@field/cascade 0.11.0 → 0.12.0

package/dist/cli/{chunk-FCDXJ6EK.js → chunk-CTPLRSWF.js}

@@ -16,7 +16,7 @@ import {
   CORE_TYPES,
   canConnectTypes,
   normalizeCascadeType
-} from "./chunk-BIJO5OFS.js";
+} from "./chunk-FWMSGKEH.js";
 
 // src/utils/nodeTypeUtils.ts
 var nodeClassRegistries = /* @__PURE__ */ new Map();
@@ -136,16 +136,6 @@ function normalizeColor(input) {
   }
   return { r: 0, g: 0, b: 0, a: 1 };
 }
-function colorToCss(color) {
-  const r = Math.round(color.r * 255);
-  const g = Math.round(color.g * 255);
-  const b = Math.round(color.b * 255);
-  const a = color.a !== void 0 ? color.a : 1;
-  if (a < 1) {
-    return `rgba(${r},${g},${b},${a})`;
-  }
-  return `rgb(${r},${g},${b})`;
-}
 function isColorValue(value) {
   if (typeof value === "string") {
     return value.startsWith("#") || value.startsWith("rgb(");
@@ -2197,7 +2187,6 @@ export {
   isStandardLibraryNode,
   getNodeClass,
   normalizeColor,
-  colorToCss,
   isColorValue,
   CORE_TYPES2 as CORE_TYPES,
   isCoreType,
@@ -2205,4 +2194,4 @@ export {
   canConnect,
   Node
 };
-//# sourceMappingURL=chunk-FCDXJ6EK.js.map
+//# sourceMappingURL=chunk-CTPLRSWF.js.map

package/dist/cli/chunk-EU4ZFZ7Y.js

@@ -0,0 +1,122 @@
+import {
+  readProjectManifest
+} from "./chunk-2JEU3MGB.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, entryPath) {
+  return toResult(await esbuild.build({ ...commonOptions(project), entryPoints: [entryPath] }));
+}
+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);
+}
+
+export {
+  compileProjectModule,
+  compileProjectPanel,
+  compileEmbedded
+};
+//# sourceMappingURL=chunk-EU4ZFZ7Y.js.map

package/dist/cli/{chunk-WIH4TEIS.js → chunk-EZRWJ4G2.js}

@@ -101,4 +101,4 @@ export {
   canvasAvailable,
   installHeadlessCanvas
 };
-//# sourceMappingURL=chunk-WIH4TEIS.js.map
+//# sourceMappingURL=chunk-EZRWJ4G2.js.map

package/dist/cli/{chunk-BIJO5OFS.js → chunk-FWMSGKEH.js}

@@ -68,4 +68,4 @@ export {
   normalizeCascadeType,
   canConnectTypes
 };
-//# sourceMappingURL=chunk-BIJO5OFS.js.map
+//# sourceMappingURL=chunk-FWMSGKEH.js.map

package/dist/cli/{chunk-POMMNKZZ.js → chunk-G23A2BZZ.js}

@@ -118,6 +118,34 @@ var VERBS = [
       call: { kind: "cli", argv: (args, resolve) => ["export", resolve(args.graph), ...args.out ? ["--out", resolve(args.out)] : ["--plan"]] }
     }]
   },
+  {
+    ...editorVerb,
+    name: "share",
+    json: "keep",
+    usage: "<graph-file | site-directory> [--name <slug>] [--scope <team>] [--protected]",
+    summary: "Export and deploy to Vercel as cascade-<slug>; print the link and record it in shares.json",
+    mcp: [{
+      name: "share",
+      description: "Share a graph's editor, or a static directory with an index.html, as one link (cascade share): export, deploy to the Vercel project cascade-<name> and return `url`, recorded in the project's shares.json. Public unless `protected`.",
+      inputSchema: object({
+        graph: { type: "string", description: "The .cascade file or site directory, relative to the project directory" },
+        name: { type: "string", description: "Slug; the Vercel project is cascade-<name> (default: the editor id or directory name)" },
+        scope: { type: "string", description: "Vercel team (default field-io)" },
+        protected: { type: "boolean", description: "Require Vercel Authentication instead of a public link" }
+      }, ["graph"]),
+      call: {
+        kind: "cli",
+        argv: (args, resolve) => [
+          "share",
+          resolve(args.graph),
+          ...args.name ? ["--name", String(args.name)] : [],
+          ...args.scope ? ["--scope", String(args.scope)] : [],
+          ...args.protected ? ["--protected"] : []
+        ],
+        timeoutMs: () => 10 * 6e4
+      }
+    }]
+  },
   { ...editorVerb, name: "publish", usage: "<graph-file> <node>.<prop> [--label ...]", summary: "Publish a node prop as an editor parameter" },
   { ...editorVerb, name: "freeze", usage: "<graph-file> <node> --fields <a,b>", summary: "Snapshot chosen fields of a live data source for export" },
   { ...editorVerb, name: "scene", usage: "<graph-file> <scene.json> --out <new-graph-file>", summary: "Apply a scene file to a copy of the graph" },
