@tangle-network/agent-app 0.45.53 → 0.45.55

package/dist/sequences/store.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Storage contract binding the sequence model to a product's database. The
+ * product constructs one store per (workspace, sequence, actor) request scope —
+ * RBAC and workspace isolation happen BEFORE construction (the product's
+ * `requireWorkspaceAccess` equivalent); the store never re-checks identity.
+ *
+ * Every method throws on failure — no silent nulls, no `{ ok: false }` wrappers
+ * at this layer. The MCP dispatcher (./mcp) is the boundary that converts
+ * thrown errors into structured tool errors the model can read and react to.
+ *
+ * Mutations append to the decision log themselves only when the operation
+ * dispatcher asks (`recordDecision`); plain CRUD stays log-free so human edits
+ * driven by the UI can batch their own decision entries.
+ */
+import type { SequenceClip, SequenceDecision, SequenceExportFormat, SequenceExportRecord, SequenceMeta, SequenceTimeline, SequenceTrack, SequenceTrackKind } from './model';
+/** Define properties for a new sequence track including kind, name, and optional sort order */
+export interface NewSequenceTrack {
+    kind: SequenceTrackKind;
+    name: string;
+    sortOrder?: number;
+}
+/** Define properties for a new sequence clip including timing, labels, and optional metadata */
+export interface NewSequenceClip {
+    trackId: string;
+    label: string;
+    startFrame: number;
+    durationFrames: number;
+    sourceInFrame?: number;
+    sourceOutFrame?: number | null;
+    text?: string;
+    language?: string;
+    generationId?: string;
+    assetId?: string;
+    metadata?: Record<string, unknown>;
+}
+/** Define optional properties to update or patch a sequence clip's attributes in a timeline */
+export interface SequenceClipPatch {
+    trackId?: string;
+    label?: string;
+    startFrame?: number;
+    durationFrames?: number;
+    sourceInFrame?: number;
+    sourceOutFrame?: number | null;
+    disabled?: boolean;
+    text?: string;
+    language?: string;
+    metadata?: Record<string, unknown>;
+}
+/** Define the structure for a new sequence decision with optional metadata and acceptance status */
+export interface NewSequenceDecision {
+    clipId?: string | null;
+    kind: SequenceDecision['kind'];
+    instruction: string;
+    reasoningSummary?: string | null;
+    accepted?: boolean | null;
+    metadata?: Record<string, unknown>;
+}
+/** Manage sequences by providing methods to get timelines, clips, and modify tracks and clips */
+export interface SequenceStore {
+    /** Full aggregate: sequence meta + tracks + clips with resolved media. */
+    getTimeline(): Promise<SequenceTimeline>;
+    getClip(clipId: string): Promise<SequenceClip>;
+    createTrack(input: NewSequenceTrack): Promise<SequenceTrack>;
+    createClip(input: NewSequenceClip): Promise<SequenceClip>;
+    updateClip(clipId: string, patch: SequenceClipPatch): Promise<SequenceClip>;
+    deleteClip(clipId: string): Promise<void>;
+    /** Grow (or shrink, never below the last clip end) the sequence duration. */
+    updateSequenceDuration(durationFrames: number): Promise<SequenceMeta>;
+    recordDecision(input: NewSequenceDecision): Promise<SequenceDecision>;
+    createExport(format: SequenceExportFormat, metadata?: Record<string, unknown>): Promise<SequenceExportRecord>;
+    listDecisions(limit?: number): Promise<SequenceDecision[]>;
+    listExports(limit?: number): Promise<SequenceExportRecord[]>;
+}
+/** Per-request scope a product binds when constructing its store. Carried so
+ *  decision rows and export rows attribute to the acting user; never trusted
+ *  from tool arguments. */
+export interface SequenceStoreScope {
+    workspaceId: string;
+    sequenceId: string;
+    userId: string;
+}

