@cueframe/kernel 0.1.4 → 0.2.0

package/dist/chunk-CGHTMZNC.js

@@ -0,0 +1,6 @@
+// ../execution/component-runtime/src/browserOptions.ts
+var COMPONENT_CHROMIUM_OPTIONS = Object.freeze({ gl: "swangle" });
+
+export {
+  COMPONENT_CHROMIUM_OPTIONS
+};

package/dist/chunk-DHKQ47Q6.js

@@ -0,0 +1,57 @@
+// ../execution/component-runtime/src/canonicalIdentity.ts
+function normalizedString(value) {
+  return value.replace(/\r\n?/g, "\n").normalize("NFC");
+}
+function canonicalValue(value, seen) {
+  if (value === null || typeof value === "boolean") return value;
+  if (typeof value === "string") return normalizedString(value);
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new TypeError("Canonical JSON does not support non-finite numbers.");
+    return Object.is(value, -0) ? 0 : value;
+  }
+  if (typeof value !== "object") {
+    throw new TypeError(`Canonical JSON does not support ${typeof value} values.`);
+  }
+  if (seen.has(value)) throw new TypeError("Canonical JSON does not support cyclic values.");
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) return value.map((item) => canonicalValue(item, seen));
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+      throw new TypeError("Canonical JSON only supports plain objects.");
+    }
+    const record = value;
+    const result = {};
+    for (const key of Object.keys(record).sort()) {
+      const item = record[key];
+      if (item === void 0) throw new TypeError("Canonical JSON does not support undefined values.");
+      result[normalizedString(key)] = canonicalValue(item, seen);
+    }
+    return result;
+  } finally {
+    seen.delete(value);
+  }
+}
+function canonicalJson(value) {
+  return JSON.stringify(canonicalValue(value, /* @__PURE__ */ new Set()));
+}
+function sourceVersionIdentity(source) {
+  return canonicalJson(source);
+}
+function componentBundleIdentity(input) {
+  return canonicalJson({ domain: "cueframe.component.bundle.v2", ...input });
+}
+function componentRenderIdentity(request) {
+  return canonicalJson({ domain: "cueframe.component.render.v2", request });
+}
+function componentArtifactIdentity(input) {
+  return canonicalJson({ domain: "cueframe.component.artifact.v2", ...input });
+}
+
+export {
+  canonicalJson,
+  sourceVersionIdentity,
+  componentBundleIdentity,
+  componentRenderIdentity,
+  componentArtifactIdentity
+};

package/dist/{chunk-3PM6VICZ.js → chunk-DQKSCHFC.js}

