@video-editor/editor-core 1.0.0-beta.1 → 1.0.0-beta.2

package/dist/index.d.ts

@@ -1,20 +1,144 @@
+import { AssetReference } from '@video-editor/protocol';
+import { AssetReferenceTarget } from '@video-editor/protocol';
 import { ComputedRef } from '@vue/reactivity';
 import { createVideoProtocolManager } from '@video-editor/protocol';
 import { DeepReadonly } from '@vue/reactivity';
+import { IKeyframeEasing } from '@video-editor/shared';
+import { IKeyframeProperty } from '@video-editor/shared';
 import { ITrackType } from '@video-editor/shared';
 import { IVideoProtocol } from '@video-editor/shared';
+import { OperationLogMeta } from '@video-editor/protocol';
 import { SegmentUnion } from '@video-editor/shared';
 import { TrackUnion } from '@video-editor/shared';
 
 /** Result payload returned by addSegment. */
 export declare type AddSegmentResult = ReturnType<ProtocolManager['addSegment']>;
 
+/** Input and result types for track structure commands. */
+export declare type AddTrackOptions = Parameters<ProtocolManager['addTrack']>[0];
+
+export declare type AddTrackResult = ReturnType<ProtocolManager['addTrack']>;
+
+/**
+ * The single commands a batch is built from. Taken as a parameter rather than
+ * read off the finished command object so this module cannot accidentally reach
+ * for anything else.
+ */
+declare interface BatchDeps {
+    transaction: EditorCoreCommands['transaction'];
+    moveSegment: EditorCoreCommands['moveSegment'];
+    removeSegment: EditorCoreCommands['removeSegment'];
+    duplicateSegment: EditorCoreCommands['duplicateSegment'];
+    updateSegment: EditorCoreCommands['updateSegment'];
+    getSegment: EditorCoreSelectors['getSegment'];
+}
+
+/**
+ * Outcome of a batch command.
+ *
+ * A batch is atomic: either every step landed and `success` is true, or nothing
+ * did and `error` says which step refused. The resulting protocol is read from
+ * `editor.state`, which is reactive — the batch reports what it operated on, not
+ * a snapshot that later steps in the same transaction may already have moved.
+ */
+export declare interface BatchResult {
+    success: boolean;
+    /** Why the batch was rejected. Absent on success. */
+    error?: string;
+    /**
+     * The segments the batch operated on, in call order. For
+     * `duplicateSegments` these are the new copies, not the sources.
+     */
+    segmentIds: string[];
+}
+
+export declare function checkKeyframeCommand(check: KeyframeCommandCheck, getSegment: GetKeyframeSegment): CommandCheckResult;
+
+/** The commands `canRun` can answer for, with the arguments each needs. */
+export declare type CommandCheck = {
+    command: 'undo';
+} | {
+    command: 'redo';
+} | {
+    command: 'removeSegment';
+    segmentId: string;
+} | {
+    command: 'duplicateSegment';
+    segmentId: string;
+} | {
+    command: 'splitSegment';
+    segmentId: string;
+    timelineMs: number;
+} | {
+    command: 'addTransition';
+} | {
+    command: 'setCanvasSize';
+    width: number;
+    height: number;
+} | {
+    command: 'setFps';
+    fps: number;
+} | {
+    command: 'addTrack';
+    input: AddTrackOptions;
+} | {
+    command: 'removeTrack';
+    trackId: string;
+} | {
+    command: 'moveTrack';
+    trackId: string;
+    toIndex: number;
+} | {
+    command: 'replaceSegmentAsset';
+    input: ReplaceSegmentAssetOptions;
+} | KeyframeCommandCheck;
+
+export declare interface CommandCheckResult {
+    ok: boolean;
+    /** Why the command would refuse. Absent when `ok`. */
+    reason?: string;
+}
+
+export declare function createBatchCommands(deps: BatchDeps): {
+    moveSegments(moves: readonly MoveSegmentOptions[]): BatchResult;
+    removeSegments(ids: readonly string[], options?: RemoveSegmentOptions): BatchResult;
+    updateSegments(ids: readonly string[], updater: (segment: SegmentUnion) => void): BatchResult;
+    duplicateSegments(ids: readonly string[]): BatchResult;
+};
+
 export declare function createEditorCore(options: EditorCoreOptions): EditorCore;
 
+export declare function createKeyframeCommands(deps: KeyframeCommandDeps): {
+    upsertKeyframe(input: UpsertKeyframeOptions): KeyframeCommandResult;
+    moveKeyframe(input: MoveKeyframeOptions): KeyframeCommandResult;
+    removeKeyframe(input: RemoveKeyframeOptions): KeyframeCommandResult;
+    setKeyframeEasing(input: SetKeyframeEasingOptions): KeyframeCommandResult;
+};
+
 export declare function createPluginManager(ctx: EditorCoreContext): EditorCorePluginManager;
 
+export declare function createProposalManager(deps: ProposalManagerDependencies): EditorProposalManager;
+
 export declare function createSegmentRegistry(): SegmentRegistry;
 
+/**
+ * Read-only queries over the protocol.
+ *
+ * An agent has to understand the timeline before it can edit it. Without these
+ * it would have to parse the whole protocol itself, which means implementing
+ * the timeline rules a second time — and the two copies would drift.
+ */
+export declare function createStructuralSelectors(deps: StructuralSelectorDeps): {
+    getSegmentsAt: (timeMs: number, options?: SegmentsAtOptions) => SegmentPlacement[];
+    getSegmentAt: (trackId: string, timeMs: number) => SegmentUnion | undefined;
+    getTrackGaps: (trackId: string) => TrackGap[];
+    getAdjacentSegments: (segmentId: string) => SegmentNeighbours;
+    getOverlaps: (trackId?: string) => SegmentOverlap[];
+    sampleProperty: (segmentId: string, property: IKeyframeProperty, timeMs: number) => SampledProperty | undefined;
+    getSelection: () => EditorSelection;
+    canRun: (check: CommandCheck) => CommandCheckResult;
+};
+
 /** Result payload returned by duplicateSegment. */
 export declare type DuplicateSegmentResult = ReturnType<ProtocolManager['duplicateSegment']>;
 
