@field/cascade 0.8.0 → 0.11.0

package/dist/cli/math-ZRMLKU2D.js

@@ -0,0 +1,16 @@
+import {
+  registerDefinitionNodes
+} from "./chunk-SGJAET2L.js";
+import "./chunk-FCDXJ6EK.js";
+import "./chunk-RUU3YWXU.js";
+import {
+  mathNodeRegistrations
+} from "./chunk-QQPA2ZHH.js";
+import "./chunk-GFS6W3C5.js";
+import "./chunk-HFHWYL55.js";
+import "./chunk-CO22XHNG.js";
+import "./chunk-BIJO5OFS.js";
+
+// src/nodes/math/index.ts
+registerDefinitionNodes(mathNodeRegistrations, {});
+//# sourceMappingURL=math-ZRMLKU2D.js.map

package/dist/cli/mcp-ZLEEMYGF.js

@@ -0,0 +1,164 @@
+import {
+  captureEnvelope
+} from "./chunk-CKS2FQWR.js";
+import {
+  mcpTools
+} from "./chunk-POMMNKZZ.js";
+
+// src/cli/mcp.ts
+import { spawn } from "node:child_process";
+import { statSync } from "node:fs";
+import path from "node:path";
+import readline from "node:readline";
+var PROTOCOL_VERSION = "2025-06-18";
+var PROJECT_PARAMETER = {
+  type: "string",
+  description: "Project directory for this call (absolute, or relative to the server's). Default: the directory the server was started in. Graph and output paths stay inside it."
+};
+var withProject = (schema) => ({
+  ...schema,
+  properties: { ...schema.properties ?? {}, project: PROJECT_PARAMETER }
+});
+var TOOLS = mcpTools().map(({ verb, tool }) => ({
+  name: tool.name,
+  description: tool.description,
+  inputSchema: withProject(tool.inputSchema),
+  verb: verb.name,
+  run: toolRunner(tool.call)
+}));
+function contextForCall(args, server) {
+  const { project, ...rest } = args;
+  if (project === void 0 || project === null || project === "") return { args: rest, context: server };
+  if (typeof project !== "string") throw new Error("project must be a path to a project directory");
+  const root = path.resolve(server.root, project);
+  let directory = false;
+  try {
+    directory = statSync(root).isDirectory();
+  } catch {
+  }
+  if (!directory) throw new Error(`project ${project} is not a directory (resolved to ${root})`);
+  return { args: rest, context: server.forProject ? server.forProject(root) : createMcpContext(root) };
+}
+function toolRunner(call) {
+  switch (call.kind) {
+    case "edit":
+      return async (args, server) => {
+        const { applyEdits } = await import("./graphCommands-6BMAKGQE.js");
+        return captureEnvelope(() => applyEdits(server.resolve(args.graph), call.operations(args), { json: true, dryRun: args.dryRun === true }));
+      };
+    case "graph":
+      return async (args, server) => {
+        const { runGraphCommand } = await import("./graphCommands-6BMAKGQE.js");
+        return captureEnvelope(() => runGraphCommand(call.argv(args, (file) => server.resolve(file)), { json: true }));
+      };
+    case "cli":
+      return (args, server) => server.cli(call.argv(args, (file) => server.resolve(file)), call.timeoutMs?.(args));
+  }
+}
+async function runMcpServer(args, version) {
+  const root = path.resolve(args.find((arg) => !arg.startsWith("-")) ?? ".");
+  console.log = console.error;
+  console.info = console.error;
+  const context = createMcpContext(root);
+  let queue = Promise.resolve();
+  const send = (message) => process.stdout.write(`${JSON.stringify(message)}
+`);
+  const lines = readline.createInterface({ input: process.stdin });
+  lines.on("line", (line) => {
+    if (!line.trim()) return;
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      send({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } });
+      return;
+    }
+    queue = queue.then(() => handle(message, context, version)).then((response) => {
+      if (response !== void 0 && message.id !== void 0) send({ jsonrpc: "2.0", id: message.id, ...response });
+    });
+  });
+  await new Promise((resolve) => lines.on("close", resolve));
+  await queue;
+}
+function createMcpContext(root) {
+  return {
+    root,
+    resolve(file) {
+      const resolved = path.resolve(root, file);
+      const relative = path.relative(root, resolved);
+      if (relative.startsWith("..") || path.isAbsolute(relative)) throw new Error(`${file} is outside the project directory ${root}`);
+      return resolved;
+    },
+    cli: (cliArgs, timeoutMs) => runCliChild(root, cliArgs, timeoutMs ?? 10 * 6e4)
+  };
+}
+async function handle(message, context, version) {
+  switch (message.method) {
+    case "initialize":
+      return {
+        result: {
+          protocolVersion: typeof message.params?.protocolVersion === "string" ? message.params.protocolVersion : PROTOCOL_VERSION,
+          capabilities: { tools: {} },
+          serverInfo: { name: "cascade", version },
+          instructions: "Cascade graph tools. Graph paths are relative to the project directory; pass `project` on any call to work in another project directory. Read a graph with graph_read before editing it; every result is { ok, data, warnings }."
+        }
+      };
+    case "ping":
+      return { result: {} };
+    case "tools/list":
+      return { result: { tools: TOOLS.map(({ name, description, inputSchema }) => ({ name, description, inputSchema })) } };
+    case "tools/call": {
+      const tool = TOOLS.find((candidate) => candidate.name === message.params?.name);
+      if (!tool) return { error: { code: -32602, message: `Unknown tool: ${message.params?.name}` } };
+      let envelope;
+      try {
+        const call = contextForCall(message.params?.arguments ?? {}, context);
+        envelope = await tool.run(call.args, call.context);
+      } catch (error) {
+        envelope = { ok: false, error: { message: error instanceof Error ? error.message : String(error) }, warnings: [] };
+      }
+      return {
+        result: {
+          content: [{ type: "text", text: JSON.stringify(envelope) }],
+          structuredContent: envelope,
+          isError: !envelope.ok
+        }
+      };
+    }
+    default:
+      if (message.method?.startsWith("notifications/")) return void 0;
+      return { error: { code: -32601, message: `Method not found: ${message.method}` } };
+  }
+}
+function runCliChild(root, args, timeoutMs) {
+  return new Promise((resolve) => {
+    const child = spawn(process.execPath, [...process.execArgv, process.argv[1], ...args, "--json"], { cwd: root, stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    const timer = setTimeout(() => child.kill("SIGTERM"), timeoutMs);
+    child.on("close", (code, signal) => {
+      clearTimeout(timer);
+      const last = stdout.trim().split("\n").pop() ?? "";
+      try {
+        resolve(JSON.parse(last));
+      } catch {
+        const reason = signal ? `stopped by ${signal}${signal === "SIGTERM" ? ` after ${timeoutMs} ms` : ""}` : `exited with code ${code}`;
+        resolve({ ok: false, error: { message: `cascade ${args[0]} ${reason}: ${(stderr || stdout).trim().slice(-2e3)}` }, warnings: [] });
+      }
+    });
+  });
+}
+export {
+  TOOLS,
+  contextForCall,
+  createMcpContext,
+  handle,
+  runMcpServer
+};
+//# sourceMappingURL=mcp-ZLEEMYGF.js.map

package/dist/cli/parity-KINARCP2.js

@@ -0,0 +1,328 @@
+import {
+  installProjectStages
+} from "./chunk-QBBKRNGY.js";
+import {
+  setEmbeddedCompiler,
+  setProjectModuleCompiler
+} from "./chunk-2KXB47FP.js";
+import {
+  compileEmbedded,
+  compileProjectModule
+} from "./chunk-MIIEFUGG.js";
+import "./chunk-WPUDGEFY.js";
+import "./chunk-VVGSLVSF.js";
+import "./chunk-WD62JIP6.js";
+import {
+  cookProjectGraph,
+  createProjectHost,
+  installProjectIo
+} from "./chunk-EUIAC3U3.js";
+import "./chunk-36P5K3SD.js";
+import "./chunk-D6BUOHUG.js";
+import "./chunk-RXDIMXN5.js";
+import "./chunk-QQPA2ZHH.js";
+import "./chunk-KH4MUBKF.js";
+import "./chunk-35D343DC.js";
+import "./chunk-DEQSEFFH.js";
+import "./chunk-HSNOBIVT.js";
+import {
+  imagePath
+} from "./chunk-ICH7N5PN.js";
+import {
+  graphSeed
+} from "./chunk-GFS6W3C5.js";
+import "./chunk-HFHWYL55.js";
+import "./chunk-CO22XHNG.js";
+import {
+  ProjectRoot
+} from "./chunk-RQZ4SX5R.js";
+import "./chunk-A4OAMOZH.js";
+import "./chunk-J7VK7MNF.js";
+import "./chunk-XWDSKG7N.js";
+import "./chunk-BIJO5OFS.js";
+import {
+  installHeadlessCanvas
+} from "./chunk-WIH4TEIS.js";
+
+// src/cli/parity.ts
+import { createHash } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import sharp from "sharp";
+function sha(bytes) {
+  return createHash("sha256").update(bytes).digest("hex").slice(0, 16);
+}
+function canonical(value) {
+  return JSON.stringify(value, (_key, item) => {
+    if (ArrayBuffer.isView(item) && !(item instanceof DataView)) return Array.from(item);
+    if (item && typeof item === "object" && !Array.isArray(item)) {
+      return Object.fromEntries(Object.keys(item).sort().map((key) => [key, item[key]]));
+    }
+    if (typeof item === "function") return void 0;
+    return item;
+  }) ?? "undefined";
+}
+function planarImage(value) {
+  const candidate = value;
+  if (!candidate || typeof candidate !== "object") return null;
+  if (typeof candidate.width !== "number" || typeof candidate.height !== "number") return null;
+  if (!Array.isArray(candidate.channels) || !candidate.channels.every((channel) => channel instanceof Float32Array)) return null;
+  return candidate;
+}
+function rgba8FromPlanar(image) {
+  const count = image.width * image.height;
+  const out = new Uint8Array(count * 4);
+  for (let index = 0; index < count; index++) {
+    for (let channel = 0; channel < 4; channel++) {
+      const source = image.channels[channel] ?? (channel === 3 ? null : image.channels[0]);
+      const value = source ? source[index] : 1;
+      out[index * 4 + channel] = Math.max(0, Math.min(255, Math.round(value * 255)));
+    }
+  }
+  return out;
+}
+async function decodeFile(full) {
+  const { data, info } = await sharp(full).ensureAlpha().raw({ depth: "uchar" }).toBuffer({ resolveWithObject: true });
+  return { width: info.width, height: info.height, pixels: new Uint8Array(data.buffer, data.byteOffset, data.byteLength) };
+}
+var IMAGE_FILE = /\.(png|jpe?g|webp|tiff?)$/i;
+async function snapshotValue(project, value) {
+  if (value === void 0 || value === null) return { kind: "missing" };
+  const planar = planarImage(value);
+  if (planar) {
+    const pixels = rgba8FromPlanar(planar);
+    return { kind: "image", digest: sha(pixels), width: planar.width, height: planar.height, pixels };
+  }
+  const file = imagePath(value);
+  if (file && IMAGE_FILE.test(file)) {
+    try {
+      const decoded = await decodeFile(project.resolveMedia(file.replace(/^\.?\//, "")));
+      return { kind: "image", digest: sha(decoded.pixels), ...decoded };
+    } catch {
+    }
+  }
+  const json = canonical(value);
+  return { kind: "value", digest: sha(json), json };
+}
+async function snapshotOutputs(project, outputs) {
+  const snapshots = /* @__PURE__ */ new Map();
+  for (const [node, ports] of outputs) {
+    for (const [port, value] of ports) {
+      if (value === void 0) continue;
+      snapshots.set(`${node}.${port}`, await snapshotValue(project, value));
+    }
+  }
+  return snapshots;
+}
+function numbers(json) {
+  try {
+    const value = JSON.parse(json);
+    if (typeof value === "number") return [value];
+    if (Array.isArray(value) && value.every((item) => typeof item === "number")) return value;
+  } catch {
+  }
+  return null;
+}
+function compareSnapshots(a, b, tolerance) {
+  if (!a || !b || a.kind === "missing" || b.kind === "missing") {
+    if ((!a || a.kind === "missing") && (!b || b.kind === "missing")) return { verdict: "same" };
+    return { verdict: "missing", detail: !a || a.kind === "missing" ? "absent in the first cook" : "absent in this cook" };
+  }
+  if (a.digest === b.digest) return { verdict: "same" };
+  if (a.kind === "image" && b.kind === "image") {
+    if (a.width !== b.width || a.height !== b.height) {
+      return { verdict: "different", detail: `size ${a.width}\xD7${a.height} vs ${b.width}\xD7${b.height}` };
+    }
+    let differing = 0;
+    let maxDelta = 0;
+    for (let pixel = 0; pixel < a.pixels.length; pixel += 4) {
+      let worst = 0;
+      for (let channel = 0; channel < 4; channel++) {
+        const delta = Math.abs(a.pixels[pixel + channel] - b.pixels[pixel + channel]);
+        if (delta > worst) worst = delta;
+      }
+      if (worst > 0) differing++;
+      if (worst > maxDelta) maxDelta = worst;
+    }
+    const share = 100 * differing / (a.width * a.height);
+    const detail = `${differing} px (${share < 0.01 ? share.toExponential(1) : share.toFixed(2)} %), max \u0394 ${maxDelta}`;
+    return { verdict: maxDelta <= tolerance ? "within tolerance" : "different", detail, differingPixels: differing, maxDelta };
+  }
+  if (a.kind === "value" && b.kind === "value") {
+    const left = numbers(a.json);
+    const right = numbers(b.json);
+    if (left && right && left.length === right.length) {
+      const maxDelta = Math.max(...left.map((value, index) => Math.abs(value - right[index])));
+      const detail = left.length === 1 ? `${left[0]} vs ${right[0]}` : `max \u0394 ${maxDelta}`;
+      return { verdict: "different", detail, maxDelta };
+    }
+    const shorten = (text) => text.length > 60 ? `${text.slice(0, 57)}...` : text;
+    return { verdict: "different", detail: `${shorten(a.json)} vs ${shorten(b.json)}` };
+  }
+  return { verdict: "different", detail: `${a.kind} vs ${b.kind}` };
+}
+async function cookHeadless(file, document, node, project) {
+  const { outputs } = await cookProjectGraph(file, structuredClone(document), node);
+  return snapshotOutputs(project, outputs);
+}
+async function cookStudio(file, document, node, project) {
+  const [{ Graph }, { registerStandardNodes }, { studioCapabilities }, { cookUntilSettled }] = await Promise.all([
+    import("./Graph-ZJJTRQTM.js"),
+    import("./registerStandardNodes-S2VLMF6J.js"),
+    import("./projectDefinition-DMTZN2NE.js"),
+    import("./frames-LSAUBZ7P.js")
+  ]);
+  await Promise.all([
+    import("./definitions-HF2FTHYU.js"),
+    import("./math-ZRMLKU2D.js"),
+    import("./pop-USDFXB7H.js"),
+    import("./geo-4RNK3QVN.js")
+  ]);
+  registerStandardNodes();
+  const host = createProjectHost(file, []);
+  Object.assign(studioCapabilities, host.capabilities);
+  const graph = Graph.fromJSON(structuredClone(document));
+  graph.restoreConnections();
+  const entry = node ? graph.getNode(node) : void 0;
+  if (node && !entry) throw new Error(`no node "${node}" in the Studio graph`);
+  try {
+    await cookUntilSettled(graph, entry ?? void 0);
+    const failed = graph.nodes.filter((item) => item.error !== null);
+    if (failed.length) {
+      throw new Error(failed.map((item) => `${item.id}: ${item.error?.message ?? "cook error"}`).join("; "));
+    }
+    const outputs = /* @__PURE__ */ new Map();
+    for (const item of graph.nodes) {
+      outputs.set(item.id, new Map(item.outputs.map((port) => [port.name, port.value])));
+    }
+    return await snapshotOutputs(project, outputs);
+  } finally {
+    graph.scheduler?.dispose?.();
+    await host.capabilities.gpu?.dispose?.();
+  }
+}
+async function parity(options) {
+  const file = path.resolve(options.file);
+  const document = JSON.parse(await fs.readFile(file, "utf8"));
+  if (options.seed !== void 0) document.seed = options.seed;
+  const project = new ProjectRoot(path.dirname(file));
+  const previousCache = process.env.CASCADE_STAGE_CACHE;
+  process.env.CASCADE_STAGE_CACHE = "off";
+  setProjectModuleCompiler(async (folder) => (await compileProjectModule(project, folder)).code);
+  setEmbeddedCompiler(async (code) => (await compileEmbedded(project, code)).code);
+  const disposers = [installProjectStages(project, { worker: false }), installProjectIo(project)];
+  try {
+    const canvas = await installHeadlessCanvas();
+    disposers.push(() => canvas.dispose());
+  } catch {
+  }
+  const failures = {};
+  const attempt = async (name, cook) => {
+    try {
+      return await cook();
+    } catch (error) {
+      failures[name] = error instanceof Error ? error.message : String(error);
+      return null;
+    }
+  };
+  try {
+    const first = await attempt("headless", () => cookHeadless(file, document, options.node, project));
+    const second = await attempt("headless again", () => cookHeadless(file, document, options.node, project));
+    const studio = options.studio ? await attempt("studio", () => cookStudio(file, document, options.node, project)) : null;
+    const keys = [.../* @__PURE__ */ new Set([...first?.keys() ?? [], ...second?.keys() ?? []])].sort();
+    const ports = keys.map((key) => {
+      const dot = key.indexOf(".");
+      const a = first?.get(key);
+      return {
+        node: key.slice(0, dot),
+        port: key.slice(dot + 1),
+        kind: (a ?? second?.get(key))?.kind ?? "missing",
+        repeat: compareSnapshots(a, second?.get(key), options.tolerance),
+        ...studio ? { studio: compareSnapshots(a, studio.get(key), options.tolerance) } : {}
+      };
+    });
+    const agrees = (comparison) => !comparison || comparison.verdict === "same" || comparison.verdict === "within tolerance";
+    const ok = Object.keys(failures).length === 0 && ports.every((port) => agrees(port.repeat) && agrees(port.studio));
+    return { graph: file, seed: graphSeed(document), tolerance: options.tolerance, ok, ports, failures };
+  } finally {
+    for (const dispose of disposers.reverse()) {
+      try {
+        dispose();
+      } catch {
+      }
+    }
+    setProjectModuleCompiler(null);
+    setEmbeddedCompiler(null);
+    if (previousCache === void 0) delete process.env.CASCADE_STAGE_CACHE;
+    else process.env.CASCADE_STAGE_CACHE = previousCache;
+  }
+}
+function formatParityReport(report) {
+  const lines = [`parity ${report.graph}  seed ${report.seed}  tolerance ${report.tolerance}`];
+  for (const [cook, message] of Object.entries(report.failures)) lines.push(`  ${cook} cook failed: ${message}`);
+  const cell = (comparison) => !comparison ? "-" : comparison.detail ? `${comparison.verdict}: ${comparison.detail}` : comparison.verdict;
+  const rows = report.ports.map((port) => [`${port.node}.${port.port}`, port.kind, cell(port.repeat), cell(port.studio)]);
+  const header = ["output", "kind", "headless twice", "headless vs studio"];
+  const widths = header.map((title, column) => Math.max(title.length, ...rows.map((row) => row[column].length)));
+  const format = (row) => `  ${row.map((text, column) => text.padEnd(widths[column])).join("  ")}`.trimEnd();
+  lines.push(format(header));
+  for (const row of rows) lines.push(format(row));
+  const differing = report.ports.filter((port) => !["same", "within tolerance"].includes(port.repeat.verdict) || port.studio && !["same", "within tolerance"].includes(port.studio.verdict));
+  lines.push(report.ok ? "all outputs agree" : `${differing.length} of ${report.ports.length} outputs differ`);
+  return lines.join("\n");
+}
+function parseParityArgs(args) {
+  let file;
+  let node;
+  let seed;
+  let tolerance = 0;
+  let json = false;
+  let studio = true;
+  for (let index = 0; index < args.length; index++) {
+    const argument = args[index];
+    const value = () => {
+      const next = args[++index];
+      if (next === void 0 || next.startsWith("--")) throw new Error(`${argument} needs a value`);
+      return next;
+    };
+    if (argument === "--node") node = value();
+    else if (argument === "--seed") {
+      seed = Number(value());
+      if (!Number.isInteger(seed) || seed < 0 || seed > 4294967295) throw new Error("--seed must be an integer from 0 to 4294967295");
+    } else if (argument === "--tolerance") {
+      tolerance = Number(value());
+      if (!Number.isFinite(tolerance) || tolerance < 0 || tolerance > 255) throw new Error("--tolerance must be 0 to 255");
+    } else if (argument === "--json") json = true;
+    else if (argument === "--no-studio") studio = false;
+    else if (argument.startsWith("-")) throw new Error(`unknown option: ${argument}`);
+    else if (!file) file = argument;
+    else throw new Error(`unexpected argument: ${argument}`);
+  }
+  if (!file) throw new Error("usage: cascade parity <graph-file> [--node <id>] [--seed N] [--tolerance N] [--no-studio] [--json]");
+  return { file, ...node ? { node } : {}, ...seed === void 0 ? {} : { seed }, tolerance, json, studio };
+}
+async function runParityCommand(args) {
+  const options = parseParityArgs(args);
+  const log = console.log;
+  if (options.json) console.log = console.error;
+  try {
+    const report = await parity(options);
+    if (options.json) {
+      process.stdout.write(JSON.stringify(report) + "\n");
+      return 0;
+    }
+    log(formatParityReport(report));
+    return report.ok ? 0 : 1;
+  } finally {
+    console.log = log;
+  }
+}
+export {
+  compareSnapshots,
+  formatParityReport,
+  parity,
+  parseParityArgs,
+  runParityCommand,
+  snapshotValue
+};
+//# sourceMappingURL=parity-KINARCP2.js.map

package/dist/cli/pop-USDFXB7H.js

@@ -0,0 +1,39 @@
+import {
+  registerDefinitionNodes
+} from "./chunk-SGJAET2L.js";
+import "./chunk-FCDXJ6EK.js";
+import "./chunk-RUU3YWXU.js";
+import {
+  popNodeDefinitions,
+  popNodeRegistrations
+} from "./chunk-KH4MUBKF.js";
+import "./chunk-HSNOBIVT.js";
+import "./chunk-GFS6W3C5.js";
+import "./chunk-HFHWYL55.js";
+import "./chunk-CO22XHNG.js";
+import "./chunk-J7VK7MNF.js";
+import "./chunk-BIJO5OFS.js";
+
+// src/nodes/pop/library.ts
+var popLibrary = {
+  id: "pop",
+  label: "Particles",
+  icon: "Sparkles",
+  categories: [{
+    id: "pop",
+    label: "Particles",
+    nodes: popNodeDefinitions.map(([moduleId, definition]) => ({
+      name: definition.label ?? moduleId.split(".").pop(),
+      icon: definition.icon ?? "Sparkles",
+      description: definition.description ?? "",
+      type: moduleId
+    }))
+  }]
+};
+
+// src/nodes/pop/index.ts
+registerDefinitionNodes(popNodeRegistrations, {});
+export {
+  popLibrary
+};
+//# sourceMappingURL=pop-USDFXB7H.js.map

package/dist/cli/project-K3QIPGBB.js

@@ -0,0 +1,12 @@
+import {
+  PathSafetyError,
+  ProjectRoot
+} from "./chunk-RQZ4SX5R.js";
+import "./chunk-A4OAMOZH.js";
+import "./chunk-J7VK7MNF.js";
+import "./chunk-BIJO5OFS.js";
+export {
+  PathSafetyError,
+  ProjectRoot
+};
+//# sourceMappingURL=project-K3QIPGBB.js.map

package/dist/cli/projectDefinition-DMTZN2NE.js

@@ -0,0 +1,27 @@
+import {
+  adaptModule,
+  declaresDefinitionV1,
+  definitionAdapterError,
+  missingStudioCapabilities,
+  moduleNodeFunction,
+  studioCapabilities
+} from "./chunk-RLCAJBVR.js";
+import "./chunk-53NMBJAO.js";
+import "./chunk-SGJAET2L.js";
+import "./chunk-FCDXJ6EK.js";
+import "./chunk-RUU3YWXU.js";
+import "./chunk-GFS6W3C5.js";
+import "./chunk-HFHWYL55.js";
+import "./chunk-CO22XHNG.js";
+import "./chunk-A4OAMOZH.js";
+import "./chunk-J7VK7MNF.js";
+import "./chunk-BIJO5OFS.js";
+export {
+  adaptModule,
+  declaresDefinitionV1,
+  definitionAdapterError,
+  missingStudioCapabilities,
+  moduleNodeFunction,
+  studioCapabilities
+};
+//# sourceMappingURL=projectDefinition-DMTZN2NE.js.map

package/dist/cli/projectRuntime-Z5PJOH47.js

@@ -0,0 +1,48 @@
+import {
+  builtinModuleIds,
+  checkProjectGraph,
+  classifyPreflight,
+  cookProjectGraph,
+  createProjectHost,
+  diagnoseGraph,
+  inspectProjectGraph,
+  moduleDefinitions,
+  moduleId,
+  projectModuleFile,
+  renderDeterministicProjectFrames,
+  runDeterministicProjectGraph,
+  validateProjectGraph
+} from "./chunk-EUIAC3U3.js";
+import "./chunk-36P5K3SD.js";
+import "./chunk-D6BUOHUG.js";
+import "./chunk-RXDIMXN5.js";
+import "./chunk-QQPA2ZHH.js";
+import "./chunk-KH4MUBKF.js";
+import "./chunk-35D343DC.js";
+import "./chunk-DEQSEFFH.js";
+import "./chunk-HSNOBIVT.js";
+import "./chunk-ICH7N5PN.js";
+import "./chunk-GFS6W3C5.js";
+import "./chunk-HFHWYL55.js";
+import "./chunk-CO22XHNG.js";
+import "./chunk-RQZ4SX5R.js";
+import "./chunk-A4OAMOZH.js";
+import "./chunk-J7VK7MNF.js";
+import "./chunk-XWDSKG7N.js";
+import "./chunk-BIJO5OFS.js";
+export {
+  builtinModuleIds,
+  checkProjectGraph,
+  classifyPreflight,
+  cookProjectGraph,
+  createProjectHost,
+  diagnoseGraph,
+  inspectProjectGraph,
+  moduleDefinitions,
+  moduleId,
+  projectModuleFile,
+  renderDeterministicProjectFrames,
+  runDeterministicProjectGraph,
+  validateProjectGraph
+};
+//# sourceMappingURL=projectRuntime-Z5PJOH47.js.map