@field/cascade 0.11.0 → 0.13.0

package/dist/cli/{chunk-WKURDVYP.js → chunk-JEW5MPGI.js}

@@ -5,30 +5,21 @@ import {
   inside,
   playerFile,
   staticRuntimePlugin
-} from "./chunk-3JTJHF7V.js";
+} from "./chunk-2L34ERS2.js";
 import {
   PREFLIGHT_WARNING_CODES,
-  cookProjectGraph,
   createRuntime,
-  installProjectIo,
   moduleId,
   projectModuleFile,
   validateNodeModuleArchitecture
-} from "./chunk-EUIAC3U3.js";
+} from "./chunk-QKL7CCRS.js";
 import {
   builtinNodeRegistration
-} from "./chunk-36P5K3SD.js";
+} from "./chunk-MI5JLQYA.js";
 import {
   ProjectRoot,
   extractNodeDefinition
-} from "./chunk-RQZ4SX5R.js";
-import {
-  installHeadlessCanvas
-} from "./chunk-WIH4TEIS.js";
-
-// src/cli/editorCommands.ts
-import fs2 from "node:fs/promises";
-import path2 from "node:path";
+} from "./chunk-W5PJ5RMP.js";
 
 // packages/runtime/src/editor/index.ts
 var SCENE_FORMAT = "cascade.scene";
