@mengine/medeo-client 2.0.1-alpha.9 → 2.1.0

package/dist/{index-CDrPUhBH.d.ts → index-CnZ9l3rb.d.ts}

@@ -1,4 +1,3 @@
-import { A as MoveVideoClipsInput, J as ChangeSpeechScriptInput, K as DeleteBgmInput, N as MoveVideoClipsByAnchorInput, O as ReplaceVideoClipContentInput, Q as AdjustVideoClipVolumeInput, R as MoveSpeechesInput, S as SetBgmInput, T as ReplaceVideoClipSequenceInput, V as DeleteVideoClipsInput, W as DeleteSpeechesInput, Y as ChangeSpeechVoiceInput, b as SetCaptionStyleInput, ct as AddSpeechesInput, et as AdjustVideoClipDurationInput, g as SetVideoClipSpeedShiftInput, it as AdjustBgmVolumeInput, nt as AdjustSpeechVolumeInput, ot as AddVideoClipsInput, v as SetCaptionVisibilityInput } from "./index-CMa6ZCtX.js";
 import { InferInputType } from "loro-mirror";
 import { z } from "zod";
 import { LoroDoc, PeerID } from "loro-crdt";
@@ -30,10 +29,10 @@ import { LoroDoc, PeerID } from "loro-crdt";
  * @enum
  */
 declare const PartKind$1: {
-  readonly BGM: "bgm";
-  readonly CAPTION: "caption";
-  readonly SPEECH: "speech";
-  readonly VIDEO_CLIP: "video_clip";
+  readonly BGM: 'bgm';
+  readonly CAPTION: 'caption';
+  readonly SPEECH: 'speech';
+  readonly VIDEO_CLIP: 'video_clip';
 };
 /**
  * @public
@@ -145,8 +144,8 @@ interface CaptionPart$1 {
  * @enum
  */
 declare const AspectRatio: {
-  readonly RATIO_16_9: "16:9";
-  readonly RATIO_9_16: "9:16";
+  readonly RATIO_16_9: '16:9';
+  readonly RATIO_9_16: '9:16';
 };
 /**
  * @public
@@ -157,10 +156,10 @@ type AspectRatio = (typeof AspectRatio)[keyof typeof AspectRatio];
  * @enum
  */
 declare const AssetSource: {
-  readonly AI_IMAGES: "ai_images";
-  readonly AI_VIDEOS: "ai_videos";
-  readonly MY_UPLOADED_ASSETS: "my_uploaded_assets";
-  readonly STOCK_VIDEOS: "stock_videos";
+  readonly AI_IMAGES: 'ai_images';
+  readonly AI_VIDEOS: 'ai_videos';
+  readonly MY_UPLOADED_ASSETS: 'my_uploaded_assets';
+  readonly STOCK_VIDEOS: 'stock_videos';
 };
 /**
  * @public
@@ -254,11 +253,11 @@ declare const SpeedShiftCategory: {
   /**
    * Variable speed controlled by Bezier keyframes
    */
-  readonly CURVE: "curve";
+  readonly CURVE: 'curve';
   /**
    * Constant speed multiplier across the entire clip
    */