@@ -1,3 +1,6 @@
+import {
+  FitText
+} from "./chunk-XHGZ2E77.js";
 import {
   ACCENT,
   BG,
@@ -19,9 +22,6 @@ import {
   TEXT_MUTED,
   VIOLET
 } from "./chunk-CX2IIQ4R.js";
-import {
-  FitText
-} from "./chunk-XHGZ2E77.js";
 
 // ../execution/primitives/src/layouts/chat-to-preview-layout/index.tsx
 import { Easing, interpolate, useCurrentFrame, useVideoConfig } from "remotion";
@@ -1187,7 +1187,7 @@ var config3 = {
 // ../execution/primitives/src/layouts/photo-grid/config.ts
 import { z as z4 } from "zod";
 var paramsSchema4 = z4.object({
-  images: z4.array(z4.string().url()).min(1).describe("Array of image URLs to display."),
+  images: z4.array(z4.string().url().meta({ cueframeAsset: true })).min(1).describe("Array of image URLs to display."),
   columns: z4.number().int().min(1).max(6).default(2).describe("Grid columns."),
   gap: z4.number().min(0).max(40).default(8).describe("Gap between cells in pixels."),
   stagger: z4.number().min(0).max(2).default(0.15).describe("Seconds between each cell's reveal. 0.1\u20130.25 reads natural.")

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

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

package/dist/{chunk-ZT7MHRQU.js → chunk-GCQ7Z7S7.js}

@@ -1,3 +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"
+};
+
 // ../authoring/src/models/modelFactory.ts
 import { createAnthropic } from "@ai-sdk/anthropic";
 import { createOpenAI } from "@ai-sdk/openai";
@@ -56,19 +65,19 @@ function buildModel(settings, langfuse) {
         apiKey: settings.apiKey,
         ...settings.baseUrl ? { baseURL: settings.baseUrl } : {}
       });
-      const id = settings.modelId || "claude-sonnet-4-6";
+      const id = settings.modelId || DEFAULT_MODEL_IDS.anthropic;
       return { model: anthropic(id), providerName: "anthropic", modelId: id };
     }
     case "openai": {
       if (!settings.apiKey) throw new Error("OpenAI API key not configured.");
       const openai = createOpenAI({ apiKey: settings.apiKey });
-      const id = settings.modelId || "gpt-4o";
+      const id = settings.modelId || DEFAULT_MODEL_IDS.openai;
       return { model: openai(id), providerName: "openai", modelId: id };
     }
     case "ollama": {
       const baseUrl = settings.baseUrl || "http://localhost:11434/v1";
       const openai = createOpenAI({ apiKey: "ollama", baseURL: baseUrl });
-      const id = settings.modelId || "llama3.1";
+      const id = settings.modelId || DEFAULT_MODEL_IDS.ollama;
       return { model: openai(id), providerName: "ollama", modelId: id };
     }
     case "gateway": {
@@ -79,7 +88,7 @@ function buildModel(settings, langfuse) {
         baseURL: settings.gatewayUrl + "/anthropic/v1",
         fetch: settings.requestTimeoutMs ? withRequestTimeout(baseFetch, settings.requestTimeoutMs) : langfuse ? baseFetch : void 0
       });
-      const id = settings.modelId || "claude-sonnet-4-6";
+      const id = settings.modelId || DEFAULT_MODEL_IDS.anthropic;
       return { model: anthropic(id), providerName: "gateway", modelId: id };
     }
     default:
@@ -90,13 +99,14 @@ function buildFastModel(settings, langfuse) {
   return buildModel(
     {
       ...settings,
-      modelId: settings.fastModelId ?? "claude-haiku-4-5-20251001"
+      modelId: settings.fastModelId ?? DEFAULT_MODEL_IDS.fast
     },
     langfuse
   );
 }
 
 export {
+  DEFAULT_MODEL_IDS,
   withRequestTimeout,
   makeLangfuseFetch,
   buildModel,

package/dist/{chunk-ZBRPF6GV.js → chunk-GEGRJKKO.js}

@@ -2,7 +2,7 @@ import {
   COMPOSE_PLANNER_TOOLS,
   COMPOSE_ROLE_TOOLS,
   dispatchComposeRoleTool
-} from "./chunk-D2EGO543.js";
+} from "./chunk-XVBOSPZI.js";
 
 // ../authoring/src/agent/buildTools.ts
 import { tool } from "ai";

package/dist/chunk-HHFDHJ3I.js

