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.

CacheStats

Every lookup in order, and the store as the render left it.

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 stages, and only persist commits each value whole by rename, evicting the least recently used past the budget. Every change to the backend’s names runs under its lock; lookups and reads never wait on it.

Stream

A target rendered block by block off one table. The target may read @notes, the sum of the terms added under handles. A node the store answers plays from its samples. A hit is looked up once; a node reading the stream’s own note sum never, as no store holds one.

Target

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

Tempo

Warmed

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 bytes. A put is whole or absent: no reader sees half of one.

Through

A store, or nothing, that a render looks a node up in and reads its samples from.

Functions

add

term summed into the stream’s @notes.

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. Each edit here is sva_engine::change’s: the stream plays on meanwhile.

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.

remove

False where the stream no longer holds handle.

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.

warm

Readings, where asked, are execute_through’s, the root computed for them.

wav_path

work_json

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