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

package/dist/index-Cu7SdKN5.d.ts

@@ -0,0 +1,940 @@
+import { B as Media, E as CaptionStyle, J as TextEdit, M as DslDiagnostic, N as DslMutation, Q as TimeAnchor, R as FieldPatch, T as CaptionSelection, c as VideoDraftInput, et as TrackRole, h as DslIdFactory, o as VideoDraftContent, p as CommitOptions, tt as Voice, w as CaptionContent, z as MedeoDslSnapshot } from "./video-draft-types-c_shaRyq.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/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;
+}
+declare const timeAnchorCodec: AtomicCodec<TimeAnchor>;
+declare const captionContentCodec: AtomicCodec<CaptionContent>;
+//#endregion
+//#region ../medeo-dsl/src/schema/loro-shape.d.ts
+/** Only direct children inherit mergeable identity. Body and ordinary entity rows keep normal identities. */
+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;
+  }> & {
+    options: {};
+  } & {
+    catchall: <C extends SchemaType>(catchallSchema: C) => LoroMapSchemaWithCatchall<{
+      seqMarker: /*elided*/any;
+      volume: /*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<{
+    body: /*elided*/any;
+    defaultLanguage: /*elided*/any;
+  }> & {
+    options: {};
+  } & {
+    catchall: <C extends SchemaType>(catchallSchema: C) => LoroMapSchemaWithCatchall<{
+      body: /*elided*/any;
+      defaultLanguage: /*elided*/any;
+    }, C>;
+  }> & {
+    options: {};
+  };
+  'caption-entities': LoroMapSchemaWithCatchall<{}, LoroMapSchema<{
+    text: /*elided*/any;
+    style: /*elided*/any;
+  }> & {
+    options: {
+      readonly mergeableMapChildContainers: true;
+    };
+  } & {
+    catchall: <C extends SchemaType>(catchallSchema: C) => LoroMapSchemaWithCatchall<{
+      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;
+    };
+  };
+  'asset-entities': LoroMapSchemaWithCatchall<{}, LoroMapSchema<{
+    system: /*elided*/any;
+    key: /*elided*/any;
+    storageKey: /*elided*/any;
+    digest: /*elided*/any;
+  }> & {
+    options: {};
+  } & {
+    catchall: <C extends SchemaType>(catchallSchema: C) => LoroMapSchemaWithCatchall<{
+      system: /*elided*/any;
+      key: /*elided*/any;
+      storageKey: /*elided*/any;
+      digest: /*elided*/any;
+    }, C>;
+  }> & {
+    options: {
+      readonly mergeableMapChildContainers: true;
+    };
+  };
+  'contain-relations': LoroTreeSchema<{
+    entityId: /*elided*/any;
+  }>;
+  'clip-source-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;
+    };
+  };
+  'time-anchor-relations': LoroMapSchemaWithCatchall<{}, StringSchemaType<string> & {
+    options: {};
+    transform: TransformDefinition<string, TimeAnchor | InvalidAtomic>;
+  }> & {
+    options: {};
+  };
+  'caption-content-relations': LoroMapSchemaWithCatchall<{}, StringSchemaType<string> & {
+    options: {};
+    transform: TransformDefinition<string, CaptionContent | InvalidAtomic>;
+  }> & {
+    options: {};
+  };
+  'caption-alignment-relations': LoroMapSchemaWithCatchall<{}, LoroMapSchema<{
+    captionId: /*elided*/any;
+    mediaId: /*elided*/any;
+    startMs: /*elided*/any;
+    endMs: /*elided*/any;
+  }> & {
+    options: {};
+  } & {
+    catchall: <C extends SchemaType>(catchallSchema: C) => LoroMapSchemaWithCatchall<{
+      captionId: /*elided*/any;
+      mediaId: /*elided*/any;
+      startMs: /*elided*/any;
+      endMs: /*elided*/any;
+    }, C>;
+  }> & {
+    options: {
+      readonly mergeableMapChildContainers: true;
+    };
+  };
+  '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<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;
+    };
+  };
+  'from-asset-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;
+    };
+  };
+  'to-asset-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;
+    };
+  };
+}> & {
+  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/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, edits: readonly TextEdit[], expectedBodyId?: string): void;
+  /** Creates real Cursors during application; pending ranges are not exposed as draft Cursor objects. */
+  editCaptionText(captionId: string, edits: readonly TextEdit[], expectedBodyId?: string): void;
+  setCaptionContent(selection: CaptionSelection): 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, expectedBodyId: string, edits: readonly TextEdit[], audit: DslAudit): void;
+  editCaptionText(captionId: string, expectedBodyId: string, edits: readonly TextEdit[], audit: DslAudit): void;
+  /** Local ranges exclude insertions at their start and include insertions at their end. K01 remains deferred. */
+  textRange(scriptId: string, start: number, end: number): Omit<CaptionContent, 'captionId'>;
+  dispose(): void;
+  private mutate;
+  private notify;
+  private assertActive;
+}
+//#endregion
+//#region src/dsl/voiceover-actions.d.ts
+interface VoiceoverCaptionInput {
+  clipId?: string;
+  startMs: number;
+  durationMs: number;
+  /** UTF-16 selection in the supplied AudioScript; timing remains a separate fact. */
+  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';
+  };
+  script: {
+    audioScriptId: string;
+    body?: never;
+  } | {
+    body: string;
+    audioScriptId?: never;
+    defaultLanguage?: string;
+  };
+  placement: ClipPlacement;
+  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;
+  captionClipIds: string[];
+  captionIds: string[];
+}
+//#endregion
+//#region src/dsl/dsl-editor.d.ts
+/** Business edits write DSL facts in one audited transaction; layout is derived on read. */
+declare class DslEditor {
+  readonly dsl: MedeoDsl;
+  private readonly idFactory;
+  constructor(dsl: MedeoDsl, idFactory?: DslIdFactory);
+  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;
+  createAudioScript(body: string, defaultLanguage?: string, options?: CommitOptions): string;
+  editAudioScript(scriptId: string, expectedBodyId: string, edits: readonly TextEdit[], options?: CommitOptions): void;
+  createCaption(input: ({
+    audioScriptId: string;
+    start: number;
+    end: number;
+    text?: never;
+  } | {
+    text: string;
+    audioScriptId?: never;
+    start?: never;
+    end?: never;
+  }) & {
+    style?: CaptionStyle;
+  }, options?: CommitOptions): string;
+  setCaptionContent(captionId: string, audioScriptId: string, start: number, end: number, 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;
+  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/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 { AddDslClip as A, MedeoDslDraft as C, captionContentCodec as D, InvalidAtomic as E, ReplaceDslClipsInput as F, ClipPlacement as I, ClipSource as M, DslClipUpdate as N, isInvalidAtomic as O, MoveDslClipsInput as P, documentFormat as S, medeoDslLoroShape as T, MedeoDsl as _, toVideoDraft as a, UnsupportedDocumentFormatError as b, DslLayout as c, createInitialMedeoDsl as d, DslEditor as f, CreateMedeoDslOptions as g, VoiceoverResult as h, VideoDraftProjection as i, AddDslClipsInput as j, timeAnchorCodec as k, DslProjectionError as l, VoiceoverCaptionInput as m, ImportedVideoDraft as n, resolveDslLayout as o, ApplyVoiceoverInput as p, fromVideoDraft as r, DslClipLayout as s, FromVideoDraftOptions as t, DslTrackLayout as u, DslAudit as v, MedeoDslLoroState as w, assertDslDocument as x, DslTransaction as y };