@darkhorseprojects/circuitry 0.2.14 → 0.2.15

package/dist/index.js

@@ -1,6 +1,3 @@
-import { createRequire } from "node:module";
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
 // src/types.ts
 var CIRCUITRY_NODE_CUSTOM_TYPE = "circuitry-node-person";
 var CIRCUITRY_NODE_KIND = "circuitry-node";
@@ -28,6 +25,7 @@ var hasCircuitryNodeData = (element) => {
 var isNodeElement = (element) => {
   return hasCircuitryNodeData(element);
 };
+
 // src/graph.ts
 var CIRCUITRY_SPEC_VERSION = "0.2";
 var CIRCUITRY_SPEC_VERSION_LEGACY = "0.1";
@@ -44,7 +42,9 @@ var DEFAULT_CIRCUITRY_VALIDATION_STANDARD = {
   executableKinds: ["agent", "tool", "output"]
 };
 var executableKindsFromRules = (rules = []) => {
-  const executableRule = rules.find((entry) => typeof entry !== "string" && entry.rule === "require-executable-inputs");
+  const executableRule = rules.find(
+    (entry) => typeof entry !== "string" && entry.rule === "require-executable-inputs"
+  );
   return executableRule?.executableKinds;
 };
 var createCircuitryValidationStandard = (standard = {}, graph) => {
@@ -169,9 +169,12 @@ var normalizeCircuitryGraph = (graph) => {
     nodes
   };
 };
-var VALID_SPEC_VERSIONS = new Set([CIRCUITRY_SPEC_VERSION]);
+var VALID_SPEC_VERSIONS = /* @__PURE__ */ new Set([CIRCUITRY_SPEC_VERSION]);
 var validateCircuitryGraphWithStandard = (graph, standard = {}) => {
-  const resolvedStandard = createCircuitryValidationStandard(standard, graph && typeof graph === "object" && !Array.isArray(graph) ? graph : undefined);
+  const resolvedStandard = createCircuitryValidationStandard(
+    standard,
+    graph && typeof graph === "object" && !Array.isArray(graph) ? graph : void 0
+  );
   const errors = [];
   const addError = (code, message, path2) => errors.push({ code, message, ...path2 ? { path: path2 } : {} });
   if (!graph || typeof graph !== "object" || Array.isArray(graph)) {
@@ -182,7 +185,11 @@ var validateCircuitryGraphWithStandard = (graph, standard = {}) => {
   const rules = resolvedStandard.rules;
   const hasRule = (name) => rules.some((entry) => (typeof entry === "string" ? entry : entry.rule) === name);
   if (resolvedStandard.requireSpecVersion && !VALID_SPEC_VERSIONS.has(String(graphObject.circuitry))) {
-    addError("invalid_spec_version", `Expected circuitry: "${CIRCUITRY_SPEC_VERSION}"`, ["circuitry"]);
+    addError(
+      "invalid_spec_version",
+      `Expected circuitry: "${CIRCUITRY_SPEC_VERSION}"`,
+      ["circuitry"]
+    );
   }
   if (graphObject.circuitry === CIRCUITRY_SPEC_VERSION && graphObject.resources && Object.keys(graphObject.resources).length > 0) {
     if (graphObject.agents && Object.keys(graphObject.agents).length > 0) {
@@ -196,7 +203,7 @@ var validateCircuitryGraphWithStandard = (graph, standard = {}) => {
     }
   }
   const normalized = normalizeCircuitryGraph(graphObject);
-  const ids = new Set;
+  const ids = /* @__PURE__ */ new Set();
   for (const [index, node] of (normalized.nodes || []).entries()) {
     if (!node.id) {
       addError("missing_node_id", "Node is missing id", ["nodes", index, "id"]);
@@ -210,8 +217,8 @@ var validateCircuitryGraphWithStandard = (graph, standard = {}) => {
       addError("missing_node_kind", `Node ${node.id} is missing kind`, ["nodes", index, "kind"]);
     }
   }
-  const adjacency = new Map;
-  const incomingCount = new Map;
+  const adjacency = /* @__PURE__ */ new Map();
+  const incomingCount = /* @__PURE__ */ new Map();
   for (const id of ids) {
     adjacency.set(id, []);
     incomingCount.set(id, 0);
@@ -244,23 +251,20 @@ var validateCircuitryGraphWithStandard = (graph, standard = {}) => {
       }
     }
   }
-  const visiting = new Set;
-  const visited = new Set;
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
   const path = [];
   let cycleMessage = "";
   const visit = (id) => {
-    if (cycleMessage)
-      return;
+    if (cycleMessage) return;
     if (visiting.has(id)) {
       cycleMessage = [...path.slice(path.indexOf(id)), id].join(" -> ");
       return;
     }
-    if (visited.has(id))
-      return;
+    if (visited.has(id)) return;
     visiting.add(id);
     path.push(id);
-    for (const next of adjacency.get(id) || [])
-      visit(next);
+    for (const next of adjacency.get(id) || []) visit(next);
     path.pop();
     visiting.delete(id);
     visited.add(id);
@@ -275,17 +279,15 @@ var validateCircuitryGraphWithStandard = (graph, standard = {}) => {
     }
   }
   const additionalRules = rules.filter((rule) => {
-    if (typeof rule === "string")
-      return false;
+    if (typeof rule === "string") return false;
     return rule.rule === "require-graph-field" || rule.rule === "require-node-field" || rule.rule === "require-edge-field" || rule.rule === "require-string" || rule.rule === "reject-string";
   });
   const fieldPath = (field) => field.split(".").filter(Boolean);
   const getField = (value, field) => fieldPath(field).reduce((current, key) => {
-    if (!current || typeof current !== "object")
-      return;
+    if (!current || typeof current !== "object") return void 0;
     return current[key];
   }, value);
-  const isPresent = (value) => value !== undefined && value !== null && value !== "";
+  const isPresent = (value) => value !== void 0 && value !== null && value !== "";
   for (const rule of additionalRules) {
     if (rule.rule === "require-graph-field") {
       if (!isPresent(getField(normalized, rule.field))) {
@@ -296,8 +298,7 @@ var validateCircuitryGraphWithStandard = (graph, standard = {}) => {
     if (rule.rule === "require-node-field") {
       const nodeKinds = new Set(rule.nodeKinds || []);
       for (const [index, node] of (normalized.nodes || []).entries()) {
-        if (nodeKinds.size > 0 && !nodeKinds.has(node.kind))
-          continue;
+        if (nodeKinds.size > 0 && !nodeKinds.has(node.kind)) continue;
         if (!isPresent(getField(node, rule.field))) {
           addError("missing_required_node_field", `Node ${node.id || "<missing id>"} is missing required field: ${rule.field}`, ["nodes", index, ...fieldPath(rule.field)]);
         }
@@ -307,8 +308,7 @@ var validateCircuitryGraphWithStandard = (graph, standard = {}) => {
     if (rule.rule === "require-edge-field") {
       const edgeKinds = new Set(rule.edgeKinds || []);
       for (const [index, edge] of (normalized.edges || []).entries()) {
-        if (edgeKinds.size > 0 && (!edge.kind || !edgeKinds.has(edge.kind)))
-          continue;
+        if (edgeKinds.size > 0 && (!edge.kind || !edgeKinds.has(edge.kind))) continue;
         if (!isPresent(getField(edge, rule.field))) {
           addError("missing_required_edge_field", `Edge ${edge.id || index} is missing required field: ${rule.field}`, ["edges", index, ...fieldPath(rule.field)]);
         }
@@ -326,28 +326,27 @@ var validateCircuitryGraphWithStandard = (graph, standard = {}) => {
         addError("rejected_string", `${target} ${id} field ${match.field} must not include string: ${match.value}`, path2);
       }
     };
-    for (const match of rule.graph || [])
-      checkString("graph", normalized, "<root>", match, fieldPath(match.field));
+    for (const match of rule.graph || []) checkString("graph", normalized, "<root>", match, fieldPath(match.field));
     for (const match of rule.nodes || []) {
       const nodeKinds = new Set(match.nodeKinds || []);
       for (const [index, node] of (normalized.nodes || []).entries()) {
-        if (nodeKinds.size > 0 && !nodeKinds.has(node.kind))
-          continue;
+        if (nodeKinds.size > 0 && !nodeKinds.has(node.kind)) continue;
         checkString("node", node, node.id || "<missing id>", match, ["nodes", index, ...fieldPath(match.field)]);
       }
     }
     for (const match of rule.edges || []) {
       const edgeKinds = new Set(match.edgeKinds || []);
       for (const [index, edge] of (normalized.edges || []).entries()) {
-        if (edgeKinds.size > 0 && (!edge.kind || !edgeKinds.has(edge.kind)))
-          continue;
+        if (edgeKinds.size > 0 && (!edge.kind || !edgeKinds.has(edge.kind))) continue;
         checkString("edge", edge, edge.id || String(index), match, ["edges", index, ...fieldPath(match.field)]);
       }
     }
   }
   return { ok: errors.length === 0, errors, standard: resolvedStandard };
 };
-var validateCircuitryGraph = (graph, standard = {}) => validateCircuitryGraphWithStandard(graph, standard).errors.map((error) => error.message);
+var validateCircuitryGraph = (graph, standard = {}) => validateCircuitryGraphWithStandard(graph, standard).errors.map(
+  (error) => error.message
+);
 var parseCircuitryJson = (text, standard = {}, options = {}) => {
   let graph;
   try {
@@ -361,8 +360,7 @@ ${message}`);
     const errors = validateCircuitryGraph(graph, standard);
     if (errors.length) {
       throw new Error(`Invalid Circuitry graph:
-${errors.join(`
-`)}`);
+${errors.join("\n")}`);
     }
   }
   return normalizeCircuitryGraph(graph);
@@ -374,6 +372,7 @@ var stringifyCircuitryJson = (graph) => {
 var isUriInput = (input) => {
   return Boolean(input.uri || ["file", "url", "uri", "image", "mcp"].includes(input.type));
 };
+
 // src/yaml.ts
 import YAML from "yaml";
 var parseCircuitryYaml = (text, standard = {}, options = {}) => {
@@ -392,8 +391,7 @@ ${message}`);
     const errors = validateCircuitryGraph(graph, standard);
     if (errors.length) {
       throw new Error(`Invalid Circuitry graph:
-${errors.join(`
-`)}`);
+${errors.join("\n")}`);
     }
   }
   return normalizeCircuitryGraph(graph);
@@ -407,6 +405,7 @@ var parseCircuitryText = (text, filename = "graph.circuitry.yaml", standard = {}
 var stringifyCircuitryText = (graph, filename = "graph.circuitry.yaml") => {
   return filename.endsWith(".json") ? stringifyCircuitryJson(graph) : stringifyCircuitryYaml(graph);
 };
+
 // src/presets.ts
 var CIRCUITRY_AGENT_PRESET_DIRS = [
   ".agents/agents",
@@ -423,8 +422,7 @@ var parseAgentPresetMarkdown = (text, fallbackName) => {
     };
   }
   const metadata = {};
-  for (const line of frontmatter[1].split(`
-`)) {
+  for (const line of frontmatter[1].split("\n")) {
     const match = /^([A-Za-z0-9_-]+):\s*(.*)$/.exec(line.trim());
     if (match) {
       metadata[match[1]] = match[2].replace(/^['\"]|['\"]$/g, "");
@@ -462,12 +460,13 @@ var applyAgentPresets = (graph, presets) => {
   });
   return { ...graph, nodes };
 };
+
 // src/scheduler.ts
 var buildCircuitryExecutionGraph = (graph) => {
   const normalized = normalizeCircuitryGraph(graph);
-  const nodes = new Map;
-  const inputSets = new Map;
-  const outputSets = new Map;
+  const nodes = /* @__PURE__ */ new Map();
+  const inputSets = /* @__PURE__ */ new Map();
+  const outputSets = /* @__PURE__ */ new Map();
   for (const node of normalized.nodes || []) {
     if (node.kind !== "agent" && node.kind !== "tool" && node.kind !== "output" && node.kind !== "input") {
       continue;
@@ -477,10 +476,11 @@ var buildCircuitryExecutionGraph = (graph) => {
       node,
       inputNodeIds: [],
       outputNodeIds: [],
+      // Input nodes are already "done" with their value as output
       ...node.kind === "input" ? { output: node.input?.value || "", completed: true } : {}
     });
-    inputSets.set(node.id, new Set);
-    outputSets.set(node.id, new Set);
+    inputSets.set(node.id, /* @__PURE__ */ new Set());
+    outputSets.set(node.id, /* @__PURE__ */ new Set());
   }
   for (const edge of normalized.edges || []) {
     if (!nodes.has(edge.to)) {
@@ -511,27 +511,24 @@ var describeEdge = (edge, direction) => {
 };
 var composeCircuitryPrompt = (graph, node, inputs, contextInputs) => {
   const agent = node.agent || {};
-  const upstreamSection = inputs.length ? inputs.map((input, index) => `Upstream ${index + 1} from ${input.nodeId}:
-${input.output}`).join(`
-
-`) : "No upstream node outputs.";
-  const contextSection = contextInputs.length ? contextInputs.map((input, index) => input.kind === "text" ? `Context ${index + 1} [text] from ${input.sourceId}:
+  const upstreamSection = inputs.length ? inputs.map(
+    (input, index) => `Upstream ${index + 1} from ${input.nodeId}:
+${input.output}`
+  ).join("\n\n") : "No upstream node outputs.";
+  const contextSection = contextInputs.length ? contextInputs.map(
+    (input, index) => input.kind === "text" ? `Context ${index + 1} [text] from ${input.sourceId}:
 ${input.text || ""}` : `Context ${index + 1} [${input.kind}] from ${input.sourceId}${input.text ? `:
-${input.text}` : ""}`).join(`
-
-`) : "No connected external context.";
+${input.text}` : ""}`
+  ).join("\n\n") : "No connected external context.";
   const incomingEdges = (graph.edges || []).filter((edge) => edge.to === node.id);
   const outgoingEdges = (graph.edges || []).filter((edge) => edge.from === node.id);
   const wiringSection = [
     "Canvas Wiring:",
     "Incoming edges:",
-    incomingEdges.length ? incomingEdges.map((edge) => describeEdge(edge, "incoming")).join(`
-`) : "- none",
+    incomingEdges.length ? incomingEdges.map((edge) => describeEdge(edge, "incoming")).join("\n") : "- none",
     "Outgoing edges:",
-    outgoingEdges.length ? outgoingEdges.map((edge) => describeEdge(edge, "outgoing")).join(`
-`) : "- none"
-  ].join(`
-`);
+    outgoingEdges.length ? outgoingEdges.map((edge) => describeEdge(edge, "outgoing")).join("\n") : "- none"
+  ].join("\n");
   return [
     `Node label: ${node.label}`,
     agent.identity ? `Identity: ${agent.identity}` : "",
@@ -546,9 +543,7 @@ ${agent.instructions}` : "",
 ${upstreamSection}`,
     `Connected Context Inputs:
 ${contextSection}`
-  ].filter(Boolean).join(`
-
-`);
+  ].filter(Boolean).join("\n\n");
 };
 var collectImages = (contextInputs) => contextInputs.filter((item) => item.kind === "image" && item.image).map((item) => item.image);
 var executeCircuitryNode = async ({
@@ -564,9 +559,7 @@ var executeCircuitryNode = async ({
 }) => {
   onNodeStart?.(item.id, fallbackCycle);
   if (item.node.kind === "output") {
-    const output = inputPayload.map((input) => input.output).join(`
-
-`);
+    const output = inputPayload.map((input) => input.output).join("\n\n");
     onNodeComplete?.(item.id, { output });
     return {
       nodeId: item.id,
@@ -579,7 +572,7 @@ var executeCircuitryNode = async ({
   try {
     const result = await executeNode({
       nodeId: item.id,
-      model: (agent.model === "inherit" ? undefined : agent.model) || (defaultModel === "inherit" ? undefined : defaultModel) || "inherit",
+      model: (agent.model === "inherit" ? void 0 : agent.model) || (defaultModel === "inherit" ? void 0 : defaultModel) || "inherit",
       tools: agent.tools || [],
       thinkingLevel: agent.thinkingLevel || "off",
       personality: agent.personality || "",
@@ -650,14 +643,14 @@ var runCircuitryGraphExecution = async ({
     if (!executionGraph.nodes.has(selectedNodeId)) {
       return runs;
     }
-    runs.push(await runOne(selectedNodeId, new Map));
+    runs.push(await runOne(selectedNodeId, /* @__PURE__ */ new Map()));
     return runs;
   }
-  const completed = new Set;
-  const queued = new Set;
-  const outputs = new Map;
+  const completed = /* @__PURE__ */ new Set();
+  const queued = /* @__PURE__ */ new Set();
+  const outputs = /* @__PURE__ */ new Map();
   const nodeIds = [...executionGraph.nodes.keys()];
-  const remainingDependencies = new Map;
+  const remainingDependencies = /* @__PURE__ */ new Map();
   const ready = [];
   for (const nodeId of nodeIds) {
     const node = executionGraph.nodes.get(nodeId);
@@ -668,7 +661,9 @@ var runCircuitryGraphExecution = async ({
       }
       continue;
     }
-    const count = node.inputNodeIds.filter((sourceId) => executionGraph.nodes.has(sourceId)).length;
+    const count = node.inputNodeIds.filter(
+      (sourceId) => executionGraph.nodes.has(sourceId)
+    ).length;
     remainingDependencies.set(nodeId, count);
     if (count === 0) {
       ready.push(nodeId);
@@ -681,10 +676,12 @@ var runCircuitryGraphExecution = async ({
       throw new Error(`Circuitry execution stalled; unresolved dependencies: ${blocked.join(", ")}`);
     }
     const chunk = ready.splice(0, parallelism);
-    const chunkResults = await Promise.all(chunk.map(async (nodeId) => ({
-      nodeId,
-      result: await runOne(nodeId, outputs)
-    })));
+    const chunkResults = await Promise.all(
+      chunk.map(async (nodeId) => ({
+        nodeId,
+        result: await runOne(nodeId, outputs)
+      }))
+    );
     for (const { nodeId, result } of chunkResults) {
       outputs.set(nodeId, result.output);
       completed.add(nodeId);
@@ -693,7 +690,10 @@ var runCircuitryGraphExecution = async ({
         if (completed.has(outputNodeId) || queued.has(outputNodeId)) {
           continue;
         }
-        const nextCount = Math.max(0, (remainingDependencies.get(outputNodeId) || 0) - 1);
+        const nextCount = Math.max(
+          0,
+          (remainingDependencies.get(outputNodeId) || 0) - 1
+        );
         remainingDependencies.set(outputNodeId, nextCount);
         if (nextCount === 0) {
           ready.push(outputNodeId);
@@ -704,6 +704,7 @@ var runCircuitryGraphExecution = async ({
   }
   return runs;
 };
+
 // src/simulation.ts
 var DEFAULT_MAX_PARALLEL_RUNS = 4;
 var pushUnique = (array, value) => {
@@ -712,7 +713,7 @@ var pushUnique = (array, value) => {
   }
 };
 var buildSimulationGraph = (elements) => {
-  const nodes = new Map;
+  const nodes = /* @__PURE__ */ new Map();
   for (const element of elements) {
     if (!hasCircuitryNodeData(element)) {
       continue;
@@ -760,13 +761,11 @@ ${input.text || ""}`;
 ${input.text}` : ""}`;
 };
 var composePrompt = (node, inputs, contextInputs) => {
-  const upstreamSection = inputs.length === 0 ? "No upstream node outputs." : inputs.map((input, index) => `Upstream ${index + 1} from ${input.nodeId}:
-${input.output}`).join(`
-
-`);
-  const contextSection = contextInputs.length === 0 ? "No connected external context." : contextInputs.map(formatContextInput).join(`
-
-`);
+  const upstreamSection = inputs.length === 0 ? "No upstream node outputs." : inputs.map(
+    (input, index) => `Upstream ${index + 1} from ${input.nodeId}:
+${input.output}`
+  ).join("\n\n");
+  const contextSection = contextInputs.length === 0 ? "No connected external context." : contextInputs.map(formatContextInput).join("\n\n");
   return [
     `Node label: ${node.data.label}`,
     node.data.context ? `Context:
@@ -779,9 +778,7 @@ ${node.data.instructions}` : "",
 ${upstreamSection}`,
     `Connected Context Inputs:
 ${contextSection}`
-  ].filter(Boolean).join(`
-
-`);
+  ].filter(Boolean).join("\n\n");
 };
 var collectImages2 = (contextInputs) => {
   return contextInputs.filter((item) => item.kind === "image" && item.image).map((item) => item.image);
@@ -859,19 +856,21 @@ var runGraphExecution = async ({
       incomingSourceIds: node.incomingSourceIds,
       elements
     }) || [];
-    runs.push(await executeSimulationNode({
-      node,
-      fallbackCycle: false,
-      inputPayload,
-      contextInputs,
-      executeNode,
-      onNodeStart,
-      onNodeComplete
-    }));
+    runs.push(
+      await executeSimulationNode({
+        node,
+        fallbackCycle: false,
+        inputPayload,
+        contextInputs,
+        executeNode,
+        onNodeStart,
+        onNodeComplete
+      })
+    );
     return runs;
   }
-  const completed = new Set;
-  const outputs = new Map;
+  const completed = /* @__PURE__ */ new Set();
+  const outputs = /* @__PURE__ */ new Map();
   const nodeIds = [...graph.nodes.keys()];
   while (completed.size < nodeIds.length) {
     const pending = nodeIds.filter((id) => !completed.has(id));
@@ -884,31 +883,33 @@ var runGraphExecution = async ({
     }
     const fallbackCycle = false;
     const currentBatch = ready;
-    for (let index = 0;index < currentBatch.length; index += parallelism) {
+    for (let index = 0; index < currentBatch.length; index += parallelism) {
       const chunk = currentBatch.slice(index, index + parallelism);
-      const chunkResults = await Promise.all(chunk.map(async (nodeId) => {
-        const node = graph.nodes.get(nodeId);
-        const inputPayload = node.inputNodeIds.filter((sourceId) => outputs.has(sourceId)).map((sourceId) => ({
-          nodeId: sourceId,
-          output: outputs.get(sourceId)
-        }));
-        const contextInputs = await resolveContextInputs?.({
-          nodeId,
-          inputNodeIds: new Set(node.inputNodeIds),
-          incomingSourceIds: node.incomingSourceIds,
-          elements
-        }) || [];
-        const result = await executeSimulationNode({
-          node,
-          fallbackCycle,
-          inputPayload,
-          contextInputs,
-          executeNode,
-          onNodeStart,
-          onNodeComplete
-        });
-        return { nodeId, result };
-      }));
+      const chunkResults = await Promise.all(
+        chunk.map(async (nodeId) => {
+          const node = graph.nodes.get(nodeId);
+          const inputPayload = node.inputNodeIds.filter((sourceId) => outputs.has(sourceId)).map((sourceId) => ({
+            nodeId: sourceId,
+            output: outputs.get(sourceId)
+          }));
+          const contextInputs = await resolveContextInputs?.({
+            nodeId,
+            inputNodeIds: new Set(node.inputNodeIds),
+            incomingSourceIds: node.incomingSourceIds,
+            elements
+          }) || [];
+          const result = await executeSimulationNode({
+            node,
+            fallbackCycle,
+            inputPayload,
+            contextInputs,
+            executeNode,
+            onNodeStart,
+            onNodeComplete
+          });
+          return { nodeId, result };
+        })
+      );
       for (const { nodeId, result } of chunkResults) {
         outputs.set(nodeId, result.output);
         completed.add(nodeId);
@@ -934,6 +935,7 @@ var runDependencySimulation = async ({
     maxParallelRuns
   });
 };
+
 // src/bundle.ts
 var BUNDLE_MIME = "application/vnd.circuitry.bundle+json";
 var deepClone = (value) => JSON.parse(JSON.stringify(value));
@@ -952,11 +954,11 @@ var createBundleFromSelection = (elements, selectedIds) => {
     const target = arrow.endBinding?.elementId;
     return !!source && !!target && selectedSet.has(source) && selectedSet.has(target);
   });
-  const dedup = new Map;
+  const dedup = /* @__PURE__ */ new Map();
   [...selected, ...relationships].forEach((el) => dedup.set(el.id, deepClone(el)));
   return {
     version: 1,
-    createdAt: new Date().toISOString(),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     elements: [...dedup.values()]
   };
 };
@@ -967,11 +969,11 @@ var parseBundleText = (text) => {
   }
   return parsed;
 };
-var randomId = () => typeof crypto !== "undefined" && ("randomUUID" in crypto) ? crypto.randomUUID().replaceAll("-", "") : Math.random().toString(36).slice(2, 12);
+var randomId = () => typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID().replaceAll("-", "") : Math.random().toString(36).slice(2, 12);
 var importBundleElements = (bundle, opts) => {
   const offsetX = opts?.offsetX ?? 24;
   const offsetY = opts?.offsetY ?? 24;
-  const idMap = new Map;
+  const idMap = /* @__PURE__ */ new Map();
   for (const element of bundle.elements) {
     idMap.set(element.id, randomId());
   }
@@ -989,7 +991,9 @@ var importBundleElements = (bundle, opts) => {
       cloned.frameId = idMap.get(cloned.frameId);
     }
     if (cloned.boundElements?.length) {
-      cloned.boundElements = cloned.boundElements.map((item) => idMap.has(item.id) ? { ...item, id: idMap.get(item.id) } : item);
+      cloned.boundElements = cloned.boundElements.map(
+        (item) => idMap.has(item.id) ? { ...item, id: idMap.get(item.id) } : item
+      );
     }
     if (cloned.containerId && idMap.has(cloned.containerId)) {
       cloned.containerId = idMap.get(cloned.containerId);
@@ -1012,6 +1016,7 @@ var importBundleElements = (bundle, opts) => {
     return cloned;
   });
 };
+
 // src/runtime.ts
 var createUnsupportedRuntimeAdapter = (id) => ({
   id,
@@ -1020,313 +1025,39 @@ var createUnsupportedRuntimeAdapter = (id) => ({
     throw new Error(`Circuitry runtime adapter is not configured: ${String(id)}`);
   }
 });
-// src/tools.ts
-import { z } from "zod";
-var standardSchema = z.object({
-  version: z.string().optional(),
-  requireSpecVersion: z.boolean().optional(),
-  executableKinds: z.array(z.string()).optional(),
-  rules: z.array(z.union([z.string(), z.object({ rule: z.string() }).passthrough()])).optional()
-}).passthrough().optional();
-var createCircuitryReadGraphTool = (host) => ({
-  name: "circuitry_read_graph",
-  description: "Read the current Circuitry graph. In the App this reads the canvas and includes latest node run outputs.",
-  parameters: z.object({
-    filename: z.string().optional().describe("Optional filename when in standalone mode.")
-  }),
-  execute: (input) => host.readGraph(input)
-});
-var createCircuitryWriteGraphTool = (host) => ({
-  name: "circuitry_write_graph",
-  description: "Replace a Circuitry graph. In the App this applies the graph to the canvas; standalone writes a file.",
-  parameters: z.object({
-    text: z.string().optional().describe("YAML graph text."),
-    filename: z.string().optional().describe("Optional filename."),
-    graph: z.any().optional().describe("Parsed graph object."),
-    standard: standardSchema
-  }),
-  execute: (input) => host.writeGraph(input)
-});
-var createCircuitryRunGraphTool = (host) => ({
-  name: "circuitry_run_graph",
-  description: "Run the current Circuitry graph. After running, call circuitry_read_graph to inspect updated per-node outputs and errors.",
-  parameters: z.object({
-    source: z.enum(["current", "text"]).optional().describe("Whether to run the 'current' canvas/file or provided 'text'."),
-    text: z.string().optional().describe("YAML graph text if source is 'text'."),
-    filename: z.string().optional().describe("Optional filename."),
-    selectedNodeId: z.string().optional().describe("Optional specific node to run."),
-    standard: standardSchema,
-    hostModel: z.string().optional().describe("Optional model to use when a node is set to 'inherit'.")
-  }),
-  execute: (input) => host.runGraph(input)
-});
-var createCircuitryValidateGraphTool = (host) => ({
-  name: "circuitry_validate_graph",
-  description: "Validate Circuitry YAML or JSON graph text. Returns structured validation issues.",
-  parameters: z.object({
-    text: z.string().describe("YAML or JSON graph text to validate."),
-    filename: z.string().optional().describe("Optional filename context."),
-    standard: standardSchema
-  }),
-  execute: (input) => host.validateGraph(input)
-});
-var createCircuitryTools = (host) => [
-  createCircuitryReadGraphTool(host),
-  createCircuitryWriteGraphTool(host),
-  createCircuitryRunGraphTool(host),
-  createCircuitryValidateGraphTool(host)
-];
-// src/node.ts
-import { access, readFile, writeFile } from "node:fs/promises";
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-var loadPiSDK = async () => {
-  const possiblePaths = [
-    path.join(process.cwd(), "node_modules/@earendil-works/pi-coding-agent/dist/index.js"),
-    path.join(os.homedir(), ".npm-global/lib/node_modules/@earendil-works/pi-coding-agent/dist/index.js")
-  ];
-  for (const modulePath of possiblePaths) {
-    if (fs.existsSync(modulePath)) {
-      return await import(modulePath);
-    }
-  }
-  return await import("@earendil-works/pi-coding-agent");
-};
-var extractAssistantText = (message) => {
-  if (!message || message.role !== "assistant")
-    return "";
-  if (typeof message.content === "string")
-    return message.content;
-  if (!Array.isArray(message.content))
-    return "";
-  return message.content.filter((part) => part?.type === "text" && typeof part.text === "string").map((part) => part.text).join("");
-};
-var withTimeout = async (promise, timeoutMs) => {
-  let timeout;
-  try {
-    return await Promise.race([
-      promise,
-      new Promise((_, reject) => {
-        timeout = setTimeout(() => reject(new Error(`Pi SDK request timed out after ${timeoutMs}ms`)), timeoutMs);
-      })
-    ]);
-  } finally {
-    clearTimeout(timeout);
-  }
-};
-var runNodeWithPiSDK = async ({
-  model,
-  prompt,
-  images = [],
-  tools = [],
-  thinkingLevel = "off"
-}) => {
-  let sdk;
-  try {
-    sdk = await loadPiSDK();
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error([
-      "Circuitry could not load the Pi SDK package for execution.",
-      "Ensure @earendil-works/pi-coding-agent is installed.",
-      message
-    ].join(`
-`));
-  }
-  const { AuthStorage, ModelRegistry, SessionManager, createAgentSession } = sdk;
-  const authStorage = AuthStorage.create();
-  const modelRegistry = ModelRegistry.create(authStorage);
-  const [provider, ...modelParts] = String(model || "").split("/");
-  const modelId = modelParts.join("/");
-  const available = await modelRegistry.getAvailable();
-  const selectedModel = (provider && modelId ? modelRegistry.find(provider, modelId) : undefined) || available.find((entry) => {
-    if (!modelId)
-      return false;
-    return `${entry.provider}/${entry.id}` === `${provider}/${modelId}` || entry.id === modelId;
-  }) || available[0];
-  if (!selectedModel) {
-    throw new Error("No Pi SDK models are available. Configure ~/.pi/agent/auth.json");
-  }
-  const { session } = await createAgentSession({
-    model: selectedModel,
-    thinkingLevel,
-    sessionManager: SessionManager.inMemory(),
-    authStorage,
-    modelRegistry
-  });
-  session.setActiveToolsByName(Array.isArray(tools) ? tools.map((tool) => String(tool)) : []);
-  let output = "";
-  const unsubscribe = session.subscribe((event) => {
-    if ((event.type === "message_update" || event.type === "message_end") && event.message?.role === "assistant") {
-      output = extractAssistantText(event.message);
-    }
-    if (event.type === "agent_end" && Array.isArray(event.messages)) {
-      const assistantMessage = [...event.messages].reverse().find((message) => message.role === "assistant");
-      output = extractAssistantText(assistantMessage);
-    }
-  });
-  try {
-    const promptImages = images.filter((image) => image?.mediaType && image?.data).map((image) => ({
-      type: "image",
-      source: { type: "base64", mediaType: image.mediaType, data: image.data }
-    }));
-    await withTimeout(session.prompt(prompt, { images: promptImages }), 180000);
-    return { output: output.trim() };
-  } finally {
-    unsubscribe();
-    session.dispose();
-  }
-};
-var defaultFilename = "graph.circuitry.yaml";
-
-class NodeCircuitryHost {
-  resolveGraphFile(filename) {
-    return path.resolve(process.cwd(), filename || process.env.CIRCUITRY_GRAPH || defaultFilename);
-  }
-  runFileFor(filename) {
-    return `${filename}.run.json`;
-  }
-  async exists(filename) {
-    try {
-      await access(filename);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  parseIssue(error, filename) {
-    return {
-      code: "parse_error",
-      message: error instanceof Error ? error.message : String(error),
-      path: [filename]
-    };
-  }
-  parseGraphForValidation(text, filename, standard) {
-    try {
-      return {
-        graph: parseCircuitryText(text || "", filename, standard, {
-          validate: false
-        })
-      };
-    } catch (error) {
-      return { error: this.parseIssue(error, filename) };
-    }
-  }
-  async readGraphFile(filename) {
-    const graphFile = this.resolveGraphFile(filename);
-    const text = await readFile(graphFile, "utf8");
-    const graph = parseCircuitryText(text, graphFile);
-    return { graphFile, text, graph };
-  }
-  async readGraph(input = {}) {
-    const { graphFile, text, graph } = await this.readGraphFile(input.filename);
-    const lastRunFile = this.runFileFor(graphFile);
-    const lastRun = await this.exists(lastRunFile) ? JSON.parse(await readFile(lastRunFile, "utf8")) : undefined;
-    return { filename: graphFile, graph, text, lastRun };
-  }
-  async validateGraph(input) {
-    if (input.graph)
-      return validateCircuitryGraphWithStandard(input.graph, input.standard);
-    const filename = input.filename || defaultFilename;
-    const parsed = this.parseGraphForValidation(input.text, filename, input.standard);
-    if (parsed.error) {
-      return {
-        ok: false,
-        errors: [parsed.error],
-        standard: validateCircuitryGraphWithStandard({}, input.standard).standard
-      };
-    }
-    return validateCircuitryGraphWithStandard(parsed.graph, input.standard);
-  }
-  async writeGraph(input) {
-    const graphFile = this.resolveGraphFile(input.filename);
-    const parsed = input.graph ? { graph: input.graph } : this.parseGraphForValidation(input.text, input.filename || graphFile, input.standard);
-    if (!parsed.graph)
-      throw new Error(`Invalid Circuitry graph:
-${parsed.error?.message}`);
-    const validation = await this.validateGraph({
-      graph: parsed.graph,
-      standard: input.standard
-    });
-    if (validation.errors.length)
-      throw new Error(`Invalid Circuitry graph:
-${validation.errors.map((e) => e.message).join(`
-`)}`);
-    await writeFile(graphFile, stringifyCircuitryText(parsed.graph, graphFile), "utf8");
-    return {
-      filename: graphFile,
-      graph: parsed.graph,
-      mode: "replace"
-    };
-  }
-  async runGraph(input = {}) {
-    const source = input.source || (input.text ? "text" : "current");
-    const graphFile = this.resolveGraphFile(input.filename);
-    const parsed = source === "text" ? this.parseGraphForValidation(input.text, input.filename || graphFile, input.standard) : { graph: (await this.readGraphFile(input.filename)).graph };
-    if (!parsed.graph)
-      throw new Error(`Invalid Circuitry graph:
-${parsed.error?.message}`);
-    const validation = await this.validateGraph({
-      graph: parsed.graph,
-      standard: input.standard
-    });
-    if (validation.errors.length)
-      throw new Error(`Invalid Circuitry graph:
-${validation.errors.map((e) => e.message).join(`
-`)}`);
-    const runItems = await runCircuitryGraphExecution({
-      graph: parsed.graph,
-      selectedNodeId: input.selectedNodeId,
-      executeNode: (req) => runNodeWithPiSDK(req)
-    });
-    const result = { completedAt: new Date().toISOString(), runItems };
-    if (source !== "text")
-      await writeFile(this.runFileFor(graphFile), JSON.stringify(result, null, 2), "utf8");
-    return result;
-  }
-}
 export {
-  validateCircuitryGraphWithStandard,
-  validateCircuitryGraph,
-  stringifyCircuitryYaml,
-  stringifyCircuitryText,
-  stringifyCircuitryJson,
-  standardSchema,
-  runNodeWithPiSDK,
-  runGraphExecution,
-  runDependencySimulation,
-  runCircuitryGraphExecution,
-  parseCircuitryYaml,
-  parseCircuitryText,
-  parseCircuitryJson,
-  parseBundleText,
-  parseAgentPresetMarkdown,
-  normalizeCircuitryGraph,
-  isUriInput,
-  isNodeElement,
-  importBundleElements,
-  hasCircuitryNodeData,
-  createUnsupportedRuntimeAdapter,
-  createDefaultNodeData,
-  createCircuitryWriteGraphTool,
-  createCircuitryValidationStandard,
-  createCircuitryValidateGraphTool,
-  createCircuitryTools,
-  createCircuitryRunGraphTool,
-  createCircuitryReadGraphTool,
-  createBundleFromSelection,
-  buildSimulationGraph,
-  buildCircuitryExecutionGraph,
-  applyAgentPresets,
-  NodeCircuitryHost,
-  DEFAULT_MAX_PARALLEL_RUNS,
-  DEFAULT_CIRCUITRY_VALIDATION_STANDARD,
-  DEFAULT_CIRCUITRY_VALIDATION_RULES,
-  CIRCUITRY_SPEC_VERSION_LEGACY,
-  CIRCUITRY_SPEC_VERSION,
-  CIRCUITRY_NODE_KIND,
-  CIRCUITRY_NODE_CUSTOM_TYPE,
+  BUNDLE_MIME,
   CIRCUITRY_AGENT_PRESET_DIRS,
-  BUNDLE_MIME
+  CIRCUITRY_NODE_CUSTOM_TYPE,
+  CIRCUITRY_NODE_KIND,
+  CIRCUITRY_SPEC_VERSION,
+  CIRCUITRY_SPEC_VERSION_LEGACY,
+  DEFAULT_CIRCUITRY_VALIDATION_RULES,
+  DEFAULT_CIRCUITRY_VALIDATION_STANDARD,
+  DEFAULT_MAX_PARALLEL_RUNS,
+  applyAgentPresets,
+  buildCircuitryExecutionGraph,
+  buildSimulationGraph,
+  createBundleFromSelection,
+  createCircuitryValidationStandard,
+  createDefaultNodeData,
+  createUnsupportedRuntimeAdapter,
+  hasCircuitryNodeData,
+  importBundleElements,
+  isNodeElement,
+  isUriInput,
+  normalizeCircuitryGraph,
+  parseAgentPresetMarkdown,
+  parseBundleText,
+  parseCircuitryJson,
+  parseCircuitryText,
+  parseCircuitryYaml,
+  runCircuitryGraphExecution,
+  runDependencySimulation,
+  runGraphExecution,
+  stringifyCircuitryJson,
+  stringifyCircuitryText,
+  stringifyCircuitryYaml,
+  validateCircuitryGraph,
+  validateCircuitryGraphWithStandard
 };