@darkhorseprojects/circuitry 0.2.12 → 0.2.13

package/dist/index.js

@@ -0,0 +1,1332 @@
+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";
+var createDefaultNodeData = (label) => {
+  const identity = label || "Agent";
+  return {
+    kind: CIRCUITRY_NODE_KIND,
+    identity,
+    label: identity,
+    model: "github-copilot/claude-haiku-4.5",
+    tools: [],
+    thinkingLevel: "off",
+    personality: "",
+    instructions: "Define this agent's behavior and objective.",
+    context: "",
+    output: "",
+    status: "idle",
+    lastError: null,
+    lastRunAt: null
+  };
+};
+var hasCircuitryNodeData = (element) => {
+  return !!element.customData?.circuitry && element.customData.circuitry.kind === CIRCUITRY_NODE_KIND;
+};
+var isNodeElement = (element) => {
+  return hasCircuitryNodeData(element);
+};
+// src/graph.ts
+var CIRCUITRY_SPEC_VERSION = "0.2";
+var CIRCUITRY_SPEC_VERSION_LEGACY = "0.1";
+var DEFAULT_CIRCUITRY_VALIDATION_RULES = [
+  "no-self-loops",
+  "no-unknown-edge-endpoints",
+  "require-executable-inputs",
+  "no-cycles"
+];
+var DEFAULT_CIRCUITRY_VALIDATION_STANDARD = {
+  version: CIRCUITRY_SPEC_VERSION,
+  requireSpecVersion: true,
+  rules: DEFAULT_CIRCUITRY_VALIDATION_RULES,
+  executableKinds: ["agent", "tool", "output"]
+};
+var executableKindsFromRules = (rules = []) => {
+  const executableRule = rules.find((entry) => typeof entry !== "string" && entry.rule === "require-executable-inputs");
+  return executableRule?.executableKinds;
+};
+var createCircuitryValidationStandard = (standard = {}, graph) => {
+  const rules = [
+    ...DEFAULT_CIRCUITRY_VALIDATION_RULES,
+    ...graph?.validation?.rules || [],
+    ...standard.rules || []
+  ];
+  return {
+    version: standard.version || DEFAULT_CIRCUITRY_VALIDATION_STANDARD.version,
+    requireSpecVersion: standard.requireSpecVersion ?? DEFAULT_CIRCUITRY_VALIDATION_STANDARD.requireSpecVersion,
+    rules,
+    executableKinds: standard.executableKinds || executableKindsFromRules(rules) || [
+      ...DEFAULT_CIRCUITRY_VALIDATION_STANDARD.executableKinds
+    ]
+  };
+};
+var expandResources = (resources) => {
+  const nodes = [];
+  const edges = [];
+  for (const [id, resource] of Object.entries(resources)) {
+    if (resource.type === "text") {
+      nodes.push({
+        id,
+        kind: "input",
+        label: resource.label || id,
+        input: { type: "text", value: resource.value }
+      });
+    } else if (resource.type === "agent") {
+      nodes.push({
+        id,
+        kind: "agent",
+        label: resource.label || resource.identity || id,
+        agent: {
+          identity: resource.identity || resource.label || id,
+          model: resource.model,
+          thinkingLevel: resource.thinkingLevel,
+          tools: resource.tools,
+          instructions: resource.instructions,
+          personality: resource.personality,
+          context: resource.context
+        },
+        skills: resource.skills,
+        expect: resource.expect
+      });
+      for (const inputRef of resource.inputs || []) {
+        edges.push({ from: inputRef, to: id, kind: "dependency" });
+      }
+    } else if (resource.type === "tool") {
+      nodes.push({
+        id,
+        kind: "tool",
+        label: resource.label || id,
+        agent: { instructions: resource.instructions }
+      });
+      for (const inputRef of resource.inputs || []) {
+        edges.push({ from: inputRef, to: id, kind: "dependency" });
+      }
+    }
+  }
+  return { nodes, edges };
+};
+var normalizeCircuitryGraph = (graph) => {
+  if (graph.resources && Object.keys(graph.resources).length > 0) {
+    const { nodes: nodes2, edges } = expandResources(graph.resources);
+    return { ...graph, nodes: nodes2, edges };
+  }
+  if (graph.nodes && graph.nodes.length > 0) {
+    const nodeIds = new Set(graph.nodes.map((n) => n.id));
+    const agents = graph.agents || {};
+    const inputs = graph.inputs || {};
+    const nodes2 = [...graph.nodes];
+    for (const [id, agent] of Object.entries(agents)) {
+      if (!nodeIds.has(id)) {
+        nodes2.push({
+          ...agent,
+          id,
+          kind: "agent",
+          label: agent.label || agent.agent?.identity || id,
+          agent: {
+            identity: agent.agent?.identity || agent.label || id,
+            ...agent.agent
+          }
+        });
+      }
+    }
+    for (const [id, input] of Object.entries(inputs)) {
+      if (!nodeIds.has(id)) {
+        nodes2.push({
+          id,
+          kind: "input",
+          label: input.label || id,
+          input
+        });
+      }
+    }
+    return { ...graph, nodes: nodes2 };
+  }
+  const nodes = [];
+  for (const [id, agent] of Object.entries(graph.agents || {})) {
+    nodes.push({
+      ...agent,
+      id,
+      kind: "agent",
+      label: agent.label || agent.agent?.identity || id,
+      agent: {
+        identity: agent.agent?.identity || agent.label || id,
+        ...agent.agent
+      }
+    });
+  }
+  for (const [id, input] of Object.entries(graph.inputs || {})) {
+    nodes.push({
+      id,
+      kind: "input",
+      label: input.label || id,
+      input
+    });
+  }
+  return {
+    ...graph,
+    nodes
+  };
+};
+var VALID_SPEC_VERSIONS = new Set([CIRCUITRY_SPEC_VERSION]);
+var validateCircuitryGraphWithStandard = (graph, standard = {}) => {
+  const resolvedStandard = createCircuitryValidationStandard(standard, graph && typeof graph === "object" && !Array.isArray(graph) ? graph : undefined);
+  const errors = [];
+  const addError = (code, message, path2) => errors.push({ code, message, ...path2 ? { path: path2 } : {} });
+  if (!graph || typeof graph !== "object" || Array.isArray(graph)) {
+    addError("invalid_graph", "Circuitry graph must be an object");
+    return { ok: false, errors, standard: resolvedStandard };
+  }
+  const graphObject = graph;
+  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"]);
+  }
+  if (graphObject.circuitry === CIRCUITRY_SPEC_VERSION && graphObject.resources && Object.keys(graphObject.resources).length > 0) {
+    if (graphObject.agents && Object.keys(graphObject.agents).length > 0) {
+      addError("v02_mixed_format", "v0.2 graphs with resources: must not use legacy agents: section", ["agents"]);
+    }
+    if (graphObject.inputs && Object.keys(graphObject.inputs).length > 0) {
+      addError("v02_mixed_format", "v0.2 graphs with resources: must not use legacy inputs: section", ["inputs"]);
+    }
+    if (graphObject.edges && graphObject.edges.length > 0) {
+      addError("v02_mixed_format", "v0.2 graphs with resources: must not use legacy edges: section", ["edges"]);
+    }
+  }
+  const normalized = normalizeCircuitryGraph(graphObject);
+  const ids = new Set;
+  for (const [index, node] of (normalized.nodes || []).entries()) {
+    if (!node.id) {
+      addError("missing_node_id", "Node is missing id", ["nodes", index, "id"]);
+      continue;
+    }
+    if (ids.has(node.id)) {
+      addError("duplicate_node_id", `Duplicate node id: ${node.id}`, ["nodes", index, "id"]);
+    }
+    ids.add(node.id);
+    if (!node.kind) {
+      addError("missing_node_kind", `Node ${node.id} is missing kind`, ["nodes", index, "kind"]);
+    }
+  }
+  const adjacency = new Map;
+  const incomingCount = new Map;
+  for (const id of ids) {
+    adjacency.set(id, []);
+    incomingCount.set(id, 0);
+  }
+  for (const [index, edge] of (normalized.edges || []).entries()) {
+    if (!edge.from || !edge.to) {
+      addError("missing_edge_endpoint", "Edge is missing from/to", ["edges", index]);
+      continue;
+    }
+    if (hasRule("no-self-loops") && edge.from === edge.to) {
+      addError("self_loop", `Edge creates self loop: ${edge.from} -> ${edge.to}`, ["edges", index]);
+      continue;
+    }
+    if (hasRule("no-unknown-edge-endpoints") && !ids.has(edge.from)) {
+      addError("unknown_edge_source", `Edge references unknown source: ${edge.from}`, ["edges", index, "from"]);
+    }
+    if (hasRule("no-unknown-edge-endpoints") && !ids.has(edge.to)) {
+      addError("unknown_edge_target", `Edge references unknown target: ${edge.to}`, ["edges", index, "to"]);
+    }
+    if (ids.has(edge.from) && ids.has(edge.to)) {
+      adjacency.get(edge.from).push(edge.to);
+      incomingCount.set(edge.to, (incomingCount.get(edge.to) || 0) + 1);
+    }
+  }
+  const executableKinds = new Set(resolvedStandard.executableKinds);
+  if (hasRule("require-executable-inputs")) {
+    for (const [index, node] of (normalized.nodes || []).entries()) {
+      if (executableKinds.has(node.kind) && (incomingCount.get(node.id) || 0) === 0) {
+        addError("executable_without_inputs", `Executable node has no inputs: ${node.id}`, ["nodes", index]);
+      }
+    }
+  }
+  const visiting = new Set;
+  const visited = new Set;
+  const path = [];
+  let cycleMessage = "";
+  const visit = (id) => {
+    if (cycleMessage)
+      return;
+    if (visiting.has(id)) {
+      cycleMessage = [...path.slice(path.indexOf(id)), id].join(" -> ");
+      return;
+    }
+    if (visited.has(id))
+      return;
+    visiting.add(id);
+    path.push(id);
+    for (const next of adjacency.get(id) || [])
+      visit(next);
+    path.pop();
+    visiting.delete(id);
+    visited.add(id);
+  };
+  if (hasRule("no-cycles")) {
+    for (const id of ids) {
+      visit(id);
+      if (cycleMessage) {
+        addError("cycle", `Graph contains cycle: ${cycleMessage}`);
+        break;
+      }
+    }
+  }
+  const additionalRules = rules.filter((rule) => {
+    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;
+    return current[key];
+  }, value);
+  const isPresent = (value) => value !== undefined && value !== null && value !== "";
+  for (const rule of additionalRules) {
+    if (rule.rule === "require-graph-field") {
+      if (!isPresent(getField(normalized, rule.field))) {
+        addError("missing_required_graph_field", `Graph is missing required field: ${rule.field}`, fieldPath(rule.field));
+      }
+      continue;
+    }
+    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 (!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)]);
+        }
+      }
+      continue;
+    }
+    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 (!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)]);
+        }
+      }
+      continue;
+    }
+    const checkString = (target, subject, id, match, path2) => {
+      const value = getField(subject, match.field);
+      const text = typeof value === "string" ? value : "";
+      const includes = text.includes(match.value);
+      if (rule.rule === "require-string" && !includes) {
+        addError("missing_required_string", `${target} ${id} field ${match.field} must include string: ${match.value}`, path2);
+      }
+      if (rule.rule === "reject-string" && includes) {
+        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.nodes || []) {
+      const nodeKinds = new Set(match.nodeKinds || []);
+      for (const [index, node] of (normalized.nodes || []).entries()) {
+        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;
+        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 parseCircuitryJson = (text, standard = {}, options = {}) => {
+  let graph;
+  try {
+    graph = JSON.parse(text);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Could not parse Circuitry JSON. Check commas, quotes, and braces.
+${message}`);
+  }
+  if (options.validate !== false) {
+    const errors = validateCircuitryGraph(graph, standard);
+    if (errors.length) {
+      throw new Error(`Invalid Circuitry graph:
+${errors.join(`
+`)}`);
+    }
+  }
+  return normalizeCircuitryGraph(graph);
+};
+var stringifyCircuitryJson = (graph) => {
+  return `${JSON.stringify(normalizeCircuitryGraph(graph), null, 2)}
+`;
+};
+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 = {}) => {
+  let graph;
+  try {
+    graph = YAML.parse(text);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Could not parse Circuitry YAML. Check indentation and quotes.
+${message}`);
+  }
+  if (!graph || typeof graph !== "object" || Array.isArray(graph)) {
+    throw new Error("Could not parse Circuitry YAML. Expected a graph object.");
+  }
+  if (options.validate !== false) {
+    const errors = validateCircuitryGraph(graph, standard);
+    if (errors.length) {
+      throw new Error(`Invalid Circuitry graph:
+${errors.join(`
+`)}`);
+    }
+  }
+  return normalizeCircuitryGraph(graph);
+};
+var stringifyCircuitryYaml = (graph) => {
+  return YAML.stringify(normalizeCircuitryGraph(graph));
+};
+var parseCircuitryText = (text, filename = "graph.circuitry.yaml", standard = {}, options = {}) => {
+  return filename.endsWith(".json") ? parseCircuitryJson(text, standard, options) : parseCircuitryYaml(text, standard, options);
+};
+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",
+  ".circuitry/agents",
+  "~/.agents/agents",
+  "~/.circuitry/agents"
+];
+var parseAgentPresetMarkdown = (text, fallbackName) => {
+  const frontmatter = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/m.exec(text);
+  if (!frontmatter) {
+    return {
+      name: fallbackName,
+      instructions: text.trim()
+    };
+  }
+  const metadata = {};
+  for (const line of frontmatter[1].split(`
+`)) {
+    const match = /^([A-Za-z0-9_-]+):\s*(.*)$/.exec(line.trim());
+    if (match) {
+      metadata[match[1]] = match[2].replace(/^['\"]|['\"]$/g, "");
+    }
+  }
+  return {
+    name: metadata.name || fallbackName,
+    description: metadata.description,
+    model: metadata.model,
+    personality: metadata.personality,
+    instructions: frontmatter[2].trim(),
+    metadata
+  };
+};
+var applyAgentPresets = (graph, presets) => {
+  const nodes = (graph.nodes || []).map((node) => {
+    if (node.kind !== "agent" || !node.agent?.uses) {
+      return node;
+    }
+    const preset = presets[node.agent.uses];
+    if (!preset) {
+      return node;
+    }
+    return {
+      ...node,
+      label: node.label || preset.name,
+      agent: {
+        model: preset.model,
+        personality: preset.personality,
+        instructions: preset.instructions,
+        identity: preset.name,
+        ...node.agent
+      }
+    };
+  });
+  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;
+  for (const node of normalized.nodes || []) {
+    if (node.kind !== "agent" && node.kind !== "tool" && node.kind !== "output" && node.kind !== "input") {
+      continue;
+    }
+    nodes.set(node.id, {
+      id: node.id,
+      node,
+      inputNodeIds: [],
+      outputNodeIds: [],
+      ...node.kind === "input" ? { output: node.input?.value || "", completed: true } : {}
+    });
+    inputSets.set(node.id, new Set);
+    outputSets.set(node.id, new Set);
+  }
+  for (const edge of normalized.edges || []) {
+    if (!nodes.has(edge.to)) {
+      continue;
+    }
+    inputSets.get(edge.to).add(edge.from);
+    if (nodes.has(edge.from)) {
+      outputSets.get(edge.from).add(edge.to);
+    }
+  }
+  for (const [id, node] of nodes) {
+    node.inputNodeIds = [...inputSets.get(id)];
+    node.outputNodeIds = [...outputSets.get(id)];
+  }
+  return { nodes };
+};
+var formatEdgeData = (data) => {
+  if (!data || Object.keys(data).length === 0) {
+    return "";
+  }
+  return ` data=${JSON.stringify(data)}`;
+};
+var describeEdge = (edge, direction) => {
+  const otherId = direction === "incoming" ? edge.from : edge.to;
+  const kind = edge.kind ? ` [${edge.kind}]` : "";
+  const label = edge.label ? `: ${edge.label}` : "";
+  return `- ${direction === "incoming" ? "from" : "to"} ${otherId}${kind}${label}${formatEdgeData(edge.data)}`;
+};
+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}:
+${input.text || ""}` : `Context ${index + 1} [${input.kind}] from ${input.sourceId}${input.text ? `:
+${input.text}` : ""}`).join(`
+
+`) : "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",
+    "Outgoing edges:",
+    outgoingEdges.length ? outgoingEdges.map((edge) => describeEdge(edge, "outgoing")).join(`
+`) : "- none"
+  ].join(`
+`);
+  return [
+    `Node label: ${node.label}`,
+    agent.identity ? `Identity: ${agent.identity}` : "",
+    agent.context ? `Context:
+${agent.context}` : "",
+    agent.personality ? `Personality:
+${agent.personality}` : "",
+    agent.instructions ? `Instructions:
+${agent.instructions}` : "",
+    wiringSection,
+    `Upstream Node Outputs:
+${upstreamSection}`,
+    `Connected Context Inputs:
+${contextSection}`
+  ].filter(Boolean).join(`
+
+`);
+};
+var collectImages = (contextInputs) => contextInputs.filter((item) => item.kind === "image" && item.image).map((item) => item.image);
+var executeCircuitryNode = async ({
+  graph,
+  item,
+  fallbackCycle,
+  inputPayload,
+  contextInputs,
+  defaultModel,
+  executeNode,
+  onNodeStart,
+  onNodeComplete
+}) => {
+  onNodeStart?.(item.id, fallbackCycle);
+  if (item.node.kind === "output") {
+    const output = inputPayload.map((input) => input.output).join(`
+
+`);
+    onNodeComplete?.(item.id, { output });
+    return {
+      nodeId: item.id,
+      fallbackCycle,
+      inputNodeIds: inputPayload.map((input) => input.nodeId),
+      output
+    };
+  }
+  const agent = item.node.agent || {};
+  try {
+    const result = await executeNode({
+      nodeId: item.id,
+      model: (agent.model === "inherit" ? undefined : agent.model) || (defaultModel === "inherit" ? undefined : defaultModel) || "inherit",
+      tools: agent.tools || [],
+      thinkingLevel: agent.thinkingLevel || "off",
+      personality: agent.personality || "",
+      instructions: agent.instructions || "",
+      context: agent.context || "",
+      inputs: inputPayload,
+      contextInputs,
+      images: collectImages(contextInputs),
+      prompt: composeCircuitryPrompt(graph, item.node, inputPayload, contextInputs)
+    });
+    onNodeComplete?.(item.id, { output: result.output });
+    return {
+      nodeId: item.id,
+      fallbackCycle,
+      inputNodeIds: inputPayload.map((input) => input.nodeId),
+      output: result.output
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    onNodeComplete?.(item.id, { error: message });
+    return {
+      nodeId: item.id,
+      fallbackCycle,
+      inputNodeIds: inputPayload.map((input) => input.nodeId),
+      output: "",
+      error: message
+    };
+  }
+};
+var runCircuitryGraphExecution = async ({
+  graph,
+  selectedNodeId,
+  executeNode,
+  resolveContextInputs,
+  onNodeStart,
+  onNodeComplete,
+  maxParallelRuns = 4
+}) => {
+  const executionGraph = buildCircuitryExecutionGraph(graph);
+  const runs = [];
+  const parallelism = Math.max(1, Math.floor(maxParallelRuns));
+  const defaultModel = graph.runtime?.model;
+  const runOne = async (nodeId, outputs2) => {
+    const fallbackCycle = false;
+    const item = executionGraph.nodes.get(nodeId);
+    const inputPayload = item.inputNodeIds.filter((sourceId) => outputs2.has(sourceId)).map((sourceId) => ({
+      nodeId: sourceId,
+      output: outputs2.get(sourceId)
+    }));
+    const contextInputs = await resolveContextInputs?.({
+      nodeId,
+      inputNodeIds: new Set(item.inputNodeIds),
+      graph
+    }) || [];
+    return executeCircuitryNode({
+      graph,
+      item,
+      fallbackCycle,
+      inputPayload,
+      contextInputs,
+      defaultModel,
+      executeNode,
+      onNodeStart,
+      onNodeComplete
+    });
+  };
+  if (selectedNodeId) {
+    if (!executionGraph.nodes.has(selectedNodeId)) {
+      return runs;
+    }
+    runs.push(await runOne(selectedNodeId, new Map));
+    return runs;
+  }
+  const completed = new Set;
+  const queued = new Set;
+  const outputs = new Map;
+  const nodeIds = [...executionGraph.nodes.keys()];
+  const remainingDependencies = new Map;
+  const ready = [];
+  for (const nodeId of nodeIds) {
+    const node = executionGraph.nodes.get(nodeId);
+    if (node.completed) {
+      completed.add(nodeId);
+      if (node.output) {
+        outputs.set(nodeId, node.output);
+      }
+      continue;
+    }
+    const count = node.inputNodeIds.filter((sourceId) => executionGraph.nodes.has(sourceId)).length;
+    remainingDependencies.set(nodeId, count);
+    if (count === 0) {
+      ready.push(nodeId);
+      queued.add(nodeId);
+    }
+  }
+  while (completed.size < nodeIds.length) {
+    if (ready.length === 0) {
+      const blocked = nodeIds.filter((id) => !completed.has(id));
+      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)
+    })));
+    for (const { nodeId, result } of chunkResults) {
+      outputs.set(nodeId, result.output);
+      completed.add(nodeId);
+      runs.push(result);
+      for (const outputNodeId of executionGraph.nodes.get(nodeId).outputNodeIds) {
+        if (completed.has(outputNodeId) || queued.has(outputNodeId)) {
+          continue;
+        }
+        const nextCount = Math.max(0, (remainingDependencies.get(outputNodeId) || 0) - 1);
+        remainingDependencies.set(outputNodeId, nextCount);
+        if (nextCount === 0) {
+          ready.push(outputNodeId);
+          queued.add(outputNodeId);
+        }
+      }
+    }
+  }
+  return runs;
+};
+// src/simulation.ts
+var DEFAULT_MAX_PARALLEL_RUNS = 4;
+var pushUnique = (array, value) => {
+  if (!array.includes(value)) {
+    array.push(value);
+  }
+};
+var buildSimulationGraph = (elements) => {
+  const nodes = new Map;
+  for (const element of elements) {
+    if (!hasCircuitryNodeData(element)) {
+      continue;
+    }
+    nodes.set(element.id, {
+      id: element.id,
+      element,
+      data: element.customData.circuitry,
+      inputNodeIds: [],
+      outputNodeIds: [],
+      incomingSourceIds: []
+    });
+  }
+  for (const element of elements) {
+    if (element.type !== "arrow") {
+      continue;
+    }
+    const arrow = element;
+    const sourceId = arrow.startBinding?.elementId;
+    const targetId = arrow.endBinding?.elementId;
+    if (!sourceId || !targetId || !nodes.has(targetId)) {
+      continue;
+    }
+    const target = nodes.get(targetId);
+    pushUnique(target.incomingSourceIds, sourceId);
+    if (!nodes.has(sourceId)) {
+      continue;
+    }
+    const source = nodes.get(sourceId);
+    pushUnique(source.outputNodeIds, targetId);
+    pushUnique(target.inputNodeIds, sourceId);
+  }
+  return { nodes };
+};
+var formatContextInput = (input, index) => {
+  if (input.kind === "text") {
+    return `Context ${index + 1} [text] from ${input.sourceId}:
+${input.text || ""}`;
+  }
+  if (input.kind === "image") {
+    return `Context ${index + 1} [image] from ${input.sourceId}`;
+  }
+  const label = input.elementType ? `${input.elementType}` : "element";
+  return `Context ${index + 1} [${label}] from ${input.sourceId}${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(`
+
+`);
+  return [
+    `Node label: ${node.data.label}`,
+    node.data.context ? `Context:
+${node.data.context}` : "",
+    node.data.personality ? `Personality:
+${node.data.personality}` : "",
+    node.data.instructions ? `Instructions:
+${node.data.instructions}` : "",
+    `Upstream Node Outputs:
+${upstreamSection}`,
+    `Connected Context Inputs:
+${contextSection}`
+  ].filter(Boolean).join(`
+
+`);
+};
+var collectImages2 = (contextInputs) => {
+  return contextInputs.filter((item) => item.kind === "image" && item.image).map((item) => item.image);
+};
+var executeSimulationNode = async ({
+  node,
+  fallbackCycle,
+  inputPayload,
+  contextInputs,
+  executeNode,
+  onNodeStart,
+  onNodeComplete
+}) => {
+  onNodeStart?.(node.id, fallbackCycle);
+  try {
+    const result = await executeNode({
+      nodeId: node.id,
+      model: node.data.model === "inherit" ? "inherit" : node.data.model || "inherit",
+      tools: node.data.tools || [],
+      thinkingLevel: node.data.thinkingLevel || "off",
+      personality: node.data.personality,
+      instructions: node.data.instructions,
+      context: node.data.context,
+      inputs: inputPayload,
+      contextInputs,
+      images: collectImages2(contextInputs),
+      prompt: composePrompt(node, inputPayload, contextInputs)
+    });
+    const item = {
+      nodeId: node.id,
+      fallbackCycle,
+      inputNodeIds: inputPayload.map((input) => input.nodeId),
+      output: result.output
+    };
+    onNodeComplete?.(node.id, { output: result.output });
+    return item;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const item = {
+      nodeId: node.id,
+      fallbackCycle,
+      inputNodeIds: inputPayload.map((input) => input.nodeId),
+      output: "",
+      error: message
+    };
+    onNodeComplete?.(node.id, { error: message });
+    return item;
+  }
+};
+var runGraphExecution = async ({
+  elements,
+  mode,
+  selectedNodeId,
+  executeNode,
+  resolveContextInputs,
+  onNodeStart,
+  onNodeComplete,
+  maxParallelRuns = DEFAULT_MAX_PARALLEL_RUNS
+}) => {
+  const graph = buildSimulationGraph(elements);
+  const runs = [];
+  const parallelism = Math.max(1, Math.floor(maxParallelRuns));
+  if (mode === "single") {
+    if (!selectedNodeId || !graph.nodes.has(selectedNodeId)) {
+      return runs;
+    }
+    const node = graph.nodes.get(selectedNodeId);
+    const inputPayload = node.inputNodeIds.map((sourceId) => graph.nodes.get(sourceId)).filter((sourceNode) => !!sourceNode?.data.output).map((sourceNode) => ({
+      nodeId: sourceNode.id,
+      output: sourceNode.data.output
+    }));
+    const contextInputs = await resolveContextInputs?.({
+      nodeId: node.id,
+      inputNodeIds: new Set(node.inputNodeIds),
+      incomingSourceIds: node.incomingSourceIds,
+      elements
+    }) || [];
+    runs.push(await executeSimulationNode({
+      node,
+      fallbackCycle: false,
+      inputPayload,
+      contextInputs,
+      executeNode,
+      onNodeStart,
+      onNodeComplete
+    }));
+    return runs;
+  }
+  const completed = new Set;
+  const outputs = new Map;
+  const nodeIds = [...graph.nodes.keys()];
+  while (completed.size < nodeIds.length) {
+    const pending = nodeIds.filter((id) => !completed.has(id));
+    const ready = pending.filter((id) => {
+      const node = graph.nodes.get(id);
+      return node.inputNodeIds.every((sourceId) => completed.has(sourceId));
+    });
+    if (ready.length === 0) {
+      throw new Error(`Circuitry execution stalled; unresolved dependencies: ${pending.join(", ")}`);
+    }
+    const fallbackCycle = false;
+    const currentBatch = ready;
+    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 };
+      }));
+      for (const { nodeId, result } of chunkResults) {
+        outputs.set(nodeId, result.output);
+        completed.add(nodeId);
+        runs.push(result);
+      }
+    }
+  }
+  return runs;
+};
+var runDependencySimulation = async ({
+  elements,
+  executeNode,
+  onNodeStart,
+  onNodeComplete,
+  maxParallelRuns
+}) => {
+  return runGraphExecution({
+    elements,
+    mode: "dependency",
+    executeNode,
+    onNodeStart,
+    onNodeComplete,
+    maxParallelRuns
+  });
+};
+// src/bundle.ts
+var BUNDLE_MIME = "application/vnd.circuitry.bundle+json";
+var deepClone = (value) => JSON.parse(JSON.stringify(value));
+var createBundleFromSelection = (elements, selectedIds) => {
+  const selected = elements.filter((el) => selectedIds[el.id]);
+  if (!selected.length) {
+    return null;
+  }
+  const selectedSet = new Set(selected.map((el) => el.id));
+  const relationships = elements.filter((el) => {
+    if (el.type !== "arrow") {
+      return false;
+    }
+    const arrow = el;
+    const source = arrow.startBinding?.elementId;
+    const target = arrow.endBinding?.elementId;
+    return !!source && !!target && selectedSet.has(source) && selectedSet.has(target);
+  });
+  const dedup = new Map;
+  [...selected, ...relationships].forEach((el) => dedup.set(el.id, deepClone(el)));
+  return {
+    version: 1,
+    createdAt: new Date().toISOString(),
+    elements: [...dedup.values()]
+  };
+};
+var parseBundleText = (text) => {
+  const parsed = JSON.parse(text);
+  if (parsed.version !== 1 || !Array.isArray(parsed.elements)) {
+    throw new Error("Invalid Circuitry bundle format");
+  }
+  return parsed;
+};
+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;
+  for (const element of bundle.elements) {
+    idMap.set(element.id, randomId());
+  }
+  return bundle.elements.map((element) => {
+    const cloned = deepClone(element);
+    const oldId = cloned.id;
+    cloned.id = idMap.get(oldId);
+    if (typeof cloned.x === "number") {
+      cloned.x += offsetX;
+    }
+    if (typeof cloned.y === "number") {
+      cloned.y += offsetY;
+    }
+    if (cloned.frameId && idMap.has(cloned.frameId)) {
+      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);
+    }
+    if (cloned.containerId && idMap.has(cloned.containerId)) {
+      cloned.containerId = idMap.get(cloned.containerId);
+    }
+    if (cloned.type === "arrow") {
+      const arrow = cloned;
+      if (arrow.startBinding && idMap.has(arrow.startBinding.elementId)) {
+        arrow.startBinding = {
+          ...arrow.startBinding,
+          elementId: idMap.get(arrow.startBinding.elementId)
+        };
+      }
+      if (arrow.endBinding && idMap.has(arrow.endBinding.elementId)) {
+        arrow.endBinding = {
+          ...arrow.endBinding,
+          elementId: idMap.get(arrow.endBinding.elementId)
+        };
+      }
+    }
+    return cloned;
+  });
+};
+// src/runtime.ts
+var createUnsupportedRuntimeAdapter = (id) => ({
+  id,
+  label: String(id),
+  async runNode() {
+    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,
+  CIRCUITRY_AGENT_PRESET_DIRS,
+  BUNDLE_MIME
+};