noe/arthur

Your Name 2dc5735ded The timeline opens the whole document

Making a lane one row cost the thing a row was for. A clip stopped being a row,
so there was no longer any way to open a clip and see what was inside it, and
the inside of a drawing — the most ordinary thing in the document — became
reachable only by opening it as its own tab. This is that capability back,
from the root timeline, down as far as it goes.

An expanded lane opens exactly ONE clip: the selected one. Its own keys, then
the lanes and nodes of the symbol it places, then theirs, each mapped into this
ruler by the recursive walk that was already there. Twelve clips in a lane
still cost one row, and inspection costs one branch rather than twelve.

Two things that only showed up once it ran. The portal is chosen by the whole
LINEAGE of the selection and not by the selected id: selecting a shape inside
the clip — or the end of its span — is still working inside that clip, and
matching the id alone shut the portal the instant anything under it was
touched. And selecting now waits for the pointer to come UP, because selecting
on the way down re-drew the timeline before the gesture had said anything: it
shut the portal holding the lane being dragged INTO, out from under the
pointer.

A HELD clip opens too, which the old row walk never did either. `source-time`
is nil for a hold, so the walk stopped there and the contents of every drawing
were invisible from here. Its rows are shown across the hold — which is when
the node is on screen — and marked `:unmapped?`: no keys, and no draggable
edges, because a frozen clock gives no frame inside it a place on this ruler.
Refusing to place the keys is the honest half; refusing to show the rows was
not.

Double-clicking a clip opens the symbol it places as a tab, as double-clicking
the same symbol in the pool does. That was already written and had never once
run: the track captures the pointer for a slide, so the click and double-click
that follow are delivered to the track and never to the block. The track now
resolves them itself. Fixing the delivery exposed two more: `symbol/lineage`
reported a `parent cycle` for any id in a symbol with NO nodes, because a
one-element chain is longer than zero nodes — and opening a symbol left the
selection pointing into the symbol being left, which the breadcrumb and the
inspector then tried to resolve. The editor unmounted. Both are fixed where
they were wrong, and the browser test asserts the editor is still standing
afterwards.

Audio is a clip in a lane like everything else. A dropped sound lands in one
and is trimmed and moved by the same commands; a lane holds picture or sound
and not both, which is the explicit capability the model asked for rather than
a guess per frame. The refusal lives in the commands and not only in
validation, because placement claims time: `blank` would have deleted the
sound to make room for the picture and left a perfectly valid document behind.
What is in a lane of the open symbol is drawn as a lane; what is nested inside
a placed symbol is still flattened by `audio-tracks`, so no sound is on two
rows.

Everything that enters the timeline now enters a lane: a converted take, a
symbol brought in from another project, a sound. One rule answers where —
`lane-destination` — and every symbol is born with a lane for it to answer
with. An unaimed drop fills an EMPTY lane rather than taking an occupied one
nobody pointed at, because the alternative is trimming away what was there to
make room for what was dropped.

Shift during a clip-body drag means the other intention: put this node INSIDE
the symbol the clip under the pointer places, through `nest/move-node`, which
is what keeps the world transform and the root timing. Overlap cannot say
which of the two is meant — dropping on occupied time already means claiming
it — so the person says, and a label by the pointer says it back. The label
asks `nest/move-refusal`, the same check the command makes, so it cannot
promise what the drop would refuse. Today it refuses more than it allows:
both clips have to be on screen at one frame, which two clips in one lane
never are, and a held destination has no clock to move through at all.
`docs/lane-nesting-notes.md` argues that the second refusal is stronger than
the facts require and says what would settle it.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

2026-10-01 16:13:02 -04:00

15 KiB

Raw Blame History

Lane and symbol-clip handoff

Status (2026-10-01): the timeline is the one timing interface. A lane is a generic non-overlapping row of symbol clips; it is not a special drawing type. Dropping a library symbol makes a naturally playing clip, while creating a new empty symbol makes a one-frame held clip at the playhead. With no destination lane, either operation creates one. Existing legacy root symbol rows can be dragged into a lane. Blocks move by mouse; edge drags claim time by trimming neighbors; Shift-edge drags ripple every later clip; and the center of a shared cut composes the two edge edits into a rolling edit. Linked audio follows picture moves while its edges remain independently trimmable.

The commits beginning at 3d3c1bb are the argument for the model and are worth reading before touching what they did — they are the design record, more than this file is.

3d3c1bb  An occurrence is a node, with a clock of its own
9446829  Reuse, duplicate and make unique: deciding what is shared
26517af  A position is an argument, not another command
94c0a21  A correction is a layer, and a layer's values are a channel
72b57e3  Regenerate the base, keep the hand work, and say when you cannot
76106d3  The shot is as long as somebody said it was
598c186  One word for one thing: it is a cel

Read first, in this order

The Lane Model — the design, and the status note under Proof obligations says what is built. It supersedes animation-model.md, timing-model.md and architecture.md wherever they overlap.
frontend/src/arthur/domain/lane.cljs — every command, and the reasoning in its docstrings.
frontend/test/arthur/domain/lane_test.cljs — what the model is asserted to do. It is the fastest way to see the shapes.
frontend/src/arthur/domain/channel.cljs, the correction-layer section.

