@cueframe/kernel 0.2.2 → 0.2.4

package/dist/{chunk-CX2IIQ4R.js → chunk-W2245F6G.js}

@@ -39,36 +39,36 @@ __export(palette_exports, {
   VIOLET: () => VIOLET,
   WARNING: () => WARNING
 });
-var BG_DEEP = "#0f0b07";
-var BG = "#14100c";
-var SURFACE = "#1c1611";
-var SURFACE_HI = "#241d16";
-var BORDER = "#2e2620";
-var BORDER_SOFT = "rgba(244,236,224,0.10)";
-var BORDER_STRONG = "#3a3128";
-var TEXT_HI = "#f4ece0";
-var TEXT = "#e4dccf";
-var TEXT_MUTED = "#b8a894";
-var TEXT_FAINT = "#7a6f63";
-var ACCENT = "#f2913c";
-var ACCENT_STRONG = "#e8782b";
-var ACCENT_DEEP = "#b0501c";
-var ACCENT_SOFT = "#ffb38e";
-var SUCCESS = "#7fae7a";
-var SUCCESS_SOFT = "#a7c8a1";
-var DANGER = "#d1685e";
-var WARNING = "#e0a355";
-var BLUE = "#7b93b0";
-var VIOLET = "#9b8bb0";
-var TEAL = "#5fa5a0";
+var BG_DEEP = "#050507";
+var BG = "#0b0b0e";
+var SURFACE = "#141418";
+var SURFACE_HI = "#1b1b1f";
+var BORDER = "#26262e";
+var BORDER_SOFT = "rgba(255,255,255,0.08)";
+var BORDER_STRONG = "#34343e";
+var TEXT_HI = "#F5F5F7";
+var TEXT = "#e4e4e9";
+var TEXT_MUTED = "#9b9ba6";
+var TEXT_FAINT = "#62626d";
+var ACCENT = "#6f7dff";
+var ACCENT_STRONG = "#5566f2";
+var ACCENT_DEEP = "#3d4ac7";
+var ACCENT_SOFT = "#a7b0ff";
+var SUCCESS = "#5ec48a";
+var SUCCESS_SOFT = "#9ddcb8";
+var DANGER = "#ef6a5e";
+var WARNING = "#e9b84a";
+var BLUE = "#6aa6ff";
+var VIOLET = "#a48cff";
+var TEAL = "#4fc8c4";
 var SERIES = [ACCENT, TEAL, BLUE, VIOLET, SUCCESS, WARNING];
-var SYN_TEXT = "#e4dccf";
-var SYN_COMMENT = "#7a6f63";
-var SYN_KEYWORD = "#c99ac0";
-var SYN_STRING = "#9cb887";
-var SYN_NUMBER = "#dcae6a";
-var SYN_FN = "#e8934f";
-var SYN_PROP = "#7fa8b0";
+var SYN_TEXT = "#e4e4e9";
+var SYN_COMMENT = "#62626d";
+var SYN_KEYWORD = "#c792ea";
+var SYN_STRING = "#9ece6a";
+var SYN_NUMBER = "#f0b46a";
+var SYN_FN = "#82aaff";
+var SYN_PROP = "#7dcfff";
 var MAC_RED = "#ff5f57";
 var MAC_YELLOW = "#febc2e";
 var MAC_GREEN = "#28c840";

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

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

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

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

package/dist/chunk-WIHXXF3X.js