package/dist/sequences/validate.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Pre-write validation for sequence operations. Every rule runs against a
+ * `SequenceTimeline` snapshot BEFORE any `SequenceStore` write, so a rejected
+ * plan leaves no partial state. Batch errors carry the shape
+ * `operation N (type): reason` — precise enough for an LLM planner to repair
+ * the offending operation and resubmit.
+ *
+ * The resolution helpers (`resolvePlaceClipTrack`, `resolveCaptionTarget`,
+ * `resolveCaptionPlacement`) are shared with ./apply so validation and
+ * application cannot disagree about which track or bounds an operation lands
+ * on.
+ *
+ * Validation is static: a batch is checked against the timeline as given, so
+ * an operation may not reference entities created by an earlier operation in
+ * the same batch. Dispatchers that chain operations must refresh the timeline
+ * between applications and validate per-operation.
+ */
+import type { SequenceTimeline, SequenceTrack, TimelineClipBounds } from './model';
+import type { AddCaptionOperation, CreateTrackOperation, DeleteClipOperation, ExtendSequenceOperation, MoveClipOperation, PlaceClipOperation, QueueExportOperation, SequenceOperation, SetClipDisabledOperation, SetClipTextOperation, SplitClipOperation, TrimClipOperation } from './operations';
+/** Editor/agent context an operation is resolved against. `playheadFrame` is
+ *  the implicit position for omitted caption placement; never persisted. */
+export interface SequenceOperationContext {
+    playheadFrame: number;
+}
+/** Validate each operation in a sequence against the timeline and context, throwing detailed errors on failure */
+export declare function validateSequenceOperations(timeline: SequenceTimeline, operations: SequenceOperation[], ctx: SequenceOperationContext): void;
+/** Validate a sequence operation against the timeline and context to ensure correctness */
+export declare function validateSequenceOperation(timeline: SequenceTimeline, operation: SequenceOperation, ctx: SequenceOperationContext): void;
+/** Validate the properties and constraints of a PlaceClipOperation within a SequenceTimeline */
+export declare function validatePlaceClip(timeline: SequenceTimeline, operation: PlaceClipOperation): void;
+/** Validate the parameters and context of an AddCaptionOperation within a sequence timeline */
+export declare function validateAddCaption(timeline: SequenceTimeline, operation: AddCaptionOperation, ctx: SequenceOperationContext): void;
+/** Validate that a clip move operation is within bounds and targets a compatible unlocked track */
+export declare function validateMoveClip(timeline: SequenceTimeline, operation: MoveClipOperation): void;
+/** Validate that a trim clip operation respects timeline bounds and source frame constraints */
+export declare function validateTrimClip(timeline: SequenceTimeline, operation: TrimClipOperation): void;
+/** Validate that a split operation on a clip is within valid frame boundaries and conditions */
+export declare function validateSplitClip(timeline: SequenceTimeline, operation: SplitClipOperation): void;
+/** Validate that a SetClipTextOperation targets a caption clip with non-empty text and valid language tag */
+export declare function validateSetClipText(timeline: SequenceTimeline, operation: SetClipTextOperation): void;
+/** Validate that the clip can be disabled within the given timeline and operation constraints */
+export declare function validateSetClipDisabled(timeline: SequenceTimeline, operation: SetClipDisabledOperation): void;
+/** Validate that the clip to delete exists and is mutable in the given timeline */
+export declare function validateDeleteClip(timeline: SequenceTimeline, operation: DeleteClipOperation): void;
+/** Validate that a CreateTrackOperation has a supported kind and a non-empty name */
+export declare function validateCreateTrack(operation: CreateTrackOperation): void;
+/** Validate that the extend sequence operation has a positive duration and exceeds the last clip end frame */
+export declare function validateExtendSequence(timeline: SequenceTimeline, operation: ExtendSequenceOperation): void;
+/** Validate that the queue export operation uses a supported export format */
+export declare function validateQueueExport(operation: QueueExportOperation): void;
+/**
+ * Shape-gate untrusted JSON (a product's `onApplyOperations` route body) into
+ * `SequenceOperation[]` BEFORE `validateSequenceOperations` sees it. The
+ * validator assumes well-typed fields (`label.trim()` on a number is a raw
+ * TypeError → 500); this parser turns junk into a thrown Error naming the
+ * operation index and field so the route can answer 400 with an actionable
+ * reason. Unknown fields are dropped — only vocabulary fields reach the
+ * validator and store.
+ */
+export declare function parseSequenceOperations(input: unknown): SequenceOperation[];
+/** Resolve caption target by specifying an existing track or creating a new one with language and name */
+export type CaptionTargetResolution = {
+    kind: 'existing';
+    track: SequenceTrack;
+} | {
+    kind: 'create';
+    language: string;
+    name: string;
+};
+/** Naming convention for auto-created per-language caption tracks. The name
+ *  doubles as the recognition rule because `SequenceStore.createTrack` cannot
+ *  persist track metadata — matching by `metadata.language` alone would never
+ *  find tracks this module created. */
+export declare function captionTrackNameForLanguage(language: string): string;
+/** Target track for a `place_clip`. Video and image media land on video
+ *  tracks, audio media on audio tracks; a `reference` track is valid only when
+ *  targeted explicitly. Media-less clips (placeholders, agent markers) need an
+ *  explicit trackId because no kind can be inferred. */
+export declare function resolvePlaceClipTrack(timeline: SequenceTimeline, operation: PlaceClipOperation): SequenceTrack;
+/** Target caption track for an `add_caption`. With `language` set and no
+ *  matching caption track, resolution returns a `create` instruction the apply
+ *  layer turns into a real track — a locked matching track is an error, never
+ *  a silent duplicate. */
+export declare function resolveCaptionTarget(timeline: SequenceTimeline, operation: AddCaptionOperation): CaptionTargetResolution;
+/** Caption bounds. Fully omitted placement slides past occupied intervals via
+ *  `chooseCaptionPlacement`; a partially explicit placement fills the missing
+ *  half deterministically (startFrame ← playhead, durationFrames ← fps*3) and
+ *  must pass the caller's bounds check — no collision slide. */
+export declare function resolveCaptionPlacement(timeline: SequenceTimeline, operation: AddCaptionOperation, ctx: SequenceOperationContext, targetTrackId: string | null): TimelineClipBounds;
+/** Last occupied frame across all clips — the floor for `extend_sequence`. */
+export declare function lastClipEndFrame(timeline: SequenceTimeline): number;
+/** Media references must be provider URLs or app-served paths. Local sandbox
+ *  artifacts (file:, data:, /tmp/, /home/) are rejected because they are
+ *  unreachable from the product and signal an agent substituting local ffmpeg
+ *  output for real provider generation. Delegates to the canonical
+ *  `assertMediaUrl` boundary in `../web` — sequences and design-canvas share ONE
+ *  rule so the two surfaces cannot drift on what counts as a reachable url. */
+export declare function assertSequenceMediaUrl(url: string): void;

