@field/cascade 0.10.0 → 0.12.0

package/dist/cli/chunk-53LGFPWX.js

@@ -0,0 +1,138 @@
+// packages/runtime/src/builtins/image/contactSheet.ts
+function contactSheetLayout(sizes, options = {}) {
+  const count = sizes.length;
+  if (!count) throw new Error("cascade.image.ContactSheet needs at least one image");
+  for (const [width, height] of sizes) {
+    if (!(width > 0 && height > 0)) throw new Error(`cascade.image.ContactSheet: an image is ${width}x${height}`);
+  }
+  const gap = Math.max(0, Math.round(options.gap ?? 16));
+  const columns = Math.min(count, options.columns && options.columns > 0 ? Math.round(options.columns) : Math.ceil(Math.sqrt(count)));
+  const rows = Math.ceil(count / columns);
+  const scaled = Boolean(options.cellWidth && options.cellWidth > 0);
+  const cellWidth = scaled ? Math.round(options.cellWidth) : Math.max(...sizes.map(([width]) => width));
+  const cellHeight = scaled ? Math.max(...sizes.map(([width, height]) => Math.round(height * cellWidth / width))) : Math.max(...sizes.map(([, height]) => height));
+  const labelHeight = Math.max(0, Math.round(options.labelHeight ?? 0));
+  const cells = sizes.map(([width, height], index) => {
+    const column = index % columns;
+    const row = Math.floor(index / columns);
+    const fit = Math.min(cellWidth / width, cellHeight / height);
+    const scale = scaled ? fit : Math.min(1, fit);
+    const drawnWidth = Math.max(1, Math.round(width * scale));
+    const drawnHeight = Math.max(1, Math.round(height * scale));
+    const left = gap + column * (cellWidth + gap);
+    const top = gap + row * (cellHeight + labelHeight + gap);
+    return {
+      x: left + Math.floor((cellWidth - drawnWidth) / 2),
+      y: top + Math.floor((cellHeight - drawnHeight) / 2),
+      width: drawnWidth,
+      height: drawnHeight,
+      labelX: left,
+      labelY: top + cellHeight
+    };
+  });
+  return {
+    width: gap + columns * (cellWidth + gap),
+    height: gap + rows * (cellHeight + labelHeight + gap),
+    columns,
+    rows,
+    cell: [cellWidth, cellHeight],
+    labelHeight,
+    cells
+  };
+}
+function host() {
+  const globals = globalThis;
+  const Canvas = globals.OffscreenCanvas;
+  const createBitmap = globals.createImageBitmap;
+  if (!Canvas || !createBitmap || !globals.Blob) {
+    throw new Error("cascade.image.ContactSheet needs OffscreenCanvas and createImageBitmap, which this host does not provide");
+  }
+  const BlobType = globals.Blob;
+  return {
+    surface: (width, height) => new Canvas(width, height),
+    decode: (bytes) => createBitmap(new BlobType([bytes]))
+  };
+}
+function css(colour, fallback) {
+  const [r = 0, g = 0, b = 0, a = 1] = colour ?? fallback;
+  return `rgba(${Math.round(r * 255)}, ${Math.round(g * 255)}, ${Math.round(b * 255)}, ${a})`;
+}
+async function composeContactSheet(images, options = {}) {
+  const canvas = host();
+  const bitmaps = [];
+  try {
+    for (const bytes of images) bitmaps.push(await canvas.decode(bytes));
+    const labels = options.labels ?? [];
+    const labelSize = Math.round(options.labelSize ?? 14);
+    const labelled = labels.some((label) => label.trim().length > 0);
+    const layout = contactSheetLayout(bitmaps.map((bitmap) => [bitmap.width, bitmap.height]), {
+      columns: options.columns,
+      gap: options.gap,
+      cellWidth: options.cellWidth,
+      labelHeight: labelled ? Math.round(labelSize * 1.8) : 0
+    });
+    const surface = canvas.surface(layout.width, layout.height);
+    const context = surface.getContext("2d");
+    if (!context) throw new Error("cascade.image.ContactSheet: no 2D context");
+    context.fillStyle = css(options.background, [1, 1, 1, 1]);
+    context.fillRect(0, 0, layout.width, layout.height);
+    context.imageSmoothingEnabled = true;
+    context.imageSmoothingQuality = "high";
+    layout.cells.forEach((cell, index) => context.drawImage(bitmaps[index], cell.x, cell.y, cell.width, cell.height));
+    if (labelled) {
+      context.fillStyle = css(options.labelColor, [0.1, 0.1, 0.1, 1]);
+      context.font = `${labelSize}px sans-serif`;
+      context.textBaseline = "top";
+      layout.cells.forEach((cell, index) => {
+        const label = labels[index];
+        if (label) context.fillText(label, cell.labelX, cell.labelY + Math.round((layout.labelHeight - labelSize) / 2), layout.cell[0]);
+      });
+    }
+    const blob = await surface.convertToBlob({ type: "image/png" });
+    return { bytes: new Uint8Array(await blob.arrayBuffer()), layout };
+  } finally {
+    for (const bitmap of bitmaps) bitmap.close?.();
+  }
+}
+function imageReference(value) {
+  if (typeof value === "string" && value) return { path: value };
+  const candidate = value?.path;
+  return typeof candidate === "string" && candidate ? { path: candidate } : void 0;
+}
+async function executeContactSheet(context) {
+  const { props } = context;
+  const references = [...context.inputs.images, ...context.inputs.list ?? []].map(imageReference).filter((reference) => reference !== void 0);
+  const bytes = [];
+  for (const reference of references) {
+    bytes.push(await context.capabilities.assets.read(reference, { signal: context.signal }));
+  }
+  const { bytes: sheet, layout } = await composeContactSheet(bytes, {
+    columns: props.columns,
+    gap: props.gap,
+    cellWidth: props.cellWidth,
+    labels: props.labels ? props.labels.split("\n") : [],
+    labelSize: props.labelSize,
+    background: props.background,
+    labelColor: props.labelColor
+  });
+  const asset = await context.capabilities.assets.write(
+    sheet,
+    { mediaType: "image/png", suggestedName: props.filename },
+    { signal: context.signal }
+  );
+  context.outputs.asset.set(asset);
+  context.outputs.image.set({
+    path: asset.path ?? props.filename,
+    size: [layout.width, layout.height],
+    channels: "rgba",
+    depth: "u8",
+    space: "srgb"
+  });
+}
+
+export {
+  contactSheetLayout,
+  composeContactSheet,
+  executeContactSheet
+};
+//# sourceMappingURL=chunk-53LGFPWX.js.map

