@cueframe/kernel 0.2.2 → 0.2.4

package/dist/{chunk-RFXR7ATW.js → chunk-MN6D3U5N.js}

@@ -1,6 +1,6 @@
 import {
   getPrimitiveCatalogMeta
-} from "./chunk-C5SEPOWD.js";
+} from "./chunk-7AZLFN26.js";
 
 // ../execution/render-harness/src/renderInputAssets.ts
 function isRemoteUrl(u) {
@@ -125,6 +125,18 @@ function* assetSlots(input) {
       track.src = u;
     } };
   }
+  for (const [clipId, component] of Object.entries(input.componentSources ?? {})) {
+    for (const [name, asset] of Object.entries(component.assets)) {
+      yield {
+        role: "componentAsset",
+        path: `componentSources[${clipId}].assets[${name}].handle`,
+        get: () => asset.handle,
+        set: (url) => {
+          asset.handle = url;
+        }
+      };
+    }
+  }
   for (const overlay of input.overlays ?? []) {
     for (const assetPath of parameterAssetPaths(overlay.template)) {
       yield* annotatedSlots(overlay.params, assetPath.split("."), `overlays[${overlay.id}].params`);

package/dist/{chunk-IJ7PVJTK.js → chunk-ODUWCQI3.js}

@@ -1,9 +1,10 @@
 import {
   CueframeError
-} from "./chunk-4FOOBSEE.js";
+} from "./chunk-J3DIUG24.js";
 
 // ../execution/render-harness/src/cardAssetAdmission.ts
-import { parse as parseCss, walk as walkCss } from "css-tree";
+import parseCss from "css-tree/parser";
+import walkCss from "css-tree/walker";
 import { parseFragment } from "parse5";
 var RESOURCE_ELEMENTS = /* @__PURE__ */ new Set([
   "audio",

package/dist/chunk-QAGGJHAF.js

@@ -0,0 +1,16 @@
+// ../execution/primitives/src/lib/frameScale.ts
+import { useVideoConfig } from "remotion";
+var FRAME_BASELINE_WIDTH = 1280;
+function frameScale(width, baseline = FRAME_BASELINE_WIDTH) {
+  return Math.max(0.5, width / baseline);
+}
+function useFrameScale(baseline = FRAME_BASELINE_WIDTH) {
+  const { width } = useVideoConfig();
+  return frameScale(width, baseline);
+}
+
+export {
+  FRAME_BASELINE_WIDTH,
+  frameScale,
+  useFrameScale
+};

package/dist/chunk-QS36DMFG.js

@@ -0,0 +1,332 @@
+import {
+  isSceneShotClip,
+  isTimelineClip,
+  readSceneSourceRef,
+  sceneClipOverlapIssue,
+  sceneClipShapeIssues,
+  sceneDedicatedTrackIssue,
+  sceneShotImageSlots,
+  sceneShotVideoSlots,
+  sceneSpecIssues
+} from "./chunk-MH3UPKWR.js";
+
+// ../authoring/src/scene/validate.ts
+var SceneAuthoringError = class extends Error {
+  code;
+  path;
+  clipId;
+  opIndex;
+  constructor(code, path, detail, options = {}) {
+    const who = options.op !== void 0 && options.clipId !== void 0 ? `${options.op} '${options.clipId}' ` : options.clipId !== void 0 ? `scene shot '${options.clipId}' ` : "";
+    super(`${who}${path}: ${detail}`);
+    this.name = "SceneAuthoringError";
+    this.code = code;
+    this.path = path;
+    this.clipId = options.clipId;
+    this.opIndex = options.opIndex;
+  }
+};
+var isSceneOp = (op) => {
+  const type = !!op && typeof op === "object" ? op.type : void 0;
+  return type === "scene.add" || type === "scene.update";
+};
+var hasSceneOp = (ops) => ops.some(isSceneOp);
+function firstIssue(issues, op, clipId) {
+  const first = issues[0];
+  if (!first) return null;
+  const detail = issues.length > 1 && issues.every((issue) => issue.path.startsWith(first.path.split(".")[0])) ? issues.map((issue) => `${issue.path}: ${issue.detail}`).join("; ") : first.detail;
+  return new SceneAuthoringError(first.code, first.path, detail, { clipId, op });
+}
+function findClip(composition, clipId) {
+  for (const track of composition.tracks) {
+    for (const content of track.contents) {
+      if (isTimelineClip(content) && content.id === clipId) return { clip: content, track };
+    }
+  }
+  return null;
+}
+function sceneTrackIdFor(clipId) {
+  return `track-scene-${clipId}`;
+}
+function validateSceneAdd(op, composition, ctx) {
+  const fail = (code, path, detail) => new SceneAuthoringError(code, path, detail, { clipId: op.clipId, op: "scene.add" });
+  if (findClip(composition, op.clipId)) {
+    throw fail("invalid_composition", "clipId", `clip '${op.clipId}' already exists; use scene.update to revise it or pick a new id.`);
+  }
+  const wantsExisting = op.trackId !== void 0;
+  const wantsNew = op.newTrack === true || op.newTrackId !== void 0;
+  if (wantsExisting === wantsNew) {
+    throw fail("validation_error", "trackId", "pass either `trackId` (a dedicated overlay track) or `newTrack: true` (optionally `newTrackId`), not both and not neither.");
+  }
+  let track;
+  let existing;
+  if (wantsExisting) {
+    existing = composition.tracks.find((candidate) => candidate.id === op.trackId);
+    if (!existing) throw fail("invalid_composition", "trackId", `no track '${op.trackId}' in the composition.`);
+    const dedicated = sceneDedicatedTrackIssue(existing, ctx.resolveSource, "trackId");
+    if (dedicated) throw fail(dedicated.code, dedicated.path, dedicated.detail);
+    track = { id: existing.id, create: false };
+  } else {
+    const id = op.newTrackId ?? sceneTrackIdFor(op.clipId);
+    if (composition.tracks.some((candidate) => candidate.id === id)) {
+      throw fail("invalid_composition", "newTrackId", `track '${id}' already exists; pass a different \`newTrackId\` or target it with \`trackId\`.`);
+    }
+    track = { id, create: true };
+  }
+  const parsed = sceneSpecIssues(op.scene, "scene");
+  const specError = firstIssue(parsed.issues, "scene.add", op.clipId);
+  if (specError) throw specError;
+  const clip = {
+    id: op.clipId,
+    startTime: op.startTime,
+    duration: op.duration,
+    ...op.transitionIn !== void 0 ? { transitionIn: op.transitionIn } : {},
+    source: {
+      kind: "component",
+      componentId: "",
+      props: { scene: parsed.spec },
+      assets: op.assets,
+      zPlane: "front"
+    }
+  };
+  const shape = sceneClipShapeIssues(clip, ctx, { checkMedia: true }).map((issue) => ({ ...issue, path: issue.path.replace(/^source\.assets/, "assets").replace(/^source\.props\.scene/, "scene") }));
+  const shapeError = firstIssue(shape, "scene.add", op.clipId);
+  if (shapeError) throw shapeError;
+  if (existing) {
+    const overlap = sceneClipOverlapIssue(clip, existing);
+    if (overlap) throw fail(overlap.code, overlap.path, overlap.detail);
+  }
+  return { spec: parsed.spec, slots: sceneShotImageSlots(parsed.spec), track, clip };
+}
+function validateSceneUpdate(op, composition, ctx) {
+  const fail = (code, path, detail) => new SceneAuthoringError(code, path, detail, { clipId: op.clipId, op: "scene.update" });
+  const found = findClip(composition, op.clipId);
+  if (!found) throw fail("invalid_composition", "clipId", `no clip '${op.clipId}' in the composition; scene.update targets a clip created by scene.add.`);
+  const { clip: current, track } = found;
+  if (!isSceneShotClip(current, ctx.resolveSource)) {
+    throw fail(
+      "invalid_composition",
+      "clipId",
+      `clip '${op.clipId}' is not a scene shot (source '${current.source.kind}'${current.source.kind === "component" ? ", no admitted scene-shot source pinned" : ""}); scene.update targets clips created by scene.add.`
+    );
+  }
+  const ref = readSceneSourceRef(current.source.props);
+  const currentDeclaration = ctx.resolveSource(current.source.componentId, ref.sourceVersionId);
+  const persisted = sceneSpecIssues(current.source.props.scene, "clipId");
+  if (persisted.issues.length > 0 && op.scene === void 0) {
+    throw fail("invalid_composition", "clipId", `the persisted scene on '${op.clipId}' no longer validates (${persisted.issues[0].path}: ${persisted.issues[0].detail}); send a replacement \`scene\`.`);
+  }
+  let spec = persisted.spec;
+  if (op.scene !== void 0) {
+    const parsed = sceneSpecIssues(op.scene, "scene");
+    const specError = firstIssue(parsed.issues, "scene.update", op.clipId);
+    if (specError) throw specError;
+    spec = parsed.spec;
+  }
+  const assets = op.assets ?? current.source.assets ?? {};
+  const clip = {
+    ...current,
+    ...op.startTime !== void 0 ? { startTime: op.startTime } : {},
+    ...op.duration !== void 0 ? { duration: op.duration } : {},
+    ...op.transitionIn !== void 0 ? { transitionIn: op.transitionIn } : {},
+    source: {
+      kind: "component",
+      componentId: current.source.componentId,
+      props: { componentRef: { version: 1, sourceVersionId: ref.sourceVersionId }, scene: spec },
+      assets,
+      zPlane: "front"
+    }
+  };
+  const shape = sceneClipShapeIssues(clip, ctx, { checkMedia: op.assets !== void 0 || op.scene !== void 0 }).map((issue) => ({ ...issue, path: issue.path.replace(/^source\.assets/, "assets").replace(/^source\.props\.scene/, "scene") }));
+  const shapeError = firstIssue(shape, "scene.update", op.clipId);
+  if (shapeError) throw shapeError;
+  const overlap = sceneClipOverlapIssue(clip, track);
+  if (overlap) {
+    throw fail(overlap.code, op.duration !== void 0 && op.startTime === void 0 ? "duration" : overlap.path, overlap.detail);
+  }
+  return {
+    spec,
+    slots: sceneShotImageSlots(spec),
+    trackId: track.id,
+    componentId: current.source.componentId,
+    currentSourceVersionId: ref.sourceVersionId,
+    currentDeclaration,
+    clip,
+    timing: {
+      ...op.startTime !== void 0 ? { startTime: op.startTime } : {},
+      ...op.duration !== void 0 ? { duration: op.duration } : {},
+      ...op.transitionIn !== void 0 ? { transitionIn: op.transitionIn } : {}
+    }
+  };
+}
+
+// ../authoring/src/scene/wrapper.ts
+var SCENE_SHOT_WRAPPER_VERSION = 2;
+var SCENE_IMAGE_MIME_TYPES = ["image/png", "image/jpeg", "image/webp"];
+var SCENE_VIDEO_MIME_TYPES = ["video/mp4", "video/webm"];
+var SCENE_SHOT_WRAPPER_SOURCE = `// generated by @cueframe/authoring generateSceneShotWrapper \u2014 scene-shot v${SCENE_SHOT_WRAPPER_VERSION}
+import { PreparedSceneShotV1 } from '@cueframe/animate';
+export default function SceneShotClip({ params, render }) {
+  if (!params || !params.preparedSceneShot) throw new Error('scene_prepared_plan_required: Scene-shot V2 rendering requires a prepared scene plan.');
+  return <PreparedSceneShotV1 plan={params.preparedSceneShot} render={render} />;
+}
+`;
+function sceneShotAlphaPolicy(spec) {
+  return spec.backdrop.kind === "transparent" ? "requires-transparency" : "allows-opaque";
+}
+function sceneShotManifest(slots, alphaPolicy, videoSlots = []) {
+  const assets = {};
+  for (const slot of [...new Set(slots)].sort()) {
+    assets[slot] = { kind: "image", required: true, mimeTypes: [...SCENE_IMAGE_MIME_TYPES] };
+  }
+  for (const slot of [...new Set(videoSlots)].sort()) {
+    assets[slot] = { kind: "video", required: true, mimeTypes: [...SCENE_VIDEO_MIME_TYPES] };
+  }
+  return {
+    version: 2,
+    assets,
+    graphics: { api: "webgl", required: true, accelerationPreference: "hardware-preferred" },
+    alphaPolicy,
+    sceneShot: { version: SCENE_SHOT_WRAPPER_VERSION }
+  };
+}
+function generateSceneShotWrapper(spec) {
+  return {
+    tsxSource: SCENE_SHOT_WRAPPER_SOURCE,
+    manifest: sceneShotManifest(sceneShotImageSlots(spec), sceneShotAlphaPolicy(spec), sceneShotVideoSlots(spec))
+  };
+}
+
+// ../authoring/src/scene/materialize.ts
+function sceneDurationInFrames(seconds, fps, opIndex, clipId) {
+  const frames = Math.round(seconds * fps);
+  if (!Number.isInteger(frames) || frames < 1) {
+    throw new SceneAuthoringError(
+      "invalid_composition",
+      "duration",
+      `${seconds} s is ${frames} frames at ${fps} fps, and a scene shot is at least one frame; the positivity and frame-lattice rules should have refused this before it reached source registration.`,
+      { opIndex, clipId }
+    );
+  }
+  return frames;
+}
+var SCENE_TRACK_NAME = "Scene shots";
+function canonical(value) {
+  const sort = (item) => Array.isArray(item) ? item.map(sort) : item !== null && typeof item === "object" ? Object.fromEntries(Object.keys(item).sort().map((key) => [key, sort(item[key])])) : item;
+  return JSON.stringify(sort(value));
+}
+function sameManifest(a, b) {
+  return canonical(a) === canonical(b);
+}
+async function materializeSceneOpsCore(composition, ops, deps) {
+  const out = [];
+  const staged = /* @__PURE__ */ new Map();
+  const resolveSource = (componentId, sourceVersionId) => staged.get(`${componentId}:${sourceVersionId}`) ?? deps.resolveSource(componentId, sourceVersionId);
+  const fpsOf = typeof deps.fps === "function" ? deps.fps : () => deps.fps;
+  const contextFor = (composition2) => ({
+    fps: fpsOf(composition2),
+    resolveSource,
+    ...deps.mediaKindById !== void 0 ? { mediaKindById: deps.mediaKindById } : {}
+  });
+  const emit = (op, current2) => {
+    out.push(op);
+    return deps.apply(current2, op);
+  };
+  const register = async (registration) => {
+    const registered = await deps.sink(registration);
+    staged.set(`${registered.componentId}:${registered.sourceVersionId}`, {
+      componentId: registered.componentId,
+      manifest: registration.manifest
+    });
+    return registered;
+  };
+  let current = composition;
+  for (let i = 0; i < ops.length; i++) {
+    const op = ops[i];
+    if (!isSceneOp(op)) {
+      current = emit(op, current);
+      continue;
+    }
+    try {
+      const ctx = contextFor(current);
+      if (op.type === "scene.add") {
+        const validated2 = validateSceneAdd(op, current, ctx);
+        const wrapper2 = generateSceneShotWrapper(validated2.spec);
+        const registered = await register({
+          opIndex: i,
+          clipId: op.clipId,
+          tsxSource: wrapper2.tsxSource,
+          manifest: wrapper2.manifest,
+          scene: validated2.spec,
+          assets: op.assets,
+          fps: ctx.fps,
+          durationInFrames: sceneDurationInFrames(op.duration, ctx.fps, i, op.clipId)
+        });
+        if (validated2.track.create) {
+          current = emit({ type: "addTrack", kind: "overlay", id: validated2.track.id, name: SCENE_TRACK_NAME }, current);
+        }
+        const clip = {
+          ...validated2.clip,
+          source: {
+            ...validated2.clip.source,
+            componentId: registered.componentId,
+            props: { componentRef: { version: 1, sourceVersionId: registered.sourceVersionId }, scene: validated2.spec }
+          }
+        };
+        current = emit({ type: "clip.add", trackId: validated2.track.id, clip }, current);
+        continue;
+      }
+      const validated = validateSceneUpdate(op, current, ctx);
+      const wrapper = generateSceneShotWrapper(validated.spec);
+      let pinned = {
+        componentId: validated.componentId,
+        sourceVersionId: validated.currentSourceVersionId
+      };
+      if (!sameManifest(validated.currentDeclaration.manifest, wrapper.manifest)) {
+        pinned = await register({
+          opIndex: i,
+          clipId: op.clipId,
+          componentId: validated.componentId,
+          tsxSource: wrapper.tsxSource,
+          manifest: wrapper.manifest,
+          scene: validated.spec,
+          assets: validated.clip.source.assets ?? {},
+          fps: ctx.fps,
+          durationInFrames: sceneDurationInFrames(validated.clip.duration, ctx.fps, i, op.clipId)
+        });
+      }
+      const patch = {
+        ...validated.timing,
+        source: {
+          kind: "component",
+          componentId: pinned.componentId,
+          props: { componentRef: { version: 1, sourceVersionId: pinned.sourceVersionId }, scene: validated.spec },
+          assets: validated.clip.source.assets ?? {},
+          zPlane: "front"
+        }
+      };
+      current = emit({ type: "clip.update", clipId: op.clipId, patch }, current);
+    } catch (error) {
+      if (error instanceof SceneAuthoringError && error.opIndex === void 0) error.opIndex = i;
+      throw error;
+    }
+  }
+  return out;
+}
+
+export {
+  SceneAuthoringError,
+  isSceneOp,
+  hasSceneOp,
+  sceneTrackIdFor,
+  validateSceneAdd,
+  validateSceneUpdate,
+  SCENE_SHOT_WRAPPER_VERSION,
+  SCENE_IMAGE_MIME_TYPES,
+  SCENE_SHOT_WRAPPER_SOURCE,
+  sceneShotAlphaPolicy,
+  sceneShotManifest,
+  generateSceneShotWrapper,
+  SCENE_TRACK_NAME,
+  materializeSceneOpsCore
+};

package/dist/{chunk-G5BFI32U.js → chunk-RAXHCRVV.js}

@@ -18,7 +18,7 @@ import {
   TEXT_HI,
   VIOLET,
   WARNING
-} from "./chunk-CX2IIQ4R.js";
+} from "./chunk-W2245F6G.js";
 
 // ../execution/primitives/src/backgrounds/animated-bar-chart/index.tsx
 import { spring, useCurrentFrame, useVideoConfig } from "remotion";

package/dist/{chunk-BIBYZJL3.js → chunk-RL5SO653.js}

@@ -1,9 +1,9 @@
 import {
   resolveTypeface
-} from "./chunk-BDMTUEEZ.js";
+} from "./chunk-LT4PWSR2.js";
 import {
   resolveContrast
-} from "./chunk-EMGFZ3PR.js";
+} from "./chunk-FWSJLHSV.js";
 import {
   fadeProgress,
   resolveEasing,
@@ -125,7 +125,7 @@ var paramsSchema = z.object({
   entrance: z.enum(["none", "fade", "word-pop", "stagger-up"]).optional().describe("Per-word entrance treatment. Default fade (the hero reveal). Bind to $brand:motion.entrance so the brand drives the motion identity."),
   fontWeight: z.number().optional().describe("Default 800 (display weight)."),
   textColor: z.string().default(resolveContrast({ behindSubject: true }).textColor).describe("Text color; defaults to a video-safe off-white. Bind to $brand:colors.textOnMedia."),
-  fontFamily: z.string().default(resolveTypeface("display")).describe("Display family; defaults to the brand display face (Bricolage Grotesque floor). Bind to $brand:fonts.heading.family.")
+  fontFamily: z.string().default(resolveTypeface("display")).describe("Display family; defaults to the brand display face (Inter floor). Bind to $brand:fonts.heading.family.")
 }).passthrough();
 var config = {
   id: "heroText",

package/dist/{chunk-ZSZABOE5.js → chunk-S5H6GH6M.js}

@@ -3,7 +3,7 @@ import {
   SUCCESS,
   SURFACE,
   TEXT_HI
-} from "./chunk-CX2IIQ4R.js";
+} from "./chunk-W2245F6G.js";
 
 // ../execution/primitives/src/ui-blocks/dashboard-populate/index.tsx
 import { interpolate, spring, useCurrentFrame, useVideoConfig } from "remotion";

package/dist/{chunk-EEXCDFY5.js → chunk-SD25VQDE.js}

@@ -9,7 +9,7 @@ import {
 import {
   decodeError,
   scrubSensitive
-} from "./chunk-4FOOBSEE.js";
+} from "./chunk-J3DIUG24.js";
 
 // ../director/src/domain/chat.ts
 import { z } from "zod";