at.atmosynth.performance - Lexicon Garden

Kind	record
Record key	tid
Authority	atmosynth.at
Indexed	3d ago · 2026-11-07

Record

record · key tid

Properties

audio

requiredarray

What it sounded like, lossless, in pieces heard one after another with no gap between them, together lasting `length`. Every note and change sounds where the timeline puts it, which is when the room had it happen and not when any one device heard it. It is what an app plays that has no engine; the timeline is what an app with one plays through the patch. The two are the same performance.

minLength: 1
maxLength: 256

itemsblob

maxSize: 52428800
accept: audio/wav, audio/flac

createdAt

requiredstring · datetime

description

string

maxLength: 3000

length

requiredinteger

How long it lasts, in microseconds. Every time in a performance is in microseconds, counted from its beginning, on the clock it was played on: in a room the room's, so that two people who kept the same stretch kept the same moments, whenever each of them heard them.

minimum: 1

license

ref

Reference

at.atmosynth.defs#license

lineage

array

What it came from beyond its own patch, whose instruments credit their makers in the patch's own lineage.

maxLength: 64

itemsref

Reference

at.atmosynth.defs#lineage

loops

array

The loops already playing when it began, each at the tick it had reached: a sequencer's loop, an arranger's song, a scenes block or an automation block's lane, each on the transport as a loop is. One named here plays on from that tick; one not named was stopped. Optional: absent is every loop stopped.

maxLength: 256

itemsref

Reference

#loop

name

requiredstring

minLength: 1
maxLength: 200

patch

requiredunknown

The patch as it stood when the performance began: an at.atmosynth.patch record, `$type` and all, held here whole, so the performance plays without reading anything else. Played in a room it is the room's patch, unpublished changes included. The timeline's changes are made to it in order: the patch at any moment is this one with every change before that moment made.

patchPresentation

unknown

How `patch` was drawn when the performance began: an at.atmosynth.patchPresentation record, `$type` and all, held here whole beside it. Nothing heard depends on it, and a reader that only plays ignores it. Optional: absent is a patch drawn from what it says itself.

playedOn

ref

The published patch it was played on, as published when it began. It says where the performance happened, and `patch` is what was played, which may hold more than was published then. Optional permanently: absent is a patch never published.

Reference

com.atproto.repo.strongRef

players

requiredarray

Everybody who played a note or changed the sound in it, each once, and nobody else: who it credits. Each event of the timeline names one of them. Whoever recorded it is among them, since only somebody who played in a performance keeps it.

minLength: 1
maxLength: 64

itemsstring · did

startedAt

requiredstring · datetime

When it began.

timeline

requiredarray

What happened, in order: each piece a JSON array of #event, each event no earlier than the one before it, and the pieces, read one after another, the whole of it. In blobs rather than here because a long performance in a busy room outgrows a record. Replaying it through `patch` is the performance played again.

minLength: 1
maxLength: 64

itemsblob

maxSize: 52428800
accept: application/json

#changed

object

Any other change to the patch: an instance added or taken away, a wire connected or disconnected, the note plane, a pattern, a song, a scene, the tempo. Each is the whole patch as it stands after it, so a reader that can load a patch can replay every one. A change nobody can hear, such as where a block is drawn, may be left out.

Properties

patch

requiredunknown

The patch from this moment on: an at.atmosynth.patch record, `$type` and all.

patchPresentation

unknown

How the patch is drawn from this moment on: an at.atmosynth.patchPresentation record, `$type` and all, held whole. Nothing heard depends on it. Optional: absent leaves it drawn as it was before this change.

#event

object

One thing that happened in a performance, when, and who did it. Never in a record: a performance's timeline is a JSON array of these.

Properties

at

requiredinteger

When, in microseconds from the beginning, no later than the performance's `length`.

minimum: 0

by

requiredstring · did

Who: one of the performance's `players`.

what

requiredunion

One of

#played
#moved
#changed
#started
#stopped
#switched

#loop

object

One thing on the transport, playing: a sequencer's loop, an arranger's song, a scenes block, or an automation block's lane.

Properties

instanceId

requiredstring

What is playing, by its instance id in the patch: a sequencer, an arranger, a scenes block or an automation block.

minLength: 1
maxLength: 64

scene

integer

For a scenes block: the scene it was playing, by its place in the block's `scenes`. It may not be the patch's `scene`, where another had been chosen and had not yet taken over. Optional: absent is the patch's.

