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

package/dist/index-C5wDKYqC.d.ts

@@ -0,0 +1,953 @@
+import { B as PhonemeSelection, J as SegmentSelection, L as FieldPatch, M as DslMutation, R as MedeoDslSnapshot, T as CaptionStyle, Y as StoredFile, Z as TextEdit, c as VideoDraftInput, h as DslIdFactory, it as Voice, j as DslDiagnostic, o as VideoDraftContent, p as CommitOptions, q as SegmentRange, rt as TrackRole, tt as TimeAnchor, w as CaptionSelection, z as Media } from "./video-draft-types-GqXnsOzA.js";
+import { ContainerType, Cursor, LoroDoc, PeerID, TreeID } from "loro-crdt";
+
+//#region src/dsl/action-context.d.ts
+type ClipPlacement = {
+  kind: 'sequential';
+} | {
+  kind: 'absolute';
+  startMs: number;
+} | {
+  kind: 'anchored';
+  clipId: string;
+  offsetMs: number;
+};
+//#endregion
+//#region src/dsl/clip-actions.d.ts
+type ClipSource = {
+  sourceId: string;
+  media?: never;
+} | {
+  media: Media;
+  sourceId?: never;
+};
+type AddDslClip = ClipSource & {
+  inMs?: number;
+  outMs?: number;
+  speed?: {
+    rate: number;
+  };
+  volume?: number;
+  fillTimeline?: true;
+  placement?: ClipPlacement;
+};
+interface AddDslClipsInput {
+  trackId: string;
+  clips: readonly AddDslClip[];
+  index?: number;
+}
+interface MoveDslClipsInput {
+  clipIds: readonly string[];
+  trackId: string;
+  index: number;
+  onAnchored: 'follow' | 'keepAbsolute';
+}
+interface ReplaceDslClipsInput {
+  clipIds: readonly string[];
+  clips: readonly AddDslClip[];
+  onAnchored: 'remap' | 'cascade';
+}
+interface DslClipUpdate {
+  clipId: string;
+  inMs?: number;
+  outMs?: number;
+  speed?: {
+    rate: number;
+  };
+  volume?: number;
+  placement?: ClipPlacement;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/loro-mirror@2.3.3_patch_hash=a551a0e4aa4f61ec88b0d9e970a183b5ee2955107a2e0bb03b378bc510c2f395_loro-crdt@1.16.1/node_modules/loro-mirror/dist/schema/types.d.ts
+/**
+ * Options for schema definitions
+ */
+interface SchemaOptions {
+  /** Whether the field is required */
+  required?: boolean;
+  /** Default value for the field */
+  defaultValue?: unknown;
+  /** Description of the field */
+  description?: string;
+  /**
+   * Additional validation function.
+   * Receives the domain value to validate - this will be the transformed value if a transform is defined, otherwise the raw value (string | number | boolean).
+   * Return true if valid, or a string error message if invalid.
+   */
+  validate?: (value: unknown) => boolean | string;
+  /**
+   * When set on a `schema.LoroMap` or `schema.LoroMapRecord`, new direct child
+   * containers under that map's keys are created with Loro's `ensureMergeable*`
+   * APIs instead of `setContainer`.
+   *
+   * By default, two peers that concurrently create a child container under the
+   * same Map key produce distinct container IDs; the Map slot is
+   * last-writer-wins, so one peer's child (and its contents) is silently
+   * dropped after sync. With this enabled, the child's identity derives from
+   * its logical position (parent container id + key + type), so every peer
+   * resolves to the same CRDT object and their content merges.
+   *
+   * Opt-in (default `false`) to keep the document format compatible with older
+   * `setContainer` child-container semantics. All collaborating clients must
+   * use `loro-crdt >= 1.13.3`.
+   *
+   * @see https://loro.dev/blog/mergeable-containers
+   */
+  mergeableMapChildContainers?: boolean;
+  [key: string]: unknown;
+}
+type HasExplicitDefaultValue<S extends SchemaType> = S extends {
+  options: {
+    defaultValue: unknown;
+  };
+} ? true : false;
+type AnySchemaOptions = SchemaOptions & {
+  /**
+   * Per-Any inference overrides.
+   *
+   * Notes:
+   * - `defaultLoroText` defaults to `false` for Any when omitted (primitive string),
+   *   overriding the global `inferOptions.defaultLoroText`.
+   * - `defaultMovableList` inherits from the global inference options unless specified.
+   */
+  defaultLoroText?: boolean;
+  defaultMovableList?: boolean;
+};
+/**
+ * Base interface for all schema types
+ */
+interface BaseSchemaType {
+  type: string;
+  options: SchemaOptions;
+  getContainerType(): ContainerType | null;
+}
+/**
+ * Any schema type
+ *
+ * This schema defers container inference decisions to the runtime (Mirror).
+ */
+interface AnySchemaType extends BaseSchemaType {
+  type: "any";
+  options: AnySchemaOptions;
+}
+/**
+ * String schema type
+ */
+interface StringSchemaType<T extends string = string> extends BaseSchemaType {
+  type: "string";
+  _t: T;
+}
+/**
+ * Number schema type
+ */
+interface NumberSchemaType extends BaseSchemaType {
+  type: "number";
+}
+/**
+ * Boolean schema type
+ */
+interface BooleanSchemaType extends BaseSchemaType {
+  type: "boolean";
+}
+/**
+ * Ignored field schema type
+ */
+interface IgnoreSchemaType extends BaseSchemaType {
+  type: "ignore";
+}
+/**
+ * Loro Map schema type
+ */
+interface LoroMapSchema<T extends Record<string, SchemaType>> extends BaseSchemaType {
+  type: "loro-map";
+  definition: SchemaDefinition<T>;
+}
+/**
+ * Enhanced LoroMapSchema with catchall support
+ */
+interface LoroMapSchemaWithCatchall<T extends Record<string, SchemaType>, C extends SchemaType> extends BaseSchemaType {
+  type: "loro-map";
+  definition: SchemaDefinition<T>;
+  catchallType: C;
+  catchall<NewC extends SchemaType>(catchallSchema: NewC): LoroMapSchemaWithCatchall<T, NewC>;
+}
+/**
+ * Loro List schema type
+ */
+interface LoroListSchema<T extends SchemaType> extends BaseSchemaType {
+  type: "loro-list";
+  itemSchema: T;
+  idSelector?: (item: unknown) => string;
+}
+/**
+ * Loro Movable List schema type
+ */
+interface LoroMovableListSchema<T extends SchemaType> extends BaseSchemaType {
+  type: "loro-movable-list";
+  itemSchema: T;
+  idSelector?: (item: unknown) => string;
+}
+/**
+ * Loro Text schema type
+ */
+interface LoroTextSchemaType extends BaseSchemaType {
+  type: "loro-text";
+}
+/**
+ * Loro Tree schema type
+ *
+ * Represents a tree where each node has a `data` map described by `nodeSchema`.
+ */
+interface LoroTreeSchema<T extends Record<string, SchemaType>> extends BaseSchemaType {
+  type: "loro-tree";
+  nodeSchema: LoroMapSchema<T>;
+}
+/**
+ * Field types allowed at the document root: containers, plus `Ignore`
+ * (a memory-only field that never touches the LoroDoc).
+ */
+type RootFieldSchemaType = ContainerSchemaType | IgnoreSchemaType;
+/**
+ * Root schema type
+ */
+interface RootSchemaType<T extends Record<string, RootFieldSchemaType>> extends BaseSchemaType {
+  type: "schema";
+  definition: RootSchemaDefinition<T>;
+}
+/**
+ * Union of all schema types
+ */
+type SchemaType = AnySchemaType | StringSchemaType | NumberSchemaType | BooleanSchemaType | IgnoreSchemaType | LoroMapSchema<Record<string, SchemaType>> | LoroMapSchemaWithCatchall<Record<string, SchemaType>, SchemaType> | LoroListSchema<SchemaType> | LoroMovableListSchema<SchemaType> | LoroTextSchemaType | LoroTreeSchema<Record<string, SchemaType>> | RootSchemaType<Record<string, RootFieldSchemaType>>;
+type ContainerSchemaType = LoroMapSchema<Record<string, SchemaType>> | LoroMapSchemaWithCatchall<Record<string, SchemaType>, SchemaType> | LoroListSchema<SchemaType> | LoroMovableListSchema<SchemaType> | LoroTextSchemaType | LoroTreeSchema<Record<string, SchemaType>>;
+/**
+ * Schema definition type
+ */
+type RootSchemaDefinition<T extends Record<string, RootFieldSchemaType>> = { [K in keyof T]: T[K] };
+/**
+ * Schema definition type
+ */
+type SchemaDefinition<T extends Record<string, SchemaType>> = { [K in keyof T]: T[K] };
+/**
+ * Check if a schema type is required
+ *
+ * true is default
+ */
+type IsSchemaRequired<S extends SchemaType> = S extends {
+  options: {
+    required: true;
+  };
+} ? true : S extends {
+  options: {
+    required: false;
+  };
+} ? false : S extends {
+  options: {
+    required?: undefined;
+  };
+} ? true : S extends {
+  options: {};
+} ? true : true;
+/**
+ * Infer the JavaScript type from a schema type.
+ */
+type InferType<S extends SchemaType> = S extends {
+  transform: TransformDefinition<infer _C, infer D>;
+} ? WithTransformStartupOptionality<D, S & SchemaType> : S extends StringSchemaType ? InferStringType<S> : S extends NumberSchemaType ? InferNumberType<S> : S extends BooleanSchemaType ? InferBooleanType<S> : IsSchemaRequired<S> extends false ? S extends AnySchemaType ? unknown : S extends IgnoreSchemaType ? unknown : S extends LoroTextSchemaType ? string | undefined : S extends LoroMapSchemaWithCatchall<infer M, infer C> ? keyof M extends never ? ({
+  [key: string]: InferType<C>;
+} & {
+  $cid: string;
+}) | undefined : (({ [K in keyof M]: InferType<M[K]> } & { [K in Exclude<string, keyof M>]: InferType<C> }) & {
+  $cid: string;
+}) | undefined : S extends LoroMapSchema<infer M> ? ({ [K in keyof M]: InferType<M[K]> } & {
+  $cid: string;
+}) | undefined : S extends LoroListSchema<infer I> ? Array<InferType<I>> | undefined : S extends LoroMovableListSchema<infer I> ? Array<InferType<I>> | undefined : S extends LoroTreeSchema<infer M> ? Array<InferTreeNodeTypeWithCid<M>> | undefined : S extends RootSchemaType<infer R> ? { [K in keyof R]: InferType<R[K]> } | undefined : never : S extends IgnoreSchemaType ? unknown : S extends LoroTextSchemaType ? string : S extends AnySchemaType ? unknown : S extends LoroMapSchemaWithCatchall<infer M, infer C> ? keyof M extends never ? {
+  [key: string]: InferType<C>;
+} & {
+  $cid: string;
+} : ({ [K in keyof M]: InferType<M[K]> } & { [K in Exclude<string, keyof M>]: InferType<C> }) & {
+  $cid: string;
+} : S extends LoroMapSchema<infer M> ? { [K in keyof M]: InferType<M[K]> } & {
+  $cid: string;
+} : S extends LoroListSchema<infer I> ? Array<InferType<I>> : S extends LoroMovableListSchema<infer I> ? Array<InferType<I>> : S extends LoroTreeSchema<infer M> ? Array<InferTreeNodeTypeWithCid<M>> : S extends RootSchemaType<infer R> ? { [K in keyof R]: InferType<R[K]> } : never;
+/**
+ * Infer the input (write) type for setState updates.
+ * Identical to InferType<S> except that for any LoroMap shape, the `$cid` field is optional.
+ */
+type InferInputType<S extends SchemaType> = S extends {
+  transform: TransformDefinition<infer _C, infer D>;
+} ? WithTransformStartupOptionality<D, S & SchemaType> : S extends StringSchemaType ? InferStringType<S> : S extends NumberSchemaType ? InferNumberType<S> : S extends BooleanSchemaType ? InferBooleanType<S> : IsSchemaRequired<S> extends false ? S extends AnySchemaType ? unknown : S extends IgnoreSchemaType ? unknown : S extends LoroTextSchemaType ? string | undefined : S extends LoroMapSchemaWithCatchall<infer M, infer C> ? keyof M extends never ? ({
+  [key: string]: InferInputType<C>;
+} & {
+  $cid?: string;
+}) | undefined : (({ [K in keyof M]: InferInputType<M[K]> } & { [K in Exclude<string, keyof M>]: InferInputType<C> }) & {
+  $cid?: string;
+}) | undefined : S extends LoroMapSchema<infer M> ? ({ [K in keyof M]: InferInputType<M[K]> } & {
+  $cid?: string;
+}) | undefined : S extends LoroListSchema<infer I> ? Array<InferInputType<I>> | undefined : S extends LoroMovableListSchema<infer I> ? Array<InferInputType<I>> | undefined : S extends LoroTreeSchema<infer M> ? Array<InferInputTreeNodeType<M>> | undefined : S extends RootSchemaType<infer R> ? { [K in keyof R]: InferInputType<R[K]> } | undefined : never : S extends IgnoreSchemaType ? unknown : S extends LoroTextSchemaType ? string : S extends AnySchemaType ? unknown : S extends LoroMapSchemaWithCatchall<infer M, infer C> ? keyof M extends never ? {
+  [key: string]: InferInputType<C>;
+} & {
+  $cid?: string;
+} : ({ [K in keyof M]: InferInputType<M[K]> } & { [K in Exclude<string, keyof M>]: InferInputType<C> }) & {
+  $cid?: string;
+} : S extends LoroMapSchema<infer M> ? { [K in keyof M]: InferInputType<M[K]> } & {
+  $cid?: string;
+} : S extends LoroListSchema<infer I> ? Array<InferInputType<I>> : S extends LoroMovableListSchema<infer I> ? Array<InferInputType<I>> : S extends LoroTreeSchema<infer M> ? Array<InferInputTreeNodeType<M>> : S extends RootSchemaType<infer R> ? { [K in keyof R]: InferInputType<R[K]> } : never;
+/**
+ * Helper: Infer the node type for a tree schema whose node.data map includes $cid
+ */
+type InferTreeNodeTypeWithCid<M extends Record<string, SchemaType>> = {
+  id: string;
+  data: { [K in keyof M]: InferType<M[K]> } & {
+    $cid: string;
+  };
+  children: Array<InferTreeNodeTypeWithCid<M>>;
+};
+/**
+ * Helper: Input node type for a tree schema (node.data has optional $cid)
+ */
+type InferInputTreeNodeType<M extends Record<string, SchemaType>> = {
+  id: string;
+  data: { [K in keyof M]: InferInputType<M[K]> } & {
+    $cid?: string;
+  };
+  children: Array<InferInputTreeNodeType<M>>;
+};
+/**
+ * Equality comparison strategy for transformed values.
+ *
+ * Reference equality is ALWAYS checked first.
+ * This setting controls what happens when references differ.
+ *
+ * - "reference-equality" (default): If refs differ, treat as not equal (no encoding).
+ *   Correct for Immer-draftable types, immutable types, and copy-on-change patterns.
+ *   Fast because no encoding is needed.
+ *
+ * - "encoded-value-equality": If refs differ, encode both and compare.
+ *   Use when you may have different objects with the same encoded value
+ *   and want to avoid redundant updates.
+ *
+ * - "deep-equality": If refs differ, perform a deep equality check on the domain values.
+ *   This is rarely needed as Immer-draftable objects typically maintain reference equality when unchanged,
+ *   but can be useful for non-Immer-managed objects that are slow to encode and have no simple equality check.
+ *
+ * - Custom function: Your own comparison logic. Receives the domain values.
+ */
+type EqualityStrategy<DomainType> = "reference-equality" | "encoded-value-equality" | "deep-equality" | ((a: DomainType, b: DomainType) => boolean);
+/**
+ * Transform definition for bidirectional conversion between CRDT primitives and domain types.
+ * It is strongly recommend that DomainType is immutable or
+ * [supported by Immer](https://immerjs.github.io/immer/complex-objects/) otherwise changes to transformed
+ * values may not be detected and converted to CRDT operations. Never mutate DomainType instances
+ * outside of Loro Mirror's setState function. CRDTType and DomainType can be null or undefined, but decode/encode functions
+ * will never receive null/undefined - they pass through as-is. Validation is performed on the domain type after transformation
+ * (or more precisely, validation on domain types happens before encoding).
+ */
+interface TransformDefinition<CRDTType, DomainType> {
+  /**
+   * Convert CRDT primitive to domain type.
+   * Never called with null/undefined - they pass through as-is.
+   */
+  decode: (value: CRDTType & {}) => DomainType & {};
+  /**
+   * Convert domain type to CRDT primitive.
+   * Never called with null/undefined - they pass through as-is.
+   */
+  encode: (value: DomainType & {}) => CRDTType & {};
+  /**
+   * Validate the domain value.
+   * Called during schema validation after null/undefined checks pass.
+   * Return true if valid, or a string error message if invalid.
+   * The validate function passed to schema.String | Number | Boolean will also be called.
+   */
+  validate?: (value: DomainType & {}) => boolean | string;
+  /**
+   * How to compare domain values for equality.
+   *
+   * Reference equality (===) is always checked first.
+   * This setting controls behavior when references differ.
+   *
+   * @default "reference-equality"
+   */
+  isEqual?: EqualityStrategy<DomainType>;
+  /**
+   * Whether to validate that encode() returns the correct CRDT type during schema validation.
+   * When true, encode() is called on every validation to check the return type.
+   * When false, encode type checking is skipped for better performance.
+   *
+   * @default false
+   */
+  validateEncodedType?: boolean;
+}
+/**
+ * Add | undefined to T if schema is optional (required: false).
+ * Used by InferType to add optionality to both transformed and non-transformed fields.
+ */
+type WithOptionality<T, S extends SchemaType> = IsSchemaRequired<S> extends false ? T | undefined : T;
+type WithTransformStartupOptionality<T, S extends SchemaType> = IsSchemaRequired<S> extends false ? T | undefined : HasExplicitDefaultValue<S> extends true ? T : T | undefined;
+type InferStringType<S extends SchemaType> = S extends {
+  transform: TransformDefinition<infer _C, infer D>;
+} ? WithOptionality<D, S> : S extends StringSchemaType<infer T> ? WithOptionality<T, S> : WithOptionality<string, S>;
+type InferNumberType<S extends SchemaType> = S extends {
+  transform: TransformDefinition<infer _C, infer D>;
+} ? WithOptionality<D, S> : WithOptionality<number, S>;
+type InferBooleanType<S extends SchemaType> = S extends {
+  transform: TransformDefinition<infer _C, infer D>;
+} ? WithOptionality<D, S> : WithOptionality<boolean, S>;
+//#endregion
+//#region ../medeo-dsl/src/schema/loro-shape.d.ts
+/**
+ * Only direct children inherit mergeable identity. Text and ordinary entity rows keep normal
+ * identities, so deleting a row also drops what a peer wrote into it concurrently: a relation an
+ * entity holds at most one of is a field of that row and never outlives it.
+ */
+declare const medeoDslLoroShape: RootSchemaType<{
+  'timeline-entities': LoroMapSchemaWithCatchall<{}, LoroMapSchema<{}> & {
+    options: {};
+  } & {
+    catchall: <C extends SchemaType>(catchallSchema: C) => LoroMapSchemaWithCatchall<{}, C>;
+  }> & {
+    options: {};
+  };
+  'track-entities': LoroMapSchemaWithCatchall<{}, LoroMapSchema<{
+    role: /*elided*/any;
+    hidden: /*elided*/any;
+  }> & {
+    options: {};
+  } & {
+    catchall: <C extends SchemaType>(catchallSchema: C) => LoroMapSchemaWithCatchall<{
+      role: /*elided*/any;
+      hidden: /*elided*/any;
+    }, C>;
+  }> & {
+    options: {};
+  };
+  'clip-entities': LoroMapSchemaWithCatchall<{}, LoroMapSchema<{
+    seqMarker: /*elided*/any;
+    volume: /*elided*/any;
+    source: /*elided*/any;
+    anchor: /*elided*/any;
+  }> & {
+    options: {};
+  } & {
+    catchall: <C extends SchemaType>(catchallSchema: C) => LoroMapSchemaWithCatchall<{
+      seqMarker: /*elided*/any;
+      volume: /*elided*/any;
+      source: /*elided*/any;
+      anchor: /*elided*/any;
+    }, C>;
+  }> & {
+    options: {};
+  };
+  'media-entities': LoroMapSchemaWithCatchall<{}, LoroMapSchema<{
+    kind: /*elided*/any;
+    system: /*elided*/any;
+    key: /*elided*/any;
+    storageKey: /*elided*/any;
+    durationMs: /*elided*/any;
+    digest: /*elided*/any;
+  }> & {
+    options: {};
+  } & {
+    catchall: <C extends SchemaType>(catchallSchema: C) => LoroMapSchemaWithCatchall<{
+      kind: /*elided*/any;
+      system: /*elided*/any;
+      key: /*elided*/any;
+      storageKey: /*elided*/any;
+      durationMs: /*elided*/any;
+      digest: /*elided*/any;
+    }, C>;
+  }> & {
+    options: {
+      readonly mergeableMapChildContainers: true;
+    };
+  };
+  'audio-script-entities': LoroMapSchemaWithCatchall<{}, LoroMapSchema<{
+    segments: /*elided*/any;
+    defaultLanguage: /*elided*/any;
+  }> & {
+    options: {};
+  } & {
+    catchall: <C extends SchemaType>(catchallSchema: C) => LoroMapSchemaWithCatchall<{
+      segments: /*elided*/any;
+      defaultLanguage: /*elided*/any;
+    }, C>;
+  }> & {
+    options: {};
+  };
+  'phonetic-script-entities': LoroMapSchemaWithCatchall<{}, LoroMapSchema<{
+    phoneme: /*elided*/any;
+    system: /*elided*/any;
+    key: /*elided*/any;
+    storageKey: /*elided*/any;
+    digest: /*elided*/any;
+  }> & {
+    options: {};
+  } & {
+    catchall: <C extends SchemaType>(catchallSchema: C) => LoroMapSchemaWithCatchall<{
+      phoneme: /*elided*/any;
+      system: /*elided*/any;
+      key: /*elided*/any;
+      storageKey: /*elided*/any;
+      digest: /*elided*/any;
+    }, C>;
+  }> & {
+    options: {};
+  };
+  'caption-entities': LoroMapSchemaWithCatchall<{}, LoroMapSchema<{
+    selection: /*elided*/any;
+    text: /*elided*/any;
+    style: /*elided*/any;
+  }> & {
+    options: {
+      readonly mergeableMapChildContainers: true;
+    };
+  } & {
+    catchall: <C extends SchemaType>(catchallSchema: C) => LoroMapSchemaWithCatchall<{
+      selection: /*elided*/any;
+      text: /*elided*/any;
+      style: /*elided*/any;
+    }, C>;
+  }> & {
+    options: {};
+  };
+  'voice-entities': LoroMapSchemaWithCatchall<{}, LoroMapSchema<{
+    system: /*elided*/any;
+    key: /*elided*/any;
+    name: /*elided*/any;
+  }> & {
+    options: {};
+  } & {
+    catchall: <C extends SchemaType>(catchallSchema: C) => LoroMapSchemaWithCatchall<{
+      system: /*elided*/any;
+      key: /*elided*/any;
+      name: /*elided*/any;
+    }, C>;
+  }> & {
+    options: {
+      readonly mergeableMapChildContainers: true;
+    };
+  };
+  'contain-relations': LoroTreeSchema<{
+    entityId: /*elided*/any;
+  }>;
+  'voice-timbre-relations': LoroMapSchemaWithCatchall<{}, LoroMapSchema<Record<string, StringSchemaType<string> & {
+    options: {};
+  } & {
+    transform: <D>(def: TransformDefinition<string, D>) => StringSchemaType<string> & {
+      options: {};
+      transform: TransformDefinition<string, D>;
+    };
+  }>> & {
+    options: {};
+  } & {
+    catchall: <C extends SchemaType>(catchallSchema: C) => LoroMapSchemaWithCatchall<Record<string, StringSchemaType<string> & {
+      options: {};
+    } & {
+      transform: <D>(def: TransformDefinition<string, D>) => StringSchemaType<string> & {
+        options: {};
+        transform: TransformDefinition<string, D>;
+      };
+    }>, C>;
+  }> & {
+    options: {
+      readonly mergeableMapChildContainers: true;
+    };
+  };
+  'derived-from-relations': LoroMapSchemaWithCatchall<{}, LoroMapSchema<{
+    entityId: /*elided*/any;
+    sourceId: /*elided*/any;
+    sourceDigest: /*elided*/any;
+  }> & {
+    options: {};
+  } & {
+    catchall: <C extends SchemaType>(catchallSchema: C) => LoroMapSchemaWithCatchall<{
+      entityId: /*elided*/any;
+      sourceId: /*elided*/any;
+      sourceDigest: /*elided*/any;
+    }, C>;
+  }> & {
+    options: {
+      readonly mergeableMapChildContainers: true;
+    };
+  };
+}> & {
+  options: {};
+};
+type MedeoDslLoroState = InferType<typeof medeoDslLoroShape>;
+/** Writable view: new containers do not yet have a $cid or TreeID. */
+type Input = InferInputType<typeof medeoDslLoroShape>;
+type ContainDraftNode = Omit<Input['contain-relations'][number], 'id' | 'children'> & {
+  readonly id?: string;
+  children: ContainDraftNode[];
+};
+type DraftFields<T> = T extends Cursor ? T : T extends (infer Item)[] ? DraftFields<Item>[] : T extends object ? { [K in keyof T as undefined extends T[K] ? never : K]: DraftFields<T[K]> } & { [K in keyof T as undefined extends T[K] ? K : never]?: DraftFields<T[K]> } : T;
+type MedeoDslDraft = DraftFields<Omit<Input, 'contain-relations'>> & {
+  'contain-relations': ContainDraftNode[];
+};
+//#endregion
+//#region ../medeo-dsl/src/schema/codec.d.ts
+interface InvalidAtomic {
+  invalid: true;
+  raw: string;
+  reason: string;
+}
+declare function isInvalidAtomic(value: unknown): value is InvalidAtomic;
+interface AtomicCodec<T> {
+  encode(value: T | InvalidAtomic): string;
+  decode(raw: string): T | InvalidAtomic;
+}
+/** A Clip's time anchor; the Clip holding it is the anchored end. */
+declare const timeAnchorCodec: AtomicCodec<TimeAnchor>;
+/** A Caption's selection. */
+declare const captionContentCodec: AtomicCodec<SegmentSelection>;
+//#endregion
+//#region ../medeo-dsl/src/schema/document-format.d.ts
+/** Format discrimination does not register containers or alter the document. */
+declare function documentFormat(doc: LoroDoc): 'dsl' | 'legacy' | 'mixed' | 'unknown';
+declare class UnsupportedDocumentFormatError extends Error {
+  readonly code = "unsupported_document_format";
+  constructor();
+}
+/** Run after initial import, before opening an editable handle. Empty new documents still have one Timeline. */
+declare function assertDslDocument(doc: LoroDoc): void;
+//#endregion
+//#region src/dsl/document/types.d.ts
+/** Serialized once at the transaction exit, using the existing server audit envelope. */
+interface DslAudit {
+  semantic_op: string;
+  payload: unknown;
+  intent?: unknown;
+  actor?: {
+    user_id: string;
+    role: 'user' | 'agent';
+  } | null;
+}
+/** Synchronous, scoped draft. Never retain this context or any draft object after the callback. */
+interface DslTransaction {
+  readonly draft: MedeoDslDraft;
+  applyMutations(mutations: readonly DslMutation[]): void;
+  /** Offsets use the preview after preceding edits. Existing Text identities are checked when supplied. */
+  editText(audioScriptId: string, segmentId: string, edits: readonly TextEdit[], expectedBodyId?: string): void;
+  editCaptionText(captionId: string, edits: readonly TextEdit[], expectedBodyId?: string): void;
+  /** Adds a segment at `index` (the end by default); its id must be new to the script. */
+  insertSegment(audioScriptId: string, segmentId: string, text: string, index?: number): void;
+  /** `index` is measured after removing the segment. */
+  moveSegment(audioScriptId: string, segmentId: string, index: number): void;
+  deleteSegment(audioScriptId: string, segmentId: string): void;
+  /** Creates real Cursors during application; pending ranges are not exposed as draft Cursor objects. */
+  setCaptionContent(selection: CaptionSelection): void;
+  /** Writes a PhoneticScript's phoneme, its run turned into Cursors like a Caption's. */
+  setPhoneme(selection: PhonemeSelection): void;
+}
+//#endregion
+//#region src/dsl/document/medeo-dsl.d.ts
+interface CreateMedeoDslOptions {
+  timelineId?: string;
+  peerId?: PeerID;
+  idFactory?: DslIdFactory;
+}
+/** One live DSL document. Business Actions belong to medeo-client, not this storage interface. */
+declare class MedeoDsl {
+  readonly doc: LoroDoc;
+  private readonly options;
+  private disposed;
+  private writing;
+  private rejectTransaction?;
+  private listeners;
+  private changeSource;
+  private snapshot?;
+  private dirty;
+  private notifying;
+  private readonly mirror;
+  private readonly unsubscribe;
+  private ownsDoc;
+  /** Opens a borrowed LoroDoc; dispose releases subscriptions but does not free the caller's doc. */
+  constructor(doc: LoroDoc, options?: {
+    mutationGuard?: {
+      run<T>(mutation: () => T): T;
+    };
+  });
+  /** Creates and owns a fresh document; this handle frees it on dispose. */
+  static create(options?: CreateMedeoDslOptions): MedeoDsl;
+  getSnapshot(): MedeoDslSnapshot;
+  subscribe(listener: (source: 'local' | 'remote') => void): () => void;
+  /** One synchronous, audited edit. Preparation errors discard the whole draft before native writes. */
+  transact(edit: (tx: DslTransaction) => void, audit: DslAudit): void;
+  /** Preferred vocabulary for ordinary entity/relation/Tree edits and serializable native commands. */
+  applyMutations(mutations: readonly DslMutation[], audit: DslAudit): void;
+  editText(scriptId: string, segmentId: string, expectedBodyId: string, edits: readonly TextEdit[], audit: DslAudit): void;
+  editCaptionText(captionId: string, expectedBodyId: string, edits: readonly TextEdit[], audit: DslAudit): void;
+  /**
+   * A run inside one segment as native Cursors. Local ranges exclude insertions at their start and
+   * include insertions at their end. K01 remains deferred.
+   */
+  textRange(scriptId: string, segmentId: string, start: number, end: number): SegmentSelection;
+  dispose(): void;
+  private mutate;
+  private notify;
+  private assertActive;
+}
+//#endregion
+//#region src/dsl/voiceover-actions.d.ts
+interface VoiceoverCaptionInput {
+  clipId?: string;
+  startMs: number;
+  durationMs: number;
+  /** The segment of the voiceover's script it shows, by index; timing remains a separate fact. */
+  segment: number;
+  /** A UTF-16 run inside that segment; without one the whole segment shows. */
+  range?: {
+    start: number;
+    end: number;
+  };
+  style?: CaptionStyle;
+}
+interface ApplyVoiceoverInput {
+  clipId?: string;
+  trackId: string;
+  captionTrackId?: string;
+  media: Extract<Media, {
+    kind: 'audio' | 'voiceover-recording';
+  }> & {
+    kind: 'voiceover-recording';
+  };
+  /**
+   * What the recording says: an existing AudioScript, a new one of these `segments`, or a
+   * PhoneticScript it was spoken from. A recording spoken from a PhoneticScript is derived-from it,
+   * and its captions select segments of that variant's base script.
+   */
+  script: {
+    audioScriptId: string;
+    segments?: never;
+    phoneticScriptId?: never;
+  } | {
+    segments: string[];
+    audioScriptId?: never;
+    phoneticScriptId?: never;
+    defaultLanguage?: string;
+  } | {
+    phoneticScriptId: string;
+    audioScriptId?: never;
+    segments?: never;
+  };
+  placement: ClipPlacement;
+  /**
+   * The digest of what the recording was synthesized from (D177): the PhoneticScript as it was
+   * read for synthesis. Absent, the source's digest as this voiceover leaves it is recorded.
+   */
+  sourceDigest?: string;
+  volume?: number;
+  voice?: Voice;
+  /** Complete generated caption set for this use. Other uses of the recording are untouched. */
+  captions: readonly VoiceoverCaptionInput[];
+}
+interface VoiceoverResult {
+  clipId: string;
+  mediaId: string;
+  audioScriptId: string;
+  /** Ids of a new script's segments, in order; empty when the script already exists. */
+  segmentIds: string[];
+  captionClipIds: string[];
+  captionIds: string[];
+}
+//#endregion
+//#region src/dsl/dsl-editor.d.ts
+/**
+ * Stores raw content in Memota as a text file and returns the file's facts. The host owns the
+ * store; an entity with the Media File trait keeps the facts beside the content (D178).
+ */
+type UploadText = (text: string) => Promise<StoredFile>;
+/** Business edits write DSL facts in one audited transaction; layout is derived on read. */
+declare class DslEditor {
+  readonly dsl: MedeoDsl;
+  private readonly idFactory;
+  private readonly uploadText?;
+  constructor(dsl: MedeoDsl, idFactory?: DslIdFactory, uploadText?: UploadText | undefined);
+  createTrack(role: TrackRole, options?: CommitOptions): string;
+  registerMedia(media: Media, options?: CommitOptions): string;
+  addClips(input: AddDslClipsInput, options?: CommitOptions): string[];
+  /** index is measured in the target's children after removing the moved Clip. */
+  moveClip(clipId: string, trackId: string, index?: number, options?: CommitOptions): void;
+  trimClip(clipId: string, window: {
+    inMs?: number;
+    outMs?: number;
+  }, options?: CommitOptions): void;
+  setClipSpeed(clipId: string, speed: {
+    rate: number;
+  } | undefined, options?: CommitOptions): void;
+  setClipVolume(clipId: string, volume: number | undefined, options?: CommitOptions): void;
+  /** A script of these segments, in order; each segment gets its own id. */
+  createAudioScript(segments: readonly string[], defaultLanguage?: string, options?: CommitOptions): string;
+  editAudioScript(scriptId: string, segmentId: string, expectedBodyId: string, edits: readonly TextEdit[], options?: CommitOptions): void;
+  /** Adds a segment at `index`, the end by default, and returns its id. */
+  insertScriptSegment(scriptId: string, text: string, index?: number, options?: CommitOptions): string;
+  /** `index` is measured after removing the segment. */
+  moveScriptSegment(scriptId: string, segmentId: string, index: number, options?: CommitOptions): void;
+  /** Captions and PhoneticScripts selecting the segment keep their selection, which then shows nothing (D72). */
+  deleteScriptSegment(scriptId: string, segmentId: string, options?: CommitOptions): void;
+  createCaption(input: ((SegmentRange & {
+    text?: never;
+  }) | {
+    text: string;
+    audioScriptId?: never;
+    segmentId?: never;
+    start?: never;
+    end?: never;
+  }) & {
+    style?: CaptionStyle;
+  }, options?: CommitOptions): string;
+  /** Show a segment of a script, or a run of it, in place of the Caption's own text. */
+  setCaptionContent(captionId: string, selection: SegmentRange, options?: CommitOptions): void;
+  setCaptionText(captionId: string, text: string, options?: CommitOptions): void;
+  editCaptionText(captionId: string, expectedBodyId: string, edits: readonly TextEdit[], options?: CommitOptions): void;
+  moveTrack(trackId: string, index: number, options?: CommitOptions): void;
+  setTrackHidden(trackId: string, hidden: boolean | undefined, options?: CommitOptions): void;
+  deleteTrack(trackId: string, onAnchored: 'cascade' | 'detach', options?: CommitOptions): void;
+  setClipPlacement(clipId: string, placement: ClipPlacement, options?: CommitOptions): void;
+  moveClips(input: MoveDslClipsInput, options?: CommitOptions): void;
+  deleteClips(clipIds: readonly string[], onAnchored: 'cascade' | 'detach', options?: CommitOptions): void;
+  replaceClipSource(clipId: string, input: ClipSource & {
+    inMs: number;
+    outMs: number;
+  }, options?: CommitOptions): void;
+  replaceClips(input: ReplaceDslClipsInput, options?: CommitOptions): string[];
+  updateClips(updates: readonly DslClipUpdate[], options?: CommitOptions): void;
+  patchCaptionStyle(captionIds: readonly string[], patch: FieldPatch<CaptionStyle>, options?: CommitOptions): void;
+  applyVoiceover(input: ApplyVoiceoverInput, options?: CommitOptions): VoiceoverResult;
+  private voiceoverScriptId;
+  /**
+   * Write a PhoneticScript: create one for a segment of a script, or a run of it, or, given
+   * `phoneticScriptId`, replace its selection and what to synthesize together (D181). A
+   * `phonemeScript` is stored as a Memota text file first, and the file's facts are written with
+   * it; an unchanged one keeps its file. Recordings already spoken from it keep their derived-from.
+   */
+  setPhoneticScript(input: SegmentRange & {
+    phoneticScriptId?: string;
+    phonemeScript?: string;
+  }, options?: CommitOptions): Promise<string>;
+  /** The file holding `text`: the one the PhoneticScript keeps while its text is unchanged, else a new upload. */
+  private fileFor;
+  setBgm(input: ClipSource & {
+    trackId: string;
+    clipId?: string;
+    volume?: number;
+  }, options?: CommitOptions): string;
+  private write;
+}
+//#endregion
+//#region src/dsl/initial-document.d.ts
+/** One server/host creates the foundation; peers import its binary identity instead of initializing independently. */
+declare function createInitialMedeoDsl(options?: CreateMedeoDslOptions): MedeoDsl;
+//#endregion
+//#region src/dsl/projection/types.d.ts
+interface DslClipLayout {
+  clipId: string;
+  trackId: string;
+  sourceId?: string;
+  inMs: number;
+  outMs: number;
+  rate: number;
+  volume: number;
+  startMs: number;
+  durationMs: number;
+  mode: 'sequential' | 'absolute' | 'anchored' | 'fallback';
+  anchorClipId?: string;
+  fillTimeline: boolean;
+}
+interface DslTrackLayout {
+  trackId: string;
+  role: TrackRole;
+  hidden: boolean;
+  clips: DslClipLayout[];
+}
+interface DslLayout {
+  timelineId: string;
+  tracks: DslTrackLayout[];
+  clips: Record<string, DslClipLayout>;
+  durationMs: number;
+  diagnostics: DslDiagnostic[];
+}
+/** Unsupported legacy representations fail explicitly; recoverable CRDT state is returned as diagnostics. */
+declare class DslProjectionError extends Error {
+  readonly issues: readonly DslDiagnostic[];
+  constructor(issues: readonly DslDiagnostic[]);
+}
+//#endregion
+//#region src/dsl/projection/layout.d.ts
+/** Pure deterministic solve. Constraints only move sequential roots; anchors retain their exact offsets. */
+declare function resolveDslLayout(snapshot: MedeoDslSnapshot): DslLayout;
+//#endregion
+//#region src/dsl/projection/to-video-draft.d.ts
+interface VideoDraftProjection {
+  content: VideoDraftContent;
+  diagnostics: DslDiagnostic[];
+}
+/** A content read view, not an archive of authoring identities, rich-text marks or provenance. */
+declare function toVideoDraft(snapshot: MedeoDslSnapshot): VideoDraftProjection;
+//#endregion
+//#region src/dsl/projection/audio-scripts.d.ts
+/**
+ * An AudioScript with everything that says or shows it, read from the same snapshot as the
+ * VideoDraft. Speeches and captions come in playback order.
+ */
+interface AudioScriptView {
+  id: string;
+  /** Its segments, in order. */
+  segments: {
+    id: string;
+    text: string;
+    language?: string;
+  }[];
+  /** Media the script was read off (a transcript), through derived-from. */
+  sourceMediaIds: string[];
+  /**
+   * Its variants written for synthesis: the segment each is for (by index, absent once that
+   * segment is gone), what its selection holds, what to synthesize, and its file's digest.
+   */
+  phoneticScripts: {
+    id: string;
+    segment?: number;
+    text?: string;
+    phonemeScript?: string;
+    digest?: string;
+  }[];
+  /** Speech Clips playing a recording of these words. */
+  speeches: {
+    clipId: string;
+    recordingId: string; /** The PhoneticScript the recording was spoken from; absent when it derives from the script directly. */
+    phoneticScriptId?: string;
+    voices: {
+      voiceId: string;
+      key: string;
+      name?: string;
+    }[];
+    /**
+     * Whether the recording was synthesized from its source as it is now: the digest its
+     * derived-from records equals the source's digest (D177). Absent when either has none.
+     */
+    applied?: boolean;
+  }[];
+  /** Caption Clips showing one of its segments. A Caption with its own text shows none. */
+  captions: {
+    clipId: string;
+    captionId: string;
+    segment: number;
+  }[];
+}
+/** Every AudioScript in the document with its PhoneticScripts, the Speech Clips saying it and the Caption Clips showing it. */
+declare function toAudioScriptViews(snapshot: MedeoDslSnapshot): AudioScriptView[];
+//#endregion
+//#region src/dsl/projection/from-video-draft.d.ts
+interface FromVideoDraftOptions extends CreateMedeoDslOptions {
+  /** Complete physical media facts, keyed by their external system/key; no IO runs in the converter. */
+  mediaFacts?: readonly Media[];
+  audit: DslAudit;
+}
+interface ImportedVideoDraft {
+  dsl: MedeoDsl;
+  diagnostics: DslDiagnostic[];
+}
+/** One-time import into a newly owned document; never reverse-diff a live collaborative document. */
+declare function fromVideoDraft(input: VideoDraftInput, options: FromVideoDraftOptions): ImportedVideoDraft;
+//#endregion
+export { MedeoDslDraft as A, UnsupportedDocumentFormatError as C, captionContentCodec as D, InvalidAtomic as E, ClipSource as F, DslClipUpdate as I, MoveDslClipsInput as L, medeoDslLoroShape as M, AddDslClip as N, isInvalidAtomic as O, AddDslClipsInput as P, ReplaceDslClipsInput as R, DslTransaction as S, documentFormat as T, VoiceoverCaptionInput as _, toAudioScriptViews as a, MedeoDsl as b, resolveDslLayout as c, DslProjectionError as d, DslTrackLayout as f, ApplyVoiceoverInput as g, UploadText as h, AudioScriptView as i, MedeoDslLoroState as j, timeAnchorCodec as k, DslClipLayout as l, DslEditor as m, ImportedVideoDraft as n, VideoDraftProjection as o, createInitialMedeoDsl as p, fromVideoDraft as r, toVideoDraft as s, FromVideoDraftOptions as t, DslLayout as u, VoiceoverResult as v, assertDslDocument as w, DslAudit as x, CreateMedeoDslOptions as y, ClipPlacement as z };