@field/cascade 0.11.0 → 0.13.0

package/dist/cli/{render-YURAPPUI.js → render-Y23W6MY6.js}

@@ -1,48 +1,50 @@
 import {
   runGraph
-} from "./chunk-DUIUFVU2.js";
-import "./chunk-4UDFYF5G.js";
-import "./chunk-QBBKRNGY.js";
+} from "./chunk-OBZAP3GG.js";
 import "./chunk-2KXB47FP.js";
+import "./chunk-EZRWJ4G2.js";
 import {
   parseFrameSpec
 } from "./chunk-BP7UKF36.js";
+import "./chunk-RUU3YWXU.js";
 import {
   encodeSequence,
   frameSequences,
   hasFfmpeg,
   timelineFrameSpec
-} from "./chunk-YAT5Y25U.js";
+} from "./chunk-7QE2ZNSN.js";
 import {
   parseEnvArgs
 } from "./chunk-ZL4JTG5Y.js";
-import "./chunk-RUU3YWXU.js";
-import "./chunk-MIIEFUGG.js";
-import "./chunk-WPUDGEFY.js";
-import "./chunk-VVGSLVSF.js";
-import "./chunk-WD62JIP6.js";
-import "./chunk-EUIAC3U3.js";
-import "./chunk-36P5K3SD.js";
-import "./chunk-D6BUOHUG.js";
+import "./chunk-QKL7CCRS.js";
+import "./chunk-MI5JLQYA.js";
+import "./chunk-GRIN2DDP.js";
+import "./chunk-X4WKAOQP.js";
+import "./chunk-DEQSEFFH.js";
 import "./chunk-RXDIMXN5.js";
 import "./chunk-QQPA2ZHH.js";
 import "./chunk-KH4MUBKF.js";
-import "./chunk-35D343DC.js";
-import "./chunk-DEQSEFFH.js";
 import "./chunk-HSNOBIVT.js";
-import "./chunk-ICH7N5PN.js";
-import "./chunk-GFS6W3C5.js";
+import "./chunk-L6B6FUQP.js";
 import "./chunk-HFHWYL55.js";
+import "./chunk-KBGUO27Q.js";
+import "./chunk-ICH7N5PN.js";
 import {
   DEFAULT_FPS,
   frameRange
 } from "./chunk-CO22XHNG.js";
-import "./chunk-RQZ4SX5R.js";
-import "./chunk-A4OAMOZH.js";
+import "./chunk-LTXWBXOM.js";
+import "./chunk-BZ63XQ3I.js";
+import "./chunk-W7OUAT7J.js";
+import "./chunk-YH637PDL.js";
+import "./chunk-X566FWBV.js";
+import "./chunk-WD62JIP6.js";
+import "./chunk-5ORUQ6ES.js";
+import "./chunk-W5PJ5RMP.js";
+import "./chunk-NJFMDXHR.js";
 import "./chunk-J7VK7MNF.js";
-import "./chunk-XWDSKG7N.js";
-import "./chunk-BIJO5OFS.js";
-import "./chunk-WIH4TEIS.js";
+import "./chunk-FWMSGKEH.js";
+import "./chunk-JVOCK5W4.js";
 
 // src/cli/render.ts
 import { fork, spawn } from "node:child_process";