@@ -0,0 +1,221 @@
+import {
+  ComponentHostAttestationV2,
+  ComponentRuntimeError
+} from "./chunk-ZVG446DJ.js";
+import {
+  STUDIO_SHADOW_MAP_BUDGET
+} from "./chunk-MH3UPKWR.js";
+
+// ../execution/component-runtime/src/webglProbe.ts
+var FEATURE_OFF = /(^|_)off(?:_ok)?$|^(?:unavailable|disabled)$/;
+var HALF_FLOAT_COLOR_TARGET_EXTENSIONS = ["EXT_color_buffer_half_float", "EXT_color_buffer_float"];
+function opensProbePage(browser) {
+  return typeof browser.newPage === "function";
+}
+function readWebGlLimitsInPage() {
+  const globals = globalThis;
+  const gl = globals.document.createElement("canvas").getContext("webgl2");
+  if (!gl) return null;
+  let halfFloatColorTarget = null;
+  for (const name of ["EXT_color_buffer_half_float", "EXT_color_buffer_float"]) {
+    if (gl.getExtension(name)) {
+      halfFloatColorTarget = name;
+      break;
+    }
+  }
+  return { maxTextureSize: gl.getParameter(gl.MAX_TEXTURE_SIZE), halfFloatColorTarget };
+}
+async function readGpuAttestation(browser) {
+  const result = await browser.connection.send("SystemInfo.getInfo");
+  const gpu = result?.value?.gpu;
+  const aux = gpu?.auxAttributes ?? {};
+  const identityFacts = Object.fromEntries(
+    Object.entries({
+      devices: gpu?.devices,
+      driverVendor: aux.driverVendor,
+      driverVersion: aux.driverVersion,
+      glRenderer: aux.glRenderer,
+      glVendor: aux.glVendor,
+      glVersion: aux.glVersion,
+      machineModelName: aux.machineModelName,
+      machineModelVersion: aux.machineModelVersion
+    }).filter(([, value]) => value !== void 0 && value !== null && value !== "")
+  );
+  const hasDeviceOrDriverIdentity = Array.isArray(gpu?.devices) && gpu.devices.length > 0 || typeof aux.driverVendor === "string" && aux.driverVendor.length > 0 || typeof aux.driverVersion === "string" && aux.driverVersion.length > 0;
+  const canonicalJson = (value) => {
+    if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+    if (value !== null && typeof value === "object") {
+      const object = value;
+      return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(object[key])}`).join(",")}}`;
+    }
+    return JSON.stringify(value);
+  };
+  return {
+    renderer: typeof aux.glRenderer === "string" ? aux.glRenderer : "",
+    featureStatus: gpu?.featureStatus ?? {},
+    gpuIdentity: hasDeviceOrDriverIdentity ? canonicalJson(identityFacts) : null
+  };
+}
+async function readWebGlAttestation(browser) {
+  if (!opensProbePage(browser)) {
+    throw new Error(
+      "WebGL admission needs a browser handle that can open a page: MAX_TEXTURE_SIZE and the half-float colour extensions exist only inside a GL context, and this handle exposes no newPage()."
+    );
+  }
+  const attestation = await readGpuAttestation(browser);
+  const page = await browser.newPage({
+    context: () => null,
+    logLevel: "error",
+    indent: false,
+    pageIndex: 0,
+    onBrowserLog: null,
+    onLog: () => void 0
+  });
+  let limits;
+  try {
+    limits = await page.evaluate(readWebGlLimitsInPage);
+  } catch (probeError) {
+    await page.close().catch((closeError) => {
+      if (probeError instanceof Error && probeError.cause === void 0) {
+        probeError.cause = closeError;
+        return;
+      }
+      process.stderr.write(
+        `[webgl-probe] the probe page failed to close after a failed limit read, and the failure could not be attached to the probe error (${probeError instanceof Error ? "it already carries a cause" : `it is a ${typeof probeError}, not an Error`}): ${closeError instanceof Error ? closeError.stack ?? closeError.message : String(closeError)}
+`
+      );
+    });
+    throw probeError;
+  }
+  await page.close();
+  return {
+    ...attestation,
+    maxTextureSize: limits === null ? null : limits.maxTextureSize,
+    halfFloatColorTarget: limits === null ? null : limits.halfFloatColorTarget
+  };
+}
+function webGlRefusal(attestation, policy = {}) {
+  const webgl = attestation.featureStatus?.webgl;
+  const renderer = attestation.renderer || "unknown";
+  const backend = policy.backend || "the default backend";
+  if (typeof webgl !== "string" || FEATURE_OFF.test(webgl)) {
+    return `WebGL is unavailable in the staged browser (webgl=${typeof webgl === "string" && webgl ? webgl : "unknown"}, renderer=${renderer}); the scene shot cannot be captured. Launch the browser with a GL backend that provides WebGL (${backend} on this host).`;
+  }
+  if (policy.hardware && /software/i.test(webgl)) {
+    return `WebGL runs in software (webgl=${webgl}, renderer=${renderer}) but CUEFRAME_RENDER_ACCELERATION=hardware forbids software rendering.`;
+  }
+  if (attestation.maxTextureSize === null) {
+    return `The staged browser attests WebGL (webgl=${webgl}, renderer=${renderer}) but a page in it could not create a WebGL2 context, so its MAX_TEXTURE_SIZE could not be read; the scene renderer needs WebGL2. Launch the browser with a GL backend that provides WebGL2 (${backend} on this host).`;
+  }
+  if (attestation.maxTextureSize < STUDIO_SHADOW_MAP_BUDGET) {
+    return `The staged browser reports MAX_TEXTURE_SIZE ${attestation.maxTextureSize} (renderer=${renderer}), below the ${STUDIO_SHADOW_MAP_BUDGET}-texel shadow map the scene renderer may allocate; the shot cannot be captured at the density it is authored for. Render this scene shot on a host whose GL backend reports at least ${STUDIO_SHADOW_MAP_BUDGET} (${backend} on this host reports ${attestation.maxTextureSize}).`;
+  }
+  if (attestation.halfFloatColorTarget === null) {
+    return `A page in the staged browser (webgl=${webgl}, renderer=${renderer}) grants neither ${HALF_FLOAT_COLOR_TARGET_EXTENSIONS.join(" nor ")}, so it cannot render into the half-float colour target every scene shot's world is composed through; the shot cannot be captured without posterizing the dark end of every gradient in it. Render this scene shot on a host whose GL backend grants one of them (${backend} on this host grants neither).`;
+  }
+  return null;
+}
+function admittedHost(attestation, policy = {}) {
+  return {
+    webgl: attestation.featureStatus?.webgl ?? "unknown",
+    renderer: attestation.renderer,
+    maxTextureSize: attestation.maxTextureSize,
+    halfFloatColorTarget: attestation.halfFloatColorTarget,
+    glBackend: policy.backend || "default"
+  };
+}
+
+// ../execution/component-runtime/src/browserOptions.ts
+function componentBrowserOptions(graphics, browserExecutable, chromeMode) {
+  const backend = componentBrowserBackend(graphics);
+  if (chromeMode === "headless-shell" && backend.chromiumOptions.headless === false) {
+    throw new ComponentRuntimeError(
+      "component_graphics_unavailable",
+      "Linux presenting capture requires the staged full Chrome browser; headless-shell cannot run this non-headless lane."
+    );
+  }
+  return { browserExecutable, chromeMode, ...backend };
+}
+function componentBrowserBackend(graphics) {
+  const hardware = process.env.CUEFRAME_RENDER_ACCELERATION === "hardware";
+  if (graphics.api === "webgl") {
+    return {
+      chromiumOptions: { gl: webglBackend(process.platform, hardware) }
+    };
+  }
+  if (process.platform === "linux" && (graphics.api === "webgpu" || graphics.api === "webgl2" || hardware)) {
+    if (!process.env.DISPLAY) {
+      throw new ComponentRuntimeError(
+        "component_graphics_unavailable",
+        "Linux presenting capture requires a display. Run the component renderer under Xvfb or an X11 session."
+      );
+    }
+    return {
+      chromiumOptions: {
+        gl: "vulkan",
+        headless: false,
+        enableMultiProcessOnLinux: true
+      }
+    };
+  }
+  if (hardware || graphics.api === "webgl2" || process.platform === "darwin") {
+    return {
+      chromiumOptions: { gl: "angle" }
+    };
+  }
+  return {
+    chromiumOptions: { gl: "swangle" }
+  };
+}
+function webglBackend(platform, hardware) {
+  if (platform !== "linux") return "angle";
+  return hardware ? "angle-egl" : "swangle";
+}
+function resolvedComponentRenderer(graphics, sceneShot) {
+  return {
+    glBackend: componentBrowserBackend(graphics).chromiumOptions.gl,
+    colorPipeline: "srgb",
+    sceneShot: sceneShot ?? null
+  };
+}
+async function assertComponentBrowserHardware(browser, graphics) {
+  const hardware = process.env.CUEFRAME_RENDER_ACCELERATION === "hardware";
+  const needsWebGl = graphics?.api === "webgl";
+  if (!hardware && !needsWebGl) return null;
+  let host = null;
+  let renderer;
+  let status;
+  if (needsWebGl) {
+    const policy = { backend: webglBackend(process.platform, hardware), hardware };
+    const attestation = await readWebGlAttestation(browser);
+    const refusal = webGlRefusal(attestation, policy);
+    if (refusal) throw new ComponentRuntimeError("component_graphics_unavailable", refusal);
+    host = ComponentHostAttestationV2.parse(admittedHost(attestation, policy));
+    ({ renderer, featureStatus: status } = attestation);
+  } else {
+    ({ renderer, featureStatus: status } = await readGpuAttestation(browser));
+  }
+  if (!hardware) return host;
+  const compositing = status.gpu_compositing;
+  if (!renderer || /swiftshader|llvmpipe|lavapipe|software/i.test(renderer) || compositing !== "enabled") {
+    throw new ComponentRuntimeError(
+      "component_graphics_unavailable",
+      `Hardware capture requires an accelerated compositor; renderer=${renderer || "unknown"}, gpu_compositing=${compositing || "unknown"}.`
+    );
+  }
+  return host;
+}
+
+export {
+  HALF_FLOAT_COLOR_TARGET_EXTENSIONS,
+  readWebGlLimitsInPage,
+  readGpuAttestation,
+  readWebGlAttestation,
+  webGlRefusal,
+  admittedHost,
+  componentBrowserOptions,
+  componentBrowserBackend,
+  webglBackend,
+  resolvedComponentRenderer,
+  assertComponentBrowserHardware
+};

