@cueframe/kernel 0.2.57 → 0.2.58

package/dist/chunk-TR53N6HB.js

@@ -0,0 +1,196 @@
+import {
+  MotifMotionPreset
+} from "./chunk-PWWZTY3G.js";
+import {
+  GraphicRole
+} from "./chunk-UFD4EZHM.js";
+
+// ../composition/src/validators/brandKitBody.ts
+import { z } from "zod";
+var BrandFontField = z.object({
+  fontFamily: z.string().min(1, "fontFamily: non-empty string"),
+  fontWeight: z.number()
+});
+var BrandMotifBody = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("card"),
+    html: z.string().min(1, "motifs[].body.html: non-empty string"),
+    tokens: z.record(z.string(), z.string()).optional()
+  }),
+  z.object({
+    kind: z.literal("overlay"),
+    primitiveId: z.string().min(1),
+    params: z.record(z.string(), z.unknown()).optional()
+  }),
+  z.object({
+    kind: z.literal("component"),
+    componentId: z.string().min(1),
+    props: z.record(z.string(), z.unknown()).optional()
+  })
+]);
+var BrandMotif = z.object({
+  id: z.string().min(1).max(40),
+  observed: z.string().min(1).max(500),
+  body: BrandMotifBody,
+  motion: z.object({
+    preset: MotifMotionPreset,
+    enterMs: z.number().int().min(0).max(5e3).optional(),
+    exitMs: z.number().int().min(0).max(5e3).optional(),
+    staggerMs: z.number().int().min(0).max(2e3).optional(),
+    confidence: z.enum(["high", "low"]).optional()
+  }).optional(),
+  role: z.enum(GraphicRole.options),
+  zone: z.object({ x: z.number(), y: z.number(), w: z.number(), h: z.number() }).optional(),
+  evidence: z.array(z.number().int().min(0)).max(24).optional(),
+  diffScore: z.number().min(0).max(1).optional(),
+  coverage: z.enum(["reproduced", "approximated", "skipped"]),
+  skipReason: z.string().max(300).optional()
+});
+var BrandAudioPaletteRef = z.string().min(1);
+var BrandAudioSchema = z.object({
+  sfxIntensity: z.enum(["off", "light", "standard", "dense"]).optional(),
+  musicEnabled: z.boolean().optional(),
+  musicMood: z.string().max(300).optional(),
+  sonicLogo: z.object({
+    ref: BrandAudioPaletteRef,
+    placement: z.enum(["intro", "outro", "both"]),
+    offsetMs: z.number().int().min(0).max(1e4).optional()
+  }).optional().describe(
+    "A brand sound signature bound to the intro/outro bookend. `ref` = a palette reference; bound only when the kit carries the matching bumper (intro/outro), else a non-blocking advisory."
+  ),
+  uiSoundSet: z.object({
+    tick: BrandAudioPaletteRef.optional(),
+    pop: BrandAudioPaletteRef.optional(),
+    impact: BrandAudioPaletteRef.optional(),
+    confirm: BrandAudioPaletteRef.optional(),
+    error: BrandAudioPaletteRef.optional(),
+    whoosh: BrandAudioPaletteRef.optional(),
+    riser: BrandAudioPaletteRef.optional()
+  }).optional().describe(
+    "Per-family SFX overrides (the brand's own tick/pop/\u2026). Highest-priority tier over the org palette + pack default in the compose SFX draw."
+  ),
+  bedStyle: z.object({
+    bedId: BrandAudioPaletteRef.optional(),
+    genre: z.string().max(120).optional(),
+    bpmRange: z.object({ min: z.number(), max: z.number() }).optional()
+  }).optional().describe(
+    "Preferred music bed (`bedId`) or a style hint (`genre` / `bpmRange`). Surfaced for driving agents; compose does not auto-select a pack bed."
+  ),
+  ambiencePreference: z.object({ ref: BrandAudioPaletteRef }).nullable().optional().describe(
+    "Preferred ambience bed (`{ref}`) or explicit null (opt-out). Surfaced for driving agents; compose has no ambience auto-placement."
+  )
+});
+var BrandIntroOutroBody = (field) => z.object({
+  kind: z.enum(["card", "video"]),
+  src: z.string().min(1, `${field}.src: non-empty string`).optional(),
+  title: z.string().optional(),
+  subtitle: z.string().optional(),
+  durationMs: z.number().optional()
+});
+var BrandKitBodyShape = {
+  kitId: z.string().min(1, "kitId: non-empty string required").max(200, "kitId: exceeds max length of 200").refine((v) => v.trim().length > 0, "kitId: non-empty string required"),
+  name: z.string().min(1, "name: non-empty string required").max(200, "name: exceeds max length of 200").refine((v) => v.trim().length > 0, "name: non-empty string required"),
+  description: z.string().max(2e3).optional(),
+  tagline: z.string().max(500).optional(),
+  secondaryTagline: z.string().max(500).optional(),
+  colors: z.object({
+    primary: z.string().min(1, "colors.primary: non-empty string"),
+    secondary: z.string().min(1, "colors.secondary: non-empty string"),
+    accent: z.string().min(1, "colors.accent: non-empty string"),
+    background: z.string().min(1, "colors.background: non-empty string"),
+    text: z.string().min(1, "colors.text: non-empty string")
+  }),
+  extraColors: z.array(z.object({
+    hex: z.string().min(1, "extraColors[].hex: non-empty string"),
+    label: z.string().min(1, "extraColors[].label: non-empty string"),
+    usage: z.string().optional()
+  })).optional(),
+  headingFont: BrandFontField,
+  bodyFont: BrandFontField,
+  voiceGuidelines: z.string().max(5e3).optional(),
+  syncCaptions: z.boolean().optional(),
+  captionProfile: z.object({
+    fontFamily: z.string().optional(),
+    fontSize: z.number().optional(),
+    fontWeight: z.number().optional(),
+    color: z.string().optional(),
+    highlightColor: z.string().optional(),
+    backgroundColor: z.string().optional(),
+    plate: z.enum(["glass", "solid", "none"]).optional(),
+    position: z.enum(["top", "center", "bottom"]).optional(),
+    textTransform: z.enum(["none", "uppercase"]).optional(),
+    entrance: z.enum(["none", "fade", "word-pop", "stagger-up"]).optional(),
+    entranceMs: z.number().optional(),
+    entranceStaggerMs: z.number().optional(),
+    exitMs: z.number().optional(),
+    emphasisColor: z.string().optional(),
+    emphasisScale: z.number().optional(),
+    emphasisFontFamily: z.string().optional(),
+    emphasisFontWeight: z.number().optional(),
+    emphasisFontStyle: z.enum(["normal", "italic"]).optional(),
+    emphasisTextTransform: z.enum(["none", "uppercase"]).optional(),
+    emphasisLetterSpacing: z.number().optional(),
+    emphasisPlate: z.boolean().optional(),
+    emphasisPlateColor: z.string().optional(),
+    emphasisPlateTextColor: z.string().optional()
+  }).optional(),
+  motion: z.object({
+    duration: z.number().optional(),
+    easing: z.union([
+      z.enum(["linear", "ease", "ease-in", "ease-out", "ease-in-out"]),
+      z.object({
+        kind: z.literal("cubic-bezier"),
+        x1: z.number(),
+        y1: z.number(),
+        x2: z.number(),
+        y2: z.number()
+      })
+    ]).optional(),
+    entrance: z.enum(["none", "fade", "word-pop", "stagger-up"]).optional(),
+    staggerMs: z.number().optional(),
+    exitMs: z.number().optional()
+  }).optional(),
+  logo: z.object({
+    src: z.string().min(1, "logo.src: non-empty string"),
+    alt: z.string().optional(),
+    placement: z.enum(["tl", "tr", "bl", "br"]).optional(),
+    sizePct: z.number().optional()
+  }).optional(),
+  intro: BrandIntroOutroBody("intro").optional(),
+  outro: BrandIntroOutroBody("outro").optional(),
+  watermark: z.object({
+    src: z.string().min(1, "watermark.src: non-empty string"),
+    opacity: z.number().min(0).max(1).optional(),
+    placement: z.enum(["tl", "tr", "bl", "br"]).optional()
+  }).optional(),
+  spacing: z.object({
+    base: z.number().optional(),
+    lg: z.number().optional(),
+    sm: z.number().optional()
+  }).optional(),
+  sizing: z.object({
+    fontSizeHeading: z.number().optional(),
+    fontSizeBody: z.number().optional(),
+    fontSizeLabel: z.number().optional(),
+    borderRadius: z.number().optional()
+  }).optional(),
+  audio: BrandAudioSchema.optional(),
+  motifs: z.array(BrandMotif).max(24).optional(),
+  styleRubric: z.string().max(4e3).optional(),
+  density: z.object({
+    graphicsPerMin: z.number().min(0).max(60),
+    maxSimultaneous: z.number().int().min(1).max(6)
+  }).optional(),
+  inspiration: z.object({
+    sources: z.array(z.string()).min(1).max(24),
+    extractedAt: z.number(),
+    extractionVersion: z.string().min(1).max(60)
+  }).optional()
+};
+var BrandKitBodySchema = z.strictObject(BrandKitBodyShape);
+
+export {
+  BrandAudioSchema,
+  BrandKitBodyShape,
+  BrandKitBodySchema
+};

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

@@ -3,7 +3,7 @@ import {
   projectMediaPlaybackSpans,
   sliceTranscriptWords,
   splitIntoSentences
-} from "./chunk-VXGA7LQQ.js";
+} from "./chunk-NVXSKKRN.js";
 import {
   createHeadlessStore,
   findClipById,
@@ -40,6 +40,206 @@ 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)}`;
+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 };
+}
+
 // ../composition-ops/src/recordingStore.ts
 function createRecordingStore(initial) {
   const base = createHeadlessStore(initial);
@@ -892,206 +1092,6 @@ 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 {
   wrapWithOpRecorder,
   createRecordingStore,

package/dist/component-runtime/template/testing.d.ts

@@ -0,0 +1 @@
+export * from "../../_members/component-runtime/template/testing/index.js";