@cueframe/kernel 0.1.3 → 0.2.0

package/dist/chunk-RFXR7ATW.js

@@ -0,0 +1,244 @@
+import {
+  getPrimitiveCatalogMeta
+} from "./chunk-C5SEPOWD.js";
+
+// ../execution/render-harness/src/renderInputAssets.ts
+function isRemoteUrl(u) {
+  return typeof u === "string" && /^https?:\/\//i.test(u) && !/^https?:\/\/(127\.0\.0\.1|localhost)(:|\/|$)/i.test(u);
+}
+function assetUrlKey(url) {
+  return url.split("?")[0];
+}
+var CORE_OVERLAY_PARAM_SCHEMAS = {
+  image: { type: "object", properties: { src: { type: "string", cueframeAsset: true } } },
+  gif: { type: "object", properties: { src: { type: "string", cueframeAsset: true } } },
+  lottie: { type: "object", properties: { src: { type: "string", cueframeAsset: true } } },
+  "alpha-layer": { type: "object", properties: { src: { type: "string", cueframeAsset: true } } }
+};
+function assetPathsFromSchema(schema, prefix = [], out = []) {
+  if (!schema || typeof schema !== "object") return out;
+  const node = schema;
+  if (node.cueframeAsset === true) {
+    if (prefix.length === 0) throw new Error("Asset schema annotation must name a parameter path.");
+    out.push(prefix.join("."));
+    return out;
+  }
+  if (node.properties && typeof node.properties === "object") {
+    for (const [name, child] of Object.entries(node.properties)) {
+      assetPathsFromSchema(child, [...prefix, name], out);
+    }
+  }
+  if (node.items) assetPathsFromSchema(node.items, [...prefix, "*"], out);
+  for (const branchKey of ["allOf", "anyOf", "oneOf"]) {
+    const branches = node[branchKey];
+    if (Array.isArray(branches)) for (const branch of branches) assetPathsFromSchema(branch, prefix, out);
+  }
+  return out;
+}
+function isUnsealedAssetRef(value) {
+  try {
+    const parsed = new URL(value);
+    return !((parsed.protocol === "http:" || parsed.protocol === "https:") && ["127.0.0.1", "localhost", "[::1]"].includes(parsed.hostname));
+  } catch {
+    return true;
+  }
+}
+function* annotatedSlots(value, segments, path) {
+  if (segments.length === 0) return;
+  const [head, ...tail] = segments;
+  if (head === "*") {
+    if (!Array.isArray(value)) return;
+    for (let index = 0; index < value.length; index++) {
+      if (tail.length === 0 && typeof value[index] === "string" && value[index].length > 0) {
+        yield {
+          role: "overlayAsset",
+          path: `${path}[${index}]`,
+          get: () => typeof value[index] === "string" ? value[index] : void 0,
+          set: (url) => {
+            value[index] = url;
+          }
+        };
+      } else {
+        yield* annotatedSlots(value[index], tail, `${path}[${index}]`);
+      }
+    }
+    return;
+  }
+  if (value === null || typeof value !== "object") return;
+  const record = value;
+  if (tail.length === 0) {
+    if (typeof record[head] !== "string" || record[head].length === 0) return;
+    yield {
+      role: "overlayAsset",
+      path: `${path}.${head}`,
+      get: () => typeof record[head] === "string" ? record[head] : void 0,
+      set: (url) => {
+        record[head] = url;
+      }
+    };
+    return;
+  }
+  yield* annotatedSlots(record[head], tail, `${path}.${head}`);
+}
+function parameterAssetPaths(primitiveId) {
+  const schema = CORE_OVERLAY_PARAM_SCHEMAS[primitiveId] ?? getPrimitiveCatalogMeta(primitiveId)?.propSchema;
+  return [...new Set(assetPathsFromSchema(schema))];
+}
+function suspiciousUnannotatedAsset(value) {
+  if (typeof value === "string") {
+    return /^(?:https?:\/\/|\/\/|data:|blob:|file:|\.\.?\/)/i.test(value) || /url\(\s*['"]?/i.test(value) || /^[^\s]+\.(?:png|jpe?g|gif|webp|svg|json|lottie|mp4|mov|webm|m4a|mp3|wav|woff2?|ttf|otf)(?:\?.*)?$/i.test(value);
+  }
+  if (Array.isArray(value)) return value.some(suspiciousUnannotatedAsset);
+  if (value && typeof value === "object") return Object.values(value).some(suspiciousUnannotatedAsset);
+  return false;
+}
+function assertPrimitiveAssetAnnotations(primitiveId, params) {
+  const remaining = structuredClone(params);
+  for (const assetPath of parameterAssetPaths(primitiveId)) {
+    for (const slot of annotatedSlots(remaining, assetPath.split("."), "params")) slot.set("");
+  }
+  if (suspiciousUnannotatedAsset(remaining)) {
+    throw new Error(
+      `overlayAsset: Primitive '${primitiveId}' contains an asset-like parameter outside its cueframeAsset schema annotation.`
+    );
+  }
+}
+function* assetSlots(input) {
+  for (const clip of input.clips ?? []) {
+    yield { role: "source", path: `clips[${clip.id}].src`, get: () => clip.src, set: (u) => {
+      clip.src = u;
+    } };
+    yield { role: "matte", path: `clips[${clip.id}].packedUrl`, get: () => clip.packedUrl, set: (u) => {
+      clip.packedUrl = u;
+    } };
+    yield {
+      role: "trajectory",
+      path: `clips[${clip.id}].cropTrajectoryUrl`,
+      get: () => clip.cropTrajectoryUrl,
+      set: (u) => {
+        clip.cropTrajectoryUrl = u;
+      }
+    };
+  }
+  for (const track of input.audioTracks ?? []) {
+    yield { role: "audio", path: `audioTracks[${track.id}].src`, get: () => track.src, set: (u) => {
+      track.src = u;
+    } };
+  }
+  for (const overlay of input.overlays ?? []) {
+    for (const assetPath of parameterAssetPaths(overlay.template)) {
+      yield* annotatedSlots(overlay.params, assetPath.split("."), `overlays[${overlay.id}].params`);
+    }
+  }
+  for (const effect of input.effects ?? []) {
+    for (const assetPath of parameterAssetPaths(effect.primitiveId)) {
+      yield* annotatedSlots(effect.params, assetPath.split("."), `effects[${effect.id}].params`);
+    }
+  }
+  for (const font of input.brandKit?.fontAssets ?? []) {
+    yield { role: "font", path: `brandKit.fontAssets[${font.family}:${font.weight}].url`, get: () => font.url, set: (u) => {
+      font.url = u;
+    } };
+  }
+  const bk = input.brandKit;
+  if (bk) {
+    if (bk.logo) {
+      yield { role: "brandMedia", path: "brandKit.logo.src", get: () => bk.logo.src, set: (u) => {
+        bk.logo.src = u;
+      } };
+    }
+    if (bk.intro) {
+      yield { role: "brandMedia", path: "brandKit.intro.src", get: () => bk.intro.src, set: (u) => {
+        bk.intro.src = u;
+      } };
+    }
+    if (bk.outro) {
+      yield { role: "brandMedia", path: "brandKit.outro.src", get: () => bk.outro.src, set: (u) => {
+        bk.outro.src = u;
+      } };
+    }
+    if (bk.watermark) {
+      yield { role: "brandMedia", path: "brandKit.watermark.src", get: () => bk.watermark.src, set: (u) => {
+        bk.watermark.src = u;
+      } };
+    }
+  }
+}
+function extFor(url, role) {
+  const path = assetUrlKey(url);
+  const m = path.match(/\.([a-z0-9]{2,5})$/i);
+  if (m) return m[1].toLowerCase();
+  return role === "trajectory" ? "json" : role === "audio" ? "m4a" : role === "font" ? "woff2" : "mp4";
+}
+function shortHash(s) {
+  let h = 2166136261 >>> 0;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h.toString(36);
+}
+function filenameFor(url, role) {
+  return `${role}-${shortHash(assetUrlKey(url))}.${extFor(url, role)}`;
+}
+function renderInputAssets(input) {
+  const seen = /* @__PURE__ */ new Set();
+  const refs = [];
+  for (const slot of assetSlots(input)) {
+    const url = slot.get();
+    if (typeof url !== "string" || !isRemoteUrl(url)) continue;
+    const key = assetUrlKey(url);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    refs.push({ role: slot.role, url, filename: filenameFor(url, slot.role) });
+  }
+  return refs;
+}
+function assertNoRemoteRefs(input) {
+  for (const font of input.brandKit?.fontAssets ?? []) {
+    if (typeof font.family !== "string" || font.family.length === 0 || typeof font.url !== "string" || font.url.length === 0) {
+      throw new Error("font_not_reproducible: Every custom brand font requires a family and sealed asset URL.");
+    }
+  }
+  const requiredBrandMedia = [
+    ["logo", input.brandKit?.logo],
+    ["watermark", input.brandKit?.watermark],
+    ["intro", input.brandKit?.intro?.kind === "video" ? input.brandKit.intro : void 0],
+    ["outro", input.brandKit?.outro?.kind === "video" ? input.brandKit.outro : void 0]
+  ];
+  for (const [slot, media] of requiredBrandMedia) {
+    if (media && (typeof media.src !== "string" || media.src.length === 0)) {
+      throw new Error(`brand_kit_unresolved: Brand ${slot} media has no sealed src asset.`);
+    }
+  }
+  const leftover = [];
+  for (const slot of assetSlots(input)) {
+    const url = slot.get();
+    if (url && isUnsealedAssetRef(url)) {
+      leftover.push(`${slot.role}: ${slot.path}: ${assetUrlKey(url)}`);
+    }
+  }
+  if (leftover.length > 0) {
+    throw new Error(
+      `RenderInput still references ${leftover.length} un-localized remote asset(s) after staging \u2014 the render environment is incomplete and would block/hang in a no-egress sandbox:
+  ` + leftover.join("\n  ")
+    );
+  }
+  for (const overlay of input.overlays ?? []) {
+    assertPrimitiveAssetAnnotations(
+      overlay.template,
+      overlay.params
+    );
+  }
+  for (const effect of input.effects ?? []) {
+    assertPrimitiveAssetAnnotations(effect.primitiveId, effect.params);
+  }
+}
+
+export {
+  isRemoteUrl,
+  assetUrlKey,
+  assetSlots,
+  renderInputAssets,
+  assertNoRemoteRefs
+};

package/dist/chunk-SIAXP3ZO.js

@@ -0,0 +1,131 @@
+import {
+  ComponentRuntimeError
+} from "./chunk-LQUWKBST.js";
+
+// ../execution/component-runtime/src/importPolicy.ts
+import { parse } from "@babel/parser";
+var COMPONENT_IMPORT_ALLOWLIST = Object.freeze([
+  "react",
+  "remotion",
+  "@remotion/media",
+  "@remotion/motion-blur",
+  "@remotion/noise",
+  "@remotion/paths",
+  "@remotion/shapes",
+  "@remotion/three",
+  "three",
+  "three/webgpu",
+  "three/tsl",
+  "@react-three/fiber",
+  "@react-three/drei",
+  "@cueframe/animate"
+]);
+var ALLOWED_IMPORTS = new Set(COMPONENT_IMPORT_ALLOWLIST);
+var DENIED_NONDETERMINISTIC_MEMBERS = /* @__PURE__ */ new Set([
+  "Math.random",
+  "Date.now",
+  "performance.now",
+  "crypto.getRandomValues",
+  "crypto.randomUUID"
+]);
+var DENIED_AMBIENT_CALLS = /* @__PURE__ */ new Set([
+  "Date",
+  "requestAnimationFrame",
+  "setTimeout",
+  "setInterval"
+]);
+function staticMemberPath(value) {
+  if (!value || typeof value !== "object") return null;
+  const node = value;
+  if (node.type === "Identifier" && typeof node.name === "string") return node.name;
+  if (node.type !== "MemberExpression" && node.type !== "OptionalMemberExpression") return null;
+  const object = staticMemberPath(node.object);
+  if (!object || !node.property || typeof node.property !== "object") return null;
+  const property = node.property;
+  const key = node.computed === true ? property.type === "StringLiteral" && typeof property.value === "string" ? property.value : null : property.type === "Identifier" && typeof property.name === "string" ? property.name : null;
+  return key ? `${object}.${key}` : null;
+}
+function normalizedAmbientPath(value) {
+  return staticMemberPath(value)?.replace(/^(?:globalThis|window|self)\./, "") ?? null;
+}
+function denied(specifier) {
+  throw new ComponentRuntimeError(
+    "component_import_denied",
+    `Component import is not allowed: ${JSON.stringify(specifier)}.`
+  );
+}
+function assertComponentImportsAllowed(tsxSource) {
+  let root;
+  try {
+    root = parse(tsxSource, {
+      sourceType: "module",
+      plugins: ["jsx", "typescript"],
+      errorRecovery: false
+    });
+  } catch (error) {
+    throw new ComponentRuntimeError(
+      "component_does_not_compile",
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+  const visit = (value) => {
+    if (!value || typeof value !== "object") return;
+    if (Array.isArray(value)) {
+      for (const child of value) visit(child);
+      return;
+    }
+    const node = value;
+    const type = node.type;
+    if ((type === "ImportDeclaration" || type === "ExportNamedDeclaration" || type === "ExportAllDeclaration") && node.source && typeof node.source === "object") {
+      const specifier = node.source.value;
+      if (typeof specifier === "string" && !ALLOWED_IMPORTS.has(specifier)) denied(specifier);
+    }
+    if (type === "ImportExpression") denied("dynamic import()");
+    if (type === "CallExpression") {
+      const callee = node.callee;
+      if (callee?.type === "Import") denied("dynamic import()");
+      if (callee?.type === "Identifier" && callee.name === "require") denied("require()");
+      if (callee?.type === "Identifier" && typeof callee.name === "string" && DENIED_AMBIENT_CALLS.has(callee.name)) {
+        denied(`ambient ${callee.name}`);
+      }
+    }
+    if (type === "NewExpression") {
+      const callee = node.callee;
+      if (callee?.type === "Identifier" && (callee.name === "Date" || callee.name === "Worker" || callee.name === "SharedWorker")) denied(`ambient ${String(callee.name)}`);
+    }
+    if (type === "MemberExpression" || type === "OptionalMemberExpression") {
+      const member = normalizedAmbientPath(node);
+      if (member && DENIED_NONDETERMINISTIC_MEMBERS.has(member)) denied(`ambient ${member}`);
+    }
+    if (type === "VariableDeclarator") {
+      const init = normalizedAmbientPath(node.init);
+      const id = node.id;
+      if (init && ["Math", "Date", "performance", "crypto"].includes(init) && id?.type === "Identifier") {
+        denied(`ambient ${init} alias`);
+      }
+      if (init === "Math" && id?.type === "ObjectPattern") {
+        const properties = Array.isArray(id.properties) ? id.properties : [];
+        if (properties.some((property) => {
+          const key = property.key;
+          return key?.name === "random" || key?.value === "random";
+        })) denied("ambient Math.random alias");
+      }
+    }
+    if (type === "TSImportType") {
+      const argument = node.argument;
+      if (argument?.type === "StringLiteral" && typeof argument.value === "string" && !ALLOWED_IMPORTS.has(argument.value)) {
+        denied(argument.value);
+      }
+    }
+    for (const [key, child] of Object.entries(node)) {
+      if (key === "loc" || key === "start" || key === "end" || key === "errors" || key === "comments") continue;
+      visit(child);
+    }
+  };
+  visit(root);
+}
+
+export {
+  COMPONENT_IMPORT_ALLOWLIST,
+  assertComponentImportsAllowed
+};

package/dist/{chunk-MCBUX5XV.js → chunk-SLN5UKLT.js}

@@ -48,14 +48,14 @@ var PREVIEW_FRAME_CASES = [
     why: "THE 2026-08-15 WRONG-PIXELS BUG. Asked 6s past the end of a 5s composition, the local lane answers 200 with the LAST frame (Remotion's Thumbnail pins), and the founder's agent read that as evidence about its own timeline. NEITHER LANE DECIDES THIS AT THE ROUTE. The cloud's 422 comes from its RENDERER \u2014 `rethrowCoded` forwarding a downstream 422 (internal/sightedAction.ts:63) \u2014 so with the executor stubbed, as it is on both sides here, the cloud answers 200 too. That is the finding, not a gap in the harness: a rule enforced only by one lane's renderer is not a rule the API applies. `timestamp_out_of_bounds` already exists in the shared registry (packages/errors/src/registry.ts:94, httpStatus 422) \u2014 the vocabulary is single-sourced; the DECISION has no home. Stage 2 gives it one: a pure precondition both lanes run before reaching for an executor.",
     body: { timestamps: [CONFORMANCE_DURATION_SEC + 6] },
     expect: { status: 422, code: "timestamp_out_of_bounds" },
-    knownRed: ["local", "cloud"]
+    knownRed: ["cloud"]
   },
   {
     name: "an unrecognised body key is refused",
     why: "THREE DEFINITIONS, AND THE PUBLISHED ONE IS THE STRICTEST. The generated `previewFrameBody` ends `.strict()`, and SDK + MCP clients enforce it. But the route's own `PreviewFrameRequest` (evidence.ts:72) \u2014 the schema `zodJson` actually runs \u2014 ends `});` with NO `.strict()`, and the local handler has no unknown-key check either (ALLOWED_KEYS covers apply only). So a typo like `timestamp` or `dryRun` is accepted and ignored by BOTH servers while the published contract says it is rejected. This row asserts the STRICT reading because that is what is published and what every generated client already enforces; a server looser than its own spec is the divergence. Note this inverts the obvious stage-1 move: adopting the generated schema locally and nowhere else would make the desktop stricter than the cloud \u2014 a NEW divergence pointing the other way. Stage 1 has to settle strictness once, for both.",
     body: { timestamps: [1], nonsenseKey: true },
     expect: { status: 400, code: "validation_error" },
-    knownRed: ["local", "cloud"]
+    knownRed: ["cloud"]
   }
 ];
 function isKnownRed(c, lane) {

package/dist/{chunk-GH27OS5S.js → chunk-VCBLGZQQ.js}

@@ -26,7 +26,7 @@ function makeNetworkExecutor(baseUrl, apiKey) {
 }
 function makeSessionExecutor(opts) {
   return {
-    async invoke({ method, path, body, query }) {
+    async invoke({ method, path, body, query, idempotent }) {
       const token = await opts.getToken();
       if (!token) {
         return { status: 0, text: JSON.stringify({ error: { code: "offline", message: "No session \u2014 sign in to use cloud features." } }) };
@@ -43,7 +43,11 @@ function makeSessionExecutor(opts) {
       }
       const mutating = method !== "GET" && method !== "HEAD";
       if (mutating) {
-        headers["idempotency-key"] = `sess-${fnv1a(`${method}|${path}|${payload ?? ""}`)}`;
+        headers["idempotency-key"] = requestIdempotencyKey(
+          "sess",
+          `${method}|${path}|${payload ?? ""}`,
+          idempotent === true
+        );
       }
       const attempt = () => fetch(url, { method, headers, body: payload });
       let res;
@@ -69,9 +73,16 @@ function fnv1a(input) {
   }
   return h.toString(16);
 }
+function freshInvocationNonce() {
+  return globalThis.crypto.randomUUID();
+}
+function requestIdempotencyKey(prefix, content, idempotent) {
+  const identity = idempotent ? content : `${content}|${freshInvocationNonce()}`;
+  return `${prefix}-${fnv1a(identity)}`;
+}
 function makePlatformExecutor(baseUrl, deployKey, orgId, opts) {
   return {
-    async invoke({ method, path, body, query }) {
+    async invoke({ method, path, body, query, idempotent }) {
       const url = `${baseUrl}${path}${query ? `?${query}` : ""}`;
       const headers = {
         "x-deploy-key": deployKey,
@@ -79,7 +90,11 @@ function makePlatformExecutor(baseUrl, deployKey, orgId, opts) {
         ...opts?.actingUserId ? { "x-acting-user-id": opts.actingUserId } : {}
       };
       if (method !== "GET" && method !== "HEAD") {
-        headers["idempotency-key"] = `plat-${fnv1a(`${method}|${path}|${body === void 0 ? "" : JSON.stringify(body)}`)}`;
+        headers["idempotency-key"] = requestIdempotencyKey(
+          "plat",
+          `${method}|${path}|${body === void 0 ? "" : JSON.stringify(body)}`,
+          idempotent === true
+        );
       }
       let payload;
       if (body !== void 0) {

package/dist/{chunk-TMB5AY6Q.js → chunk-XHUYWVYK.js}

@@ -1,7 +1,7 @@
 import {
   ChatErrorView,
   DirectorTurnContext
-} from "./chunk-TO4BFNLJ.js";
+} from "./chunk-EEXCDFY5.js";
 import {
   GenerationArtifact
 } from "./chunk-73DQTUWY.js";

package/dist/{chunk-BZZTVOGG.js → chunk-XVBOSPZI.js}

@@ -4,16 +4,16 @@ import {
 import {
   getPrimitiveSubtextParam,
   getPrimitiveTextParam
-} from "./chunk-DCVJWGIA.js";
+} from "./chunk-C5SEPOWD.js";
 import {
   selectAllOverlays
-} from "./chunk-ICSZF37W.js";
+} from "./chunk-IBMJ33EL.js";
 import {
   ComposePlan
-} from "./chunk-TFGKUWHY.js";
+} from "./chunk-IHFREGFA.js";
 import {
   OverlayClipSource
-} from "./chunk-WZH57M53.js";
+} from "./chunk-7KEUL3FI.js";
 
 // ../authoring/src/tools/toolSets.ts
 var COMPOSE_PLANNER_TOOLS = [
@@ -63,7 +63,7 @@ var COMPOSE_ROLE_TOOLS = Object.freeze({
     schema: z.object({}),
     metadata: { label: "Get Context" },
     handler: async (_args, capabilities) => {
-      const { buildDirectorContext } = await import("./context-JLLU3MYD.js");
+      const { buildDirectorContext } = await import("./context-4GSDBFT3.js");
       return buildDirectorContext(capabilities);
     }
   },
@@ -113,9 +113,6 @@ var COMPOSE_ROLE_TOOLS = Object.freeze({
         lines.push(`
 Source code:
 ${overlay.params.jsxSource}`);
-      } else if (overlay.params.sourceCode) {
-        lines.push(`
-(Compiled code only \u2014 no JSX source available)`);
       } else {
         lines.push(`
 (No custom source code \u2014 uses built-in template rendering)`);
@@ -125,7 +122,7 @@ ${overlay.params.jsxSource}`);
   },
   update_overlay: {
     name: "update_overlay",
-    description: "Update properties of an existing motion graphic overlay. Only include the fields you want to change. You can provide new sourceCode to re-generate the component.",
+    description: "Update properties of an existing motion graphic overlay. Only include the fields you want to change. Provide authored jsxSource to re-generate a custom component.",
     schema: z.object({
       id: z.string().min(1).describe("The overlay clip ID (a UUID). Use the exact id inspect_overlay reports \u2014 never fabricate IDs."),
       startTime: z.coerce.number().min(0).optional().describe("New start time in seconds"),
@@ -141,7 +138,7 @@ ${overlay.params.jsxSource}`);
       textColor: z.string().regex(/^#[0-9a-fA-F]{3,8}$/, "Must be a hex color").optional().describe("New text color as hex"),
       fontFamily: z.string().optional().describe("New font family"),
       backgroundColor: z.string().regex(/^#[0-9a-fA-F]{3,8}$/, "Must be a hex color").optional().describe("New background color as hex"),
-      sourceCode: z.string().max(1e4).optional().describe("New JSX source code for the overlay"),
+      jsxSource: z.string().max(1e4).optional().describe("New canonical TSX module source for the overlay"),
       transition: z.enum(["fade", "slide", "wipe", "none"]).optional().describe("New transition type"),
       sequenceGroup: z.string().optional().describe("New sequence group ID"),
       primitiveId: z.string().optional().describe(
@@ -166,7 +163,7 @@ ${overlay.params.jsxSource}`);
     metadata: { label: "Update Overlay" },
     inputExamples: [
       { input: { id: "abc-123", text: "Updated Title", accentColor: "#6366f1" } },
-      { input: { id: "def-456", startTime: 10, duration: 5, sourceCode: "export default function..." } },
+      { input: { id: "def-456", startTime: 10, duration: 5, jsxSource: "export default function..." } },
       { input: { id: "ghi-789", zPlane: "behind-subject", anchor: { x: 0.5, y: 0.4 }, parallax: 0.1 } }
     ],
     handler: async (args, capabilities) => {
@@ -207,15 +204,16 @@ ${overlay.params.jsxSource}`);
       if (args.position != null) newParams.position = args.position;
       if (args.transition != null) newParams.transition = args.transition;
       if (args.sequenceGroup != null) newParams.sequenceGroup = args.sequenceGroup;
-      const jsxSource = args.sourceCode ?? args.jsxSource;
+      const jsxSource = args.jsxSource;
       let primitiveId = args.primitiveId ?? existingTemplate;
       if (jsxSource) {
-        const transpileFn = capabilities.transpile?.transpile;
-        if (!transpileFn) return { error: "Transpiler not available" };
-        const result = await transpileFn(jsxSource);
-        if (!result.success) return { error: `JSX transpile failed: ${result.error}` };
-        newParams.sourceCode = result.code;
         newParams.jsxSource = jsxSource;
+        newParams.componentManifest ??= {
+          version: 2,
+          assets: {},
+          graphics: { api: "canvas2d", required: true, accelerationPreference: "software-allowed" },
+          alphaPolicy: "requires-transparency"
+        };
         primitiveId = "custom";
       }
       const newSource = { ...existingSource, primitiveId, params: newParams };

package/dist/{chunk-HBVAZXYO.js → chunk-Y3QGYASW.js}

@@ -1,41 +1,41 @@
 import {
   isContrastCritical
 } from "./chunk-YLDMAZZE.js";
+import {
+  catalog as catalog3
+} from "./chunk-AWT3P5ZN.js";
 import {
   catalog as catalog6
 } from "./chunk-BKHGL4MB.js";
 import {
   catalog as catalog2
-} from "./chunk-GMD33ZD7.js";
+} from "./chunk-6ID2J64H.js";
 import {
   catalog as catalog8
-} from "./chunk-SAMQUUO5.js";
+} from "./chunk-BIBYZJL3.js";
 import {
   catalog as catalog4
-} from "./chunk-RP4SXXLJ.js";
+} from "./chunk-DQKSCHFC.js";
 import {
   catalog as catalog7
-} from "./chunk-DYZE7JZA.js";
+} from "./chunk-TMIBBD5E.js";
 import {
   catalog
-} from "./chunk-UQSOS726.js";
-import {
-  catalog as catalog3
-} from "./chunk-AWT3P5ZN.js";
+} from "./chunk-KKEY5MIW.js";
 import {
   catalog as catalog5
 } from "./chunk-G5BFI32U.js";
 import {
   getPrimitiveSubtextParam,
   getPrimitiveTextParam
-} from "./chunk-DCVJWGIA.js";
+} from "./chunk-C5SEPOWD.js";
 import {
   NEUTRAL_RAMP
 } from "./chunk-JF4JJAFP.js";
 import {
   CueframeError,
   encodeError
-} from "./chunk-AW57IWNW.js";
+} from "./chunk-4FOOBSEE.js";
 
 // ../execution/compose/src/primitiveRegistry.ts
 var allCatalogs = [
@@ -89,8 +89,8 @@ function getPrimitiveText(overlay) {
   if (typeof canonical === "string" && canonical.length > 0) return canonical;
   const textParam = getPrimitiveTextParam(overlay.template);
   if (typeof textParam === "string") {
-    const legacy = overlay.params[textParam];
-    if (typeof legacy === "string") return legacy;
+    const native = overlay.params[textParam];
+    if (typeof native === "string") return native;
   }
   return void 0;
 }
@@ -99,8 +99,8 @@ function getPrimitiveSubtext(overlay) {
   if (typeof canonical === "string" && canonical.length > 0) return canonical;
   const subtextParam = getPrimitiveSubtextParam(overlay.template);
   if (typeof subtextParam === "string") {
-    const legacy = overlay.params[subtextParam];
-    if (typeof legacy === "string") return legacy;
+    const native = overlay.params[subtextParam];
+    if (typeof native === "string") return native;
   }
   return void 0;
 }

package/dist/{chunk-DWLNPNC4.js → chunk-ZCAQHNPI.js}

@@ -2,7 +2,7 @@ import {
   selectAllClips,
   selectAllOverlays,
   selectSceneMarkers
-} from "./chunk-ICSZF37W.js";
+} from "./chunk-IBMJ33EL.js";
 
 // ../authoring/src/context/transcript.ts
 var MAX_TRANSCRIPT_CHARS = 6e4;