@mengine/medeo-client 2.1.0 → 2.1.1-dsl.0

package/dist/legacy.d.ts

@@ -0,0 +1,1044 @@
+import { i as VideoDraft, l as VideoDraftPartUnion, o as VideoDraftContent, p as CommitOptions, t as CaptionDisplayCue } from "./video-draft-types-c_shaRyq.js";
+import { A as MengineAuditResponse, B as base64ToBytes, C as MengineEventStreamOptions, D as MengineHttpRequestError, E as MengineHttpClientOptions, F as MengineRejectedResponse, I as MengineSnapshotResponse, L as MengineSseUpdateEvent, M as MengineDraftResponse, N as MenginePushResponse, O as MenginePushRejectedError, P as MenginePushUpdateResponse, R as MengineSyncResponse, S as PushResultKind, T as MengineHttpClient, V as bytesToBase64, _ as encodeDocVersionMark, a as MengineDocSessionOptions, b as PullResult, c as DocStorageLike, d as MedeoHttpDocStorageOptions, f as PushOutcome, g as decodeDocVersionMark, h as ManualSyncTransport, j as MengineDocumentVersion, k as MengineAuditEntry, l as MengineUndoState, m as ManualSyncDocOptions, o as MengineDocSyncState, p as PushOutcomeKind, s as WaitForServerAckOptions, t as MemoryDocStorage, u as MedeoHttpDocStorage, v as DocVersionMark, w as readMengineEventStream, x as PushResult, y as PullFailureReason, z as MengineUpdateMeta } from "./index-B7fC7q7P.js";
+import { LoroDoc, PeerID } from "loro-crdt";
+
+//#region ../medeo-dsl/depreacted/sandbox.d.ts
+/** Kinds a script can author. */
+type EntityKind = 'timeline' | 'track' | 'clip' | 'sequence-marker' | 'video' | 'audio' | 'voiceover-recording' | 'image' | 'voice' | 'audio-script' | 'phonetic-script' | 'caption' | 'asset';
+type RelationKind = 'contain' | 'marker' | 'clip-anchor' | 'voice-timbre' | 'caption-alignment' | 'derived-from' | 'from-asset' | 'to-asset';
+/** One segment of an AudioScript, identified by a stable id rather than its ordinal. */
+interface Segment {
+  segmentId: string;
+}
+interface ScriptSegment extends Segment {
+  text: string;
+  language?: string;
+}
+interface SegmentTime extends Segment {
+  startMs: number;
+  endMs: number;
+}
+/**
+ * Sequence: content that can be placed on a Track. It always has a length;
+ * `null` means infinite.
+ */
+interface Sequence {
+  durationMs: number | null;
+}
+/**
+ * A variant names its bases; every field it does not state reads through to
+ * the base that has it, and membership is unordered. Any kind but an Asset may
+ * be a variant; a PhoneticScript and a Caption always are.
+ */
+interface Composed {
+  bases: string[];
+}
+/** Every style field a Caption may own; anything else is refused. */
+interface CaptionStyle {
+  font?: {
+    system: 'font-library';
+    key: string;
+  };
+  fontSize?: number;
+  fontColor?: string;
+  fontWeight?: number;
+  entranceAnimation?: string;
+  entranceAnimationDurationMs?: number;
+  strokeColor?: string;
+  strokeWidth?: number;
+  positionX?: number;
+  positionY?: number;
+}
+/** A kind, or a relation, with no fields of its own. */
+type Empty = Record<never, never>;
+/** Own fields by kind. A kind states these and nothing else. */
+interface Payload {
+  /** Structure only: its Tracks are its content. */
+  timeline: Empty;
+  /** What the Track is for; the roles a document starts with come with its snapshot. */
+  track: {
+    role: string;
+    hidden?: boolean;
+  };
+  /** Where it sits in its Track is the order of its contain Relation; a Marker startMs overrides where it begins. volume is decibels, -60 to 20, 0 the source's own level. */
+  clip: {
+    volume?: number;
+  };
+  'sequence-marker': {
+    /** In point on the source, from 0. */inMs: number; /** Out point on the source. outMs - inMs is how long this content runs. */
+    outMs: number; /** Where the Clip begins, overriding its order: on the Track, or inside the Clip named by clip-anchor. */
+    startMs?: number; /** Linear speed; omitted means 1. Played length is (outMs - inMs) / rate. Video and audio only. */
+    rate?: number; /** BGM only: run as long as the Timeline instead of the source. */
+    fillTimeline?: true; /** Assigned AudioScript times, counted from the annotated audio's start; annotation Markers only. */
+    segmentRanges?: SegmentTime[];
+  };
+  /** Media is made from stored bytes: link its Asset with from-asset. */
+  video: Sequence;
+  /** Sound that carries no language: BGM, sound effects, a video's own track. Spoken language is a voiceover-recording. */
+  audio: Sequence;
+  /** Speech. It states the PhoneticScript it was spoken from through derived-from. */
+  'voiceover-recording': Sequence;
+  image: Sequence;
+  /** A timbre identity, never playable; the take rendered with it is a voiceover-recording. */
+  voice: {
+    voice: {
+      system: 'voice-library';
+      key: string;
+      name?: string;
+    };
+  };
+  /** A script written here owns its text; one read off media links the transcript it was read from with from-asset. */
+  'audio-script': {
+    segments: ScriptSegment[];
+  };
+  /** Pronunciation the plain script cannot state, in the target TTS vocabulary. */
+  'phonetic-script': Composed & {
+    phonemeScript?: string;
+  };
+  caption: Sequence & Composed & {
+    /** One script segment, or a half-open code-point range inside it. */selection: Segment & {
+      textRange?: {
+        start: number;
+        end: number;
+      };
+    };
+    style?: CaptionStyle;
+    segmentRanges?: SegmentTime[];
+  };
+  /**
+   * Stored bytes. A document holds one Asset per system and key: reuse the one
+   * it has. Every field but system and key is a fact the host records.
+   */
+  asset: {
+    /** Speech results (ids starting `sph_`) are memota-speech; every other resource is memota. */system: 'memota' | 'memota-speech'; /** The bytes' id in that store. */
+    key: string; /** Where the bytes live in storage. */
+    storageKey?: string; /** Fingerprint of the bytes. */
+    digest?: string;
+    /**
+     * The bytes are this document's own content written out, so it may write
+     * them again: their digest is one it can work out from that content at any
+     * time, which is how it sees that the content has moved past them. Bytes a
+     * store produced state nothing here and are never written again.
+     */
+    writable?: true;
+  };
+}
+/** Stated in full, or stated by a variant over its bases. An Asset is the bytes themselves and has no variant. */
+type StoredPayload<K extends EntityKind> = Payload[K] | (K extends 'asset' ? never : Partial<Payload[K]> & Composed);
+//#endregion
+//#region ../medeo-dsl/depreacted/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/depreacted/src/entities/types.d.ts
+/** One independently identified Medeo domain object. Peer associations belong in Relation rows. */
+interface MedeoEntity<K extends EntityKind = EntityKind> {
+  readonly entityId: EntityId;
+  readonly entityKind: K;
+}
+type Of<K extends EntityKind> = MedeoEntity<K> & Readonly<Payload[K]>;
+type Voice = Of<'voice'>;
+type Caption = Of<'caption'>;
+/** One persisted entity: its identity, its kind, and the fields its row states — in full, or as a variant. */
+type EntityRow<K extends EntityKind = EntityKind> = { [P in K]: {
+  readonly entityId: EntityId;
+  readonly entityKind: P;
+  readonly payload: Readonly<StoredPayload<P>>;
+} }[K];
+/**
+ * An entity read through its bases: every field its kind has, wherever it is
+ * stated. A document that compiled reads this way; so does any row stating
+ * all it has.
+ */
+type AssembledRow<K extends EntityKind = EntityKind> = { [P in K]: {
+  readonly entityId: EntityId;
+  readonly entityKind: P;
+  readonly payload: Readonly<Payload[P]>;
+} }[K];
+//#endregion
+//#region ../medeo-dsl/depreacted/src/relations/types.d.ts
+/**
+ * Authoritative persisted relation value. Every kind gives endpoint 0 and
+ * endpoint 1 their own roles, so the positions a row states are kept as given.
+ */
+interface RelationRow<K extends RelationKind = RelationKind> {
+  readonly relationId: RelationId;
+  readonly endpoint0EntityId: EntityId;
+  readonly endpoint1EntityId: EntityId;
+  readonly relationKind: K;
+}
+//#endregion
+//#region ../medeo-dsl/depreacted/src/compile.d.ts
+/** A document's stored rows: every entity and every relation. This is what compiles. */
+interface EntityRelationRows {
+  readonly entities: readonly EntityRow[];
+  readonly relations: readonly RelationRow[];
+}
+//#endregion
+//#region ../medeo-dsl/depreacted/src/entities/runtime.d.ts
+type ScriptCompositionIssueCode = 'field_conflict' | 'composition_cycle' | 'invalid_bases' | 'composition_dangling' | 'unknown_segment' | 'empty_selection' | 'invalid_script' | 'invalid_selection';
+declare class ScriptCompositionError extends Error {
+  readonly code: ScriptCompositionIssueCode;
+  readonly entityId: EntityId;
+  constructor(code: ScriptCompositionIssueCode, entityId: EntityId, message: string);
+}
+/**
+ * An entity read through its `bases`: an own field wins, otherwise the field
+ * comes from the base that has it, however deep.
+ *
+ * The payload is a live, read-only view. Reads follow edits to any base; writes
+ * are refused, and go through `updateEntityFields`, which finds the entity that
+ * actually owns the field.
+ *
+ * Reading never judges the composition. Missing bases, cycles and two bases
+ * supplying one field are compile errors, reported by `checkComposition`; on
+ * uncompiled rows a read skips what it cannot reach and takes the first base
+ * that has the field.
+ *
+ * Naming the kind the caller expects narrows the row to that kind's fields.
+ */
+declare function assembleEntityContent<K extends EntityKind = EntityKind>(rows: EntityRelationRows, entityId: EntityId, kind?: K): AssembledRow<K>;
+/** The entity whose own payload holds `field` for this entity — itself or a base — or undefined when none does. */
+declare function resolveEntityFieldOwner(rows: EntityRelationRows, entityId: EntityId, field: string): EntityId | undefined;
+/** The whole text a row carries — its own segments or those it reads through its bases — in segment order. */
+declare function assembleScriptText(row: EntityRow): string;
+/** A row's segments, own or composed; pass an assembled row to read through its bases. */
+declare function segmentsOf(row: EntityRow): readonly ScriptSegment[];
+/**
+ * The text a Caption shows: the segment its `selection` names, among the
+ * segments it reads through its bases, narrowed by `textRange`. Pass the
+ * assembled Caption; a stored Caption holds no segments of its own.
+ */
+declare function selectedSegment(caption: EntityRow): ScriptSegment;
+//#endregion
+//#region src/legacy/projection/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/legacy/projection/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): VideoDraftContent;
+//#endregion
+//#region src/legacy/projection/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;
+}
+/** Validated graph lookup shared by the compatibility layout and projection. */
+declare class EntityProjectionGraph {
+  readonly rows: EntityRelationRows;
+  readonly entities: ReadonlyMap<string, AssembledRow>;
+  readonly timeline: AssembledRow<'timeline'>;
+  constructor(rows: EntityRelationRows);
+  /** The entity with this id; naming its kind narrows the row to that kind's fields. */
+  entity<K extends EntityKind = EntityKind>(id: string, kind?: K): AssembledRow<K>;
+  adjacent(id: string, kind: RelationKind): AssembledRow[];
+  /** What this entity contains, as opposed to what contains it. */
+  holds(id: string): AssembledRow[];
+  heldBy(id: string): AssembledRow[];
+  /**
+   * Ordered relations put the product at endpoint 0 and its source at endpoint 1.
+   * One entity can sit on both sides of the same kind — a Voiceover Recording is
+   * spoken from a PhoneticScript and is itself what a transcript was read from —
+   * so provenance is never read through the undirected `adjacent`.
+   */
+  madeFrom(id: string, kind: RelationKind): AssembledRow[];
+  madeInto(id: string, kind: RelationKind): AssembledRow[];
+  one<K extends EntityKind = EntityKind>(id: string, relation: RelationKind, kind?: K, values?: AssembledRow[]): AssembledRow<K>;
+}
+/**
+ * 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 resolveGraphLayout(graph: EntityProjectionGraph): ResolvedEntityTimelineLayout;
+//#endregion
+//#region src/entity-editor/entity-graph-http-client.d.ts
+/** One authenticated revision of the authoritative Medeo Entity graph. */
+interface EntityGraphState {
+  /** Current AudioScript attached to the project, or null until one is written. */
+  readonly audioScriptEntityId: string | null;
+  readonly revision: number;
+  readonly loroSnapshot: string;
+  readonly rows: EntityRelationRows;
+}
+interface EntityGraphCommitOptions {
+  /** Server version vector proving the explicit legacy-to-Entity migration baseline. */
+  readonly migrationBaseVv?: string;
+}
+/** Browser-safe authenticated Loro client for a document's Entity graph. */
+declare class EntityGraphHttpClient {
+  private readonly options;
+  private readonly transport;
+  private readonly endpoint;
+  constructor(options: MengineHttpClientOptions);
+  fetchState(): Promise<EntityGraphState>;
+  /**
+   * Apply edits against the original causal snapshot and publish native Loro operations.
+   *
+   * Deletion intent is derived from baseline IDs omitted from `nextRows`, so a
+   * transient create-then-remove never becomes a request to delete unknown
+   * persisted data.
+   */
+  commit(baseState: Pick<EntityGraphState, 'revision' | 'rows' | 'loroSnapshot'>, nextRows: EntityRelationRows, options?: EntityGraphCommitOptions): Promise<EntityGraphState>;
+  /** Send the same prepared bytes on retry; never re-apply an unconfirmed edit. */
+  commitUpdate(update: string): Promise<EntityGraphState>;
+  private request;
+}
+//#endregion
+//#region src/entity-editor/types.d.ts
+/** Injectable domain-id mint shared by Entity and Relation authoring surfaces. */
+type EntityTimelineIdFactory = (prefix: 'entity' | 'relation') => string;
+interface ImageMediaAssetFact {
+  readonly assetId: string;
+  readonly kind: 'image';
+  readonly durationMs: number | null;
+  readonly storageKey?: string;
+}
+interface VideoMediaAssetFact {
+  readonly assetId: string;
+  readonly kind: 'video';
+  readonly durationMs: number | null;
+  readonly storageKey?: string;
+}
+interface AudioMediaAssetFact {
+  readonly assetId: string;
+  readonly kind: 'audio';
+  readonly durationMs: number | null;
+  readonly storageKey: string;
+}
+/**
+ * Speech. It materializes as a `voiceover` entity — its own kind, because only
+ * speech answers which words it said; `voice` names the timbre identity it was
+ * synthesized with, which becomes its own Voice entity linked by a
+ * `voice-timbre` Relation.
+ */
+interface VoiceoverMediaAssetFact {
+  /** Stable external speech result id, independent of the placed Clip id. */
+  readonly assetId: string;
+  readonly kind: 'voiceover-recording';
+  readonly durationMs: number | null;
+  readonly storageKey: string;
+  /**
+   * The PhoneticScript this take was spoken from, when the caller minting it
+   * knows. A migration that rebuilds the whole chain relates it itself; either
+   * way a take that never names one is refused when a plan is built.
+   */
+  readonly phoneticScriptEntityId?: string;
+  /** Present for synthesized speech, absent for original recorded audio. */
+  readonly voice?: Voice['voice'];
+}
+/**
+ * Facts resolved from media storage. Every medium states its length: whole
+ * milliseconds, or `null` for infinite. A trim window never substitutes for it.
+ */
+type MediaAssetFact = ImageMediaAssetFact | VideoMediaAssetFact | AudioMediaAssetFact | VoiceoverMediaAssetFact;
+/** Where a Clip starts: in flow by order, or at a stated start on its Track or inside its host. */
+type ClipPlacement = {
+  readonly kind: 'sequential';
+  readonly order: number;
+} | {
+  readonly kind: 'absolute';
+  readonly startMs: number;
+} | {
+  readonly kind: 'anchored';
+  readonly hostClipEntityId: string;
+  readonly startMs: number;
+};
+interface InsertPlacedClipInput {
+  readonly trackEntityId: string;
+  readonly contentEntityId: string;
+  readonly inMs: number;
+  readonly outMs: number;
+  readonly placement: ClipPlacement;
+  readonly clipPayload?: Payload['clip'];
+  /** Stable caller-owned placement identity, when one already exists outside the graph. */
+  readonly clipEntityId?: string;
+}
+interface SetClipPlacementInput {
+  readonly clipEntityId: string;
+  readonly placement: ClipPlacement;
+}
+type SequentialClipAnchor = {
+  readonly position: 'before' | 'after';
+  readonly clipEntityId: string;
+} | {
+  readonly position: 'trackStart';
+};
+interface MoveSequentialClipsInput {
+  readonly clipEntityIds: readonly string[];
+  readonly anchor: SequentialClipAnchor;
+  readonly onAnchored: 'follow' | 'keepAbsolute';
+}
+interface MoveClipsToStartsInput {
+  readonly moves: readonly {
+    readonly clipEntityId: string;
+    readonly newStartMs: number;
+  }[];
+  /** Absolute-time drags preserve every voiceover's current visible landing. */
+  readonly onAnchored: 'keepAbsolute';
+}
+interface DeleteClipTreeInput {
+  readonly clipEntityIds: readonly string[];
+  readonly onAnchored: 'cascade' | 'detach';
+}
+interface VoiceoverCaptionFact {
+  /** Stable placed caption identity supplied by the materialized side effect. */
+  readonly captionClipEntityId: string;
+  /** Directly held bases; includes the AudioScript the voiceover was rendered from. */
+  readonly bases: readonly string[];
+  /** Ordered selection of AudioScript segments; caption text is never passed inline. */
+  readonly selection: Caption['selection'];
+  readonly startMs: number;
+  readonly durationMs: number;
+  readonly style?: CaptionStyle;
+}
+type VoiceoverTakeInput = {
+  readonly timelineEntityId: string; /** Stable placed speech identity, distinct from media.assetId. */
+  readonly voiceoverClipEntityId: string;
+  readonly media: VoiceoverMediaAssetFact; /** Existing pronunciation variant; its composed AudioScript stays the text owner. */
+  readonly phoneticScriptEntityId: string;
+  readonly volume: number;
+  readonly captions: readonly VoiceoverCaptionFact[];
+} & ({
+  readonly placement: ClipPlacement;
+  readonly hostClipEntityId?: never;
+  readonly startMs?: never;
+} | {
+  readonly placement?: never;
+  readonly hostClipEntityId: string;
+  readonly startMs: number;
+});
+type VisualMediaAssetFact = ImageMediaAssetFact | VideoMediaAssetFact;
+interface InsertMediaClipInput {
+  readonly timelineEntityId: string;
+  readonly clipEntityId?: string;
+  readonly media: VisualMediaAssetFact;
+  /** Window on the source, whole milliseconds. An Image uses it as its finite display span. */
+  readonly inMs: number;
+  readonly outMs: number;
+  readonly placement: ClipPlacement;
+  readonly volume?: number;
+}
+interface ReplaceMediaClipInput {
+  readonly clipEntityId: string;
+  readonly media: VisualMediaAssetFact;
+  readonly inMs: number;
+  readonly outMs: number;
+}
+interface ReplacementMediaClipInput {
+  readonly clipEntityId?: string;
+  readonly media: VisualMediaAssetFact;
+  readonly inMs: number;
+  readonly outMs: number;
+  readonly volume?: number;
+}
+type MediaClipInsertion = {
+  readonly kind: 'before';
+  readonly clipEntityId: string;
+} | {
+  readonly kind: 'after';
+  readonly clipEntityId: string;
+} | {
+  readonly kind: 'firstStart';
+  readonly startMs: number;
+};
+interface InsertMediaClipsInput {
+  readonly timelineEntityId: string;
+  readonly clips: readonly ReplacementMediaClipInput[];
+  /** One placement decision for the whole input-ordered block. */
+  readonly insertion: MediaClipInsertion;
+}
+interface ReplaceSequentialClipsInput {
+  readonly timelineEntityId: string;
+  readonly oldClipEntityIds: readonly string[];
+  readonly newClips: readonly ReplacementMediaClipInput[];
+  readonly onAnchored: 'remap' | 'cascade';
+}
+interface SetClipVolumeInput {
+  readonly clipEntityId: string;
+  /** Playback gain in decibels. */
+  readonly volume: number;
+}
+interface LinearClipSpeed {
+  readonly kind: 'linear';
+  readonly rate: number;
+  readonly mode?: string;
+}
+interface SetClipSpeedInput {
+  readonly clipEntityId: string;
+  /** Linear speed; null restores the source's own pace. */
+  readonly rate: number | null;
+}
+interface TrimClipInput {
+  readonly clipEntityId: string;
+  readonly inMs: number;
+  readonly outMs: number;
+}
+interface VoiceoverTakeResult {
+  readonly voiceoverClipEntityId: string;
+  /** The rendered voiceover Audio entity. */
+  readonly voiceoverAudioEntityId: string;
+  /** The timbre identity it was synthesized with, when the take declared one. */
+  readonly voiceEntityId?: string;
+  /** The pronunciation variant the voiceover was rendered from. */
+  readonly phoneticScriptEntityId: string;
+  /** The base-text owner resolved from the PhoneticScript bases. */
+  readonly audioScriptEntityId: string;
+  readonly captionClipEntityIds: readonly string[];
+}
+interface MoveVoiceoverInput {
+  readonly voiceoverClipEntityId: string;
+  /** Absolute requested timeline start; MEngine resolves and persists the host relation. */
+  readonly newStartMs: number;
+}
+interface DeleteVoiceoverInput {
+  readonly voiceoverClipEntityIds: readonly string[];
+}
+interface SetBgmInput {
+  readonly timelineEntityId: string;
+  readonly bgmClipEntityId: string;
+  readonly media: AudioMediaAssetFact;
+  readonly volume: number;
+}
+interface DeleteBgmInput {
+  readonly timelineEntityId: string;
+}
+interface SetCaptionVisibilityInput {
+  readonly timelineEntityId: string;
+  readonly hidden: boolean;
+}
+interface PatchCaptionStyleInput {
+  readonly timelineEntityId: string;
+  readonly style: CaptionStyle;
+}
+interface InsertCaptionClipInput {
+  readonly timelineEntityId: string;
+  /** Existing generation identity for newly materialized Caption content, distinct from its Clip. */
+  readonly captionEntityId?: string;
+  /** Stable placed caption identity, distinct from the Caption content identity. */
+  readonly captionClipEntityId?: string;
+  /** Existing bases composed by this variant; includes an AudioScript text owner. */
+  readonly bases: readonly string[];
+  /** Ordered selection of the AudioScript segments this Caption displays. */
+  readonly selection: Caption['selection'];
+  /** Intrinsic cue length of the Caption entity itself; display comes from the placement. */
+  readonly durationMs: number;
+  readonly style?: CaptionStyle;
+  readonly placement: ClipPlacement;
+}
+interface InsertClipInput {
+  readonly trackEntityId: string;
+  /** Existing Sequence media Entity id. Asset ids and URLs are not content ids. */
+  readonly contentEntityId: string;
+  readonly inMs: number;
+  readonly outMs: number;
+  readonly startMs?: number;
+  /** Where among its Track's Clips it lands; appended when omitted. */
+  readonly order?: number;
+  readonly clipPayload?: Payload['clip'];
+}
+interface UpdateClipMarkerInput {
+  readonly clipEntityId: string;
+  readonly inMs?: number;
+  readonly outMs?: number;
+  /** Passing `undefined` explicitly removes the optional start. */
+  readonly startMs?: number | undefined;
+  /** Passing `undefined` explicitly removes the optional rate. */
+  readonly rate?: number | undefined;
+}
+interface MoveClipInput {
+  readonly clipEntityId: string;
+  readonly trackEntityId: string;
+}
+interface ReplaceClipContentInput {
+  readonly clipEntityId: string;
+  /** Existing Sequence media Entity id. Asset ids and URLs are not content ids. */
+  readonly contentEntityId: string;
+  readonly inMs: number;
+  readonly outMs: number;
+  readonly startMs?: number;
+  readonly rate?: number;
+}
+interface DeleteClipInput {
+  readonly clipEntityId: string;
+}
+interface UpdateClipInput {
+  readonly clipEntityId: string;
+  /** Complete replacement for the Clip-owned payload. */
+  readonly payload: Payload['clip'];
+}
+type ClipEntityId = EntityId;
+//#endregion
+//#region src/entity-editor/entity-timeline-editor.d.ts
+/**
+ * Graph-native timeline authoring over authoritative Medeo Entity and Relation rows.
+ *
+ * Each mutation is applied to a detached graph, validated as a complete DSL set,
+ * and committed only after validation succeeds.
+ */
+declare class EntityTimelineEditor {
+  private readonly idFactory;
+  private state;
+  constructor(initialRows: EntityRelationRows, idFactory?: EntityTimelineIdFactory);
+  rows(): EntityRelationRows;
+  insertClip(input: InsertClipInput): ClipEntityId;
+  insertPlacedClip(input: InsertPlacedClipInput): ClipEntityId;
+  updateClipMarker(input: UpdateClipMarkerInput): void;
+  setClipPlacement(input: SetClipPlacementInput): void;
+  moveSequentialClips(input: MoveSequentialClipsInput): void;
+  moveClipsToStarts(input: MoveClipsToStartsInput): void;
+  moveClip(input: MoveClipInput): void;
+  replaceClipContent(input: ReplaceClipContentInput): void;
+  insertMediaClip(input: InsertMediaClipInput): ClipEntityId;
+  insertMediaClips(input: InsertMediaClipsInput): readonly ClipEntityId[];
+  replaceMediaClip(input: ReplaceMediaClipInput): void;
+  setClipVolume(input: SetClipVolumeInput): void;
+  setClipSpeed(input: SetClipSpeedInput): void;
+  trimClip(input: TrimClipInput): void;
+  replaceSequentialClips(input: ReplaceSequentialClipsInput): readonly ClipEntityId[];
+  deleteClip(input: DeleteClipInput): void;
+  deleteClipTree(input: DeleteClipTreeInput): void;
+  updateClip(input: UpdateClipInput): void;
+  upsertVoiceoverTake(input: VoiceoverTakeInput): VoiceoverTakeResult;
+  moveVoiceover(input: MoveVoiceoverInput): void;
+  deleteVoiceover(input: DeleteVoiceoverInput): void;
+  setBgm(input: SetBgmInput): ClipEntityId;
+  deleteBgm(input: DeleteBgmInput): void;
+  setCaptionVisibility(input: SetCaptionVisibilityInput): void;
+  patchCaptionStyle(input: PatchCaptionStyleInput): void;
+  /**
+   * Place a Caption as a composed variant of an existing AudioScript: the
+   * entity stores bases, selection, optional style, and inherent cue-bounded
+   * Sequence. This helper does not copy base text. The Clip and its display Marker describe this use;
+   * moving or stretching the returned Clip later changes the Clip/Marker,
+   * never the Caption entity or the AudioScript.
+   */
+  insertCaptionClip(input: InsertCaptionClipInput): ClipEntityId;
+  private insertPlacedClipIntoDraft;
+  private ensureRoleTrack;
+  /** The existing pronunciation variant a voiceover consumes; composition is required. */
+  private requireComposedPhoneticScript;
+  /** Preserve the factual synthesis input, regardless of persisted endpoint positions. */
+  private ensurePhoneticRender;
+  private reconcileVoiceoverCaptions;
+  private ensureRoleTrackForClip;
+  /** A Caption follows one take; it is relinked only when that take changes. */
+  private replaceCaptionAlignment;
+  /**
+   * Remove one placed Caption use. The composed AudioScript outlives the
+   * caption: it may anchor further captions and remains the text owner.
+   */
+  private removeCaptionClipGraph;
+  private replaceAnchorHost;
+  /** Rebuild the legacy edit baseline from current visual order before a high-level cascade. */
+  private normalizeMainSequential;
+  private resolveOneVoiceoverOverlap;
+  private applyClipPlacement;
+  private reanchorAtAbsolute;
+  private removeAnchoredDescendants;
+  private removeClipGraph;
+  private transact;
+  private mintEntityId;
+  private createRelation;
+  private relinkRelation;
+  private mintRelationId;
+}
+//#endregion
+//#region src/entity-editor/editor-resources.d.ts
+declare const roleOrder: {
+  readonly caption: 0;
+  readonly video_clip: 1;
+  readonly speech: 2;
+  readonly bgm: 3;
+};
+type EditorTrackRole = keyof typeof roleOrder;
+interface EditorFoundation {
+  readonly rows: EntityRelationRows;
+  readonly timelineEntityId: string;
+  readonly trackEntityIds: Readonly<Record<EditorTrackRole, string>>;
+  /** Initial or current AudioScript content ID selected by the foundation. */
+  readonly audioScriptEntityId: string | null;
+}
+/**
+ * MEngine editor policy, not a cardinality restriction on the general-purpose DSL.
+ *
+ * Resources live on Asset entities and are reached through `from-asset`: no
+ * other entity carries a locator, one Asset claims each `(system, key)` pair,
+ * and media reaches at most one Asset. Media whose bytes are not named through
+ * that Relation is rejected rather than guessed at.
+ */
+declare function assertCanonicalEditorResources(rows: EntityRelationRows): void;
+/**
+ * Commit-transition policy shared by the editor, the HTTP commit boundary, the
+ * host tool, and the entity stores. It compares the authoritative before and
+ * after rows of one CAS commit and enforces the resource rules on the complete
+ * after state, with no exemption for historical graphs:
+ *
+ * 1. every media Entity reaches exactly one Asset through `from-asset`;
+ * 2. no entity other than an Asset carries a locator;
+ * 3. an Asset's locator is immutable — pointing it at other bytes would
+ *    silently rewrite every entity already made from it.
+ *
+ * Deleting media is explicit and allowed.
+ */
+declare function assertMediaAssetWritePolicy(before: EntityRelationRows, after: EntityRelationRows): void;
+/** Add only missing editor structure; existing identities and owned settings are never replaced. */
+declare function ensureEditorFoundation(initial: EntityRelationRows, idFactory?: EntityTimelineIdFactory, selectedAudioScriptEntityId?: string | null): EditorFoundation;
+//#endregion
+//#region src/entity-editor/media-asset-import.d.ts
+interface ImportedMediaAsset {
+  readonly rows: EntityRelationRows;
+  /** The media entity for this asset id. */
+  readonly contentEntityId: string;
+  /** The Asset the media was made from; shared by every entity naming the same bytes. */
+  readonly assetEntityId: string;
+  /** The timbre identity of a synthesized voiceover; absent for recorded media. */
+  readonly voiceEntityId?: string;
+}
+/**
+ * Import at the editor boundary, not at asset generation time. Existing
+ * provenance is retained.
+ *
+ * The bytes are named once, on an Asset entity, and the media entity reaches
+ * them through a `from-asset` Relation. Re-importing the same `(system, key)`
+ * reuses that Asset and the media already made from it, so one stored resource
+ * is never copied into several rows.
+ */
+declare function importMediaAsset(initial: EntityRelationRows, fact: MediaAssetFact, idFactory?: EntityTimelineIdFactory): ImportedMediaAsset;
+//#endregion
+//#region src/entity-editor/caption-content.d.ts
+interface CaptionContentInput {
+  readonly contentEntityId: string;
+  readonly audioScriptEntityId: string;
+  readonly text: string;
+  readonly selection?: Caption['selection'];
+  readonly durationMs: number;
+}
+/** Author Caption content from semantic intent; callers never reconcile variant bases or assembled fields. */
+declare function prepareCaptionContent(rows: EntityRelationRows, input: CaptionContentInput): EntityRow<'caption'>;
+//#endregion
+//#region src/entity-editor/document-audio-script.d.ts
+interface DocumentAudioScript {
+  readonly entityId: string;
+  readonly segments: readonly ScriptSegment[];
+}
+/** State exposing the current AudioScript content version attached to the project. */
+interface DocumentAudioScriptState {
+  readonly rows: EntityRelationRows;
+  /** Current attachment, or null until a script is transcribed or written. */
+  readonly audioScriptEntityId: string | null;
+}
+/** Read only the attached version and preserve every segment; never aggregate other scripts. */
+declare function readDocumentAudioScript(state: DocumentAudioScriptState): DocumentAudioScript;
+//#endregion
+//#region src/entity-crdt/json-values.d.ts
+/**
+ * What a Loro document stores and the wire carries. Entities never take this
+ * shape in code — their fields are typed by kind — only at the edge where a row
+ * becomes stored JSON, or JSON from outside becomes a row.
+ */
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonObject | readonly JsonValue[];
+type JsonObject = {
+  readonly [key: string]: JsonValue;
+};
+/**
+ * A plain object whose values are all JSON, however deep: finite numbers, no
+ * class instances, no cycles. Objects built in a script's VM realm pass, since
+ * their prototypes are that realm's `Object`, not this one's.
+ */
+declare function isJsonObject(value: unknown): value is JsonObject;
+//#endregion
+//#region src/entity-crdt/field-changes.d.ts
+/** List members are addressed by identity, never a transient array offset. */
+type FieldPath = readonly (string | {
+  elementId: string;
+})[];
+type FieldChange = {
+  op: 'set';
+  path: FieldPath;
+  value: JsonValue;
+} | {
+  op: 'unset';
+  path: FieldPath;
+} | {
+  op: 'text.splice';
+  path: FieldPath;
+  index: number;
+  deleteCount: number;
+  text: string;
+} | {
+  op: 'list.insert';
+  path: FieldPath;
+  value: JsonValue;
+  beforeElementId: string | null;
+} | {
+  op: 'list.move';
+  path: FieldPath;
+  elementId: string;
+  beforeElementId: string | null;
+} | {
+  op: 'list.remove';
+  path: FieldPath;
+  elementId: string;
+};
+declare function assertFieldChanges(changes: readonly FieldChange[]): void;
+/** Resolve against the sequential causal view; the numeric path never crosses the API boundary. */
+declare function resolveFieldPath(payload: JsonObject, path: FieldPath): (string | number)[];
+/** Detached plan evaluation. The Loro write replays the original operations, not this snapshot. */
+declare function applyFieldChanges(payload: JsonObject, changes: readonly FieldChange[]): JsonObject;
+//#endregion
+//#region src/entity-crdt/entity-document.d.ts
+declare const LORO_ENTITY_SCHEMA = "medeo.entities.loro.v1";
+interface EntityDocumentState {
+  readonly rows: EntityRelationRows;
+  readonly project: Readonly<Record<string, string>>;
+}
+type Command = {
+  type: 'create';
+  row: EntityRow;
+} | {
+  type: 'selection-baseline';
+  root: string;
+  fingerprint: string;
+} | {
+  type: 'order';
+  group: string;
+  roots: string[];
+  token: string;
+} | {
+  type: 'write';
+  root: string;
+  payload: JsonObject;
+  token: string;
+} | {
+  type: 'text';
+  root: string;
+  path: readonly (string | number)[];
+  start: number;
+  deleteCount: number;
+  text: string;
+  token: string;
+} | {
+  type: 'field';
+  root: string;
+  path: (string | number)[];
+  change: FieldChange;
+  token: string;
+} | {
+  type: 'delete';
+  root: string;
+} | {
+  type: 'relation';
+  row: RelationRow;
+} | {
+  type: 'unlink';
+  root: string;
+} | {
+  type: 'attach';
+  slot: string;
+  entityId: string;
+};
+/** Plain domain objects assembled from native Loro state, never a second writable authority. */
+declare function readEntityDocument(doc: LoroDoc, allowSelectionConflicts?: boolean): EntityDocumentState;
+/** Native editing containers survive domain version changes and merge independently. */
+declare class LoroEntityDocument {
+  readonly doc: LoroDoc;
+  private readonly validate?;
+  private readonly undoManager;
+  constructor(doc: LoroDoc, validate?: ((state: EntityDocumentState) => void) | undefined);
+  /** Open the causal snapshot an edit is applied against. */
+  static fromSnapshot(snapshot: Uint8Array, validate?: (state: EntityDocumentState) => void): LoroEntityDocument;
+  static create(rows: EntityRelationRows, project?: Readonly<Record<string, string>>, peerId?: PeerID): LoroEntityDocument;
+  snapshot(): EntityDocumentState;
+  relationsOf(entityId: string): readonly RelationRow[];
+  /** Resolve a queued edit target through its native identity without changing history. */
+  resolveCurrentEntityId(id: string): string;
+  getVersion(id: string): EntityRow | undefined;
+  /** The callback and every domain validation execute on a causally complete fork first. */
+  transact(edit: (draft: LoroEntityDraft) => void): Uint8Array;
+  /** Import preserves native operation identities; projection errors never discard remote operations. */
+  import(update: Uint8Array): void;
+  /**
+   * Bind a saved snapshot without rewriting text operations or resolving
+   * selection conflicts. The script names the bytes the same way everything
+   * else does — an Asset entity plus a Relation — and the Asset's digest says
+   * which content they hold, which is what tells a stale snapshot from a
+   * current one. The Relation is `to-asset`: these bytes are the script's own
+   * content written out, not a source it was made from, so the Asset is
+   * `writable`.
+   */
+  bindScriptAsset(entityId: string, snapshot: {
+    readonly key: string;
+    readonly digest: string;
+  }): Uint8Array;
+  canUndo(): boolean;
+  canRedo(): boolean;
+  undo(): boolean;
+  redo(): boolean;
+  private historyEdit;
+}
+declare class LoroEntityDraft {
+  private readonly doc;
+  readonly commands: Command[];
+  private readonly selectedRoots;
+  private readonly relationAliases;
+  constructor(doc: LoroDoc);
+  snapshot(): EntityDocumentState;
+  order(groupId: string, entityIds: readonly string[]): void;
+  /** Project the final scalar placement intents onto the existing native ordering containers. */
+  reconcileOrder(rows: EntityRelationRows): void;
+  create(row: EntityRow): void;
+  delete(entityId: string): void;
+  attach(slot: string, entityId: string): void;
+  link(row: RelationRow): void;
+  unlink(relationId: string): void;
+  private relationRoot;
+  update(entityId: string, fields: Partial<EntityRow['payload']>): void;
+  declare(entityId: string, fields: Partial<EntityRow['payload']>): void;
+  replaceOwned(entityId: string, payload: EntityRow['payload']): void;
+  private write;
+  editText(entityId: string, path: readonly (string | number)[], start: number, deleteCount: number, text: string): void;
+  /** Generic assembled-field edit applied at the author's causal position. */
+  change(entityId: string, changes: readonly FieldChange[]): void;
+  captureSelectionBaselines(): void;
+  private record;
+}
+//#endregion
+//#region src/entity-crdt/apply.d.ts
+/**
+ * Apply rows to a document as native Loro operations, returning the update.
+ * On a live peer the edit joins its local undo history; an edit made on an
+ * earlier baseline is applied to `LoroEntityDocument.fromSnapshot` of it.
+ */
+declare function apply(editor: LoroEntityDocument, rows: EntityRelationRows): {
+  update: Uint8Array;
+  state: EntityDocumentState;
+};
+//#endregion
+//#region src/editor/id-gen.d.ts
+/**
+ * Part-id generation, aligned with the online ecosystem.
+ *
+ * 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.
+ *
+ * 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; retained for the legacy entity sandbox host. */
+type PartIdFactory = (prefix: PartIdPrefix) => string;
+//#endregion
+//#region src/legacy/retired-journal.d.ts
+/** Retained wire shape for rejecting obsolete timeline plans; entity plans use their own journal. */
+interface JournalEntry extends CommitOptions {
+  kind: string;
+  payload: unknown;
+  generated_ids: string[];
+}
+//#endregion
+//#region src/legacy/manual-sync-doc.d.ts
+/** Legacy entity tools only. The retired timeline document has no editing or reading adapter. */
+declare class ManualSyncDoc extends ManualSyncTransport {
+  private constructor();
+  static open(options: ManualSyncDocOptions): Promise<ManualSyncDoc>;
+  isEntityDocument(): boolean;
+  content(): VideoDraftContent;
+}
+//#endregion
+//#region src/entity-crdt/audio-script-assets.d.ts
+/** The bytes a resource is stored as: its JSON text, exactly as uploaded. */
+declare function assetBytes(content: JsonObject): Uint8Array;
+/** The fingerprint of those bytes: `sha256:` and the hex of their SHA-256. */
+declare function assetDigest(content: JsonObject): string;
+/** A resource is a snapshot of text; the native Loro text remains the editing authority. */
+declare function audioScriptAssetContent(rows: EntityRelationRows, entityId: string): JsonObject;
+/** What a script's snapshot holds, which is a different document for each kind of script. */
+declare function scriptAssetContent(rows: EntityRelationRows, entityId: string): JsonObject;
+/**
+ * Whether a script's snapshot still holds its content: the Asset's digest is
+ * that of what the script would be saved as now.
+ *
+ * Only a `writable` Asset can be judged this way, because only for bytes this
+ * document wrote is the digest one it can work out again. Anything else holds a
+ * store's bytes and is left alone; a writable one with no digest cannot say
+ * what it holds, so the content is written out again.
+ */
+declare function scriptSnapshotIsCurrent(rows: EntityRelationRows, entityId: string): boolean;
+/**
+ * The Asset a script was written out to. It is a snapshot the script owns, so
+ * it is reached by `to-asset` — not `from-asset`, which would say the script
+ * was produced from bytes it cannot change.
+ */
+declare function scriptSnapshotAssetOf(rows: EntityRelationRows, entityId: string): EntityRow<'asset'> | undefined;
+/**
+ * The Asset a script was made from — a transcript it does not own. A script
+ * that has one never writes a snapshot of its own: the bytes it would describe
+ * are already named, and rewriting them would contradict their source.
+ */
+declare function scriptSourceAssetOf(rows: EntityRelationRows, entityId: string): EntityRow<'asset'> | undefined;
+/**
+ * What a PhoneticScript hands to synthesis: the base AudioScript's text as the
+ * variant pronounces it, plus the variant's own phoneme control.
+ *
+ * The variant's content is written by a model — deciding how words are said is
+ * text work, not a mechanical copy — but the bytes a synthesizer reads have to
+ * leave the entity graph to reach it, because synthesis does not handle
+ * entities. Writing this resource down is that crossing, and it is why speech
+ * can only come from a PhoneticScript.
+ */
+declare function phoneticScriptAssetContent(rows: EntityRelationRows, entityId: string): JsonObject;
+//#endregion
+export { type AudioMediaAssetFact, type CaptionContentInput, type CaptionDisplayCue, type ClipEntityId, type ClipPlacement, type DeleteBgmInput, type DeleteClipInput, type DeleteClipTreeInput, type DeleteVoiceoverInput, type DocStorageLike, DocVersionMark, type DocumentAudioScript, type DocumentAudioScriptState, type EditorFoundation, EntityDocumentState, type EntityGraphCommitOptions, EntityGraphHttpClient, type EntityGraphState, EntityProjectionGraph, EntityTimelineEditor, type EntityTimelineIdFactory, EntityTimelineProjectionError, EntityTimelineTrackRole, type FieldChange, type FieldPath, type ImageMediaAssetFact, type ImportedMediaAsset, type InsertCaptionClipInput, type InsertClipInput, type InsertMediaClipInput, type InsertMediaClipsInput, type InsertPlacedClipInput, type JournalEntry, JsonObject, JsonPrimitive, JsonValue, LORO_ENTITY_SCHEMA, type LinearClipSpeed, LoroEntityDocument, LoroEntityDraft, ManualSyncDoc, type ManualSyncDocOptions, MedeoHttpDocStorage, type MedeoHttpDocStorageOptions, type MediaAssetFact, type MediaClipInsertion, MemoryDocStorage, type MengineAuditEntry, type MengineAuditResponse, type MengineDocSessionOptions, type MengineDocSyncState, type MengineDocumentVersion, type MengineDraftResponse, type MengineEventStreamOptions, MengineHttpClient, type MengineHttpClientOptions, MengineHttpRequestError, MenginePushRejectedError, type MenginePushResponse, type MenginePushUpdateResponse, type MengineRejectedResponse, type MengineSnapshotResponse, type MengineSseUpdateEvent, type MengineSyncResponse, type MengineUndoState, type MengineUpdateMeta, type MoveClipInput, type MoveClipsToStartsInput, type MoveSequentialClipsInput, type MoveVoiceoverInput, type PartIdFactory, type PatchCaptionStyleInput, PullFailureReason, PullResult, type PushOutcome, type PushOutcomeKind, PushResult, PushResultKind, type ReplaceClipContentInput, type ReplaceMediaClipInput, type ReplaceSequentialClipsInput, type ReplacementMediaClipInput, ResolvedEntityClipPlacement, ResolvedEntityTimelineLayout, ResolvedEntityTrack, ScriptCompositionError, type SequentialClipAnchor, type SetBgmInput, type SetCaptionVisibilityInput, type SetClipPlacementInput, type SetClipSpeedInput, type SetClipVolumeInput, type TrimClipInput, type UpdateClipInput, type UpdateClipMarkerInput, type VideoDraft, type VideoDraftContent, type VideoDraftPartUnion, type VideoMediaAssetFact, type VisualMediaAssetFact, type VoiceoverCaptionFact, type VoiceoverMediaAssetFact, type VoiceoverTakeInput, type VoiceoverTakeResult, type WaitForServerAckOptions, apply, applyFieldChanges, assembleEntityContent, assembleScriptText, assertCanonicalEditorResources, assertFieldChanges, assertMediaAssetWritePolicy, assetBytes, assetDigest, audioScriptAssetContent, base64ToBytes, bytesToBase64, decodeDocVersionMark, encodeDocVersionMark, ensureEditorFoundation, generatePartId, importMediaAsset, isJsonObject, phoneticScriptAssetContent, prepareCaptionContent, projectEntityTimeline, readDocumentAudioScript, readEntityDocument, readMengineEventStream, resolveEntityFieldOwner, resolveEntityTimelineLayout, resolveFieldPath, resolveGraphLayout, scriptAssetContent, scriptSnapshotAssetOf, scriptSnapshotIsCurrent, scriptSourceAssetOf, segmentsOf, selectedSegment };