Vocabulary — one word for one thing

Renamed in 598c186, after four words had accumulated for one object. Use these and do not reintroduce the others.

word	means
instance	the `:kind`. The general thing, anywhere in a document
clip	an instance in a lane. It can hold one source frame or play a symbol naturally
cel	specifically a one-frame source held over a clip's duration; the empty-symbol/drawing creation policy
lane	a group with `:layout :sequence`
drawing	content authored into a symbol; not a different timeline node type
placement	ONLY where a node sits: `nest/placement`, and the transform that puts a face on the stage. Never the node itself

occurrence and exposure are not words for a cel. exposure means something else and still does: :time :expose is how many frames each step of a subtree lasts, which is what shooting on twos is — node/expose, clock/exposed-frame, subs/render ::exposure. Keeping these apart is why the block is called a cel.

:layout :sequence stays as the field, and is the one place two words are kept on purpose: the layout names the RULE — children follow one another and may not overlap — and a group carrying it is called a lane. node/lane? is where they meet.

Decisions already made — do not re-litigate

These were each argued out and are load-bearing. Changing one is a design decision, not a cleanup.

The shot length is authored. :frames is the symbol's window; the occupied extent of its lanes is a different fact derived from the cels. A command grows the window only when the caller passes :extent :grow-symbol, and never shrinks it. Blanking the end of a shot leaves empty frames at the end, because deriving the window from the extent would make deleting the last drawing silently shorten the film. lane/finish.
Placing ripples; overwrite is blank then non-rippling placement. lane/overwrite-drawing composes those pieces as one transaction. Insertion retains its ripple rule; overwrite does not move any surviving cel.
A position inside a cel refuses and names split. One command must not quietly perform two. The UI offers the retry.
A correction has no time space of its own. Its :support and its values' keys are in the frames the base channel's keys are in — the node's. A correction on a lane is in lane frames and reaches across the drawings under it; one on a cel travels with that cel. Ownership already answered it.
A layer's values are a channel. Constant, ramp and return motion are one mechanism. Do not add a second way to say what a value is over time.
A conflict is not a problem. A document whose topology outgrew a correction loads, evaluates and saves; clip/conflicts lists the decisions waiting for a person. problems means the document will not load.
Refuse rather than guess. Every command returns {:clip :selection} or {:refused why}, never a half-applied edit. Where the model needs a choice nobody has made, refusing and saying why is the behaviour, not a placeholder.
A clip is not a row. Rows, expansion and selection are editor state. The document has never known about rows and must not learn — which is what let the row model change three times in one sitting (blocks, then a selected-clip portal, then sound lanes under the audio heading) without touching a single document.
A lane is generic. Drawing creation, library placement, and adopting an existing root instance all produce the same child instance shape. The only difference is playback policy: a new empty drawing holds source frame zero; a dropped library symbol plays at speed one.
Every symbol is born with a lane, clip/lane-node, id :lane. A symbol with none had nowhere to drop a thing, which made the first drop into any symbol a special case. An unaimed drop fills an EMPTY lane that is already there and otherwise makes a new one; it never takes an occupied lane nobody pointed at, because placement claims time and would trim or delete what was in it.
Placement claims time. Lanes never store overlaps. A new or extended clip trims, removes, or splits whatever previously owned the claimed interval. Real compositing overlap uses another lane, where ordering remains explicit.

The timeline opens the whole document

Expanding a lane opens exactly one clip — the selected one — and that portal opens the lanes and nodes of the symbol it places, recursively, mapped into the open symbol's ruler. The portal follows the LINEAGE of the selection, so working on something nested keeps the rows that revealed it open. A held clip opens too, with its rows marked :unmapped?: shown across the hold, with no keys and no draggable edges, because a frozen clock gives its frames no place on this ruler. docs/lane-nesting-notes.md has the reasoning and what is still missing.

Double-clicking a clip opens the symbol it places as a tab, the same as double-clicking that symbol in the pool. Shift while dragging a clip body turns the temporal move into a structural one — see the nesting notes for why that is mostly refused today.

Current timeline interaction

Creating a symbol inside an aimed lane creates a one-frame held clip at the playhead. With no aimed lane it first creates a lane. Drawing a polygon uses the existing clip there or creates the same one-frame clip when the frame is empty.
Dropping any library symbol into a lane creates a natural-duration playing clip. Dropping it on unclaimed timeline or stage space first creates a lane.
Dragging a clip body moves it. A linked audio node follows a picture move; moving or trimming the audio itself remains independent.
Dragging a right edge changes its endpoint. Growth consumes adjacent spans instead of overlapping them. Shift-drag inserts or removes lane time by moving every later clip by the same delta.
At a shared boundary, the left and right hit zones trim one side. The center is a rolling edit: right-edge resize followed by left-edge resize at one frame.
Split, trim-in, and trim-out are direct buttons and are disabled without an editable selected span. Movement is a mouse gesture, not a toolbar command.

Next steps, in order

The implemented correction slice and its remaining UI limits are recorded in Correction authoring.

