@field/cascade 0.8.0 → 0.11.0

package/dist/cli/chunk-3JTJHF7V.js

@@ -0,0 +1,267 @@
+import {
+  createRuntime,
+  moduleId,
+  projectModuleFile,
+  validateNodeModuleArchitecture
+} from "./chunk-EUIAC3U3.js";
+import {
+  builtinNodeRegistration
+} from "./chunk-36P5K3SD.js";
+import {
+  ProjectRoot,
+  extractNodeDefinition
+} from "./chunk-RQZ4SX5R.js";
+
+// src/cli/webBuild.ts
+import fs from "node:fs/promises";
+import path from "node:path";
+import { builtinModules } from "node:module";
+import { fileURLToPath } from "node:url";
+import { build } from "esbuild";
+import ts from "typescript";
+
+// packages/runtime/src/browser.ts
+function createBrowserRuntimeHost(options) {
+  const {
+    modules,
+    legacyShell,
+    now = () => Date.now(),
+    report = () => {
+    },
+    ...capabilities
+  } = options;
+  return {
+    environment: "browser",
+    modules,
+    legacyShell,
+    capabilities,
+    now,
+    report
+  };
+}
+
+// src/cli/webBuild.ts
+var installRoot = fileURLToPath(new URL("../../", import.meta.url));
+var forbiddenModules = new Set(builtinModules.map((name) => name.replace(/^node:/, "")));
+async function buildPlayer(file, options) {
+  if (!options.out) throw new Error("cascade build requires --out <new-directory>");
+  const project = new ProjectRoot(path.dirname(path.resolve(file)));
+  const out = path.resolve(project.root, options.out);
+  if (await exists(out)) throw new Error(`Player output already exists: ${out}. Choose a new directory.`);
+  const canonicalOut = await canonicalFuturePath(out);
+  for (const sourceDirectory of ["assets", "nodes"]) {
+    const sourceRoot = await canonicalFuturePath(path.join(project.root, sourceDirectory));
+    if (inside(sourceRoot, canonicalOut)) {
+      throw new Error(`Player output cannot be inside the project's ${sourceDirectory} directory`);
+    }
+  }
+  const document = JSON.parse(await fs.readFile(file, "utf8"));
+  if (!Array.isArray(document.nodes)) throw new Error("Graph document must contain a nodes array");
+  const modules = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const node of document.nodes) {
+    const id = moduleId(node);
+    if (seen.has(id)) continue;
+    seen.add(id);
+    if (builtinNodeRegistration(id)) continue;
+    const resolved = await projectModuleFile(project.root, node, id);
+    if (!resolved.file) throw new Error(`${id}: no supported static project module (${resolved.tried.join(", ")})`);
+    const sourceFile = project.resolve(path.relative(project.root, resolved.file));
+    const source = await fs.readFile(sourceFile, "utf8");
+    const extracted = extractNodeDefinition(source, sourceFile, ts);
+    if (!extracted.ok) throw new Error(`${id}: static browser builds require definition-v1
+${extracted.diagnostics.map((d) => `${d.code}: ${d.message}`).join("\n")}`);
+    const diagnostics = validateNodeModuleArchitecture(source, sourceFile, ts);
+    if (diagnostics.length) throw new Error(diagnostics.map((d) => `${id}: ${d.code}: ${d.message}`).join("\n"));
+    modules.push({ id, file: sourceFile, definition: extracted.definition });
+  }
+  const registrations = modules.map((item) => ({
+    kind: "definition-v1",
+    moduleId: item.id,
+    definition: item.definition,
+    loadExecute: async () => {
+      throw new Error("Static builds never execute project code");
+    }
+  }));
+  const runtime = createRuntime({ host: createBrowserRuntimeHost({
+    modules: { resolve: async (id) => registrations.find((item) => item.moduleId === id) ?? null },
+    // Presence describes the exported player contract, not this Node process.
+    assets: {},
+    gpu: {}
+  }), nodes: registrations });
+  const assets = new Set(options.assets ?? []);
+  try {
+    const graph = await runtime.load(document);
+    const diagnostics = graph.preflight();
+    if (diagnostics.length) throw new Error(`This graph cannot be exported to the browser player:
+${diagnostics.map((d) => `${d.path ?? ""} ${d.code}: ${d.message}`).join("\n")}`);
+    for (const node of graph.inspect().nodes) {
+      for (const port of [...Object.values(node.inputs), ...Object.values(node.props)]) {
+        if (port.type !== "image" && port.type !== "asset") continue;
+        const value = port.value;
+        const asset = typeof value === "string" ? value : value && typeof value === "object" && "path" in value ? value.path : void 0;
+        if (typeof asset === "string" && asset && !/^(https?:|data:|blob:)/.test(asset)) assets.add(asset);
+      }
+    }
+  } finally {
+    await runtime.dispose();
+  }
+  const sources = [];
+  for (const asset of assets) {
+    const name = asset.replace(/^\.\//, "");
+    if (!name || name.includes("\\") || name.split("/").some((part) => !part || part.startsWith(".")) || path.isAbsolute(name)) {
+      throw new Error(`Asset must be a visible project-relative file: ${asset}`);
+    }
+    const source = project.resolve(name);
+    if (!(await fs.stat(source)).isFile()) throw new Error(`Asset is not a file: ${asset}`);
+    sources.push({ name, file: source });
+  }
+  const playerApp = await playerFile("app");
+  const playerEmbed = await playerFile("embed");
+  const plugins = [await staticRuntimePlugin(project.root)];
+  const imports = modules.map((item, index) => `import { execute as execute${index} } from ${JSON.stringify(item.file)};`).join("\n");
+  const registrationSource = modules.map((item, index) => `{ kind:'definition-v1', moduleId:${JSON.stringify(item.id)}, definition:${JSON.stringify(item.definition)}, loadExecute:async()=>execute${index} }`).join(",");
+  const assetSource = sources.map((item) => `${JSON.stringify(item.name)}:new URL(${JSON.stringify(`./assets/${item.name.split("/").map(encodeURIComponent).join("/")}`)},import.meta.url).href`).join(",");
+  const appSource = `import { startPlayer } from ${JSON.stringify(playerApp)};
+${imports}
+window.cascadePlayerReady = startPlayer({document:${JSON.stringify(document)},registrations:[${registrationSource}],assets:{${assetSource}}});
+window.cascadePlayerReady.catch(error=>{const message=document.createElement('pre');message.textContent=String(error?.message??error);document.body.append(message);});`;
+  const embedSource = `import { mountPlayer } from ${JSON.stringify(playerEmbed)};
+export function mount(container,options={}) { return mountPlayer(container,{...options,url:new URL('./player.html',import.meta.url)}); }`;
+  const common = {
+    bundle: true,
+    platform: "browser",
+    format: "esm",
+    target: "es2022",
+    write: false,
+    minify: true,
+    logLevel: "silent",
+    plugins
+  };
+  const app = await build({ ...common, stdin: { contents: appSource, resolveDir: project.root, sourcefile: "player-entry.js" } });
+  const embed = await build({ ...common, stdin: { contents: embedSource, resolveDir: project.root, sourcefile: "embed-entry.js" } });
+  await fs.mkdir(path.dirname(out), { recursive: true });
+  const staging = await fs.mkdtemp(path.join(path.dirname(out), ".cascade-player-"));
+  try {
+    const html = '<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Cascade</title><style>html,body{margin:0;width:100%;height:100%;overflow:hidden}body{font:13px system-ui}pre{white-space:pre-wrap;padding:16px}</style></head><body><script type="module" src="./app.js"></script></body></html>';
+    await fs.writeFile(path.join(staging, "index.html"), html);
+    await fs.writeFile(path.join(staging, "player.html"), html);
+    await fs.writeFile(path.join(staging, "app.js"), app.outputFiles[0].contents);
+    await fs.writeFile(path.join(staging, "embed.js"), embed.outputFiles[0].contents);
+    for (const source of sources) {
+      const target = path.join(staging, "assets", source.name);
+      await fs.mkdir(path.dirname(target), { recursive: true });
+      await fs.copyFile(source.file, target);
+    }
+    await fs.mkdir(out);
+    try {
+      for (const entry of await fs.readdir(staging)) await fs.rename(path.join(staging, entry), path.join(out, entry));
+    } catch (error) {
+      await fs.rm(out, { recursive: true, force: true });
+      throw error;
+    }
+  } finally {
+    await fs.rm(staging, { recursive: true, force: true });
+  }
+  return { directory: out };
+}
+async function playerFile(name) {
+  const source = path.join(installRoot, "src", "player", `${name}.ts`);
+  return await exists(source) ? source : path.join(installRoot, "dist", "player", `${name}.js`);
+}
+async function staticRuntimePlugin(projectRoot) {
+  const manifest = JSON.parse(await fs.readFile(path.join(installRoot, "package.json"), "utf8"));
+  const canonicalProjectRoot = await fs.realpath(projectRoot);
+  const confinementMarker = /* @__PURE__ */ Symbol("cascade-player-confinement");
+  return { name: "cascade-static-player", setup(builder) {
+    builder.onResolve({ filter: /.*/ }, async (args) => {
+      const marked = typeof args.pluginData === "object" && args.pluginData !== null && args.pluginData[confinementMarker] === true;
+      if (!marked && isFilesystemImport(args.path) && await importerIsInProject(args.importer, canonicalProjectRoot)) {
+        const resolved = await builder.resolve(args.path, {
+          importer: args.importer,
+          resolveDir: args.resolveDir,
+          kind: args.kind,
+          pluginData: { [confinementMarker]: true }
+        });
+        if (resolved.errors.length || !resolved.path || resolved.external) return resolved;
+        const canonicalTarget = await fs.realpath(resolved.path);
+        if (!inside(canonicalProjectRoot, canonicalTarget)) {
+          return { errors: [{
+            text: `Project import escapes the project: ${args.path} resolves to ${canonicalTarget}`
+          }] };
+        }
+        return resolved;
+      }
+      if (args.path.startsWith("node:") || forbiddenModules.has(args.path)) {
+        return { errors: [{ text: `Browser player cannot import Node module ${args.path}` }] };
+      }
+      const canonical = args.path.replace(/^@field\/cascade\//, "cascade/").replace(/^@cascade\//, "cascade/");
+      if (!canonical.startsWith("cascade/")) return;
+      const subpath = canonical.slice("cascade/".length);
+      if (!(subpath === "io" || subpath === "image" || subpath === "gpu" || subpath === "contracts" || subpath.startsWith("contracts/") || subpath === "runtime" || subpath.startsWith("runtime/"))) {
+        return { errors: [{ text: `Browser player cannot import ${args.path}; server transports and configuration are not exported` }] };
+      }
+      if (subpath === "runtime/node" || subpath === "runtime/definition/extract") {
+        return { errors: [{ text: `Browser player cannot import ${args.path}` }] };
+      }
+      const entry = manifest.exports[`./${subpath}`]?.default;
+      if (!entry) return { errors: [{ text: `Unknown Cascade browser export: ${args.path}` }] };
+      const sourceShim = path.join(installRoot, "server", "src", "runtime", `${subpath}.ts`);
+      return { path: (subpath === "io" || subpath === "image" || subpath === "gpu") && await exists(sourceShim) ? sourceShim : path.resolve(installRoot, entry) };
+    });
+  } };
+}
+function isFilesystemImport(specifier) {
+  return specifier.startsWith(".") || path.isAbsolute(specifier);
+}
+async function importerIsInProject(importer, canonicalProjectRoot) {
+  if (!importer || !path.isAbsolute(importer)) return false;
+  try {
+    return inside(canonicalProjectRoot, await fs.realpath(importer));
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+}
+async function canonicalFuturePath(candidate) {
+  let existing = path.resolve(candidate);
+  const missing = [];
+  for (; ; ) {
+    try {
+      await fs.lstat(existing);
+      break;
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+      const parent = path.dirname(existing);
+      if (parent === existing) throw new Error(`Output path has no accessible parent: ${candidate}`);
+      missing.unshift(path.basename(existing));
+      existing = parent;
+    }
+  }
+  return path.resolve(await fs.realpath(existing), ...missing);
+}
+function inside(root, candidate) {
+  const relative = path.relative(root, candidate);
+  return relative === "" || !relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative);
+}
+async function exists(file) {
+  try {
+    await fs.lstat(file);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+}
+
+export {
+  createBrowserRuntimeHost,
+  installRoot,
+  buildPlayer,
+  playerFile,
+  staticRuntimePlugin,
+  canonicalFuturePath,
+  inside,
+  exists
+};
+//# sourceMappingURL=chunk-3JTJHF7V.js.map

package/dist/cli/chunk-4UDFYF5G.js

@@ -0,0 +1,132 @@
+// src/cli/runTrace.ts
+import fs from "node:fs";
+import path from "node:path";
+var MAX_NODE_LOGS = 500;
+var MAX_LOG_LINE = 2e3;
+var RunTrace = class {
+  constructor(graphFile, cascade, seed) {
+    this.graphFile = graphFile;
+    this.cascade = cascade;
+    this.seed = seed;
+    this.runs = [];
+    this.current = null;
+    /** Stage calls made outside any node (a run with no graph events). */
+    this.loose = [];
+    this.startedAt = /* @__PURE__ */ new Date();
+    this.envNames = [];
+  }
+  /** Follow one loaded graph's events. Returns the unsubscribe. */
+  attach(graph) {
+    const modules = new Map(graph.inspect().nodes.map((node) => [node.id, node.moduleId]));
+    return graph.subscribe((event) => {
+      if (event.type === "run:start") {
+        this.runs.push({ runId: event.runId, frame: graph.getFrame(), nodes: [] });
+      } else if (event.type === "node:start") {
+        const run = this.runs[this.runs.length - 1];
+        if (!run) return;
+        const node = { id: event.nodeId, module: modules.get(event.nodeId) ?? "", ms: 0, stages: [] };
+        run.nodes.push(node);
+        this.current = { node, started: performance.now() };
+      } else if (event.type === "node:complete" && this.current?.node.id === event.nodeId) {
+        this.current.node.ms = Math.round(performance.now() - this.current.started);
+        this.current = null;
+      }
+    });
+  }
+  /** Record a stage call against the node cooking now. */
+  recordStage(trace) {
+    if (this.current) this.current.node.stages.push(trace);
+    else this.loose.push(trace);
+  }
+  /**
+   * Record a line printed while a node cooks, against that node. Returns
+   * false when no node is cooking, so the caller leaves the line alone (the
+   * CLI's own messages are not node output).
+   */
+  recordLog(level, text) {
+    const node = this.current?.node;
+    if (!node) return false;
+    for (const line of text.split("\n")) {
+      if (!line.trim()) continue;
+      node.logs ??= [];
+      if (node.logs.length >= MAX_NODE_LOGS) {
+        node.logsDropped = (node.logsDropped ?? 0) + 1;
+        continue;
+      }
+      node.logs.push({ level, text: line.length > MAX_LOG_LINE ? `${line.slice(0, MAX_LOG_LINE)}\u2026` : line });
+    }
+    return true;
+  }
+  /** Every logged line in order, with its node. */
+  logs() {
+    return this.runs.flatMap((run) => run.nodes.flatMap((node) => (node.logs ?? []).map((line) => ({ node: node.id, ...line }))));
+  }
+  /** The names (never the values) of variables `--env` set, for the trace. */
+  setEnvNames(names) {
+    this.envNames = [...names];
+  }
+  /** Every stage call in order, with its node. */
+  stages() {
+    const list = [];
+    for (const run of this.runs) {
+      for (const node of run.nodes) for (const stage of node.stages) list.push({ node: node.id, ...stage });
+    }
+    for (const stage of this.loose) list.push({ node: null, ...stage });
+    return list;
+  }
+  toJSON() {
+    return {
+      format: 1,
+      graph: this.graphFile,
+      startedAt: this.startedAt.toISOString(),
+      cascade: this.cascade,
+      seed: this.seed,
+      ...this.envNames.length ? { env: this.envNames } : {},
+      runs: this.runs
+    };
+  }
+  /** Write the trace into the project and return its project-relative path. */
+  write(projectRoot) {
+    const stamp = this.startedAt.toISOString().replace(/[:.]/g, "-");
+    const name = `${stamp}-${path.basename(this.graphFile, ".cascade")}.json`;
+    const relative = path.posix.join(".cascade", "runs", name);
+    const full = path.join(projectRoot, relative);
+    fs.mkdirSync(path.dirname(full), { recursive: true });
+    fs.writeFileSync(full, JSON.stringify(this.toJSON(), null, 2) + "\n");
+    pruneTraces(path.dirname(full));
+    return relative;
+  }
+};
+var CONSOLE_LEVELS = ["log", "info", "warn", "error", "debug"];
+function captureNodeConsole(trace) {
+  const original = Object.fromEntries(CONSOLE_LEVELS.map((level) => [level, console[level]]));
+  for (const level of CONSOLE_LEVELS) {
+    console[level] = (...args) => {
+      trace.recordLog(level, args.map((arg) => typeof arg === "string" ? arg : arg instanceof Error ? arg.stack ?? arg.message : safeJson(arg)).join(" "));
+      original[level](...args);
+    };
+  }
+  return () => {
+    for (const level of CONSOLE_LEVELS) console[level] = original[level];
+  };
+}
+function safeJson(value) {
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+var KEPT_TRACES = 200;
+function pruneTraces(directory) {
+  const traces = fs.readdirSync(directory).filter((name) => name.endsWith(".json")).sort();
+  for (const name of traces.slice(0, Math.max(0, traces.length - KEPT_TRACES))) {
+    fs.rmSync(path.join(directory, name), { force: true });
+  }
+}
+
+export {
+  RunTrace,
+  captureNodeConsole
+};
+//# sourceMappingURL=chunk-4UDFYF5G.js.map

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

@@ -0,0 +1,35 @@
+// src/nodes/definition/browserCapabilities.ts
+function assetUrl(path) {
+  const clean = path.replace(/^\.\//, "").replace(/^assets\//, "");
+  return `/api/assets/${clean.split("/").map(encodeURIComponent).join("/")}`;
+}
+var browserAssetCapability = {
+  async read(ref, { signal }) {
+    const response = await fetch(assetUrl(ref.path), { signal });
+    if (!response.ok) throw new Error(`Could not read asset ${ref.path} (${response.status})`);
+    return new Uint8Array(await response.arrayBuffer());
+  },
+  async write(data, metadata, { signal }) {
+    const name = metadata.suggestedName?.trim() || "asset.bin";
+    const form = new FormData();
+    form.append("file", new Blob([new Uint8Array(data)], { type: metadata.mediaType }), name);
+    const response = await fetch("/api/assets", {
+      method: "POST",
+      body: form,
+      signal
+    });
+    if (!response.ok) throw new Error(`Could not write asset ${name} (${response.status})`);
+    const result = await response.json();
+    if (!result.path) throw new Error(`Asset upload returned no path for ${name}`);
+    return { path: result.path, ...metadata.mediaType ? { mediaType: metadata.mediaType } : {} };
+  },
+  async resolveUrl(ref) {
+    return { value: assetUrl(ref.path), release: () => {
+    } };
+  }
+};
+
+export {
+  browserAssetCapability
+};
+//# sourceMappingURL=chunk-53NMBJAO.js.map