package/dist/sequences-react/components/BrandMark.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Load the canonical Tangle knot only when a sequence surface renders it.
+ * `/brand` imports the optional `@tangle-network/brand` peer, so a failed load
+ * renders a fixed-size spacer instead of crashing the editor.
+ */
+export interface BrandMarkProps {
+    size: number;
+    className?: string;
+}
+export declare function BrandMark({ size, className }: BrandMarkProps): import("react").JSX.Element;

package/dist/sequences-react/components/PreviewCanvas.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Program monitor: a canvas letterboxed to the sequence aspect that paints
+ * the playhead frame — black base, the topmost enabled video-track clip via
+ * `frameProvider.drawFrame`, then caption text bottom-centered on an 80%
+ * black backing bar with type scaled to canvas height / 18.
+ *
+ * Track stacking: tracks composite bottom-up, so among clips active at the
+ * frame the one on the HIGHEST sortOrder track covers the rest; muted tracks
+ * do not render. Only `video` tracks paint — `reference` tracks are
+ * non-rendered guide media (model contract) and are excluded from mp4/EDL/
+ * contact-sheet export, so painting them would preview content the program
+ * output does not contain. Paints serialize through a latest-wins queue —
+ * decode is async, so a slow seek never paints over a newer frame.
+ *
+ * `sourceSeconds` = (sourceInFrame + playhead offset into the clip) / fps:
+ * the model maps source frames 1:1 at sequence fps.
+ */
+import type { SequenceTimeline } from '../../sequences/model';
+import type { PlaybackClock, VideoFrameProvider } from '../contracts';
+export interface PreviewCanvasProps {
+    timeline: SequenceTimeline;
+    clock: PlaybackClock;
+    frameProvider: VideoFrameProvider;
+    className?: string;
+}
+export declare function PreviewCanvas({ timeline, clock, frameProvider, className }: PreviewCanvasProps): import("react").JSX.Element;