-  readonly LINEAR: "linear";
+  readonly LINEAR: 'linear';
 };
 /**
  * @public
@@ -483,21 +482,9 @@ type SpeechPart = Omit<SpeechPart$1, 'duration_ms'> & {
  *
  * `speech_part_id` / `start_ms` are kept as resource-intrinsic facts (which
  * speech it was split from, and its offset in that source) — reference/17
- * principle 4. An independently placed Caption (its own Clip and Sequence
- * Marker, no Voice take) has no owning speech: both fields stay unset and its
- * position is expressed entirely by the Clip's placement. Generation source
- * (AudioScript provenance) and Voice alignment are entity Relations, decoupled
- * from this display-side legacy view.
- */
-/** Derived render interval, relative to the placed Caption Clip; never an Entity. */
-interface CaptionDisplayCue {
-  segmentId: string;
-  text: string;
-  startMs: number;
-  durationMs: number;
-}
+ * principle 4.
+ */
 type CaptionPart = Omit<CaptionPart$1, 'duration_ms'> & {
-  display_cues?: CaptionDisplayCue[];
   initial_duration_ms?: number | undefined;
 };
 /**
@@ -563,19 +550,6 @@ interface Track {
   is_hidden: boolean | undefined;
   items: TrackItem[] | undefined;
 }
-/** The linear speed multiplier of a `speed_shift`, defaulting to 1 (original). */
-declare function speedOf(speedShift: SpeedShift | undefined): number;
-/**
- * A video clip's effective timeline duration, derived from authoritative facts
- * (RFC 02, `reference/16` §4, reference/17 §5): the trim window
- * `play_out - play_in` divided by the speed multiplier, rounded to integer ms.
- * `play_in` / `play_out` are optional in the IDL but every write path sets them
- * (defaulting to the whole media), and the legacy-ingest projection backfills the
- * window from a legacy `duration_ms` — so an authoritative clip always carries a
- * trim window and there is no stored `duration_ms` to fall back to. A clip with
- * neither bound yields 0. Speeds the clip up (>1× → shorter) or down (<1×).
- */
-declare function effectiveVideoClipDurationMs(clip: VideoClipPart): number;
 /**
  * Authoritative part union: a flat discriminated union over the four part kinds.
  * Deliberately *not* the IDL's namespace union (no `$unknown` / `visit`): engine
@@ -735,184 +709,6 @@ interface VideoDocumentValidationIssue {
   severity?: VideoDocumentValidationIssueSeverity;
 }
 //#endregion
-//#region src/document/mirror-schema.d.ts
-declare const videoDocumentMirrorSchema: import("loro-mirror").RootSchemaType<{
-  timeline: import("loro-mirror").LoroMapSchema<{
-    unit_time_ms: /*elided*/any;
-  }> & {
-    options: {};
-  } & {
-    catchall: <C extends import("loro-mirror").SchemaType>(catchallSchema: C) => import("loro-mirror").LoroMapSchemaWithCatchall<{
-      unit_time_ms: /*elided*/any;
-    }, C>;
-  };
-  tracks: import("loro-mirror").LoroMovableListSchema<import("loro-mirror").LoroMapSchema<{
-    id: /*elided*/any;
-    parts_kind: /*elided*/any;
-    is_hidden: /*elided*/any;
-    items: /*elided*/any;
-  }> & {
-    options: {};
-  } & {
-    catchall: <C extends import("loro-mirror").SchemaType>(catchallSchema: C) => import("loro-mirror").LoroMapSchemaWithCatchall<{
-      id: /*elided*/any;
-      parts_kind: /*elided*/any;
-      is_hidden: /*elided*/any;
-      items: /*elided*/any;
-    }, C>;
-  }> & {
-    options: {};
-  };
-  part_library: import("loro-mirror").LoroMapSchemaWithCatchall<{}, import("loro-mirror").LoroMapSchema<{
-    video_clip: /*elided*/any;
-    speech: /*elided*/any;
-    caption: /*elided*/any;
-    bgm: /*elided*/any;
-  }> & {
-    options: {};
-  } & {
-    catchall: <C extends import("loro-mirror").SchemaType>(catchallSchema: C) => import("loro-mirror").LoroMapSchemaWithCatchall<{
-      video_clip: /*elided*/any;
-      speech: /*elided*/any;
-      caption: /*elided*/any;
-      bgm: /*elided*/any;
-    }, C>;
-  }> & {
-    options: {};
-  };
-}> & {
-  options: {};
-};
-type VideoDocumentMirrorSchema = typeof videoDocumentMirrorSchema;
-/**
- * The mutable draft an op's `transact` callback edits, inferred from the schema.
- *
- * `InferInputType` is the schema's *input* shape: the declared business fields
- * with the `$cid` container ids (which mirror injects into its output
- * `InferType`) made optional, so ops assign plain objects without supplying
- * `$cid`. Deriving it from the schema keeps draft and storage in lockstep — a
- * schema change is a compile error at every edit site, not a silent drift.
- * Reorders within `items` still diff to real Loro `move` ops because the schema
- * keys items by `part_id`.
- */
-type VideoDocumentDraft = InferInputType<VideoDocumentMirrorSchema>;
-/** Track value as it appears in a draft. Derived from the single `tracks` movable list. */
-type TrackDraft = NonNullable<NonNullable<VideoDocumentDraft['tracks']>[number]>;
-/** A single track item in a draft. */
-type TrackItemDraft = NonNullable<NonNullable<TrackDraft['items']>[number]>;
-//#endregion
-//#region src/timeline-core/bridge.d.ts
-/**
- * Bridge between the authoritative `VideoDocument` (position-only facts) and the
- * flat `TimelineDoc` the cascade primitives solve over.
- *
- * The data flow is single-directional (RFC 02 §7/§10): ops write only facts
- * (`time_position`, parts) to `VideoDocument`; absolute time, `part_aggregations`,
- * total duration, and gap fillers are NOT stored — the projection derives them
- * on read by running the cascade. There is no write-back of solved positions.
- *
- * - `solveVideoDocument` seeds a `TimelineDoc` from each item's `time_position`,
- *   runs the full cascade, and returns the derived read-view (abs / aggregations
- *   / duration). It is the single solve shared by the legacy `VideoDraft`
- *   projection.
- * - `ensureLaneTrack` / `findLaneTrack` locate (or mint) a secondary lane's
- *   track row in the draft, so ops can write authoritative facts onto the right
- *   named container (lane = container).
- */
-/** The projection-derived read-view of a `VideoDocument` (RFC 02 §7). */
-interface SolvedVideoDocument {
-  absByPartId: Map<string, number>;
-  aggregations: PartAggregation[];
-  durationMs: number;
-  partLibrary: Record<string, PartUnion>;
-  /**
-   * Part ids of the gap fillers this solve minted.
-   *
-   * They exist only inside the solve: gap filling needs them so the clips after a
-   * gap land at the right absolute time, but they are not authoritative state and
-   * the read view does not carry them (see `fromVideoDocument`).
-   *
-   * Reported as ids rather than left for the caller to detect, because the caller
-   * *cannot* detect them. The obvious predicate — `origin_media_id === ''` — also
-   * matches an empty clip a writer placed on purpose (`batch_replace_video_clip_sequence`
-   * documents "Omit to create an empty clip placeholder"), and those are
-   * authoritative parts that must survive the projection. The mint callback is the
-   * only place that knows the difference.
-   *
-   * Note this deliberately excludes the fillers that gap filling *extended* rather
-   * than minted (`fillMainTrackTimeGaps` cases 1 and 2): those are authoritative
-   * empty clips already in `part_library`, and only their length is derived.
-   */
-  derivedFillerPartIds: Set<string>;
-}
-/** How the caller obtained the document it is asking to be solved. */
-interface SolveVideoDocumentOptions {
-  /**
-   * The producer already resolved every placement, so the legacy cascade must
-   * not run. Only an Entity projection can state this: its placement comes from
-   * Clip order / clip-anchor offsets / Marker targetRange, and re-solving would
-   * overwrite those and synthesize gap fillers the Entity graph never had.
-   *
-   * The document itself no longer carries its provenance (P7M14 moved business
-   * metadata out of the CRDT), so the caller states it. `hasResolvedPlacement`
-   * only verifies the claim — it is never the branch condition, because a
-   * legacy draft can satisfy it by accident and a broken projection can fail it.
-   */
-  readonly placementResolved?: boolean;
-}
-/**
- * Solve a `VideoDocument` (authoritative, position-only) into its derived
- * read-view: absolute time per item, `part_aggregations`, and total duration.
- * This is the read side of the single-directional flow — never written back.
- */
-declare function solveVideoDocument(document: VideoDocument, options?: SolveVideoDocumentOptions): SolvedVideoDocument;
-/** The named container a secondary lane lives in. */
-type SecondaryLane = 'speech' | 'caption' | 'bgm';
-/** A lane's track kind: the `video_clip` main lane plus the three secondary lanes. */
-type LaneKind = SecondaryLane | 'video_clip';
-/**
- * The four lanes in top-to-bottom stack order — the order a `tracks` list holds
- * them in (see {@link laneRank}).
- *
- * Exported so a document can be seeded with all four lanes up front. That seed is
- * not cosmetic: {@link ensureLaneTrack} is find-then-mint over a `LoroMovableList`,
- * so two concurrent writers that each mint the same absent lane both keep their
- * row, and the merged document holds two tracks for one lane. For the main lane
- * that is fatal — `videoDocumentSchema` allows at most one `video_clip` track, so
- * the merged document stops being projectable at all, symmetrically on both
- * replicas. Pre-seeding every lane makes `ensureLaneTrack` always take its find
- * branch, which removes the race by construction rather than by detection.
- *
- * What closes the race is that a track with the lane's `parts_kind` EXISTS — the
- * lookup is by kind, not by id. So a seed is only safe if it covers every lane:
- * a partial seed leaves the uncovered lanes exactly as exposed as before.
- */
-declare const LANE_KINDS_IN_STACK_ORDER: readonly LaneKind[];
-/**
- * The conventional track id for a lane (`main_track`, `<kind>_track`). Shared by
- * the up-front seed and {@link ensureLaneTrack}'s lazy mint so a document's lane
- * ids do not depend on which of the two created the track.
- *
- * Ids are cosmetic to the merge itself — lane lookup goes by `parts_kind`, so
- * drifting them apart would not reopen the concurrent-mint race. They matter to
- * readers that address a lane by id (the FE editor's panes, fixtures), which is
- * why there is one convention rather than two.
- */
-declare function laneTrackId(kind: LaneKind): string;
-/**
- * Locate a lane's track row in the single `tracks` list by kind, minting an empty
- * row in lane-stacking order if absent (reference/17 §4: lane = `parts_kind`).
- * Ops use this to write authoritative items onto the right lane. The track id
- * comes from {@link laneTrackId}, shared with the up-front seed.
- *
- * The mint branch is a concurrency hazard, not a convenience: see
- * {@link LANE_KINDS_IN_STACK_ORDER}. A document seeded with all four lanes never
- * reaches it.
- */
-declare function ensureLaneTrack(draft: VideoDocumentDraft, kind: LaneKind): TrackDraft;
-/** Find a secondary lane's track row without minting it. */
-declare function findLaneTrack(draft: VideoDocumentDraft, kind: SecondaryLane): TrackDraft | undefined;
-//#endregion
 //#region src/document/projection.d.ts
 /**
  * Projection between authoritative `VideoDocument` and compatible content
@@ -991,7 +787,7 @@ declare function derivePositionFromAbs(partId: string, abs: number, isMain: bool
  * here — it belongs to Director assembly using the server envelope update_seq.
  * Neither business metadata nor a revision counter belongs in content projection.
  */
-declare function fromVideoDocument(document: VideoDocument, options?: SolveVideoDocumentOptions): VideoDraftContent;
+declare function fromVideoDocument(document: VideoDocument): VideoDraftContent;
 //#endregion
 //#region src/document/initial-document.d.ts
 /**
@@ -1019,170 +815,6 @@ declare function fromVideoDocument(document: VideoDocument, options?: SolveVideo
  */
 declare function buildInitialVideoDocument(): VideoDocument;
 //#endregion
