@field/cascade 0.8.0 → 0.11.0

package/dist/cli/chunk-QBBKRNGY.js

@@ -0,0 +1,90 @@
+import {
+  PythonWorker,
+  callStage,
+  stageSources
+} from "./chunk-MIIEFUGG.js";
+import {
+  readStageConfig,
+  runProjectStage
+} from "./chunk-VVGSLVSF.js";
+
+// server/src/runtime/stage.ts
+var BRIDGE_KEY = "__cascadeStageBridge";
+function installStageBridge(bridge) {
+  const globals = globalThis;
+  const previous = globals[BRIDGE_KEY];
+  globals[BRIDGE_KEY] = bridge ?? void 0;
+  return () => {
+    globals[BRIDGE_KEY] = previous;
+  };
+}
+
+// src/cli/projectStages.ts
+function installProjectStages(project, options = {}) {
+  let worker = null;
+  const warmWorker = (config) => {
+    if (options.worker === false || !config.worker) return null;
+    const sources = stageSources(project, config);
+    const key = `${config.python}\0${config.worker}\0${sources.roots.join("\0")}`;
+    if (worker?.key !== key) {
+      worker?.process.shutdown();
+      worker = {
+        key,
+        process: new PythonWorker(project, config.worker, config.python, process.env, {
+          sources,
+          // The one-shot path's bound, not Studio's two minutes: an offline
+          // render may run a stage for several.
+          requestTimeoutMs: 10 * 60 * 1e3,
+          // What a stage prints is shown with --verbose only, as before.
+          onStderr: options.onOutput ? (text) => {
+            for (const line of text.split("\n")) options.onOutput(null, "stderr", line);
+          } : options.verbose ? (text) => {
+            for (const line of text.split("\n")) console.warn(`[stage-worker] ${line}`);
+          } : () => {
+          }
+        })
+      };
+    }
+    return worker.process;
+  };
+  const dispose = installStageBridge(async (stage, args, callOptions) => {
+    const config = readStageConfig(project);
+    const warm = warmWorker(config);
+    if (warm) {
+      const { result: result2 } = await callStage(project, config, stage, args, (envelope) => warm.callWithMeta(stage, args, { signal: callOptions?.signal, cascade: envelope }), { onTrace: options.onTrace });
+      return result2;
+    }
+    const { result } = await callStage(project, config, stage, args, async (envelope) => ({
+      result: await runProjectStage(project, stage, args, {
+        // A superseded cook kills its subprocess rather than waiting for it.
+        signal: callOptions?.signal,
+        cascade: envelope,
+        codeHash: envelope.code,
+        /**
+         * A stage can log, and until 0.8 nobody could read it: `stderr` was
+         * consulted only on failure and `stdout` only for its last line. Behind
+         * `--verbose`, because a stage that prints per mark would bury the
+         * render it is part of; prefixed with the stage name, because a graph
+         * runs several.
+         */
+        onOutput: options.onOutput ? (stream, text) => {
+          for (const line of text.split("\n")) options.onOutput(stage, stream, line);
+        } : options.verbose ? (stream, text) => {
+          const write = stream === "stderr" ? console.warn : console.log;
+          for (const line of text.split("\n")) write(`[${stage}] ${line}`);
+        } : void 0
+      })
+    }), { onTrace: options.onTrace });
+    return result;
+  });
+  return () => {
+    dispose();
+    worker?.process.shutdown();
+    worker = null;
+  };
+}
+
+export {
+  installProjectStages
+};
+//# sourceMappingURL=chunk-QBBKRNGY.js.map

package/dist/cli/chunk-QQPA2ZHH.js