package/dist/sequences-react/components/SnapIndicatorLine.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Vertical accent line at the frame an in-flight drag is snapped to. Rendered
+ * inside the horizontally-scrolled track area so its x position is plain
+ * frame * zoom; visibility is owned by the editor (non-null point = visible).
+ */
+import type { SnapPoint } from '../contracts';
+export interface SnapIndicatorLineProps {
+    point: SnapPoint | null;
+    zoom: number;
+}
+export declare function SnapIndicatorLine({ point, zoom }: SnapIndicatorLineProps): import("react").JSX.Element | null;

package/dist/sequences-react/components/TimelineClipChip.d.ts

@@ -0,0 +1,80 @@
+/**
+ * One clip on a track lane. Owns the pointer gestures that edit it:
+ *
+ * - body drag        → move (horizontal frames + vertical retarget onto another
+ *                       unlocked track of the same kind)
+ * - edge handles     → head/tail trim, clamped to MIN_SEQUENCE_CLIP_FRAMES and
+ *                       the source material bounds
+ * - double-click     → inline caption text edit (caption clips only)
+ *
+ * Gesture discipline: pointer capture on gesture start, every move quantizes
+ * to whole frames, Escape restores the pre-drag state without emitting, and a
+ * completed gesture commits EXACTLY ONCE through the `onCommit*` callbacks —
+ * the editor turns that into one command on the stack (one undo step). The
+ * chip never writes timeline state itself; until commit it renders a local
+ * preview only.
+ *
+ * Vertical retarget reads lane geometry captured at gesture start (rects of
+ * every `[data-lane-track]` under the editor's `[data-timeline-tracks]` root),
+ * so the moving chip itself can never occlude the hit test.
+ */
+import type { SequenceClip, SequenceTrack } from '../../sequences/model';
+import type { SnapPoint, VideoFrameProvider } from '../contracts';
+export interface ClipMoveCommit {
+    clipId: string;
+    startFrame: number;
+    trackId: string;
+}
+export interface ClipTrimCommit {
+    clipId: string;
+    startFrame: number;
+    durationFrames: number;
+    sourceInFrame: number;
+}
+export interface TimelineClipChipProps {
+    clip: SequenceClip;
+    track: SequenceTrack;
+    fps: number;
+    /** Pixels per frame. */
+    zoom: number;
+    sequenceDurationFrames: number;
+    selected: boolean;
+    canWrite: boolean;
+    /** Roving-tabindex: exactly one chip per editor carries tabIndex 0 so the
+     *  clip set is a single Tab stop; arrows move focus across the others. */
+    tabbable: boolean;
+    frameProvider: VideoFrameProvider;
+    /** Snap a candidate move (both clip edges considered); editor closes over
+     *  the engine's snap points. */
+    snapMove(candidate: {
+        startFrame: number;
+        durationFrames: number;
+        clipId: string;
+    }): {
+        startFrame: number;
+        point: SnapPoint | null;
+    };
+    /** Snap a single trim edge. */
+    snapEdge(candidate: {
+        frame: number;
+        clipId: string;
+    }): {
+        frame: number;
+        point: SnapPoint | null;
+    };
+    onSnapPointChange(point: SnapPoint | null): void;
+    onSelect(clipId: string, additive: boolean): void;
+    /** Keyboard delete of the focused clip (one command on the stack), routed
+     *  through the same locked-track guard as the transport Delete key. */
+    onRequestDelete(clipId: string): void;
+    /** Move keyboard focus to the previous/next clip in DOM order (roving
+     *  tabindex); the editor owns the ordered chip set. */
+    onFocusStep(clipId: string, direction: -1 | 1): void;
+    onCommitMove(input: ClipMoveCommit): void;
+    onCommitTrim(input: ClipTrimCommit): void;
+    onCommitText(input: {
+        clipId: string;
+        text: string;
+    }): void;
+}
+export declare function TimelineClipChip(props: TimelineClipChipProps): import("react").JSX.Element;

