@cueframe/kernel 0.2.57 → 0.2.59-rc.0

package/dist/{chunk-HGCYZMII.js → chunk-AK6QPX7A.js}

@@ -3,19 +3,19 @@ import {
   componentDir,
   findWorkspace
 } from "./chunk-WB2VFDQZ.js";
-import {
-  sha256Hex,
-  sourceVersionId
-} from "./chunk-EXY4JJPH.js";
-import {
-  assertComponentImportsAllowed
-} from "./chunk-K66NLMGX.js";
 import {
   assertComponentBrowserHardware,
   componentBrowserBackend,
   componentBrowserOptions,
   readGpuAttestation
-} from "./chunk-JWMWVP64.js";
+} from "./chunk-KC4LNZL5.js";
+import {
+  sha256Hex,
+  sourceVersionId
+} from "./chunk-F6PLDBAK.js";
+import {
+  assertComponentImportsAllowed
+} from "./chunk-UGWJC4GA.js";
 import {
   ComponentCapturePageRasterAttestationV1,
   ComponentGraphicsApiV2,
@@ -25,7 +25,7 @@ import {
   ComponentStillPngContainerFactsV1,
   ComponentStillSessionAttestationV1,
   ComponentStillSessionHostAttestationV1
-} from "./chunk-EC6VFQE6.js";
+} from "./chunk-BZVOCVQV.js";
 import {
   parseSceneShotSpecV2
 } from "./chunk-CL5Y6V6K.js";

package/dist/{chunk-EC6VFQE6.js → chunk-BZVOCVQV.js}

@@ -240,6 +240,7 @@ var COMPONENT_RUNTIME_ERROR_CODES = [
   "component_asset_integrity_failed",
   "component_network_denied",
   "component_import_denied",
+  "component_api_mismatch",
   "component_graphics_unavailable",
   "component_graphics_mismatch",
   "component_device_lost",

package/dist/{chunk-RBWS5XHE.js → chunk-CAF7BRNE.js}

@@ -11,7 +11,7 @@ import {
   FLOOR_SHADOW,
   FLOOR_TEXT,
   resolveContrast
-} from "./chunk-FWSJLHSV.js";
+} from "./chunk-R642352J.js";
 import {
   resolveEasing,
   staggerRise,
@@ -34,7 +34,7 @@ import {
   TEXT_MUTED,
   VIOLET,
   WARNING
-} from "./chunk-W2245F6G.js";
+} from "./chunk-WTQRLFR2.js";
 
 // ../execution/primitives/src/text/blur-reveal/index.tsx
 import { interpolate, useCurrentFrame, useVideoConfig } from "remotion";

package/dist/chunk-CEO47DIE.js

@@ -0,0 +1,199 @@
+import {
+  MotifMotionPreset
+} from "./chunk-6KZCXAYL.js";
+import {
+  GraphicRole
+} from "./chunk-AFUITAH6.js";
+import {
+  CardHtml
+} from "./chunk-EQH37KNZ.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: CardHtml,
+    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-CIOUDOGN.js

@@ -0,0 +1,12 @@
+// ../authoring/src/models/defaultModels.ts
+var DEFAULT_MODEL_IDS = {
+  anthropic: "claude-opus-5",
+  openai: "gpt-4.1",
+  ollama: "llama3.1",
+  /** Cheaper model used for fast-mode / low-effort turns. */
+  fast: "claude-haiku-4-5"
+};
+
+export {
+  DEFAULT_MODEL_IDS
+};

package/dist/{chunk-BDFAA747.js → chunk-DCKADD5B.js}

@@ -1,6 +1,6 @@
 import {
   CueframeError
-} from "./chunk-E63UEO5C.js";
+} from "./chunk-XQGQ5EFS.js";
 import {
   bundledFontFamilyFaces,
   isGenericOnlyStack,

package/dist/{chunk-7AZLFN26.js → chunk-EISHFHU5.js}

@@ -16270,6 +16270,24 @@ var PRIMITIVE_META = [
   }
 ];
 
