@cueframe/kernel 0.2.2 → 0.2.4

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-XVBOSPZI.js → chunk-TBNTAQJA.js}

@@ -4,16 +4,16 @@ import {
 import {
   getPrimitiveSubtextParam,
   getPrimitiveTextParam
-} from "./chunk-C5SEPOWD.js";
+} from "./chunk-7AZLFN26.js";
 import {
   selectAllOverlays
-} from "./chunk-IBMJ33EL.js";
+} from "./chunk-I5RX2QZT.js";
 import {
   ComposePlan
-} from "./chunk-IHFREGFA.js";
+} from "./chunk-TCHPRGC5.js";
 import {
   OverlayClipSource
-} from "./chunk-7KEUL3FI.js";
+} from "./chunk-XF2QMKRG.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-4GSDBFT3.js");
+      const { buildDirectorContext } = await import("./context-IUPQ54V4.js");
       return buildDirectorContext(capabilities);
     }
   },
@@ -138,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"),
-      jsxSource: z.string().max(1e4).optional().describe("New canonical TSX module source for the overlay"),
+      jsxSource: z.string().max(5e4).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(

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-ZN6P3KOJ.js → chunk-UN6NY2E6.js}

@@ -310,7 +310,7 @@ Call wait_job(kind="compose", id="${j.composeJobId}", projectId="${a.projectId}"
     name: "apply_composition",
     operationId: "applyComposition",
     pathArgs: { projectId: "id" },
-    description: 'Atomically apply an array of CompositionOps to a project composition. All ops succeed or none do (transactional). Pass `if_match` for optimistic-concurrency control (409 stale_etag on mismatch) and `dry_run: true` to validate the batch without persisting. Use this to seed a composition (add media clips) or make targeted edits (set a crop intent, reorder clips, set the format). CAPTIONS: attach content with {type:"captions.fromTranscript", mediaId, window?} \u2014 the server slices the cached word-timed transcript, rebases times, and sentence-splits into segments (no pasting words; 422 media_no_transcript if the media has no speech); style it with {type:"setCaptionStyle", style}; or set explicit words with {type:"setCaptions", segments, style?} (e.g. translations or your own VO timings). Brand is NOT set here \u2014 it lives on the project (create_project / PATCH /projects/:id with brandKitId). CARDS: a {kind:"card", html, tokens} clip projects each `tokens` KEY `x` to the CSS custom property `--cf-x`, so the html must read it as `var(--cf-x)` \u2014 write `tokens:{"plate":"#0af"}` + `background:var(--cf-plate)`. Do NOT put dashes in the key: `"--plate"` becomes `--cf---plate` and your `var(--plate)` then resolves to NOTHING, which CSS silently degrades to a transparent background and black text. Responses carry `warnings[]` when a card reads a var nothing defines.',
+    description: 'Atomically apply an array of CompositionOps to a project composition. All ops succeed or none do (transactional). Pass `if_match` for optimistic-concurrency control (409 stale_etag on mismatch) and `dry_run: true` to validate the batch without persisting. Use this to seed a composition (add media clips) or make targeted edits (set a crop intent, reorder clips, set the format). CAPTIONS: attach content with {type:"captions.fromTranscript", mediaId, window?} \u2014 the server slices the cached word-timed transcript, rebases times, and sentence-splits into segments (no pasting words; 422 media_no_transcript if the media has no speech); style it with {type:"setCaptionStyle", style}; or set explicit words with {type:"setCaptions", segments, style?} (e.g. translations or your own VO timings). Brand is NOT set here \u2014 it lives on the project (create_project / PATCH /projects/:id with brandKitId). CARDS: a {kind:"card", html, tokens} clip projects each `tokens` KEY `x` to the CSS custom property `--cf-x`, so the html must read it as `var(--cf-x)` \u2014 write `tokens:{"plate":"#0af"}` + `background:var(--cf-plate)`. Do NOT put dashes in the key: `"--plate"` becomes `--cf---plate` and your `var(--plate)` then resolves to NOTHING, which CSS silently degrades to a transparent background and black text. Responses carry `warnings[]` when a card reads a var nothing defines. SCENE SHOTS: for a 3D product shot \u2014 a tilted page screenshot, a lit laptop/phone showing a real screenshot, two-colour type, a colour-field backdrop, focus/grain/vignette and a camera move \u2014 use {type:"scene.add", clipId, newTrack|trackId, startTime, duration, scene, assets} and revise it with {type:"scene.update", clipId, scene?, assets?, startTime?, duration?}. You author a scene SPEC, never wrapper TSX; the server registers the component for you. There is NO built-in scene primitive in list_catalog \u2014 READ cueframe://scene-shot first for the JSON schema, a copyable two-shot example with its asset-binding map, the admitted image formats (PNG/JPEG/WebP), the reference-aspect rule, screen-vs-world text, the v1 limits and the global-effect scope gap.',
     okFormat: (j, a) => {
       const warns = formatWarnings(j);
       if (j && typeof j.valid === "boolean") {
@@ -483,7 +483,7 @@ Call wait_job(kind="verify", id="${j.jobId}") to block until the scores + checkp
     name: "list_catalog",
     operationId: "listCatalog",
     defaults: { limit: 20 },
-    description: "DISCOVER WHAT TO BUILD WITH \u2014 list the component catalog: the built-in primitive catalog plus your org-installed components. The agent-safe default page is 20 entries; use pagination.nextCursor as `after`, or narrow with category, kind, tier, useCase, mood, q, or intent. Results are recommended-tier-first when filtered. Each entry carries the exact placement hint for apply_composition and fixedCopy warnings; use get_component_source to fork a primitive when baked copy must change. Read cueframe://component/{id} for the full prop schema.",
+    description: "DISCOVER WHAT TO BUILD WITH \u2014 list the component catalog: the built-in primitive catalog plus your org-installed components. The agent-safe default page is 20 entries; use pagination.nextCursor as `after`, or narrow with category, kind, tier, useCase, mood, q, or intent. Results are recommended-tier-first when filtered. Each entry carries the exact placement hint for apply_composition and fixedCopy warnings; use get_component_source to fork a primitive when baked copy must change. Read cueframe://component/{id} for the full prop schema. SCENE SHOTS ARE NOT LISTED HERE: there is no built-in scene primitive, so do not look for one \u2014 author a shot with the scene.add op (see cueframe://scene-shot). The wrapper it registers then appears here as an ordinary INSTALLED component under these same rules.",
     okFormat: (j) => formatComponentList(j),
     annotations: { readOnlyHint: true },
     preview: {
@@ -775,7 +775,7 @@ Render it with create_render(projectId="${a.projectId}", body={ compositionId: "
   {
     name: "get_account",
     operationId: "getAccount",
-    description: "ORIENT FIRST \u2014 show THIS key's account before you spend a metered call: the org it is bound to, the current plan, a per-feature entitlements map, and per-call cost ceilings. READ `balance`, NOT `included`. CueFrame is credit-funded: rendering (entitlements.exports), generation (generate), preview stills (compose_capture), the judge (compose_verify) and the Director (compose) have NO separate per-plan allowance \u2014 they all spend one shared wallet, named in `fundedBy` (`credits`; generation spends `premium_credits`). Each `balance` restates that ONE wallet in that feature's own unit at `creditCost` credits per unit, so they are alternative ways to spend the same money, not four budgets. A positive balance means proceed \u2014 `create_render`, `compose`, `generate_media` and `create_brand_kit` all succeed on a funded wallet and only 402 `billing_required` once it is spent, so do NOT tell the user a capability is missing, and do not send them to checkout, while balance > 0. `included:false` means the plan genuinely lacks the feature. Every new org starts with a free credit grant, so an account with an empty usage history can still render, generate, preview and score. costCeilings.generateMediaUsdPerCall is the generate_media per-call USD cap. No args \u2014 identity is resolved from your key (never echoed from input).",
+    description: "ORIENT FIRST \u2014 show THIS key's account before you spend a metered call: the org it is bound to, the current plan, a per-feature entitlements map, and per-call cost ceilings. READ `balance`, NOT `included`. CueFrame is credit-funded: rendering (entitlements.exports), generation (generate), preview stills (compose_capture), the judge (compose_verify) and the Director (compose) have NO separate per-plan allowance \u2014 they all spend one shared wallet, named in `fundedBy` (`credits`; generation is metered in provider-cost units against that wallet). Each `balance` restates that ONE wallet in that feature's own unit at `creditCost` credits per unit, so they are alternative ways to spend the same money, not four budgets. Check the requested cost against the balance. For generation, also check generationLimit: free accounts have a separate provider-cost cap even with a positive wallet. A billing_required error with reason free_generation_cap requires a credit-pack purchase through normal checkout. `included:false` means the plan genuinely lacks the feature. Every new org starts with a free credit grant, so an account with an empty usage history can still render, generate, preview and score. costCeilings.generateMediaUsdPerCall is the generate_media per-call USD cap. No args \u2014 identity is resolved from your key (never echoed from input).",
     annotations: { readOnlyHint: true }
   },
   {