@mengine/medeo-client 1.3.1-alpha.8 → 1.4.0

package/dist/{index-BUkDsU7c.d.ts → index-CX7IXsnp.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,8 @@ 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;
+declare const VIDEO_DOCUMENT_SCHEMA_VERSION: 'video-document/v0';
+type VideoDocumentSchemaVersion = typeof VIDEO_DOCUMENT_SCHEMA_VERSION;
 type PartKind = 'video_clip' | 'speech' | 'caption' | 'bgm';
 /**
  * Project-level creation settings. Mirrors the IDL, but keeps the two fields the
@@ -487,11 +484,7 @@ 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.
+ * principle 4.
  */
 type CaptionPart = Omit<CaptionPart$1, 'duration_ms'> & {
   initial_duration_ms?: number | undefined;
@@ -559,19 +552,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
@@ -678,7 +658,6 @@ interface VideoDocumentMeta {
   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'];
 }
 /**
@@ -839,170 +818,6 @@ interface InitialDocumentFacts {
  */
 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;
-}
-/**
- * One ordered entry of the Caption's segment 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;
-//#endregion
 //#region src/document/validation.d.ts
 /**
  * Business-level schema guard for `VideoDocument` (RFC 03 §9). It is the gate
@@ -1120,35 +935,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 {
@@ -1302,15 +1693,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;
 }
@@ -1345,18 +1731,18 @@ 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.
@@ -1484,6 +1870,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;
@@ -1499,16 +1898,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;
+  /**
+   * Release mirror subscriptions; do not reuse this adapter afterwards.
+   * The caller still owns the borrowed LoroDoc.
+   */
+  dispose(): void;
   /**
    * 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`
@@ -1522,64 +1928,12 @@ 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
 /**
@@ -1637,7 +1991,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<{
@@ -1664,10 +2018,7 @@ declare const partUnionSchema: z.ZodUnion<readonly [z.ZodObject<{
 }, 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";
-    }>;
+    schema_version: z.ZodLiteral<"video-document/v0">;
     draft_id: z.ZodOptional<z.ZodString>;
     project_id: z.ZodOptional<z.ZodString>;
     owner_id: z.ZodOptional<z.ZodString>;
@@ -1682,9 +2033,9 @@ declare const videoDocumentSchema: z.ZodObject<{
   tracks: z.ZodOptional<z.ZodArray<z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     parts_kind: z.ZodOptional<z.ZodEnum<{
-      speech: "speech";
-      caption: "caption";
       bgm: "bgm";
+      caption: "caption";
+      speech: "speech";
       video_clip: "video_clip";
     }>>;
     is_hidden: z.ZodOptional<z.ZodBoolean>;
@@ -1740,7 +2091,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<{
@@ -1767,4 +2118,4 @@ declare const videoDocumentSchema: z.ZodObject<{
   }, z.core.$loose>]>>>;
 }, z.core.$loose>;
 //#endregion
-export { VoiceDescriptor as $, generatePartId as A, effectiveVideoClipDurationMs as At, ResolvedEntityClipPlacement as B, PlannedSemanticOpKind as C, VideoClipPart as Ct, SnapshotReadable as D, VideoDocumentValidationIssueCode as Dt, SchemaValidator as E, VideoDocumentValidationIssue as Et, videoDocumentMirrorSchema as F, PartAggregation as Ft, EntityTimelineProjectionError as G, ResolvedEntityTrack as H, VideoDocumentValidationError as I, SpeedShift as It, CaptionSegmentSelection as J, EntityRelationRows as K, assertValidVideoDocument as L, Timeline$1 as Lt, TrackItemDraft as M, Attachment as Mt, VideoDocumentDraft as N, CaptionPart$1 as Nt, ValidationError as O, VideoDraft as Ot, VideoDocumentMirrorSchema as P, CaptionStyle as Pt, SequenceRange as Q, validateVideoDocument as R, Track$1 as Rt, ImplementedSemanticOpKind as S, VIDEO_DOCUMENT_SCHEMA_VERSION as St, isImplementedSemanticOpKind as T, VideoDocumentSchemaVersion as Tt, resolveEntityTimelineLayout as U, ResolvedEntityTimelineLayout as V, projectEntityTimeline as W, ScriptTextSegment as X, CaptionStyleFields as Y, SequenceDuration as Z, SemanticEditor as _, SpeechPart as _t, PlainMemoryAdapter as a, DerivedItemPosition as at, TransactAudit as b, TrackItem as bt, MirrorVideoDocumentAdapter as c, derivePositionFromAbs as ct, createMirrorVideoDocument as d, BgmPart as dt, JsonObject as et, createMirrorVideoDocumentAdapter as f, CaptionPart as ft, SemanticDocumentAdapter as g, PartUnion as gt, OpActor as h, PartKind as ht, JournalEntry as i, buildInitialVideoDocument as it, TrackDraft as j, speedOf as jt, PartIdFactory as k, VideoDraftPartUnion as kt, MirrorVideoDocumentOptions as l, fromVideoDocument as lt, CommitOptions as m, ENTITY_TIMELINE_PROJECTION_SCHEMA_VERSION as mt, videoDocumentSchema as n, EntityId as nt, PlainMemoryAdapterOptions as o, SpeechHostMap as ot, writeVideoDocumentToDraft as p, DEFAULT_UNIT_TIME_MS as pt, EntityRow as q, readVideoDocumentFromDraft as r, InitialDocumentFacts as rt, createPlainMemoryAdapter as s, buildSpeechHostMap as st, partUnionSchema as t, JsonValue as tt, applyEntityTimelineProjection as u, toVideoDocument as ut, SemanticOpInput as v, Timeline as vt, SemanticOpKind as w, VideoDocument as wt, IMPLEMENTED_SEMANTIC_OP_KINDS as x, TrackItemTimePosition as xt, SemanticOpName as y, Track as yt, EntityTimelineTrackRole as z, TrackItem$1 as zt };
+export { VideoDocumentSchemaVersion as $, assertValidVideoDocument as A, BgmPart as B, index_d_exports as C, VideoDocumentMirrorSchema as D, VideoDocumentDraft as E, SpeechHostMap as F, SpeechPart as G, DEFAULT_UNIT_TIME_MS as H, buildSpeechHostMap as I, TrackItem as J, Timeline as K, derivePositionFromAbs as L, InitialDocumentFacts as M, buildInitialVideoDocument as N, videoDocumentMirrorSchema as O, DerivedItemPosition as P, VideoDocument as Q, fromVideoDocument as R, ValidationError as S, TrackItemDraft as T, PartKind as U, CaptionPart as V, PartUnion as W, VIDEO_DOCUMENT_SCHEMA_VERSION as X, TrackItemTimePosition as Y, VideoClipPart as Z, PlannedSemanticOpKind as _, MirrorVideoDocumentOptions as a, CaptionPart$1 as at, SchemaValidator as b, CommitOptions as c, SpeedShift as ct, SemanticEditor as d, TrackItem$1 as dt, VideoDocumentValidationIssue as et, SemanticOpInput as f, ImplementedSemanticOpKind as g, IMPLEMENTED_SEMANTIC_OP_KINDS as h, MirrorVideoDocumentAdapter as i, Attachment as it, validateVideoDocument as j, VideoDocumentValidationError as k, OpActor as l, Timeline$1 as lt, TransactAudit as m, videoDocumentSchema as n, VideoDraft as nt, createMirrorVideoDocument as o, CaptionStyle as ot, SemanticOpName as p, Track as q, readVideoDocumentFromDraft as r, VideoDraftPartUnion as rt, createMirrorVideoDocumentAdapter as s, PartAggregation as st, partUnionSchema as t, VideoDocumentValidationIssueCode as tt, SemanticDocumentAdapter as u, Track$1 as ut, SemanticOpKind as v, TrackDraft as w, SnapshotReadable as x, isImplementedSemanticOpKind as y, toVideoDocument as z };