package/dist/cli/chunk-5ORUQ6ES.js

@@ -0,0 +1,267 @@
+// server/src/stageCache.ts
+import { createHash as createHash2 } from "node:crypto";
+import fs3 from "node:fs";
+import path2 from "node:path";
+import { fileURLToPath } from "node:url";
+
+// server/src/atomicWrite.ts
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+var temporaryFor = (file) => `${file}.${process.pid}.tmp`;
+async function writeFileAtomic(file, data, options = {}) {
+  const temporary = temporaryFor(file);
+  await fsp.writeFile(temporary, data, options.mode === void 0 ? void 0 : { mode: options.mode });
+  await fsp.rename(temporary, file);
+}
+function writeFileAtomicSync(file, data) {
+  const temporary = temporaryFor(file);
+  fs.writeFileSync(temporary, data);
+  fs.renameSync(temporary, file);
+}
+
+// server/src/stageSources.ts
+import { createHash } from "node:crypto";
+import fs2 from "node:fs";
+import path from "node:path";
+var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set(["__pycache__", "node_modules", "venv", ".venv", ".git", ".cascade", ".cascade-cache"]);
+var digests = /* @__PURE__ */ new Map();
+function contentDigest(fullPath) {
+  let stat;
+  try {
+    stat = fs2.statSync(fullPath, { bigint: true });
+  } catch {
+    return null;
+  }
+  if (!stat.isFile()) return null;
+  const stamp = `${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
+  const known = digests.get(fullPath);
+  if (known?.stamp === stamp) return known.digest;
+  const hash = createHash("sha256");
+  const handle = fs2.openSync(fullPath, "r");
+  try {
+    const buffer = Buffer.allocUnsafe(1 << 20);
+    let read;
+    while ((read = fs2.readSync(handle, buffer, 0, buffer.length, null)) > 0) hash.update(buffer.subarray(0, read));
+  } finally {
+    fs2.closeSync(handle);
+  }
+  const digest = hash.digest("hex");
+  digests.set(fullPath, { stamp, digest });
+  return digest;
+}
+var StageSources = class {
+  constructor(project, roots) {
+    this.project = project;
+    this.roots = [...new Set(roots)].sort();
+  }
+  /** The default roots for a stage configuration without `sources`. */
+  static defaultRoots(project, entrypoint, worker) {
+    const roots = [path.posix.dirname(entrypoint)];
+    if (worker) roots.push(path.posix.dirname(worker));
+    if (fs2.existsSync(project.resolve("src"))) roots.push("src");
+    return roots.map((root) => root === "" ? "." : root);
+  }
+  /** Every source file, project-relative and sorted. */
+  files() {
+    const found = /* @__PURE__ */ new Set();
+    for (const root of this.roots) {
+      let full;
+      try {
+        full = this.project.resolveMedia(root);
+      } catch {
+        continue;
+      }
+      let stat;
+      try {
+        stat = fs2.statSync(full);
+      } catch {
+        continue;
+      }
+      if (stat.isFile()) found.add(root);
+      else if (stat.isDirectory()) this.walk(full, root, found);
+    }
+    return [...found].sort();
+  }
+  walk(directory, relative, found) {
+    let entries;
+    try {
+      entries = fs2.readdirSync(directory, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const child = relative === "." ? entry.name : path.posix.join(relative, entry.name);
+      if (entry.isDirectory()) {
+        if (SKIPPED_DIRECTORIES.has(entry.name) || entry.name.startsWith(".")) continue;
+        this.walk(path.join(directory, entry.name), child, found);
+      } else if (entry.isFile() && entry.name.endsWith(".py")) {
+        found.add(child);
+      }
+    }
+  }
+  digest(relative) {
+    return contentDigest(this.project.resolveMedia(relative)) ?? "missing";
+  }
+  /**
+   * The code hash, 16 hex characters. A file added, removed or edited changes
+   * it. Cheap to call per request: one directory walk and one stat per file,
+   * with a file read only when its stat changed.
+   */
+  codeHash() {
+    const hash = createHash("sha256");
+    for (const file of this.files()) hash.update(`${file}\0${this.digest(file)}
+`);
+    return hash.digest("hex").slice(0, 16);
+  }
+};
+
+// server/src/stageCache.ts
+var CACHE_FORMAT = 1;
+var CACHE_DIRECTORY = ".cascade/cache/stages";
+var version;
+function cascadeVersion() {
+  if (version) return version;
+  let directory = path2.dirname(fileURLToPath(import.meta.url));
+  for (let depth = 0; depth < 6; depth++) {
+    try {
+      const manifest = JSON.parse(fs3.readFileSync(path2.join(directory, "package.json"), "utf8"));
+      if (manifest.name === "@field/cascade" && manifest.version) return version = manifest.version;
+    } catch {
+    }
+    directory = path2.dirname(directory);
+  }
+  return version = "unknown";
+}
+function projectFile(project, value) {
+  if (!value || value.length > 1024 || value.includes("\0") || /^[a-z][a-z0-9+.-]*:/i.test(value)) return null;
+  if (path2.isAbsolute(value) || !/[./]/.test(value)) return null;
+  try {
+    return project.resolveMedia(value.replace(/^\.\//, ""));
+  } catch {
+    return null;
+  }
+}
+function replaceFiles(project, value, at, skip, onFile) {
+  if (typeof value === "string") {
+    const full = projectFile(project, value);
+    const digest = full ? contentDigest(full) : null;
+    if (!digest) return value;
+    onFile(at, value, digest);
+    return `file:${digest}`;
+  }
+  if (Array.isArray(value)) return value.map((item, index) => replaceFiles(project, item, `${at}[${index}]`, skip, onFile));
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const name of Object.keys(value).sort()) {
+      const child = value[name];
+      const where = at ? `${at}.${name}` : name;
+      out[name] = !at && skip.has(name) ? child : replaceFiles(project, child, where, skip, onFile);
+    }
+    return out;
+  }
+  return value;
+}
+function stageCacheKey(project, stage, args, code, outputs = []) {
+  const inputs = {};
+  const params = replaceFiles(project, args, "", new Set(outputs), (where, _relative, digest) => {
+    inputs[where] = digest.slice(0, 16);
+  });
+  const cascade = cascadeVersion();
+  const blob = JSON.stringify({ format: CACHE_FORMAT, stage, code, cascade, params });
+  return { key: createHash2("sha256").update(blob).digest("hex").slice(0, 32), code, cascade, inputs };
+}
+function entryPath(project, stage, key) {
+  return project.resolve(path2.posix.join(CACHE_DIRECTORY, stage, `${key}.json`));
+}
+function resultFiles(project, result) {
+  const files = {};
+  replaceFiles(project, result, "", /* @__PURE__ */ new Set(), (_where, relative, digest) => {
+    files[relative] = digest;
+  });
+  return files;
+}
+function readEntry(project, stage, key) {
+  let entry;
+  try {
+    entry = JSON.parse(fs3.readFileSync(entryPath(project, stage, key), "utf8"));
+  } catch {
+    return { why: "no entry" };
+  }
+  if (entry.format !== CACHE_FORMAT || entry.key !== key) return { why: "no entry" };
+  for (const [relative, digest] of Object.entries(entry.outputs ?? {})) {
+    const full = projectFile(project, relative);
+    if (!full || contentDigest(full) !== digest) return { why: `output changed: ${relative}` };
+  }
+  return { result: entry.result };
+}
+function writeEntry(project, stage, key, result) {
+  const file = entryPath(project, stage, key);
+  const entry = { format: CACHE_FORMAT, stage, key, result, outputs: resultFiles(project, result) };
+  fs3.mkdirSync(path2.dirname(file), { recursive: true });
+  writeFileAtomicSync(file, JSON.stringify(entry));
+}
+function cacheMode(policy, stage, caller, env) {
+  if (env.CASCADE_STAGE_CACHE === "off") return { use: false, bypass: true, why: "CASCADE_STAGE_CACHE=off" };
+  if (!policy.enabled) return { use: false, bypass: false, why: "not enabled" };
+  if (policy.exclude.includes(stage)) return { use: false, bypass: false, why: "excluded" };
+  if (policy.scope === "cook" && caller !== "cook") return { use: false, bypass: false, why: "not a cook call" };
+  return { use: true, bypass: false };
+}
+function stageSources(project, config) {
+  return new StageSources(project, config.sources ?? StageSources.defaultRoots(project, config.entrypoint, config.worker));
+}
+async function callStage(project, config, stage, args, invoke, options = {}) {
+  const started = performance.now();
+  const code = stageSources(project, config).codeHash();
+  const identity = stageCacheKey(project, stage, args, code, config.cache.outputs);
+  const mode = cacheMode(config.cache, stage, options.caller ?? "cook", options.env ?? process.env);
+  const finish = (result, trace) => {
+    const full = {
+      stage,
+      key: identity.key,
+      ...trace,
+      code: identity.code,
+      cascade: identity.cascade,
+      inputs: identity.inputs,
+      ms: Math.round(performance.now() - started)
+    };
+    options.onTrace?.(full);
+    return { result, trace: full };
+  };
+  let why = mode.why;
+  if (mode.use) {
+    const stored = readEntry(project, stage, identity.key);
+    if ("result" in stored) return finish(stored.result, { cache: "hit" });
+    why = stored.why;
+  }
+  const answer = await invoke({ key: identity.key, code, cache: mode.bypass ? "off" : "use" });
+  if (mode.use) {
+    try {
+      writeEntry(project, stage, identity.key, answer.result);
+    } catch {
+    }
+  }
+  return finish(answer.result, {
+    cache: mode.use ? "miss" : "off",
+    ...why ? { why } : {},
+    ...answer.projectCache ? { project: answer.projectCache } : {},
+    ...answer.restarted ? { restarted: true } : {}
+  });
+}
+function formatStageTrace(trace) {
+  const reason = trace.why ? ` (${trace.why})` : "";
+  const project = trace.project ? ` project:${trace.project}` : "";
+  const restarted = trace.restarted ? " worker restarted for new code" : "";
+  return `${trace.stage}: ${trace.cache}${reason}${project} key ${trace.key.slice(0, 12)} code ${trace.code} ${trace.ms} ms${restarted}`;
+}
+
+export {
+  writeFileAtomic,
+  writeFileAtomicSync,
+  cascadeVersion,
+  stageCacheKey,
+  stageSources,
+  callStage,
+  formatStageTrace
+};
+//# sourceMappingURL=chunk-5ORUQ6ES.js.map