@@ -335,7 +326,8 @@ async function exportEditor(file, options = {}) {
   const directory = await buildSite(prepared, options.out);
   const plan = JSON.parse(await fs.readFile(path.join(directory, "export-manifest.json"), "utf8"));
   let url;
-  if (options.deploy === "vercel") url = await deployVercel(directory, options.project ?? prepared.plan.editor.id, options.scope, log, options.public === true);
+  if (options.deploy === "vercel")
+    url = (await deployVercel(directory, { project: options.project ?? prepared.plan.editor.id, scope: options.scope, public: options.public === true, log })).deployment;
   return { plan, directory, ...url ? { url } : {} };
 }
 async function prepareExport(file) {
@@ -659,7 +651,7 @@ async function secretValues(projectRoot) {
   values.set("your home directory", os.homedir());
   return [...values];
 }
-async function deployVercel(directory, projectName, scope, log, intendedPublic) {
+var deployVercel = async (directory, { project: projectName, scope, public: intendedPublic, log }) => {
   const team = scope ?? "field-io";
   const scratch = await fs.mkdtemp(path.join(os.tmpdir(), "cascade-vercel-"));
   try {
@@ -671,16 +663,21 @@ async function deployVercel(directory, projectName, scope, log, intendedPublic)
     await fs.rm(scratch, { recursive: true, force: true });
   }
   log(`Deploying ${directory} to Vercel project ${team}/${projectName}\u2026`);
-  const { stdout } = await run("vercel", ["deploy", "--prod", "--yes", "--scope", team], { cwd: directory, maxBuffer: 16 * 1024 * 1024 });
-  const url = stdout.trim().split("\n").reverse().find((line) => /^https:\/\//.test(line.trim()))?.trim();
-  if (!url) throw new Error(`Vercel did not report a deployment URL:
+  const { stdout, stderr } = await run("vercel", ["deploy", "--prod", "--yes", "--scope", team], { cwd: directory, maxBuffer: 16 * 1024 * 1024 });
+  const deployment = stdout.trim().split("\n").reverse().find((line) => /^https:\/\//.test(line.trim()))?.trim();
+  if (!deployment) throw new Error(`Vercel did not report a deployment URL:
 ${stdout}`);
-  const response = await fetch(`https://${projectName}.vercel.app/`, { redirect: "manual" });
+  const url = productionAlias(`${stdout}
+${stderr}`) ?? `https://${projectName}.vercel.app`;
+  const response = await fetch(`${url}/`, { redirect: "manual" });
   const verdict = publicVerdict(response.status, intendedPublic);
-  if (verdict === "public-as-intended") log(`Public, as intended (--public): https://${projectName}.vercel.app`);
+  if (verdict === "public-as-intended") log(`Public, as intended: ${url}`);
   else if (verdict === "public-by-accident")
-    throw new Error(`Deployed, but https://${projectName}.vercel.app is publicly readable. Turn on Vercel Authentication (Settings \u2192 Deployment Protection) for ${team}/${projectName}.`);
-  return url;
+    throw new Error(`Deployed, but ${url} is publicly readable. Turn on Vercel Authentication (Settings \u2192 Deployment Protection) for ${team}/${projectName}.`);
+  return { deployment, url };
+};
+function productionAlias(output) {
+  return /Aliased:?\s+(https:\/\/[^\s[\]]+)/.exec(output)?.[1]?.replace(/\/$/, "");
 }
 function publicVerdict(status, intendedPublic) {
   if (status !== 200) return "protected";
@@ -806,314 +803,14 @@ function formatSize(bytes) {
   return bytes >= 1048576 ? `${(bytes / 1048576).toFixed(1)} MB` : bytes >= 1024 ? `${Math.round(bytes / 1024)} KB` : `${bytes} B`;
 }
 
-// src/cli/editorCommands.ts
-var EDITOR_COMMANDS = ["export", "freeze", "publish", "scene"];
-var EDITOR_HELP = `
-Shareable editors (see doc/EDITOR_EXPORT.md):
-  cascade export <graph> --plan                 Print what would ship, build nothing
-  cascade export <graph> --out <dir> [--deploy vercel [--project <name>] [--scope <team>] [--public]]
-  cascade publish <graph> <node>.<prop> [--id <id>] [--label <text>] [--group <name>]
-                  [--control <kind>] [--min n] [--max n] [--step n] [--help <text>] [--remove]
-  cascade freeze <graph> <node> --fields <a,b.c> [--output <port>] [--personal <a,..>]
-  cascade scene <graph> <scene.json> --out <new-graph.cascade>
-  cascade run <graph> --scene <scene.json> [--write <node>.<port>=<file>]...
-`;
-async function runEditorCommand(args) {
-  const [command, graph] = args;
-  if (!graph || graph.startsWith("-")) throw new Error(`cascade ${command} requires a graph file`);
-  const flags = parseFlags(args.slice(2));
-  switch (command) {
-    case "export":
-      return exportCommand(graph, flags);
-    case "publish":
-      return publishCommand(graph, flags);
-    case "freeze":
-      return freezeCommand(graph, flags);
-    case "scene":
-      return sceneCommand(graph, flags);
-    case "run":
-      return runWithScene(graph, flags);
-    default:
-      throw new Error(`Unknown command ${command}`);
-  }
-}
-var SWITCHES = /* @__PURE__ */ new Set(["--plan", "--remove", "--json", "--public"]);
-function parseFlags(args) {
-  const positional = [];
-  const values = /* @__PURE__ */ new Map();
-  const switches = /* @__PURE__ */ new Set();
-  for (let index = 0; index < args.length; index++) {
-    const arg = args[index];
-    if (!arg.startsWith("--")) {
-      positional.push(arg);
-      continue;
-    }
-    if (SWITCHES.has(arg)) {
-      switches.add(arg);
-      continue;
-    }
-    const value = args[index + 1];
-    if (value === void 0 || value.startsWith("--") && !/^--?\d/.test(value)) throw new Error(`${arg} needs a value`);
-    values.set(arg, [...values.get(arg) ?? [], value]);
-    index++;
-  }
-  return { positional, values, switches };
-}
-var one = (flags, name) => {
-  const list = flags.values.get(name);
-  return list?.[list.length - 1];
-};
-async function exportCommand(graph, flags) {
-  const deploy = one(flags, "--deploy");
-  if (deploy && deploy !== "vercel") throw new Error("--deploy supports vercel only");
-  const result = await exportEditor(graph, {
-    plan: flags.switches.has("--plan"),
-    out: one(flags, "--out"),
-    ...deploy ? { deploy: "vercel" } : {},
-    project: one(flags, "--project"),
-    scope: one(flags, "--scope"),
-    ...flags.switches.has("--public") ? { public: true } : {}
-  });
-  if (flags.switches.has("--json")) console.log(JSON.stringify(result.plan, null, 2));
-  else console.log(formatPlan(result.plan));
-  if (result.directory) console.log(`
-Editor exported: ${result.directory}
-Manifest: ${path2.join(result.directory, "export-manifest.json")}`);
-  if (result.url) console.log(`Deployed: ${result.url}`);
-}
-async function readGraph(file) {
-  return JSON.parse(await fs2.readFile(file, "utf8"));
-}
-async function writeEditor(file, document, editor) {
-  const next = { ...document, editor };
-  await fs2.writeFile(file, `${JSON.stringify(next, null, 2)}
-`);
-}
-async function publishCommand(graph, flags) {
-  const target = flags.positional[0];
-  const match = target ? /^([^.]+)\.(.+)$/.exec(target) : null;
-  if (!match) throw new Error("cascade publish needs <node>.<prop>");
-  const [, node, prop] = match;
-  const document = await readGraph(graph);
-  if (!document.nodes.some((item) => item.id === node)) throw new Error(`No node ${node} in ${graph}`);
-  const editor = document.editor ?? { id: path2.basename(graph).replace(/\.cascade$/, "") };
-  const parameters = [...editor.parameters ?? []];
-  const id = one(flags, "--id") ?? prop;
-  const existing = parameters.findIndex((item) => item.node === node && item.prop === prop);
-  if (flags.switches.has("--remove")) {
-    if (existing < 0) throw new Error(`${node}.${prop} is not published`);
-    parameters.splice(existing, 1);
-    await writeEditor(graph, document, { ...editor, parameters });
-    console.log(`Unpublished ${node}.${prop}`);
-    return;
-  }
-  const number = (name) => {
-    const value = one(flags, name);
-    if (value === void 0) return void 0;
-    const parsed = Number(value);
-    if (!Number.isFinite(parsed)) throw new Error(`${name} must be a number`);
-    return parsed;
-  };
-  const previous = existing >= 0 ? parameters[existing] : void 0;
-  const parameter = {
-    ...previous,
-    id: previous?.id ?? id,
-    node,
-    prop,
-    ...one(flags, "--label") ? { label: one(flags, "--label") } : {},
-    ...one(flags, "--group") ? { group: one(flags, "--group") } : {},
-    ...one(flags, "--control") ? { control: one(flags, "--control") } : {},
-    ...number("--min") !== void 0 ? { min: number("--min") } : {},
-    ...number("--max") !== void 0 ? { max: number("--max") } : {},
-    ...number("--step") !== void 0 ? { step: number("--step") } : {},
-    ...number("--order") !== void 0 ? { order: number("--order") } : {},
-    ...one(flags, "--help") ? { help: one(flags, "--help") } : {},
-    ...one(flags, "--unit") ? { unit: one(flags, "--unit") } : {}
-  };
-  if (existing >= 0) parameters[existing] = parameter;
-  else {
-    if (parameters.some((item) => item.id === parameter.id)) throw new Error(`Parameter id ${parameter.id} is taken; pass --id`);
-    parameters.push(parameter);
-  }
-  await writeEditor(graph, document, { ...editor, parameters });
-  console.log(`${existing >= 0 ? "Updated" : "Published"} ${node}.${prop} as "${parameter.id}"`);
-}
-async function freezeCommand(graph, flags) {
-  const node = flags.positional[0];
-  if (!node) throw new Error("cascade freeze needs a node id");
-  const fields = (one(flags, "--fields") ?? "").split(",").map((item) => item.trim()).filter(Boolean);
-  if (!fields.length) throw new Error("cascade freeze needs --fields: name exactly the values to keep");
-  const personal = (one(flags, "--personal") ?? "").split(",").map((item) => item.trim()).filter(Boolean);
-  const document = await readGraph(graph);
-  if (!document.nodes.some((item) => item.id === node)) throw new Error(`No node ${node} in ${graph}`);
-  const graphFile = path2.resolve(graph);
-  const project = new ProjectRoot(path2.dirname(graphFile));
-  await installHeadlessCanvas().catch(() => void 0);
-  const removeIo = installProjectIo(project);
-  const { outputs } = await cookProjectGraph(graphFile, document, node).finally(removeIo);
-  const produced = outputs.get(node);
-  if (!produced) throw new Error(`${node} produced nothing`);
-  const output = one(flags, "--output") ?? [...produced.keys()][0];
-  if (!produced.has(output)) throw new Error(`${node} has no output ${output}; it has ${[...produced.keys()].join(", ")}`);
-  const full = toJson(produced.get(output));
-  const directory = path2.join("frozen", node);
-  await fs2.mkdir(project.resolve(directory), { recursive: true });
-  const files = [];
-  const pick = async (value) => {
-    if (value && typeof value === "object" && !Array.isArray(value) && typeof value.path === "string") {
-      const from = value.path;
-      const source = project.resolve(from.replace(/^\.\//, ""));
-      const name = `${directory}/${path2.basename(from)}`;
-      await fs2.copyFile(source, project.resolve(name));
-      files.push(name);
-      return { ...value, path: name };
-    }
-    if (Array.isArray(value)) return Promise.all(value.map(pick));
-    if (value && typeof value === "object")
-      return Object.fromEntries(await Promise.all(Object.entries(value).map(async ([key, item]) => [key, await pick(item)])));
-    return value;
-  };
-  const chosen = {};
-  for (const field of fields) {
-    const value = getPath(full, field);
-    if (value === void 0) throw new Error(`${node}.${output} has no field ${field}`);
-    setPath(chosen, field, await pick(value));
-  }
-  if (fields.includes("path") && typeof chosen.path === "string" && full && typeof full === "object" && !Array.isArray(full)) {
-    const { path: copied } = await pick({ path: chosen.path });
-    chosen.path = copied;
-  }
-  const snapshot = {
-    format: "cascade.frozen",
-    version: 1,
-    node,
-    output,
-    fields,
-    ...personal.length ? { personal } : {},
-    value: chosen,
-    ...files.length ? { files } : {},
-    frozenAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  const snapshotFile = `${directory}.json`;
-  await fs2.writeFile(project.resolve(snapshotFile), `${JSON.stringify(snapshot, null, 2)}
-`);
-  const editor = document.editor ?? { id: path2.basename(graph).replace(/\.cascade$/, "") };
-  const freeze = (editor.freeze ?? []).filter((item) => item.node !== node);
-  freeze.push({ node, output, snapshot: snapshotFile });
-  await writeEditor(graph, document, { ...editor, freeze });
-  console.log(`Froze ${node}.${output}: ${fields.join(", ")} \u2192 ${snapshotFile}${files.length ? ` (+${files.length} file${files.length > 1 ? "s" : ""})` : ""}`);
-}
-async function sceneCommand(graph, flags) {
-  const sceneFile = flags.positional[0];
-  const out = one(flags, "--out");
-  if (!sceneFile || !out) throw new Error("cascade scene needs <scene.json> --out <new-graph.cascade>");
-  if (path2.resolve(out) === path2.resolve(graph)) throw new Error("--out must be a new file; the source graph is never overwritten");
-  const { document, warnings } = await sceneDocument(graph, sceneFile);
-  await fs2.writeFile(out, `${JSON.stringify(document, null, 2)}
-`);
-  for (const warning of warnings) console.warn(`Warning: ${warning}`);
-  console.log(`Scene applied: ${out}`);
-}
-async function sceneDocument(graph, sceneFile) {
-  const document = await readGraph(graph);
-  const scene = parseScene(await fs2.readFile(sceneFile, "utf8"));
-  const project = new ProjectRoot(path2.dirname(path2.resolve(graph)));
-  const located = /* @__PURE__ */ new Map();
-  for (const [id, file] of Object.entries(scene.files ?? {})) {
-    const found = await locateSceneFile(project, file);
-    if (found) located.set(id, { path: found, ...file.mediaType ? { mediaType: file.mediaType } : {} });
-  }
-  return applyScene(document, scene, { resolveFile: (parameter) => located.get(parameter.id) });
-}
-async function locateSceneFile(project, file) {
-  const { createHash } = await import("node:crypto");
-  const safe = path2.basename(file.name).replace(/[^A-Za-z0-9._-]/g, "_");
-  if (file.data) {
-    const bytes = fromBase64(file.data);
-    const digest = createHash("sha256").update(bytes).digest("hex");
-    if (digest !== file.sha256) throw new Error(`Scene file ${file.name} does not match its hash`);
-    const name = `assets/scenes/${digest.slice(0, 12)}-${safe}`;
-    await fs2.mkdir(path2.dirname(project.resolve(name)), { recursive: true });
-    await fs2.writeFile(project.resolve(name), bytes);
-    return name;
-  }
-  for (const candidate of await filesNamed(project.root, path2.basename(file.name))) {
-    const digest = createHash("sha256").update(await fs2.readFile(candidate)).digest("hex");
-    if (digest === file.sha256) return path2.relative(project.root, candidate).split(path2.sep).join("/");
-  }
-  return void 0;
-}
-async function filesNamed(root, name) {
-  const found = [];
-  const walk = async (directory, depth) => {
-    if (depth > 6) return;
-    for (const entry of await fs2.readdir(directory, { withFileTypes: true }).catch(() => [])) {
-      if (entry.name === "node_modules" || entry.name === ".git" || entry.name === ".cascade-cache") continue;
-      const file = path2.join(directory, entry.name);
-      if (entry.isDirectory()) await walk(file, depth + 1);
-      else if (entry.name === name) found.push(file);
-    }
-  };
-  await walk(path2.join(root, "assets"), 0);
-  await walk(path2.join(root, "licensed"), 0);
-  return found;
-}
-async function runWithScene(graph, flags) {
-  const graphFile = path2.resolve(graph);
-  let document = await readGraph(graph);
-  const scene = one(flags, "--scene");
-  if (scene) {
-    const applied = await sceneDocument(graph, scene);
-    document = applied.document;
-    for (const warning of applied.warnings) console.warn(`Warning: ${warning}`);
-  }
-  await installHeadlessCanvas().catch(() => void 0);
-  const project = new ProjectRoot(path2.dirname(graphFile));
-  const removeIo = installProjectIo(project);
-  const { outputs } = await cookProjectGraph(graphFile, document).finally(removeIo);
-  for (const spec of flags.values.get("--write") ?? []) {
-    const match = /^([^.=]+)\.([^=]+)=(.+)$/.exec(spec);
-    if (!match) throw new Error(`--write expects <node>.<port>=<file>, got ${spec}`);
-    const [, node, port, file] = match;
-    const value = outputs.get(node)?.get(port);
-    if (value === void 0) throw new Error(`${node}.${port} produced nothing`);
-    if (typeof value === "string") await fs2.writeFile(file, value);
-    else if (value && typeof value === "object" && typeof value.path === "string")
-      await fs2.copyFile(project.resolve(value.path.replace(/^\.\//, "")), file);
-    else await fs2.writeFile(file, JSON.stringify(toJson(value)));
-    console.log(`Wrote ${node}.${port} \u2192 ${file}`);
-  }
-}
-function toJson(value) {
-  return JSON.parse(JSON.stringify(value, (_key, item) => ArrayBuffer.isView(item) ? Array.from(item) : item) ?? "null");
-}
-function getPath(value, field) {
-  let current = value;
-  for (const part of field.split(".").flatMap((item) => item.split(/\[(\d+)\]/).filter(Boolean))) {
-    if (current === null || typeof current !== "object") return void 0;
-    current = current[part];
-  }
-  return current;
-}
-function setPath(target, field, value) {
-  const parts = field.split(".").flatMap((item) => item.split(/\[(\d+)\]/).filter(Boolean));
-  let current = target;
-  parts.forEach((part, index) => {
-    const last = index === parts.length - 1;
-    const container = current;
-    if (last) {
-      container[part] = value;
-      return;
-    }
-    if (container[part] === void 0) container[part] = /^\d+$/.test(parts[index + 1]) ? [] : {};
-    current = container[part];
-  });
-}
-
 export {
-  EDITOR_COMMANDS,
-  EDITOR_HELP,
-  runEditorCommand,
-  sceneDocument
+  parseScene,
+  applyScene,
+  fromBase64,
+  exportEditor,
+  formatPlan,
+  vercelConfig,
+  scanForLeaks,
+  deployVercel
 };
-//# sourceMappingURL=chunk-WKURDVYP.js.map
+//# sourceMappingURL=chunk-JEW5MPGI.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