Crate sva_core 

Modules

encode

json

Structs

Answer

Every answer says which reading ran and under which profile, so a caller never has to infer either from the shape of the value.

Asked

A call resolved to the reading it names and the arguments only a front end reads.

Builtins

Cache

Every value a render computed and chose to keep, under its content hash. A hit is the value the cold run wrote, so what is kept or evicted decides only what is computed again. A clone is a handle on the same store, which a stream holds for as long as it plays.

Call

One reading written as a call, spectrum(peaks=8, frame=50ms)=out.json: its name, its arguments as written, and where it goes.

Callable

Crossing

One written cast, and every representation it takes to which.

Diagnostic

One located finding. No fix field: an edit needs a span, and no written literal carries one.

Extent

Samples [start, end) of the one grid every node is read on, whose sample 0 is t = 0.

Handle

Job

One render: target an expression over the composition source holds, its own ref read over an interval where it writes one.

Label

LintViolation

One lint finding: its code, how hard it lands, and the node it is against.

NoStore

Persisted

Printed

One answer as a report prints it.

QuietTail

Seconds in the instance’s own time.

Rendered

Report

What a render answered with, and where anything too big for the object went instead.

Store

Node values under their keys. A render reads through it and spills what it computes to the staging area; only persist changes the store, committing each staged value whole by rename, least recently used going first past the budget.

Stream

A target rendered block by block off one table. The target may read @notes, the sum of the terms added under handles; an edit to it or to a term plays from the next block on. Opening and each edit look store up first, as a render through it does.

Target

The expression with its interval read as t, and that interval’s two ends.

Tempo

Enums

CachePolicy

Which values a render stores; whatever is not stored is computed again when asked.

CliError

Every expected failure mode this crate can hit; none of them a panic.

Edge

One end of an interval, in the units it was written in; a bare zero is zero in all of them.

LintCode

Every shape lint reports. A caller dispatches on the tag, so the tag is the contract and the variant is how this workspace spells it.

Output

PrunePolicy

Representation

Severity

Until

Comparisons over t and the measured level, joined by and and or.

Constants

DEFAULT_LEDGER_DEPTH

DEFAULT_MAX_PEAKS

DEFAULT_OVERSAMPLE

DEFAULT_STORE_BYTES

PROBE

REPRESENTATIONS

RESERVED_VARIABLES

Read by name rather than through a ref.

RETIRED

ROOT

SAMPLE_LIMIT

Past this a caller reading stdout wants a later interval start, not a wall of JSON.

Traits

Backend

Named byte storage. A put is whole or absent: no reader ever sees half of one.

Through

What a stream looks a node up in before typing it: a store, or nothing at all.

Functions

add

term summed into the stream’s @notes from its next block on.

answer_json

FORMAT 14.3: every answer says which reading ran, under which profile, and at what rate. A reading that truncated a series names what it left out, so the kept list is never read as the whole of it.

asked

The reading a call names, each argument read as that reading takes it.

builtins

builtins_data

call

name, name(k=v, ...), either followed by =path.

calls

A comma list of calls; a comma inside a call’s parentheses separates its arguments.

cwd

define_probe_for

Argv math: trace and lint each refuse a target no node answers for here, under one code and one message.

diagnostics_json

edit

target, an expression over source with no interval of its own, in place of what stream plays from its next block on.

error_envelope

data.diagnostics is always present, empty where the failure has no subject to locate.

execute

execute_through

execute reading through store in place of job’s own cache; only persist writes it.

is_wav

label_json

The collapse label beside the reading it belongs to, per FORMAT 9.3. detail is the one place a key may be absent: each rule is its own shape, and its fields belong to it.

lint_diagnostic

The one place a lint code becomes a diagnostic, so both of lint’s response paths namespace it, locate it and help against it identically.

outline_data

{ "text", "outline" }, or the parser’s own refusal, located in the text.

plan

prepared

probe

query_data

written names every reading that went to a file rather than into representations.

quiet_tails

The target is no file to crop, so it is not among them.

refuse_unresolved_bars

A b literal without a tempo refuses rather than defaulting to some seconds-per-bar.

replace

False where the stream no longer holds handle.

retired

roots_of

A node path the source answers for is a node; anything else is math, and its reads are roots. Only a node path is asked of the source: math is never looked up as a file.

seconds

A positive time the language spells, 50ms or 1.5s; a bare number is seconds.

settled

stats_json

computed counts every miss, stored the misses the store kept and replaced the volatile misses kept in place of their last value; the store’s figures are as the render left it.

stream

stream_stats_json

stats_json, and dropped: each node a live stream’s edits started silent.

success_envelope

target

An interval is the argument of the target’s own ref, @a([0, 2b], vel=0.5): nowhere else. A [ right after a ref or self reads an index, which the expression grammar owns.

tempo

None when the composition declares neither bpm nor meter.

types

Every refusal typing the target reaches, and no render’s.

until

t in seconds is compared with times, a level with levels; and binds tighter than or.

value_json

limit caps the arrays a stdout reader scrolls past; None writes every value. skim only changes the ledger.

wav_path

work_json

Whole counts every one; waves is null where a node’s go uncounted.