@mengine/medeo-client 2.0.1-alpha.2 → 2.0.1-alpha.4

package/dist/{index-B31KeDzA.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
@@ -442,10 +441,6 @@ interface VideoDraft$1 {
 }
 //#endregion
 //#region src/document/types.d.ts
-declare const VIDEO_DOCUMENT_SCHEMA_VERSION: "video-document/v0";
-/** A server-derived compatibility view, never an editor write authority. */
-declare const ENTITY_TIMELINE_PROJECTION_SCHEMA_VERSION: "video-document/entity-projection-v1";
-type VideoDocumentSchemaVersion = typeof VIDEO_DOCUMENT_SCHEMA_VERSION | typeof ENTITY_TIMELINE_PROJECTION_SCHEMA_VERSION;
 type PartKind = 'video_clip' | 'speech' | 'caption' | 'bgm';
 /**
  * Project-level creation settings. Mirrors the IDL, but keeps the two fields the
@@ -487,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;
 };
 /**
@@ -567,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
@@ -645,17 +615,52 @@ type VideoDraftPartUnion = {
   };
 };
 /**
- * Derived `VideoDraft` read-view. The shape follows the IDL verbatim except for
- * `part_library`: the IDL types its parts with the generated namespace
- * `PartUnion`, but the engine's projection emits `VideoDraftPartUnion` — the
- * authoritative parts with the derived `duration_ms` re-injected (reference/17 §7)
- * plus the engine extensions (`media_duration_ms`, the looser `SpeedShift`). This
- * is the intentional superset over the IDL `VideoDraft` (see the extensions note).
+ * Legacy Draft import shape. It allows omitted durations and engine extensions
+ * so existing fixtures and migrations can state only the facts they have.
+ * Projection returns the narrower `VideoDraftContent` contract instead.
  */
 type VideoDraft = Omit<VideoDraft$1, 'part_library' | 'video_creation_settings'> & {
   part_library: Record<string, VideoDraftPartUnion> | undefined;
   video_creation_settings?: VideoCreationSettings | undefined;
 };
+/**
+ * The complete content read model produced by the shared projection. Business
+ * identity, settings, thumbnail and revision counters are assembled by Director;
+ * keeping an explicit field list prevents new business DTO fields entering here.
+ */
+type VideoDraftContent = Pick<VideoDraft, 'timeline' | 'main_track' | 'above_main_tracks' | 'below_main_tracks' | 'part_aggregations'> & {
+  part_library: Record<string, VideoDraftContentPartUnion> | undefined;
+};
+/** Projection always states the duration field; legacy imports may omit it. */
+type VideoDraftContentPartUnion = {
+  video_clip: VideoClipPart & {
+    duration_ms: number | undefined;
+  };
+  speech?: never;
+  caption?: never;
+  bgm?: never;
+} | {
+  video_clip?: never;
+  speech: SpeechPart & {
+    duration_ms: number | undefined;
+  };
+  caption?: never;
+  bgm?: never;
+} | {
+  video_clip?: never;
+  speech?: never;
+  caption: CaptionPart & {
+    duration_ms: number | undefined;
+  };
+  bgm?: never;
+} | {
+  video_clip?: never;
+  speech?: never;
+  caption?: never;
+  bgm: BgmPart & {
+    duration_ms: number | undefined;
+  };
+};
 /** Authoritative timeline: `duration_ms` is derived (= longest track), not stored. */
 interface Timeline {
   unit_time_ms: number | undefined;
@@ -670,39 +675,19 @@ interface Timeline {
  * is not, and passes any `>= 0` guard on its way to an editor that cannot use it.
  */
 declare const DEFAULT_UNIT_TIME_MS = 33.333;
-/**
- * Project-level scalars that do not participate in track ordering. Grouped under
- * `meta` because the loro-mirror `schema()` root only accepts container schemas,
- * not bare scalars — so these must live inside a map container in storage. The
- * domain type mirrors that storage shape 1:1 (RFC 03 §4) rather than flattening,
- * keeping `VideoDocument` and the loro draft isomorphic and the mapping layer a
- * near-identity. `schema_version` lives here too (it is a scalar fact).
- */
-interface VideoDocumentMeta {
-  schema_version: VideoDocumentSchemaVersion;
-  draft_id?: string | undefined;
-  project_id: VideoDraft['project_id'];
-  owner_id: VideoDraft['owner_id'];
-  thumbnail_storage_key: VideoDraft['thumbnail_storage_key'];
-  chat_session_id: VideoDraft['chat_session_id'];
-  video_creation_settings: VideoDraft['video_creation_settings'];
-  /** Legacy imported version for v0; committed Entity revision for entity-projection-v1. */
-  version: VideoDraft['version'];
-}
 /**
  * Authoritative collaborative document: only facts. Positioning lives on each
  * `TrackItem.time_position`; absolute time, `part_aggregations`, and total
  * duration are derived in the `VideoDraft` projection, not stored here (RFC 02 §6).
  *
- * The shape mirrors the loro storage structure 1:1 (RFC 03 §4): a `meta` map of
- * project scalars, plus a single ordered `tracks` list (reference/17 §4). A
+ * The content mirrors Loro storage: timeline, part library, and a single
+ * ordered `tracks` list (reference/17 §4). Business metadata stays in Director. A
  * track's lane is expressed by its `parts_kind`, not by which container it lives
  * in — the `main` / `above` / `below` three-pane view is reconstructed at
  * projection time. Order is the list order itself, so there is no `lane` /
  * `lane_order` field to diverge under concurrent edits.
  */
 interface VideoDocument {
-  meta: VideoDocumentMeta;
   timeline: Timeline | undefined;
   tracks: Track[] | undefined;
   part_library: Record<string, PartUnion> | undefined;
@@ -726,13 +711,13 @@ interface VideoDocumentValidationIssue {
 //#endregion
 //#region src/document/projection.d.ts
 /**
- * Projection between the authoritative `VideoDocument` and the legacy
- * `VideoDraft` read-view (RFC 02 §5/§7). Both directions live here:
+ * Projection between authoritative `VideoDocument` and compatible content
+ * layouts (RFC 02 §5/§7). Both directions live here:
  *
  * - `toVideoDocument` ingests a `VideoDraft`, deriving each item's `position`
  *   from the legacy absolute layout + aggregations; derived values (abs time,
  *   `part_aggregations`, total duration) are dropped.
- * - `fromVideoDocument` solves a `VideoDocument` back into a `VideoDraft` via the
+ * - `fromVideoDocument` solves a `VideoDocument` into `VideoDraftContent` via the
  *   timeline-core cascade, re-deriving exactly those values.
  *
  * Business validation lives in `validation.ts`; `fromVideoDocument` asserts a
@@ -744,7 +729,7 @@ interface VideoDocumentValidationIssue {
  * aggregations (RFC 02 §4/§5). Absolute time, `part_aggregations`, and total
  * duration are dropped — they are re-derived by the projection.
  */
-declare function toVideoDocument(draft: VideoDraft): VideoDocument;
+declare function toVideoDocument(draft: Pick<VideoDraft, keyof VideoDraftContent>): VideoDocument;
 /** speech/attachment part_id → its host video part_id + relative offset. */
 type SpeechHostMap = Map<string, {
   hostPartId: string;
@@ -784,8 +769,8 @@ interface DerivedItemPosition {
  */
 declare function derivePositionFromAbs(partId: string, abs: number, isMain: boolean, speechHost: SpeechHostMap, partLibrary: Record<string, PartUnion | string | undefined>): DerivedItemPosition;
 /**
- * Project the authoritative `VideoDocument` back into the legacy `VideoDraft`
- * read-view, solving each item's absolute position, the `part_aggregations`, and
+ * Project `VideoDocument` into `VideoDraftContent`, solving each item's
+ * absolute position, the `part_aggregations`, and
  * the total duration via the timeline-core cascade.
  *
  * The read-view is a compatibility contract, and the IDL declares
@@ -799,32 +784,15 @@ declare function derivePositionFromAbs(partId: string, abs: number, isMain: bool
  * These two are defaultable because the projection knows their values on its own:
  * absent `unit_time_ms` means "no display granularity was ever stated" and absent
  * `is_hidden` means "this track was never hidden". `version` is NOT defaultable
- * here — its only honest value is server state (`update_seq`) that a
- * `VideoDocument` cannot see, so it stays absent and the HTTP layer fills it.
+ * 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): VideoDraft;
+declare function fromVideoDocument(document: VideoDocument): VideoDraftContent;
 //#endregion
 //#region src/document/initial-document.d.ts
-/**
- * The project facts a freshly created document is built from — exactly the five
- * fields Director sets when it creates a draft row, and nothing else.
- *
- * Deliberately not a whole `VideoDraft`: tracks and the part library of a new
- * document are empty by definition, so accepting them would mean accepting
- * values that must always be empty, and every such field is a place for a future
- * caller to send something that is silently dropped. The narrow shape makes the
- * "a new document has no content" rule structural instead of a convention.
- */
-interface InitialDocumentFacts {
-  draftId: string;
-  projectId: string | undefined;
-  ownerId: string | undefined;
-  chatSessionId: string | undefined;
-  videoCreationSettings: VideoCreationSettings | undefined;
-}
 /**
  * Build the `VideoDocument` a newly created project starts from: the caller's
- * project facts, no parts, and one empty track per lane.
+ * no parts and one empty track per lane. Business facts remain in Director.
  *
  * The empty lane tracks are the reason this function exists rather than callers
  * assembling a document inline. Lane tracks are otherwise minted lazily by the
@@ -845,171 +813,7 @@ interface InitialDocumentFacts {
  * supplies, and total duration is derived on read (RFC 02 §6), so a new document
  * has no timeline fact to state.
  */
-declare function buildInitialVideoDocument(facts: InitialDocumentFacts): 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, meta: VideoDocumentMeta): 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;
+declare function buildInitialVideoDocument(): VideoDocument;
 //#endregion
 //#region src/document/validation.d.ts
 /**
@@ -1041,29 +845,6 @@ declare function validateVideoDocument(document: unknown): VideoDocumentValidati
 //#endregion
 //#region src/document/mirror-schema.d.ts
 declare const videoDocumentMirrorSchema: import("loro-mirror").RootSchemaType<{
-  meta: import("loro-mirror").LoroMapSchema<{
-    schema_version: /*elided*/any;
-    draft_id: /*elided*/any;
-    project_id: /*elided*/any;
-    owner_id: /*elided*/any;
-    thumbnail_storage_key: /*elided*/any;
-    chat_session_id: /*elided*/any;
-    video_creation_settings: /*elided*/any;
-    version: /*elided*/any;
-  }> & {
-    options: {};
-  } & {
-    catchall: <C extends import("loro-mirror").SchemaType>(catchallSchema: C) => import("loro-mirror").LoroMapSchemaWithCatchall<{
-      schema_version: /*elided*/any;
-      draft_id: /*elided*/any;
-      project_id: /*elided*/any;
-      owner_id: /*elided*/any;
-      thumbnail_storage_key: /*elided*/any;
-      chat_session_id: /*elided*/any;
-      video_creation_settings: /*elided*/any;
-      version: /*elided*/any;
-    }, C>;
-  };
   timeline: import("loro-mirror").LoroMapSchema<{
     unit_time_ms: /*elided*/any;
   }> & {
@@ -1128,35 +909,611 @@ 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/id-gen.d.ts
+//#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
 /**
- * Part-id generation, aligned with the online ecosystem.
+ * 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):
  *
- * 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.
+ * - `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 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;
+ * 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
+/**
+ * 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.
+ *
+ * - `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.
+ *
+ * **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 {
@@ -1310,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;
 }
@@ -1350,21 +1702,19 @@ interface TransactAudit {
  * position. The caller never materializes a layout (ADR 0009).
  */
 interface SemanticDocumentAdapter extends SnapshotReadable {
-  /** True once the document holds real content (a bootstrapped/synced snapshot). */
-  hasContent(): boolean;
   /**
-   * Apply one op's whole mutation in a single transaction. `edit` mutates the
-   * document draft; the adapter diffs the result and commits once with `audit`.
+   * Apply one op's domain mutation in a single synchronous transaction. `edit`
+   * must finish before returning; async callbacks/await are unsupported. The
+   * adapter diffs the resulting draft and commits once with `audit`.
    * A throw in `edit` rolls back (the draft is discarded, Loro untouched). An
-   * edit that changes nothing produces no commit (no phantom audit entry).
+   * edit that changes nothing produces no domain commit (no phantom undo step).
    */
   transact(edit: (draft: VideoDocumentDraft) => void, audit: TransactAudit): void;
 }
 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.
@@ -1492,6 +1842,19 @@ declare class SemanticEditor {
   private computeAddInsertIndex;
 }
 //#endregion
+//#region src/document/document-mutation-guard.d.ts
+/**
+ * @internal
+ * Shared by synchronous mutation entry points for one document. The session
+ * closes it before teardown callbacks can attempt another write.
+ */
+declare class DocumentMutationGuard {
+  private running;
+  private closed;
+  run<T>(mutation: () => T): T;
+  close(): void;
+}
+//#endregion
 //#region src/document/mirror-adapter.d.ts
 interface MirrorVideoDocumentOptions {
   peerId?: PeerID;
@@ -1507,22 +1870,23 @@ interface MirrorVideoDocumentOptions {
  * - `transact(edit, audit)` runs the whole op in one `mirror.setState` callback:
  *   one diff, one `doc.commit` carrying the audit message. The callback edits an
  *   immer draft, so a throw inside it discards the draft and never touches Loro
- *   (natural rollback) — no `guard` / `rollback` / `openTransaction` machinery.
+ *   (natural rollback) without a document checkout or compensating commit.
  * - mirror's `idSelector` (track items keyed by `part_id`) diffs reorders to
  *   real Loro `move` ops on every lane, so per-item CRDT identity survives on
  *   main and secondary tracks alike.
  */
 declare class MirrorVideoDocumentAdapter implements SemanticDocumentAdapter {
   readonly doc: LoroDoc;
+  private readonly mutationGuard;
   private readonly mirror;
-  constructor(doc: LoroDoc);
+  private disposed;
+  constructor(doc: LoroDoc, mutationGuard?: DocumentMutationGuard);
   snapshot(): VideoDocument;
   /**
-   * True once the doc holds real document content. A fresh mirror over an empty
-   * doc still reports defaulted root maps, so probe the stored `schema_version`
-   * (empty until a snapshot is bootstrapped or synced in).
+   * Release mirror subscriptions; do not reuse this adapter afterwards.
+   * The caller still owns the borrowed LoroDoc.
    */
-  hasContent(): boolean;
+  dispose(): void;
   /**
    * Apply one op as a single transaction. `edit` mutates the immer draft; mirror
    * diffs the result and commits once with the audit `message`. A throw in `edit`
@@ -1530,72 +1894,20 @@ declare class MirrorVideoDocumentAdapter implements SemanticDocumentAdapter {
    * skips the commit — matching the prior "empty op leaves no audit" behavior.
    */
   transact(edit: (draft: VideoDocumentDraft) => void, audit: TransactAudit): void;
+  private assertActive;
 }
 /** Build a fresh Loro doc seeded with `document` through the mirror. */
 declare function createMirrorVideoDocument(document: VideoDocument, options?: MirrorVideoDocumentOptions): LoroDoc;
 /** Build a `MirrorVideoDocumentAdapter` over a fresh doc seeded with `document`. */
 declare function createMirrorVideoDocumentAdapter(document: VideoDocument, options?: MirrorVideoDocumentOptions): MirrorVideoDocumentAdapter;
-/** Host-only replacement of a derived view, retaining the existing Loro history. */
-declare function applyEntityTimelineProjection(doc: LoroDoc, projection: VideoDocument, entityRevision: number): Uint8Array;
-/** Write a whole `VideoDocument` into a draft (seed a fresh doc / plain-memory state). */
-declare function writeVideoDocumentToDraft(draft: VideoDocumentDraft, document: VideoDocument): void;
-//#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;
-}
-/**
- * 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;
-  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
  * `VideoDocument`. The storage shape is isomorphic to the domain shape (RFC 03
- * §4, reference/17 §4: meta map + a single `tracks` list + part_library), so this
+ * §4, reference/17 §4: timeline + a single `tracks` list + part_library), so this
  * is a near-identity — it reads `time_position` / `fallback_abs_ms` JSON blobs
- * back into structured values and trims empty strings, nothing more.
+ * back into structured values and selects content fields. Legacy meta is ignored.
  *
  * It maps only authoritative facts (RFC 02 §6): `part_id` + `time_position`. The
  * projection-derived `VideoDraft` read-view (absolute time, `part_aggregations`,
@@ -1645,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<{
@@ -1671,29 +1983,16 @@ declare const partUnionSchema: z.ZodUnion<readonly [z.ZodObject<{
   }, z.core.$loose>;
 }, z.core.$loose>]>;
 declare const videoDocumentSchema: z.ZodObject<{
-  meta: z.ZodObject<{
-    schema_version: z.ZodEnum<{
-      "video-document/v0": "video-document/v0";
-      "video-document/entity-projection-v1": "video-document/entity-projection-v1";
-    }>;
-    draft_id: z.ZodOptional<z.ZodString>;
-    project_id: z.ZodOptional<z.ZodString>;
-    owner_id: z.ZodOptional<z.ZodString>;
-    thumbnail_storage_key: z.ZodOptional<z.ZodString>;
-    chat_session_id: z.ZodOptional<z.ZodString>;
-    video_creation_settings: z.ZodOptional<z.ZodUnknown>;
-    version: z.ZodOptional<z.ZodNumber>;
-  }, z.core.$loose>;
   timeline: z.ZodOptional<z.ZodObject<{
     unit_time_ms: z.ZodOptional<z.ZodNumber>;
   }, z.core.$loose>>;
   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<{
@@ -1748,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<{
@@ -1775,4 +2074,4 @@ declare const videoDocumentSchema: z.ZodObject<{
   }, z.core.$loose>]>>>;
 }, z.core.$loose>;
 //#endregion
-export { SequenceRange as $, generatePartId as A, VideoDraft as At, ResolvedEntityClipPlacement as B, Track$1 as Bt, PlannedSemanticOpKind as C, TrackItemTimePosition as Ct, SnapshotReadable as D, VideoDocumentSchemaVersion as Dt, SchemaValidator as E, VideoDocument as Et, videoDocumentMirrorSchema as F, CaptionPart$1 as Ft, EntityTimelineProjectionError as G, ResolvedEntityTrack as H, VideoDocumentValidationError as I, CaptionStyle as It, RelationRow as J, EntityRelationRows as K, assertValidVideoDocument as L, PartAggregation as Lt, TrackItemDraft as M, effectiveVideoClipDurationMs as Mt, VideoDocumentDraft as N, speedOf as Nt, ValidationError as O, VideoDocumentValidationIssue as Ot, VideoDocumentMirrorSchema as P, Attachment as Pt, SequenceDuration as Q, validateVideoDocument as R, SpeedShift as Rt, ImplementedSemanticOpKind as S, TrackItem as St, isImplementedSemanticOpKind as T, VideoClipPart as Tt, resolveEntityTimelineLayout as U, ResolvedEntityTimelineLayout as V, TrackItem$1 as Vt, projectEntityTimeline as W, CaptionStyleFields as X, CaptionSegmentSelection as Y, ScriptTextSegment as Z, SemanticEditor as _, PartKind as _t, PlainMemoryAdapter as a, buildInitialVideoDocument as at, TransactAudit as b, Timeline as bt, MirrorVideoDocumentAdapter as c, buildSpeechHostMap as ct, createMirrorVideoDocument as d, toVideoDocument as dt, VoiceDescriptor as et, createMirrorVideoDocumentAdapter as f, BgmPart as ft, SemanticDocumentAdapter as g, ENTITY_TIMELINE_PROJECTION_SCHEMA_VERSION as gt, OpActor as h, DEFAULT_UNIT_TIME_MS as ht, JournalEntry as i, InitialDocumentFacts as it, TrackDraft as j, VideoDraftPartUnion as jt, PartIdFactory as k, VideoDocumentValidationIssueCode as kt, MirrorVideoDocumentOptions as l, derivePositionFromAbs as lt, CommitOptions as m, CaptionPart as mt, videoDocumentSchema as n, JsonValue as nt, PlainMemoryAdapterOptions as o, DerivedItemPosition as ot, writeVideoDocumentToDraft as p, CaptionDisplayCue as pt, EntityRow as q, readVideoDocumentFromDraft as r, EntityId as rt, createPlainMemoryAdapter as s, SpeechHostMap as st, partUnionSchema as t, JsonObject as tt, applyEntityTimelineProjection as u, fromVideoDocument as ut, SemanticOpInput as v, PartUnion as vt, SemanticOpKind as w, VIDEO_DOCUMENT_SCHEMA_VERSION as wt, IMPLEMENTED_SEMANTIC_OP_KINDS as x, Track as xt, SemanticOpName as y, SpeechPart as yt, EntityTimelineTrackRole as z, Timeline$1 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 };