@field/cascade 0.11.0 → 0.12.0

package/dist/cli/chunk-MIIEFUGG.js

@@ -1,623 +0,0 @@
-import {
-  writeFileAtomicSync
-} from "./chunk-WPUDGEFY.js";
-import {
-  readProjectManifest
-} from "./chunk-RQZ4SX5R.js";
-
-// server/src/compile.ts
-import * as esbuild from "esbuild";
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-var __dirname_compile = path.dirname(fileURLToPath(import.meta.url));
-function cascadeRuntimePlugin(project) {
-  return {
-    name: "cascade-runtime",
-    setup(build2) {
-      build2.onResolve({ filter: /^cascade\/(?:io|image|shell|net|config|stage)$/ }, (args) => ({
-        path: args.path,
-        namespace: "cascade-runtime"
-      }));
-      build2.onResolve({ filter: /^(?:@cascade|cascade)\/contracts$/ }, () => {
-        const candidates = [
-          path.join(__dirname_compile, "..", "contracts", "index.js"),
-          path.join(__dirname_compile, "..", "..", "packages", "contracts", "dist", "index.js")
-        ];
-        const found = candidates.find((c) => fs.existsSync(c));
-        if (!found) {
-          return { errors: [{ text: `@cascade/contracts not found (looked in ${candidates.join(", ")})` }] };
-        }
-        return { path: found };
-      });
-      build2.onLoad({ filter: /.*/, namespace: "cascade-runtime" }, (args) => {
-        if (args.path === "cascade/config") {
-          return { contents: configRuntimeSource(readProjectManifest(project.root).settings), loader: "ts" };
-        }
-        const candidates = [
-          path.join(__dirname_compile, "runtime", `${args.path.slice("cascade/".length)}.ts`),
-          path.join(__dirname_compile, "..", "src", "runtime", `${args.path.slice("cascade/".length)}.ts`)
-        ];
-        const found = candidates.find((c) => fs.existsSync(c));
-        if (!found) {
-          return { errors: [{ text: `${args.path} runtime not found (looked in ${candidates.join(", ")})` }] };
-        }
-        return { contents: fs.readFileSync(found, "utf-8"), loader: "ts", resolveDir: path.dirname(found) };
-      });
-    }
-  };
-}
-function commonOptions(project) {
-  return {
-    bundle: true,
-    format: "esm",
-    platform: "browser",
-    target: "es2022",
-    write: false,
-    logLevel: "silent",
-    plugins: [cascadeRuntimePlugin(project)]
-  };
-}
-async function compileProjectModule(project, moduleName) {
-  try {
-    await project.moduleRunsOn(moduleName);
-    return await compileEntry(project, project.resolve(`nodes/${moduleName}/index.ts`));
-  } catch (err) {
-    return { ok: false, code: "", errors: [errorMessage(err)] };
-  }
-}
-async function compileProjectPanel(project, panelName) {
-  try {
-    return await compileEntry(project, await project.resolvePanelEntry(panelName));
-  } catch (err) {
-    return { ok: false, code: "", errors: [errorMessage(err)] };
-  }
-}
-async function compileEmbedded(project, code) {
-  try {
-    const result = await esbuild.build({
-      ...commonOptions(project),
-      stdin: {
-        contents: code,
-        loader: "ts",
-        resolveDir: project.root,
-        sourcefile: "embedded.ts"
-      }
-    });
-    return toResult(result);
-  } catch (err) {
-    return { ok: false, code: "", errors: [errorMessage(err)] };
-  }
-}
-function toResult(result) {
-  const errors = result.errors.map((e) => e.text);
-  const code = result.outputFiles?.[0]?.text ?? "";
-  return { ok: errors.length === 0, code, errors };
-}
-async function compileEntry(project, entryPath2) {
-  return toResult(await esbuild.build({ ...commonOptions(project), entryPoints: [entryPath2] }));
-}
-function configRuntimeSource(settings) {
-  return `function deepFreeze(value) { if (value && typeof value === 'object') { for (const item of Object.values(value)) deepFreeze(item); Object.freeze(value); } return value; }
-const values = deepFreeze(${JSON.stringify(settings)});
-function value(name) { return Object.prototype.hasOwnProperty.call(values, name) ? values[name] : undefined; }
-export const config = Object.freeze({
-  get(name, fallback) { return value(name) ?? fallback; },
-  string(name, fallback = '') { const item = value(name); return typeof item === 'string' ? item : fallback; },
-  number(name, fallback = 0) { const item = value(name); return typeof item === 'number' && Number.isFinite(item) ? item : fallback; },
-  boolean(name, fallback = false) { const item = value(name); return typeof item === 'boolean' ? item : fallback; },
-  has(name) { return value(name) !== undefined; }
-});`;
-}
-function errorMessage(err) {
-  if (err && typeof err === "object" && "errors" in err) {
-    const errors = err.errors;
-    if (errors?.length) return errors.map((e) => e.text).join("\n");
-  }
-  return err instanceof Error ? err.message : String(err);
-}
-
-// server/src/pythonWorker.ts
-import { spawn } from "child_process";
-import os from "node:os";
-import path2 from "node:path";
-import readline from "readline";
-var REQUEST_TIMEOUT_MS = 12e4;
-var CANCEL_GRACE_MS = 3e3;
-var StageCancelledError = class extends Error {
-  constructor(stage) {
-    super(`stage "${stage}" was cancelled`);
-    this.cancelled = true;
-    this.name = "StageCancelledError";
-  }
-};
-var liveWorkers = /* @__PURE__ */ new Set();
-function pythonWorkerStatuses() {
-  return [...liveWorkers].map((worker) => worker.status);
-}
-function shutdownAllPythonWorkers() {
-  for (const worker of [...liveWorkers]) worker.shutdown();
-}
-var PythonWorker = class {
-  constructor(project, entrypoint, python = "python3", env = process.env, options = {}) {
-    this.proc = null;
-    this.nextId = 1;
-    this.queue = [];
-    /** The request the worker is running, or one it was told to abandon and has
-     *  not yet answered. Nothing else is written until it answers or exits. */
-    this.inFlight = null;
-    /** Set once the in-flight request has been cancelled: its answer is
-     *  discarded whatever it says. */
-    this.inFlightCancelled = false;
-    this.killTimer = null;
-    /** The code hash the running process started with. */
-    this.spawnedCodeHash = null;
-    /** Set by a restart, cleared by the answer that follows it. */
-    this.restartPending = false;
-    /** How many times the worker restarted because its code changed. */
-    this.restarts = 0;
-    this.project = project;
-    this.entrypoint = entrypoint;
-    this.python = python;
-    this.env = env;
-    this.cancelGraceMs = options.cancelGraceMs ?? CANCEL_GRACE_MS;
-    this.requestTimeoutMs = options.requestTimeoutMs ?? REQUEST_TIMEOUT_MS;
-    this.sources = options.sources ?? null;
-    this.onStderr = options.onStderr ?? ((text) => console.error("[python-worker]", text));
-    liveWorkers.add(this);
-  }
-  get status() {
-    const pid = this.pid;
-    return {
-      entrypoint: this.entrypoint,
-      pid,
-      state: pid === null ? "stopped" : this.inFlight ? "busy" : "idle",
-      queued: this.queue.length,
-      codeHash: this.spawnedCodeHash,
-      restarts: this.restarts
-    };
-  }
-  /** The code hash the running worker started with; null before the first
-   *  request or when sources are not watched. */
-  get codeHash() {
-    return this.spawnedCodeHash;
-  }
-  /** The worker's process id, or null when none is running. For tests and
-   *  diagnostics: a cancelled stage must not leave an orphan behind. */
-  get pid() {
-    return this.proc?.pid ?? null;
-  }
-  ensureStarted() {
-    if (this.proc && this.proc.exitCode === null && this.proc.signalCode === null) return this.proc;
-    this.spawnedCodeHash = this.sources?.codeHash() ?? null;
-    const scriptPath = this.project.resolve(this.entrypoint);
-    const proc = spawn(this.python, [scriptPath], { cwd: this.project.root, env: this.spawnEnv() });
-    readline.createInterface({ input: proc.stdout }).on("line", (line) => this.handleLine(proc, line));
-    proc.stderr.on("data", (chunk) => this.onStderr(chunk.toString().trimEnd()));
-    proc.stdin.on("error", () => {
-    });
-    proc.on("exit", (code, signal) => {
-      if (this.proc !== proc) return;
-      this.proc = null;
-      this.clearKillTimer();
-      const current = this.inFlight;
-      const cancelled = this.inFlightCancelled;
-      this.inFlight = null;
-      this.inFlightCancelled = false;
-      if (current && !cancelled) {
-        console.warn(`[python-worker] exited (${signal ?? `code ${code}`}) \u2014 will respawn on next call`);
-        this.settle(current, new Error(`python worker exited (${signal ?? `code ${code}`}) before responding`));
-      }
-      this.pump();
-    });
-    this.proc = proc;
-    return proc;
-  }
-  /**
-   * The environment for a new process. With sources watched, Python's bytecode
-   * cache is moved to a folder named by the code hash.
-   *
-   * Without that a restart is not enough: Python validates a `.pyc` by the
-   * source's size and its mtime in whole seconds, so an edit that keeps the
-   * length (`VALUE = 1` to `VALUE = 2`) within the same second is served from
-   * the old bytecode by the fresh process. Found by the respawn test.
-   */
-  spawnEnv() {
-    if (!this.spawnedCodeHash) return this.env;
-    const prefix = path2.join(os.tmpdir(), "cascade-pycache", this.spawnedCodeHash);
-    return { ...this.env, PYTHONPYCACHEPREFIX: prefix };
-  }
-  handleLine(proc, line) {
-    if (this.proc !== proc) return;
-    let msg;
-    try {
-      msg = JSON.parse(line);
-    } catch {
-      console.error("[python-worker] non-JSON line from worker:", line);
-      return;
-    }
-    const current = this.inFlight;
-    if (!current || msg.id !== current.id) return;
-    const cancelled = this.inFlightCancelled;
-    this.inFlight = null;
-    this.inFlightCancelled = false;
-    this.clearKillTimer();
-    if (!cancelled) {
-      const restarted = this.restartPending;
-      this.restartPending = false;
-      if (msg.ok) {
-        this.settle(current, null, {
-          result: msg.result,
-          codeHash: this.spawnedCodeHash,
-          restarted,
-          ...typeof msg.cache === "string" ? { projectCache: msg.cache } : {}
-        });
-      } else this.settle(current, new Error(msg.error || "python worker reported an error"));
-    }
-    this.pump();
-  }
-  settle(request, error, answer) {
-    if (request.timer) clearTimeout(request.timer);
-    request.timer = null;
-    if (error) request.reject(error);
-    else request.resolve(answer);
-  }
-  /**
-   * Stop a running worker whose code changed since it started. Only ever
-   * called with nothing in flight, so no request is lost: the exit handler
-   * finds no current request, and the next `ensureStarted` spawns afresh.
-   */
-  restartIfCodeChanged() {
-    if (!this.sources || !this.proc) return;
-    const now = this.sources.codeHash();
-    if (now === this.spawnedCodeHash) return;
-    console.warn(`[python-worker] stage code changed (${this.spawnedCodeHash} -> ${now}), restarting`);
-    const stale = this.proc;
-    this.proc = null;
-    stale.kill();
-    this.restarts += 1;
-    this.restartPending = true;
-  }
-  clearKillTimer() {
-    if (this.killTimer) clearTimeout(this.killTimer);
-    this.killTimer = null;
-  }
-  /** Send the next queued request if the worker is free. */
-  pump() {
-    if (this.inFlight) return;
-    const next = this.queue.shift();
-    if (!next) return;
-    this.restartIfCodeChanged();
-    const proc = this.ensureStarted();
-    this.inFlight = next;
-    this.inFlightCancelled = false;
-    proc.stdin.write(next.line);
-  }
-  /** Run a stage and return its result. */
-  async call(stage, args, options = {}) {
-    return (await this.callWithMeta(stage, args, options)).result;
-  }
-  /** Run a stage and return its result with the code hash that produced it. */
-  callWithMeta(stage, args, options = {}) {
-    const { signal, cascade } = options;
-    if (signal?.aborted) return Promise.reject(new StageCancelledError(stage));
-    const id = this.nextId++;
-    return new Promise((resolve, reject) => {
-      const onAbort = () => this.cancel(id);
-      const request = {
-        id,
-        stage,
-        line: JSON.stringify(cascade ? { id, stage, args, cascade } : { id, stage, args }) + "\n",
-        resolve: (r) => {
-          signal?.removeEventListener("abort", onAbort);
-          resolve(r);
-        },
-        reject: (e) => {
-          signal?.removeEventListener("abort", onAbort);
-          reject(e);
-        },
-        timer: null
-      };
-      request.timer = setTimeout(() => {
-        this.cancel(id, new Error(`python worker timed out after ${this.requestTimeoutMs}ms on stage "${stage}"`));
-      }, this.requestTimeoutMs);
-      signal?.addEventListener("abort", onAbort, { once: true });
-      this.queue.push(request);
-      this.pump();
-    });
-  }
-  /**
-   * Withdraw a request. A queued one is dropped without ever reaching Python;
-   * the one in flight is interrupted, and its answer — whenever it comes — is
-   * discarded, so a superseded result is never delivered.
-   */
-  cancel(id, reason) {
-    const queued = this.queue.findIndex((request) => request.id === id);
-    if (queued >= 0) {
-      const [request] = this.queue.splice(queued, 1);
-      this.settle(request, reason ?? new StageCancelledError(request.stage));
-      return;
-    }
-    const current = this.inFlight;
-    if (!current || current.id !== id || this.inFlightCancelled) return;
-    this.inFlightCancelled = true;
-    this.settle(current, reason ?? new StageCancelledError(current.stage));
-    const proc = this.proc;
-    if (!proc) return;
-    proc.kill("SIGINT");
-    this.clearKillTimer();
-    this.killTimer = setTimeout(() => {
-      this.killTimer = null;
-      if (this.proc === proc && this.inFlight === current) proc.kill("SIGKILL");
-    }, this.cancelGraceMs);
-  }
-  shutdown() {
-    liveWorkers.delete(this);
-    this.clearKillTimer();
-    for (const request of this.queue.splice(0)) this.settle(request, new Error("python worker shut down"));
-    const current = this.inFlight;
-    this.inFlight = null;
-    this.inFlightCancelled = false;
-    if (current) this.settle(current, new Error("python worker shut down"));
-    const proc = this.proc;
-    this.proc = null;
-    proc?.kill();
-  }
-};
-
-// server/src/stageCache.ts
-import { createHash as createHash2 } from "node:crypto";
-import fs3 from "node:fs";
-import path4 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-
-// server/src/stageSources.ts
-import { createHash } from "node:crypto";
-import fs2 from "node:fs";
-import path3 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 = [path3.posix.dirname(entrypoint)];
-    if (worker) roots.push(path3.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 : path3.posix.join(relative, entry.name);
-      if (entry.isDirectory()) {
-        if (SKIPPED_DIRECTORIES.has(entry.name) || entry.name.startsWith(".")) continue;
-        this.walk(path3.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 = path4.dirname(fileURLToPath2(import.meta.url));
-  for (let depth = 0; depth < 6; depth++) {
-    try {
-      const manifest = JSON.parse(fs3.readFileSync(path4.join(directory, "package.json"), "utf8"));
-      if (manifest.name === "@field/cascade" && manifest.version) return version = manifest.version;
-    } catch {
-    }
-    directory = path4.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 (path4.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(path4.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(path4.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 {
-  compileProjectModule,
-  compileProjectPanel,
-  compileEmbedded,
-  StageCancelledError,
-  pythonWorkerStatuses,
-  shutdownAllPythonWorkers,
-  PythonWorker,
-  cascadeVersion,
-  stageSources,
-  callStage,
-  formatStageTrace
-};
-//# sourceMappingURL=chunk-MIIEFUGG.js.map