+// ../composition/src/primitive-catalog/types.ts
+var PRIMITIVE_USE_CASES = [
+  "intro",
+  "outro",
+  "full-scene",
+  "title-over-footage",
+  "transition",
+  "background",
+  "grade",
+  "emphasis",
+  "explainer",
+  "social-cut",
+  "ui-entrance",
+  "camera",
+  "rhythm",
+  "data"
+];
+
 // ../composition/src/primitive-catalog/disabled.ts
 var DISABLED_PRIMITIVE_IDS = /* @__PURE__ */ new Set([]);
 function isPrimitiveDisabled(id) {
@@ -16533,18 +16551,7 @@ var CATALOG_CATEGORY_VALUES = /* @__PURE__ */ new Set([
 ]);
 var CATALOG_KIND_VALUES = /* @__PURE__ */ new Set(["component", "transition", "scene"]);
 var CATALOG_TIER_VALUES = /* @__PURE__ */ new Set(["recommended", "standard", "niche"]);
-var CATALOG_USE_CASE_VALUES = /* @__PURE__ */ new Set([
-  "intro",
-  "outro",
-  "full-scene",
-  "title-over-footage",
-  "transition",
-  "background",
-  "grade",
-  "emphasis",
-  "explainer",
-  "social-cut"
-]);
+var CATALOG_USE_CASE_VALUES = new Set(PRIMITIVE_USE_CASES);
 var TIER_RANK = { recommended: 0, standard: 1, niche: 2 };
 var CatalogFilterError = class extends Error {
   constructor(field, value, allowed) {
@@ -16682,12 +16689,6 @@ function getPrimitiveSubtextParam(id) {
 function getPrimitiveCatalogMeta(id) {
   return byId2.get(id);
 }
-function listPrimitiveIds() {
-  return [...byId2.keys()];
-}
-function getPrimitivePropSchema(id) {
-  return byId2.get(id)?.propSchema;
-}
 function getPrimitiveText(overlay) {
   const canonical = overlay.params.text;
   if (typeof canonical === "string" && canonical.length > 0) return canonical;
@@ -16701,6 +16702,7 @@ function getPrimitiveText(overlay) {
 
 export {
   PRIMITIVE_META,
+  PRIMITIVE_USE_CASES,
   DISABLED_PRIMITIVE_IDS,
   isPrimitiveDisabled,
   derivePlacement,
@@ -16724,7 +16726,5 @@ export {
   getPrimitiveTextParam,
   getPrimitiveSubtextParam,
   getPrimitiveCatalogMeta,
-  listPrimitiveIds,
-  getPrimitivePropSchema,
   getPrimitiveText
 };

package/dist/chunk-EQH37KNZ.js

@@ -0,0 +1,224 @@
+// ../composition/src/validators/cardHtml.ts
+import parseCss from "css-tree/parser";
+import walkCss from "css-tree/walker";
+import { parseFragment } from "parse5";
+import { z } from "zod";
+function isFragmentReference(value) {
+  return value.trim().startsWith("#");
+}
+function cssUrlPayloads(value) {
+  return [...value.matchAll(/url\(\s*(['"]?)(.*?)\1\s*\)/gi)].map((m) => m[2] ?? "");
+}
+function hasNonFragmentCssUrl(value) {
+  return cssUrlPayloads(value).some((payload) => !isFragmentReference(payload));
+}
+var HTML_ELEMENTS = [
+  "abbr",
+  "address",
+  "article",
+  "aside",
+  "b",
+  "bdi",
+  "bdo",
+  "blockquote",
+  "br",
+  "button",
+  "caption",
+  "cite",
+  "code",
+  "col",
+  "colgroup",
+  "data",
+  "dd",
+  "del",
+  "dfn",
+  "div",
+  "dl",
+  "dt",
+  "em",
+  "figcaption",
+  "figure",
+  "footer",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "header",
+  "hgroup",
+  "hr",
+  "i",
+  "ins",
+  "kbd",
+  "label",
+  "li",
+  "main",
+  "mark",
+  "meter",
+  "nav",
+  "ol",
+  "p",
+  "pre",
+  "progress",
+  "q",
+  "rp",
+  "rt",
+  "ruby",
+  "s",
+  "samp",
+  "section",
+  "small",
+  "span",
+  "strong",
+  "style",
+  "sub",
+  "sup",
+  "table",
+  "tbody",
+  "td",
+  "tfoot",
+  "th",
+  "thead",
+  "time",
+  "tr",
+  "u",
+  "ul",
+  "var",
+  "wbr"
+];
+var SVG_ELEMENTS = [
+  "svg",
+  "g",
+  "defs",
+  "symbol",
+  "use",
+  "title",
+  "desc",
+  "path",
+  "rect",
+  "circle",
+  "ellipse",
+  "line",
+  "polyline",
+  "polygon",
+  "text",
+  "tspan",
+  "textpath",
+  "lineargradient",
+  "radialgradient",
+  "stop",
+  "clippath",
+  "mask",
+  "pattern",
+  "marker",
+  "filter",
+  "feblend",
+  "fecolormatrix",
+  "fecomponenttransfer",
+  "fecomposite",
+  "feconvolvematrix",
+  "fediffuselighting",
+  "fedisplacementmap",
+  "fedistantlight",
+  "fedropshadow",
+  "feflood",
+  "fefunca",
+  "fefuncb",
+  "fefuncg",
+  "fefuncr",
+  "fegaussianblur",
+  "femerge",
+  "femergenode",
+  "femorphology",
+  "feoffset",
+  "fepointlight",
+  "fespecularlighting",
+  "fespotlight",
+  "fetile",
+  "feturbulence"
+];
+var ALLOWED_ELEMENTS = /* @__PURE__ */ new Set([...HTML_ELEMENTS, ...SVG_ELEMENTS]);
+var URL_ATTRIBUTES = /* @__PURE__ */ new Set(["action", "data", "formaction", "href", "poster", "src", "srcset"]);
+var CSS_VALUE_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "clip-path",
+  "cursor",
+  "fill",
+  "filter",
+  "marker",
+  "marker-end",
+  "marker-mid",
+  "marker-start",
+  "mask",
+  "stroke"
+]);
+function cssProblem(css, context) {
+  let ast;
+  try {
+    ast = parseCss(css, { context });
+  } catch (cause) {
+    return `contains invalid CSS: ${String(cause)}`;
+  }
+  let problem = null;
+  walkCss(ast, (node) => {
+    if (problem) return;
+    if (node.type === "Url" && !isFragmentReference(node.value)) {
+      problem = "contains a CSS url() asset reference";
+    } else if (node.type === "Atrule" && ["import", "font-face"].includes(node.name.toLowerCase())) {
+      problem = `contains a forbidden CSS @${node.name} rule`;
+    }
+  });
+  return problem;
+}
+function nodeProblem(node) {
+  if (node.nodeName === "#comment" || node.nodeName === "#text") return null;
+  if ("tagName" in node) {
+    const tag = node.tagName.toLowerCase();
+    if (!ALLOWED_ELEMENTS.has(tag)) return `contains <${node.tagName}>, which a card may not use`;
+    for (const attr of node.attrs) {
+      const name = attr.name.toLowerCase();
+      if (name.startsWith("on")) return `contains the event handler '${attr.name}'`;
+      if (URL_ATTRIBUTES.has(name) && !isFragmentReference(attr.value)) {
+        return `contains a ${attr.name} reference outside the card`;
+      }
+      if (name === "style") {
+        const problem = cssProblem(attr.value, "declarationList");
+        if (problem) return problem;
+      }
+      if (CSS_VALUE_ATTRIBUTES.has(name) && hasNonFragmentCssUrl(attr.value)) {
+        return `contains a ${attr.name} url() reference outside the card`;
+      }
+    }
+    if (tag === "style") {
+      const css = node.childNodes.filter((child) => child.nodeName === "#text").map((child) => child.value).join("");
+      const problem = cssProblem(css, "stylesheet");
+      if (problem) return problem;
+    }
+  }
+  if ("childNodes" in node) {
+    for (const child of node.childNodes) {
+      const problem = nodeProblem(child);
+      if (problem) return problem;
+    }
+  }
+  return null;
+}
+function cardHtmlProblem(html) {
+  for (const node of parseFragment(html).childNodes) {
+    const problem = nodeProblem(node);
+    if (problem) return problem;
+  }
+  return null;
+}
+var CardHtml = z.string().min(1).superRefine((html, ctx) => {
+  const problem = cardHtmlProblem(html);
+  if (problem) ctx.addIssue({ code: "custom", message: `Card HTML ${problem}.` });
+});
+
+export {
+  isFragmentReference,
+  cssUrlPayloads,
+  hasNonFragmentCssUrl,
+  cardHtmlProblem,
+  CardHtml
+};

package/dist/{chunk-EXY4JJPH.js → chunk-F6PLDBAK.js}

@@ -3,7 +3,7 @@ import {
   componentBundleIdentity,
   componentRenderIdentity,
   sourceVersionIdentity
-} from "./chunk-DAARYRNT.js";
+} from "./chunk-FKSXKS35.js";
 
 // ../execution/component-runtime/src/identity.ts
 import { createHash } from "crypto";
@@ -22,20 +22,11 @@ function componentRenderKey(request) {
 function componentArtifactId(input) {
   return sha256Hex(componentArtifactIdentity(input));
 }
-function bundleIdentityFields(bundle) {
-  return {
-    bundleId: bundle.bundleId,
-    sourceVersionId: bundle.sourceVersionId,
-    runtimeDigest: bundle.runtimeDigest,
-    dependencyLockDigest: bundle.dependencyLockDigest
-  };
-}
 
 export {
   sha256Hex,
   sourceVersionId,
   componentBundleId,
   componentRenderKey,
-  componentArtifactId,
-  bundleIdentityFields
+  componentArtifactId
 };

package/dist/{chunk-DAARYRNT.js → chunk-FKSXKS35.js}

@@ -32,21 +32,21 @@ function canonicalValue(value, seen) {
     seen.delete(value);
   }
 }
-function canonicalJson(value) {
+function canonicalIdentityJson(value) {
   return JSON.stringify(canonicalValue(value, /* @__PURE__ */ new Set()));
 }
 function sourceVersionIdentity(source) {
-  return canonicalJson(source);
+  return canonicalIdentityJson(source);
 }
 function componentBundleIdentity(input) {
-  return canonicalJson({ domain: "cueframe.component.bundle.v2", ...input });
+  return canonicalIdentityJson({ domain: "cueframe.component.bundle.v2", ...input });
 }
 function componentRenderIdentity(request) {
-  return canonicalJson({ domain: "cueframe.component.render.v2", request });
+  return canonicalIdentityJson({ domain: "cueframe.component.render.v2", request });
 }
 function componentArtifactIdentity(input) {
   const { host: _host, ...identity } = input.receipt;
-  return canonicalJson({
+  return canonicalIdentityJson({
     domain: "cueframe.component.artifact.v2",
     outputSha256: input.outputSha256,
     receipt: identity
@@ -54,7 +54,7 @@ function componentArtifactIdentity(input) {
 }
 
 export {
-  canonicalJson,
+  canonicalIdentityJson,
   sourceVersionIdentity,
   componentBundleIdentity,
   componentRenderIdentity,

package/dist/{chunk-KBDUEU4W.js → chunk-FZB7UX44.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./chunk-2ESYSVXG.js";
+} from "./chunk-U67V476Y.js";
 
 // ../sdk/src/client.ts
 var ApiError = class extends Error {

package/dist/chunk-H2ZZXISB.js

@@ -0,0 +1,24 @@
+import {
+  cardHtmlProblem
+} from "./chunk-EQH37KNZ.js";
+import {
+  CueframeError
+} from "./chunk-XQGQ5EFS.js";
+
+// ../execution/render-harness/src/cardAssetAdmission.ts
+function assertCardHtmlAssetFree(input) {
+  for (const overlay of input.overlays ?? []) {
+    if (overlay.template !== "card") continue;
+    const html = overlay.params?.html;
+    if (typeof html !== "string") continue;
+    const problem = cardHtmlProblem(html);
+    if (problem) {
+      const locator = `overlay '${overlay.id}'`;
+      throw new CueframeError("card_external_asset_forbidden", `Card ${locator} ${problem}`, void 0, { card: locator });
+    }
+  }
+}
+
+export {
+  assertCardHtmlAssetFree
+};

package/dist/{chunk-WSMCZRJ2.js → chunk-I2HNC4PQ.js}

@@ -1,7 +1,7 @@
 import {
   bodySchemaFor,
   opById
-} from "./chunk-KBDUEU4W.js";
+} from "./chunk-FZB7UX44.js";
 
 // ../mcp/src/generated/sceneContract.ts
 function deepFreeze(value) {