@cueframe/kernel 0.2.1 → 0.2.3

package/dist/chunk-TARKDVP6.js

@@ -0,0 +1,430 @@
+// ../composition/src/fonts/bundledFaces.ts
+var VENDORED_FONT_FAMILIES = [
+  "Inter",
+  "Space Mono",
+  "Montserrat",
+  "Roboto",
+  "Poppins",
+  "Oswald",
+  "Playfair Display",
+  "Bebas Neue",
+  "Instrument Serif",
+  "National Park",
+  "Bricolage Grotesque",
+  "Schibsted Grotesk"
+];
+var ALIASED_FONT_FAMILIES = ["Georgia"];
+var BUNDLED_FONT_FACES = Object.freeze({
+  // Variable files: one upright binary whose `wght` axis covers the declared range. Each carries
+  // the house 600/800 pair outright, so its caption defaults are that pair.
+  "Inter": {
+    slug: "inter",
+    faces: [{ weight: "100 900", file: "400" }],
+    captionDefaults: { base: 600, emphasis: 800 }
+  },
+  "Montserrat": {
+    slug: "montserrat",
+    faces: [{ weight: "100 900", file: "400" }],
+    captionDefaults: { base: 600, emphasis: 800 }
+  },
+  "Roboto": {
+    slug: "roboto",
+    faces: [{ weight: "100 900", file: "400" }],
+    captionDefaults: { base: 600, emphasis: 800 }
+  },
+  // Oswald's axis stops at 700, so it declares 700 for the emphasis run rather than an 800 it
+  // has no bytes for.
+  "Oswald": {
+    slug: "oswald",
+    faces: [{ weight: "400 700", file: "400" }],
+    captionDefaults: { base: 600, emphasis: 700 }
+  },
+  "Playfair Display": {
+    slug: "playfair-display",
+    faces: [{ weight: "400 900", file: "400" }],
+    captionDefaults: { base: 600, emphasis: 800 }
+  },
+  "Bricolage Grotesque": {
+    slug: "bricolage-grotesque",
+    faces: [{ weight: "200 800", file: "400" }],
+    captionDefaults: { base: 600, emphasis: 800 }
+  },
+  "Schibsted Grotesk": {
+    slug: "schibsted-grotesk",
+    faces: [{ weight: "400 900", file: "400" }],
+    captionDefaults: { base: 600, emphasis: 800 }
+  },
+  // Static files: exactly the weights listed, nothing between them, so the declared defaults are
+  // drawn from those weights — the regular for the base run and the bold for the emphasis run.
+  "Space Mono": {
+    slug: "space-mono",
+    faces: [{ weight: "400", file: "400" }, { weight: "700", file: "700" }],
+    captionDefaults: { base: 400, emphasis: 700 }
+  },
+  "Poppins": {
+    slug: "poppins",
+    faces: [{ weight: "400", file: "400" }, { weight: "700", file: "700" }],
+    captionDefaults: { base: 400, emphasis: 700 }
+  },
+  // One file, one weight: the emphasis run separates itself by scale, colour and letter spacing
+  // rather than by a weight these families do not ship.
+  "Bebas Neue": {
+    slug: "bebas-neue",
+    faces: [{ weight: "400", file: "400" }],
+    captionDefaults: { base: 400, emphasis: 400 }
+  },
+  "Instrument Serif": {
+    slug: "instrument-serif",
+    faces: [{ weight: "400", file: "400" }],
+    captionDefaults: { base: 400, emphasis: 400 }
+  },
+  "National Park": {
+    slug: "national-park",
+    faces: [{ weight: "400", file: "400" }],
+    captionDefaults: { base: 400, emphasis: 400 }
+  },
+  // The one alias: `@font-face { font-family: 'Georgia' }` served from the Gelasio binary.
+  "Georgia": {
+    slug: "gelasio",
+    faces: [{ weight: "400", file: "400" }, { weight: "700", file: "700" }],
+    captionDefaults: { base: 400, emphasis: 700 }
+  }
+});
+var BUNDLED_FONT_STYLE = "normal";
+function bundledFontFamilyFaces(family) {
+  return BUNDLED_FONT_FACES[family];
+}
+function bundledFaceCoversWeight(face, weight) {
+  const parts = face.weight.split(/\s+/).map(Number);
+  if (parts.some((n) => !Number.isFinite(n))) return false;
+  if (parts.length === 1) return parts[0] === weight;
+  const [lo, hi] = parts;
+  return weight >= lo && weight <= hi;
+}
+function bundledFontFaceExists(family, weight, style) {
+  if (style !== BUNDLED_FONT_STYLE) return false;
+  const bundled = bundledFontFamilyFaces(family);
+  if (!bundled) return false;
+  return bundled.faces.some((face) => bundledFaceCoversWeight(face, weight));
+}
+function describeBundledFontWeights(family) {
+  const bundled = bundledFontFamilyFaces(family);
+  if (!bundled) return "";
+  return bundled.faces.map((face) => face.weight.split(/\s+/).join("-")).join(", ");
+}
+function unrenderableFaceField(family, weight, style, sealed) {
+  if (bundledFontFamilyFaces(family)) {
+    return style === BUNDLED_FONT_STYLE ? "fontWeight" : "fontStyle";
+  }
+  if (sealed.hasFamily(family)) {
+    return sealed.hasWeight(family, weight) ? "fontStyle" : "fontWeight";
+  }
+  return "fontFamily";
+}
+function parseFontStack(value) {
+  return value.split(",").map((f) => f.trim().replace(/^['"]|['"]$/g, "").trim()).filter(Boolean);
+}
+var CSS_GENERIC_FAMILIES = /* @__PURE__ */ new Set([
+  "serif",
+  "sans-serif",
+  "monospace",
+  "cursive",
+  "fantasy",
+  "system-ui",
+  "ui-serif",
+  "ui-sans-serif",
+  "ui-monospace",
+  "ui-rounded",
+  "emoji",
+  "math",
+  "fangsong"
+]);
+function isGenericOnlyStack(stack) {
+  if (typeof stack !== "string" || stack.trim().length === 0) return false;
+  const families = parseFontStack(stack);
+  return families.length > 0 && families.every((entry) => CSS_GENERIC_FAMILIES.has(entry.toLowerCase()));
+}
+var BUNDLED_BY_LOWER = new Map(
+  Object.keys(BUNDLED_FONT_FACES).map((family) => [family.toLowerCase(), family])
+);
+function bundledFamilyForStack(stack) {
+  if (typeof stack !== "string" || stack.trim().length === 0) return { kind: "default" };
+  if (stack.includes("$brand:") || stack.includes("${")) return { kind: "unknown" };
+  let bundled;
+  for (const entry of parseFontStack(stack)) {
+    const lower = entry.toLowerCase();
+    if (CSS_GENERIC_FAMILIES.has(lower)) continue;
+    const known = BUNDLED_BY_LOWER.get(lower);
+    if (!known) return { kind: "unknown" };
+    bundled ??= known;
+  }
+  return bundled ? { kind: "bundled", family: bundled } : { kind: "default" };
+}
+
+// ../composition/src/fonts/captionFaces.ts
+var CAPTION_FACE_DEFAULTS = Object.freeze({
+  fontFamily: "Inter, 'Helvetica Neue', Helvetica, Arial, sans-serif",
+  fontWeight: 600,
+  emphasisFontWeight: 800,
+  emphasisFontStyle: "normal"
+});
+var CAPTION_DEFAULT_FAMILY = "Inter";
+function captionStackFamily(stack) {
+  if (typeof stack !== "string" || stack.trim().length === 0) {
+    return { kind: "bundled", family: CAPTION_DEFAULT_FAMILY };
+  }
+  return bundledFamilyForStack(stack);
+}
+function captionDefaultWeights(resolved) {
+  const bundled = resolved.kind === "bundled" ? bundledFontFamilyFaces(resolved.family) : void 0;
+  return bundled?.captionDefaults ?? {
+    base: CAPTION_FACE_DEFAULTS.fontWeight,
+    emphasis: CAPTION_FACE_DEFAULTS.emphasisFontWeight
+  };
+}
+function resolveCaptionFaces(style) {
+  const baseStack = style.fontFamily ?? CAPTION_FACE_DEFAULTS.fontFamily;
+  const baseResolved = captionStackFamily(style.fontFamily);
+  const baseWeight = style.fontWeight ?? captionDefaultWeights(baseResolved).base;
+  const emphasisAuthoredStack = style.emphasisFontFamily;
+  const emphasisStack = emphasisAuthoredStack ?? baseStack;
+  const emphasisResolved = emphasisAuthoredStack === void 0 ? baseResolved : captionStackFamily(emphasisAuthoredStack);
+  const emphasisWeight = style.emphasisFontWeight ?? captionDefaultWeights(emphasisResolved).emphasis;
+  const emphasisStyle = style.emphasisFontStyle ?? CAPTION_FACE_DEFAULTS.emphasisFontStyle;
+  return {
+    base: {
+      role: "base",
+      field: "fontWeight",
+      stack: baseStack,
+      resolved: baseResolved,
+      weight: baseWeight,
+      style: BUNDLED_FONT_STYLE,
+      fromDefault: style.fontWeight === void 0
+    },
+    emphasis: {
+      role: "emphasis",
+      field: emphasisStyle === "italic" ? "emphasisFontStyle" : "emphasisFontWeight",
+      stack: emphasisStack,
+      resolved: emphasisResolved,
+      weight: emphasisWeight,
+      style: emphasisStyle,
+      fromDefault: emphasisStyle === "italic" ? style.emphasisFontStyle === void 0 : style.emphasisFontWeight === void 0
+    }
+  };
+}
+function captionFaceUses(style) {
+  const { base, emphasis } = resolveCaptionFaces(style);
+  const sameFace = emphasis.stack === base.stack && emphasis.weight === base.weight && emphasis.style === base.style;
+  return sameFace ? [base] : [base, emphasis];
+}
+var CAPTION_FACE_ISSUE_FIELDS = Object.freeze(["fontWeight", "emphasisFontWeight", "emphasisFontStyle"]);
+function because(use) {
+  return use.fromDefault ? `no ${use.field} is authored, so the ${use.role} run is drawn at the default ${use.style === "italic" ? `${use.field} "italic"` : use.weight}` : `${use.field} ${use.style === "italic" ? '"italic"' : use.weight} has no file behind it`;
+}
+function faceIssue(use) {
+  if (use.resolved.kind === "default" && use.style === "italic") {
+    return {
+      field: use.field,
+      face: { family: use.stack, weight: use.weight, style: use.style },
+      message: `font_not_reproducible \u2014 ${because(use)}: "${use.stack}" names no font file the render bundle carries, and it ships no italic binary at all, so the browser would slant whatever upright face it matched and the render refuses it before capture. Emphasise with emphasisFontWeight, emphasisColor or emphasisScale, or name an uploaded brand font that is sealed in italic.`
+    };
+  }
+  if (use.resolved.kind !== "bundled") return null;
+  const face = { family: use.resolved.family, weight: use.weight, style: use.style };
+  if (use.style === "italic") {
+    return {
+      field: use.field,
+      face,
+      message: `font_not_reproducible \u2014 ${because(use)}: ${use.resolved.family} ships no italic binary, so the browser would slant the upright face and the render refuses it before capture. Emphasise with emphasisFontWeight, emphasisColor or emphasisScale, or name an uploaded brand font that is sealed in italic.`
+    };
+  }
+  if (bundledFontFaceExists(use.resolved.family, use.weight, use.style)) return null;
+  return {
+    field: use.field,
+    face,
+    message: `font_not_reproducible \u2014 ${because(use)}: ${use.resolved.family} ships ${describeBundledFontWeights(use.resolved.family)}. The render refuses a weight outside that range before capture rather than let the browser substitute a nearby file, so set ${use.field} to a weight the family covers, or pick a family whose files do.`
+  };
+}
+function captionFaceIssues(style) {
+  const issues = [];
+  for (const use of captionFaceUses(style)) {
+    const issue = faceIssue(use);
+    if (issue) issues.push(issue);
+  }
+  return issues;
+}
+function faceKey(issue) {
+  return `${issue.face.family}\0${issue.face.weight}\0${issue.face.style}`;
+}
+function introducedCaptionFaceIssues(base, next) {
+  const before = new Set(captionFaceIssues(base).map(faceKey));
+  return captionFaceIssues(next).filter((issue) => !before.has(faceKey(issue)));
+}
+var CAPTION_FACE_MERGE_FIELDS = Object.freeze([
+  "fontFamily",
+  "fontWeight",
+  "emphasisFontFamily",
+  "emphasisFontWeight",
+  "emphasisFontStyle"
+]);
+function captionFontSource(fonts) {
+  if (fonts.caption) return { ref: fonts.caption, slot: "caption" };
+  if (fonts.body) return { ref: fonts.body, slot: "body" };
+  return { ref: fonts.heading, slot: "heading" };
+}
+function effectiveCaptionFamily(kit) {
+  const authored = kit.captionProfile?.fontFamily;
+  if (authored !== void 0) return { family: authored, path: "captionProfile.fontFamily" };
+  const { ref, slot } = captionFontSource(kit.fonts);
+  return { family: ref?.family, path: `fonts.${slot}` };
+}
+function brandKitCaptionFaceIssues(kit) {
+  const family = effectiveCaptionFamily(kit);
+  const profile = kit.captionProfile ?? {};
+  const style = {
+    ...profile,
+    ...family.family !== void 0 ? { fontFamily: family.family } : { fontFamily: void 0 }
+  };
+  return captionFaceIssues(style).map((issue) => ({
+    ...issue,
+    // The offending value is normally the profile's own — which is all that is reachable while
+    // every bundled family's DECLARED caption defaults are faces it ships (pinned by "declares a
+    // base and an emphasis weight every family has bytes for" in fonts.test.ts), because a kit
+    // whose profile authors nothing then draws two faces that exist. `family.path` is the answer
+    // for the day that stops being true: a defaulted face refused by the family the slot chain
+    // chose has to send the author to the SLOT, not to a profile field they never wrote.
+    path: profile[issue.field] !== void 0 ? `captionProfile.${issue.field}` : family.path
+  }));
+}
+function supplied(value) {
+  return value !== void 0 && value !== null && value !== "";
+}
+function mergeCaptionFaceFields(style, brandCaption) {
+  const merged = {};
+  for (const field of CAPTION_FACE_MERGE_FIELDS) {
+    const fromKit = brandCaption?.[field];
+    if (supplied(fromKit)) {
+      merged[field] = fromKit;
+      continue;
+    }
+    const fromStyle = style?.[field];
+    if (supplied(fromStyle)) merged[field] = fromStyle;
+  }
+  return merged;
+}
+function mergedCaptionFaceIssues(style, brandCaption) {
+  const merged = mergeCaptionFaceFields(style, brandCaption);
+  const originOf = (field) => {
+    if (supplied(brandCaption?.[field])) return "brandKit.captionProfile";
+    if (supplied(style?.[field])) return "captions.style";
+    return null;
+  };
+  return captionFaceIssues(merged).map((issue) => {
+    const familyField = issue.field === "fontWeight" ? "fontFamily" : supplied(merged.emphasisFontFamily) ? "emphasisFontFamily" : "fontFamily";
+    const origin = originOf(issue.field) ?? originOf(familyField);
+    if (origin === null) {
+      throw new Error(
+        `merged caption face refused at ${issue.field}, but neither it nor ${familyField} was authored by the composition or the brand kit, so no surface owns the value`
+      );
+    }
+    return { ...issue, origin, path: `${origin}.${issue.field}` };
+  });
+}
+function describeCaptionFaceIssues(issues, pathPrefix = "captionStyle") {
+  return issues.map((issue) => `${pathPrefix}.${issue.field}: ${issue.message}`).join(" ");
+}
+var CAPTION_WEIGHT_CHOICES = Object.freeze([400, 500, 600, 700, 800, 900]);
+function captionWeightChoices(stack) {
+  const resolved = captionStackFamily(stack);
+  if (resolved.kind !== "bundled") return CAPTION_WEIGHT_CHOICES;
+  return CAPTION_WEIGHT_CHOICES.filter(
+    (weight) => bundledFontFaceExists(resolved.family, weight, BUNDLED_FONT_STYLE)
+  );
+}
+function captionStyleChoices(stack) {
+  return captionStackFamily(stack).kind === "unknown" ? ["normal", "italic"] : ["normal"];
+}
+
+// ../composition/src/fonts.ts
+var AVAILABLE_LOWER = new Set(
+  [...VENDORED_FONT_FAMILIES, ...ALIASED_FONT_FAMILIES].map((f) => f.toLowerCase())
+);
+function isAvailableFontFamily(family) {
+  return AVAILABLE_LOWER.has(family.trim().replace(/^['"]|['"]$/g, "").toLowerCase());
+}
+var FONT_FAMILY_CSS = /font-family\s*:\s*((?:'[^']*'|"[^"]*"|[^;}"'])+?)\s*(?:;|}|"|$)/gi;
+var FONT_FAMILY_KEY = /fontfamily$/i;
+var MAX_NAMED = 6;
+function collectFontStacks(value, out) {
+  if (Array.isArray(value)) {
+    for (const v of value) collectFontStacks(v, out);
+    return;
+  }
+  if (value === null || typeof value !== "object") return;
+  for (const [k, v] of Object.entries(value)) {
+    if (typeof v === "string") {
+      if (FONT_FAMILY_KEY.test(k)) out.push(v);
+      for (const m of v.matchAll(FONT_FAMILY_CSS)) out.push(m[1]);
+      continue;
+    }
+    collectFontStacks(v, out);
+  }
+}
+function detectUnavailableFonts(value) {
+  const stacks = [];
+  collectFontStacks(value, stacks);
+  if (stacks.length === 0) return [];
+  const offenders = /* @__PURE__ */ new Map();
+  for (const raw of stacks) {
+    if (raw.includes("$brand:")) continue;
+    const families = parseFontStack(raw);
+    if (families.length === 0) continue;
+    if (families.some((f) => f.includes("${"))) continue;
+    if (families.some(isAvailableFontFamily)) continue;
+    offenders.set(families[0], (offenders.get(families[0]) ?? 0) + 1);
+  }
+  if (offenders.size === 0) return [];
+  const names = [...offenders.keys()];
+  const shown = names.slice(0, MAX_NAMED).map((n) => `\`${n}\``).join(", ");
+  const elided = names.length > MAX_NAMED ? ` (+${names.length - MAX_NAMED} more)` : "";
+  const requests = [...offenders.values()].reduce((a, b) => a + b, 0);
+  return [
+    `font_not_available \u2014 ${requests} font request${requests === 1 ? "" : "s"} name ${shown}${elided}, and nothing else in those stacks is vendored either. Only the vendored faces are guaranteed present in the render, so naming a family alone gets you the generic fallback (Liberation Sans) \u2014 no error, just the wrong typeface. Guaranteed: ${VENDORED_FONT_FAMILIES.join(", ")} (plus Georgia). Note that putting the family on a brand kit does NOT make it available \u2014 brand fonts resolve against the same vendored set.`
+  ];
+}
+
+export {
+  VENDORED_FONT_FAMILIES,
+  ALIASED_FONT_FAMILIES,
+  BUNDLED_FONT_FACES,
+  BUNDLED_FONT_STYLE,
+  bundledFontFamilyFaces,
+  bundledFaceCoversWeight,
+  bundledFontFaceExists,
+  describeBundledFontWeights,
+  unrenderableFaceField,
+  parseFontStack,
+  isGenericOnlyStack,
+  bundledFamilyForStack,
+  CAPTION_FACE_DEFAULTS,
+  CAPTION_DEFAULT_FAMILY,
+  captionStackFamily,
+  captionDefaultWeights,
+  resolveCaptionFaces,
+  captionFaceUses,
+  CAPTION_FACE_ISSUE_FIELDS,
+  captionFaceIssues,
+  introducedCaptionFaceIssues,
+  CAPTION_FACE_MERGE_FIELDS,
+  captionFontSource,
+  effectiveCaptionFamily,
+  brandKitCaptionFaceIssues,
+  mergeCaptionFaceFields,
+  mergedCaptionFaceIssues,
+  describeCaptionFaceIssues,
+  CAPTION_WEIGHT_CHOICES,
+  captionWeightChoices,
+  captionStyleChoices,
+  isAvailableFontFamily,
+  detectUnavailableFonts
+};

package/dist/{chunk-IHFREGFA.js → chunk-TCHPRGC5.js}

@@ -4,7 +4,10 @@ import {
   Format,
   GraphicRole,
   OpaqueId
-} from "./chunk-7KEUL3FI.js";
+} from "./chunk-XF2QMKRG.js";
+import {
+  brandKitCaptionFaceIssues
+} from "./chunk-TARKDVP6.js";
 
 // ../composition/src/validators/composePlan.ts
 import { z } from "zod";
@@ -238,9 +241,18 @@ var BrandKit = z2.object({
     entranceStaggerMs: z2.number().optional(),
     exitMs: z2.number().optional(),
     fontFamily: z2.string().optional(),
+    // The ordinary run's weight. The profile could name a caption family but never how heavy it
+    // was drawn, so the only answer to "that weight has no file behind it" was to change the
+    // family. A family that does not declare this weight is still refused here — but now at a
+    // field the author can set, and a family that ships it needs no setting at all: every
+    // bundled family declares a base and an emphasis weight it has bytes for.
+    fontWeight: z2.number().int().min(100).max(900).multipleOf(100).optional(),
     emphasisFontFamily: z2.string().optional(),
     emphasisScale: z2.number().positive().optional(),
-    emphasisFontWeight: z2.number().optional(),
+    // A CSS weight, and the profile is projected straight onto the caption style, so it is held
+    // to the same range the composition holds `emphasisFontWeight` to. An unbounded number here
+    // was a hole: 0 or 1500 named no face at all.
+    emphasisFontWeight: z2.number().int().min(100).max(900).optional(),
     emphasisFontStyle: z2.enum(["normal", "italic"]).optional(),
     emphasisTextTransform: z2.enum(["none", "uppercase"]).optional(),
     emphasisLetterSpacing: z2.number().optional(),
@@ -298,6 +310,10 @@ var BrandKit = z2.object({
   ]).optional(),
   ownerOrgId: z2.string().optional(),
   acl: AccessControl.optional()
+}).superRefine((kit, ctx) => {
+  for (const issue of brandKitCaptionFaceIssues(kit)) {
+    ctx.addIssue({ code: "custom", path: issue.path.split("."), message: issue.message });
+  }
 });
 
 // ../composition/src/validators/font.ts

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

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

package/dist/{chunk-KU376ELE.js → chunk-UY77TMKD.js}

@@ -1,53 +1,28 @@
 import {
+  assertSceneShotCapabilitySupported,
+  assertSceneShotParamsAdmitted,
+  materializeComponentSource,
   renderComponentAlpha
-} from "./chunk-5OTQ7M43.js";
-import {
-  findWorkspace
-} from "./chunk-WB2VFDQZ.js";
+} from "./chunk-DQLYWNLC.js";
 import {
   componentArtifactId,
   componentBundleId,
   componentRenderKey,
   sha256Hex,
   sourceVersionId
-} from "./chunk-M2TLRXEO.js";
+} from "./chunk-EXY4JJPH.js";
 import {
-  assertComponentImportsAllowed
-} from "./chunk-2PGLNTB7.js";
+  resolvedComponentRenderer
+} from "./chunk-WIHXXF3X.js";
 import {
   ComponentBakeJobV2,
   ComponentBakeRequestV2,
   ComponentRenderReceiptV2,
   ComponentRenderRequestV2,
   ComponentRuntimeError,
-  ComponentSourceV2,
-  assertGraphicsReceiptMatches
-} from "./chunk-LQUWKBST.js";
-
-// ../execution/component-runtime/src/sourceWorkspace.ts
-import { mkdirSync, writeFileSync } from "fs";
-import { join } from "path";
-function materializeComponentSource(workspaceRoot, input) {
-  const source = ComponentSourceV2.parse(input);
-  assertComponentImportsAllowed(source.tsxSource);
-  mkdirSync(workspaceRoot, { recursive: true });
-  writeFileSync(join(workspaceRoot, "cueframe.json"), '{"componentsDir":"cueframe/components"}\n', {
-    flag: "wx"
-  });
-  const dir = join(workspaceRoot, "cueframe", "components", source.componentId);
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(join(dir, "index.tsx"), source.tsxSource, { flag: "wx" });
-  writeFileSync(join(dir, "component-source-v2.json"), `${JSON.stringify(source)}
-`, { flag: "wx" });
-  const workspace = findWorkspace(workspaceRoot);
-  if (!workspace) throw new Error("Materialized component workspace could not be opened.");
-  return {
-    workspace,
-    source,
-    sourceVersionId: sourceVersionId(source),
-    componentDir: dir
-  };
-}
+  assertGraphicsReceiptMatches,
+  assertRendererReceiptMatches
+} from "./chunk-ZVG446DJ.js";
 
 // ../execution/component-runtime/src/assetServer.ts
 import { createHash, randomBytes } from "crypto";