@@ -28,6 +152,8 @@ export declare interface EditorCore {
     commands: EditorCoreCommands;
     /** Read-only selectors. */
     selectors: EditorCoreSelectors;
+    /** Isolated agent proposals waiting for review. */
+    proposals: EditorProposalManager;
     /** Plugin manager instance. */
     plugins: EditorCorePluginManager;
     /** Segment plugin registry. */
@@ -60,6 +186,8 @@ export declare interface EditorCoreCommands {
     moveSegment: ProtocolManager['moveSegment'];
     /** Resize a segment's time range. */
     resizeSegment: ProtocolManager['resizeSegment'];
+    /** Replace a media source with an explicit duration adaptation strategy. */
+    replaceSegmentAsset: ProtocolManager['replaceSegmentAsset'];
     /** Split a segment into two at a timeline position (single undo step). */
     splitSegment: ProtocolManager['splitSegment'];
     /** Add a transition at the current time or a specified time. */
@@ -70,12 +198,61 @@ export declare interface EditorCoreCommands {
     updateTransition: ProtocolManager['updateTransition'];
     /** Update a track's mutable presentation fields (hidden / muted / extra). */
     updateTrack: ProtocolManager['updateTrack'];
+    /** Add an empty track. */
+    addTrack: ProtocolManager['addTrack'];
+    /** Remove a track and all of its segments as one undo step. */
+    removeTrack: ProtocolManager['removeTrack'];
+    /** Move a track to its final zero-based position. */
+    moveTrack: ProtocolManager['moveTrack'];
     /** Resize the project canvas as a single undoable step. */
     setCanvasSize: ProtocolManager['setCanvasSize'];
+    /** Set the project frame rate as a single undoable step. */
+    setFps: ProtocolManager['setFps'];
+    /** Insert a keyframe, or update the value at the same property and time. */
+    upsertKeyframe: (input: UpsertKeyframeOptions) => KeyframeCommandResult;
+    /** Move one keyframe without replacing a frame already at the target time. */
+    moveKeyframe: (input: MoveKeyframeOptions) => KeyframeCommandResult;
+    /** Remove one keyframe and clean up its empty property track. */
+    removeKeyframe: (input: RemoveKeyframeOptions) => KeyframeCommandResult;
+    /** Change one keyframe's outgoing easing; omit easing to restore linear. */
+    setKeyframeEasing: (input: SetKeyframeEasingOptions) => KeyframeCommandResult;
     /** Replace a track id (useful for migrations). */
     replaceTrackId: ProtocolManager['replaceTrackId'];
     /** Replace a segment id (useful for migrations). */
     replaceSegmentId: ProtocolManager['replaceSegmentId'];
+    /**
+     * Move several segments as one undo step. Moves are applied in the order
+     * given; if any is refused the whole batch is rolled back.
+     */
+    moveSegments: (moves: readonly MoveSegmentOptions[]) => BatchResult;
+    /**
+     * Remove several segments as one undo step. Later segments are removed first,
+     * since a ripple delete shifts the ones after it left.
+     */
+    removeSegments: (ids: readonly string[], options?: RemoveSegmentOptions) => BatchResult;
+    /**
+     * Apply the same edit to several segments as one undo step — the entry point
+     * for adjusting a property across a multi-selection. An edit the protocol
+     * rejects fails the whole batch rather than being silently skipped.
+     */
+    updateSegments: (ids: readonly string[], updater: (segment: SegmentUnion) => void) => BatchResult;
+    /** Duplicate several segments as one undo step; reports the new ids. */
+    duplicateSegments: (ids: readonly string[]) => BatchResult;
+    /**
+     * Run a batch of commands as one atomic undo step.
+     *
+     * Every command inside still updates state immediately, so previews stay
+     * live, but only one history item is pushed when the batch commits. If the
+     * body throws, the protocol is restored and the error is rethrown; calling
+     * `tx.cancel()` discards the batch without touching the undo/redo stacks.
+     */
+    transaction: ProtocolManager['transaction'];
+    /**
+     * Open a transaction that spans multiple events, for continuous interactions
+     * such as a canvas or timeline drag. Commit on pointer up, cancel to restore
+     * the state captured at pointer down.
+     */
+    beginTransaction: ProtocolManager['beginTransaction'];
     /** Undo the last mutation. */
     undo: ProtocolManager['undo'];
     /** Redo the last undone mutation. */
@@ -103,10 +280,11 @@ export declare interface EditorCoreContext {
 export declare interface EditorCoreOptions {
     /** Initial protocol snapshot. */
     protocol: IVideoProtocol;
-    /** Optional id generators for segments/tracks. */
+    /** Optional id generators for segments, tracks and proposals. */
     idFactory?: {
         segment?: () => string;
         track?: () => string;
+        proposal?: () => string;
     };
     /** Optional shared services (resource manager, renderer, etc). */
     services?: EditorCoreServices;
@@ -164,6 +342,37 @@ export declare interface EditorCoreSelectors {
     getTrackBySegmentId: (segmentId: string) => DeepReadonly<TrackUnion> | undefined;
     /** List tracks, optionally filtered by type. */
     getTracks: (trackType?: ITrackType) => DeepReadonly<TrackUnion>[];
+    /**
+     * Every segment playing at `timeMs`, in track order — the answer to "what is
+     * on screen right now". Segment ranges are half-open, so a segment ending at
+     * `timeMs` and the one starting there are never both returned.
+     */
+    getSegmentsAt: (timeMs: number, options?: SegmentsAtOptions) => SegmentPlacement[];
+    /** The segment playing on one track at `timeMs`. */
+    getSegmentAt: (trackId: string, timeMs: number) => SegmentUnion | undefined;
+    /**
+     * Bounded empty stretches on a track, in order. The open range after the last
+     * segment is not a gap — nothing bounds it.
+     */
+    getTrackGaps: (trackId: string) => TrackGap[];
+    /** The segments either side of one, on its own track. */
+    getAdjacentSegments: (segmentId: string) => SegmentNeighbours;
+    /** Segments of one track (or every track) that share time, which is invalid. */
+    getOverlaps: (trackId?: string) => SegmentOverlap[];
+    /**
+     * A property's effective value at a moment, and whether it came from a
+     * keyframe, an interpolation between two, the segment's static field, or the
+     * documented default. Uses the same pure sampler as the renderer and export.
+     */
+    sampleProperty: (segmentId: string, property: IKeyframeProperty, timeMs: number) => SampledProperty | undefined;
+    /** The current selection, resolved against the protocol. */
+    getSelection: () => EditorSelection;
+    /** Find every segment in this protocol that uses a library asset. */
+    getAssetReferences: (asset: AssetReferenceTarget) => AssetReference[];
+    /** Semantic history entries without internal Immer patches. */
+    getOperationLog: () => ProtocolManager['operationLog']['value'];
+    /** Whether a command would do anything right now, and why not when it would not. */
+    canRun: (check: CommandCheck) => CommandCheckResult;
 }
 
 /**
@@ -198,26 +407,195 @@ export declare interface EditorCoreState {
     undoCount: ProtocolManager['undoCount'];
     /** Redo stack size. */
     redoCount: ProtocolManager['redoCount'];
+    /** Semantic descriptions of the currently reachable history branch. */
+    operationLog: ProtocolManager['operationLog'];
+    /** Monotonic committed-state version used for proposal conflict checks. */
+    revision: ProtocolManager['revision'];
+    /** Whether a history transaction is currently open. */
+    isTransactionActive: ProtocolManager['isTransactionActive'];
+    /** Nesting depth of the open transaction; 0 when none is open. */
+    transactionDepth: ProtocolManager['transactionDepth'];
+}
+
+/** A valid protocol preview produced without changing the main editor. */
+export declare interface EditorProposal {
+    id: string;
+    baseRevision: number;
+    previewProtocol: IVideoProtocol;
+    validation: {
+        valid: true;
+    };
+    operations: readonly OperationLogMeta[];
+    summary: ProposalChangeSummary;
+}
+
+export declare interface EditorProposalManager {
+    /** Run commands against an isolated copy and keep the resulting preview for review. */
+    create: (build: (editor: EditorCore) => void, options?: {
+        id?: string;
+    }) => ProposalActionResult;
+    /** Apply the whole proposal as one history item if its base revision is current. */
+    accept: (id: string) => ProposalActionResult;
+    /** Discard a proposal without touching protocol history. */
+    reject: (id: string) => ProposalActionResult;
+    get: (id: string) => EditorProposal | undefined;
+    list: () => EditorProposal[];
+}
+
+export declare interface EditorSelection {
+    segmentId?: string;
+    segment?: SegmentUnion;
+    trackId?: string;
+}
+
+declare type GetKeyframeSegment = (segmentId: string) => ReadableKeyframeSegment | undefined;
+
+export declare type KeyframeCommandCheck = {
+    command: 'upsertKeyframe';
+    input: UpsertKeyframeOptions;
+} | {
+    command: 'moveKeyframe';
+    input: MoveKeyframeOptions;
+} | {
+    command: 'removeKeyframe';
+    input: RemoveKeyframeOptions;
+} | {
+    command: 'setKeyframeEasing';
+    input: SetKeyframeEasingOptions;
+};
+
+declare interface KeyframeCommandDeps {
+    getSegment: GetKeyframeSegment;
+    updateSegment: EditorCoreCommands['updateSegment'];
+    transaction: EditorCoreCommands['transaction'];
+}
+
+export declare interface KeyframeCommandResult {
+    success: boolean;
+    error?: string;
+}
+
+export declare interface MoveKeyframeOptions {
+    segmentId: string;
+    property: IKeyframeProperty;
+    /** Current segment-relative timeline time in ms. */
+    timeMs: number;
+    /** New segment-relative timeline time in ms. */
+    toTimeMs: number;
 }
 
 /** Options for moving a segment between tracks or within a track. */
 export declare type MoveSegmentOptions = Parameters<ProtocolManager['moveSegment']>[0];
 
+export declare interface ProposalActionResult {
+    success: boolean;
+    error?: string;
+    proposal?: EditorProposal;
+}
+
+export declare interface ProposalChangeSummary {
+    addedTrackIds: string[];
+    removedTrackIds: string[];
+    changedTrackIds: string[];
+    addedSegmentIds: string[];
+    removedSegmentIds: string[];
+    changedSegmentIds: string[];
+    projectFields: Array<'width' | 'height' | 'fps'>;
+}
+
+declare interface ProposalManagerDependencies {
+    getProtocol: () => IVideoProtocol;
+    getRevision: () => number;
+    isTransactionActive: () => boolean;
+    createSandbox: (protocol: IVideoProtocol) => EditorCore;
+    applySnapshot: (protocol: IVideoProtocol, proposal: EditorProposal) => 'committed' | 'empty' | 'cancelled' | 'invalid' | 'nested';
+    createId: () => string;
+}
+
 /** Internal protocol manager type used to align editor-core signatures with protocol behavior. */
 declare type ProtocolManager = ReturnType<typeof createVideoProtocolManager>;
 
+declare type ReadableEasing = Exclude<IKeyframeEasing, [number, number, number, number]> | readonly [number, number, number, number];
+
+declare interface ReadableKeyframe {
+    readonly timeMs: number;
+    readonly value: number;
+    readonly easing?: ReadableEasing;
+}
+
+declare interface ReadableKeyframeSegment {
+    readonly segmentType: SegmentUnion['segmentType'];
+    readonly type?: string;
+    readonly startTime: number;
+    readonly endTime: number;
+    readonly keyframes?: readonly {
+        readonly property: IKeyframeProperty;
+        readonly frames: readonly ReadableKeyframe[];
+    }[];
+}
+
+export declare interface RemoveKeyframeOptions {
+    segmentId: string;
+    property: IKeyframeProperty;
+    /** Segment-relative timeline time in ms. */
+    timeMs: number;
+}
+
 /** Optional flags accepted by removeSegment (e.g. ripple delete). */
 export declare type RemoveSegmentOptions = Parameters<ProtocolManager['removeSegment']>[1];
 
+/** Input and result types for replacing a segment's media source. */
+export declare type ReplaceSegmentAssetOptions = Parameters<ProtocolManager['replaceSegmentAsset']>[0];
+
+export declare type ReplaceSegmentAssetResult = ReturnType<ProtocolManager['replaceSegmentAsset']>;
+
 /** Options for resizing a segment on a track. */
 export declare type ResizeSegmentOptions = Parameters<ProtocolManager['resizeSegment']>[0];
 
+/**
+ * A property's effective value at a moment, and where it came from — a curve,
+ * the segment's own field, or the documented fallback. An agent reviewing a
+ * value needs to know which, since only an interpolated one is changing here.
+ *
+ * `keyframe` covers a value read straight off a frame, including one held at
+ * either end of the curve; `interpolated` means strictly between two frames.
+ */
+export declare interface SampledProperty {
+    value: number;
+    source: 'keyframe' | 'interpolated' | 'static' | 'default';
+    /** False when the queried time lies outside the segment's own range. */
+    withinSegment: boolean;
+}
+
 /** Input payload for adding a segment (id is optional). */
 export declare type SegmentInput = Parameters<ProtocolManager['addSegment']>[0];
 
 /** Result payload returned by segment mutation commands. */
 export declare type SegmentMutationResult = ReturnType<ProtocolManager['removeSegment']>;
 
+export declare interface SegmentNeighbours {
+    trackId?: string;
+    previous?: SegmentUnion;
+    next?: SegmentUnion;
+}
+
+/** Two segments of one track sharing time, which the timeline rules forbid. */
+export declare interface SegmentOverlap {
+    trackId: string;
+    a: SegmentUnion;
+    b: SegmentUnion;
+    /** The overlapping stretch itself. */
+    startTime: number;
+    endTime: number;
+}
+
+/** Where a segment sits: the segment itself plus the track carrying it. */
+export declare interface SegmentPlacement {
+    segment: SegmentUnion;
+    trackId: string;
+    trackType: ITrackType;
+}
+
 /**
  * Segment plugin bundle: ops + renderer adapter + optional UI bindings.
  */
@@ -264,10 +642,52 @@ export declare interface SegmentRegistry {
     list: () => SegmentPlugin[];
 }
 
+export declare interface SegmentsAtOptions {
+    /** Only look at tracks of this type. */
+    trackType?: ITrackType;
+    /** Pass `false` to skip hidden tracks — what is actually on screen. */
+    includeHidden?: boolean;
+}
+
 /** Result payload returned by setCanvasSize. */
 export declare type SetCanvasSizeResult = ReturnType<ProtocolManager['setCanvasSize']>;
 
+/** Result payload returned by setFps. */
+export declare type SetFpsResult = ReturnType<ProtocolManager['setFps']>;
+
+export declare interface SetKeyframeEasingOptions extends RemoveKeyframeOptions {
+    /** Omit to restore linear easing. */
+    easing?: IKeyframeEasing;
+}
+
+declare interface StructuralSelectorDeps {
+    protocol: () => IVideoProtocol;
+    selectedSegmentId: () => string | undefined;
+    undoCount: () => number;
+    redoCount: () => number;
+}
+
+export declare function summarizeProposal(before: IVideoProtocol, after: IVideoProtocol): ProposalChangeSummary;
+
+/** A bounded stretch of empty time on a track. */
+export declare interface TrackGap {
+    startTime: number;
+    endTime: number;
+}
+
 /** The mutable track fields exposed to an updateTrack updater. */
 export declare type TrackMutableFields = Parameters<Parameters<ProtocolManager['updateTrack']>[1]>[0];
 
+export declare type TrackStructureResult = ReturnType<ProtocolManager['removeTrack']>;
+
+export declare interface UpsertKeyframeOptions {
+    segmentId: string;
+    property: IKeyframeProperty;
+    /** Segment-relative timeline time in ms. */
+    timeMs: number;
+    value: number;
+    /** When omitted, an existing frame keeps its easing. */
+    easing?: IKeyframeEasing;
+}
+
 export { }

package/dist/index.js

@@ -1,74 +1,603 @@
-import { createVideoProtocolManager as v } from "@video-editor/protocol";
-import { computed as p } from "@vue/reactivity";
-function y(s) {
-  const e = [], o = /* @__PURE__ */ new Map();
-  let c = !1;
+import { MIN_FPS as R, MIN_CANVAS_SIZE as L, MAX_CANVAS_SIZE as j, createVideoProtocolManager as Q, findAssetReferences as W } from "@video-editor/protocol";
+import { computed as O } from "@vue/reactivity";
+import { isVideoFramesSegment as ee, isAudioSegment as te, sampleKeyframes as re } from "@video-editor/shared";
+function K(t) {
+  return { success: !0, segmentIds: t };
+}
+function _(t) {
+  return { success: !1, error: t, segmentIds: [] };
+}
+function P(t) {
+  return [...new Set(t)];
+}
+function ne(t) {
+  const { transaction: e, getSegment: n } = t;
+  function i(r, s, c) {
+    let p = _(`${r}: nothing ran`);
+    return e((v) => {
+      const f = c();
+      if (typeof f == "string") {
+        p = _(f), v.cancel();
+        return;
+      }
+      p = K(f);
+    }, { label: r, data: s }), p;
+  }
+  function a(r, s) {
+    const c = [];
+    for (const p of r) {
+      const v = n(p);
+      if (!v)
+        return `${s}: no segment with id ${p}`;
+      c.push({ id: v.id, startTime: v.startTime });
+    }
+    return c;
+  }
   return {
-    register: async (t, n) => {
-      const a = t(s), { name: i } = a;
-      if (o.has(i)) {
-        if (!n?.override)
-          throw new Error(`Plugin ${i} has been registered`);
-        await o.get(i)?.destroy?.();
-        const u = e.findIndex((S) => S.name === i);
-        u >= 0 && e.splice(u, 1), o.delete(i);
+    moveSegments(r) {
+      return r.length ? i("move-segments", { moves: r.map((s) => ({ ...s })) }, () => {
+        const s = [];
+        for (const c of r) {
+          if (!t.moveSegment(c).success)
+            return `move-segments: could not move ${c.segmentId}`;
+          s.push(c.segmentId);
+        }
+        return s;
+      }) : K([]);
+    },
+    removeSegments(r, s) {
+      const c = P(r);
+      return c.length ? i("remove-segments", { segmentIds: c, ripple: s?.ripple === !0 }, () => {
+        const p = a(c, "remove-segments");
+        if (typeof p == "string")
+          return p;
+        const v = p.map((f, k) => ({ segment: f, index: k })).sort((f, k) => k.segment.startTime - f.segment.startTime || k.index - f.index);
+        for (const { segment: f } of v)
+          if (!t.removeSegment(f.id, s).success)
+            return `remove-segments: could not remove ${f.id}`;
+        return c;
+      }) : K([]);
+    },
+    updateSegments(r, s) {
+      const c = P(r);
+      return c.length ? i("update-segments", { segmentIds: c }, () => {
+        const p = a(c, "update-segments");
+        if (typeof p == "string")
+          return p;
+        for (const v of c)
+          if (!t.updateSegment(s, v))
+            return `update-segments: rejected the edit to ${v}`;
+        return c;
+      }) : K([]);
+    },
+    duplicateSegments(r) {
+      const s = P(r);
+      return s.length ? i("duplicate-segments", { segmentIds: s }, () => {
+        const c = a(s, "duplicate-segments");
+        if (typeof c == "string")
+          return c;
+        const p = [];
+        for (const v of s) {
+          const f = t.duplicateSegment(v);
+          if (!f.success)
+            return `duplicate-segments: could not duplicate ${v}`;
+          p.push(f.id);
+        }
+        return p;
+      }) : K([]);
+    }
+  };
+}
+const se = /* @__PURE__ */ new Set(["linear", "easeIn", "easeOut", "easeInOut"]), oe = {
+  moveKeyframe: "move-keyframe",
+  removeKeyframe: "remove-keyframe",
+  setKeyframeEasing: "set-keyframe-easing",
+  upsertKeyframe: "upsert-keyframe"
+};
+function T(t) {
+  return { ok: !1, reason: t };
+}
+function q(t) {
+  return t === void 0 ? !0 : typeof t == "string" ? se.has(t) : t.length === 4 && t.every(Number.isFinite);
+}
+function z(t, e) {
+  return t === e ? !0 : !Array.isArray(t) || !Array.isArray(e) ? !1 : t.every((n, i) => n === e[i]);
+}
+function E(t) {
+  return Array.isArray(t) ? [...t] : t;
+}
+function ae(t, e) {
+  return e === "opacity" ? t.segmentType === "frames" || t.segmentType === "text" : e === "volume" ? t.segmentType === "audio" || t.segmentType === "frames" && t.type === "video" : e === "intensity" ? t.segmentType === "filter" : t.segmentType === "frames" || t.segmentType === "text" || t.segmentType === "sticker";
+}
+function D(t, e, n) {
+  return t.keyframes?.find((a) => a.property === e)?.frames.find((a) => a.timeMs === n);
+}
+function V(t, e) {
+  const n = t(e.segmentId);
+  if (!n)
+    return T(`no segment with id ${e.segmentId}`);
+  if (!ae(n, e.property))
+    return T(`${e.property} keyframes are not supported by this segment`);
+  if (!Number.isFinite(e.timeMs))
+    return T("keyframe time must be a finite number");
+  const i = n.endTime - n.startTime;
+  return e.timeMs < 0 || e.timeMs > i ? T(`keyframe time must be between 0 and ${i}`) : { ok: !0 };
+}
+function Y(t, e) {
+  const n = V(e, t.input);
+  if (!n.ok)
+    return n;
+  const i = e(t.input.segmentId), a = D(i, t.input.property, t.input.timeMs);
+  switch (t.command) {
+    case "upsertKeyframe": {
+      const { input: r } = t;
+      return Number.isFinite(r.value) ? q(r.easing) ? a && a.value === r.value && (r.easing === void 0 || z(a.easing, r.easing)) ? T("keyframe already has the requested value") : { ok: !0 } : T("keyframe easing is invalid") : T("keyframe value must be a finite number");
+    }
+    case "moveKeyframe": {
+      const { input: r } = t;
+      if (!a)
+        return T(`no ${r.property} keyframe at ${r.timeMs}`);
+      const s = V(e, { ...r, timeMs: r.toTimeMs });
+      return s.ok ? r.toTimeMs === r.timeMs ? T("keyframe is already at the requested time") : D(i, r.property, r.toTimeMs) ? T(`a ${r.property} keyframe already exists at ${r.toTimeMs}`) : { ok: !0 } : s;
+    }
+    case "removeKeyframe": {
+      const { input: r } = t;
+      return a ? { ok: !0 } : T(`no ${r.property} keyframe at ${r.timeMs}`);
+    }
+    case "setKeyframeEasing": {
+      const { input: r } = t;
+      return a ? q(r.easing) ? z(a.easing, r.easing) ? T("keyframe already has the requested easing") : { ok: !0 } : T("keyframe easing is invalid") : T(`no ${r.property} keyframe at ${r.timeMs}`);
+    }
+  }
+}
+function ie(t) {
+  function e(n, i) {
+    const a = Y(n, t.getSegment);
+    return a.ok ? t.transaction(() => t.updateSegment(i, n.input.segmentId) ? { success: !0 } : { success: !1, error: "the protocol rejected the keyframe edit" }, {
+      label: oe[n.command],
+      data: { ...n.input }
+    }).value : { success: !1, error: a.reason };
+  }
+  return {
+    upsertKeyframe(n) {
+      return e({ command: "upsertKeyframe", input: n }, (i) => {
+        const a = i.keyframes ?? (i.keyframes = []);
+        let r = a.find((c) => c.property === n.property);
+        r || (r = { property: n.property, frames: [] }, a.push(r));
+        const s = r.frames.find((c) => c.timeMs === n.timeMs);
+        s ? (s.value = n.value, n.easing !== void 0 && (s.easing = E(n.easing))) : (r.frames.push({
+          timeMs: n.timeMs,
+          value: n.value,
+          ...n.easing === void 0 ? {} : { easing: E(n.easing) }
+        }), r.frames.sort((c, p) => c.timeMs - p.timeMs));
+      });
+    },
+    moveKeyframe(n) {
+      return e({ command: "moveKeyframe", input: n }, (i) => {
+        const a = i.keyframes.find((s) => s.property === n.property), r = a.frames.find((s) => s.timeMs === n.timeMs);
+        r.timeMs = n.toTimeMs, a.frames.sort((s, c) => s.timeMs - c.timeMs);
+      });
+    },
+    removeKeyframe(n) {
+      return e({ command: "removeKeyframe", input: n }, (i) => {
+        const a = i.keyframes, r = a.findIndex((p) => p.property === n.property), s = a[r], c = s.frames.findIndex((p) => p.timeMs === n.timeMs);
+        s.frames.splice(c, 1), s.frames.length || a.splice(r, 1), a.length || delete i.keyframes;
+      });
+    },
+    setKeyframeEasing(n) {
+      return e({ command: "setKeyframeEasing", input: n }, (i) => {
+        const r = i.keyframes.find((s) => s.property === n.property).frames.find((s) => s.timeMs === n.timeMs);
+        n.easing === void 0 ? delete r.easing : r.easing = E(n.easing);
+      });
+    }
+  };
+}
+function ce(t) {
+  const e = [], n = /* @__PURE__ */ new Map();
+  let i = !1;
+  return {
+    register: async (f, k) => {
+      const w = f(t), { name: S } = w;
+      if (n.has(S)) {
+        if (!k?.override)
+          throw new Error(`Plugin ${S} has been registered`);
+        await n.get(S)?.destroy?.();
+        const g = e.findIndex((u) => u.name === S);
+        g >= 0 && e.splice(g, 1), n.delete(S);
       }
-      e.push(a), o.set(i, a), (n?.autoInit || c) && await a.init?.();
+      e.push(w), n.set(S, w), (k?.autoInit || i) && await w.init?.();
     },
     init: async () => {
-      for (const t of e)
-        await t.init?.();
-      c = !0;
+      for (const f of e)
+        await f.init?.();
+      i = !0;
     },
-    get: (t) => o.get(t),
-    has: (t) => o.has(t),
-    remove: async (t) => {
-      const n = e.findIndex((i) => i.name === t);
-      return n === -1 ? !1 : (await e[n].destroy?.(), e.splice(n, 1), o.delete(t));
+    get: (f) => n.get(f),
+    has: (f) => n.has(f),
+    remove: async (f) => {
+      const k = e.findIndex((S) => S.name === f);
+      return k === -1 ? !1 : (await e[k].destroy?.(), e.splice(k, 1), n.delete(f));
     },
     destroy: async () => {
-      for (const t of e)
-        await t.destroy?.();
-      e.length = 0, o.clear(), c = !1;
+      for (const f of e)
+        await f.destroy?.();
+      e.length = 0, n.clear(), i = !1;
     }
   };
 }
-function T() {
-  const s = /* @__PURE__ */ new Map();
+function Z(t, e) {
+  return JSON.stringify(t) === JSON.stringify(e);
+}
+function B(t) {
+  const e = /* @__PURE__ */ new Map();
+  for (const n of t.tracks)
+    for (const i of n.children)
+      e.set(i.id, i);
+  return e;
+}
+function U(t) {
+  return new Map(t.tracks.map((e) => [e.trackId, e]));
+}
+function G(t, e) {
+  const n = [], i = [], a = [];
+  for (const [r, s] of e) {
+    const c = t.get(r);
+    c === void 0 ? n.push(r) : Z(c, s) || a.push(r);
+  }
+  for (const r of t.keys())
+    e.has(r) || i.push(r);
+  return { added: n, removed: i, changed: a };
+}
+function me(t, e) {
+  const n = G(U(t), U(e)), i = G(B(t), B(e)), a = [];
+  for (const r of ["width", "height", "fps"])
+    t[r] !== e[r] && a.push(r);
+  return {
+    addedTrackIds: n.added,
+    removedTrackIds: n.removed,
+    changedTrackIds: n.changed,
+    addedSegmentIds: i.added,
+    removedSegmentIds: i.removed,
+    changedSegmentIds: i.changed,
+    projectFields: a
+  };
+}
+function A(t) {
+  return structuredClone(t);
+}
+function J(t) {
+  return {
+    success: !1,
+    error: t instanceof Error ? t.message : String(t)
+  };
+}
+function ue(t) {
+  const e = /* @__PURE__ */ new Map();
+  return {
+    create: (r, s) => {
+      const c = s?.id ?? t.createId();
+      if (!c)
+        return { success: !1, error: "proposal id must not be empty" };
+      if (e.has(c))
+        return { success: !1, error: `proposal id ${c} already exists` };
+      const p = t.getRevision(), v = structuredClone(t.getProtocol()), f = t.createSandbox(v);
+      try {
+        r(f);
+        const k = structuredClone(f.commands.exportProtocol());
+        if (Z(v, k))
+          return { success: !1, error: "proposal must change the protocol" };
+        const w = f.selectors.getOperationLog().filter((M) => M.status === "applied").flatMap((M) => M.operations.length ? M.operations : M.meta === void 0 ? [] : [M.meta]), S = {
+          id: c,
+          baseRevision: p,
+          previewProtocol: k,
+          validation: { valid: !0 },
+          operations: structuredClone(w),
+          summary: me(v, k)
+        };
+        return e.set(c, S), { success: !0, proposal: A(S) };
+      } catch (k) {
+        return J(k);
+      }
+    },
+    accept: (r) => {
+      const s = e.get(r);
+      if (!s)
+        return { success: !1, error: `no proposal with id ${r}` };
+      if (t.isTransactionActive())
+        return { success: !1, error: "cannot accept a proposal while a transaction is active" };
+      if (t.getRevision() !== s.baseRevision)
+        return {
+          success: !1,
+          error: `proposal ${r} conflicts with the current protocol revision`
+        };
+      try {
+        const c = t.applySnapshot(s.previewProtocol, s);
+        return c !== "committed" ? { success: !1, error: `proposal ${r} could not be committed: ${c}` } : (e.delete(r), { success: !0, proposal: A(s) });
+      } catch (c) {
+        return J(c);
+      }
+    },
+    reject: (r) => {
+      const s = e.get(r);
+      return s ? (e.delete(r), { success: !0, proposal: A(s) }) : { success: !1, error: `no proposal with id ${r}` };
+    },
+    get: (r) => {
+      const s = e.get(r);
+      return s === void 0 ? void 0 : A(s);
+    },
+    list: () => [...e.values()].map(A)
+  };
+}
+function de() {
+  const t = /* @__PURE__ */ new Map();
   return {
-    register: (r, d) => {
-      if (s.has(r.type) && !d?.override)
-        throw new Error(`Segment plugin ${r.type} has been registered`);
-      s.set(r.type, r);
+    register: (a, r) => {
+      if (t.has(a.type) && !r?.override)
+        throw new Error(`Segment plugin ${a.type} has been registered`);
+      t.set(a.type, a);
     },
-    get: (r) => s.get(r),
-    list: () => [...s.values()]
+    get: (a) => t.get(a),
+    list: () => [...t.values()]
   };
 }
-function k(s) {
+const fe = {
+  opacity: 1,
+  "position.x": 0,
+  "position.y": 0,
+  scale: 1,
+  rotation: 0,
+  volume: 1,
+  intensity: 1
+}, le = /* @__PURE__ */ new Set(["frames", "text", "sticker", "audio", "effect", "filter"]);
+function ge(t, e) {
+  const n = t, i = n.transform;
+  switch (e) {
+    case "opacity":
+      return n.opacity;
+    case "volume":
+      return n.volume;
+    case "intensity":
+      return n.intensity;
+    case "position.x":
+      return i?.position?.[0];
+    case "position.y":
+      return i?.position?.[1];
+    case "scale":
+      return i?.scale?.[0];
+    case "rotation":
+      return i?.rotation?.[2];
+  }
+}
+function pe(t, e) {
+  return t.keyframes?.find((n) => n.property === e && n.frames.length > 0);
+}
+function F(t, e) {
+  return e >= t.startTime && e < t.endTime;
+}
+function N(t) {
+  return [...t.children].sort((e, n) => e.startTime - n.startTime);
+}
+function ye(t) {
+  const { protocol: e, selectedSegmentId: n, undoCount: i, redoCount: a } = t, r = (m) => e().tracks.find((o) => o.children.some((l) => l.id === m)), s = (m) => {
+    for (const o of e().tracks) {
+      const l = o.children.find((d) => d.id === m);
+      if (l)
+        return l;
+    }
+  }, c = () => e().tracks.find((m) => m.trackType === "frames" && m.isMain);
+  function p(m, o) {
+    const l = [];
+    for (const d of e().tracks)
+      if (!(o?.trackType && d.trackType !== o.trackType) && !(o?.includeHidden === !1 && d.hidden))
+        for (const y of d.children)
+          F(y, m) && l.push({ segment: y, trackId: d.trackId, trackType: d.trackType });
+    return l;
+  }
+  function v(m, o) {
+    return e().tracks.find((d) => d.trackId === m)?.children.find((d) => F(d, o));
+  }
+  function f(m) {
+    const o = e().tracks.find((y) => y.trackId === m);
+    if (!o)
+      return [];
+    const l = [];
+    let d = 0;
+    for (const y of N(o))
+      y.startTime > d && l.push({ startTime: d, endTime: y.startTime }), d = Math.max(d, y.endTime);
+    return l;
+  }
+  function k(m) {
+    const o = r(m);
+    if (!o)
+      return {};
+    const l = N(o), d = l.findIndex((y) => y.id === m);
+    return d < 0 ? {} : {
+      trackId: o.trackId,
+      previous: l[d - 1],
+      next: l[d + 1]
+    };
+  }
+  function w(m) {
+    const o = m ? e().tracks.filter((d) => d.trackId === m) : e().tracks, l = [];
+    for (const d of o) {
+      const y = N(d);
+      for (let h = 0; h < y.length - 1; h++) {
+        const I = y[h];
+        for (let b = h + 1; b < y.length; b++) {
+          const x = y[b];
+          if (x.startTime >= I.endTime)
+            break;
+          l.push({
+            trackId: d.trackId,
+            a: I,
+            b: x,
+            startTime: x.startTime,
+            endTime: Math.min(I.endTime, x.endTime)
+          });
+        }
+      }
+    }
+    return l;
+  }
+  function S(m, o, l) {
+    const d = s(m);
+    if (!d)
+      return;
+    const y = F(d, l), h = pe(d, o);
+    if (h) {
+      const b = Math.max(0, l - d.startTime), x = re(h, b);
+      if (Number.isFinite(x)) {
+        const $ = h.frames, H = $.length === 1 || b <= $[0].timeMs || b >= $[$.length - 1].timeMs || $.some((X) => X.timeMs === b);
+        return {
+          value: x,
+          source: H ? "keyframe" : "interpolated",
+          withinSegment: y
+        };
+      }
+    }
+    const I = ge(d, o);
+    return I !== void 0 && Number.isFinite(I) ? { value: I, source: "static", withinSegment: y } : { value: fe[o], source: "default", withinSegment: y };
+  }
+  function M() {
+    const m = n();
+    if (!m)
+      return {};
+    const o = s(m);
+    return o ? { segmentId: m, segment: o, trackId: r(m)?.trackId } : {};
+  }
+  const g = { ok: !0 }, u = (m) => ({ ok: !1, reason: m });
+  function C(m) {
+    switch (m.command) {
+      case "undo":
+        return i() > 0 ? g : u("nothing to undo");
+      case "redo":
+        return a() > 0 ? g : u("nothing to redo");
+      case "removeSegment":
+      case "duplicateSegment":
+        return s(m.segmentId) ? g : u(`no segment with id ${m.segmentId}`);
+      case "splitSegment": {
+        const o = s(m.segmentId);
+        return o ? Number.isFinite(m.timelineMs) ? m.timelineMs <= o.startTime || m.timelineMs >= o.endTime ? u("split time must fall strictly inside the segment") : g : u("split time must be a finite number") : u(`no segment with id ${m.segmentId}`);
+      }
+      case "addTransition": {
+        const o = c();
+        return o ? o.children.length < 2 ? u("a transition needs two adjacent segments") : g : u("the project has no main frames track");
+      }
+      case "setCanvasSize": {
+        for (const [o, l] of [["width", m.width], ["height", m.height]]) {
+          if (!Number.isInteger(l))
+            return u(`${o} must be a whole number of pixels`);
+          if (l < L || l > j)
+            return u(`${o} must be between ${L} and ${j}`);
+        }
+        return g;
+      }
+      case "setFps":
+        return Number.isFinite(m.fps) ? m.fps < R ? u(`fps must be at least ${R}`) : g : u("fps must be a finite number");
+      case "addTrack": {
+        const { input: o } = m;
+        if (!le.has(o.trackType))
+          return u(`unsupported track type ${String(o.trackType)}`);
+        if (o.trackId !== void 0 && (typeof o.trackId != "string" || o.trackId.length === 0))
+          return u("track id must not be empty");
+        if (o.trackId && e().tracks.some((d) => d.trackId === o.trackId))
+          return u(`track id ${o.trackId} already exists`);
+        const l = o.index ?? 0;
+        return !Number.isInteger(l) || l < 0 || l > e().tracks.length ? u(`track index must be between 0 and ${e().tracks.length}`) : g;
+      }
+      case "removeTrack":
+        return e().tracks.some((o) => o.trackId === m.trackId) ? g : u(`no track with id ${m.trackId}`);
+      case "moveTrack": {
+        const o = e().tracks;
+        return o.some((l) => l.trackId === m.trackId) ? !Number.isInteger(m.toIndex) || m.toIndex < 0 || m.toIndex >= o.length ? u(`track index must be between 0 and ${Math.max(0, o.length - 1)}`) : g : u(`no track with id ${m.trackId}`);
+      }
+      case "replaceSegmentAsset": {
+        const { asset: o, segmentId: l, strategy: d } = m.input, y = s(l);
+        if (!y)
+          return u(`no segment with id ${l}`);
+        const h = ee(y) ? "video" : te(y) ? "audio" : y.segmentType === "sticker" || y.segmentType === "frames" && y.type === "image" ? "image" : void 0;
+        if (!h)
+          return u("segment does not use a replaceable asset");
+        if (h !== o.kind)
+          return u(`cannot replace ${h} with ${o.kind}`);
+        if (o.id !== void 0 && !o.id)
+          return u("asset id must not be empty");
+        try {
+          if (!new URL(o.url).protocol)
+            return u("asset url must be an absolute URL");
+        } catch {
+          return u("asset url must be an absolute URL");
+        }
+        if (d !== "preserve" && d !== "fit")
+          return u(`unsupported replacement strategy ${String(d)}`);
+        if (h === "image")
+          return d === "fit" ? u("fit strategy requires a video or audio asset with a duration") : g;
+        if (typeof o.durationMs != "number" || !Number.isFinite(o.durationMs) || o.durationMs <= 0)
+          return u("asset durationMs must be a positive number for video and audio");
+        if (d === "preserve") {
+          const I = y, b = (I.fromTime ?? 0) + (I.endTime - I.startTime) * (I.playRate ?? 1);
+          if (b > o.durationMs)
+            return u(`current source window ends at ${b}ms, beyond the ${o.durationMs}ms asset`);
+        }
+        return g;
+      }
+      case "upsertKeyframe":
+      case "moveKeyframe":
+      case "removeKeyframe":
+      case "setKeyframeEasing":
+        return Y(m, s);
+    }
+  }
+  return {
+    getSegmentsAt: p,
+    getSegmentAt: v,
+    getTrackGaps: f,
+    getAdjacentSegments: k,
+    getOverlaps: w,
+    sampleProperty: S,
+    getSelection: M,
+    canRun: C
+  };
+}
+function ve(t) {
   let e = 0;
-  for (const o of s)
-    for (const c of o.children)
-      c.endTime > e && (e = c.endTime);
+  for (const n of t)
+    for (const i of n.children)
+      i.endTime > e && (e = i.endTime);
   return e;
 }
-function x(s) {
-  const e = v(s.protocol, {
-    idFactory: s.idFactory
-  }), o = p(() => e.selectedSegment.value?.id), c = p(() => k(e.protocol.value.tracks)), r = {
+function ke(t) {
+  const e = Q(t.protocol, {
+    idFactory: t.idFactory
+  }), n = O(() => e.selectedSegment.value?.id), i = O(() => ve(e.protocol.value.tracks)), a = {
     protocol: e.protocol,
     videoBasicInfo: e.videoBasicInfo,
     currentTime: e.curTime,
     selectedSegment: e.selectedSegment,
-    selectedSegmentId: o,
+    selectedSegmentId: n,
     trackMap: e.trackMap,
     segmentMap: e.segmentMap,
-    duration: c,
+    duration: i,
     undoCount: e.undoCount,
-    redoCount: e.redoCount
-  }, d = {
-    setCurrentTime: (n) => {
-      e.curTime.value = n;
+    redoCount: e.redoCount,
+    operationLog: e.operationLog,
+    revision: e.revision,
+    isTransactionActive: e.isTransactionActive,
+    transactionDepth: e.transactionDepth
+  }, r = ne({
+    transaction: e.transaction,
+    moveSegment: e.moveSegment,
+    removeSegment: e.removeSegment,
+    duplicateSegment: e.duplicateSegment,
+    updateSegment: e.updateSegment,
+    getSegment: e.getSegment
+  }), s = ie({
+    getSegment: e.getSegment,
+    updateSegment: e.updateSegment,
+    transaction: e.transaction
+  }), c = {
+    setCurrentTime: (g) => {
+      e.curTime.value = g;
     },
     setSelectedSegment: e.setSelectedSegment,
     addSegment: e.addSegment,
@@ -77,45 +606,89 @@ function x(s) {
     updateSegment: e.updateSegment,
     moveSegment: e.moveSegment,
     resizeSegment: e.resizeSegment,
+    replaceSegmentAsset: e.replaceSegmentAsset,
     splitSegment: e.splitSegment,
     addTransition: e.addTransition,
     removeTransition: e.removeTransition,
     updateTransition: e.updateTransition,
+    addTrack: e.addTrack,
+    removeTrack: e.removeTrack,
+    moveTrack: e.moveTrack,
     updateTrack: e.updateTrack,
     setCanvasSize: e.setCanvasSize,
+    setFps: e.setFps,
+    upsertKeyframe: s.upsertKeyframe,
+    moveKeyframe: s.moveKeyframe,
+    removeKeyframe: s.removeKeyframe,
+    setKeyframeEasing: s.setKeyframeEasing,
     replaceTrackId: e.replaceTrackId,
     replaceSegmentId: e.replaceSegmentId,
+    moveSegments: r.moveSegments,
+    removeSegments: r.removeSegments,
+    updateSegments: r.updateSegments,
+    duplicateSegments: r.duplicateSegments,
+    transaction: e.transaction,
+    beginTransaction: e.beginTransaction,
     undo: e.undo,
     redo: e.redo,
     exportProtocol: e.exportProtocol
-  }, g = {
+  }, v = {
+    ...ye({
+      protocol: () => e.exportProtocol(),
+      selectedSegmentId: () => n.value,
+      undoCount: () => e.undoCount.value,
+      redoCount: () => e.redoCount.value
+    }),
     getSegment: e.getSegment,
-    getTrackById: (n) => r.protocol.value.tracks.find((a) => a.trackId === n),
-    getTrackBySegmentId: (n) => r.protocol.value.tracks.find((a) => a.children.some((i) => i.id === n)),
-    getTracks: (n) => n ? r.protocol.value.tracks.filter((a) => a.trackType === n) : r.protocol.value.tracks
-  }, l = {
-    segments: T()
-  }, m = s.services ?? {}, t = y({
-    state: r,
-    commands: d,
-    selectors: g,
-    registry: l,
-    services: m
+    getTrackById: (g) => a.protocol.value.tracks.find((u) => u.trackId === g),
+    getTrackBySegmentId: (g) => a.protocol.value.tracks.find((u) => u.children.some((C) => C.id === g)),
+    getTracks: (g) => g ? a.protocol.value.tracks.filter((u) => u.trackType === g) : a.protocol.value.tracks,
+    getOperationLog: () => structuredClone(a.operationLog.value),
+    getAssetReferences: (g) => W(e.exportProtocol(), g)
+  }, f = {
+    segments: de()
+  }, k = t.services ?? {}, S = ce({
+    state: a,
+    commands: c,
+    selectors: v,
+    registry: f,
+    services: k
+  }), M = ue({
+    getProtocol: () => e.exportProtocol(),
+    getRevision: () => e.revision.value,
+    isTransactionActive: () => e.isTransactionActive.value,
+    createSandbox: (g) => ke({
+      protocol: g,
+      idFactory: t.idFactory
+    }),
+    applySnapshot: (g, u) => e.applyProtocolSnapshot(g, {
+      label: "accept-proposal",
+      data: { proposalId: u.id, baseRevision: u.baseRevision },
+      operations: u.operations
+    }).status,
+    createId: t.idFactory?.proposal ?? (() => globalThis.crypto.randomUUID())
   });
   return {
-    state: r,
-    commands: d,
-    selectors: g,
-    plugins: t,
-    registry: l,
-    services: m,
+    state: a,
+    commands: c,
+    selectors: v,
+    proposals: M,
+    plugins: S,
+    registry: f,
+    services: k,
     destroy: async () => {
-      await t.destroy();
+      await S.destroy();
     }
   };
 }
 export {
-  x as createEditorCore,
-  y as createPluginManager,
-  T as createSegmentRegistry
+  Y as checkKeyframeCommand,
+  ne as createBatchCommands,
+  ke as createEditorCore,
+  ie as createKeyframeCommands,
+  ce as createPluginManager,
+  ue as createProposalManager,
+  de as createSegmentRegistry,
+  ye as createStructuralSelectors,
+  me as summarizeProposal
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@video-editor/editor-core",
   "type": "module",
-  "version": "1.0.0-beta.1",
+  "version": "1.0.0-beta.2",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -19,14 +19,15 @@
     "@vue/reactivity": "^3.5.26"
   },
   "dependencies": {
-    "@video-editor/protocol": "1.0.0-beta.1",
-    "@video-editor/shared": "1.0.0-beta.1"
+    "@video-editor/protocol": "1.0.0-beta.2",
+    "@video-editor/shared": "1.0.0-beta.2"
   },
   "devDependencies": {
     "@vue/reactivity": "^3.5.26"
   },
   "scripts": {
     "build": "vite build",
-    "preview": "vite preview"
+    "preview": "vite preview",
+    "test": "vitest run --config ./vitest.config.ts"
   }
 }