@cueframe/kernel 0.1.4 → 0.2.1

package/dist/chunk-KU376ELE.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-2PGLNTB7.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-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
+};