package/dist/{chunk-7KEUL3FI.js → chunk-XF2QMKRG.js}

@@ -1,6 +1,9 @@
 import {
   Reframe
 } from "./chunk-2B5VJZHL.js";
+import {
+  captionFaceIssues
+} from "./chunk-TARKDVP6.js";
 
 // ../composition/src/validators/opaqueId.ts
 import { z } from "zod";
@@ -265,7 +268,12 @@ var CompositionCaptions = z2.discriminatedUnion("source", [
     style: CaptionStyle.optional(),
     zPlane: CaptionDepth
   })
-]);
+]).superRefine((captions, ctx) => {
+  if (!captions.style) return;
+  for (const issue of captionFaceIssues(captions.style)) {
+    ctx.addIssue({ code: "custom", path: ["style", issue.field], message: issue.message });
+  }
+});
 function captionsAreBehindSubject(captions) {
   return captions?.zPlane === "behind-subject";
 }

package/dist/{chunk-HFC3MKXA.js → chunk-Y4HPN4BC.js}

@@ -297,6 +297,7 @@ var TOOLKIT_REFERENCE = `- \`interpolate(frame, inputRange, outputRange, { easin
 - Noise: \`noise2D(seed, x, y)\`, \`noise3D\`, \`noise4D\` \u2014 organic motion
 - Effects: \`<Trail>\`, \`<CameraMotionBlur>\`
 - Layout: \`<AbsoluteFill>\`, \`<Sequence>\`, \`<Img>\`
+- Multi-cell layout that reflows: \`<FlexLayout tracks={[\u2026]} tracksEnd={[\u2026]} fits={[\u2026]} width={R.w*width} height={R.h*height}>\` from \`@cueframe/animate\` \u2014 tracks are weights (\`{ weight: 0, basis: px }\` is content-sized and pushes its neighbours), children fill the cells depth-first, weights ease across the clip and every cell re-solves per frame; \`fits\` per cell: stretch | contain | cover | position | scale | matte. \`solveFlex\` / \`fitBox\` / \`flexBoxToThree\` for custom or 3D placement (one \`<ThreeCanvas orthographic>\` pinned 1:1 to pixels). Never CSS-scale it \u2014 size the container.
 - Fonts: FONTS.inter, .montserrat, .poppins, .roboto, .oswald, .playfairDisplay, .bebasNeue, .spaceMono, .instrumentSerif, .nationalPark`;
 var DESIGN_QUALITY_RULES = `Good motion graphics have:
 - **Layered composition**: Multiple animated elements (text + accent line + shape + bg glow) with staggered timing, not just a single text fade