-//#region ../medeo-dsl/src/ids.d.ts
-declare const entityIdBrand: unique symbol;
-declare const relationIdBrand: unique symbol;
-type EntityId = string & {
-  readonly [entityIdBrand]: 'EntityId';
-};
-type RelationId = string & {
-  readonly [relationIdBrand]: 'RelationId';
-};
-//#endregion
-//#region ../medeo-dsl/src/json-values.d.ts
-type JsonPrimitive = string | number | boolean | null;
-type JsonValue = JsonPrimitive | JsonObject | readonly JsonValue[];
-type JsonObject = {
-  readonly [key: string]: JsonValue;
-};
-//#endregion
-//#region ../medeo-dsl/src/entities.d.ts
-type KnownEntityKind = 'axvideo' | 'timeline' | 'track' | 'clip' | 'asset' | 'video' | 'audio' | 'voice' | 'image' | 'sequence-marker' | 'viewport' | 'audio-script' | 'phonetic-script' | 'caption';
-declare const extensionEntityKindBrand: unique symbol;
-type ExtensionEntityKind = string & {
-  readonly [extensionEntityKindBrand]: 'ExtensionEntityKind';
-};
-/** Extensions require explicit branding so removed or reserved domain kinds cannot reappear accidentally. */
-type EntityKind = KnownEntityKind | ExtensionEntityKind;
-interface SequenceRange<Point = unknown> {
-  readonly start: Point;
-  readonly end: Point;
-}
-type SequenceDuration<Span = unknown> = {
-  readonly mode: 'from-source';
-} | {
-  readonly mode: 'fixed';
-  readonly value: Span;
-};
-interface ScriptTextSegment {
-  readonly segmentId: string;
-  readonly text: string;
-  readonly language?: string;
-}
-interface VoiceDescriptor {
-  readonly system: 'voice-library';
-  readonly key: string;
-  readonly name?: string;
-}
-interface CaptionFontDescriptor {
-  readonly system: 'font-library';
-  readonly key: string;
-}
-interface CaptionStyleFields {
-  readonly font?: CaptionFontDescriptor;
-  readonly fontSize?: number;
-  readonly fontColor?: string;
-  readonly fontWeight?: number;
-  readonly entranceAnimation?: string;
-  readonly entranceAnimationDurationMs?: number;
-  readonly strokeColor?: string;
-  readonly strokeWidth?: number;
-  readonly positionX?: number;
-  readonly positionY?: number;
-}
-/**
- * Half-open `[start, end)` position window inside one Segment's text, counted
- * in Unicode code points (not UTF-16 code units), so a boundary never splits a
- * surrogate pair. Positions are non-negative safe integers with `start < end`;
- * `end` must not exceed the Segment's code-point length.
- */
-interface CaptionTextRange extends JsonObject {
-  readonly start: number;
-  readonly end: number;
-}
-/**
- * The Caption's single text selection. `segmentId` quotes the
- * composed AudioScript's own stable segment identity — a local id quoted by the
- * variant, never a peer Entity reference. Text itself is never copied here;
- * complete Caption content is assembled through its direct baseEntityIds.
- * The optional `textRange` narrows one Segment to an intra-Segment sub-span
- * (intra-segment re-segmentation); without it the whole Segment text is selected.
- */
-type CaptionSegmentSelection = JsonObject & {
-  readonly segmentId: string;
-  readonly textRange?: CaptionTextRange;
-};
-//#endregion
-//#region ../medeo-dsl/src/relations.d.ts
-type KnownRelationKind = 'timeline-track' | 'track-clip' | 'clip-marker' | 'marker-content' | 'axvideo-marker' | 'marker-timeline' | 'physical-asset' | 'generated' | 'caption-alignment' | 'clip-anchor' | 'phonetic-script-render' | 'audio-script-source' | 'audio-script-marker';
-type RelationKind = KnownRelationKind | (string & {});
-type RelationTrace = JsonObject;
-/**
- * Authoritative persisted relation value.
- *
- * A kind may assign semantic roles to endpoint 0 and endpoint 1. Callers and
- * storage adapters must preserve the submitted positions; kinds whose
- * semantics are unordered simply do not interpret those positions.
- */
-interface RelationRow<K extends RelationKind = RelationKind, Metadata extends JsonObject = JsonObject> {
-  readonly relationId: RelationId;
-  readonly endpoint0EntityId: EntityId;
-  readonly endpoint1EntityId: EntityId;
-  readonly relationKind: K;
-  readonly metadata: Metadata;
-  readonly trace: RelationTrace;
-}
-//#endregion
-//#region ../medeo-dsl/src/rows.d.ts
-/** One persisted first-class entity. Its owned fields live directly in payload. */
-interface EntityRow<K extends EntityKind = EntityKind> {
-  readonly entityId: EntityId;
-  readonly entityKind: K;
-  readonly payload: JsonObject;
-}
-/** Complete persistence value for an entity set and its authoritative relations. */
-interface EntityRelationRows {
-  readonly entities: readonly EntityRow[];
-  readonly relations: readonly RelationRow[];
-}
-//#endregion
-//#region src/document/entity-projection-values.d.ts
-/** A graph cannot be represented faithfully by the compatibility reader. */
-declare class EntityTimelineProjectionError extends Error {
-  constructor(message: string);
-}
-//#endregion
-//#region src/document/entity-projection.d.ts
-/**
- * One-way compatibility view over the Entity graph. A legacy part is never
- * consulted as an editing fact. Peer IDs appear only in this derived read
- * contract, reconstructed from relations; they are not stored in payloads.
- */
-declare function projectEntityTimeline(rows: EntityRelationRows): VideoDocument;
-//#endregion
-//#region src/document/entity-timeline-layout.d.ts
-type EntityTimelineTrackRole = 'video_clip' | 'speech' | 'caption' | 'bgm';
-interface ResolvedEntityClipPlacement {
-  readonly clipEntityId: string;
-  readonly markerEntityId: string;
-  readonly contentEntityId: string;
-  readonly trackEntityId: string;
-  readonly start: number;
-  readonly duration: number;
-  readonly mode: 'sequential' | 'absolute' | 'anchored';
-  readonly anchorClipEntityId?: string;
-  readonly anchorOffset?: number;
-}
-interface ResolvedEntityTrack {
-  readonly entityId: string;
-  readonly role: EntityTimelineTrackRole;
-  readonly order: number;
-  readonly hidden: boolean;
-  readonly clips: readonly ResolvedEntityClipPlacement[];
-}
-interface ResolvedEntityTimelineLayout {
-  readonly tracks: readonly ResolvedEntityTrack[];
-  readonly clips: ReadonlyMap<string, ResolvedEntityClipPlacement>;
-  /** Background music fills this duration; it never extends the timeline. */
-  readonly durationMs: number;
-}
-/**
- * Resolve only entity-owned placement facts. This does not choose new anchors,
- * manufacture clips, or mutate a graph while reading. Write-side operations
- * must express any detach/reparent/overlap decision in their entity plan.
- */
-declare function resolveEntityTimelineLayout(rows: EntityRelationRows): ResolvedEntityTimelineLayout;
-//#endregion
 //#region src/document/validation.d.ts
 /**
  * Business-level schema guard for `VideoDocument` (RFC 03 §9). It is the gate
@@ -1211,35 +843,677 @@ declare class VideoDocumentValidationError extends Error {
 declare function assertValidVideoDocument(document: unknown): asserts document is VideoDocument;
 declare function validateVideoDocument(document: unknown): VideoDocumentValidationIssue[];
 //#endregion
-//#region src/editor/id-gen.d.ts
+//#region src/document/mirror-schema.d.ts
+declare const videoDocumentMirrorSchema: import("loro-mirror").RootSchemaType<{
+  timeline: import("loro-mirror").LoroMapSchema<{
+    unit_time_ms: /*elided*/any;
+  }> & {
+    options: {};
+  } & {
+    catchall: <C extends import("loro-mirror").SchemaType>(catchallSchema: C) => import("loro-mirror").LoroMapSchemaWithCatchall<{
+      unit_time_ms: /*elided*/any;
+    }, C>;
+  };
+  tracks: import("loro-mirror").LoroMovableListSchema<import("loro-mirror").LoroMapSchema<{
+    id: /*elided*/any;
+    parts_kind: /*elided*/any;
+    is_hidden: /*elided*/any;
+    items: /*elided*/any;
+  }> & {
+    options: {};
+  } & {
+    catchall: <C extends import("loro-mirror").SchemaType>(catchallSchema: C) => import("loro-mirror").LoroMapSchemaWithCatchall<{
+      id: /*elided*/any;
+      parts_kind: /*elided*/any;
+      is_hidden: /*elided*/any;
+      items: /*elided*/any;
+    }, C>;
+  }> & {
+    options: {};
+  };
+  part_library: import("loro-mirror").LoroMapSchemaWithCatchall<{}, import("loro-mirror").LoroMapSchema<{
+    video_clip: /*elided*/any;
+    speech: /*elided*/any;
+    caption: /*elided*/any;
+    bgm: /*elided*/any;
+  }> & {
+    options: {};
+  } & {
+    catchall: <C extends import("loro-mirror").SchemaType>(catchallSchema: C) => import("loro-mirror").LoroMapSchemaWithCatchall<{
+      video_clip: /*elided*/any;
+      speech: /*elided*/any;
+      caption: /*elided*/any;
+      bgm: /*elided*/any;
+    }, C>;
+  }> & {
+    options: {};
+  };
+}> & {
+  options: {};
+};
+type VideoDocumentMirrorSchema = typeof videoDocumentMirrorSchema;
+/**
+ * The mutable draft an op's `transact` callback edits, inferred from the schema.
+ *
+ * `InferInputType` is the schema's *input* shape: the declared business fields
+ * with the `$cid` container ids (which mirror injects into its output
+ * `InferType`) made optional, so ops assign plain objects without supplying
+ * `$cid`. Deriving it from the schema keeps draft and storage in lockstep — a
+ * schema change is a compile error at every edit site, not a silent drift.
+ * Reorders within `items` still diff to real Loro `move` ops because the schema
+ * keys items by `part_id`.
+ */
+type VideoDocumentDraft = InferInputType<VideoDocumentMirrorSchema>;
+/** Track value as it appears in a draft. Derived from the single `tracks` movable list. */
+type TrackDraft = NonNullable<NonNullable<VideoDocumentDraft['tracks']>[number]>;
+/** A single track item in a draft. */
+type TrackItemDraft = NonNullable<NonNullable<TrackDraft['items']>[number]>;
+//#endregion
+//#region src/editor/schemas/add-speeches.d.ts
+/**
+ * Add speeches (and their captions). TTS runs upstream; the stable speech /
+ * caption parts arrive materialized (see `speech-assets.ts`). The op writes the
+ * parts and each speech's `{ mode:'anchored', anchorPartId, offsetMs }` fact
+ * verbatim — no write-time host-picking, no cascade (RFC 02 §4). The projection
+ * derives absolute positions on read.
+ */
+declare const addSpeechesInputSchema: z.ZodObject<{
+  speeches: z.ZodArray<z.ZodObject<{
+    speech_id: z.ZodString;
+    anchor_part_id: z.ZodString;
+    offset_ms: z.ZodNumber;
+    audio_storage_key: z.ZodString;
+    duration_ms: z.ZodNumber;
+    audio_script: z.ZodString;
+    volume: z.ZodNumber;
+    voice: z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+    }, z.core.$strip>;
+    origin_speech_id: z.ZodString;
+    caption_ids: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>>;
+  captions: z.ZodArray<z.ZodObject<{
+    caption_id: z.ZodString;
+    speech_part_id: z.ZodString;
+    text: z.ZodString;
+    start_ms: z.ZodNumber;
+    duration_ms: z.ZodNumber;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type AddSpeechesInput = z.infer<typeof addSpeechesInputSchema>;
+//#endregion
+//#region src/editor/schemas/add-video-clips.d.ts
+/**
+ * Add video clips to a track. Each clip's duration facts are separated so a
+ * single number is never overloaded (RFC 02 / `reference/16` §0b):
+ *
+ * - `media_duration_ms` is the source media's intrinsic full length (a resource
+ *   fact, written to the part);
+ * - `play_in` / `play_out` are the optional trim window into that media; when
+ *   omitted the whole media is used (`play_in=0`, `play_out=media_duration_ms`).
+ *
+ * The clip's effective timeline duration is derived by the projection from the
+ * trim window and `speed_shift` — it is never an input here.
+ */
+declare const addVideoClipsInputSchema: z.ZodObject<{
+  clips: z.ZodArray<z.ZodObject<{
+    media_id: z.ZodString;
+    start_ms: z.ZodOptional<z.ZodNumber>;
+    media_duration_ms: z.ZodNumber;
+    play_in: z.ZodOptional<z.ZodNumber>;
+    play_out: z.ZodOptional<z.ZodNumber>;
+    track_id: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  before_clip_id: z.ZodOptional<z.ZodString>;
+  after_clip_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type AddVideoClipsInput = z.infer<typeof addVideoClipsInputSchema>;
+//#endregion
+//#region src/editor/schemas/adjust-bgm-volume.d.ts
+declare const adjustBgmVolumeInputSchema: z.ZodObject<{
+  bgm: z.ZodArray<z.ZodObject<{
+    bgm_id: z.ZodString;
+    volume: z.ZodNumber;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type AdjustBgmVolumeInput = z.infer<typeof adjustBgmVolumeInputSchema>;
+//#endregion
+//#region src/editor/schemas/adjust-speech-volume.d.ts
+declare const adjustSpeechVolumeInputSchema: z.ZodObject<{
+  speeches: z.ZodArray<z.ZodObject<{
+    speech_id: z.ZodString;
+    volume: z.ZodNumber;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type AdjustSpeechVolumeInput = z.infer<typeof adjustSpeechVolumeInputSchema>;
+//#endregion
+//#region src/editor/schemas/adjust-video-clip-duration.d.ts
+/**
+ * Re-trim existing video clips (the user-facing "adjust duration" gesture is a
+ * trim of the source window). The new `play_in` / `play_out` are the facts; the
+ * effective timeline duration is derived from them and the clip's `speed_shift`,
+ * and the change reflows downstream clips, speeches, and the timeline inside the
+ * op's transaction (no caller-materialized cascade).
+ */
+declare const adjustVideoClipDurationInputSchema: z.ZodObject<{
+  clips: z.ZodArray<z.ZodObject<{
+    clip_id: z.ZodString;
+    play_in: z.ZodNumber;
+    play_out: z.ZodNumber;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type AdjustVideoClipDurationInput = z.infer<typeof adjustVideoClipDurationInputSchema>;
+//#endregion
+//#region src/editor/schemas/adjust-video-clip-volume.d.ts
+declare const adjustVideoClipVolumeInputSchema: z.ZodObject<{
+  clips: z.ZodArray<z.ZodObject<{
+    clip_id: z.ZodString;
+    volume: z.ZodNumber;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type AdjustVideoClipVolumeInput = z.infer<typeof adjustVideoClipVolumeInputSchema>;
+//#endregion
+//#region src/editor/schemas/change-speech.d.ts
+/**
+ * Change a speech's script or voice. Both re-run TTS upstream and return the
+ * regenerated speech / caption parts in the same materialized shape as
+ * `AddSpeeches` (`speech-assets.ts`); the op upserts them by id (the speech part
+ * id is preserved across a re-TTS), re-seats at `start_ms`, and reflows. Old
+ * caption parts no longer owned by the speech are removed via `caption_ids`.
+ */
+declare const changeSpeechScriptInputSchema: z.ZodObject<{
+  speeches: z.ZodArray<z.ZodObject<{
+    speech_id: z.ZodString;
+    anchor_part_id: z.ZodString;
+    offset_ms: z.ZodNumber;
+    audio_storage_key: z.ZodString;
+    duration_ms: z.ZodNumber;
+    audio_script: z.ZodString;
+    volume: z.ZodNumber;
+    voice: z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+    }, z.core.$strip>;
+    origin_speech_id: z.ZodString;
+    caption_ids: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>>;
+  captions: z.ZodArray<z.ZodObject<{
+    caption_id: z.ZodString;
+    speech_part_id: z.ZodString;
+    text: z.ZodString;
+    start_ms: z.ZodNumber;
+    duration_ms: z.ZodNumber;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const changeSpeechVoiceInputSchema: z.ZodObject<{
+  speeches: z.ZodArray<z.ZodObject<{
+    speech_id: z.ZodString;
+    anchor_part_id: z.ZodString;
+    offset_ms: z.ZodNumber;
+    audio_storage_key: z.ZodString;
+    duration_ms: z.ZodNumber;
+    audio_script: z.ZodString;
+    volume: z.ZodNumber;
+    voice: z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+    }, z.core.$strip>;
+    origin_speech_id: z.ZodString;
+    caption_ids: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>>;
+  captions: z.ZodArray<z.ZodObject<{
+    caption_id: z.ZodString;
+    speech_part_id: z.ZodString;
+    text: z.ZodString;
+    start_ms: z.ZodNumber;
+    duration_ms: z.ZodNumber;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type ChangeSpeechScriptInput = z.infer<typeof changeSpeechScriptInputSchema>;
+type ChangeSpeechVoiceInput = z.infer<typeof changeSpeechVoiceInputSchema>;
+//#endregion
+//#region src/editor/schemas/delete-bgm.d.ts
+/**
+ * Remove the document BGM. Pure document edit: clears the bgm lane and removes
+ * the bgm part. Takes no input (a document holds at most one bgm); an empty
+ * object keeps the op signature uniform with the rest.
+ */
+declare const deleteBgmInputSchema: z.ZodObject<{}, z.core.$strip>;
+type DeleteBgmInput = z.infer<typeof deleteBgmInputSchema>;
+//#endregion
+//#region src/editor/schemas/delete-speeches.d.ts
+/**
+ * Delete speeches with their captions. Pure document edit (no side effect): the
+ * op removes each speech part, cascade-deletes the captions it owns (via
+ * `caption_ids` / `speech_part_id`), drops their track items, and reflows.
+ */
+declare const deleteSpeechesInputSchema: z.ZodObject<{
+  speech_ids: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type DeleteSpeechesInput = z.infer<typeof deleteSpeechesInputSchema>;
+//#endregion
+//#region src/editor/schemas/delete-video-clips.d.ts
 /**
- * Part-id generation, aligned with the online ecosystem.
+ * How a delete handles the anchored subtree (speeches anchored to a deleted clip,
+ * and their captions) — a delete-op policy, not a data-model field (reference/17
+ * §6). `cascade` (default) removes the subtree; `detach` keeps the direct
+ * anchored children, re-pinning them to `absolute` so they stay on the timeline.
+ */
+declare const anchoredDeletePolicySchema: z.ZodEnum<{
+  cascade: "cascade";
+  detach: "detach";
+}>;
+type AnchoredDeletePolicy = z.infer<typeof anchoredDeletePolicySchema>;
+declare const deleteVideoClipsInputSchema: z.ZodObject<{
+  clip_ids: z.ZodArray<z.ZodString>;
+  on_anchored: z.ZodOptional<z.ZodEnum<{
+    cascade: "cascade";
+    detach: "detach";
+  }>>;
+}, z.core.$strip>;
+type DeleteVideoClipsInput = z.infer<typeof deleteVideoClipsInputSchema>;
+//#endregion
+//#region src/editor/schemas/move-speeches.d.ts
+/**
+ * Move speeches in time. Pure document edit: the op re-seats each speech at its
+ * new absolute `start_ms`; the cascade reassigns it to the host video clip,
+ * resolves overlaps, and reflows. Captions follow their speech.
+ */
+declare const moveSpeechesInputSchema: z.ZodObject<{
+  speeches: z.ZodArray<z.ZodObject<{
+    speech_id: z.ZodString;
+    new_start_ms: z.ZodNumber;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type MoveSpeechesInput = z.infer<typeof moveSpeechesInputSchema>;
+//#endregion
+//#region src/editor/schemas/move-video-clips-by-anchor.d.ts
+/**
+ * Where the moved block lands on the main track.
+ *
+ * A discriminated union rather than two optional `before_clip_id` /
+ * `after_clip_id` fields (the shape `addVideoClips` had to use, because there the
+ * two modes share a whole clip description): here the alternatives carry nothing
+ * in common, so making them mutually exclusive *by type* removes three runtime
+ * `superRefine` checks that would otherwise have to be written and tested.
+ *
+ * `track_start` is an explicit member, not the absence of an anchor. The
+ * agent-harness mutation this maps from treats "neither anchor given" as
+ * "move to the front" (`applyBatchMoveVideoClips` falls back to `insertIndex = 0`),
+ * which is a default buried in a tool description. Requiring the caller to name
+ * that intent keeps a forgotten field from silently reordering the timeline.
+ */
+declare const moveAnchorSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  position: z.ZodLiteral<"before">;
+  clip_id: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  position: z.ZodLiteral<"after">;
+  clip_id: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  position: z.ZodLiteral<"track_start">;
+}, z.core.$strip>], "position">;
+/**
+ * What happens to the speeches anchored to the clips being moved.
  *
- * The authoritative online producers — agent-harness (`@harness/shared`
- * `genObjId`) and director.v2 (`common/obj_id.py` `gen_obj_id`) — both mint part
- * ids as `` `${prefix}_${ulid()}` ``, and real captured drafts use exactly that
- * shape (`clip_…` / `spe_…` / `cap_…` / `bgm_…`, each a 26-char ULID). The engine
- * previously emitted `vc_<base36 timestamp><6 random>`, a different prefix AND a
- * different encoding — the sole cross-repo id divergence. This module removes it
- * by emitting the same `<prefix>_<ULID>` bytes.
+ * - `follow` keeps each speech anchored where it is, so it travels with its clip
+ *   to the new position. In the anchored model this is the *no-op* branch: a
+ *   speech's authoritative fact is `{ anchorPartId, offsetMs }` and its absolute
+ *   time is derived on read from the host's position, so moving the host moves
+ *   the speech with no write to the speech at all.
+ * - `keep_absolute` preserves each speech's current absolute landing instead, then
+ *   re-anchors it to whichever clip now covers that time (RFC 02 §9.1/§11.1). This
+ *   is the branch that costs an extra pass, and the one the FE timeline uses.
  *
- * The ULID is generated inline (Crockford Base32, 48-bit time + 80-bit random)
- * rather than pulling the `ulid` npm package: the randomness class matches the
- * old generator (both `Math.random`-based) and it keeps `@mengine/medeo-client`
- * dependency-free for a purely mechanical id string. Part ids only need to be
- * unique and lexicographically time-sortable, which this satisfies.
- */
-/**
- * Online part-id semantic prefixes. `clip` (video clip) is the only value the
- * engine currently mints (see `addVideoClips`); the rest are declared so the
- * type documents the shared vocabulary and guards against reintroducing the old
- * `vc`/`sp`/`cp`/`bg` names. Speech/caption/bgm ids arrive pre-minted in op
- * payloads, so the engine never generates them itself.
- */
-type PartIdPrefix = 'clip' | 'spe' | 'cap' | 'bgm' | 'ti';
-declare function generatePartId(prefix: PartIdPrefix): string;
-/** Injectable part-id mint; defaults to `generatePartId` on `SemanticEditor`. */
-type PartIdFactory = (prefix: PartIdPrefix) => string;
+ * **Required, with no default**, matching `deleteVideoClips` and
+ * `replaceVideoClipSequence`. The two branches decide which picture the user's
+ * narration ends up over, which is too consequential to infer from a missing
+ * field — and neither branch is "safe enough" to be the implicit one.
+ */
+declare const movedClipAnchoredPolicySchema: z.ZodEnum<{
+  follow: "follow";
+  keep_absolute: "keep_absolute";
+}>;
+/**
+ * Reorder a set of main-track clips relative to a reference clip.
+ *
+ * Distinct from `moveVideoClips`, which positions clips by absolute time
+ * (`new_start_ms`) and is what the FE timeline dispatches after a drag. Main-track
+ * clips are `sequential`-positioned, so absolute time is not authoritative state
+ * there (RFC 02 §4/§7): `moveVideoClips` has to *guess* an index back out of the
+ * time it was handed, whereas an anchor already is the ordinal fact being changed.
+ * Keeping them separate also isolates blast radius — this method can diverge on
+ * speech policy without touching the FE path.
+ *
+ * `clip_ids` need not be contiguous. They move as one block, keeping their
+ * relative order, which is the agent-harness `batch_move_video_clips` contract.
+ */
+declare const moveVideoClipsByAnchorInputSchema: z.ZodObject<{
+  clip_ids: z.ZodArray<z.ZodString>;
+  anchor: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    position: z.ZodLiteral<"before">;
+    clip_id: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    position: z.ZodLiteral<"after">;
+    clip_id: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    position: z.ZodLiteral<"track_start">;
+  }, z.core.$strip>], "position">;
+  on_anchored: z.ZodEnum<{
+    follow: "follow";
+    keep_absolute: "keep_absolute";
+  }>;
+}, z.core.$strip>;
+type MoveAnchor = z.infer<typeof moveAnchorSchema>;
+type MovedClipAnchoredPolicy = z.infer<typeof movedClipAnchoredPolicySchema>;
+type MoveVideoClipsByAnchorInput = z.infer<typeof moveVideoClipsByAnchorInputSchema>;
+//#endregion
+//#region src/editor/schemas/move-video-clips.d.ts
+declare const moveVideoClipsInputSchema: z.ZodObject<{
+  clips: z.ZodArray<z.ZodObject<{
+    clip_id: z.ZodString;
+    new_start_ms: z.ZodNumber;
+    new_track_id: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type MoveVideoClipsInput = z.infer<typeof moveVideoClipsInputSchema>;
+//#endregion
+//#region src/editor/schemas/replace-video-clip-content.d.ts
+/**
+ * Replace the media backing existing video clips. The media import runs upstream
+ * (Director); its stable result — the new media id, intrinsic length, and the
+ * reset trim window — arrives materialized (see
+ * `results/phase-4-side-effect-payload-contract.md` §4). Director resets
+ * `play_in=0` / `play_out=media_duration_ms` and clears `speed_shift` on
+ * replacement. The clip `part_id`s (hence their track items) are unchanged; the
+ * editor reflows the main track from the new effective durations.
+ */
+declare const replaceVideoClipContentInputSchema: z.ZodObject<{
+  clips: z.ZodArray<z.ZodObject<{
+    clip_id: z.ZodString;
+    origin_media_id: z.ZodString;
+    media_duration_ms: z.ZodNumber;
+    play_in: z.ZodNumber;
+    play_out: z.ZodNumber;
+    volume: z.ZodNumber;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type ReplaceVideoClipContentInput = z.infer<typeof replaceVideoClipContentInputSchema>;
+//#endregion
+//#region src/editor/schemas/replace-video-clip-sequence.d.ts
+/**
+ * What happens to the speeches anchored to the clips being replaced.
+ *
+ * - `remap` re-anchors each surviving speech to the new clip in the SAME POSITION
+ *   of the sequence, keeping its offset — old[i]'s children become new[i]'s
+ *   children. An old clip with no counterpart (fewer new clips than old) has its
+ *   subtree deleted, because there is nothing left to anchor to.
+ * - `cascade` deletes every anchored speech (and its captions) outright, like
+ *   `deleteVideoClips`.
+ *
+ * **Required, with no default.** The two branches differ in whether the user's
+ * narration survives, and the agent tool that drives this op makes its
+ * `preserve_speeches` flag required for that reason. A default here would let a
+ * caller that forgot the field silently delete speech.
+ */
+declare const anchoredReplacePolicySchema: z.ZodEnum<{
+  cascade: "cascade";
+  remap: "remap";
+}>;
+type AnchoredReplacePolicy = z.infer<typeof anchoredReplacePolicySchema>;
+/**
+ * Replace a contiguous run of main-track clips with a new run.
+ *
+ * A composite of delete + insert that cannot be expressed as the two ops in
+ * sequence, because the anchored speeches have to survive *across* the swap: with
+ * `remap` they are re-anchored positionally, which needs both the old and the new
+ * ids in the same transaction (ADR 0009 — the cascade stays in the editor, callers
+ * never re-wire anchors themselves).
+ *
+ * Duration facts follow `addVideoClips`: `media_duration_ms` is the source's
+ * intrinsic length and the trim window defaults to the whole media. The effective
+ * timeline duration is derived by the projection, never an input.
+ *
+ * `media_id` is optional: omitting it creates a **deliberate empty placeholder
+ * clip** (`origin_media_id: ''`) — structure with no picture. This is the only op
+ * that can produce one, and it is authoritative state, unlike the gap fillers the
+ * read-side solve mints (which never enter the document).
+ */
+declare const replaceVideoClipSequenceInputSchema: z.ZodObject<{
+  old_clip_ids: z.ZodArray<z.ZodString>;
+  new_clips: z.ZodArray<z.ZodObject<{
+    media_id: z.ZodOptional<z.ZodString>;
+    media_duration_ms: z.ZodNumber;
+    play_in: z.ZodOptional<z.ZodNumber>;
+    play_out: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>>;
+  on_anchored: z.ZodEnum<{
+    cascade: "cascade";
+    remap: "remap";
+  }>;
+}, z.core.$strip>;
+type ReplaceVideoClipSequenceInput = z.infer<typeof replaceVideoClipSequenceInputSchema>;
+//#endregion
+//#region src/editor/schemas/set-bgm.d.ts
+/**
+ * Set the document BGM. The media's stable result (storage key) arrives
+ * materialized from upstream (see
+ * `results/phase-4-side-effect-payload-contract.md` §3). The op upserts the bgm
+ * part and seats it on the bgm lane; its effective length is always the whole
+ * timeline, derived by the projection on read — so there is no `duration_ms`
+ * input or fact (RFC 02 / `reference/16` §0b). A `bgm_id` lets the op replace an
+ * existing bgm part by id.
+ */
+declare const setBgmInputSchema: z.ZodObject<{
+  bgm_id: z.ZodString;
+  audio_storage_key: z.ZodString;
+  origin_media_id: z.ZodString;
+  volume: z.ZodNumber;
+}, z.core.$strip>;
+type SetBgmInput = z.infer<typeof setBgmInputSchema>;
+//#endregion
+//#region src/editor/schemas/set-caption-style.d.ts
+/**
+ * Set the caption visual style. GLOBAL by design: the style applies to every
+ * caption part in the document — it carries NO `caption_id`. This mirrors the FE,
+ * whose caption-style store (`caption-style.ts:persistCaptionStylePatch`) iterates
+ * ALL captions and writes the same normalized style to each; the product has a
+ * single document-wide caption style, not per-caption styling.
+ *
+ * Every field is optional and maps to a `CaptionStyle` attribute (snake_case
+ * IDL). A field present in the input is written to every caption; a field ABSENT
+ * from the input is left untouched on each caption (the editor merges the patch
+ * onto each caption's existing style — this is a value edit, not a full-style
+ * replace, so a partial patch such as "recolor only" does not wipe font size).
+ *
+ * Pure document edit, no cascade — captions keep their positions; only the style
+ * sub-map of each caption part changes.
+ */
+declare const setCaptionStyleInputSchema: z.ZodObject<{
+  font_id: z.ZodOptional<z.ZodString>;
+  font_size: z.ZodOptional<z.ZodNumber>;
+  font_color: z.ZodOptional<z.ZodString>;
+  font_weight: z.ZodOptional<z.ZodNumber>;
+  entrance_animation: z.ZodOptional<z.ZodString>;
+  entrance_animation_duration_ms: z.ZodOptional<z.ZodNumber>;
+  stroke_color: z.ZodOptional<z.ZodString>;
+  stroke_width: z.ZodOptional<z.ZodNumber>;
+  position_x: z.ZodOptional<z.ZodNumber>;
+  position_y: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type SetCaptionStyleInput = z.infer<typeof setCaptionStyleInputSchema>;
+//#endregion
+//#region src/editor/schemas/set-caption-visibility.d.ts
+/**
+ * Toggle caption visibility (the caption track's `is_hidden` flag). Pure
+ * document edit, no cascade — captions keep their positions; only the lane's
+ * hidden flag changes.
+ */
+declare const setCaptionVisibilityInputSchema: z.ZodObject<{
+  is_hidden: z.ZodBoolean;
+}, z.core.$strip>;
+type SetCaptionVisibilityInput = z.infer<typeof setCaptionVisibilityInputSchema>;
+//#endregion
+//#region src/editor/schemas/set-video-clip-speed-shift.d.ts
+/**
+ * Set the playback speed of existing video clips. Per the speed-shift decision
+ * (`reference/16` §0): the op writes only the `speed_shift` fact — it does NOT
+ * store an effective `duration_ms` (projection derives it from the trim window /
+ * speed) and does NOT scale anchored speeches' relative offsets (offsets stay
+ * put; the cascade reflows absolute positions). A `null` speed_shift clears the
+ * speed back to original (1×).
+ */
+declare const setVideoClipSpeedShiftInputSchema: z.ZodObject<{
+  clips: z.ZodArray<z.ZodObject<{
+    clip_id: z.ZodString;
+    speed_shift: z.ZodNullable<z.ZodObject<{
+      category: z.ZodEnum<{
+        curve: "curve";
+        linear: "linear";
+      }>;
+      mode: z.ZodString;
+      config: z.ZodUnion<readonly [z.ZodObject<{
+        linear: z.ZodObject<{
+          speed: z.ZodNumber;
+        }, z.core.$strip>;
+      }, z.core.$strip>, z.ZodObject<{
+        curve: z.ZodObject<{
+          keyframes: z.ZodArray<z.ZodObject<{
+            position: z.ZodNumber;
+            rate: z.ZodNumber;
+            in_tangent: z.ZodOptional<z.ZodObject<{
+              x: z.ZodNumber;
+              y: z.ZodNumber;
+            }, z.core.$strip>>;
+            out_tangent: z.ZodOptional<z.ZodObject<{
+              x: z.ZodNumber;
+              y: z.ZodNumber;
+            }, z.core.$strip>>;
+          }, z.core.$strip>>;
+        }, z.core.$strip>;
+      }, z.core.$strip>]>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type SetVideoClipSpeedShiftInput = z.infer<typeof setVideoClipSpeedShiftInputSchema>;
+//#endregion
+//#region src/editor/schemas/shared.d.ts
+declare const clipIdSchema: z.ZodString;
+declare const clipIdsSchema: z.ZodArray<z.ZodString>;
+declare const mediaIdSchema: z.ZodString;
+declare const speechIdSchema: z.ZodString;
+declare const timelineMsSchema: z.ZodNumber;
+declare const positiveMsSchema: z.ZodNumber;
+declare const volumeSchema: z.ZodNumber;
+declare const speechIdsSchema: z.ZodArray<z.ZodString>;
+/**
+ * A clip's playback-speed fact, the only thing `SetVideoClipSpeedShift` writes.
+ * Mirrors the IDL `SpeedShift`: `category` is `linear` | `curve`, and `config`
+ * is a discriminated union — `{ linear: { speed } }` for a constant multiplier
+ * (the multiplier projection reads at `config.linear.speed`) or `{ curve: {
+ * keyframes } }` for a Bezier-controlled variable speed (RFC 02 / `reference/16`
+ * §0). Exactly one of `linear` / `curve` is present.
+ */
+declare const speedShiftSchema: z.ZodObject<{
+  category: z.ZodEnum<{
+    curve: "curve";
+    linear: "linear";
+  }>;
+  mode: z.ZodString;
+  config: z.ZodUnion<readonly [z.ZodObject<{
+    linear: z.ZodObject<{
+      speed: z.ZodNumber;
+    }, z.core.$strip>;
+  }, z.core.$strip>, z.ZodObject<{
+    curve: z.ZodObject<{
+      keyframes: z.ZodArray<z.ZodObject<{
+        position: z.ZodNumber;
+        rate: z.ZodNumber;
+        in_tangent: z.ZodOptional<z.ZodObject<{
+          x: z.ZodNumber;
+          y: z.ZodNumber;
+        }, z.core.$strip>>;
+        out_tangent: z.ZodOptional<z.ZodObject<{
+          x: z.ZodNumber;
+          y: z.ZodNumber;
+        }, z.core.$strip>>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  }, z.core.$strip>]>;
+}, z.core.$strip>;
+declare const voiceSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+}, z.core.$strip>;
+//#endregion
+//#region src/editor/schemas/speech-assets.d.ts
+/**
+ * The materialized TTS result shared by `AddSpeeches` / `ChangeSpeechScript` /
+ * `ChangeSpeechVoice` (see `results/phase-4-side-effect-payload-contract.md`
+ * §1/§2). The side effect (TTS/ASR + billing) runs upstream; the op receives the
+ * stable speech + caption parts and writes them as authoritative facts. No
+ * cascade runs on write — the projection derives absolute positions on read.
+ *
+ * Each speech carries the anchoring fact directly (RFC 02 §4): the host video
+ * clip `anchor_part_id` and the `offset_ms` within it. The upstream caller
+ * already knows which clip a speech attaches to, so the op writes
+ * `{ mode:'anchored', anchorPartId, offsetMs }` verbatim — no write-time
+ * host-picking. Captions anchor to their speech via the caption part's
+ * `start_ms` (offset within the speech).
+ */
+declare const speechAssetSchema: z.ZodObject<{
+  speech_id: z.ZodString;
+  anchor_part_id: z.ZodString;
+  offset_ms: z.ZodNumber;
+  audio_storage_key: z.ZodString;
+  duration_ms: z.ZodNumber;
+  audio_script: z.ZodString;
+  volume: z.ZodNumber;
+  voice: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+  }, z.core.$strip>;
+  origin_speech_id: z.ZodString;
+  caption_ids: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+declare const captionAssetSchema: z.ZodObject<{
+  caption_id: z.ZodString;
+  speech_part_id: z.ZodString;
+  text: z.ZodString;
+  start_ms: z.ZodNumber;
+  duration_ms: z.ZodNumber;
+}, z.core.$strip>;
+/** A materialized speech-subtree write (speeches + their captions). */
+declare const speechAssetsSchema: z.ZodObject<{
+  speeches: z.ZodArray<z.ZodObject<{
+    speech_id: z.ZodString;
+    anchor_part_id: z.ZodString;
+    offset_ms: z.ZodNumber;
+    audio_storage_key: z.ZodString;
+    duration_ms: z.ZodNumber;
+    audio_script: z.ZodString;
+    volume: z.ZodNumber;
+    voice: z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+    }, z.core.$strip>;
+    origin_speech_id: z.ZodString;
+    caption_ids: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>>;
+  captions: z.ZodArray<z.ZodObject<{
+    caption_id: z.ZodString;
+    speech_part_id: z.ZodString;
+    text: z.ZodString;
+    start_ms: z.ZodNumber;
+    duration_ms: z.ZodNumber;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type SpeechAsset = z.infer<typeof speechAssetSchema>;
+type CaptionAsset = z.infer<typeof captionAssetSchema>;
+type SpeechAssets = z.infer<typeof speechAssetsSchema>;
+declare namespace index_d_exports {
+  export { AddSpeechesInput, AddVideoClipsInput, AdjustBgmVolumeInput, AdjustSpeechVolumeInput, AdjustVideoClipDurationInput, AdjustVideoClipVolumeInput, AnchoredDeletePolicy, AnchoredReplacePolicy, CaptionAsset, ChangeSpeechScriptInput, ChangeSpeechVoiceInput, DeleteBgmInput, DeleteSpeechesInput, DeleteVideoClipsInput, MoveAnchor, MoveSpeechesInput, MoveVideoClipsByAnchorInput, MoveVideoClipsInput, MovedClipAnchoredPolicy, ReplaceVideoClipContentInput, ReplaceVideoClipSequenceInput, SetBgmInput, SetCaptionStyleInput, SetCaptionVisibilityInput, SetVideoClipSpeedShiftInput, SpeechAsset, SpeechAssets, addSpeechesInputSchema, addVideoClipsInputSchema, adjustBgmVolumeInputSchema, adjustSpeechVolumeInputSchema, adjustVideoClipDurationInputSchema, adjustVideoClipVolumeInputSchema, anchoredDeletePolicySchema, anchoredReplacePolicySchema, changeSpeechScriptInputSchema, changeSpeechVoiceInputSchema, clipIdSchema, clipIdsSchema, deleteBgmInputSchema, deleteSpeechesInputSchema, deleteVideoClipsInputSchema, mediaIdSchema, moveAnchorSchema, moveSpeechesInputSchema, moveVideoClipsByAnchorInputSchema, moveVideoClipsInputSchema, movedClipAnchoredPolicySchema, positiveMsSchema, replaceVideoClipContentInputSchema, replaceVideoClipSequenceInputSchema, setBgmInputSchema, setCaptionStyleInputSchema, setCaptionVisibilityInputSchema, setVideoClipSpeedShiftInputSchema, speechAssetsSchema, speechIdSchema, speechIdsSchema, speedShiftSchema, timelineMsSchema, voiceSchema, volumeSchema };
+}
 //#endregion
 //#region src/editor/schema-validator.d.ts
 interface SnapshotReadable {
@@ -1393,15 +1667,10 @@ interface OpActor {
   role: 'user' | 'agent';
 }
 interface CommitOptions {
-  /**
-   * Caller-supplied intent attached to the op's audit message.
-   *
-   * Typed as `unknown` to match `TransactAudit.intent`. The wire (real
-   * mengine-server and the in-memory test double) only surfaces **string**
-   * intents onto the audit log — non-string values stay in the Loro commit
-   * message but parse to `null`. Agent callers should pass a string.
-   */
-  intent?: unknown;
+  intent?: {
+    kind: string;
+    payload: unknown;
+  };
   /** Author of this op; omitted for writes with no acting user (bootstrap, repair). */
   actor?: OpActor;
 }
@@ -1445,8 +1714,7 @@ interface SemanticDocumentAdapter extends SnapshotReadable {
 declare class SemanticEditor {
   private readonly doc;
   private readonly validator;
-  private readonly idFactory;
-  constructor(doc: SemanticDocumentAdapter, validator?: SchemaValidator, idFactory?: PartIdFactory);
+  constructor(doc: SemanticDocumentAdapter, validator?: SchemaValidator);
   moveVideoClips(input: MoveVideoClipsInput, options?: CommitOptions): Promise<void>;
   /**
    * Reorder main-track clips relative to an anchor clip, moving them as one block.
@@ -1614,14 +1882,6 @@ declare class MirrorVideoDocumentAdapter implements SemanticDocumentAdapter {
   private disposed;
   constructor(doc: LoroDoc, mutationGuard?: DocumentMutationGuard);
   snapshot(): VideoDocument;
-  /**
-   * Native Entity authority: placement is already solved by the Entity graph.
-   *
-   * The root check goes through `getShallowValue` first because `getMap` creates
-   * the container on access — probing a legacy document for `medeo` would
-   * otherwise mutate it, which a read must never do.
-   */
-  isEntityDocument(): boolean;
   /**
    * Release mirror subscriptions; do not reuse this adapter afterwards.
    * The caller still owns the borrowed LoroDoc.
@@ -1641,62 +1901,6 @@ declare function createMirrorVideoDocument(document: VideoDocument, options?: Mi
 /** Build a `MirrorVideoDocumentAdapter` over a fresh doc seeded with `document`. */
 declare function createMirrorVideoDocumentAdapter(document: VideoDocument, options?: MirrorVideoDocumentOptions): MirrorVideoDocumentAdapter;
 //#endregion
-//#region src/document/plain-memory-adapter.d.ts
-/**
- * A `TransactAudit` widened with the ordered ids minted during that transact.
- * `generated_ids` is empty when the op never called the id factory.
- */
-interface JournalEntry extends TransactAudit {
-  /** Ids produced by the adapter's id factory during this transact, in mint order. */
-  generated_ids: string[];
-}
-interface PlainMemoryAdapterOptions {
-  /** Underlying id mint; wrapped so each call inside a transact is journaled. */
-  idFactory?: PartIdFactory;
-  /**
-   * Refuse every `transact`. Set when the seed document is an Entity projection:
-   * its timeline is owned by the Entity graph, and the document itself no longer
-   * states its provenance (business metadata left the CRDT), so the caller does.
-   */
-  readOnly?: boolean;
-}
-/**
- * Pure in-memory `SemanticDocumentAdapter` — no Loro/WASM. Holds a
- * `VideoDocumentDraft` object and applies each `transact` via immer `produce`,
- * journaling every audit that actually mutated state (plus any ids minted
- * during that transact).
- *
- * Known benign difference vs `MirrorVideoDocumentAdapter`: the editor's
- * `setPart` assigns a fresh part object on every call, so a same-value rewrite
- * produces a new immer state and IS journaled here, while the mirror's deep
- * diff emits no commit. Terminal `snapshot()` stays equal; replay is idempotent.
- */
-declare class PlainMemoryAdapter implements SemanticDocumentAdapter {
-  private state;
-  private readonly _journal;
-  private readonly baseIdFactory;
-  /** Non-null only while a `transact` edit callback is running. */
-  private pendingIds;
-  /**
-   * Recording wrapper around the underlying factory. Callers (sandbox editor)
-   * use this so every minted id is appended to the current transact's list.
-   */
-  readonly idFactory: PartIdFactory;
-  private readonly readOnly;
-  constructor(document: VideoDocument, options?: PlainMemoryAdapterOptions);
-  get journal(): readonly JournalEntry[];
-  hasContent(): boolean;
-  snapshot(): VideoDocument;
-  /**
-   * Apply one op via immer. A throw in `edit` discards the draft (state and
-   * journal unchanged). When `produce` returns the same reference, there was
-   * no structural change — skip journal, matching mirror "no change, no commit".
-   */
-  transact(edit: (draft: VideoDocumentDraft) => void, audit: TransactAudit): void;
-}
-/** Build a `PlainMemoryAdapter` seeded with `document`. */
-declare function createPlainMemoryAdapter(document: VideoDocument, options?: PlainMemoryAdapterOptions): PlainMemoryAdapter;
-//#endregion
 //#region src/document/mirror-read.d.ts
 /**
  * Project the mirror state (`VideoDocumentDraft`) into the authoritative
@@ -1753,7 +1957,7 @@ declare const partUnionSchema: z.ZodUnion<readonly [z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     kind: z.ZodLiteral<"caption">;
     initial_duration_ms: z.ZodNumber;
-    speech_part_id: z.ZodOptional<z.ZodString>;
+    speech_part_id: z.ZodString;
     text: z.ZodString;
     start_ms: z.ZodNumber;
     style: z.ZodOptional<z.ZodObject<{
@@ -1785,10 +1989,10 @@ declare const videoDocumentSchema: z.ZodObject<{
   tracks: z.ZodOptional<z.ZodArray<z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     parts_kind: z.ZodOptional<z.ZodEnum<{
-      video_clip: "video_clip";
-      speech: "speech";
-      caption: "caption";
       bgm: "bgm";
+      caption: "caption";
+      speech: "speech";
+      video_clip: "video_clip";
     }>>;
     is_hidden: z.ZodOptional<z.ZodBoolean>;
     items: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -1843,7 +2047,7 @@ declare const videoDocumentSchema: z.ZodObject<{
       id: z.ZodOptional<z.ZodString>;
       kind: z.ZodLiteral<"caption">;
       initial_duration_ms: z.ZodNumber;
-      speech_part_id: z.ZodOptional<z.ZodString>;
+      speech_part_id: z.ZodString;
       text: z.ZodString;
       start_ms: z.ZodNumber;
       style: z.ZodOptional<z.ZodObject<{
@@ -1870,4 +2074,4 @@ declare const videoDocumentSchema: z.ZodObject<{
   }, z.core.$loose>]>>>;
 }, z.core.$loose>;
 //#endregion
-export { SpeechHostMap as $, assertValidVideoDocument as A, VideoDocumentValidationIssueCode as At, EntityRow as B, SpeedShift as Bt, isImplementedSemanticOpKind as C, Timeline as Ct, PartIdFactory as D, VideoClipPart as Dt, ValidationError as E, TrackItemTimePosition as Et, ResolvedEntityTrack as F, speedOf as Ft, SequenceDuration as G, CaptionSegmentSelection as H, Track$1 as Ht, resolveEntityTimelineLayout as I, Attachment as It, JsonObject as J, SequenceRange as K, projectEntityTimeline as L, CaptionPart$1 as Lt, EntityTimelineTrackRole as M, VideoDraftContent as Mt, ResolvedEntityClipPlacement as N, VideoDraftPartUnion as Nt, generatePartId as O, VideoDocument as Ot, ResolvedEntityTimelineLayout as P, effectiveVideoClipDurationMs as Pt, DerivedItemPosition as Q, EntityTimelineProjectionError as R, CaptionStyle as Rt, SemanticOpKind as S, SpeechPart as St, SnapshotReadable as T, TrackItem as Tt, CaptionStyleFields as U, TrackItem$1 as Ut, RelationRow as V, Timeline$1 as Vt, ScriptTextSegment as W, EntityId as X, JsonValue as Y, buildInitialVideoDocument as Z, SemanticOpName as _, CaptionDisplayCue as _t, PlainMemoryAdapter as a, LaneKind as at, ImplementedSemanticOpKind as b, PartKind as bt, MirrorVideoDocumentAdapter as c, findLaneTrack as ct, createMirrorVideoDocumentAdapter as d, TrackDraft as dt, buildSpeechHostMap as et, CommitOptions as f, TrackItemDraft as ft, SemanticOpInput as g, BgmPart as gt, SemanticEditor as h, videoDocumentMirrorSchema as ht, JournalEntry as i, LANE_KINDS_IN_STACK_ORDER as it, validateVideoDocument as j, VideoDraft as jt, VideoDocumentValidationError as k, VideoDocumentValidationIssue as kt, MirrorVideoDocumentOptions as l, laneTrackId as lt, SemanticDocumentAdapter as m, VideoDocumentMirrorSchema as mt, videoDocumentSchema as n, fromVideoDocument as nt, PlainMemoryAdapterOptions as o, SolvedVideoDocument as ot, OpActor as p, VideoDocumentDraft as pt, VoiceDescriptor as q, readVideoDocumentFromDraft as r, toVideoDocument as rt, createPlainMemoryAdapter as s, ensureLaneTrack as st, partUnionSchema as t, derivePositionFromAbs as tt, createMirrorVideoDocument as u, solveVideoDocument as ut, TransactAudit as v, CaptionPart as vt, SchemaValidator as w, Track as wt, PlannedSemanticOpKind as x, PartUnion as xt, IMPLEMENTED_SEMANTIC_OP_KINDS as y, DEFAULT_UNIT_TIME_MS as yt, EntityRelationRows as z, PartAggregation as zt };
+export { VideoDraft as $, assertValidVideoDocument as A, CaptionPart as B, index_d_exports as C, VideoDocumentMirrorSchema as D, VideoDocumentDraft as E, buildSpeechHostMap as F, Timeline as G, PartKind as H, derivePositionFromAbs as I, TrackItemTimePosition as J, Track as K, fromVideoDocument as L, buildInitialVideoDocument as M, DerivedItemPosition as N, videoDocumentMirrorSchema as O, SpeechHostMap as P, VideoDocumentValidationIssueCode as Q, toVideoDocument as R, ValidationError as S, TrackItemDraft as T, PartUnion as U, DEFAULT_UNIT_TIME_MS as V, SpeechPart as W, VideoDocument as X, VideoClipPart as Y, VideoDocumentValidationIssue as Z, PlannedSemanticOpKind as _, MirrorVideoDocumentOptions as a, PartAggregation as at, SchemaValidator as b, CommitOptions as c, Track$1 as ct, SemanticEditor as d, VideoDraftContent as et, SemanticOpInput as f, ImplementedSemanticOpKind as g, IMPLEMENTED_SEMANTIC_OP_KINDS as h, MirrorVideoDocumentAdapter as i, CaptionStyle as it, validateVideoDocument as j, VideoDocumentValidationError as k, OpActor as l, TrackItem$1 as lt, TransactAudit as m, videoDocumentSchema as n, Attachment as nt, createMirrorVideoDocument as o, SpeedShift as ot, SemanticOpName as p, TrackItem as q, readVideoDocumentFromDraft as r, CaptionPart$1 as rt, createMirrorVideoDocumentAdapter as s, Timeline$1 as st, partUnionSchema as t, VideoDraftPartUnion as tt, SemanticDocumentAdapter as u, SemanticOpKind as v, TrackDraft as w, SnapshotReadable as x, isImplementedSemanticOpKind as y, BgmPart as z };