@@ -434,11 +462,11 @@ var VERBS = [
   {
     ...lockVerb,
     name: "ladder",
-    usage: "<graph-file> <node> --name <name> --vary <node.prop>=<a,b,c> | --seeds <a,b,c>",
-    summary: "Cook 3-5 variants, write a labelled contact sheet and ladders/<id>.json",
+    usage: "<graph-file> <node> --name <name> --vary <node.prop>=<a,b,c> | --seeds <a,b,c> [--cairn <vault dir>]",
+    summary: "Cook 3-5 variants, write a labelled contact sheet and ladders/<id>.json; --cairn makes a tap-to-pick card",
     mcp: [{
       name: "ladder",
-      description: "Cook `node` once per variant (cascade ladder) and return the contact sheet, each variant image and the record ladders/<id>.json. `vary` maps node.prop to a list of values (zipped; one value applies to all); `seeds` varies the graph seed. Three to five variants is the usual.",
+      description: 'Cook `node` once per variant (cascade ladder) and return the contact sheet, each variant image and the record ladders/<id>.json. `vary` maps node.prop to a list of values (zipped; one value applies to all); `seeds` varies the graph seed. Three to five variants is the usual. `cairn` is a directory in the Substrate vault (the space\'s _attachments/ladders/<id>): each variant is copied there and `data.cairnChoice` is a cairn:choice fence to post as is (at most 8 variants); a tap comes back as "Picked: <label> (pick:<id>:<n>)", then call `pick` with ladder <id> and variant <n>.',
       inputSchema: object({
         graph,
         node: { type: "string" },
@@ -447,7 +475,9 @@ var VERBS = [
         seeds: { type: "array", items: { type: "integer" } },
         columns: { type: "integer" },
         note: { type: "string" },
-        live: { type: "boolean" }
+        live: { type: "boolean" },
+        cairn: { type: "string", description: "Absolute vault directory for the variant images; returns data.cairnChoice" },
+        vault: { type: "string", description: "Absolute vault root the cairnChoice image paths are relative to (default: nearest .obsidian or .git above `cairn`)" }
       }, ["graph", "node", "name"]),
       call: {
         kind: "cli",
@@ -457,6 +487,9 @@ var VERBS = [
           args.node,
           "--name",
           args.name,
+          // Outside the project by design (the vault), so passed as given: absolute.
+          ...args.cairn ? ["--cairn", String(args.cairn)] : [],
+          ...args.vault ? ["--vault", String(args.vault)] : [],
           ...Object.entries(args.vary ?? {}).flatMap(([key, values]) => [
             "--vary",
             `${key}=${(Array.isArray(values) ? values : [values]).map((value) => JSON.stringify(value)).join(",")}`
@@ -669,4 +702,4 @@ export {
   graphCommandsHelp,
   mainHelp
 };
-//# sourceMappingURL=chunk-POMMNKZZ.js.map
+//# sourceMappingURL=chunk-G23A2BZZ.js.map

package/dist/cli/{chunk-35D343DC.js → chunk-GRIN2DDP.js}

@@ -100,6 +100,23 @@ var Color = Object.freeze({
   opaque(color) {
     return [clamp(color[0]), clamp(color[1]), clamp(color[2]), 1];
   },
+  /**
+   * A colour saved in an older shape, as the one colour: `{ r, g, b, a? }`
+   * (the class-based image nodes stored that until 2026-11-07) or three
+   * components, with alpha 1. Components above 1 are read as 0–255, the way
+   * those nodes read them. Anything else comes back unchanged, so a reader can
+   * apply this to every stored `color` value and validate the result.
+   */
+  upgrade(value) {
+    const legacy = value !== null && typeof value === "object" && !Array.isArray(value) && "r" in value && "g" in value && "b" in value ? value : Array.isArray(value) && value.length === 3 ? { r: value[0], g: value[1], b: value[2] } : null;
+    if (!legacy) return value;
+    const parts = [legacy.r, legacy.g, legacy.b, legacy.a ?? 1];
+    if (!parts.every((part) => typeof part === "number" && Number.isFinite(part))) return value;
+    const numbers = parts;
+    const unit2 = numbers.slice(0, 3).every((part) => part <= 1);
+    const read = (part) => unit2 ? part : part / 255;
+    return [read(numbers[0]), read(numbers[1]), read(numbers[2]), legacy.a === void 0 ? 1 : read(numbers[3])];
+  },
   /**
    * Four unit components from anything indexable, clamping and defaulting a
    * missing alpha to 1. The reader for a `Cd` attribute's flat array, and the
@@ -1438,10 +1455,11 @@ var registrationsById = new Map(
 );
 
 export {
+  Color,
   LIGHT_DEFAULTS,
   isLight,
   isScene,
   geoNodeDefinitions,
   geoNodeRegistrations
 };
-//# sourceMappingURL=chunk-35D343DC.js.map
+//# sourceMappingURL=chunk-GRIN2DDP.js.map

package/dist/cli/chunk-JVOCK5W4.js

@@ -0,0 +1,83 @@
+// packages/runtime/src/builtins/assert/definitions.ts
+var rangeDefinition = {
+  apiVersion: 1,
+  runsOn: "portable",
+  label: "Assert Range",
+  description: "Fails the run unless value is a finite number in [min, max]; passes value through",
+  icon: "ShieldCheck",
+  inputs: { value: { kind: "data", type: "float", default: 0 } },
+  outputs: { value: { kind: "data", type: "float" } },
+  props: {
+    min: { type: "float", default: 0 },
+    max: { type: "float", default: 1 },
+    message: { type: "string", default: "" }
+  }
+};
+var equalsDefinition = {
+  apiVersion: 1,
+  runsOn: "portable",
+  label: "Assert Equals",
+  description: "Fails the run unless value equals expected (JSON-equal; numbers within tolerance); passes value through",
+  icon: "ShieldCheck",
+  inputs: { value: { kind: "data", type: "any", default: null } },
+  outputs: { value: { kind: "data", type: "any" } },
+  props: {
+    expected: { type: "any", default: null },
+    tolerance: { type: "float", default: 0, min: 0 },
+    message: { type: "string", default: "" }
+  }
+};
+var trueDefinition = {
+  apiVersion: 1,
+  runsOn: "portable",
+  label: "Assert True",
+  description: "Fails the run unless value is true (wire a condition, or give the prop an expression); passes value through",
+  icon: "ShieldCheck",
+  inputs: { value: { kind: "data", type: "bool", default: false } },
+  outputs: { value: { kind: "data", type: "bool" } },
+  props: { message: { type: "string", default: "" } }
+};
+var notBlankDefinition = {
+  apiVersion: 1,
+  runsOn: "portable",
+  label: "Assert Not Blank",
+  description: "Fails the run when an image (PNG or PPM) is one flat colour or fully transparent; passes the image through",
+  icon: "ShieldCheck",
+  capabilities: ["assets"],
+  inputs: { image: { kind: "data", type: "image" } },
+  outputs: { image: { kind: "data", type: "image" } },
+  props: {
+    tolerance: { type: "int", default: 0, min: 0, max: 255, step: 1 },
+    message: { type: "string", default: "" }
+  }
+};
+
+// packages/runtime/src/builtins/assert/index.ts
+var ASSERT_NAMESPACE = "cascade.assert.";
+function lazy(name, definition, load) {
+  return { kind: "definition-v1", moduleId: `${ASSERT_NAMESPACE}${name}`, definition, loadExecute: load };
+}
+var rangeRegistration = lazy("Range", rangeDefinition, async () => (await import("./checks-3WB44XBL.js")).executeRange);
+var equalsRegistration = lazy("Equals", equalsDefinition, async () => (await import("./checks-3WB44XBL.js")).executeEquals);
+var trueRegistration = lazy("True", trueDefinition, async () => (await import("./checks-3WB44XBL.js")).executeTrue);
+var notBlankRegistration = lazy("NotBlank", notBlankDefinition, async () => (await import("./checks-3WB44XBL.js")).executeNotBlank);
+var assertNodeRegistrations = Object.freeze([
+  equalsRegistration,
+  notBlankRegistration,
+  rangeRegistration,
+  trueRegistration
+]);
+
+export {
+  rangeDefinition,
+  equalsDefinition,
+  trueDefinition,
+  notBlankDefinition,
+  ASSERT_NAMESPACE,
+  rangeRegistration,
+  equalsRegistration,
+  trueRegistration,
+  notBlankRegistration,
+  assertNodeRegistrations
+};
+//# sourceMappingURL=chunk-JVOCK5W4.js.map

package/dist/cli/chunk-KBGUO27Q.js

@@ -0,0 +1,15 @@
+// server/src/runtime/io.ts
+var IO_BRIDGE_KEY = "__cascadeIoBridge";
+function installIoBridge(bridge) {
+  const globals = globalThis;
+  const previous = globals[IO_BRIDGE_KEY];
+  globals[IO_BRIDGE_KEY] = bridge ?? void 0;
+  return () => {
+    globals[IO_BRIDGE_KEY] = previous;
+  };
+}
+
+export {
+  installIoBridge
+};
+//# sourceMappingURL=chunk-KBGUO27Q.js.map

package/dist/cli/{chunk-GFS6W3C5.js → chunk-L6B6FUQP.js}

@@ -67,37 +67,6 @@ function editDistance(a, b) {
   return previous[b.length];
 }
 
-// packages/runtime/src/seed.ts
-var DEFAULT_GRAPH_SEED = 0;
-function graphSeed(document) {
-  const value = document?.seed;
-  return typeof value === "number" && Number.isInteger(value) ? value >>> 0 : DEFAULT_GRAPH_SEED;
-}
-function nodeSeed(seedOfGraph, nodeId) {
-  const text = `${seedOfGraph >>> 0}:${nodeId}`;
-  let hash = 2166136261;
-  for (let index = 0; index < text.length; index++) {
-    hash ^= text.charCodeAt(index);
-    hash = Math.imul(hash, 16777619);
-  }
-  hash ^= hash >>> 16;
-  hash = Math.imul(hash, 2246822507);
-  hash ^= hash >>> 13;
-  hash = Math.imul(hash, 3266489909);
-  hash ^= hash >>> 16;
-  return hash >>> 0;
-}
-function seededRandom(seed) {
-  let state = seed >>> 0;
-  return () => {
-    state = state + 1831565813 >>> 0;
-    let value = state;
-    value = Math.imul(value ^ value >>> 15, value | 1);
-    value ^= value + Math.imul(value ^ value >>> 7, value | 61);
-    return ((value ^ value >>> 14) >>> 0) / 4294967296;
-  };
-}
-
 // packages/runtime/src/gpu.ts
 var HOST_SCOPE = "\0host";
 var MISSING_DEVICE = "The gpu capability was used before its device was ready \u2014 the host must await ensure() before a cook.";
@@ -274,6 +243,26 @@ function createGpuHost(options) {
   }
   return host;
 }
+async function requestDeviceWithAdapterLimits(adapter) {
+  const requiredLimits = readGpuLimits(adapter.limits);
+  try {
+    return await adapter.requestDevice({ requiredLimits });
+  } catch {
+    return adapter.requestDevice();
+  }
+}
+function gpuLimitShortfall(label, required, gpu) {
+  if (!required) return null;
+  const short = [];
+  for (const [name, wanted] of Object.entries(required)) {
+    const have = gpu.limits[name];
+    const fits = have !== void 0 && (name.startsWith("min") ? have <= wanted : have >= wanted);
+    if (!fits) short.push(`${name} ${wanted} (this GPU: ${have ?? "not reported"})`);
+  }
+  if (!short.length) return null;
+  const adapter = gpu.adapterInfo.description || gpu.adapterInfo.device || gpu.adapterInfo.vendor || "this adapter";
+  return `${label} needs GPU limits ${adapter} does not allow: ${short.join(", ")}.`;
+}
 function readGpuLimits(source) {
   if (!source || typeof source !== "object") return {};
   const names = new Set(Object.keys(source));
@@ -290,6 +279,37 @@ function readGpuLimits(source) {
   return limits;
 }
 
+// packages/runtime/src/seed.ts
+var DEFAULT_GRAPH_SEED = 0;
+function graphSeed(document) {
+  const value = document?.seed;
+  return typeof value === "number" && Number.isInteger(value) ? value >>> 0 : DEFAULT_GRAPH_SEED;
+}
+function nodeSeed(seedOfGraph, nodeId) {
+  const text = `${seedOfGraph >>> 0}:${nodeId}`;
+  let hash = 2166136261;
+  for (let index = 0; index < text.length; index++) {
+    hash ^= text.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  hash ^= hash >>> 16;
+  hash = Math.imul(hash, 2246822507);
+  hash ^= hash >>> 13;
+  hash = Math.imul(hash, 3266489909);
+  hash ^= hash >>> 16;
+  return hash >>> 0;
+}
+function seededRandom(seed) {
+  let state = seed >>> 0;
+  return () => {
+    state = state + 1831565813 >>> 0;
+    let value = state;
+    value = Math.imul(value ^ value >>> 15, value | 1);
+    value ^= value + Math.imul(value ^ value >>> 7, value | 61);
+    return ((value ^ value >>> 14) >>> 0) / 4294967296;
+  };
+}
+
 export {
   bundleFieldType,
   bundleSchemasCompatible,
@@ -300,9 +320,11 @@ export {
   bundleValueProblem,
   isGpuHost,
   createGpuHost,
+  requestDeviceWithAdapterLimits,
+  gpuLimitShortfall,
   DEFAULT_GRAPH_SEED,
   graphSeed,
   nodeSeed,
   seededRandom
 };
-//# sourceMappingURL=chunk-GFS6W3C5.js.map
+//# sourceMappingURL=chunk-L6B6FUQP.js.map