@cueframe/kernel 0.2.57 → 0.2.59-rc.0

package/dist/{chunk-4PV3UYJF.js → chunk-ONSGT6UJ.js}

@@ -3,13 +3,13 @@ import {
   projectMediaPlaybackSpans,
   sliceTranscriptWords,
   splitIntoSentences
-} from "./chunk-VXGA7LQQ.js";
+} from "./chunk-IUJABAG2.js";
 import {
   createHeadlessStore,
   findClipById,
   findMarkerById,
   findTrackContainingClipId
-} from "./chunk-LBJ5LI5V.js";
+} from "./chunk-2K2GBFLU.js";
 import {
   CaptionLayoutInput,
   CaptionSegment,
@@ -25,7 +25,7 @@ import {
   captionLayoutIssues,
   captionSegmentSignature,
   captionVisibilityIssues
-} from "./chunk-UFD4EZHM.js";
+} from "./chunk-AFUITAH6.js";
 import {
   ReframeSegment
 } from "./chunk-B7J5UUUV.js";
@@ -40,6 +40,256 @@ import {
 // ../composition-ops/src/index.ts
 import { z } from "zod";
 
+// ../composition-ops/src/opRecorder.ts
+var genTrackId = (kind) => `track-${kind}-${crypto.randomUUID().slice(0, 8)}`;
+var NON_DOCUMENT_METHODS = /* @__PURE__ */ new Set([
+  "selectClip",
+  "setSelection",
+  "selectAllClips",
+  "selectOverlay",
+  "clearOverlaySelection",
+  "getState",
+  "batch"
+]);
+function wrapWithOpRecorder(base, opts) {
+  const { record, getComposition } = opts;
+  const captionTarget = {
+    getState: () => ({ composition: getComposition() }),
+    setCaptionStyle: (style) => base.setCaptionStyle(style),
+    setCaptions: (segments, style) => base.setCaptions(segments, style)
+  };
+  const opTarget = {
+    ...base,
+    getState: () => ({ composition: getComposition() })
+  };
+  const applyAndRecord = (op) => {
+    const before = getComposition();
+    applyOp(before, op);
+    record(op, before);
+    applyOpToStore(opTarget, op);
+  };
+  const wrapped = {
+    addClip: (clip, options) => {
+      const before = getComposition();
+      const c = clip.kind ? clip : { ...clip, kind: "video" };
+      if (options?.newTrack || !before.tracks.some((t) => t.kind === "video")) {
+        const newTrackId = options?.newTrackId ?? genTrackId("video");
+        record({ type: "clip.add", clip: c, newTrack: true, newTrackId }, before);
+        base.addClip(c, { newTrack: true, newTrackId });
+      } else {
+        record({ type: "clip.add", clip: c }, before);
+        base.addClip(c);
+      }
+    },
+    addClipToTrack: (clip, target) => {
+      if ("trackId" in target) {
+        applyAndRecord({ type: "clip.add", clip, trackId: target.trackId });
+        return;
+      }
+      const c = clip.kind ? clip : { ...clip, kind: target.kind };
+      const creates = target.newTrack || !getComposition().tracks.some((t) => t.kind === target.kind);
+      applyAndRecord(
+        creates ? { type: "clip.add", clip: c, newTrack: true, newTrackId: target.newTrackId ?? genTrackId(target.kind) } : { type: "clip.add", clip: c }
+      );
+    },
+    removeClip: (id) => {
+      record({ type: "clip.remove", clipId: id }, getComposition());
+      base.removeClip(id);
+    },
+    updateClip: (id, updates) => {
+      record({ type: "clip.update", clipId: id, patch: updates }, getComposition());
+      base.updateClip(id, updates);
+    },
+    removeClipsByMediaId: (mediaId) => {
+      record({ type: "removeClipsByMediaId", mediaId }, getComposition());
+      base.removeClipsByMediaId(mediaId);
+    },
+    setClipProperties: (id, props) => {
+      const { playbackRate, ...patch } = props;
+      if (playbackRate !== void 0) {
+        if (opts.onUnjournalable) {
+          const preview = createHeadlessStore(getComposition());
+          preview.setClipProperties(id, props);
+          opts.onUnjournalable("setClipProperties.playbackRate", preview.getState().composition);
+          return base.setClipProperties(id, props);
+        }
+        throw new Error(
+          "opRecorder.setClipProperties: playbackRate is not serializable as a clip.update op (source.playbackRate triggers a cross-field ripple). Use the server-authoritative ripple path."
+        );
+      }
+      record({ type: "clip.update", clipId: id, patch }, getComposition());
+      return base.setClipProperties(id, props);
+    },
+    addOverlay: (clip) => {
+      const before = getComposition();
+      const track = before.tracks.find((t) => t.kind === "overlay");
+      let trackId = track?.id;
+      if (!trackId) {
+        trackId = genTrackId("overlay");
+        record({ type: "addTrack", kind: "overlay", id: trackId }, before);
+        base.addTrack("overlay", void 0, trackId);
+      }
+      record({ type: "clip.add", clip, trackId }, getComposition());
+      base.addOverlay(clip);
+    },
+    removeOverlay: (id) => {
+      record({ type: "clip.remove", clipId: id }, getComposition());
+      base.removeOverlay(id);
+    },
+    updateOverlay: (id, updates) => {
+      record({ type: "clip.update", clipId: id, patch: updates }, getComposition());
+      base.updateOverlay(id, updates);
+    },
+    loadOverlays: (clips) => {
+      record({ type: "loadOverlays", clips }, getComposition());
+      base.loadOverlays(clips);
+    },
+    addAudioClip: (clip) => {
+      const before = getComposition();
+      const track = before.tracks.find((t) => t.kind === "audio");
+      let trackId = track?.id;
+      if (!trackId) {
+        trackId = genTrackId("audio");
+        record({ type: "addTrack", kind: "audio", id: trackId }, before);
+        base.addTrack("audio", void 0, trackId);
+      }
+      record({ type: "clip.add", clip, trackId }, getComposition());
+      base.addAudioClip(clip);
+    },
+    removeAudioClip: (id) => {
+      record({ type: "clip.remove", clipId: id }, getComposition());
+      base.removeAudioClip(id);
+    },
+    updateAudioClip: (id, updates) => {
+      record({ type: "clip.update", clipId: id, patch: updates }, getComposition());
+      base.updateAudioClip(id, updates);
+    },
+    addMarker: (marker) => {
+      record({ type: "addMarker", marker }, getComposition());
+      base.addMarker(marker);
+    },
+    removeMarker: (id) => {
+      record({ type: "removeMarker", markerId: id }, getComposition());
+      base.removeMarker(id);
+    },
+    updateMarker: (id, updates) => {
+      record({ type: "updateMarker", markerId: id, updates }, getComposition());
+      base.updateMarker(id, updates);
+    },
+    setCropIntents: (clipId, segments) => {
+      record({ type: "setCropIntents", clipId, segments }, getComposition());
+      base.setCropIntents(clipId, segments);
+    },
+    setEffects: (clipId, effects) => {
+      record({ type: "setEffects", clipId, effects }, getComposition());
+      base.setEffects(clipId, effects);
+    },
+    // The two caption writes go through the same function `applyOpToStore` uses, so the op this
+    // journals is exactly the op a replay applies. Calling the store's setter directly left this
+    // lane — Studio's composition store and the in-app agent capability are built on it — able to
+    // write a face the op gate refuses and to journal an op `applyOp` would refuse on replay.
+    // The op is applied FIRST: a refusal must leave nothing in the journal.
+    setCaptionStyle: (style) => {
+      const before = getComposition();
+      const op = { type: "setCaptionStyle", style };
+      applyOp(before, op);
+      record(op, before);
+      applyCaptionOpToStore(captionTarget, op);
+    },
+    setCaptions: (segments, style) => {
+      const before = getComposition();
+      const op = {
+        type: "setCaptions",
+        segments,
+        ...style !== void 0 ? { style } : {}
+      };
+      applyOp(before, op);
+      record(op, before);
+      applyCaptionOpToStore(captionTarget, op);
+    },
+    setCaptionLayouts: (layouts) => {
+      applyAndRecord({
+        type: "setCaptionLayouts",
+        layouts: layouts.map(({ wordSignature: _signature, ...layout }) => layout)
+      });
+    },
+    setCaptionDepth: (zPlane) => {
+      applyAndRecord({ type: "setCaptionDepth", zPlane });
+    },
+    setFormat: (format) => {
+      record({ type: "setFormat", format }, getComposition());
+      base.setFormat(format);
+    },
+    addTrack: (kind, name, id) => {
+      const useId = id ?? genTrackId(kind);
+      record({ type: "addTrack", kind, ...name !== void 0 ? { name } : {}, id: useId }, getComposition());
+      base.addTrack(kind, name, useId);
+    },
+    removeTrack: (trackId) => {
+      record({ type: "removeTrack", trackId }, getComposition());
+      base.removeTrack(trackId);
+    },
+    updateTrack: (trackId, updates) => {
+      record({ type: "updateTrack", trackId, updates }, getComposition());
+      base.updateTrack(trackId, updates);
+    },
+    reorderTracks: (fromIndex, toIndex) => {
+      record({ type: "reorderTracks", fromIndex, toIndex }, getComposition());
+      base.reorderTracks(fromIndex, toIndex);
+    },
+    moveClipToTrack: (clipId, targetTrackId, newStartTime) => {
+      record(
+        {
+          type: "moveClipToTrack",
+          clipId,
+          targetTrackId,
+          ...newStartTime !== void 0 ? { newStartTime } : {}
+        },
+        getComposition()
+      );
+      base.moveClipToTrack(clipId, targetTrackId, newStartTime);
+    },
+    duplicateClip: (id) => {
+      if (createHeadlessStore(getComposition()).duplicateClip(id) === void 0) return void 0;
+      const newClipId = `${id}-dup-${crypto.randomUUID().slice(0, 8)}`;
+      applyAndRecord({ type: "duplicateClip", clipId: id, newClipId });
+      return newClipId;
+    },
+    cutAndRipple: (start, end) => {
+      record({ type: "cutAndRipple", start, end }, getComposition());
+      base.cutAndRipple(start, end);
+    },
+    ripple: (time, amount) => {
+      record({ type: "ripple", time, amount }, getComposition());
+      base.ripple(time, amount);
+    },
+    addExcludedRange: (clipId, sourceStart, sourceEnd, reason) => {
+      record(
+        {
+          type: "addExcludedRange",
+          clipId,
+          sourceStart,
+          sourceEnd,
+          ...reason !== void 0 ? { reason } : {}
+        },
+        getComposition()
+      );
+      base.addExcludedRange(clipId, sourceStart, sourceEnd, reason);
+    },
+    removeExcludedRange: (clipId, rangeIdx) => {
+      record({ type: "removeExcludedRange", clipId, rangeIdx }, getComposition());
+      base.removeExcludedRange(clipId, rangeIdx);
+    }
+  };
+  for (const [name, member] of Object.entries(base)) {
+    if (typeof member !== "function" || name in wrapped || NON_DOCUMENT_METHODS.has(name)) continue;
+    throw new Error(
+      `wrapWithOpRecorder: '${name}' is neither journaled nor a non-document method. Journal it here, or add it to NON_DOCUMENT_METHODS if it changes no document state.`
+    );
+  }
+  return { ...base, ...wrapped };
+}
+
 // ../composition-ops/src/recordingStore.ts
 function createRecordingStore(initial) {
   const base = createHeadlessStore(initial);
@@ -378,28 +628,6 @@ function collectRawComponentClips(composition) {
   }
   return out;
 }
-function collectUnbakedComponentClips(composition) {
-  const tracks = composition?.tracks;
-  if (!Array.isArray(tracks)) return [];
-  const out = [];
-  for (const track of tracks) {
-    const contents = track?.contents;
-    if (!Array.isArray(contents)) continue;
-    for (const c of contents) {
-      const src = c?.source;
-      if (!src || typeof src !== "object") continue;
-      if (src.kind !== "overlay") continue;
-      if (src.primitiveId !== "custom") continue;
-      const params = src.params;
-      const componentId = params && typeof params === "object" ? params.componentId : void 0;
-      const clipId = c.id;
-      if (typeof componentId !== "string" || componentId.length === 0) continue;
-      if (typeof clipId !== "string" || clipId.length === 0) continue;
-      out.push({ clipId, componentId });
-    }
-  }
-  return out;
-}
 
 // ../composition-ops/src/index.ts
 var SceneAssetBindings = z.record(z.string().min(1), z.string().min(1));
@@ -726,6 +954,9 @@ function applyOpToStore(store, op) {
       store.moveClipToTrack(op.clipId, op.targetTrackId, op.newStartTime);
       break;
     case "duplicateClip": {
+      if (op.newClipId !== void 0 && findClipById(composition, op.newClipId)) {
+        throw new Error(`duplicateClip: clip '${op.newClipId}' already exists`);
+      }
       const minted = store.duplicateClip(op.clipId);
       if (op.newClipId !== void 0 && minted !== void 0 && minted !== op.newClipId) {
         store.updateClip(minted, { id: op.newClipId });
@@ -892,207 +1123,8 @@ function invertOp(before, op) {
   }
 }
 
-// ../composition-ops/src/opRecorder.ts
-var genTrackId = (kind) => `track-${kind}-${crypto.randomUUID().slice(0, 8)}`;
-function wrapWithOpRecorder(base, opts) {
-  const { record, getComposition } = opts;
-  const captionTarget = {
-    getState: () => ({ composition: getComposition() }),
-    setCaptionStyle: (style) => base.setCaptionStyle(style),
-    setCaptions: (segments, style) => base.setCaptions(segments, style)
-  };
-  const wrapped = {
-    addClip: (clip, options) => {
-      const before = getComposition();
-      const c = clip.kind ? clip : { ...clip, kind: "video" };
-      if (options?.newTrack) {
-        const newTrackId = options.newTrackId ?? genTrackId("video");
-        record({ type: "clip.add", clip: c, newTrack: true, newTrackId }, before);
-        base.addClip(c, { newTrack: true, newTrackId });
-      } else {
-        record({ type: "clip.add", clip: c }, before);
-        base.addClip(c);
-      }
-    },
-    removeClip: (id) => {
-      record({ type: "clip.remove", clipId: id }, getComposition());
-      base.removeClip(id);
-    },
-    updateClip: (id, updates) => {
-      record({ type: "clip.update", clipId: id, patch: updates }, getComposition());
-      base.updateClip(id, updates);
-    },
-    removeClipsByMediaId: (mediaId) => {
-      record({ type: "removeClipsByMediaId", mediaId }, getComposition());
-      base.removeClipsByMediaId(mediaId);
-    },
-    setClipProperties: (id, props) => {
-      const { playbackRate, ...patch } = props;
-      if (playbackRate !== void 0) {
-        if (opts.onUnjournalable) {
-          const result = base.setClipProperties(id, props);
-          opts.onUnjournalable("setClipProperties.playbackRate");
-          return result;
-        }
-        throw new Error(
-          "opRecorder.setClipProperties: playbackRate is not serializable as a clip.update op (source.playbackRate triggers a cross-field ripple). Use the server-authoritative ripple path."
-        );
-      }
-      record({ type: "clip.update", clipId: id, patch }, getComposition());
-      return base.setClipProperties(id, props);
-    },
-    addOverlay: (clip) => {
-      const before = getComposition();
-      const track = before.tracks.find((t) => t.kind === "overlay");
-      let trackId = track?.id;
-      if (!trackId) {
-        trackId = genTrackId("overlay");
-        record({ type: "addTrack", kind: "overlay", id: trackId }, before);
-        base.addTrack("overlay", void 0, trackId);
-      }
-      record({ type: "clip.add", clip, trackId }, getComposition());
-      base.addOverlay(clip);
-    },
-    removeOverlay: (id) => {
-      record({ type: "clip.remove", clipId: id }, getComposition());
-      base.removeOverlay(id);
-    },
-    updateOverlay: (id, updates) => {
-      record({ type: "clip.update", clipId: id, patch: updates }, getComposition());
-      base.updateOverlay(id, updates);
-    },
-    loadOverlays: (clips) => {
-      record({ type: "loadOverlays", clips }, getComposition());
-      base.loadOverlays(clips);
-    },
-    addAudioClip: (clip) => {
-      const before = getComposition();
-      const track = before.tracks.find((t) => t.kind === "audio");
-      let trackId = track?.id;
-      if (!trackId) {
-        trackId = genTrackId("audio");
-        record({ type: "addTrack", kind: "audio", id: trackId }, before);
-        base.addTrack("audio", void 0, trackId);
-      }
-      record({ type: "clip.add", clip, trackId }, getComposition());
-      base.addAudioClip(clip);
-    },
-    removeAudioClip: (id) => {
-      record({ type: "clip.remove", clipId: id }, getComposition());
-      base.removeAudioClip(id);
-    },
-    updateAudioClip: (id, updates) => {
-      record({ type: "clip.update", clipId: id, patch: updates }, getComposition());
-      base.updateAudioClip(id, updates);
-    },
-    addMarker: (marker) => {
-      record({ type: "addMarker", marker }, getComposition());
-      base.addMarker(marker);
-    },
-    removeMarker: (id) => {
-      record({ type: "removeMarker", markerId: id }, getComposition());
-      base.removeMarker(id);
-    },
-    updateMarker: (id, updates) => {
-      record({ type: "updateMarker", markerId: id, updates }, getComposition());
-      base.updateMarker(id, updates);
-    },
-    setCropIntents: (clipId, segments) => {
-      record({ type: "setCropIntents", clipId, segments }, getComposition());
-      base.setCropIntents(clipId, segments);
-    },
-    setEffects: (clipId, effects) => {
-      record({ type: "setEffects", clipId, effects }, getComposition());
-      base.setEffects(clipId, effects);
-    },
-    // The two caption writes go through the same function `applyOpToStore` uses, so the op this
-    // journals is exactly the op a replay applies. Calling the store's setter directly left this
-    // lane — Studio's composition store and the in-app agent capability are built on it — able to
-    // write a face the op gate refuses and to journal an op `applyOp` would refuse on replay.
-    // The op is applied FIRST: a refusal must leave nothing in the journal.
-    setCaptionStyle: (style) => {
-      const before = getComposition();
-      const op = { type: "setCaptionStyle", style };
-      applyCaptionOpToStore(captionTarget, op);
-      record(op, before);
-    },
-    setCaptions: (segments, style) => {
-      const before = getComposition();
-      const op = {
-        type: "setCaptions",
-        segments,
-        ...style !== void 0 ? { style } : {}
-      };
-      applyCaptionOpToStore(captionTarget, op);
-      record(op, before);
-    },
-    setFormat: (format) => {
-      record({ type: "setFormat", format }, getComposition());
-      base.setFormat(format);
-    },
-    addTrack: (kind, name, id) => {
-      const useId = id ?? genTrackId(kind);
-      record({ type: "addTrack", kind, ...name !== void 0 ? { name } : {}, id: useId }, getComposition());
-      base.addTrack(kind, name, useId);
-    },
-    removeTrack: (trackId) => {
-      record({ type: "removeTrack", trackId }, getComposition());
-      base.removeTrack(trackId);
-    },
-    updateTrack: (trackId, updates) => {
-      record({ type: "updateTrack", trackId, updates }, getComposition());
-      base.updateTrack(trackId, updates);
-    },
-    reorderTracks: (fromIndex, toIndex) => {
-      record({ type: "reorderTracks", fromIndex, toIndex }, getComposition());
-      base.reorderTracks(fromIndex, toIndex);
-    },
-    moveClipToTrack: (clipId, targetTrackId, newStartTime) => {
-      record(
-        {
-          type: "moveClipToTrack",
-          clipId,
-          targetTrackId,
-          ...newStartTime !== void 0 ? { newStartTime } : {}
-        },
-        getComposition()
-      );
-      base.moveClipToTrack(clipId, targetTrackId, newStartTime);
-    },
-    duplicateClip: (id) => {
-      record({ type: "duplicateClip", clipId: id }, getComposition());
-      return base.duplicateClip(id);
-    },
-    cutAndRipple: (start, end) => {
-      record({ type: "cutAndRipple", start, end }, getComposition());
-      base.cutAndRipple(start, end);
-    },
-    ripple: (time, amount) => {
-      record({ type: "ripple", time, amount }, getComposition());
-      base.ripple(time, amount);
-    },
-    addExcludedRange: (clipId, sourceStart, sourceEnd, reason) => {
-      record(
-        {
-          type: "addExcludedRange",
-          clipId,
-          sourceStart,
-          sourceEnd,
-          ...reason !== void 0 ? { reason } : {}
-        },
-        getComposition()
-      );
-      base.addExcludedRange(clipId, sourceStart, sourceEnd, reason);
-    },
-    removeExcludedRange: (clipId, rangeIdx) => {
-      record({ type: "removeExcludedRange", clipId, rangeIdx }, getComposition());
-      base.removeExcludedRange(clipId, rangeIdx);
-    }
-  };
-  return { ...base, ...wrapped };
-}
-
 export {
+  NON_DOCUMENT_METHODS,
   wrapWithOpRecorder,
   createRecordingStore,
   CaptionMaterializationError,
@@ -1106,7 +1138,6 @@ export {
   replaceRegion,
   collectAlphaLayerClips,
   collectRawComponentClips,
-  collectUnbakedComponentClips,
   mediaFamily,
   resolveClipKind,
   CompositionOp,

package/dist/{chunk-VZ7TYX6Z.js → chunk-P3EFZDM5.js}

@@ -37,7 +37,6 @@ var AMBIENCE_BED = {
 };
 var SFX_TRACK_ID = "track-audio-sfx";
 var MUSIC_TRACK_ID = "track-audio-music";
-var AMBIENCE_TRACK_ID = "track-audio-ambience";
 
 // ../composition/src/audio/mixStaging.ts
 var ROLE_DEFAULT_GAIN_DB = {
@@ -78,20 +77,6 @@ function effectiveClipGainDb(source, voPresent) {
   if (source.audioRole !== void 0) return roleDefaultGainDb(source.audioRole, voPresent);
   return void 0;
 }
-function sfxTransients(composition) {
-  const out = [];
-  for (const track of composition.tracks) {
-    if (track.enabled === false) continue;
-    for (const c of track.contents) {
-      if (!("source" in c)) continue;
-      const src = c.source;
-      if (src.kind === "media" && src.audioRole === "sfx") {
-        out.push({ clipId: c.id, startMs: Math.round(c.startTime * 1e3) });
-      }
-    }
-  }
-  return out.sort((a, b) => a.startMs - b.startMs);
-}
 function detectNoAudioTrack(composition) {
   if ((composition.markers ?? []).some((m) => m.kind === "intentional-silence")) return [];
   for (const track of composition.tracks) {
@@ -415,13 +400,11 @@ export {
   AMBIENCE_BED,
   SFX_TRACK_ID,
   MUSIC_TRACK_ID,
-  AMBIENCE_TRACK_ID,
   ROLE_DEFAULT_GAIN_DB,
   ROLE_HIERARCHY,
   roleDefaultGainDb,
   compositionHasVo,
   effectiveClipGainDb,
-  sfxTransients,
   detectNoAudioTrack,
   detectMixHierarchyInversion,
   sfxPackR2Key,

package/dist/{chunk-BEFSJMFF.js → chunk-P6RVYHLT.js}

@@ -3,20 +3,20 @@ import {
   assertSceneShotParamsAdmitted,
   materializeComponentSource,
   renderComponentAlpha
-} from "./chunk-HGCYZMII.js";
+} from "./chunk-AK6QPX7A.js";
+import {
+  assertSourceReadsDeclaredAssets
+} from "./chunk-6HPEMDQW.js";
+import {
+  resolvedComponentRenderer
+} from "./chunk-KC4LNZL5.js";
 import {
   componentArtifactId,
   componentBundleId,
   componentRenderKey,
   sha256Hex,
   sourceVersionId
-} from "./chunk-EXY4JJPH.js";
-import {
-  assertSourceReadsDeclaredAssets
-} from "./chunk-WL2MLKWU.js";
-import {
-  resolvedComponentRenderer
-} from "./chunk-JWMWVP64.js";
+} from "./chunk-F6PLDBAK.js";
 import {
   ComponentBakeJobV2,
   ComponentBakeRequestV2,
@@ -25,7 +25,7 @@ import {
   ComponentRuntimeError,
   assertGraphicsReceiptMatches,
   assertRendererReceiptMatches
-} from "./chunk-EC6VFQE6.js";
+} from "./chunk-BZVOCVQV.js";
 
 // ../execution/component-runtime/src/assetServer.ts
 import { createHash, randomBytes } from "crypto";

package/dist/{chunk-TBHSOEYK.js → chunk-PLWDYWK6.js}

@@ -1,3 +1,6 @@
+import {
+  canonicalJson
+} from "./chunk-XHMKPTHV.js";
 import {
   checkTracks
 } from "./chunk-T56BK7NS.js";
@@ -5,23 +8,8 @@ import {
 // ../composition/src/invariants/etag.ts
 import { sha256 } from "@noble/hashes/sha256";
 import { bytesToHex } from "@noble/hashes/utils";
-function canonicalJSON(value) {
-  return JSON.stringify(canonicalize(value));
-}
-function canonicalize(value) {
-  if (value === null || typeof value !== "object") return value;
-  if (Array.isArray(value)) return value.map(canonicalize);
-  const out = {};
-  const keys = Object.keys(value).sort();
-  for (const key of keys) {
-    const v = value[key];
-    if (v === void 0) continue;
-    out[key] = canonicalize(v);
-  }
-  return out;
-}
 function etag(composition) {
-  const canonical = canonicalJSON(composition);
+  const canonical = canonicalJson(composition);
   const hash = bytesToHex(sha256(new TextEncoder().encode(canonical)));
   return `"${hash}"`;
 }
@@ -138,20 +126,6 @@ function compositionDuration(composition) {
   return max;
 }
 
-// ../composition/src/invariants/time.ts
-function otioFrames(seconds, fps) {
-  return Math.round(seconds * fps);
-}
-function otioRationalTime(seconds, fps) {
-  return { value: Math.round(seconds * fps), rate: fps };
-}
-function sourceFrame(params) {
-  const { outputFrame, formatFps, clipStartTime, trimStart, playbackRate, sourceFps } = params;
-  const outSeconds = outputFrame / formatFps;
-  const sourceSeconds = trimStart + (outSeconds - clipStartTime) * playbackRate;
-  return Math.round(sourceSeconds * sourceFps);
-}
-
 // ../composition/src/invariants/clipPlacement.ts
 var AUDIO_TRACK_KINDS = /* @__PURE__ */ new Set(["audio"]);
 var VISUAL_TRACK_KINDS = /* @__PURE__ */ new Set(["video", "image"]);
@@ -196,7 +170,6 @@ function collectClipPlacementIssues(composition, mediaKindById) {
 }
 
 export {
-  canonicalJSON,
   etag,
   checkSceneMarkerPartition,
   checkIdCollisions,
@@ -204,8 +177,5 @@ export {
   checkKeyframes,
   checkComposition,
   compositionDuration,
-  otioFrames,
-  otioRationalTime,
-  sourceFrame,
   collectClipPlacementIssues
 };

package/dist/{chunk-KYRDKK2D.js → chunk-Q6CJ6HCU.js}

@@ -34,14 +34,9 @@ function expandToLinkGroup(composition, entities) {
 function linkPartners(composition, clipId) {
   return expandClipIdsToLinkGroups(composition, [clipId]).filter((id) => id !== clipId);
 }
-function makeLinkGroup(clipIds, newGroupId) {
-  if (clipIds.length < 2) return null;
-  return { linkGroupId: newGroupId(), clipIds };
-}
 
 export {
   expandClipIdsToLinkGroups,
   expandToLinkGroup,
-  linkPartners,
-  makeLinkGroup
+  linkPartners
 };