@@ -0,0 +1,392 @@
+import {
+  renderComponentAlpha
+} from "./chunk-5OTQ7M43.js";
+import {
+  findWorkspace
+} from "./chunk-WB2VFDQZ.js";
+import {
+  componentArtifactId,
+  componentBundleId,
+  componentRenderKey,
+  sha256Hex,
+  sourceVersionId
+} from "./chunk-M2TLRXEO.js";
+import {
+  assertComponentImportsAllowed
+} from "./chunk-SIAXP3ZO.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
+  };
+}
+
+// ../execution/component-runtime/src/assetServer.ts
+import { createHash, randomBytes } from "crypto";
+import { createReadStream, realpathSync, statSync } from "fs";
+import { createServer } from "http";
+var sha256File = async (path) => await new Promise((resolve, reject) => {
+  const hash = createHash("sha256");
+  const stream = createReadStream(path);
+  stream.on("data", (chunk) => hash.update(chunk));
+  stream.once("error", reject);
+  stream.once("end", () => resolve(hash.digest("hex")));
+});
+function sendStatus(response, status) {
+  response.statusCode = status;
+  response.setHeader("Cache-Control", "no-store");
+  response.end();
+}
+function parseSingleRange(value, size) {
+  if (!value) return null;
+  const match = /^bytes=(\d*)-(\d*)$/.exec(value);
+  if (!match || match[1] === "" && match[2] === "") return "invalid";
+  let start;
+  let end;
+  if (match[1] === "") {
+    const suffix = Number(match[2]);
+    if (!Number.isSafeInteger(suffix) || suffix <= 0) return "invalid";
+    start = Math.max(0, size - suffix);
+    end = size - 1;
+  } else {
+    start = Number(match[1]);
+    end = match[2] === "" ? size - 1 : Number(match[2]);
+  }
+  if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 0 || start > end || start >= size) {
+    return "invalid";
+  }
+  return [start, Math.min(end, size - 1)];
+}
+async function startComponentAssetServer(args) {
+  const assetNames = Object.keys(args.assets).sort();
+  if (assetNames.length !== Object.keys(args.files).length || assetNames.some((name) => !Object.hasOwn(args.files, name))) {
+    throw new ComponentRuntimeError("component_asset_unavailable", "Component asset inputs and localized files must have identical keys.");
+  }
+  const sealed = await Promise.all(assetNames.map(async (name) => {
+    const path = realpathSync(args.files[name].path);
+    const stat = statSync(path);
+    if (!stat.isFile() || stat.size <= 0) {
+      throw new ComponentRuntimeError("component_asset_unavailable", `Component asset ${JSON.stringify(name)} is not a readable file.`);
+    }
+    return [name, { path, size: stat.size, binding: { ...args.assets[name], contentSha256: await sha256File(path) } }];
+  }));
+  const byName = new Map(sealed);
+  const token = randomBytes(32).toString("hex");
+  let expectedHost = null;
+  const server = createServer((request, response) => {
+    if (expectedHost === null || request.headers.host !== expectedHost) return sendStatus(response, 421);
+    response.setHeader("Access-Control-Allow-Origin", "*");
+    response.setHeader("Accept-Ranges", "bytes");
+    response.setHeader("X-Content-Type-Options", "nosniff");
+    if (request.method !== "GET" && request.method !== "HEAD") return sendStatus(response, 405);
+    const parsed = new URL(request.url ?? "/", "http://127.0.0.1");
+    const prefix = `/v2/${token}/`;
+    if (!parsed.pathname.startsWith(prefix) || parsed.search || parsed.hash) return sendStatus(response, 404);
+    let name;
+    try {
+      name = decodeURIComponent(parsed.pathname.slice(prefix.length));
+    } catch {
+      return sendStatus(response, 404);
+    }
+    if (!name || name.includes("/") || name.includes("\\")) return sendStatus(response, 404);
+    const row = byName.get(name);
+    if (!row) return sendStatus(response, 404);
+    const range = parseSingleRange(request.headers.range, row.size);
+    if (range === "invalid") {
+      response.setHeader("Content-Range", `bytes */${row.size}`);
+      return sendStatus(response, 416);
+    }
+    const [start, end] = range ?? [0, row.size - 1];
+    response.statusCode = range ? 206 : 200;
+    response.setHeader("Content-Type", row.binding.mimeType);
+    response.setHeader("Content-Length", String(end - start + 1));
+    if (range) response.setHeader("Content-Range", `bytes ${start}-${end}/${row.size}`);
+    if (request.method === "HEAD") return response.end();
+    const stream = createReadStream(row.path, { start, end });
+    stream.once("error", () => response.destroy());
+    stream.pipe(response);
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => resolve());
+  });
+  const address = server.address();
+  if (!address || typeof address === "string") {
+    server.close();
+    throw new ComponentRuntimeError("component_asset_unavailable", "Component asset server failed to bind a loopback port.");
+  }
+  expectedHost = `127.0.0.1:${address.port}`;
+  const origin = `http://127.0.0.1:${address.port}`;
+  const bindings = Object.fromEntries(sealed.map(([name, row]) => [name, row.binding]));
+  const runtimeAssets = Object.fromEntries(sealed.map(([name, row]) => [name, {
+    ...row.binding,
+    handle: `${origin}/v2/${token}/${encodeURIComponent(name)}`
+  }]));
+  return {
+    origin,
+    bindings,
+    runtimeAssets,
+    close: async () => await new Promise((resolve, reject) => {
+      server.closeAllConnections?.();
+      server.close((error) => error ? reject(error) : resolve());
+    })
+  };
+}
+
+// ../execution/component-runtime/src/outputVerifier.ts
+import { execFileSync } from "child_process";
+import { dirname, join as join2 } from "path";
+import { existsSync, statSync as statSync2 } from "fs";
+var OPAQUE_ALPHA_FRACTION = 0.98;
+function parseAlphaOpaqueFractions(ffmpegOutput) {
+  const fractions = [];
+  for (const match of ffmpegOutput.matchAll(/lavfi\.signalstats\.YAVG=([\d.]+)/g)) {
+    const value = Number(match[1]);
+    if (Number.isFinite(value)) fractions.push(Math.min(1, Math.max(0, value / 255)));
+  }
+  return fractions;
+}
+function bakeOpacityContradictsPolicy(alphaPolicy, opaqueFractions) {
+  return alphaPolicy === "requires-transparency" && opaqueFractions.length > 0 && opaqueFractions.every((fraction) => fraction >= OPAQUE_ALPHA_FRACTION);
+}
+function rational(value) {
+  if (!value) return Number.NaN;
+  const [numerator, denominator = "1"] = value.split("/");
+  return Number(numerator) / Number(denominator);
+}
+function assertComponentOutputProbe(probe, expected) {
+  const stream = probe.streams?.[0];
+  const expectedCodec = expected.codec === "vp9" ? "vp9" : "prores";
+  const frames = Number(stream?.nb_read_frames);
+  const fps = rational(stream?.avg_frame_rate);
+  const duration = Number(probe.format?.duration);
+  const expectedDuration = expected.durationInFrames / expected.fps;
+  const hasAlpha = expected.codec === "vp9" ? stream?.tags?.alpha_mode === "1" : Boolean(stream?.pix_fmt?.startsWith("yuva"));
+  if (stream?.codec_name !== expectedCodec || stream.width !== expected.width || stream.height !== expected.height || frames !== expected.durationInFrames || !Number.isFinite(fps) || Math.abs(fps - expected.fps) > 1e-3 || !Number.isFinite(duration) || Math.abs(duration - expectedDuration) > Math.max(0.05, 1 / expected.fps) || !hasAlpha) {
+    throw new ComponentRuntimeError(
+      "component_output_invalid",
+      "Rendered component artifact failed codec, alpha, dimensions, frame-count, FPS, or duration verification."
+    );
+  }
+}
+function verifyComponentOutput(options) {
+  const size = statSync2(options.path).size;
+  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 ffprobeExecutable = options.ffprobeExecutable ?? process.env.COMPONENT_FFPROBE_EXECUTABLE ?? (existsSync(bundledProbe) ? bundledProbe : "ffprobe");
+  let probe;
+  try {
+    probe = JSON.parse(execFileSync(ffprobeExecutable, [
+      "-v",
+      "error",
+      "-count_frames",
+      "-select_streams",
+      "v:0",
+      "-show_entries",
+      "stream=codec_name,width,height,avg_frame_rate,nb_read_frames,pix_fmt:stream_tags=alpha_mode:format=duration",
+      "-of",
+      "json",
+      options.path
+    ], { encoding: "utf8", timeout: 3e4, maxBuffer: 2e6 }));
+  } catch (error) {
+    throw new ComponentRuntimeError("component_output_invalid", "Rendered component artifact could not be probed.", { cause: error });
+  }
+  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 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;
+    try {
+      const output = execFileSync(ffmpegExecutable, [
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        ...options.expected.codec === "vp9" ? ["-c:v", "libvpx-vp9"] : [],
+        "-i",
+        options.path,
+        "-vf",
+        `format=yuva420p,alphaextract,fps=5/${durationSec},signalstats,metadata=print:file=-`,
+        "-an",
+        "-f",
+        "null",
+        "-"
+      ], { encoding: "utf8", timeout: 3e4, maxBuffer: 2e6 });
+      fractions = parseAlphaOpaqueFractions(output);
+    } catch (error) {
+      throw new ComponentRuntimeError("component_output_invalid", "Rendered component alpha policy could not be verified.", { cause: error });
+    }
+    if (fractions.length === 0) {
+      throw new ComponentRuntimeError("component_output_invalid", "Rendered component alpha policy produced no samples.");
+    }
+    if (bakeOpacityContradictsPolicy(options.expected.source.manifest.alphaPolicy, fractions)) {
+      throw new ComponentRuntimeError("component_output_invalid", "Rendered component is opaque but its manifest requires transparency.");
+    }
+  }
+}
+
+// ../execution/component-runtime/src/bake.ts
+import { constants, copyFileSync, mkdirSync as mkdirSync2, readFileSync, statSync as statSync3 } from "fs";
+import { dirname as dirname2 } from "path";
+function assertAssetBindingsMatch(request) {
+  const declared = request.source.manifest.assets;
+  for (const [name, declaration] of Object.entries(declared)) {
+    const binding = request.assets[name];
+    if (!binding) {
+      if (declaration.required) {
+        throw new ComponentRuntimeError(
+          "component_asset_unavailable",
+          `Required component asset ${JSON.stringify(name)} is missing.`
+        );
+      }
+      continue;
+    }
+    if (binding.kind !== declaration.kind) {
+      throw new ComponentRuntimeError(
+        "component_asset_integrity_failed",
+        `Component asset ${JSON.stringify(name)} has kind ${binding.kind}; expected ${declaration.kind}.`
+      );
+    }
+    if (declaration.mimeTypes && !declaration.mimeTypes.includes(binding.mimeType)) {
+      throw new ComponentRuntimeError(
+        "component_asset_integrity_failed",
+        `Component asset ${JSON.stringify(name)} has an undeclared MIME type.`
+      );
+    }
+  }
+  for (const name of Object.keys(request.assets)) {
+    if (!Object.hasOwn(declared, name)) {
+      throw new ComponentRuntimeError(
+        "component_asset_undeclared",
+        `Component asset ${JSON.stringify(name)} was not declared by the source manifest.`
+      );
+    }
+  }
+}
+async function bakeComponentAlphaV2(options) {
+  const job = ComponentBakeJobV2.parse(options.job);
+  const assetServer = await startComponentAssetServer({ assets: job.assets, files: job.assetFiles });
+  try {
+    const { assetFiles: _assetFiles, ...unsealedRequest } = job;
+    const request = ComponentBakeRequestV2.parse({
+      ...unsealedRequest,
+      assets: assetServer.bindings
+    });
+    assertAssetBindingsMatch(request);
+    const materialized = materializeComponentSource(options.workspaceRoot, request.source);
+    const bundleId = componentBundleId({
+      sourceVersionId: materialized.sourceVersionId,
+      runtimeDigest: request.runtimeDigest,
+      dependencyLockDigest: request.dependencyLockDigest
+    });
+    const renderRequest = ComponentRenderRequestV2.parse({
+      version: 2,
+      bundleId,
+      params: request.params,
+      assets: request.assets,
+      width: request.width,
+      height: request.height,
+      fps: request.fps,
+      durationInFrames: request.durationInFrames,
+      alpha: true,
+      graphics: request.source.manifest.graphics,
+      seed: request.seed
+    });
+    const renderKey = componentRenderKey(renderRequest);
+    const rendered = await renderComponentAlpha({
+      ws: materialized.workspace,
+      id: request.source.componentId,
+      params: request.params,
+      assets: assetServer.runtimeAssets,
+      allowedAssetOrigins: /* @__PURE__ */ new Set([assetServer.origin]),
+      seed: request.seed,
+      graphics: request.source.manifest.graphics,
+      codec: request.codec,
+      width: request.width,
+      height: request.height,
+      fps: request.fps,
+      durationInFrames: request.durationInFrames,
+      renderEntryRoot: options.renderEntryRoot
+    });
+    verifyComponentOutput({
+      path: rendered.videoPath,
+      expected: request,
+      ffprobeExecutable: options.ffprobeExecutable,
+      ffmpegExecutable: options.ffmpegExecutable
+    });
+    mkdirSync2(dirname2(options.outputPath), { recursive: true });
+    copyFileSync(rendered.videoPath, options.outputPath, constants.COPYFILE_EXCL);
+    const output = readFileSync(options.outputPath);
+    const outputSha256 = sha256Hex(output);
+    const receiptWithoutArtifact = {
+      version: 2,
+      renderKey,
+      bundleId,
+      sourceVersionId: materialized.sourceVersionId,
+      runtimeDigest: request.runtimeDigest,
+      outputSha256,
+      outputBytes: statSync3(options.outputPath).size,
+      codec: request.codec,
+      width: request.width,
+      height: request.height,
+      fps: request.fps,
+      durationInFrames: request.durationInFrames,
+      alpha: true,
+      requestedGraphics: request.source.manifest.graphics,
+      actualGraphics: rendered.actualGraphics
+    };
+    const receipt = ComponentRenderReceiptV2.parse({
+      ...receiptWithoutArtifact,
+      artifactId: componentArtifactId({ outputSha256, receipt: receiptWithoutArtifact })
+    });
+    assertGraphicsReceiptMatches(renderRequest, receipt);
+    return receipt;
+  } finally {
+    await assetServer.close();
+  }
+}
+function sourceIdentityForBake(request) {
+  return sourceVersionId(ComponentBakeRequestV2.parse(request).source);
+}
+
+export {
+  materializeComponentSource,
+  startComponentAssetServer,
+  parseAlphaOpaqueFractions,
+  bakeOpacityContradictsPolicy,
+  assertComponentOutputProbe,
+  verifyComponentOutput,
+  assertAssetBindingsMatch,
+  bakeComponentAlphaV2,
+  sourceIdentityForBake
+};

