@cueframe/kernel 0.1.4 → 0.2.0

package/dist/chunk-IJ7PVJTK.js

@@ -0,0 +1,114 @@
+import {
+  CueframeError
+} from "./chunk-4FOOBSEE.js";
+
+// ../execution/render-harness/src/cardAssetAdmission.ts
+import { parse as parseCss, walk as walkCss } from "css-tree";
+import { parseFragment } from "parse5";
+var RESOURCE_ELEMENTS = /* @__PURE__ */ new Set([
+  "audio",
+  "embed",
+  "iframe",
+  "image",
+  "img",
+  "link",
+  "object",
+  "script",
+  "source",
+  "track",
+  "video"
+]);
+var URL_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "action",
+  "data",
+  "formaction",
+  "href",
+  "poster",
+  "src",
+  "srcset",
+  "xlink:href"
+]);
+var CSS_VALUE_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "clip-path",
+  "cursor",
+  "fill",
+  "filter",
+  "marker",
+  "marker-end",
+  "marker-mid",
+  "marker-start",
+  "mask",
+  "stroke"
+]);
+function isFragmentReference(value) {
+  return value.trim().startsWith("#");
+}
+function refuse(locator, reason) {
+  throw new CueframeError(
+    "card_external_asset_forbidden",
+    `Card ${locator} ${reason}`,
+    void 0,
+    { card: locator }
+  );
+}
+function assertCssAssetFree(css, context, locator) {
+  let ast;
+  try {
+    ast = parseCss(css, { context });
+  } catch (cause) {
+    refuse(locator, `contains invalid CSS: ${String(cause)}`);
+  }
+  walkCss(ast, (node) => {
+    if (node.type === "Url" && !isFragmentReference(node.value)) {
+      refuse(locator, "contains a CSS url() asset reference");
+    }
+    if (node.type === "Atrule" && ["import", "font-face"].includes(node.name.toLowerCase())) {
+      refuse(locator, `contains a forbidden CSS @${node.name} rule`);
+    }
+  });
+}
+function assertNodeAssetFree(node, locator) {
+  if ("tagName" in node) {
+    const tagName = node.tagName.toLowerCase();
+    if (RESOURCE_ELEMENTS.has(tagName)) {
+      refuse(locator, `contains resource-bearing <${tagName}> markup`);
+    }
+    for (const attr of node.attrs) {
+      const name = attr.name.toLowerCase();
+      if (name.startsWith("on")) {
+        refuse(locator, `contains executable event handler '${name}'`);
+      }
+      if (URL_ATTRIBUTES.has(name) && !isFragmentReference(attr.value)) {
+        refuse(locator, `contains an unmanifested ${name} asset reference`);
+      }
+      if (name === "style") assertCssAssetFree(attr.value, "declarationList", locator);
+      if (CSS_VALUE_ATTRIBUTES.has(name)) {
+        for (const match of attr.value.matchAll(/url\(\s*(['"]?)(.*?)\1\s*\)/gi)) {
+          if (!isFragmentReference(match[2] ?? "")) {
+            refuse(locator, `contains an unmanifested ${name} url() asset reference`);
+          }
+        }
+      }
+    }
+    if (tagName === "style" && "childNodes" in node) {
+      const css = node.childNodes.filter((child) => child.nodeName === "#text").map((child) => child.value).join("");
+      assertCssAssetFree(css, "stylesheet", locator);
+    }
+  }
+  if ("childNodes" in node) {
+    for (const child of node.childNodes) assertNodeAssetFree(child, locator);
+  }
+}
+function assertCardHtmlAssetFree(input) {
+  for (const overlay of input.overlays ?? []) {
+    if (overlay.template !== "card") continue;
+    const html = overlay.params?.html;
+    if (typeof html !== "string") continue;
+    const fragment = parseFragment(html);
+    for (const node of fragment.childNodes) assertNodeAssetFree(node, `overlay '${overlay.id}'`);
+  }
+}
+
+export {
+  assertCardHtmlAssetFree
+};

package/dist/{chunk-6ABIXGLO.js → chunk-KKEY5MIW.js}

@@ -17,6 +17,10 @@ import {
   staggerRise,
   staggerUp
 } from "./chunk-ZFEXATWN.js";
+import {
+  FitText,
+  resolveFitFontSize
+} from "./chunk-XHGZ2E77.js";
 import {
   ACCENT,
   ACCENT_STRONG,
@@ -31,10 +35,6 @@ import {
   VIOLET,
   WARNING
 } from "./chunk-CX2IIQ4R.js";
-import {
-  FitText,
-  resolveFitFontSize
-} from "./chunk-XHGZ2E77.js";
 
 // ../execution/primitives/src/text/blur-reveal/index.tsx
 import { interpolate, useCurrentFrame, useVideoConfig } from "remotion";
@@ -1986,7 +1986,7 @@ var paramsSchema2 = z2.object({
     "Visual variant. default: letterboxed fade with letter-spacing tighten. bold: heavier weight + spring entrance. zoom: scale-from-blur with overshoot."
   ),
   position: z2.enum(["center", "top", "bottom"]).default("center").describe("Vertical position of the title block."),
-  tokens: tokensSchema.default({}).describe("Visual tokens. fontFamily, fontSize, textColor, accentColor, letterSpacing.")
+  tokens: tokensSchema.prefault({}).describe("Visual tokens. fontFamily, fontSize, textColor, accentColor, letterSpacing.")
 }).passthrough();
 var config2 = {
   id: "cinematic-title",
@@ -2113,7 +2113,7 @@ var paramsSchema4 = z4.object({
     "Array of timed words. Each word has text + startMs/endMs in milliseconds relative to the clip start. Source from the transcript."
   ),
   position: z4.enum(["center", "left", "right", "bottom"]).default("center").describe('Block position. "bottom" is canonical for caption-style overlays.'),
-  tokens: tokensSchema2.default({}).describe("Visual tokens. fontFamily, fontSize, textColor, activeColor, activeScale.")
+  tokens: tokensSchema2.prefault({}).describe("Visual tokens. fontFamily, fontSize, textColor, activeColor, activeScale.")
 }).passthrough();
 var config4 = {
   id: "karaoke",
@@ -2178,7 +2178,7 @@ var paramsSchema5 = z5.object({
   ),
   position: z5.enum(["center", "left", "right"]).default("center").describe("Horizontal alignment of the word block."),
   accentColor: z5.string().default(ACCENT).describe("Accent for the payoff (last) word. Empty string disables."),
-  tokens: tokensSchema3.default({}).describe("Visual tokens. fontFamily, fontSize, textColor.")
+  tokens: tokensSchema3.prefault({}).describe("Visual tokens. fontFamily, fontSize, textColor.")
 }).passthrough();
 var config5 = {
   id: "kinetic-type",
@@ -2244,7 +2244,7 @@ var paramsSchema6 = z6.object({
   variant: z6.enum(["classic", "modern", "cinematic"]).default("classic").describe(
     "Visual variant. classic: split accent + dark sub bar. modern: full accent rounded bg. cinematic: borderLeft accent + translucent dark."
   ),
-  tokens: tokensSchema4.default({}).describe("Visual tokens. fontFamily, fontSize, subtitleFontSize, textColor, accentColor, backgroundColor.")
+  tokens: tokensSchema4.prefault({}).describe("Visual tokens. fontFamily, fontSize, subtitleFontSize, textColor, accentColor, backgroundColor.")
 }).passthrough();
 var config6 = {
   id: "lower-third",

package/dist/{chunk-7TQCR7AB.js → chunk-LNBVTDFR.js}

@@ -1,7 +1,7 @@
 import {
   CueframeError,
   encodeError
-} from "./chunk-R5BMJ2NX.js";
+} from "./chunk-4FOOBSEE.js";
 
 // ../execution/core/src/render/vcam/constants.ts
 var P_MIN = 0.5;

package/dist/chunk-LQUWKBST.js

@@ -0,0 +1,195 @@
+// ../execution/component-runtime/src/contracts.ts
+import { z } from "zod";
+var COMPONENT_SOURCE_VERSION = 2;
+var COMPONENT_BUNDLE_VERSION = 2;
+var COMPONENT_RECEIPT_VERSION = 2;
+var ComponentAssetKind = z.enum(["image", "video", "audio", "data"]);
+var ComponentAssetDeclarationV2 = z.object({
+  kind: ComponentAssetKind,
+  required: z.boolean(),
+  mimeTypes: z.array(z.string().min(1)).min(1).optional()
+}).strict();
+var ComponentGraphicsRequirementV2 = z.object({
+  api: z.enum(["canvas2d", "webgpu"]),
+  required: z.literal(true),
+  accelerationPreference: z.enum(["hardware-preferred", "software-allowed"])
+}).strict();
+var ComponentManifestV2 = z.object({
+  version: z.literal(COMPONENT_SOURCE_VERSION),
+  assets: z.record(z.string().min(1), ComponentAssetDeclarationV2),
+  graphics: ComponentGraphicsRequirementV2,
+  alphaPolicy: z.enum(["requires-transparency", "allows-opaque"])
+}).strict();
+var CANVAS2D_COMPONENT_MANIFEST_V2 = Object.freeze({
+  version: COMPONENT_SOURCE_VERSION,
+  assets: Object.freeze({}),
+  graphics: Object.freeze({
+    api: "canvas2d",
+    required: true,
+    accelerationPreference: "software-allowed"
+  }),
+  alphaPolicy: "requires-transparency"
+});
+var ComponentSourceV2 = z.object({
+  version: z.literal(COMPONENT_SOURCE_VERSION),
+  componentId: z.string().min(1).max(128).regex(/^[a-z0-9][a-z0-9._-]*$/),
+  tsxSource: z.string().min(1),
+  manifest: ComponentManifestV2
+}).strict();
+var ComponentAssetBindingV2 = z.object({
+  handle: z.string().min(1).max(256),
+  kind: ComponentAssetKind,
+  mimeType: z.string().min(1),
+  contentSha256: z.string().regex(/^[a-f0-9]{64}$/),
+  width: z.number().int().positive().optional(),
+  height: z.number().int().positive().optional(),
+  durationSec: z.number().positive().optional()
+}).strict();
+var ComponentAssetInputV2 = z.object({
+  handle: z.string().min(1).max(256),
+  kind: ComponentAssetKind,
+  mimeType: z.string().min(1),
+  width: z.number().int().positive().optional(),
+  height: z.number().int().positive().optional(),
+  durationSec: z.number().positive().optional()
+}).strict();
+var ComponentAssetFileV2 = z.object({
+  path: z.string().min(1)
+}).strict();
+var ComponentBundleV2 = z.object({
+  version: z.literal(COMPONENT_BUNDLE_VERSION),
+  bundleId: z.string().regex(/^[a-f0-9]{64}$/),
+  sourceVersionId: z.string().regex(/^[a-f0-9]{64}$/),
+  runtimeDigest: z.string().min(1),
+  dependencyLockDigest: z.string().regex(/^[a-f0-9]{64}$/),
+  entrypoint: z.string().min(1),
+  manifest: ComponentManifestV2
+}).strict();
+var ComponentRenderRequestV2 = z.object({
+  version: z.literal(COMPONENT_RECEIPT_VERSION),
+  bundleId: z.string().regex(/^[a-f0-9]{64}$/),
+  params: z.record(z.string(), z.unknown()),
+  assets: z.record(z.string().min(1), ComponentAssetBindingV2),
+  width: z.number().int().positive(),
+  height: z.number().int().positive(),
+  fps: z.number().positive(),
+  durationInFrames: z.number().int().positive(),
+  alpha: z.boolean(),
+  graphics: ComponentGraphicsRequirementV2,
+  seed: z.string().min(1)
+}).strict();
+var ComponentBakeRequestV2 = z.object({
+  version: z.literal(COMPONENT_RECEIPT_VERSION),
+  source: ComponentSourceV2,
+  params: z.record(z.string(), z.unknown()),
+  assets: z.record(z.string().min(1), ComponentAssetBindingV2),
+  width: z.number().int().positive(),
+  height: z.number().int().positive(),
+  fps: z.number().positive(),
+  durationInFrames: z.number().int().positive(),
+  codec: z.enum(["vp9", "prores"]),
+  runtimeDigest: z.string().min(1),
+  dependencyLockDigest: z.string().regex(/^[a-f0-9]{64}$/),
+  seed: z.string().min(1)
+}).strict();
+var ComponentBakeJobV2 = z.object({
+  version: z.literal(COMPONENT_RECEIPT_VERSION),
+  source: ComponentSourceV2,
+  params: z.record(z.string(), z.unknown()),
+  assets: z.record(z.string().min(1), ComponentAssetInputV2),
+  assetFiles: z.record(z.string().min(1), ComponentAssetFileV2),
+  width: z.number().int().positive(),
+  height: z.number().int().positive(),
+  fps: z.number().positive(),
+  durationInFrames: z.number().int().positive(),
+  codec: z.enum(["vp9", "prores"]),
+  runtimeDigest: z.string().min(1),
+  dependencyLockDigest: z.string().regex(/^[a-f0-9]{64}$/),
+  seed: z.string().min(1)
+}).strict();
+var ComponentGraphicsActualV2 = z.object({
+  api: z.enum(["canvas2d", "webgpu"]),
+  acceleration: z.enum(["hardware", "software"]),
+  adapterName: z.string().min(1).optional(),
+  deviceLost: z.literal(false)
+}).strict();
+var ComponentRenderReceiptV2 = z.object({
+  version: z.literal(COMPONENT_RECEIPT_VERSION),
+  artifactId: z.string().regex(/^[a-f0-9]{64}$/),
+  renderKey: z.string().regex(/^[a-f0-9]{64}$/),
+  bundleId: z.string().regex(/^[a-f0-9]{64}$/),
+  sourceVersionId: z.string().regex(/^[a-f0-9]{64}$/),
+  runtimeDigest: z.string().min(1),
+  outputSha256: z.string().regex(/^[a-f0-9]{64}$/),
+  outputBytes: z.number().int().positive(),
+  codec: z.enum(["png", "vp9", "prores"]),
+  width: z.number().int().positive(),
+  height: z.number().int().positive(),
+  fps: z.number().positive(),
+  durationInFrames: z.number().int().positive(),
+  alpha: z.boolean(),
+  requestedGraphics: ComponentGraphicsRequirementV2,
+  actualGraphics: ComponentGraphicsActualV2
+}).strict();
+var COMPONENT_RUNTIME_ERROR_CODES = [
+  "invalid_component_source",
+  "unsupported_runtime_version",
+  "component_does_not_compile",
+  "component_runtime_error",
+  "component_deadline_exceeded",
+  "component_resource_exhausted",
+  "component_asset_undeclared",
+  "component_asset_unavailable",
+  "component_asset_integrity_failed",
+  "component_network_denied",
+  "component_import_denied",
+  "component_graphics_unavailable",
+  "component_graphics_mismatch",
+  "component_device_lost",
+  "component_output_invalid",
+  "component_conflict"
+];
+var ComponentRuntimeErrorCode = z.enum(COMPONENT_RUNTIME_ERROR_CODES);
+var ComponentRuntimeError = class extends Error {
+  code;
+  retryable;
+  constructor(code, message, options) {
+    super(message, options?.cause === void 0 ? void 0 : { cause: options.cause });
+    this.name = "ComponentRuntimeError";
+    this.code = code;
+    this.retryable = options?.retryable ?? false;
+  }
+};
+function assertGraphicsReceiptMatches(request, receipt) {
+  if (receipt.requestedGraphics.api !== request.graphics.api || receipt.requestedGraphics.required !== request.graphics.required || receipt.requestedGraphics.accelerationPreference !== request.graphics.accelerationPreference) {
+    throw new ComponentRuntimeError("component_graphics_mismatch", "Graphics receipt does not match the render request.");
+  }
+  if (receipt.actualGraphics.api !== request.graphics.api || receipt.actualGraphics.deviceLost) {
+    throw new ComponentRuntimeError("component_graphics_mismatch", "Rendered graphics backend does not satisfy the component requirement.");
+  }
+}
+
+export {
+  COMPONENT_SOURCE_VERSION,
+  COMPONENT_BUNDLE_VERSION,
+  COMPONENT_RECEIPT_VERSION,
+  ComponentAssetKind,
+  ComponentAssetDeclarationV2,
+  ComponentGraphicsRequirementV2,
+  ComponentManifestV2,
+  CANVAS2D_COMPONENT_MANIFEST_V2,
+  ComponentSourceV2,
+  ComponentAssetBindingV2,
+  ComponentAssetInputV2,
+  ComponentAssetFileV2,
+  ComponentBundleV2,
+  ComponentRenderRequestV2,
+  ComponentBakeRequestV2,
+  ComponentBakeJobV2,
+  ComponentGraphicsActualV2,
+  ComponentRenderReceiptV2,
+  COMPONENT_RUNTIME_ERROR_CODES,
+  ComponentRuntimeErrorCode,
+  ComponentRuntimeError,
+  assertGraphicsReceiptMatches
+};

package/dist/chunk-M2TLRXEO.js

@@ -0,0 +1,41 @@
+import {
+  componentArtifactIdentity,
+  componentBundleIdentity,
+  componentRenderIdentity,
+  sourceVersionIdentity
+} from "./chunk-DHKQ47Q6.js";
+
+// ../execution/component-runtime/src/identity.ts
+import { createHash } from "crypto";
+function sha256Hex(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function sourceVersionId(source) {
+  return sha256Hex(sourceVersionIdentity(source));
+}
+function componentBundleId(input) {
+  return sha256Hex(componentBundleIdentity(input));
+}
+function componentRenderKey(request) {
+  return sha256Hex(componentRenderIdentity(request));
+}
+function componentArtifactId(input) {
+  return sha256Hex(componentArtifactIdentity(input));
+}
+function bundleIdentityFields(bundle) {
+  return {
+    bundleId: bundle.bundleId,
+    sourceVersionId: bundle.sourceVersionId,
+    runtimeDigest: bundle.runtimeDigest,
+    dependencyLockDigest: bundle.dependencyLockDigest
+  };
+}
+
+export {
+  sha256Hex,
+  sourceVersionId,
+  componentBundleId,
+  componentRenderKey,
+  componentArtifactId,
+  bundleIdentityFields
+};

package/dist/{chunk-7V3F5HO4.js → chunk-NOEBAV2G.js}

@@ -5,7 +5,7 @@ import {
   isOk,
   opById,
   safeParse
-} from "./chunk-RQ2G4DXI.js";
+} from "./chunk-QBKDEO7J.js";
 
 // ../mcp/src/wait.ts
 var defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
@@ -396,6 +396,62 @@ async function waitForJob(ex, kind, id, projectId, deadline, deps = {}) {
   };
 }
 
+// ../mcp/src/query.ts
+import { z } from "zod";
+var QUERY_SAFE_RESERVED = /%3A|%2F|%3F|%40|%21|%24|%27|%28|%29|%2A|%2C|%3B|%3D/gi;
+function encode(value, allowReserved) {
+  const encoded = encodeURIComponent(String(value));
+  return allowReserved ? encoded.replace(QUERY_SAFE_RESERVED, (part) => String.fromCharCode(Number.parseInt(part.slice(1), 16))) : encoded;
+}
+function querySchemaShape(parameters, defaults = {}) {
+  const shape = {};
+  for (const parameter of parameters) {
+    const jsonSchema = Object.hasOwn(defaults, parameter.name) ? { ...parameter.schema, default: defaults[parameter.name] } : parameter.schema;
+    let schema = z.fromJSONSchema(jsonSchema);
+    if (parameter.description) schema = schema.describe(parameter.description);
+    shape[parameter.name] = parameter.required ? schema : schema.optional();
+  }
+  return shape;
+}
+function appendObject(pairs, parameter, value) {
+  const entries = Object.entries(value).filter(([, item]) => item !== void 0 && item !== null);
+  if (parameter.explode) {
+    for (const [key, item] of entries) {
+      pairs.push(`${encode(key, parameter.allowReserved)}=${encode(item, parameter.allowReserved)}`);
+    }
+    return;
+  }
+  const flattened = entries.flatMap(([key, item]) => [key, item]);
+  pairs.push(
+    `${encode(parameter.name, false)}=${flattened.map((item) => encode(item, parameter.allowReserved)).join(",")}`
+  );
+}
+function serializeQuery(parameters, args) {
+  const pairs = [];
+  for (const parameter of parameters) {
+    const value = args[parameter.name];
+    if (value === void 0 || value === null || value === "") continue;
+    if (Array.isArray(value)) {
+      if (parameter.explode) {
+        for (const item of value) {
+          pairs.push(`${encode(parameter.name, false)}=${encode(item, parameter.allowReserved)}`);
+        }
+      } else {
+        pairs.push(
+          `${encode(parameter.name, false)}=${value.map((item) => encode(item, parameter.allowReserved)).join(",")}`
+        );
+      }
+    } else if (typeof value === "object") {
+      appendObject(pairs, parameter, value);
+    } else {
+      pairs.push(`${encode(parameter.name, false)}=${encode(value, parameter.allowReserved)}`);
+    }
+  }
+  return pairs.length > 0 ? pairs.join("&") : void 0;
+}
+
 export {
-  waitForJob
+  waitForJob,
+  querySchemaShape,
+  serializeQuery
 };