@@ -178,12 +180,17 @@ function parseRenderArgs(args) {
 function sharedOutputPaths(a, b) {
   const shared = [];
   for (const output of a.outputs) {
+    if (isContentNamed(output.source)) continue;
     if (b.outputs.some((other) => other.nodeId === output.nodeId && other.source === output.source)) {
       shared.push({ nodeId: output.nodeId, source: output.source });
     }
   }
   return shared;
 }
+function isContentNamed(source) {
+  const clean = source.split("\\").join("/");
+  return /(?:^|\/)\.cascade-cache\//.test(clean) && /^[^.]*\.[0-9a-f]{12}(?:\.[^/]*)?$/.test(path.posix.basename(clean));
+}
 function fixedPathMessage(shared, a, b) {
   const nodes = shared.map(({ nodeId, source }) => `"${nodeId}" (${source})`).join(", ");
   return `Cannot render in parallel: ${shared.length === 1 ? "node" : "nodes"} ${nodes} wrote frames ${a} and ${b} to the same file, so workers would overwrite each other's frames and the sequence would silently mix them up. Give the output a per-frame path: put the frame in the file name, or save through saveImage(canvas, cachePath(context.nodeId, ".png")) from cascade/io or the assets capability, which name files by their content. Or render with --workers 1.`;
@@ -433,4 +440,4 @@ export {
   runRenderWorker,
   sharedOutputPaths
 };
-//# sourceMappingURL=render-YURAPPUI.js.map
+//# sourceMappingURL=render-Y23W6MY6.js.map

package/dist/cli/{runCommand-PI764LEG.js → runCommand-XOG7AVC5.js}

@@ -155,7 +155,7 @@ async function runCommand(args) {
     process.exitCode = await superviseProcess(process.execPath, [...process.execArgv, process.argv[1], ...childArgs], ms);
     return;
   }
-  const { runGraph } = await import("./runner-RA6UKEPD.js");
+  const { runGraph } = await import("./runner-DNJO5WO2.js");
   try {
     if (options.json) console.log = console.error;
     await runGraph(options);
@@ -168,7 +168,7 @@ async function runCommand(args) {
   }
 }
 async function buildCommand(args) {
-  const { buildPlayer } = await import("./webBuild-GT4PZT5D.js");
+  const { buildPlayer } = await import("./webBuild-2K4COCGY.js");
   if (!args[1] || args[1].startsWith("-")) throw new Error("cascade build requires a graph file");
   let out;
   const assets = [];
@@ -195,4 +195,4 @@ export {
   buildCommand,
   runCommand
 };
-//# sourceMappingURL=runCommand-PI764LEG.js.map
+//# sourceMappingURL=runCommand-XOG7AVC5.js.map

package/dist/cli/runner-DNJO5WO2.js

@@ -0,0 +1,43 @@
+import {
+  RENDER_SUGGESTION_FRAMES,
+  renderSuggestion,
+  runGraph
+} from "./chunk-OBZAP3GG.js";
+import "./chunk-2KXB47FP.js";
+import "./chunk-EZRWJ4G2.js";
+import "./chunk-BP7UKF36.js";
+import "./chunk-RUU3YWXU.js";
+import "./chunk-7QE2ZNSN.js";
+import "./chunk-ZL4JTG5Y.js";
+import "./chunk-QKL7CCRS.js";
+import "./chunk-MI5JLQYA.js";
+import "./chunk-GRIN2DDP.js";
+import "./chunk-X4WKAOQP.js";
+import "./chunk-DEQSEFFH.js";
+import "./chunk-RXDIMXN5.js";
+import "./chunk-QQPA2ZHH.js";
+import "./chunk-KH4MUBKF.js";
+import "./chunk-HSNOBIVT.js";
+import "./chunk-L6B6FUQP.js";
+import "./chunk-HFHWYL55.js";
+import "./chunk-KBGUO27Q.js";
+import "./chunk-ICH7N5PN.js";
+import "./chunk-CO22XHNG.js";
+import "./chunk-LTXWBXOM.js";
+import "./chunk-BZ63XQ3I.js";
+import "./chunk-W7OUAT7J.js";
+import "./chunk-YH637PDL.js";
+import "./chunk-X566FWBV.js";
+import "./chunk-WD62JIP6.js";
+import "./chunk-5ORUQ6ES.js";
+import "./chunk-W5PJ5RMP.js";
+import "./chunk-NJFMDXHR.js";
+import "./chunk-J7VK7MNF.js";
+import "./chunk-FWMSGKEH.js";
+import "./chunk-JVOCK5W4.js";
+export {
+  RENDER_SUGGESTION_FRAMES,
+  renderSuggestion,
+  runGraph
+};
+//# sourceMappingURL=runner-DNJO5WO2.js.map

package/dist/cli/runtime/image.ts

@@ -44,6 +44,10 @@
  * copy are not always the same module instance.
  */
 
+import { canvasPixels, pixelsBitmap, type ImagePixels } from './io.js';
+
+export type { ImagePixels } from './io.js';
+
 /** An image port value. Mirrors Cascade's core `ImageRef`. */
 export interface ImageRef {
   path: string;
@@ -64,6 +68,14 @@ export interface ImageAssets {
     metadata: { mediaType?: string; suggestedName?: string },
     options: { signal: unknown },
   ): Promise<{ path: string; mediaType?: string }>;
+  /** Optional: store an intermediate from its pixels (see core `AssetCapability.keepImage`). */
+  keepImage?(
+    pixels: ImagePixels,
+    metadata: { suggestedName?: string },
+    options: { signal: unknown },
+  ): Promise<{ path: string; mediaType?: string }>;
+  /** Optional: the pixels behind a stored image while the host holds them in memory. */
+  imagePixels?(ref: { path: string }): ImagePixels | undefined;
 }
 
 /**
@@ -250,6 +262,9 @@ export async function readBytes(context: ImageNodeContext, ref: ImageSourceRef):
 
 /** Read and decode an image input, an asset, or a project file. */
 export async function readImage(context: ImageNodeContext, ref: ImageSourceRef): Promise<ImageBitmap> {
+  // An image the host still holds in memory skips the read and the decode.
+  const pixels = assetsOf(context).imagePixels?.(refOf(ref));
+  if (pixels) return pixelsBitmap(pixels);
   return decodeImage(await readBytes(context, ref));
 }
 
@@ -265,8 +280,18 @@ export async function writeImage(
   options: { type?: ImageType; quality?: number; space?: 'srgb' | 'linear' } = {},
 ): Promise<ImageRef> {
   const type = options.type ?? 'image/png';
-  const bytes = await encodeImage(canvas, { type, ...(options.quality === undefined ? {} : { quality: options.quality }) });
-  const stored = await assetsOf(context).write(bytes, { mediaType: type, suggestedName: name }, { signal: context.signal ?? NEVER });
+  const assets = assetsOf(context);
+  const signal = context.signal ?? NEVER;
+  // A PNG intermediate goes to the host as pixels when it can take them: a
+  // fast lossless write, or no encode at all until something needs the file.
+  const pixels = type === 'image/png' && assets.keepImage ? canvasPixels(canvas) : null;
+  const stored = pixels && assets.keepImage
+    ? await assets.keepImage(pixels, { suggestedName: name }, { signal })
+    : await assets.write(
+      await encodeImage(canvas, { type, ...(options.quality === undefined ? {} : { quality: options.quality }) }),
+      { mediaType: type, suggestedName: name },
+      { signal },
+    );
   return {
     path: stored.path,
     size: [canvas.width, canvas.height],

package/dist/cli/runtime/io.ts

@@ -51,6 +51,25 @@ export interface IoBridge {
   write(path: string, data: Uint8Array): Promise<string>;
   /** Host-owned display URL, valid until the host releases its stored asset. */
   url?(path: string, options?: MediaOptions): string;
+  /**
+   * Store an intermediate image from its pixels and return the stored path,
+   * as `write` would. Optional. The headless host has it: it writes a fast
+   * lossless PNG, and in a run that keeps pixels it holds them in memory and
+   * writes behind (`pixels` below). Without it `saveImage` encodes and writes.
+   */
+  keep?(path: string, pixels: ImagePixels): Promise<string>;
+  /** The pixels behind a path `keep` returned, while the host holds them. */
+  pixels?(path: string): ImagePixels | undefined;
+}
+
+/**
+ * An image's pixels in memory. Mirrors Cascade's core `ImagePixels`: 8-bit
+ * RGBA, sRGB, unpremultiplied, top row first — `ImageData`'s layout.
+ */
+export interface ImagePixels {
+  readonly width: number;
+  readonly height: number;
+  readonly data: Uint8ClampedArray;
 }
 
 const IO_BRIDGE_KEY = '__cascadeIoBridge';
@@ -96,6 +115,8 @@ export async function loadBytes(path: string, options: MediaOptions = { raw: tru
  * to hand it. Pass a width explicitly to work at a smaller size on purpose.
  */
 export async function loadImage(path: string, options: MediaOptions = { raw: true }): Promise<HTMLImageElement> {
+  const held = heldBitmap(path);
+  if (held) return held as unknown as HTMLImageElement;
   const image = new Image();
   const bridge = localIo();
   let temporaryUrl: string | undefined;
@@ -123,8 +144,41 @@ export async function loadImage(path: string, options: MediaOptions = { raw: tru
   }
 }
 
+/**
+ * Pixels the host still holds in memory for `path` (a path `keep` returned),
+ * as something `drawImage` takes, or null to read the file. Bypasses the read
+ * and the decode; the image is the same either way (`ImagePixels` is what a
+ * PNG decodes to).
+ */
+function heldBitmap(path: string): ImageBitmap | null {
+  if (/^(https?:|data:|blob:)/.test(path)) return null;
+  const pixels = localIo()?.pixels?.(path.replace(/^\.?\//, ''));
+  return pixels ? pixelsBitmap(pixels) : null;
+}
+
+/**
+ * `ImagePixels` as a drawable: a canvas holding them, with an `ImageBitmap`'s
+ * `width`, `height` and `close()` (and an image's `naturalWidth`/`naturalHeight`).
+ */
+export function pixelsBitmap(pixels: ImagePixels): ImageBitmap {
+  const Canvas = (globalThis as { OffscreenCanvas?: new (w: number, h: number) => OffscreenCanvas }).OffscreenCanvas;
+  if (!Canvas) throw new Error('cascade/io: this host has no OffscreenCanvas to hold the image');
+  const canvas = new Canvas(pixels.width, pixels.height);
+  const context = canvas.getContext('2d') as OffscreenCanvasRenderingContext2D | null;
+  if (!context) throw new Error('cascade/io: the canvas has no 2D context');
+  const data = new ImageData(pixels.data as Uint8ClampedArray<ArrayBuffer>, pixels.width, pixels.height);
+  context.putImageData(data, 0, 0);
+  const drawable = canvas as unknown as Record<string, unknown>;
+  drawable.close = () => {};
+  drawable.naturalWidth = pixels.width;
+  drawable.naturalHeight = pixels.height;
+  return canvas as unknown as ImageBitmap;
+}
+
 /** Same, as an ImageBitmap — the right input for `texImage2D`. */
 export async function loadBitmap(path: string, options: MediaOptions = { raw: true }): Promise<ImageBitmap> {
+  const held = heldBitmap(path);
+  if (held) return held;
   const bridge = localIo();
   if (bridge?.url) return createImageBitmap(await loadImage(path, options));
   if (bridge) return createImageBitmap(new Blob([await loadBytes(path, options)]));
@@ -177,6 +231,15 @@ export async function saveImage(
   const type = `image/${format}`;
   let blob: Blob;
 
+  // A host that keeps intermediates gets the pixels, not an encode: the
+  // headless host writes a fast PNG (or holds them in memory), where the
+  // canvas's own encoder would spend six times as long.
+  const bridge = localIo();
+  if (format === 'png' && bridge?.keep) {
+    const pixels = canvasPixels(source);
+    if (pixels) return bridge.keep(path.replace(/^\.?\//, ''), pixels);
+  }
+
   if (source instanceof Blob) {
     blob = source;
   } else if (typeof (source as OffscreenCanvas).convertToBlob === 'function') {
@@ -200,6 +263,21 @@ export async function saveImage(
   return saveBytes(blob, path);
 }
 
+/**
+ * A canvas's pixels as `ImagePixels`, or null for anything that is not a 2D
+ * canvas (a Blob, an encoder-only source, a WebGL canvas, whose `getContext('2d')`
+ * is null).
+ */
+export function canvasPixels(source: unknown): ImagePixels | null {
+  const canvas = source as { width?: unknown; height?: unknown; getContext?: (kind: '2d') => CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D | null };
+  if (typeof canvas?.getContext !== 'function' || typeof canvas.width !== 'number' || typeof canvas.height !== 'number') return null;
+  if (!canvas.width || !canvas.height) return null;
+  const context = canvas.getContext('2d');
+  if (!context || typeof context.getImageData !== 'function') return null;
+  const image = context.getImageData(0, 0, canvas.width, canvas.height);
+  return { width: image.width, height: image.height, data: image.data };
+}
+
 /** Write any bytes into the project cache and return the path. */
 export async function saveBytes(data: Blob | ArrayBuffer | Uint8Array, path: string): Promise<string> {
   const clean = path.replace(/^\.?\//, '');

package/dist/cli/share-B7HTCOJX.js

@@ -0,0 +1,166 @@
+import {
+  deployVercel,
+  exportEditor,
+  scanForLeaks,
+  vercelConfig
+} from "./chunk-JEW5MPGI.js";
+import "./chunk-2L34ERS2.js";
+import "./chunk-QKL7CCRS.js";
+import "./chunk-MI5JLQYA.js";
+import "./chunk-GRIN2DDP.js";
+import "./chunk-X4WKAOQP.js";
+import "./chunk-DEQSEFFH.js";
+import "./chunk-RXDIMXN5.js";
+import "./chunk-QQPA2ZHH.js";
+import "./chunk-KH4MUBKF.js";
+import "./chunk-HSNOBIVT.js";
+import "./chunk-L6B6FUQP.js";
+import "./chunk-HFHWYL55.js";
+import "./chunk-KBGUO27Q.js";
+import "./chunk-ICH7N5PN.js";
+import "./chunk-CO22XHNG.js";
+import "./chunk-LTXWBXOM.js";
+import "./chunk-BZ63XQ3I.js";
+import "./chunk-YH637PDL.js";
+import "./chunk-X566FWBV.js";
+import "./chunk-WD62JIP6.js";
+import "./chunk-5ORUQ6ES.js";
+import "./chunk-W5PJ5RMP.js";
+import "./chunk-NJFMDXHR.js";
+import "./chunk-J7VK7MNF.js";
+import "./chunk-FWMSGKEH.js";
+import "./chunk-JVOCK5W4.js";
+
+// src/cli/share.ts
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+var SHARE_USAGE = "cascade share <graph-file | site-directory> [--name <slug>] [--scope <team>] [--protected] [--json]";
+function shareSlug(text) {
+  const slug = text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/^cascade-/, "").slice(0, 80).replace(/-+$/, "");
+  if (!slug) throw new Error(`"${text}" makes no usable name; pass --name <slug>`);
+  return slug;
+}
+async function share(target, options = {}) {
+  const log = options.log ?? ((line) => console.log(line));
+  const source = path.resolve(target);
+  const stat = await fs.stat(source).catch(() => void 0);
+  if (!stat) throw new Error(`${target} does not exist`);
+  const isGraph = stat.isFile() && source.endsWith(".cascade");
+  if (!isGraph && !stat.isDirectory()) throw new Error(`cascade share takes a .cascade graph or a directory with an index.html (got ${target})`);
+  const scratch = await fs.mkdtemp(path.join(os.tmpdir(), "cascade-share-"));
+  try {
+    const site = path.join(scratch, "site");
+    let name;
+    let projectRoot;
+    if (isGraph) {
+      const { plan } = await exportEditor(source, { out: site, log });
+      name = shareSlug(options.name ?? plan.editor.id);
+      projectRoot = path.dirname(source);
+    } else {
+      if (!(await fs.stat(path.join(source, "index.html")).catch(() => void 0))?.isFile())
+        throw new Error(`${target} has no index.html to share`);
+      await copySite(source, site);
+      if (!await fs.stat(path.join(site, "vercel.json")).catch(() => void 0))
+        await fs.writeFile(path.join(site, "vercel.json"), `${JSON.stringify(vercelConfig(), null, 2)}
+`);
+      projectRoot = await findProjectRoot(source);
+      await scanForLeaks(site, projectRoot ?? source);
+      name = shareSlug(options.name ?? path.basename(source));
+    }
+    const project = `cascade-${name}`;
+    const deploy = options.deploy ?? deployVercel;
+    const deployed = await deploy(site, { project, scope: options.scope, public: options.protected !== true, log });
+    const record = {
+      source: projectRoot ? path.relative(projectRoot, source).split(path.sep).join("/") || "." : path.basename(source),
+      name,
+      project,
+      url: deployed.url,
+      deployment: deployed.deployment,
+      sharedAt: (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString()
+    };
+    const shares = projectRoot ? await recordShare(projectRoot, record) : void 0;
+    return { ...record, ...shares ? { shares } : {} };
+  } finally {
+    await fs.rm(scratch, { recursive: true, force: true });
+  }
+}
+async function recordShare(projectRoot, record) {
+  const file = path.join(projectRoot, "shares.json");
+  const existing = await readShares(projectRoot);
+  const shares = [...existing.shares.filter((item) => item.source !== record.source), record].sort((a, b) => a.source.localeCompare(b.source));
+  const next = { format: "cascade.shares", version: 1, shares };
+  await fs.writeFile(file, `${JSON.stringify(next, null, 2)}
+`);
+  return file;
+}
+async function readShares(projectRoot) {
+  const text = await fs.readFile(path.join(projectRoot, "shares.json"), "utf8").catch(() => void 0);
+  if (!text) return { format: "cascade.shares", version: 1, shares: [] };
+  const parsed = JSON.parse(text);
+  if (parsed.format !== "cascade.shares" || !Array.isArray(parsed.shares)) throw new Error(`${path.join(projectRoot, "shares.json")} is not a cascade.shares file`);
+  return { format: "cascade.shares", version: 1, shares: parsed.shares };
+}
+async function findProjectRoot(start) {
+  for (let directory = start; ; directory = path.dirname(directory)) {
+    if (await fs.stat(path.join(directory, "cascade.json")).catch(() => void 0)) return directory;
+    if (path.dirname(directory) === directory) return void 0;
+  }
+}
+async function copySite(from, to) {
+  await fs.cp(from, to, {
+    recursive: true,
+    dereference: true,
+    filter: (file) => {
+      const relative = path.relative(from, file);
+      return !relative || relative.split(path.sep).every((part) => !part.startsWith(".") && part !== "licensed");
+    }
+  });
+}
+async function runShareCommand(args) {
+  const rest = args.slice(1);
+  const json = rest.includes("--json");
+  let target;
+  const values = {};
+  let isProtected = false;
+  for (let index = 0; index < rest.length; index++) {
+    const arg = rest[index];
+    if (arg === "--json") continue;
+    if (arg === "--protected") {
+      isProtected = true;
+      continue;
+    }
+    if (arg === "--name" || arg === "--scope") {
+      const value = rest[++index];
+      if (!value || value.startsWith("--")) throw new Error(`${arg} needs a value`);
+      values[arg.slice(2)] = value;
+      continue;
+    }
+    if (arg.startsWith("--")) throw new Error(`Unknown option ${arg}
+Usage: ${SHARE_USAGE}`);
+    if (target) throw new Error(`cascade share takes one graph or directory
+Usage: ${SHARE_USAGE}`);
+    target = arg;
+  }
+  if (!target) throw new Error(`Usage: ${SHARE_USAGE}`);
+  const result = await share(target, {
+    ...values.name ? { name: values.name } : {},
+    ...values.scope ? { scope: values.scope } : {},
+    protected: isProtected,
+    log: json ? () => {
+    } : (line) => console.log(line)
+  });
+  if (json) console.log(JSON.stringify(result));
+  else console.log(`
+Shared: ${result.url}${result.shares ? `
+Recorded in ${result.shares}` : ""}`);
+}
+export {
+  SHARE_USAGE,
+  readShares,
+  recordShare,
+  runShareCommand,
+  share,
+  shareSlug
+};
+//# sourceMappingURL=share-B7HTCOJX.js.map

package/dist/cli/stageCache-TY2BFZJR.js

@@ -0,0 +1,15 @@
+import {
+  callStage,
+  cascadeVersion,
+  formatStageTrace,
+  stageCacheKey,
+  stageSources
+} from "./chunk-5ORUQ6ES.js";
+export {
+  callStage,
+  cascadeVersion,
+  formatStageTrace,
+  stageCacheKey,
+  stageSources
+};
+//# sourceMappingURL=stageCache-TY2BFZJR.js.map

package/dist/cli/{stageRunner-KUNIMQKJ.js → stageRunner-KY2EJP7X.js}

@@ -1,10 +1,10 @@
 import {
   readStageConfig,
   runProjectStage
-} from "./chunk-VVGSLVSF.js";
+} from "./chunk-X566FWBV.js";
 import "./chunk-WD62JIP6.js";
 export {
   readStageConfig,
   runProjectStage
 };
-//# sourceMappingURL=stageRunner-KUNIMQKJ.js.map
+//# sourceMappingURL=stageRunner-KY2EJP7X.js.map

package/dist/cli/text-MB3EKR4H.js

@@ -0,0 +1,126 @@
+import {
+  colorToCss,
+  normalizeColor,
+  readPixelsFromCanvas,
+  surface,
+  writePixels
+} from "./chunk-WGKPJZDY.js";
+
+// packages/runtime/src/builtins/image/text.ts
+var FONT_FILE = /\.(otf|ttf|woff2?)$/i;
+var HOST_KEY = "__cascadeImageHost";
+var registered = /* @__PURE__ */ new Set();
+function fingerprint(bytes) {
+  let hash = 2166136261;
+  for (let index = 0; index < bytes.length; index += 1) {
+    hash ^= bytes[index];
+    hash = Math.imul(hash, 16777619);
+  }
+  return `${bytes.length}-${(hash >>> 0).toString(16)}`;
+}
+async function fontFamily(context, font) {
+  const path = font.trim();
+  if (!FONT_FILE.test(path)) return font;
+  let bytes;
+  try {
+    const assets = context.capabilities.assets;
+    if (!assets) throw new Error("no assets");
+    bytes = await assets.read({ path }, { signal: context.signal });
+  } catch {
+    return "sans-serif";
+  }
+  const family = `cascade-font-${fingerprint(bytes)}`;
+  const globals = globalThis;
+  const host = globals[HOST_KEY];
+  const fonts = host ? null : globals.fonts ?? globals.document?.fonts;
+  const key = `${host ? `headless:${host.renderer}` : "browser"}:${family}`;
+  if (registered.has(key)) return family;
+  if (host && typeof host.registerFont === "function") {
+    await host.registerFont(family, bytes, {});
+  } else if (typeof globals.FontFace === "function" && fonts) {
+    const face = new globals.FontFace(family, bytes.slice().buffer);
+    fonts.add(await face.load());
+  } else {
+    return "sans-serif";
+  }
+  registered.add(key);
+  return family;
+}
+async function executeText(context) {
+  const { props } = context;
+  const [width, height] = [props.resolution[0], props.resolution[1]];
+  const color = normalizeColor(props.color);
+  const background = normalizeColor(props.backgroundColor);
+  const [offsetX, offsetY] = props.offset;
+  const { fontSize, alignH, alignV, rotation, letterSpacing } = props;
+  const family = await fontFamily(context, props.font);
+  const { canvas, context: ctx } = surface(width, height);
+  if (background.a > 0) {
+    ctx.fillStyle = colorToCss(background);
+    ctx.fillRect(0, 0, width, height);
+  } else {
+    ctx.clearRect(0, 0, width, height);
+  }
+  ctx.save();
+  ctx.globalAlpha = props.opacity;
+  ctx.font = `${props.fontStyle} ${props.fontWeight} ${fontSize}px ${family}`;
+  ctx.fillStyle = colorToCss(color);
+  const lines = props.text.split("\n");
+  const lineHeightPx = fontSize * props.lineHeight;
+  const totalTextHeight = lines.length * lineHeightPx;
+  let anchorX;
+  let anchorY;
+  switch (alignH) {
+    case "left":
+      ctx.textAlign = "left";
+      anchorX = 0;
+      break;
+    case "right":
+      ctx.textAlign = "right";
+      anchorX = width;
+      break;
+    default:
+      ctx.textAlign = "center";
+      anchorX = width / 2;
+  }
+  switch (alignV) {
+    case "top":
+      anchorY = fontSize;
+      break;
+    case "bottom":
+      anchorY = height - totalTextHeight + fontSize;
+      break;
+    default:
+      anchorY = (height - totalTextHeight) / 2 + fontSize;
+  }
+  anchorX += offsetX;
+  anchorY += offsetY;
+  if (rotation !== 0) {
+    const pivotY = anchorY - fontSize / 2 + totalTextHeight / 2;
+    ctx.translate(anchorX, pivotY);
+    ctx.rotate(rotation * Math.PI / 180);
+    ctx.translate(-anchorX, -pivotY);
+  }
+  if (letterSpacing !== 0) {
+    ctx.textAlign = "left";
+    lines.forEach((line, index) => {
+      const y = anchorY + index * lineHeightPx;
+      let lineWidth = 0;
+      for (const char of line) lineWidth += ctx.measureText(char).width + letterSpacing;
+      lineWidth -= letterSpacing;
+      let x = alignH === "left" ? anchorX : alignH === "right" ? anchorX - lineWidth : anchorX - lineWidth / 2;
+      for (const char of line) {
+        ctx.fillText(char, x, y);
+        x += ctx.measureText(char).width + letterSpacing;
+      }
+    });
+  } else {
+    lines.forEach((line, index) => ctx.fillText(line, anchorX, anchorY + index * lineHeightPx));
+  }
+  ctx.restore();
+  context.outputs.image.set(await writePixels(context, readPixelsFromCanvas(canvas)));
+}
+export {
+  executeText
+};
+//# sourceMappingURL=text-MB3EKR4H.js.map

package/dist/cli/{verbs-RCE3K4VQ.js → verbs-PI2JH5FI.js}

@@ -6,7 +6,7 @@ import {
   mainHelp,
   mcpTools,
   verbFor
-} from "./chunk-POMMNKZZ.js";
+} from "./chunk-G23A2BZZ.js";
 export {
   VERBS,
   graphCommandsHelp,
@@ -16,4 +16,4 @@ export {
   mcpTools,
   verbFor
 };
-//# sourceMappingURL=verbs-RCE3K4VQ.js.map
+//# sourceMappingURL=verbs-PI2JH5FI.js.map