@darkhorseprojects/circuitry 0.2.6 → 0.2.12

package/dist/index.js

@@ -1,1063 +0,0 @@
-// 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 = /* @__PURE__ */ new Set([CIRCUITRY_SPEC_VERSION]);
-var validateCircuitryGraphWithStandard = (graph, standard = {}) => {
-  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)) {
-    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 = /* @__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"]);
-      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 = /* @__PURE__ */ new Map();
-  const incomingCount = /* @__PURE__ */ 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 = /* @__PURE__ */ new Set();
-  const visited = /* @__PURE__ */ 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 void 0;
-    return current[key];
-  }, 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))) {
-        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("\n")}`);
-    }
-  }
-  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("\n")}`);
-    }
-  }
-  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("\n")) {
-    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 = /* @__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;
-    }
-    nodes.set(node.id, {
-      id: node.id,
-      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, /* @__PURE__ */ new Set());
-    outputSets.set(node.id, /* @__PURE__ */ 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("\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("\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("\n") : "- none",
-    "Outgoing edges:",
-    outgoingEdges.length ? outgoingEdges.map((edge) => describeEdge(edge, "outgoing")).join("\n") : "- none"
-  ].join("\n");
-  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("\n\n");
-};
-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("\n\n");
-    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 || defaultModel || "",
-      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, /* @__PURE__ */ new Map()));
-    return runs;
-  }
-  const completed = /* @__PURE__ */ new Set();
-  const queued = /* @__PURE__ */ new Set();
-  const outputs = /* @__PURE__ */ new Map();
-  const nodeIds = [...executionGraph.nodes.keys()];
-  const remainingDependencies = /* @__PURE__ */ 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 = /* @__PURE__ */ 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("\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:
-${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("\n\n");
-};
-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,
-      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 = /* @__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));
-    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 = /* @__PURE__ */ new Map();
-  [...selected, ...relationships].forEach((el) => dedup.set(el.id, deepClone(el)));
-  return {
-    version: 1,
-    createdAt: (/* @__PURE__ */ 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 = /* @__PURE__ */ 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)}`);
-  }
-});
-export {
-  BUNDLE_MIME,
-  CIRCUITRY_AGENT_PRESET_DIRS,
-  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
-};