package/dist/{chunk-JRIPQ7DN.js → chunk-IBMJ33EL.js}

@@ -1,9 +1,9 @@
+import {
+  Composition
+} from "./chunk-7KEUL3FI.js";
 import {
   expandToLinkGroup
 } from "./chunk-KYRDKK2D.js";
-import {
-  Composition
-} from "./chunk-2SNY75AR.js";
 
 // ../composition/src/ops/compositionOps.shared.ts
 function findOrCreateTrackByKind(composition, kind) {

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

@@ -4,7 +4,7 @@ import {
   Format,
   GraphicRole,
   OpaqueId
-} from "./chunk-2SNY75AR.js";
+} from "./chunk-7KEUL3FI.js";
 
 // ../composition/src/validators/composePlan.ts
 import { z } from "zod";
@@ -92,17 +92,23 @@ var AudioPaletteRef = z2.string().min(1);
 var FontRef = z2.union([
   z2.object({
     kind: z2.literal("system"),
-    family: z2.string().min(1)
+    family: z2.string().min(1),
+    weight: z2.number().int().min(1).max(1e3).optional(),
+    style: z2.enum(["normal", "italic"]).optional()
   }),
   z2.object({
     kind: z2.literal("web"),
     family: z2.string().min(1),
-    url: z2.string().url().optional()
+    url: z2.string().url().optional(),
+    weight: z2.number().int().min(1).max(1e3).optional(),
+    style: z2.enum(["normal", "italic"]).optional()
   }),
   z2.object({
     kind: z2.literal("uploaded"),
     fontId: OpaqueId,
-    family: z2.string().optional()
+    family: z2.string().optional(),
+    weight: z2.number().int().min(1).max(1e3).optional(),
+    style: z2.enum(["normal", "italic"]).optional()
   })
 ]);
 var Colors = z2.object({