package/dist/sequences-react/components/TimelineEditor.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The timeline editor surface: program monitor, transport row, and the
+ * scrollable track area, composed over the engine (command stack, zoom math,
+ * snapping, playback clock) and media (frame provider, waveforms) layers.
+ *
+ * State ownership:
+ * - The COMMAND STACK owns the timeline. Every edit is a `TimelineCommand`
+ *   executed optimistically, then persisted via `onApplyOperations`; a
+ *   rejected persist rolls the command back locally WITHOUT emitting its
+ *   inverse (the server never saw it). A user-initiated undo/redo DOES emit
+ *   (the server applied the original), so the editor mirrors the executed
+ *   commands to know which operations an undo corresponds to — the engine
+ *   stack exposes no command identity from `undo()`.
+ * - Clip-creating commands mint optimistic `local-…` ids. When
+ *   `onApplyOperations` resolves with `SequenceApplyResult[]`, the editor
+ *   records local→server aliases that every command resolves through at
+ *   execute/undo/emission time, so undoing a committed place/split/caption
+ *   works after a server refresh. Hosts resolving void skip reconciliation;
+ *   undo of creates then fails loud (error bar) once a refresh replaced the
+ *   local ids.
+ *
+ * Captions require an unlocked caption track: the editor creates clips, never
+ * tracks. Products seed a caption track at sequence creation (or let the
+ * agent's create_track tool add one); the caption button errors otherwise.
+ * - The PLAYBACK CLOCK owns the playhead. Volatile view state (selection,
+ *   zoom, snap toggle) lives in React state; the contract's
+ *   `EditorTimelineState` view fields are initials, not a live channel.
+ *
+ * Compositing/stacking rule: `sortOrder` is paint order — later tracks paint
+ * over earlier ones in the preview; rows render top→bottom in the same order.
+ *
+ * Asset drops: lanes accept `application/x-sequence-media` payloads
+ * (JSON `{ url, kind, label?, durationSeconds?, generationId?, assetId? }`),
+ * which is how a host's `renderAssetShelf` content places media — video/image
+ * onto video tracks, audio onto audio tracks.
+ *
+ * Keyboard: space play/pause · delete/backspace removes the selection (one
+ * undo step) · mod+z undo · shift+mod+z / mod+y redo · escape cancels an
+ * in-flight drag (handled by the chips).
+ */
+import type { TimelineEditorProps } from '../contracts';
+export declare const SEQUENCE_MEDIA_DRAG_TYPE = "application/x-sequence-media";
+export declare function TimelineEditor(props: TimelineEditorProps): import("react").JSX.Element;
+export default TimelineEditor;

package/dist/sequences-react/components/TimelineEmptyState.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Resting / zero-track state for the timeline. Two jobs:
+ *
+ *  1. Keep TIME legible at rest — the ruler and labeled ghost lanes (Video /
+ *     Captions) render even with no clips, so the surface still reads as a
+ *     timeline ("a ruler WITH numbers") the moment it opens.
+ *  2. Give the first move a name — up to three doors (start from a template,
+ *     add a clip, ask the agent), branded with the Tangle knot, over the ghost
+ *     lanes. Each door renders only when the host wires its handler.
+ *
+ * The doors and copy are fully overridable through `TimelineEditorLabels`.
+ */
+import type { TimelineEditorLabels } from '../contracts';
+export interface TimelineEmptyStateProps {
+    labels?: TimelineEditorLabels;
+    brandedExport?: boolean;
+    onStartFromTemplate?(): void;
+    onAddClip?(): void;
+    onAskAgent?(): void;
+}
+export declare function TimelineEmptyState(props: TimelineEmptyStateProps): import("react").JSX.Element;

package/dist/sequences-react/components/TimelineGhostLanes.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Labeled placeholder lanes drawn behind the empty state so the surface reads
+ * as a timeline before any track exists: a "Video" lane and a "Captions" lane
+ * with the same sticky header column the real `TimelineTrackRow` uses, sized to
+ * the timeline width so the ruler's timecodes line up over real lanes. Purely
+ * decorative — no clips, no gestures.
+ */
+export interface TimelineGhostLanesProps {
+    /** Timeline pixel width (durationFrames * zoom), so ghost lanes match the ruler. */
+    laneWidth: number;
+    videoLabel: string;
+    captionLabel: string;
+}
+export declare function TimelineGhostLanes({ laneWidth, videoLabel, captionLabel }: TimelineGhostLanesProps): import("react").JSX.Element;

package/dist/sequences-react/components/TimelinePlayhead.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Playhead overlay for the track area: a full-height line with a triangular
+ * cap. Positioned in timeline pixels (frame * zoom) inside the scrolled
+ * content, so it moves with horizontal scroll for free. Pointer-transparent —
+ * scrubbing belongs to the ruler.
+ */
+export interface TimelinePlayheadProps {
+    frame: number;
+    zoom: number;
+}
+export declare function TimelinePlayhead({ frame, zoom }: TimelinePlayheadProps): import("react").JSX.Element;

package/dist/sequences-react/components/TimelineRuler.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Adaptive timecode ruler. Tick density follows zoom through
+ * `selectTickStepSeconds` (major ticks never closer than ~80px, minor ticks
+ * at a fifth of the major step when they'd sit at least 8px apart). Click or
+ * drag scrubs: the pointer is captured, every move quantizes to a whole frame,
+ * and the frame is committed through `onScrub` (the editor routes it to
+ * `PlaybackClock.seek`).
+ */
+export interface TimelineRulerProps {
+    fps: number;
+    durationFrames: number;
+    /** Pixels per frame. */
+    zoom: number;
+    onScrub(frame: number): void;
+}
+export declare function TimelineRuler({ fps, durationFrames, zoom, onScrub }: TimelineRulerProps): import("react").JSX.Element;

package/dist/sequences-react/components/TimelineSmallScreenGate.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Phone gate. The Konva preview + frame-accurate scrub/trim gestures need room;
+ * below the `sm` breakpoint a squeezed timeline is unusable, so we show a short,
+ * on-brand "best on a larger screen" panel INSTEAD of a broken editor. The real
+ * editor is rendered alongside and revealed at `sm`+ via Tailwind — this gate is
+ * `sm:hidden`, so nothing about the editor's logic, lifecycle, or tests changes.
+ */
+import type { TimelineEditorLabels } from '../contracts';
+export interface TimelineSmallScreenGateProps {
+    labels?: TimelineEditorLabels;
+}
+export declare function TimelineSmallScreenGate({ labels }: TimelineSmallScreenGateProps): import("react").JSX.Element;

package/dist/sequences-react/components/TimelineTrackRow.d.ts

@@ -0,0 +1,51 @@
+/**
+ * One track: a sticky-left header (name, kind glyph, lock/mute state) and a
+ * lane sized in timeline pixels (durationFrames * zoom) carrying a
+ * `TimelineClipChip` per clip. The lane advertises itself through
+ * `data-lane-track`/`data-lane-kind`/`data-lane-locked` — the geometry chips
+ * read for vertical drag retargeting. Clicking empty lane space seeks the
+ * playhead.
+ */
+import type { SequenceClip, SequenceTrack } from '../../sequences/model';
+import type { SnapPoint, VideoFrameProvider } from '../contracts';
+import type { ClipMoveCommit, ClipTrimCommit } from './TimelineClipChip';
+export interface TimelineTrackRowProps {
+    track: SequenceTrack;
+    clips: SequenceClip[];
+    fps: number;
+    zoom: number;
+    sequenceDurationFrames: number;
+    selectedClipIds: ReadonlySet<string>;
+    /** The single clip that carries tabIndex 0 (roving tabindex); null seeds the
+     *  first chip in the editor as the lone Tab stop. */
+    tabbableClipId: string | null;
+    canWrite: boolean;
+    frameProvider: VideoFrameProvider;
+    snapMove(candidate: {
+        startFrame: number;
+        durationFrames: number;
+        clipId: string;
+    }): {
+        startFrame: number;
+        point: SnapPoint | null;
+    };
+    snapEdge(candidate: {
+        frame: number;
+        clipId: string;
+    }): {
+        frame: number;
+        point: SnapPoint | null;
+    };
+    onSnapPointChange(point: SnapPoint | null): void;
+    onSelectClip(clipId: string, additive: boolean): void;
+    onRequestDeleteClip(clipId: string): void;
+    onFocusStepClip(clipId: string, direction: -1 | 1): void;
+    onCommitMove(input: ClipMoveCommit): void;
+    onCommitTrim(input: ClipTrimCommit): void;
+    onCommitText(input: {
+        clipId: string;
+        text: string;
+    }): void;
+    onLaneSeek(frame: number): void;
+}
+export declare function TimelineTrackRow(props: TimelineTrackRowProps): import("react").JSX.Element;

package/dist/sequences-react/components/ZoomControl.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Zoom slider mapped through `ZoomMath` so equal slider travel feels like
+ * equal zoom ratio. The slider's numeric domain is derived from the math
+ * itself (`zoomToSlider(minZoom)..zoomToSlider(maxZoom)`) — this component
+ * never assumes what scale the engine chose.
+ */
+import type { ZoomMath } from '../contracts';
+export interface ZoomControlProps {
+    zoomMath: ZoomMath;
+    zoom: number;
+    onZoomChange(zoom: number): void;
+    /** Fit-to-sequence pixels-per-frame; clicking the readout snaps back to it. */
+    fitZoom?: number;
+}
+export declare function ZoomControl({ zoomMath, zoom, onZoomChange, fitZoom }: ZoomControlProps): import("react").JSX.Element;

package/dist/sequences-react/components/composite-command.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Fuses several `TimelineCommand`s into one undo step so a single gesture
+ * (multi-select delete, drop that creates a track and places a clip) never
+ * fragments the history. Execute runs in order; undo runs in strict reverse so
+ * intermediate states reconstruct exactly.
+ */
+import type { TimelineCommand } from '../contracts';
+export declare function compositeCommand(label: string, commands: TimelineCommand[]): TimelineCommand;

package/dist/sequences-react/components/glyphs.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Inline SVG glyphs for the timeline editor. The package stays dependency-free
+ * beyond React (the repo convention — see web-react), so the handful of icons
+ * the editor needs are inlined with lucide-equivalent path data.
+ */
+interface GlyphProps {
+    className?: string;
+}
+export declare const FilmGlyph: ({ className }: GlyphProps) => import("react").JSX.Element;
+export declare const AudioGlyph: ({ className }: GlyphProps) => import("react").JSX.Element;
+export declare const CaptionGlyph: ({ className }: GlyphProps) => import("react").JSX.Element;
+export declare const ReferenceGlyph: ({ className }: GlyphProps) => import("react").JSX.Element;
+export declare const AgentGlyph: ({ className }: GlyphProps) => import("react").JSX.Element;
+export declare const LockGlyph: ({ className }: GlyphProps) => import("react").JSX.Element;
+export declare const MutedGlyph: ({ className }: GlyphProps) => import("react").JSX.Element;
+export declare const PlayGlyph: ({ className }: GlyphProps) => import("react").JSX.Element;
+export declare const PauseGlyph: ({ className }: GlyphProps) => import("react").JSX.Element;
+export declare const UndoGlyph: ({ className }: GlyphProps) => import("react").JSX.Element;
+export declare const RedoGlyph: ({ className }: GlyphProps) => import("react").JSX.Element;
+export declare const MagnetGlyph: ({ className }: GlyphProps) => import("react").JSX.Element;
+export declare const ScissorsGlyph: ({ className }: GlyphProps) => import("react").JSX.Element;
+export declare const CaptionPlusGlyph: ({ className }: GlyphProps) => import("react").JSX.Element;
+export declare const ExportGlyph: ({ className }: GlyphProps) => import("react").JSX.Element;
+export declare const PlusGlyph: ({ className }: GlyphProps) => import("react").JSX.Element;
+export declare const MinusGlyph: ({ className }: GlyphProps) => import("react").JSX.Element;
+export {};

package/dist/sequences-react/components/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Timeline editor component surface. `TimelineEditor` is the root products
+ * mount (see `../lazy` for the code-split entry); the leaf pieces are exported
+ * for products that compose a custom editor shell from the same parts.
+ */
+export { TimelineEditor, SEQUENCE_MEDIA_DRAG_TYPE } from './TimelineEditor';
+export { PreviewCanvas } from './PreviewCanvas';
+export type { PreviewCanvasProps } from './PreviewCanvas';
+export { TimelineRuler } from './TimelineRuler';
+export type { TimelineRulerProps } from './TimelineRuler';
+export { TimelineTrackRow } from './TimelineTrackRow';
+export type { TimelineTrackRowProps } from './TimelineTrackRow';
+export { TimelineClipChip } from './TimelineClipChip';
+export type { TimelineClipChipProps, ClipMoveCommit, ClipTrimCommit } from './TimelineClipChip';
+export { TimelinePlayhead } from './TimelinePlayhead';
+export type { TimelinePlayheadProps } from './TimelinePlayhead';
+export { BrandMark } from './BrandMark';
+export type { BrandMarkProps } from './BrandMark';
+export { TimelineEmptyState } from './TimelineEmptyState';
+export type { TimelineEmptyStateProps } from './TimelineEmptyState';
+export { TimelineGhostLanes } from './TimelineGhostLanes';
+export type { TimelineGhostLanesProps } from './TimelineGhostLanes';
+export { TimelineSmallScreenGate } from './TimelineSmallScreenGate';
+export type { TimelineSmallScreenGateProps } from './TimelineSmallScreenGate';
+export { SnapIndicatorLine } from './SnapIndicatorLine';
+export type { SnapIndicatorLineProps } from './SnapIndicatorLine';
+export { ZoomControl } from './ZoomControl';
+export type { ZoomControlProps } from './ZoomControl';
+export { compositeCommand } from './composite-command';
+export { framesFromPixelDelta, moveDragStartFrame, trimStartDrag, trimEndDrag, selectTickStepSeconds, letterboxRect, captionFontPx, clipChipGeometry, chooseMoveSnap, } from './interaction-math';
+export type { MoveDragInput, TrimStartDragInput, TrimStartDragResult, TrimEndDragInput, LetterboxRect, } from './interaction-math';