@graphrefly/graphrefly 0.27.0 → 0.29.0

package/dist/chunk-K2AUJHVP.js

@@ -1,2251 +0,0 @@
-import {
-  decay,
-  knowledgeGraph,
-  lightCollection,
-  vectorIndex
-} from "./chunk-AT5LKYNL.js";
-import {
-  distill,
-  switchMap
-} from "./chunk-RNHBMHKA.js";
-import {
-  topic
-} from "./chunk-X5R3GL6H.js";
-import {
-  domainMeta
-} from "./chunk-JSCT3CR4.js";
-import {
-  reactiveLog
-} from "./chunk-J2VBW3DZ.js";
-import {
-  fromAny,
-  fromTimer,
-  keepalive
-} from "./chunk-BVZYTZ5H.js";
-import {
-  GRAPH_META_SEGMENT,
-  Graph
-} from "./chunk-PF7GRZMW.js";
-import {
-  ResettableTimer
-} from "./chunk-7TAQJHQV.js";
-import {
-  batch,
-  derived,
-  effect,
-  monotonicNs,
-  node,
-  producer,
-  state
-} from "./chunk-PHOUUNK7.js";
-import {
-  COMPLETE,
-  DATA,
-  ERROR,
-  RESOLVED,
-  __export
-} from "./chunk-SX52TAR4.js";
-
-// src/patterns/ai.ts
-var ai_exports = {};
-__export(ai_exports, {
-  AgentLoopGraph: () => AgentLoopGraph,
-  ChatStreamGraph: () => ChatStreamGraph,
-  ToolRegistryGraph: () => ToolRegistryGraph,
-  admissionFilter3D: () => admissionFilter3D,
-  agentLoop: () => agentLoop,
-  agentMemory: () => agentMemory,
-  chatStream: () => chatStream,
-  contentGate: () => contentGate,
-  costMeterExtractor: () => costMeterExtractor,
-  fromLLM: () => fromLLM,
-  gatedStream: () => gatedStream,
-  gaugesAsContext: () => gaugesAsContext,
-  graphFromSpec: () => graphFromSpec,
-  keywordFlagExtractor: () => keywordFlagExtractor,
-  knobsAsTools: () => knobsAsTools,
-  llmConsolidator: () => llmConsolidator,
-  llmExtractor: () => llmExtractor,
-  promptNode: () => promptNode,
-  redactor: () => redactor,
-  streamExtractor: () => streamExtractor,
-  streamingPromptNode: () => streamingPromptNode,
-  suggestStrategy: () => suggestStrategy,
-  systemPromptBuilder: () => systemPromptBuilder,
-  toolCallExtractor: () => toolCallExtractor,
-  toolRegistry: () => toolRegistry,
-  validateGraphDef: () => validateGraphDef
-});
-
-// src/patterns/orchestration.ts
-var orchestration_exports = {};
-__export(orchestration_exports, {
-  approval: () => approval,
-  branch: () => branch,
-  forEach: () => forEach,
-  gate: () => gate,
-  join: () => join,
-  loop: () => loop,
-  onFailure: () => onFailure,
-  pipeline: () => pipeline,
-  sensor: () => sensor,
-  subPipeline: () => subPipeline,
-  task: () => task,
-  valve: () => valve,
-  wait: () => wait
-});
-function resolveDep(graph, dep) {
-  if (typeof dep === "string") {
-    return { node: graph.resolve(dep), path: dep };
-  }
-  const path = findRegisteredNodePath(graph, dep);
-  if (!path) {
-    throw new Error(
-      "orchestration dep node must already be registered in the graph so explicit edges can be recorded; pass a string path or register the node first"
-    );
-  }
-  return { node: dep, path };
-}
-function findRegisteredNodePath(graph, target) {
-  const described = graph.describe();
-  const metaSegment = `::${GRAPH_META_SEGMENT}::`;
-  for (const path of Object.keys(described.nodes).sort()) {
-    if (path.includes(metaSegment)) continue;
-    try {
-      if (graph.resolve(path) === target) return path;
-    } catch {
-    }
-  }
-  return void 0;
-}
-function registerStep(graph, name, step, depPaths) {
-  graph.add(name, step);
-  void depPaths;
-}
-function baseMeta(kind, meta) {
-  return domainMeta("orchestration", kind, meta);
-}
-function coerceLoopIterations(raw) {
-  const parseString = (value) => {
-    const trimmed = value.trim();
-    if (trimmed.length === 0) return 0;
-    return Number(trimmed);
-  };
-  let parsed;
-  if (typeof raw === "string") {
-    parsed = parseString(raw);
-  } else if (raw === null) {
-    parsed = 0;
-  } else {
-    parsed = Number(raw);
-  }
-  if (!Number.isFinite(parsed)) return 1;
-  return Math.max(0, Math.trunc(parsed));
-}
-function pipeline(name, opts) {
-  return new Graph(name, opts);
-}
-function task(graph, name, run, opts) {
-  const depRefs = opts?.deps ?? [];
-  const deps = depRefs.map((dep) => resolveDep(graph, dep));
-  const { deps: _deps, ...nodeOpts } = opts ?? {};
-  const wrapped = (batchData, actions, ctx) => {
-    const data = batchData.map(
-      (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
-    );
-    actions.emit(run(data, ctx));
-    return void 0;
-  };
-  const step = node(
-    deps.map((d) => d.node),
-    wrapped,
-    {
-      ...nodeOpts,
-      name,
-      describeKind: "derived",
-      meta: baseMeta("task", opts?.meta)
-    }
-  );
-  registerStep(
-    graph,
-    name,
-    step,
-    deps.flatMap((d) => d.path ? [d.path] : [])
-  );
-  return step;
-}
-function branch(graph, name, source, predicate, opts) {
-  const src = resolveDep(graph, source);
-  const step = derived(
-    [src.node],
-    ([value]) => ({
-      branch: predicate(value) ? "then" : "else",
-      value
-    }),
-    {
-      ...opts,
-      name,
-      meta: baseMeta("branch", opts?.meta)
-    }
-  );
-  registerStep(graph, name, step, src.path ? [src.path] : []);
-  return step;
-}
-function valve(graph, name, source, control, opts) {
-  const src = resolveDep(graph, source);
-  const ctrl = resolveDep(graph, control);
-  const step = node(
-    [src.node, ctrl.node],
-    (batchData, actions, ctx) => {
-      const batch0 = batchData[0];
-      const batch1 = batchData[1];
-      const ctrlVal = batch1 != null && batch1.length > 0 ? batch1.at(-1) : ctx.prevData[1];
-      if (batch0 == null || batch0.length === 0) {
-        if (batch1 != null && batch1.length > 0 && ctrlVal && ctx.prevData[0] !== void 0) {
-          actions.emit(ctx.prevData[0]);
-        } else {
-          actions.down([[RESOLVED]]);
-        }
-        return;
-      }
-      if (!ctrlVal) {
-        actions.down([[RESOLVED]]);
-        return;
-      }
-      for (const v of batch0) actions.emit(v);
-    },
-    {
-      ...opts,
-      name,
-      describeKind: "derived",
-      meta: baseMeta("valve", opts?.meta)
-    }
-  );
-  registerStep(
-    graph,
-    name,
-    step,
-    [src.path, ctrl.path].filter((v) => typeof v === "string")
-  );
-  return step;
-}
-function approval(graph, name, source, approver, opts) {
-  const src = resolveDep(graph, source);
-  const ctrl = resolveDep(graph, approver);
-  const isApproved = opts?.isApproved ?? ((value) => Boolean(value));
-  const step = node(
-    [src.node, ctrl.node],
-    (batchData, actions, ctx) => {
-      const batch0 = batchData[0];
-      const batch1 = batchData[1];
-      const ctrlVal = batch1 != null && batch1.length > 0 ? batch1.at(-1) : ctx.prevData[1];
-      if (ctrlVal === void 0 || !isApproved(ctrlVal)) {
-        actions.down([[RESOLVED]]);
-        return;
-      }
-      if (batch0 == null || batch0.length === 0) {
-        if (batch1 != null && batch1.length > 0 && ctx.prevData[0] !== void 0) {
-          actions.emit(ctx.prevData[0]);
-        } else {
-          actions.down([[RESOLVED]]);
-        }
-        return;
-      }
-      for (const v of batch0) actions.emit(v);
-    },
-    {
-      ...opts,
-      name,
-      describeKind: "derived",
-      meta: baseMeta("approval", opts?.meta)
-    }
-  );
-  registerStep(
-    graph,
-    name,
-    step,
-    [src.path, ctrl.path].filter((v) => typeof v === "string")
-  );
-  return step;
-}
-function gate(graph, name, source, opts) {
-  const maxPending = opts?.maxPending ?? Infinity;
-  if (maxPending < 1 && maxPending !== Infinity) {
-    throw new RangeError("gate: maxPending must be >= 1");
-  }
-  const startOpen = opts?.startOpen ?? false;
-  const src = resolveDep(graph, source);
-  const pendingNode = state([], { name: "pending", equals: () => false });
-  const isOpenNode = state(startOpen, { name: "isOpen" });
-  const countNode = derived([pendingNode], ([arr]) => arr.length, {
-    name: "count"
-  });
-  let queue = [];
-  let torn = false;
-  let latestIsOpen = startOpen;
-  const isOpenUnsub = isOpenNode.subscribe((msgs) => {
-    for (const m of msgs) {
-      if (m[0] === DATA) latestIsOpen = m[1];
-    }
-  });
-  function syncPending() {
-    pendingNode.down([[DATA, [...queue]]]);
-  }
-  function enqueue(value) {
-    queue.push(value);
-    if (queue.length > maxPending) queue.shift();
-    syncPending();
-  }
-  function dequeue(n) {
-    const items = queue.splice(0, n);
-    syncPending();
-    return items;
-  }
-  function guardTorn(method) {
-    if (torn) throw new Error(`gate: ${method}() called after gate was torn down`);
-  }
-  const output = node(
-    [src.node],
-    (batchData, actions, ctx) => {
-      const terminal = ctx.terminalDeps[0];
-      if (terminal !== void 0) {
-        torn = true;
-        queue = [];
-        syncPending();
-        actions.down(terminal === true ? [[COMPLETE]] : [[ERROR, terminal]]);
-        return;
-      }
-      const batch0 = batchData[0];
-      if (batch0 == null || batch0.length === 0) {
-        actions.down([[RESOLVED]]);
-        return;
-      }
-      for (const v of batch0) {
-        if (latestIsOpen) {
-          actions.emit(v);
-        } else {
-          enqueue(v);
-          actions.down([[RESOLVED]]);
-        }
-      }
-    },
-    {
-      name,
-      describeKind: "derived",
-      meta: baseMeta("gate", opts?.meta)
-    }
-  );
-  const controller = {
-    node: output,
-    pending: pendingNode,
-    count: countNode,
-    isOpen: isOpenNode,
-    approve(count = 1) {
-      guardTorn("approve");
-      const items = dequeue(count);
-      for (const item of items) {
-        if (torn) break;
-        output.down([[DATA, item]]);
-      }
-    },
-    reject(count = 1) {
-      guardTorn("reject");
-      dequeue(count);
-    },
-    modify(fn, count = 1) {
-      guardTorn("modify");
-      const snapshot = [...queue];
-      const items = dequeue(count);
-      for (let i = 0; i < items.length; i++) {
-        if (torn) break;
-        output.down([[DATA, fn(items[i], i, snapshot)]]);
-      }
-    },
-    open() {
-      guardTorn("open");
-      batch(() => {
-        isOpenNode.down([[DATA, true]]);
-        const items = dequeue(queue.length);
-        for (const item of items) {
-          if (torn) break;
-          output.down([[DATA, item]]);
-        }
-      });
-    },
-    close() {
-      guardTorn("close");
-      isOpenNode.down([[DATA, false]]);
-    }
-  };
-  graph.addDisposer(countNode.subscribe(() => void 0));
-  graph.addDisposer(isOpenUnsub);
-  registerStep(graph, name, output, src.path ? [src.path] : []);
-  const internal = new Graph(`${name}_state`);
-  internal.add("pending", pendingNode);
-  internal.add("isOpen", isOpenNode);
-  internal.add("count", countNode);
-  graph.mount(`${name}_state`, internal);
-  return controller;
-}
-function forEach(graph, name, source, run, opts) {
-  const src = resolveDep(graph, source);
-  let terminated = false;
-  const step = node(
-    [src.node],
-    (batchData, actions, ctx) => {
-      if (terminated) {
-        actions.down([[RESOLVED]]);
-        return;
-      }
-      const terminal = ctx.terminalDeps[0];
-      if (terminal !== void 0) {
-        terminated = true;
-        actions.down(terminal === true ? [[COMPLETE]] : [[ERROR, terminal]]);
-        return;
-      }
-      const batch0 = batchData[0];
-      if (batch0 == null || batch0.length === 0) {
-        actions.down([[RESOLVED]]);
-        return;
-      }
-      for (const v of batch0) {
-        try {
-          run(v, actions);
-        } catch (err) {
-          terminated = true;
-          actions.down([[ERROR, err]]);
-          return;
-        }
-      }
-    },
-    {
-      ...opts,
-      name,
-      describeKind: "effect",
-      completeWhenDepsComplete: false,
-      meta: baseMeta("forEach", opts?.meta)
-    }
-  );
-  registerStep(graph, name, step, src.path ? [src.path] : []);
-  return step;
-}
-function join(graph, name, deps, opts) {
-  const resolved = deps.map((dep) => resolveDep(graph, dep));
-  const step = derived(
-    resolved.map((d) => d.node),
-    (values) => values,
-    {
-      ...opts,
-      name,
-      meta: baseMeta("join", opts?.meta)
-    }
-  );
-  registerStep(
-    graph,
-    name,
-    step,
-    resolved.flatMap((d) => d.path ? [d.path] : [])
-  );
-  return step;
-}
-function loop(graph, name, source, iterate, opts) {
-  const src = resolveDep(graph, source);
-  const iterRef = opts?.iterations;
-  const iterDep = typeof iterRef === "number" || iterRef === void 0 ? void 0 : resolveDep(graph, iterRef);
-  const staticIterations = typeof iterRef === "number" ? iterRef : void 0;
-  const step = node(
-    iterDep ? [src.node, iterDep.node] : [src.node],
-    (depValues, actions, ctx) => {
-      const batch0 = depValues[0];
-      let current = batch0 != null && batch0.length > 0 ? batch0.at(-1) : ctx.prevData[0];
-      const batch1 = iterDep ? depValues[1] : void 0;
-      const rawCount = staticIterations ?? (iterDep ? batch1 != null && batch1.length > 0 ? batch1.at(-1) : ctx.prevData[1] : 1);
-      const count = coerceLoopIterations(rawCount);
-      for (let i = 0; i < count; i += 1) {
-        current = iterate(current, i, actions);
-      }
-      actions.emit(current);
-    },
-    {
-      ...opts,
-      name,
-      describeKind: "derived",
-      meta: baseMeta("loop", opts?.meta)
-    }
-  );
-  registerStep(
-    graph,
-    name,
-    step,
-    [src.path, iterDep?.path].filter((v) => typeof v === "string")
-  );
-  return step;
-}
-function subPipeline(graph, name, childOrBuild, opts) {
-  const child = childOrBuild instanceof Graph ? childOrBuild : pipeline(name, opts);
-  if (typeof childOrBuild === "function") {
-    childOrBuild(child);
-  }
-  graph.mount(name, child);
-  return child;
-}
-function sensor(graph, name, initial, opts) {
-  const source = node([], () => void 0, {
-    ...opts,
-    name,
-    initial,
-    describeKind: "producer",
-    meta: baseMeta("sensor", opts?.meta)
-  });
-  registerStep(graph, name, source, []);
-  return {
-    node: source,
-    push(value) {
-      source.down([[DATA, value]]);
-    },
-    error(err) {
-      source.down([[ERROR, err]]);
-    },
-    complete() {
-      source.down([[COMPLETE]]);
-    }
-  };
-}
-function wait(graph, name, source, ms, opts) {
-  const src = resolveDep(graph, source);
-  const timers = /* @__PURE__ */ new Set();
-  let terminated = false;
-  let completed = false;
-  function clearAllTimers() {
-    for (const id of timers) clearTimeout(id);
-    timers.clear();
-  }
-  const srcVal = src.node.cache;
-  const initialOpt = srcVal !== void 0 ? { initial: srcVal } : {};
-  const step = node(
-    [],
-    (_deps, actions) => {
-      clearAllTimers();
-      terminated = false;
-      completed = false;
-      const unsub = src.node.subscribe((msgs) => {
-        for (const msg of msgs) {
-          if (terminated) return;
-          if (msg[0] === DATA) {
-            const id = setTimeout(() => {
-              timers.delete(id);
-              actions.down([msg]);
-              if (completed && timers.size === 0) {
-                actions.down([[COMPLETE]]);
-              }
-            }, ms);
-            timers.add(id);
-          } else if (msg[0] === COMPLETE) {
-            terminated = true;
-            completed = true;
-            if (timers.size === 0) {
-              actions.down([[COMPLETE]]);
-            }
-          } else if (msg[0] === ERROR) {
-            terminated = true;
-            clearAllTimers();
-            actions.down([msg]);
-          } else {
-            actions.down([msg]);
-          }
-        }
-      });
-      return () => {
-        unsub();
-        clearAllTimers();
-        terminated = true;
-      };
-    },
-    {
-      ...opts,
-      name,
-      ...initialOpt,
-      describeKind: "derived",
-      completeWhenDepsComplete: false,
-      meta: baseMeta("wait", opts?.meta)
-    }
-  );
-  graph.add(name, step);
-  return step;
-}
-function onFailure(graph, name, source, recover, opts) {
-  const src = resolveDep(graph, source);
-  let terminated = false;
-  const step = node(
-    [],
-    (_data, actions) => {
-      const unsub = src.node.subscribe((msgs) => {
-        for (const msg of msgs) {
-          if (terminated) return;
-          if (msg[0] === ERROR) {
-            try {
-              actions.emit(recover(msg[1], actions));
-            } catch (err) {
-              terminated = true;
-              actions.down([[ERROR, err]]);
-            }
-          } else {
-            actions.down([msg]);
-            if (msg[0] === COMPLETE) terminated = true;
-          }
-        }
-      });
-      return () => unsub();
-    },
-    {
-      ...opts,
-      name,
-      describeKind: "derived",
-      completeWhenDepsComplete: false,
-      // onFailure handles errors via manual subscription (recover callback).
-      // Disable auto-propagation so dep-channel ERROR doesn't terminate this
-      // node before the recover callback has a chance to emit a replacement value.
-      errorWhenDepsError: false,
-      meta: baseMeta("onFailure", opts?.meta)
-    }
-  );
-  registerStep(graph, name, step, src.path ? [src.path] : []);
-  return step;
-}
-
-// src/patterns/ai.ts
-function aiMeta(kind, extra) {
-  return domainMeta("ai", kind, extra);
-}
-function isPromiseLike(x) {
-  return x != null && typeof x.then === "function";
-}
-function isNodeLike(x) {
-  return typeof x === "object" && x !== null && "subscribe" in x && typeof x.subscribe === "function" && "cache" in x;
-}
-function isAsyncIterableLike(x) {
-  return x != null && typeof x === "object" && Symbol.asyncIterator in x && typeof x[Symbol.asyncIterator] === "function";
-}
-var DEFAULT_TIMEOUT_MS = 3e4;
-function firstDataFromNode(resolved, opts) {
-  if (resolved.status === "settled") {
-    const immediate = resolved.cache;
-    if (immediate !== void 0) {
-      return Promise.resolve(immediate);
-    }
-  }
-  const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  return new Promise((resolve, reject) => {
-    const timer = new ResettableTimer();
-    const unsub = resolved.subscribe((messages) => {
-      for (const msg of messages) {
-        if (msg[0] === DATA) {
-          timer.cancel();
-          unsub();
-          resolve(msg[1]);
-          return;
-        }
-        if (msg[0] === ERROR) {
-          timer.cancel();
-          unsub();
-          reject(msg[1]);
-          return;
-        }
-        if (msg[0] === COMPLETE) {
-          timer.cancel();
-          unsub();
-          reject(new Error("firstDataFromNode: completed without producing a value"));
-          return;
-        }
-      }
-    });
-    timer.start(timeoutMs, () => {
-      unsub();
-      reject(new Error(`firstDataFromNode: timed out after ${timeoutMs}ms`));
-    });
-  });
-}
-async function resolveToolHandlerResult(value) {
-  if (isPromiseLike(value)) {
-    return resolveToolHandlerResult(await value);
-  }
-  if (isNodeLike(value)) {
-    return firstDataFromNode(value);
-  }
-  if (isAsyncIterableLike(value)) {
-    return firstDataFromNode(fromAny(value));
-  }
-  return value;
-}
-function fromLLM(adapter, messages, opts) {
-  const msgsNode = fromAny(messages);
-  const result = switchMap(msgsNode, (msgs) => {
-    if (!msgs || msgs.length === 0) {
-      return state(null);
-    }
-    const tools = opts?.tools;
-    return adapter.invoke(msgs, {
-      model: opts?.model,
-      temperature: opts?.temperature,
-      maxTokens: opts?.maxTokens,
-      tools,
-      systemPrompt: opts?.systemPrompt
-    });
-  });
-  return result;
-}
-function streamingPromptNode(adapter, deps, prompt, opts) {
-  const sourceName = opts?.name ?? "llm";
-  const format = opts?.format ?? "text";
-  const streamTopic = topic(`${sourceName}/stream`);
-  const messagesNode = derived(deps, (values) => {
-    if (values.some((v) => v == null)) return [];
-    const text = typeof prompt === "string" ? prompt : prompt(...values);
-    if (!text) return [];
-    const msgs = [];
-    if (opts?.systemPrompt) msgs.push({ role: "system", content: opts.systemPrompt });
-    msgs.push({ role: "user", content: text });
-    return msgs;
-  });
-  const output = switchMap(messagesNode, (msgs) => {
-    const chatMsgs = msgs;
-    if (!chatMsgs || chatMsgs.length === 0) {
-      return state(null);
-    }
-    const ac = new AbortController();
-    async function* pumpAndCollect() {
-      let accumulated = "";
-      let index = 0;
-      try {
-        for await (const token of adapter.stream(chatMsgs, {
-          model: opts?.model,
-          temperature: opts?.temperature,
-          maxTokens: opts?.maxTokens,
-          systemPrompt: opts?.systemPrompt,
-          signal: ac.signal
-        })) {
-          accumulated += token;
-          streamTopic.publish({
-            source: sourceName,
-            token,
-            accumulated,
-            index: index++
-          });
-        }
-        let result;
-        if (format === "json") {
-          try {
-            result = JSON.parse(stripFences(accumulated));
-          } catch {
-            result = null;
-          }
-        } else {
-          result = accumulated;
-        }
-        yield result;
-      } finally {
-        ac.abort();
-      }
-    }
-    return fromAny(pumpAndCollect());
-  });
-  const unsub = keepalive(output);
-  return {
-    output,
-    stream: streamTopic,
-    dispose: () => {
-      unsub();
-      streamTopic.destroy();
-    }
-  };
-}
-function streamExtractor(streamTopic, extractFn, opts) {
-  return derived(
-    [streamTopic.latest],
-    ([chunk]) => {
-      if (chunk == null) return null;
-      return extractFn(chunk.accumulated);
-    },
-    {
-      name: opts?.name ?? "extractor",
-      describeKind: "derived",
-      initial: null,
-      meta: aiMeta("stream_extractor"),
-      ...opts?.equals ? { equals: opts.equals } : {}
-    }
-  );
-}
-var keywordFlagsEqual = (a, b) => {
-  if (a === b) return true;
-  if (a == null || b == null) return a === b;
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) {
-    const x = a[i];
-    const y = b[i];
-    if (x.label !== y.label || x.pattern !== y.pattern || x.match !== y.match || x.position !== y.position) {
-      return false;
-    }
-  }
-  return true;
-};
-function keywordFlagExtractor(streamTopic, opts) {
-  const maxPatternLength = opts.maxPatternLength ?? 128;
-  return derived(
-    [streamTopic.latest],
-    ([chunk], ctx) => {
-      if (chunk == null) return [];
-      const accumulated = chunk.accumulated;
-      if (!("flags" in ctx.store)) {
-        ctx.store.flags = [];
-        ctx.store.scannedTo = 0;
-      }
-      const flags = ctx.store.flags;
-      const scannedTo = ctx.store.scannedTo;
-      const startOffset = Math.max(0, scannedTo - maxPatternLength);
-      const region = accumulated.slice(startOffset);
-      let added = false;
-      for (const { pattern, label } of opts.patterns) {
-        const re = new RegExp(pattern.source, `${pattern.flags.replace("g", "")}g`);
-        for (const m of region.matchAll(re)) {
-          const pos = startOffset + m.index;
-          if (pos + m[0].length <= scannedTo) continue;
-          flags.push({ label, pattern, match: m[0], position: pos });
-          added = true;
-        }
-      }
-      ctx.store.scannedTo = accumulated.length;
-      return added ? [...flags] : flags.slice();
-    },
-    {
-      name: opts.name ?? "keyword-flag-extractor",
-      describeKind: "derived",
-      initial: [],
-      meta: aiMeta("keyword_flag_extractor"),
-      equals: keywordFlagsEqual
-    }
-  );
-}
-var toolCallsEqual = (a, b) => {
-  if (a === b) return true;
-  if (a == null || b == null) return a === b;
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) {
-    const x = a[i];
-    const y = b[i];
-    if (x.startIndex !== y.startIndex || x.name !== y.name || x.raw !== y.raw) {
-      return false;
-    }
-  }
-  return true;
-};
-function toolCallExtractor(streamTopic, opts) {
-  return derived(
-    [streamTopic.latest],
-    ([chunk], ctx) => {
-      if (chunk == null) return [];
-      const accumulated = chunk.accumulated;
-      if (!("calls" in ctx.store)) {
-        ctx.store.calls = [];
-        ctx.store.scanFrom = 0;
-      }
-      const calls = ctx.store.calls;
-      let i = ctx.store.scanFrom;
-      let added = false;
-      while (i < accumulated.length) {
-        const start = accumulated.indexOf("{", i);
-        if (start === -1) {
-          ctx.store.scanFrom = accumulated.length;
-          break;
-        }
-        let depth = 0;
-        let end = -1;
-        let inString = false;
-        for (let j = start; j < accumulated.length; j++) {
-          const ch = accumulated[j];
-          if (inString) {
-            if (ch === "\\" && j + 1 < accumulated.length) {
-              j++;
-            } else if (ch === '"') {
-              inString = false;
-            }
-          } else if (ch === '"') {
-            inString = true;
-          } else if (ch === "{") {
-            depth++;
-          } else if (ch === "}") {
-            depth--;
-            if (depth === 0) {
-              end = j;
-              break;
-            }
-          }
-        }
-        if (end === -1) {
-          ctx.store.scanFrom = start;
-          break;
-        }
-        const raw = accumulated.slice(start, end + 1);
-        try {
-          const parsed = JSON.parse(raw);
-          if (typeof parsed.name === "string" && parsed.arguments != null && typeof parsed.arguments === "object") {
-            calls.push({
-              name: parsed.name,
-              arguments: parsed.arguments,
-              raw,
-              startIndex: start
-            });
-            added = true;
-          }
-        } catch {
-        }
-        i = end + 1;
-        ctx.store.scanFrom = i;
-      }
-      return added ? [...calls] : calls.slice();
-    },
-    {
-      name: opts?.name ?? "tool-call-extractor",
-      describeKind: "derived",
-      initial: [],
-      meta: aiMeta("tool_call_extractor"),
-      equals: toolCallsEqual
-    }
-  );
-}
-var costMeterEqual = (a, b) => {
-  if (a === b) return true;
-  return a.chunkCount === b.chunkCount && a.charCount === b.charCount && a.estimatedTokens === b.estimatedTokens;
-};
-function costMeterExtractor(streamTopic, opts) {
-  const charsPerToken = opts?.charsPerToken ?? 4;
-  return derived(
-    [streamTopic.latest],
-    ([chunk]) => {
-      if (chunk == null) return { chunkCount: 0, charCount: 0, estimatedTokens: 0 };
-      const c = chunk;
-      const charCount = c.accumulated.length;
-      return {
-        chunkCount: c.index + 1,
-        charCount,
-        estimatedTokens: Math.ceil(charCount / charsPerToken)
-      };
-    },
-    {
-      name: opts?.name ?? "cost-meter",
-      describeKind: "derived",
-      initial: { chunkCount: 0, charCount: 0, estimatedTokens: 0 },
-      meta: aiMeta("cost_meter_extractor"),
-      equals: costMeterEqual
-    }
-  );
-}
-function redactor(streamTopic, patterns, replaceFn, opts) {
-  const replace = replaceFn ?? (() => "[REDACTED]");
-  function sanitize(text) {
-    let result = text;
-    for (const pat of patterns) {
-      const global = pat.global ? pat : new RegExp(pat.source, `${pat.flags}g`);
-      result = result.replace(global, (m) => replace(m, pat));
-    }
-    return result;
-  }
-  return derived(
-    [streamTopic.latest],
-    ([chunk]) => {
-      if (chunk == null) {
-        return { source: "", token: "", accumulated: "", index: -1 };
-      }
-      const c = chunk;
-      const sanitizedAccumulated = sanitize(c.accumulated);
-      const sanitizedToken = sanitize(c.token);
-      return {
-        source: c.source,
-        token: sanitizedToken,
-        accumulated: sanitizedAccumulated,
-        index: c.index
-      };
-    },
-    { name: opts?.name ?? "redactor" }
-  );
-}
-function contentGate(streamTopic, classifier, threshold, opts) {
-  const hardThreshold = threshold * (opts?.hardMultiplier ?? 1.5);
-  const isNodeClassifier = typeof classifier !== "function";
-  const deps = [streamTopic.latest];
-  if (isNodeClassifier) deps.push(classifier);
-  return derived(
-    deps,
-    (values) => {
-      const chunk = values[0];
-      if (chunk == null) return "allow";
-      const score = isNodeClassifier ? values[1] ?? 0 : classifier(chunk.accumulated);
-      if (score >= hardThreshold) return "block";
-      if (score >= threshold) return "review";
-      return "allow";
-    },
-    { name: opts?.name ?? "content-gate", initial: "allow" }
-  );
-}
-function gatedStream(graph, name, adapter, deps, prompt, opts) {
-  const cancelSignal = state(0, { name: `${name}/cancel` });
-  let cancelCounter = 0;
-  const allDeps = [...deps, cancelSignal];
-  const sourceName = opts?.name ?? name;
-  const format = opts?.format ?? "text";
-  const streamTopic = topic(`${sourceName}/stream`);
-  const messagesNode = derived(allDeps, (values) => {
-    const depValues = values.slice(0, -1);
-    if (depValues.some((v) => v == null)) return [];
-    const text = typeof prompt === "string" ? prompt : prompt(...depValues);
-    if (!text) return [];
-    const msgs = [];
-    if (opts?.systemPrompt) msgs.push({ role: "system", content: opts.systemPrompt });
-    msgs.push({ role: "user", content: text });
-    return msgs;
-  });
-  const output = switchMap(messagesNode, (msgs) => {
-    const chatMsgs = msgs;
-    if (!chatMsgs || chatMsgs.length === 0) {
-      return state(null);
-    }
-    const ac = new AbortController();
-    async function* pumpAndCollect() {
-      let accumulated = "";
-      let index = 0;
-      try {
-        for await (const token of adapter.stream(chatMsgs, {
-          model: opts?.model,
-          temperature: opts?.temperature,
-          maxTokens: opts?.maxTokens,
-          systemPrompt: opts?.systemPrompt,
-          signal: ac.signal
-        })) {
-          accumulated += token;
-          streamTopic.publish({
-            source: sourceName,
-            token,
-            accumulated,
-            index: index++
-          });
-        }
-        let result;
-        if (format === "json") {
-          try {
-            result = JSON.parse(stripFences(accumulated));
-          } catch {
-            result = null;
-          }
-        } else {
-          result = accumulated;
-        }
-        yield result;
-      } finally {
-        ac.abort();
-      }
-    }
-    return fromAny(pumpAndCollect());
-  });
-  const unsub = keepalive(output);
-  const nonNullOutput = derived(
-    [output],
-    ([v]) => {
-      if (v == null) return void 0;
-      return v;
-    },
-    {
-      name: `${name}/filter`
-    }
-  );
-  graph.add(`${name}/raw`, nonNullOutput);
-  const gateCtrl = gate(graph, `${name}/gate`, `${name}/raw`, opts?.gate);
-  const originalReject = gateCtrl.reject.bind(gateCtrl);
-  const gateWithAbort = {
-    ...gateCtrl,
-    reject(count = 1) {
-      originalReject(count);
-      cancelSignal.down([[DATA, ++cancelCounter]]);
-    }
-  };
-  return {
-    output: gateCtrl.node,
-    stream: streamTopic,
-    gate: gateWithAbort,
-    dispose: () => {
-      unsub();
-      streamTopic.destroy();
-    }
-  };
-}
-function extractContent(resp) {
-  if (resp != null && typeof resp === "object" && "content" in resp) {
-    return String(resp.content);
-  }
-  if (typeof resp === "string") return resp;
-  return String(resp);
-}
-function promptNode(adapter, deps, prompt, opts) {
-  const format = opts?.format ?? "text";
-  const retries = opts?.retries ?? 0;
-  const useCache = opts?.cache ?? false;
-  const cache = useCache ? /* @__PURE__ */ new Map() : null;
-  const messagesNode = derived(
-    deps,
-    (values) => {
-      if (values.some((v) => v == null)) return [];
-      const text = typeof prompt === "string" ? prompt : prompt(...values);
-      if (!text) return [];
-      const msgs = [];
-      if (opts?.systemPrompt) msgs.push({ role: "system", content: opts.systemPrompt });
-      msgs.push({ role: "user", content: text });
-      return msgs;
-    },
-    {
-      name: opts?.name ? `${opts.name}::messages` : "prompt_node::messages",
-      meta: aiMeta("prompt_node"),
-      initial: []
-    }
-  );
-  const result = switchMap(messagesNode, (msgs) => {
-    if (!msgs || msgs.length === 0) {
-      return state(null);
-    }
-    const cacheKey = useCache ? JSON.stringify(msgs.map((m) => [m.role, m.content])) : "";
-    if (cache?.has(cacheKey)) {
-      return state(cache.get(cacheKey));
-    }
-    async function attempt(remaining) {
-      try {
-        const resp = await new Promise((resolve, reject) => {
-          const input = adapter.invoke(msgs, {
-            model: opts?.model,
-            temperature: opts?.temperature,
-            maxTokens: opts?.maxTokens,
-            systemPrompt: opts?.systemPrompt
-          });
-          if (input && typeof input.then === "function") {
-            input.then(resolve, reject);
-          } else if (input && typeof input.subscribe === "function") {
-            resolve(input.cache);
-          } else {
-            resolve(input);
-          }
-        });
-        const content = extractContent(resp);
-        let parsed;
-        if (format === "json") {
-          parsed = JSON.parse(stripFences(content));
-        } else {
-          parsed = content;
-        }
-        cache?.set(cacheKey, parsed);
-        return parsed;
-      } catch (err) {
-        if (remaining > 0) return attempt(remaining - 1);
-        throw err;
-      }
-    }
-    return attempt(retries);
-  });
-  return result;
-}
-var ChatStreamGraph = class extends Graph {
-  _log;
-  messages;
-  latest;
-  messageCount;
-  constructor(name, opts = {}) {
-    super(name, opts.graph);
-    this._log = reactiveLog([], {
-      name: "messages",
-      maxSize: opts.maxMessages
-    });
-    this.messages = this._log.entries;
-    this.add("messages", this.messages);
-    this.latest = derived(
-      [this.messages],
-      ([snapshot]) => {
-        const entries = snapshot;
-        return entries.length === 0 ? null : entries[entries.length - 1];
-      },
-      {
-        name: "latest",
-        describeKind: "derived",
-        meta: aiMeta("chat_latest")
-      }
-    );
-    this.add("latest", this.latest);
-    this.addDisposer(keepalive(this.latest));
-    this.messageCount = derived(
-      [this.messages],
-      ([snapshot]) => snapshot.length,
-      {
-        name: "messageCount",
-        describeKind: "derived",
-        meta: aiMeta("chat_message_count"),
-        initial: 0
-      }
-    );
-    this.add("messageCount", this.messageCount);
-    this.addDisposer(keepalive(this.messageCount));
-  }
-  append(role, content, extra) {
-    this._log.append({ role, content, ...extra });
-  }
-  appendToolResult(callId, content) {
-    this._log.append({ role: "tool", content, toolCallId: callId });
-  }
-  clear() {
-    this._log.clear();
-  }
-  allMessages() {
-    return this.messages.cache;
-  }
-};
-function chatStream(name, opts) {
-  return new ChatStreamGraph(name, opts);
-}
-var ToolRegistryGraph = class extends Graph {
-  definitions;
-  schemas;
-  constructor(name, opts = {}) {
-    super(name, opts.graph);
-    this.definitions = state(/* @__PURE__ */ new Map(), {
-      name: "definitions",
-      describeKind: "state",
-      meta: aiMeta("tool_definitions")
-    });
-    this.add("definitions", this.definitions);
-    this.schemas = derived(
-      [this.definitions],
-      ([defs]) => [...(defs ?? /* @__PURE__ */ new Map()).values()],
-      {
-        name: "schemas",
-        describeKind: "derived",
-        meta: aiMeta("tool_schemas"),
-        initial: []
-      }
-    );
-    this.add("schemas", this.schemas);
-    this.addDisposer(keepalive(this.schemas));
-  }
-  register(tool) {
-    const current = this.definitions.cache;
-    const next = new Map(current);
-    next.set(tool.name, tool);
-    this.definitions.down([[DATA, next]]);
-  }
-  unregister(name) {
-    const current = this.definitions.cache;
-    if (!current.has(name)) return;
-    const next = new Map(current);
-    next.delete(name);
-    this.definitions.down([[DATA, next]]);
-  }
-  async execute(name, args) {
-    const defs = this.definitions.cache;
-    const tool = defs.get(name);
-    if (!tool) throw new Error(`toolRegistry: unknown tool "${name}"`);
-    const raw = tool.handler(args);
-    return resolveToolHandlerResult(raw);
-  }
-  getDefinition(name) {
-    return this.definitions.cache?.get(name);
-  }
-};
-function toolRegistry(name, opts) {
-  return new ToolRegistryGraph(name, opts);
-}
-function systemPromptBuilder(sections, opts) {
-  const separator = opts?.separator ?? "\n\n";
-  const sectionNodes = sections.map((s) => typeof s === "string" ? state(s) : fromAny(s));
-  const prompt = derived(
-    sectionNodes,
-    (values) => values.filter((v) => v != null && v !== "").join(separator),
-    {
-      name: opts?.name ?? "systemPrompt",
-      describeKind: "derived",
-      meta: aiMeta("system_prompt"),
-      initial: ""
-    }
-  );
-  const unsub = keepalive(prompt);
-  return Object.assign(prompt, { dispose: unsub });
-}
-function llmExtractor(systemPrompt, opts) {
-  return (raw, existing) => {
-    const existingKeys = [...existing.keys()].slice(0, 100);
-    const messages = [
-      { role: "system", content: systemPrompt },
-      {
-        role: "user",
-        content: JSON.stringify({
-          input: raw,
-          existingKeys
-        })
-      }
-    ];
-    return producer((actions) => {
-      let active = true;
-      const result = opts.adapter.invoke(messages, {
-        model: opts.model,
-        temperature: opts.temperature ?? 0,
-        maxTokens: opts.maxTokens
-      });
-      const resolved = fromAny(result);
-      const unsub = resolved.subscribe((msgs) => {
-        if (!active) return;
-        let done = false;
-        for (const msg of msgs) {
-          if (done) break;
-          if (msg[0] === DATA) {
-            const response = msg[1];
-            try {
-              const parsed = JSON.parse(response.content);
-              actions.emit(parsed);
-              actions.down([[COMPLETE]]);
-            } catch {
-              actions.down([
-                [ERROR, new Error("llmExtractor: failed to parse LLM response as JSON")]
-              ]);
-            }
-            done = true;
-          } else if (msg[0] === ERROR) {
-            actions.down([[ERROR, msg[1]]]);
-            done = true;
-          } else if (msg[0] === COMPLETE) {
-            actions.down([[COMPLETE]]);
-            done = true;
-          } else {
-            actions.down([[msg[0], msg[1]]]);
-          }
-        }
-      });
-      return () => {
-        unsub();
-        active = false;
-      };
-    });
-  };
-}
-function llmConsolidator(systemPrompt, opts) {
-  return (entries) => {
-    const entriesArray = [...entries.entries()].map(([key, value]) => ({ key, value }));
-    const messages = [
-      { role: "system", content: systemPrompt },
-      { role: "user", content: JSON.stringify({ memories: entriesArray }) }
-    ];
-    return producer((actions) => {
-      let active = true;
-      const result = opts.adapter.invoke(messages, {
-        model: opts.model,
-        temperature: opts.temperature ?? 0,
-        maxTokens: opts.maxTokens
-      });
-      const resolved = fromAny(result);
-      const unsub = resolved.subscribe((msgs) => {
-        if (!active) return;
-        let done = false;
-        for (const msg of msgs) {
-          if (done) break;
-          if (msg[0] === DATA) {
-            const response = msg[1];
-            try {
-              const parsed = JSON.parse(response.content);
-              actions.emit(parsed);
-              actions.down([[COMPLETE]]);
-            } catch {
-              actions.down([
-                [ERROR, new Error("llmConsolidator: failed to parse LLM response as JSON")]
-              ]);
-            }
-            done = true;
-          } else if (msg[0] === ERROR) {
-            actions.down([[ERROR, msg[1]]]);
-            done = true;
-          } else if (msg[0] === COMPLETE) {
-            actions.down([[COMPLETE]]);
-            done = true;
-          } else {
-            actions.down([[msg[0], msg[1]]]);
-          }
-        }
-      });
-      return () => {
-        unsub();
-        active = false;
-      };
-    });
-  };
-}
-function defaultAdmissionScorer(_raw) {
-  return { persistence: 0.5, structure: 0.5, personalValue: 0.5 };
-}
-function admissionFilter3D(opts = {}) {
-  const scoreFn = opts.scoreFn ?? defaultAdmissionScorer;
-  const pThresh = opts.persistenceThreshold ?? 0.3;
-  const pvThresh = opts.personalValueThreshold ?? 0.3;
-  const reqStructured = opts.requireStructured ?? false;
-  return (raw) => {
-    const scores = scoreFn(raw);
-    if (scores.persistence < pThresh) return false;
-    if (scores.personalValue < pvThresh) return false;
-    if (reqStructured && scores.structure <= 0) return false;
-    return true;
-  };
-}
-var DEFAULT_DECAY_RATE = Math.LN2 / (7 * 86400);
-function extractStoreMap(snapshot) {
-  if (snapshot instanceof Map) return snapshot;
-  return /* @__PURE__ */ new Map();
-}
-function agentMemory(name, source, opts) {
-  const graph = new Graph(name, opts.graph);
-  const keepaliveSubs = [];
-  let rawExtractFn;
-  if (opts.extractFn) {
-    rawExtractFn = opts.extractFn;
-  } else if (opts.adapter && opts.extractPrompt) {
-    rawExtractFn = llmExtractor(opts.extractPrompt, { adapter: opts.adapter });
-  } else {
-    throw new Error("agentMemory: provide either extractFn or adapter + extractPrompt");
-  }
-  const extractFn = (raw, existing) => {
-    if (raw == null) return { upsert: [] };
-    return rawExtractFn(raw, existing);
-  };
-  let filteredSource = source;
-  if (opts.admissionFilter) {
-    const srcNode = fromAny(source);
-    const filter = opts.admissionFilter;
-    filteredSource = derived(
-      [srcNode],
-      ([raw]) => {
-        if (filter(raw)) return raw;
-        return void 0;
-      },
-      { name: "admissionFilter", describeKind: "derived" }
-    );
-  }
-  let consolidateFn;
-  if (opts.consolidateFn) {
-    consolidateFn = opts.consolidateFn;
-  } else if (opts.adapter && opts.consolidatePrompt) {
-    consolidateFn = llmConsolidator(opts.consolidatePrompt, { adapter: opts.adapter });
-  }
-  let consolidateTrigger = opts.consolidateTrigger;
-  if (!consolidateTrigger && consolidateFn && opts.reflection?.enabled !== false) {
-    const interval = opts.reflection?.interval ?? 3e5;
-    consolidateTrigger = fromTimer(interval, { period: interval });
-  }
-  const distillOpts = {
-    score: opts.score,
-    cost: opts.cost,
-    budget: opts.budget ?? 2e3,
-    context: opts.context,
-    consolidate: consolidateFn,
-    consolidateTrigger
-  };
-  const distillBundle = distill(filteredSource, extractFn, distillOpts);
-  graph.add("store", distillBundle.store.entries);
-  graph.add("compact", distillBundle.compact);
-  graph.add("size", distillBundle.size);
-  let vectors = null;
-  if (opts.vectorDimensions && opts.vectorDimensions > 0 && opts.embedFn) {
-    vectors = vectorIndex({ dimension: opts.vectorDimensions });
-    graph.add("vectorIndex", vectors.entries);
-  }
-  let kg = null;
-  if (opts.enableKnowledgeGraph) {
-    kg = knowledgeGraph(`${name}-kg`);
-    graph.mount("kg", kg);
-  }
-  let memoryTiersBundle = null;
-  if (opts.tiers) {
-    const tiersOpts = opts.tiers;
-    const decayRate = tiersOpts.decayRate ?? DEFAULT_DECAY_RATE;
-    const maxActive = tiersOpts.maxActive ?? 1e3;
-    const archiveThreshold = tiersOpts.archiveThreshold ?? 0.1;
-    const permanentFilter = tiersOpts.permanentFilter ?? (() => false);
-    const permanent = lightCollection({ name: "permanent" });
-    graph.add("permanent", permanent.entries);
-    const permanentKeys = /* @__PURE__ */ new Set();
-    const tierOf = (key) => {
-      if (permanentKeys.has(key)) return "permanent";
-      const storeMap = extractStoreMap(distillBundle.store.entries.cache);
-      if (storeMap.has(key)) return "active";
-      return "archived";
-    };
-    const markPermanent = (key, value) => {
-      permanentKeys.add(key);
-      permanent.upsert(key, value);
-    };
-    const entryCreatedAtNs = /* @__PURE__ */ new Map();
-    const storeNode = distillBundle.store.entries;
-    const contextNode = opts.context ? fromAny(opts.context) : state(null);
-    const tierClassifier = effect([storeNode, contextNode], ([snapshot, ctx]) => {
-      const storeMap = extractStoreMap(snapshot);
-      const nowNs = monotonicNs();
-      const toArchive = [];
-      const toPermanent = [];
-      for (const [key, mem] of storeMap) {
-        if (!entryCreatedAtNs.has(key)) {
-          entryCreatedAtNs.set(key, nowNs);
-        }
-        if (permanentFilter(key, mem)) {
-          toPermanent.push({ key, value: mem });
-          continue;
-        }
-        const baseScore = opts.score(mem, ctx);
-        const createdNs = entryCreatedAtNs.get(key) ?? nowNs;
-        const ageSeconds = Number(nowNs - createdNs) / 1e9;
-        const decayed = decay(baseScore, ageSeconds, decayRate);
-        if (decayed < archiveThreshold) {
-          toArchive.push(key);
-        }
-      }
-      for (const key of entryCreatedAtNs.keys()) {
-        if (!storeMap.has(key)) entryCreatedAtNs.delete(key);
-      }
-      for (const { key, value } of toPermanent) {
-        if (!permanentKeys.has(key)) {
-          markPermanent(key, value);
-        }
-      }
-      const activeCount = storeMap.size - permanentKeys.size;
-      if (activeCount > maxActive) {
-        const scored = [...storeMap.entries()].filter(([k]) => !permanentKeys.has(k)).map(([k, m]) => ({ key: k, score: opts.score(m, ctx) })).sort((a, b) => a.score - b.score);
-        const excess = activeCount - maxActive;
-        for (let i = 0; i < excess && i < scored.length; i++) {
-          const sk = scored[i].key;
-          if (!toArchive.includes(sk)) toArchive.push(sk);
-        }
-      }
-      if (toArchive.length > 0) {
-        batch(() => {
-          for (const key of toArchive) {
-            distillBundle.store.delete(key);
-          }
-        });
-      }
-    });
-    keepaliveSubs.push(tierClassifier.subscribe(() => void 0));
-    let archiveHandle = null;
-    if (tiersOpts.archiveTier) {
-      archiveHandle = graph.attachStorage(
-        [tiersOpts.archiveTier],
-        tiersOpts.archiveStorageOptions ?? {}
-      );
-    }
-    memoryTiersBundle = {
-      permanent,
-      activeEntries: storeNode,
-      archiveHandle,
-      tierOf,
-      markPermanent
-    };
-  }
-  if (vectors || kg) {
-    const embedFn = opts.embedFn;
-    const entityFn = opts.entityFn;
-    const storeNode = distillBundle.store.entries;
-    const indexer = effect([storeNode], ([snapshot]) => {
-      const storeMap = extractStoreMap(snapshot);
-      for (const [key, mem] of storeMap) {
-        if (vectors && embedFn) {
-          const vec = embedFn(mem);
-          if (vec) vectors.upsert(key, vec, mem);
-        }
-        if (kg && entityFn) {
-          const extracted = entityFn(key, mem);
-          if (extracted) {
-            for (const ent of extracted.entities ?? []) {
-              kg.upsertEntity(ent.id, ent.value);
-            }
-            for (const rel of extracted.relations ?? []) {
-              kg.link(rel.from, rel.to, rel.relation, rel.weight);
-            }
-          }
-        }
-      }
-    });
-    keepaliveSubs.push(indexer.subscribe(() => void 0));
-  }
-  let retrievalNode = null;
-  let retrievalTraceNode = null;
-  let retrieveFn = null;
-  if (vectors || kg) {
-    const topK = opts.retrieval?.topK ?? 20;
-    const graphDepth = opts.retrieval?.graphDepth ?? 1;
-    const budget = opts.budget ?? 2e3;
-    const costFn = opts.cost;
-    const scoreFn = opts.score;
-    const contextNode = opts.context ? fromAny(opts.context) : state(null);
-    const retrievalOutput = state([], {
-      name: "retrieval",
-      describeKind: "state",
-      meta: aiMeta("retrieval_pipeline")
-    });
-    graph.add("retrieval", retrievalOutput);
-    retrievalNode = retrievalOutput;
-    const traceState = state(null, {
-      name: "retrievalTrace",
-      describeKind: "state",
-      meta: aiMeta("retrieval_trace")
-    });
-    graph.add("retrievalTrace", traceState);
-    retrievalTraceNode = traceState;
-    retrieveFn = (query) => {
-      const storeMap = extractStoreMap(distillBundle.store.entries.cache);
-      const ctx = contextNode.cache;
-      const candidateMap = /* @__PURE__ */ new Map();
-      let vectorCandidates = [];
-      if (vectors && query.vector) {
-        vectorCandidates = vectors.search(query.vector, topK);
-        for (const vc of vectorCandidates) {
-          const mem = storeMap.get(vc.id);
-          if (mem) {
-            candidateMap.set(vc.id, { value: mem, sources: /* @__PURE__ */ new Set(["vector"]) });
-          }
-        }
-      }
-      const graphExpanded = [];
-      if (kg) {
-        const seedIds = [...query.entityIds ?? [], ...[...candidateMap.keys()]];
-        const visited = /* @__PURE__ */ new Set();
-        let frontier = seedIds;
-        for (let depth = 0; depth < graphDepth; depth++) {
-          const nextFrontier = [];
-          for (const id of frontier) {
-            if (visited.has(id)) continue;
-            visited.add(id);
-            const related = kg.related(id);
-            for (const edge of related) {
-              const targetId = edge.to;
-              if (!visited.has(targetId)) {
-                nextFrontier.push(targetId);
-                const mem = storeMap.get(targetId);
-                if (mem) {
-                  const existing = candidateMap.get(targetId);
-                  if (existing) {
-                    existing.sources.add("graph");
-                  } else {
-                    candidateMap.set(targetId, { value: mem, sources: /* @__PURE__ */ new Set(["graph"]) });
-                  }
-                  graphExpanded.push(targetId);
-                }
-              }
-            }
-          }
-          frontier = nextFrontier;
-        }
-      }
-      for (const [key, mem] of storeMap) {
-        if (!candidateMap.has(key)) {
-          candidateMap.set(key, { value: mem, sources: /* @__PURE__ */ new Set(["store"]) });
-        }
-      }
-      const ranked = [];
-      for (const [key, { value, sources }] of candidateMap) {
-        const score = scoreFn(value, ctx);
-        ranked.push({ key, value, score, sources: [...sources] });
-      }
-      ranked.sort((a, b) => b.score - a.score);
-      const packed = [];
-      let usedBudget = 0;
-      for (const entry of ranked) {
-        const c = costFn(entry.value);
-        if (usedBudget + c > budget && packed.length > 0) break;
-        packed.push(entry);
-        usedBudget += c;
-      }
-      const trace = {
-        vectorCandidates,
-        graphExpanded,
-        ranked,
-        packed
-      };
-      batch(() => {
-        retrievalOutput.down([[DATA, packed]]);
-        traceState.down([[DATA, trace]]);
-      });
-      return packed;
-    };
-  }
-  graph.addDisposer(() => {
-    for (const unsub of keepaliveSubs) unsub();
-    keepaliveSubs.length = 0;
-  });
-  return Object.assign(graph, {
-    distillBundle,
-    compact: distillBundle.compact,
-    size: distillBundle.size,
-    vectors,
-    kg,
-    memoryTiers: memoryTiersBundle,
-    retrieval: retrievalNode,
-    retrievalTrace: retrievalTraceNode,
-    retrieve: retrieveFn
-  });
-}
-var AgentLoopGraph = class extends Graph {
-  chat;
-  tools;
-  status;
-  turnCount;
-  lastResponse;
-  _statusState;
-  _turnCountState;
-  _adapter;
-  _maxTurns;
-  _stopWhen;
-  _onToolCall;
-  _systemPrompt;
-  _model;
-  _temperature;
-  _maxTokens;
-  _running = false;
-  _abortController = null;
-  constructor(name, opts) {
-    super(name, opts.graph);
-    this._adapter = opts.adapter;
-    this._maxTurns = opts.maxTurns ?? 10;
-    this._stopWhen = opts.stopWhen;
-    this._onToolCall = opts.onToolCall;
-    this._systemPrompt = opts.systemPrompt;
-    this._model = opts.model;
-    this._temperature = opts.temperature;
-    this._maxTokens = opts.maxTokens;
-    this.chat = chatStream(`${name}-chat`, { maxMessages: opts.maxMessages });
-    this.mount("chat", this.chat);
-    this.tools = toolRegistry(`${name}-tools`);
-    this.mount("tools", this.tools);
-    if (opts.tools) {
-      for (const tool of opts.tools) {
-        this.tools.register(tool);
-      }
-    }
-    this._statusState = state("idle", {
-      name: "status",
-      describeKind: "state",
-      meta: aiMeta("agent_status")
-    });
-    this.status = this._statusState;
-    this.add("status", this.status);
-    this._turnCountState = state(0, {
-      name: "turnCount",
-      describeKind: "state",
-      meta: aiMeta("agent_turn_count")
-    });
-    this.turnCount = this._turnCountState;
-    this.add("turnCount", this.turnCount);
-    this.lastResponse = state(null, {
-      name: "lastResponse",
-      describeKind: "state",
-      meta: aiMeta("agent_last_response")
-    });
-    this.add("lastResponse", this.lastResponse);
-  }
-  /**
-   * Start the agent loop with a user message. The loop runs reactively:
-   * think (LLM call) → act (tool execution) → repeat until done.
-   *
-   * Messages accumulate across calls. Call `chat.clear()` before `run()`
-   * to reset conversation history.
-   */
-  async run(userMessage) {
-    if (this._running) throw new Error("agentLoop: already running");
-    this._running = true;
-    this._abortController = new AbortController();
-    const { signal } = this._abortController;
-    batch(() => {
-      this._statusState.down([[DATA, "idle"]]);
-      this._turnCountState.down([[DATA, 0]]);
-    });
-    this.chat.append("user", userMessage);
-    try {
-      let turns = 0;
-      while (turns < this._maxTurns) {
-        if (signal.aborted) throw new Error("agentLoop: aborted");
-        turns++;
-        batch(() => {
-          this._turnCountState.down([[DATA, turns]]);
-          this._statusState.down([[DATA, "thinking"]]);
-        });
-        const msgs = this.chat.allMessages();
-        const toolSchemas = this.tools.schemas.cache ?? [];
-        const response = await this._invokeLLM(msgs, toolSchemas, signal);
-        if (signal.aborted) throw new Error("agentLoop: aborted");
-        this.lastResponse.down([[DATA, response]]);
-        this.chat.append("assistant", response.content, {
-          toolCalls: response.toolCalls
-        });
-        if (this._shouldStop(response)) {
-          this._statusState.down([[DATA, "done"]]);
-          this._running = false;
-          this._abortController = null;
-          return response;
-        }
-        if (response.toolCalls && response.toolCalls.length > 0) {
-          this._statusState.down([[DATA, "acting"]]);
-          for (const call of response.toolCalls) {
-            if (signal.aborted) throw new Error("agentLoop: aborted");
-            this._onToolCall?.(call);
-            try {
-              const result = await this.tools.execute(call.name, call.arguments);
-              this.chat.appendToolResult(call.id, JSON.stringify(result));
-            } catch (err) {
-              this.chat.appendToolResult(call.id, JSON.stringify({ error: String(err) }));
-            }
-          }
-        } else {
-          this._statusState.down([[DATA, "done"]]);
-          this._running = false;
-          this._abortController = null;
-          return response;
-        }
-      }
-      this._statusState.down([[DATA, "done"]]);
-      this._running = false;
-      this._abortController = null;
-      return this.lastResponse.cache;
-    } catch (err) {
-      this._statusState.down([[DATA, "error"]]);
-      this._running = false;
-      this._abortController = null;
-      throw err;
-    }
-  }
-  async _invokeLLM(msgs, tools, signal) {
-    const result = this._adapter.invoke(msgs, {
-      tools: tools.length > 0 ? tools : void 0,
-      systemPrompt: this._systemPrompt,
-      model: this._model,
-      temperature: this._temperature,
-      maxTokens: this._maxTokens,
-      signal
-    });
-    if (result == null) {
-      throw new Error("_invokeLLM: adapter.invoke() returned null or undefined");
-    }
-    if (typeof result === "string") {
-      throw new Error("_invokeLLM: adapter.invoke() returned a string, expected LLMResponse");
-    }
-    if (typeof result === "object" && "content" in result && !("subscribe" in result) && !("then" in result)) {
-      return result;
-    }
-    if (isPromiseLike(result)) {
-      const awaited = await result;
-      if (typeof awaited === "object" && awaited !== null && "content" in awaited && !("subscribe" in awaited)) {
-        return awaited;
-      }
-      return firstDataFromNode(fromAny(awaited));
-    }
-    return firstDataFromNode(fromAny(result));
-  }
-  _shouldStop(response) {
-    if (response.finishReason === "end_turn" && (!response.toolCalls || response.toolCalls.length === 0))
-      return true;
-    if (this._stopWhen?.(response)) return true;
-    return false;
-  }
-  destroy() {
-    if (this._abortController) {
-      this._abortController.abort();
-      this._abortController = null;
-    }
-    this._running = false;
-    super.destroy();
-  }
-};
-function agentLoop(name, opts) {
-  return new AgentLoopGraph(name, opts);
-}
-function metaToJsonSchema(meta) {
-  const schema = {};
-  const metaType = meta.type;
-  if (metaType === "enum" && Array.isArray(meta.values)) {
-    schema.type = "string";
-    schema.enum = meta.values;
-  } else if (metaType === "integer") {
-    schema.type = "integer";
-  } else if (metaType === "number") {
-    schema.type = "number";
-  } else if (metaType === "boolean") {
-    schema.type = "boolean";
-  } else if (metaType === "string") {
-    schema.type = "string";
-  } else {
-    schema.type = ["string", "number", "boolean"];
-  }
-  if (Array.isArray(meta.range) && meta.range.length === 2) {
-    schema.minimum = meta.range[0];
-    schema.maximum = meta.range[1];
-  }
-  if (typeof meta.format === "string") {
-    schema.description = `Format: ${meta.format}`;
-  }
-  if (typeof meta.unit === "string") {
-    if (schema.description) {
-      schema.description += ` (${meta.unit})`;
-    } else {
-      schema.description = `Unit: ${meta.unit}`;
-    }
-  }
-  return schema;
-}
-function knobsAsTools(graph, actor) {
-  const described = graph.describe({ actor, detail: "full" });
-  const openai = [];
-  const mcp = [];
-  const definitions = [];
-  for (const [path, node2] of Object.entries(described.nodes)) {
-    if (node2.type !== "state") continue;
-    if (path.includes("::__meta__::")) continue;
-    if (node2.status === "completed" || node2.status === "errored") continue;
-    const meta = node2.meta ?? {};
-    const access = meta.access;
-    if (access === "human" || access === "system") continue;
-    const description = meta.description ?? `Set the value of ${path}`;
-    const valueSchema = metaToJsonSchema(meta);
-    const parameterSchema = {
-      type: "object",
-      required: ["value"],
-      properties: {
-        value: valueSchema
-      },
-      additionalProperties: false
-    };
-    const sanitizedName = path.replace(/::/g, "__");
-    openai.push({
-      type: "function",
-      function: {
-        name: sanitizedName,
-        description,
-        parameters: parameterSchema
-      }
-    });
-    mcp.push({
-      name: path,
-      description,
-      inputSchema: parameterSchema
-    });
-    const graphRef = graph;
-    const actorRef = actor;
-    const nv = node2.v;
-    definitions.push({
-      name: path,
-      description,
-      parameters: parameterSchema,
-      handler(args) {
-        graphRef.set(path, args.value, actorRef ? { actor: actorRef } : void 0);
-        return args.value;
-      },
-      ...nv != null ? { version: { id: nv.id, version: nv.version } } : {}
-    });
-  }
-  return { openai, mcp, definitions };
-}
-function gaugesAsContext(graph, actor, options) {
-  const described = graph.describe({ actor, detail: "full" });
-  const groupByTags = options?.groupByTags ?? true;
-  const separator = options?.separator ?? "\n";
-  const entries = [];
-  const sinceVersion = options?.sinceVersion;
-  for (const [path, node2] of Object.entries(described.nodes)) {
-    const meta = node2.meta ?? {};
-    const desc = meta.description;
-    const format = meta.format;
-    if (!desc && !format) continue;
-    if (sinceVersion != null && node2.v != null) {
-      const lastSeen = sinceVersion.get(path);
-      if (lastSeen != null && lastSeen.id === node2.v.id && node2.v.version <= lastSeen.version)
-        continue;
-    }
-    const label = desc ?? path;
-    const value = node2.value;
-    const unit = meta.unit;
-    let formatted;
-    if (format === "currency" && typeof value === "number") {
-      formatted = `$${value.toFixed(2)}`;
-    } else if (format === "percentage" && typeof value === "number") {
-      formatted = `${(value * 100).toFixed(1)}%`;
-    } else if (value === void 0 || value === null) {
-      formatted = "(no value)";
-    } else {
-      formatted = String(value);
-    }
-    if (unit && format !== "currency" && format !== "percentage") {
-      formatted = `${formatted} ${unit}`;
-    }
-    entries.push({ path, description: label, formatted });
-  }
-  if (entries.length === 0) return "";
-  if (groupByTags) {
-    const tagGroups = /* @__PURE__ */ new Map();
-    const ungrouped = [];
-    for (const entry of entries) {
-      const node2 = described.nodes[entry.path];
-      const tags = node2.meta?.tags;
-      if (tags && tags.length > 0) {
-        const tag = tags[0];
-        let group = tagGroups.get(tag);
-        if (!group) {
-          group = [];
-          tagGroups.set(tag, group);
-        }
-        group.push(entry);
-      } else {
-        ungrouped.push(entry);
-      }
-    }
-    if (tagGroups.size === 0) {
-      return entries.map((e) => `- ${e.description}: ${e.formatted}`).join(separator);
-    }
-    const sections = [];
-    for (const [tag, group] of [...tagGroups.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
-      sections.push(
-        `[${tag}]${separator}${group.map((e) => `- ${e.description}: ${e.formatted}`).join(separator)}`
-      );
-    }
-    if (ungrouped.length > 0) {
-      sections.push(ungrouped.map((e) => `- ${e.description}: ${e.formatted}`).join(separator));
-    }
-    return sections.join(separator + separator);
-  }
-  return entries.map((e) => `- ${e.description}: ${e.formatted}`).join(separator);
-}
-var VALID_NODE_TYPES = /* @__PURE__ */ new Set(["state", "derived", "producer", "operator", "effect"]);
-function validateGraphDef(def) {
-  const errors = [];
-  if (def == null || typeof def !== "object") {
-    return { valid: false, errors: ["Definition must be a non-null object"] };
-  }
-  const d = def;
-  if (typeof d.name !== "string" || d.name.length === 0) {
-    errors.push("Missing or empty 'name' field");
-  }
-  if (d.nodes == null || typeof d.nodes !== "object" || Array.isArray(d.nodes)) {
-    errors.push("Missing or invalid 'nodes' field (must be an object)");
-    return { valid: false, errors };
-  }
-  const nodeNames = new Set(Object.keys(d.nodes));
-  for (const [name, raw] of Object.entries(d.nodes)) {
-    if (raw == null || typeof raw !== "object") {
-      errors.push(`Node "${name}": must be an object`);
-      continue;
-    }
-    const node2 = raw;
-    if (typeof node2.type !== "string" || !VALID_NODE_TYPES.has(node2.type)) {
-      errors.push(
-        `Node "${name}": invalid type "${String(node2.type)}" (expected: ${[...VALID_NODE_TYPES].join(", ")})`
-      );
-    }
-    if (Array.isArray(node2.deps)) {
-      for (const dep of node2.deps) {
-        if (typeof dep === "string" && !nodeNames.has(dep)) {
-          errors.push(`Node "${name}": dep "${dep}" does not reference an existing node`);
-        }
-      }
-    }
-  }
-  if (!Array.isArray(d.edges)) {
-    if (d.edges !== void 0) {
-      errors.push("'edges' must be an array");
-    }
-  } else {
-    const seen = /* @__PURE__ */ new Set();
-    for (let i = 0; i < d.edges.length; i++) {
-      const edge = d.edges[i];
-      if (edge == null || typeof edge !== "object") {
-        errors.push(`Edge [${i}]: must be an object`);
-        continue;
-      }
-      const e = edge;
-      if (typeof e.from !== "string" || !nodeNames.has(e.from)) {
-        errors.push(`Edge [${i}]: 'from' "${String(e.from)}" does not reference an existing node`);
-      }
-      if (typeof e.to !== "string" || !nodeNames.has(e.to)) {
-        errors.push(`Edge [${i}]: 'to' "${String(e.to)}" does not reference an existing node`);
-      }
-      const key = `${e.from}->${e.to}`;
-      if (seen.has(key)) {
-        errors.push(`Edge [${i}]: duplicate edge ${key}`);
-      }
-      seen.add(key);
-    }
-  }
-  return { valid: errors.length === 0, errors };
-}
-function stripFences(text) {
-  const match = text.match(/^```(?:json)?\s*([\s\S]*?)\s*```[\s\S]*$/);
-  return match ? match[1] : text;
-}
-var GRAPH_FROM_SPEC_SYSTEM_PROMPT = `You are a graph architect for GraphReFly, a reactive graph protocol.
-
-Given a natural-language description, produce a JSON graph definition with this structure:
-
-{
-  "name": "<graph_name>",
-  "nodes": {
-    "<node_name>": {
-      "type": "state" | "derived" | "producer" | "operator" | "effect",
-      "value": <initial_value_or_null>,
-      "deps": ["<dep_node_name>", ...],
-      "meta": {
-        "description": "<human-readable purpose>",
-        "type": "string" | "number" | "boolean" | "integer" | "enum",
-        "range": [min, max],
-        "values": ["a", "b"],
-        "format": "currency" | "percentage" | "status",
-        "access": "human" | "llm" | "both" | "system",
-        "unit": "<unit>",
-        "tags": ["<tag>"]
-      }
-    }
-  },
-  "edges": [
-    { "from": "<source_node>", "to": "<target_node>" }
-  ]
-}
-
-Rules:
-- "state" nodes have no deps and hold user/LLM-writable values (knobs).
-- "derived" nodes have deps and compute from them.
-- "effect" nodes have deps but produce side effects (no return value).
-- "producer" nodes have no deps but generate values asynchronously.
-- Edges wire output of one node as input to another. They must match deps.
-- meta.description is required for every node.
-- Return ONLY valid JSON, no markdown fences or commentary.`;
-async function graphFromSpec(naturalLanguage, adapter, opts) {
-  const systemPrompt = opts?.systemPromptExtra ? `${GRAPH_FROM_SPEC_SYSTEM_PROMPT}
-
-${opts.systemPromptExtra}` : GRAPH_FROM_SPEC_SYSTEM_PROMPT;
-  const messages = [
-    { role: "system", content: systemPrompt },
-    { role: "user", content: naturalLanguage }
-  ];
-  const rawResult = adapter.invoke(messages, {
-    model: opts?.model,
-    temperature: opts?.temperature ?? 0,
-    maxTokens: opts?.maxTokens
-  });
-  const response = await resolveToolHandlerResult(rawResult);
-  let content = response.content.trim();
-  if (content.startsWith("```")) {
-    content = stripFences(content);
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(content);
-  } catch {
-    throw new Error(`graphFromSpec: LLM response is not valid JSON: ${content.slice(0, 200)}`);
-  }
-  const validation = validateGraphDef(parsed);
-  if (!validation.valid) {
-    throw new Error(`graphFromSpec: invalid graph definition:
-${validation.errors.join("\n")}`);
-  }
-  const def = parsed;
-  if (def.version === void 0) def.version = 1;
-  if (!Array.isArray(def.subgraphs)) def.subgraphs = [];
-  return Graph.fromSnapshot(def, opts?.build);
-}
-var SUGGEST_STRATEGY_SYSTEM_PROMPT = `You are a reactive graph optimizer for GraphReFly.
-
-Given a graph's current structure (from describe()) and a problem statement, suggest topology and parameter changes to solve the problem.
-
-Return ONLY valid JSON with this structure:
-{
-  "summary": "<one-line summary of the strategy>",
-  "reasoning": "<explanation of why these changes help>",
-  "operations": [
-    { "type": "add_node", "name": "<name>", "nodeType": "state|derived|effect|producer|operator", "meta": {...}, "initial": <value> },
-    { "type": "remove_node", "name": "<name>" },
-    { "type": "connect", "from": "<source>", "to": "<target>" },
-    { "type": "disconnect", "from": "<source>", "to": "<target>" },
-    { "type": "set_value", "name": "<name>", "value": <new_value> },
-    { "type": "update_meta", "name": "<name>", "key": "<meta_key>", "value": <new_value> }
-  ]
-}
-
-Rules:
-- Only suggest operations that reference existing nodes (for remove/disconnect/set_value/update_meta) or new nodes you define (for add_node).
-- Keep changes minimal \u2014 prefer the smallest set of operations that solves the problem.
-- Return ONLY valid JSON, no markdown fences or commentary.`;
-async function suggestStrategy(graph, problem, adapter, opts) {
-  const { expand: _, ...described } = graph.describe({ actor: opts?.actor, detail: "standard" });
-  const messages = [
-    { role: "system", content: SUGGEST_STRATEGY_SYSTEM_PROMPT },
-    {
-      role: "user",
-      content: JSON.stringify({
-        graph: described,
-        problem
-      })
-    }
-  ];
-  const rawResult = adapter.invoke(messages, {
-    model: opts?.model,
-    temperature: opts?.temperature ?? 0,
-    maxTokens: opts?.maxTokens
-  });
-  const response = await resolveToolHandlerResult(rawResult);
-  let content = response.content.trim();
-  if (content.startsWith("```")) {
-    content = content.replace(/^```(?:json)?\s*/, "").replace(/\s*```$/, "");
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(content);
-  } catch {
-    throw new Error(`suggestStrategy: LLM response is not valid JSON: ${content.slice(0, 200)}`);
-  }
-  const plan = parsed;
-  if (typeof plan.summary !== "string") {
-    throw new Error("suggestStrategy: missing 'summary' in response");
-  }
-  if (typeof plan.reasoning !== "string") {
-    throw new Error("suggestStrategy: missing 'reasoning' in response");
-  }
-  if (!Array.isArray(plan.operations)) {
-    throw new Error("suggestStrategy: missing 'operations' array in response");
-  }
-  return {
-    summary: plan.summary,
-    reasoning: plan.reasoning,
-    operations: plan.operations
-  };
-}
-
-export {
-  gate,
-  orchestration_exports,
-  fromLLM,
-  streamingPromptNode,
-  streamExtractor,
-  keywordFlagExtractor,
-  toolCallExtractor,
-  costMeterExtractor,
-  redactor,
-  contentGate,
-  gatedStream,
-  promptNode,
-  ChatStreamGraph,
-  chatStream,
-  ToolRegistryGraph,
-  toolRegistry,
-  systemPromptBuilder,
-  llmExtractor,
-  llmConsolidator,
-  admissionFilter3D,
-  agentMemory,
-  AgentLoopGraph,
-  agentLoop,
-  knobsAsTools,
-  gaugesAsContext,
-  validateGraphDef,
-  graphFromSpec,
-  suggestStrategy,
-  ai_exports
-};
-//# sourceMappingURL=chunk-K2AUJHVP.js.map