Slip source and retime. Both have real design questions open and the doc says to refuse rather than approximate: retime needs a defined warp and interpolation behaviour, and is not moving keys whose numbers happen to fall inside a selection.
Deleting reused content. Reference discovery exists (node/sources, clip/places, clip/contains-symbol?); the policy does not.
Displayed-range correction gestures. The first correction panel asks for explicit owner frames. Dragging a range in a retimed/nested view still needs a proved mapping; do not make it snap through floors or loops.
Collaboration. lane-model.md is explicit that one leaf per channel does NOT solve two people editing different keys of the same channel. No conflict policy exists for that.

Mechanisms to reuse — these keep paying out

:span is in the node's OWN frames and :time says where they land in the lane. Moving an edge of a cel is therefore one write to :span, with :time and :playback untouched. This is why split costs nothing, why the two halves of a split go on meaning what the one cel meant, why trimming the front of a playing insert starts it later into its animation instead of restarting it, and why extending a hold leaves lane keys alone. lane/local and lane/edged are the whole geometry; trim, split and blank are all it.
lane/finish is the one commit path: it validates, applies the shot-length policy, and returns the refusal. New commands go through it.
:required-frames plus the retry event is the pattern for "this needs a decision you have not made": the domain reports what it would need, the UI offers one button. events/ui/lane-retry.
lane/lane-frame converts a symbol frame to a lane frame, or returns nil through a stepped or looping lane where there is no single answer. Nil refuses; it never snaps.
channel/conflict-with is the rule for whether one offset fits a base, used by conflicts and regeneration. Validation additionally follows prior replacement layers, so it cannot approve a stack that throws when read.
Generated sampling applies to the base, not the hand correction. Picture rate and pose selection may choose an earlier generated frame; correction support and values still read the node's current authored frame.
Correction commands live in domain/correction.cljs. IDs come from the event caller; the pure command materializes default transform channels, appends one layer, and validates the complete document. The inspector authors rotation and position offsets in explicit owner frames. One Apply is one undo step. channel/reconcile is the shared ordered-stack compatibility rule used by validation, conflict reporting, and regeneration.
Two test patterns worth copying. the-cursor-agrees-with-the-specification-in-any-frame-order holds the optimized cursor to value-at in forward, backward and random order — add a case to it for any new channel shape. And drawn in lane_test samples every frame before and after an edit, which is how split and trim are proved to change nothing: state a claim as "the same picture" rather than as numbers computed by hand.

Known gaps and traps

Audio is a clip in a lane too, and a lane holds one kind. A sound placed from the pool lands in a lane and is moved and trimmed by the same commands as picture. The capability the earlier note asked for is the homogeneity rule rather than a field: symbol/lane-problems refuses a lane holding both kinds, and lane/place-symbol and lane/adopt refuse BEFORE claiming time, because placement claims time and would otherwise have deleted the sound to make room for the picture and left a valid document behind. Audio nested inside a placed symbol — a take's own sound — is still shown flattened by nest/audio-tracks; what is in a lane of the open symbol is drawn as a lane and not flattened twice.
:z is required on cels and means nothing there. A lane never has two cels on one frame, so draw order between them cannot matter. node/problems requires :z on every node uniformly, which is its own kind of simplicity — but the field is noise on a cel.
channel/offset-onto throws on a shape mismatch that no regeneration has recorded as a conflict. That is deliberate — a correction that silently does not take is the failure the design exists to prevent, and channel/problems catches the authored case — but it is a throw in the read path, so any new producer of layers must not create a mismatched one.
docs/timing-handoff.md is a separate, unreconciled thread. Performance- pose selection and plate drawings/tracing, instance-specific picture-rate requests, pose/put-cut addressing only :main. It predates the lane model and nobody has squared the two.
Slip and retime are still absent. The timeline action strip now applies split/trim uniformly to a selected root or lane clip, but source-time slip and retime still need their own proved semantics before they become controls.
shadow-cljs release app clobbers the dev bundle. Both builds write ../static/arthur/js, which Django serves, and the optimized build does not export the arthur global — so after a release the browser tests fail with ReferenceError: arthur is not defined. Run npx shadow-cljs compile app to restore it. A running watch app does not notice; it rebuilds on the next source change.

Running it

From frontend/:

npx shadow-cljs compile test && node out/node-tests.js     # 469 tests, 9,592 assertions
npx shadow-cljs compile app                                # the bundle Django serves
npx shadow-cljs release app                                # then `compile app` again — see above

The browser tests need the Django dev server up (mise exec -- python manage.py runserver 8778 from the repo root) and a compiled dev bundle:

node --experimental-websocket test/browser/lane.mjs                  # generic symbol-lane flow
CHROME=/usr/bin/chromium node --experimental-websocket test/browser/take.mjs

take.mjs defaults to a macOS Chrome path, hence CHROME=. It writes a real project to the local server by design; lane.mjs never writes to the server.

From the repo root: mise exec -- python manage.py test clips — 56 tests.

Documents are schema 3. A version 2 document is not read and nothing converts one; there is no backward compatibility to preserve anywhere in this work.

15 KiB Raw Blame History