@@ -163,7 +138,7 @@ async function startComponentAssetServer(args) {
 
 // ../execution/component-runtime/src/outputVerifier.ts
 import { execFileSync } from "child_process";
-import { dirname, join as join2 } from "path";
+import { dirname, join } from "path";
 import { existsSync, statSync as statSync2 } from "fs";
 var OPAQUE_ALPHA_FRACTION = 0.98;
 function parseAlphaOpaqueFractions(ffmpegOutput) {
@@ -202,7 +177,7 @@ function verifyComponentOutput(options) {
   if (size <= 0 || size > (options.maxBytes ?? 1073741824)) {
     throw new ComponentRuntimeError("component_output_invalid", "Rendered component artifact has an invalid size.");
   }
-  const bundledProbe = join2(dirname(process.execPath), process.platform === "win32" ? "ffprobe.exe" : "ffprobe");
+  const bundledProbe = join(dirname(process.execPath), process.platform === "win32" ? "ffprobe.exe" : "ffprobe");
   const ffprobeExecutable = options.ffprobeExecutable ?? process.env.COMPONENT_FFPROBE_EXECUTABLE ?? (existsSync(bundledProbe) ? bundledProbe : "ffprobe");
   let probe;
   try {
@@ -223,7 +198,7 @@ function verifyComponentOutput(options) {
   }
   assertComponentOutputProbe(probe, options.expected);
   if (options.expected.source.manifest.alphaPolicy === "requires-transparency") {
-    const bundledFfmpeg = join2(dirname(process.execPath), process.platform === "win32" ? "ffmpeg.exe" : "ffmpeg");
+    const bundledFfmpeg = join(dirname(process.execPath), process.platform === "win32" ? "ffmpeg.exe" : "ffmpeg");
     const ffmpegExecutable = options.ffmpegExecutable ?? process.env.COMPONENT_FFMPEG_EXECUTABLE ?? (existsSync(bundledFfmpeg) ? bundledFfmpeg : "ffmpeg");
     const durationSec = Math.max(0.05, options.expected.durationInFrames / options.expected.fps);
     let fractions;
@@ -256,7 +231,7 @@ function verifyComponentOutput(options) {
 }
 
 // ../execution/component-runtime/src/bake.ts
-import { constants, copyFileSync, mkdirSync as mkdirSync2, readFileSync, statSync as statSync3 } from "fs";
+import { constants, copyFileSync, mkdirSync, readFileSync, statSync as statSync3 } from "fs";
 import { dirname as dirname2 } from "path";
 function assertAssetBindingsMatch(request) {
   const declared = request.source.manifest.assets;
@@ -294,7 +269,9 @@ function assertAssetBindingsMatch(request) {
   }
 }
 async function bakeComponentAlphaV2(options) {
+  assertSceneShotCapabilitySupported(options.job?.source?.manifest, { componentId: options.job?.source?.componentId });
   const job = ComponentBakeJobV2.parse(options.job);
+  assertSceneShotParamsAdmitted(job.source.manifest, job.params, { componentId: job.source.componentId });
   const assetServer = await startComponentAssetServer({ assets: job.assets, files: job.assetFiles });
   try {
     const { assetFiles: _assetFiles, ...unsealedRequest } = job;
@@ -309,6 +286,7 @@ async function bakeComponentAlphaV2(options) {
       runtimeDigest: request.runtimeDigest,
       dependencyLockDigest: request.dependencyLockDigest
     });
+    const renderer = resolvedComponentRenderer(request.source.manifest.graphics, request.source.manifest.sceneShot);
     const renderRequest = ComponentRenderRequestV2.parse({
       version: 2,
       bundleId,
@@ -320,7 +298,8 @@ async function bakeComponentAlphaV2(options) {
       durationInFrames: request.durationInFrames,
       alpha: true,
       graphics: request.source.manifest.graphics,
-      seed: request.seed
+      seed: request.seed,
+      renderer
     });
     const renderKey = componentRenderKey(renderRequest);
     const rendered = await renderComponentAlpha({
@@ -336,7 +315,10 @@ async function bakeComponentAlphaV2(options) {
       height: request.height,
       fps: request.fps,
       durationInFrames: request.durationInFrames,
-      renderEntryRoot: options.renderEntryRoot
+      renderEntryRoot: options.renderEntryRoot,
+      concurrency: options.concurrency,
+      onProgress: options.onProgress,
+      onTiming: options.onTiming
     });
     verifyComponentOutput({
       path: rendered.videoPath,
@@ -344,7 +326,7 @@ async function bakeComponentAlphaV2(options) {
       ffprobeExecutable: options.ffprobeExecutable,
       ffmpegExecutable: options.ffmpegExecutable
     });
-    mkdirSync2(dirname2(options.outputPath), { recursive: true });
+    mkdirSync(dirname2(options.outputPath), { recursive: true });
     copyFileSync(rendered.videoPath, options.outputPath, constants.COPYFILE_EXCL);
     const output = readFileSync(options.outputPath);
     const outputSha256 = sha256Hex(output);
@@ -363,13 +345,19 @@ async function bakeComponentAlphaV2(options) {
       durationInFrames: request.durationInFrames,
       alpha: true,
       requestedGraphics: request.source.manifest.graphics,
-      actualGraphics: rendered.actualGraphics
+      actualGraphics: rendered.actualGraphics,
+      renderer,
+      // The machine, not the picture: recorded so an evidence row can cite the host this artifact
+      // was drawn on, and dropped by `componentArtifactIdentity` before hashing so two hosts that
+      // both clear the shadow-map budget still produce one artifact id for one set of bytes.
+      host: rendered.host
     };
     const receipt = ComponentRenderReceiptV2.parse({
       ...receiptWithoutArtifact,
       artifactId: componentArtifactId({ outputSha256, receipt: receiptWithoutArtifact })
     });
     assertGraphicsReceiptMatches(renderRequest, receipt);
+    assertRendererReceiptMatches(renderRequest, receipt);
     return receipt;
   } finally {
     await assetServer.close();
@@ -380,7 +368,6 @@ function sourceIdentityForBake(request) {
 }
 
 export {
-  materializeComponentSource,
   startComponentAssetServer,
   parseAlphaOpaqueFractions,
   bakeOpacityContradictsPolicy,