minimum: 0

since

string

For a scenes block: how many ticks before the beginning that scene took over, as decimal text, which is where the loops it starts from their first step count from. Optional: absent is a scene playing since before anything was counted.

maxLength: 32

tick

requiredstring

How far it had reached, 96 to the beat, as decimal text, since a loop is rarely caught on a whole tick. For a sequencer playing a loop of its own, the tick of its pattern; for anything else, ticks from its downbeat: an arranger's from its song's first beat, an automation block's into its lane, a scenes block's from the downbeat its lines are counted from, and a sequencer an arranger or a scenes block chooses the loops of from its own.

maxLength: 32

#moved

object

One parameter of one instance set, as a turn of a knob sets it: the patch's `parameterValues` entry for it, from this moment on.

Properties

instanceId

requiredstring

minLength: 1
maxLength: 64

parameterId

requiredstring

minLength: 1
maxLength: 64

useDefault

boolean

Set where the parameter goes back to its module's default, in place of a value.

value

string

The value, as text, as the patch writes one.

maxLength: 200

#played

object

A key struck or let go, as a room passes it on: what reaches the patch, after any arpeggiator of the player's own.

Properties

block

string

The Keyboard block it was played into, by instance id. Optional: absent is the player through no block.

minLength: 1
maxLength: 64

key

requiredinteger

minimum: 0
maximum: 127

velocity

requiredinteger

How hard, and nought for letting the key go.

minimum: 0
maximum: 127

#started

object

Something on the transport starting, or everything: a sequencer's loop, an arranger's song, a scenes block or an automation block's lane. The moment is when it was heard to start, not when it was asked for.

Properties

instanceId

string

The sequencer, arranger, scenes block or automation block. Optional: absent is everything on the transport in the patch.

minLength: 1
maxLength: 64

tick

requiredstring

How far it starts from at this moment, 96 to the beat, as decimal text, as a loop's `tick` says it: a song started from a section starts from that section's first tick.

maxLength: 32

#stopped

object

Something on the transport stopping, or everything.

Properties

instanceId

string

The sequencer, arranger, scenes block or automation block. Optional: absent is everything on the transport in the patch.

minLength: 1
maxLength: 64

#switched

object

A scene taking over on a scenes block. The moment is when it was heard to take over, on the line the block's launch put it on, not when it was chosen: choosing it was a change to the patch's `scene`, a `#changed` at the moment it was chosen.

Properties

instanceId

requiredstring

The scenes block.

minLength: 1
maxLength: 64

scene

requiredinteger

The scene taking over, by its place in the block's `scenes` at this moment.

minimum: 0

tick

requiredstring

Where on the scenes block it takes over, in ticks from its downbeat, 96 to the beat, as decimal text: the line it was heard on.

maxLength: 32

Similar lexicons

semantic match

Lexicons whose schemas describe something close to this one. Check them before publishing a new one that overlaps.

at.atmosynth.defs

What the arrangement, its tracks, its clips, its effect chains, its samples and the parts offered to it share: musical time, credit, reuse, and the objects an arrangement holds inline and every one of them also publishes as a record of its own. Time here is counted in ticks, 960 to the beat, a beat being a quarter note whatever the meter says. A patch's own patterns keep the 96 to the beat the patch description counts in, so a pattern copied into a clip is multiplied by ten and loses nothing.
at.atmosynth.arrangement
record

An arrangement: tracks of clips over one timeline, mixed through busses into a master, with the tempo, the meter and the key it is counted in. Its instruments and effects are patches held inside it whole, and what it took from other people's records it holds as copies that remember where they came from. Parts that other people wrote for it in their own repositories are included by address.
at.atmosynth.patch
record

A synth patch: which modules it uses, how they are wired, what their parameters are set to, and how it is played. A patch plus the module records it pins is everything needed to reproduce it.
at.atmosynth.sample
record

A recording published to be found and used: a one-shot, a loop or a longer take, with what is known of its time and pitch. A recording used only inside an arrangement is a blob of that arrangement and needs no record; this is for sharing one.
at.atmosynth.part
record

Tracks written for somebody else's arrangement, held in the repository of whoever wrote them. Nobody can write into another account's repository, so a contribution is offered rather than added: it names the arrangement it is for, and becomes part of that arrangement only when the arrangement's creator includes it by address. It stays its writer's, under their name, and what they change in it changes what the arrangement plays.