@@ -0,0 +1,273 @@
+// packages/runtime/src/builtins/math/definitions.ts
+function asComponents(value, label2) {
+  if (typeof value === "number") return [value];
+  if (Array.isArray(value) && value.every((part) => typeof part === "number"))
+    return value;
+  if (value === void 0 || value === null) return [0];
+  throw new Error(
+    `${label2} needs a number or a vector of numbers, and got ${describe(value)}`
+  );
+}
+function describe(value) {
+  if (Array.isArray(value)) return `an array of ${value.length}`;
+  return `a ${typeof value}`;
+}
+function combine(left, right, operate) {
+  const a = asComponents(left, "the first input");
+  const b = asComponents(right, "the second input");
+  if (a.length !== b.length && a.length !== 1 && b.length !== 1)
+    throw new Error(
+      `cannot combine a vector of ${a.length} with a vector of ${b.length}`
+    );
+  const width = Math.max(a.length, b.length);
+  const out = [];
+  for (let index = 0; index < width; index += 1)
+    out.push(operate(a[a.length === 1 ? 0 : index], b[b.length === 1 ? 0 : index]));
+  return width === 1 ? out[0] : out;
+}
+function map(value, operate) {
+  const components = asComponents(value, "the input");
+  const out = components.map(operate);
+  return out.length === 1 ? out[0] : out;
+}
+function divide(a, b) {
+  return b === 0 ? 0 : a / b;
+}
+var BINARY = {
+  add: (a, b) => a + b,
+  subtract: (a, b) => a - b,
+  multiply: (a, b) => a * b,
+  divide,
+  power: (a, b) => a ** b,
+  modulo: (a, b) => b === 0 ? 0 : a % b,
+  min: (a, b) => Math.min(a, b),
+  max: (a, b) => Math.max(a, b),
+  atan2: (a, b) => Math.atan2(a, b)
+};
+var DEG = Math.PI / 180;
+var UNARY = {
+  abs: Math.abs,
+  negate: (a) => -a,
+  floor: Math.floor,
+  ceil: Math.ceil,
+  round: Math.round,
+  sqrt: (a) => a < 0 ? 0 : Math.sqrt(a),
+  sign: Math.sign,
+  // Trigonometry in RADIANS, matching the expression engine, where bare `sin`
+  // is radians too. `radians` and `degrees` are here for the conversion, and
+  // the divergence from `Transform`'s degrees is recorded in AGENTS.md.
+  sin: Math.sin,
+  cos: Math.cos,
+  tan: Math.tan,
+  asin: (a) => Math.asin(Math.max(-1, Math.min(1, a))),
+  acos: (a) => Math.acos(Math.max(-1, Math.min(1, a))),
+  exp: Math.exp,
+  log: (a) => a <= 0 ? 0 : Math.log(a),
+  radians: (a) => a * DEG,
+  degrees: (a) => a / DEG,
+  /** The fractional part, always positive — `fract(-0.25)` is `0.75`, which is
+   *  what a repeating pattern wants and what GLSL's `fract` does. */
+  fract: (a) => a - Math.floor(a)
+};
+var COMPARE = {
+  greater: (a, b) => a > b,
+  "greater-or-equal": (a, b) => a >= b,
+  less: (a, b) => a < b,
+  "less-or-equal": (a, b) => a <= b,
+  equal: (a, b) => a === b,
+  "not-equal": (a, b) => a !== b
+};
+function options(table) {
+  return Object.keys(table).map((value) => ({ value, label: label(value) }));
+}
+function label(value) {
+  return value.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+var binaryDefinition = {
+  apiVersion: 1,
+  label: "Binary Math",
+  description: "Two values, one operation. Component-wise, and a scalar broadcasts against a vector.",
+  icon: "Plus",
+  runsOn: "portable",
+  inputs: {
+    a: { kind: "data", type: "any", default: 0, description: "First value." },
+    b: { kind: "data", type: "any", default: 0, description: "Second value." }
+  },
+  outputs: { value: { kind: "data", type: "any" } },
+  props: {
+    operation: {
+      type: "string",
+      default: "add",
+      control: "select",
+      options: options(BINARY),
+      label: "Operation"
+    }
+  }
+};
+function executeBinary(context) {
+  const operate = BINARY[context.props.operation];
+  if (!operate)
+    throw new Error(
+      `cascade.math.Binary has no operation "${context.props.operation}"`
+    );
+  context.outputs.value.set(combine(context.inputs.a, context.inputs.b, operate));
+}
+var unaryDefinition = {
+  apiVersion: 1,
+  label: "Unary Math",
+  description: "One value, one operation. Trigonometry is in radians.",
+  icon: "FunctionSquare",
+  runsOn: "portable",
+  inputs: {
+    value: { kind: "data", type: "any", default: 0 }
+  },
+  outputs: { value: { kind: "data", type: "any" } },
+  props: {
+    operation: {
+      type: "string",
+      default: "abs",
+      control: "select",
+      options: options(UNARY),
+      label: "Operation"
+    }
+  }
+};
+function executeUnary(context) {
+  const operate = UNARY[context.props.operation];
+  if (!operate)
+    throw new Error(
+      `cascade.math.Unary has no operation "${context.props.operation}"`
+    );
+  context.outputs.value.set(map(context.inputs.value, operate));
+}
+var clampDefinition = {
+  apiVersion: 1,
+  label: "Clamp",
+  description: "Hold a value between two bounds.",
+  icon: "Brackets",
+  runsOn: "portable",
+  inputs: {
+    value: { kind: "data", type: "any", default: 0 },
+    min: { kind: "data", type: "any", default: 0 },
+    max: { kind: "data", type: "any", default: 1 }
+  },
+  outputs: { value: { kind: "data", type: "any" } },
+  props: {}
+};
+function executeClamp(context) {
+  const lower = combine(context.inputs.value, context.inputs.min, Math.max);
+  context.outputs.value.set(combine(lower, context.inputs.max, Math.min));
+}
+var mixDefinition = {
+  apiVersion: 1,
+  label: "Mix",
+  description: "Blend between two values. Houdini's lerp.",
+  icon: "Blend",
+  runsOn: "portable",
+  inputs: {
+    a: { kind: "data", type: "any", default: 0, description: "The value at 0." },
+    b: { kind: "data", type: "any", default: 1, description: "The value at 1." },
+    bias: {
+      kind: "data",
+      type: "float",
+      default: 0.5,
+      min: 0,
+      max: 1,
+      step: 0.01,
+      description: "Not clamped: past 0..1 this extrapolates, which is useful."
+    }
+  },
+  outputs: { value: { kind: "data", type: "any" } },
+  props: {}
+};
+function executeMix(context) {
+  const bias = context.inputs.bias ?? 0.5;
+  const delta = combine(context.inputs.b, context.inputs.a, (b, a) => b - a);
+  context.outputs.value.set(
+    combine(context.inputs.a, delta, (a, d) => a + d * bias)
+  );
+}
+var compareDefinition = {
+  apiVersion: 1,
+  label: "Compare",
+  description: "Test two values. Outputs a bool, for a Switch.",
+  icon: "Equal",
+  runsOn: "portable",
+  inputs: {
+    a: { kind: "data", type: "float", default: 0 },
+    b: { kind: "data", type: "float", default: 0 }
+  },
+  outputs: { result: { kind: "data", type: "bool" } },
+  props: {
+    operation: {
+      type: "string",
+      default: "greater",
+      control: "select",
+      options: options(COMPARE),
+      label: "Test"
+    },
+    /**
+     * Scalars only, unlike the rest of this namespace.
+     *
+     * "Is this vector greater than that one" has no single right answer — all
+     * components, any component, or the length — and a node that picked one
+     * silently would be wrong for the other two readings. A comparison feeding
+     * a `Switch` wants one boolean, so the input is a `float` and the question
+     * does not arise.
+     */
+    tolerance: {
+      type: "float",
+      default: 0,
+      min: 0,
+      label: "Tolerance",
+      description: "Slack for Equal and Not Equal. Floating point rarely lands on exactly equal."
+    }
+  }
+};
+function executeCompare(context) {
+  const operation = context.props.operation;
+  const test = COMPARE[operation];
+  if (!test)
+    throw new Error(`cascade.math.Compare has no test "${context.props.operation}"`);
+  const a = context.inputs.a ?? 0;
+  const b = context.inputs.b ?? 0;
+  const tolerance = context.props.tolerance;
+  if (tolerance > 0 && (operation === "equal" || operation === "not-equal")) {
+    const near = Math.abs(a - b) <= tolerance;
+    context.outputs.result.set(operation === "equal" ? near : !near);
+    return;
+  }
+  context.outputs.result.set(test(a, b));
+}
+function registration(name, definition, execute) {
+  return {
+    kind: "definition-v1",
+    moduleId: `cascade.math.${name}`,
+    definition,
+    loadExecute: async () => execute
+  };
+}
+var binaryRegistration = registration("Binary", binaryDefinition, executeBinary);
+var unaryRegistration = registration("Unary", unaryDefinition, executeUnary);
+var clampRegistration = registration("Clamp", clampDefinition, executeClamp);
+var mixRegistration = registration("Mix", mixDefinition, executeMix);
+var compareRegistration = registration("Compare", compareDefinition, executeCompare);
+var mathNodeRegistrations = Object.freeze([
+  binaryRegistration,
+  unaryRegistration,
+  clampRegistration,
+  mixRegistration,
+  compareRegistration
+]);
+var mathNodeDefinitions = Object.freeze([
+  ["cascade.math.Binary", binaryDefinition],
+  ["cascade.math.Unary", unaryDefinition],
+  ["cascade.math.Clamp", clampDefinition],
+  ["cascade.math.Mix", mixDefinition],
+  ["cascade.math.Compare", compareDefinition]
+]);
+
+export {
+  mathNodeRegistrations
+};
+//# sourceMappingURL=chunk-QQPA2ZHH.js.map

package/dist/cli/chunk-RLCAJBVR.js

@@ -0,0 +1,224 @@
+import {
+  browserAssetCapability
+} from "./chunk-53NMBJAO.js";
+import {
+  attachDefinition
+} from "./chunk-SGJAET2L.js";
+import {
+  createGpuHost
+} from "./chunk-GFS6W3C5.js";
+import {
+  validateNodeDefinition
+} from "./chunk-A4OAMOZH.js";
+
+// src/nodes/definition/browserShellCapability.ts
+var capability = null;
+function forgetShellCapability() {
+  capability = null;
+}
+async function token() {
+  if (capability) return capability;
+  const response = await fetch("/api/shell/capability", { cache: "no-store" });
+  if (!response.ok) {
+    throw new Error(
+      response.status === 404 ? "The shell capability is disabled on this server. It is available on a loopback server, or one started with an explicit trusted host." : `Could not obtain the shell capability (${response.status})`
+    );
+  }
+  const { capability: issued } = await response.json();
+  if (typeof issued !== "string" || !issued) {
+    throw new Error("Server issued no shell capability");
+  }
+  capability = issued;
+  return issued;
+}
+function domSignal(signal) {
+  if (!signal) return void 0;
+  const controller = new AbortController();
+  if (signal.aborted) controller.abort(signal.reason);
+  else signal.addEventListener("abort", () => controller.abort(signal.reason), { once: true });
+  return controller.signal;
+}
+async function post(body, signal) {
+  const bridged = domSignal(signal);
+  const send = async (issued) => fetch("/api/shell", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Cascade-Shell-Capability": issued
+    },
+    body: JSON.stringify(body),
+    ...bridged ? { signal: bridged } : {}
+  });
+  let response = await send(await token());
+  if (response.status === 403) {
+    capability = null;
+    response = await send(await token());
+  }
+  return response;
+}
+function requestBody(command, args, options) {
+  const { signal: _signal, ...rest } = options ?? {};
+  return {
+    command,
+    ...args ? { args } : {},
+    // `/api/shell` has always accepted execution options at the top level;
+    // keep the Studio adapter on that wire contract. Nesting them under
+    // `options` silently drops stdin, timeout, cwd and env in the route parser.
+    ...rest
+  };
+}
+async function fail(response) {
+  let payload = null;
+  try {
+    payload = await response.json();
+  } catch {
+  }
+  const message = typeof payload?.error === "string" ? payload.error : `Shell request failed (${response.status})`;
+  if (payload?.code === "COMMAND_NOT_ALLOWED") {
+    throw new Error(`${message}. Add it under Allowed Commands in Project Settings.`);
+  }
+  throw new Error(message);
+}
+var browserShellCapability = {
+  async run(command, args, options) {
+    const response = await post(requestBody(command, args, options), options?.signal);
+    if (!response.ok) await fail(response);
+    const { ok: _ok, ...result } = await response.json();
+    return result;
+  },
+  async runJson(command, args, options) {
+    const result = await this.run(command, args, options);
+    try {
+      return JSON.parse(result.stdout);
+    } catch {
+      throw new Error(`${command} did not print JSON`);
+    }
+  }
+};
+async function shellRouteAvailable() {
+  const forget = () => {
+    forgetShellCapability();
+    return false;
+  };
+  if (typeof fetch !== "function") return forget();
+  try {
+    const response = await fetch("/api/shell/capability", { cache: "no-store" });
+    if (!response.ok) return forget();
+    const { capability: issued } = await response.json();
+    if (typeof issued !== "string" || !issued) return forget();
+    capability = issued;
+    return true;
+  } catch {
+    return forget();
+  }
+}
+
+// src/browser/gpu.ts
+function createBrowserGpuHost() {
+  const gpu = globalThis.navigator?.gpu;
+  if (!gpu) return void 0;
+  return createGpuHost({
+    async acquire() {
+      const adapter = await gpu.requestAdapter();
+      if (!adapter) {
+        throw new Error(
+          "No WebGPU adapter is available \u2014 the browser reports WebGPU but the system offers no GPU to render on."
+        );
+      }
+      const device = await adapter.requestDevice();
+      const info = adapter.info;
+      return {
+        device,
+        info: {
+          vendor: info?.vendor ?? "",
+          architecture: info?.architecture ?? "",
+          device: info?.device ?? "",
+          description: info?.description ?? ""
+        },
+        limits: device.limits ?? adapter.limits
+      };
+    }
+  });
+}
+
+// src/nodes/definition/projectDefinition.ts
+var studioCapabilities = {
+  assets: browserAssetCapability,
+  // Installed only where the browser has WebGPU, and absent rather than
+  // stubbed otherwise. That is what makes the failure a sentence: the preflight
+  // reports `runtime/missing-capability` and the adapter throws "requires the
+  // Studio gpu capability", both naming what is missing. A stub that threw on
+  // first use would name nothing.
+  ...gpuCapabilityIfAvailable(),
+  /**
+   * Shell is present up front and withdrawn if the route turns out not to be
+   * there, which is the opposite way round from gpu and worth the sentence.
+   *
+   * `navigator.gpu` is a synchronous check, so gpu can be absent from the map
+   * before anything reads it. Whether the shell route exists takes a fetch, and
+   * this object is a module-level const read by three default parameters — so
+   * the choice is between delaying Studio's boot on a request, racing the
+   * probe, or installing and withdrawing. Installing is the one where the
+   * common case (a loopback server, where the route is always there) has no
+   * race at all and no cost.
+   *
+   * What it costs: on a server that does NOT offer the route, a cook in the
+   * first few milliseconds after boot sees the capability present and fails at
+   * the fetch instead of at the gate. That failure still names itself — *"the
+   * shell capability is disabled on this server"* — so it is a worse-shaped
+   * error rather than a silent one, and once the probe lands the preflight is
+   * correct from then on.
+   */
+  shell: browserShellCapability
+};
+void shellRouteAvailable().then((available) => {
+  if (!available) delete studioCapabilities.shell;
+});
+function gpuCapabilityIfAvailable() {
+  const gpu = createBrowserGpuHost();
+  return gpu ? { gpu } : {};
+}
+function declaresDefinitionV1(value) {
+  return typeof value === "object" && value !== null && value.apiVersion === 1;
+}
+function definitionAdapterError(value) {
+  const diagnostics = validateNodeDefinition(value);
+  if (!diagnostics.length) return null;
+  return diagnostics.map((item) => `${item.code}: ${item.message}`).join("\n");
+}
+function missingStudioCapabilities(definition, capabilities = studioCapabilities) {
+  const declared = definition?.capabilities;
+  if (!Array.isArray(declared)) return [];
+  return declared.filter((name) => typeof name === "string").filter((name) => !capabilities[name]);
+}
+function moduleNodeFunction(node, moduleId, modulePromise, capabilities = studioCapabilities) {
+  const prepared = modulePromise.then((module) => adaptModule(node, moduleId, module, capabilities));
+  prepared.catch(() => {
+  });
+  return (n, g) => prepared.then((fn) => fn(n, g));
+}
+function adaptModule(node, moduleId, module, capabilities = studioCapabilities) {
+  if (!declaresDefinitionV1(module.definition)) {
+    return (n, g) => module.execute(n, g);
+  }
+  const invalid = definitionAdapterError(module.definition);
+  if (invalid) throw new Error(`${moduleId} exports an invalid definition-v1 literal:
+${invalid}`);
+  const registration = {
+    kind: "definition-v1",
+    moduleId,
+    definition: module.definition,
+    loadExecute: async () => module.execute
+  };
+  return attachDefinition(node, registration, capabilities);
+}
+
+export {
+  studioCapabilities,
+  declaresDefinitionV1,
+  definitionAdapterError,
+  missingStudioCapabilities,
+  moduleNodeFunction,
+  adaptModule
+};
+//# sourceMappingURL=chunk-RLCAJBVR.js.map