@graphrefly/graphrefly 0.1.0

package/dist/index.js

@@ -0,0 +1,3649 @@
+import {
+  CircuitOpenError,
+  DictCheckpointAdapter,
+  FileCheckpointAdapter,
+  MemoryCheckpointAdapter,
+  NS_PER_MS,
+  NS_PER_SEC,
+  SqliteCheckpointAdapter,
+  audit,
+  buffer,
+  bufferCount,
+  bufferTime,
+  catchError,
+  checkpointNodeValue,
+  circuitBreaker,
+  combine,
+  combineLatest,
+  concat,
+  concatMap,
+  constant,
+  createTransport,
+  debounce,
+  debounceTime,
+  decorrelatedJitter,
+  delay,
+  deserializeError,
+  distill,
+  distinctUntilChanged,
+  elementAt,
+  exhaustMap,
+  exponential,
+  extra_exports,
+  fibonacci,
+  filter,
+  find,
+  first,
+  flatMap,
+  fromCSV,
+  fromClickHouseWatch,
+  fromGitHook,
+  fromHTTP,
+  fromIDBRequest,
+  fromIDBTransaction,
+  fromKafka,
+  fromMCP,
+  fromNDJSON,
+  fromOTel,
+  fromPrometheus,
+  fromRedisStream,
+  fromStatsD,
+  fromSyslog,
+  fromWebSocket,
+  fromWebhook,
+  gate,
+  interval,
+  last,
+  linear,
+  map,
+  merge,
+  mergeMap,
+  nameToSignal,
+  pairwise,
+  parsePrometheusText,
+  parseStatsD,
+  parseSyslog,
+  pausable,
+  pubsub,
+  race,
+  rateLimiter,
+  reactiveIndex,
+  reactiveList,
+  reactiveMap,
+  reduce,
+  repeat,
+  rescue,
+  resolveBackoffPreset,
+  restoreGraphCheckpoint,
+  restoreGraphCheckpointIndexedDb,
+  retry,
+  sample,
+  saveGraphCheckpoint,
+  saveGraphCheckpointIndexedDb,
+  scan,
+  serializeError,
+  signalToName,
+  skip,
+  startWith,
+  switchMap,
+  take,
+  takeUntil,
+  takeWhile,
+  tap,
+  throttle,
+  throttleTime,
+  timeout,
+  toKafka,
+  toRedisStream,
+  toSSE,
+  toWebSocket,
+  tokenBucket,
+  tokenTracker,
+  verifiable,
+  window,
+  windowCount,
+  windowTime,
+  withBreaker,
+  withLatestFrom,
+  withMaxAttempts,
+  withStatus,
+  workerBridge,
+  workerSelf,
+  zip
+} from "./chunk-VPS7L64N.js";
+import {
+  cqrs_exports,
+  nestjs_exports
+} from "./chunk-QW7H3ICI.js";
+import {
+  JsonCodec,
+  createDagCborCodec,
+  createDagCborZstdCodec,
+  graph_exports,
+  negotiateCodec,
+  replayWAL
+} from "./chunk-HP7OKEOE.js";
+import {
+  core_exports
+} from "./chunk-CP6MNKAA.js";
+import {
+  cached,
+  createWatermarkController,
+  empty,
+  escapeRegexChar,
+  firstValueFrom,
+  forEach,
+  fromAny,
+  fromAsyncIter,
+  fromCron,
+  fromEvent,
+  fromFSWatch,
+  fromIter,
+  fromPromise,
+  fromTimer,
+  globToRegExp,
+  logSlice,
+  matchesAnyPattern,
+  matchesCron,
+  never,
+  observeGraph$,
+  observeNode$,
+  of,
+  parseCron,
+  reactiveLog,
+  replay,
+  share,
+  shareReplay,
+  throwError,
+  toArray,
+  toMessages$,
+  toObservable
+} from "./chunk-KWXPDASV.js";
+import {
+  reactive_layout_exports
+} from "./chunk-Z4Y4FMQN.js";
+import {
+  GRAPH_META_SEGMENT,
+  Graph,
+  reachable
+} from "./chunk-6W5SGIGB.js";
+import {
+  describeNode,
+  metaSnapshot
+} from "./chunk-O3PI7W45.js";
+import {
+  COMPLETE,
+  DATA,
+  DEFAULT_ACTOR,
+  DIRTY,
+  DynamicNodeImpl,
+  ERROR,
+  GuardDenied,
+  INVALIDATE,
+  PAUSE,
+  RESOLVED,
+  RESUME,
+  TEARDOWN,
+  __export,
+  accessHintForGuard,
+  advanceVersion,
+  batch,
+  createVersioning,
+  defaultHash,
+  derived,
+  dynamicNode,
+  effect,
+  emitWithBatch,
+  isBatching,
+  isKnownMessageType,
+  isPhase2Message,
+  isTerminalMessage,
+  isV1,
+  knownMessageTypes,
+  messageTier,
+  monotonicNs,
+  node,
+  normalizeActor,
+  partitionForBatch,
+  pipe,
+  policy,
+  policyFromRules,
+  producer,
+  propagatesToMeta,
+  state,
+  wallClockNs
+} from "./chunk-5X3LAO3B.js";
+
+// src/compat/index.ts
+var compat_exports = {};
+__export(compat_exports, {
+  jotai: () => jotai_exports,
+  nanostores: () => nanostores_exports,
+  nestjs: () => nestjs_exports,
+  react: () => react_exports,
+  signals: () => signals_exports,
+  solid: () => solid_exports,
+  svelte: () => svelte_exports,
+  vue: () => vue_exports,
+  zustand: () => zustand_exports
+});
+
+// src/compat/jotai/index.ts
+var jotai_exports = {};
+__export(jotai_exports, {
+  atom: () => atom
+});
+function atom(initialOrRead, writeOrOptions, options) {
+  if (typeof initialOrRead === "function") {
+    const read = initialOrRead;
+    if (typeof writeOrOptions === "function") {
+      return createDerivedAtom(read, writeOrOptions, options);
+    }
+    return createDerivedAtom(read, void 0, writeOrOptions);
+  }
+  return createPrimitiveAtom(initialOrRead, writeOrOptions);
+}
+function pull(n) {
+  let val = n.get();
+  let err;
+  const unsub = n.subscribe((msgs) => {
+    for (const [t, v] of msgs) {
+      if (t === DATA) val = v;
+      if (t === ERROR) err = v;
+    }
+  });
+  unsub();
+  if (err) throw err;
+  return val;
+}
+function createPrimitiveAtom(initial, options) {
+  const n = state(initial, {
+    ...options,
+    resubscribable: true,
+    resetOnTeardown: true
+  });
+  return {
+    get: () => {
+      if (n.status === "disconnected") {
+        return pull(n);
+      }
+      return n.get();
+    },
+    set: (value) => n.down([[DATA, value]]),
+    update: (fn) => {
+      const current = n.status === "disconnected" ? pull(n) : n.get();
+      n.down([[DATA, fn(current)]]);
+    },
+    subscribe: (cb) => {
+      return n.subscribe((msgs) => {
+        for (const [t, v] of msgs) {
+          if (t === DATA) cb(v);
+        }
+      });
+    },
+    meta: n.meta,
+    _node: n
+  };
+}
+function createDerivedAtom(read, write, options) {
+  const n = dynamicNode(
+    (get) => read((a) => {
+      const dn = a._node;
+      if (dn.status === "disconnected") {
+        pull(dn);
+      }
+      return get(dn);
+    }),
+    {
+      ...options,
+      resubscribable: true,
+      resetOnTeardown: true
+    }
+  );
+  const result = {
+    get: () => {
+      if (n.status === "disconnected") {
+        return pull(n);
+      }
+      return n.get();
+    },
+    subscribe: (cb) => {
+      return n.subscribe((msgs) => {
+        for (const [t, v] of msgs) {
+          if (t === DATA) cb(v);
+        }
+      });
+    },
+    meta: n.meta,
+    _node: n
+  };
+  if (write) {
+    const getFn = (a) => a.get();
+    const setFn = (a, value) => a.set(value);
+    const writable = result;
+    writable.set = (value) => write(getFn, setFn, value);
+    writable.update = (fn) => {
+      const current = n.status === "disconnected" ? pull(n) : n.get();
+      return write(getFn, setFn, fn(current));
+    };
+    return writable;
+  }
+  return result;
+}
+
+// src/compat/nanostores/index.ts
+var nanostores_exports = {};
+__export(nanostores_exports, {
+  action: () => action,
+  atom: () => atom2,
+  computed: () => computed,
+  getValue: () => getValue,
+  map: () => map2,
+  onMount: () => onMount,
+  onStart: () => onStart,
+  onStop: () => onStop
+});
+var START_LISTENERS = /* @__PURE__ */ new WeakMap();
+var STOP_LISTENERS = /* @__PURE__ */ new WeakMap();
+function trigger(node2, map3) {
+  const callbacks = map3.get(node2);
+  if (callbacks) {
+    for (const cb of callbacks) cb();
+  }
+}
+function createStore(node2, extra = {}) {
+  let listeners = 0;
+  const store = {
+    ...extra,
+    get: () => getVal(node2),
+    subscribe: (cb) => {
+      if (listeners === 0) trigger(node2, START_LISTENERS);
+      listeners++;
+      const sub = node2.subscribe((msgs) => {
+        for (const [t, v] of msgs) {
+          if (t === DATA) cb(v);
+        }
+      });
+      cb(getVal(node2));
+      return () => {
+        sub();
+        listeners--;
+        if (listeners === 0) trigger(node2, STOP_LISTENERS);
+      };
+    },
+    listen: (cb) => {
+      if (listeners === 0) trigger(node2, START_LISTENERS);
+      listeners++;
+      const sub = node2.subscribe((msgs) => {
+        for (const [t, v] of msgs) {
+          if (t === DATA) cb(v);
+        }
+      });
+      return () => {
+        sub();
+        listeners--;
+        if (listeners === 0) trigger(node2, STOP_LISTENERS);
+      };
+    },
+    _node: node2
+  };
+  return store;
+}
+function pull2(n) {
+  let val = n.get();
+  let err;
+  const unsub = n.subscribe((msgs) => {
+    for (const [t, v] of msgs) {
+      if (t === DATA) val = v;
+      if (t === ERROR) err = v;
+    }
+  });
+  unsub();
+  if (err) throw err;
+  return val;
+}
+function getVal(n) {
+  if (n.status === "disconnected") {
+    return pull2(n);
+  }
+  return n.get();
+}
+function atom2(initial) {
+  const n = state(initial, {
+    resubscribable: true,
+    resetOnTeardown: true
+  });
+  return createStore(n, {
+    set: (value) => n.down([[DATA, value]])
+  });
+}
+function computed(stores, fn) {
+  const storeArray = Array.isArray(stores) ? stores : [stores];
+  const n = dynamicNode(
+    (get) => {
+      const vals = storeArray.map((s) => {
+        const node2 = s._node;
+        if (node2.status === "disconnected") {
+          pull2(node2);
+        }
+        return get(node2);
+      });
+      return fn(...vals);
+    },
+    {
+      resubscribable: true,
+      resetOnTeardown: true,
+      equals: Object.is
+    }
+  );
+  return createStore(n);
+}
+function map2(initial) {
+  const n = state(initial, {
+    resubscribable: true,
+    resetOnTeardown: true,
+    equals: () => false
+  });
+  return createStore(n, {
+    set: (value) => n.down([[DATA, value]]),
+    setKey: (key, value) => {
+      const current = getVal(n);
+      n.down([[DATA, { ...current, [key]: value }]]);
+    }
+  });
+}
+function getValue(store) {
+  return store.get();
+}
+function onStart(store, cb) {
+  const node2 = store._node;
+  let callbacks = START_LISTENERS.get(node2);
+  if (!callbacks) {
+    callbacks = /* @__PURE__ */ new Set();
+    START_LISTENERS.set(node2, callbacks);
+  }
+  callbacks.add(cb);
+}
+function onStop(store, cb) {
+  const node2 = store._node;
+  let callbacks = STOP_LISTENERS.get(node2);
+  if (!callbacks) {
+    callbacks = /* @__PURE__ */ new Set();
+    STOP_LISTENERS.set(node2, callbacks);
+  }
+  callbacks.add(cb);
+}
+function onMount(store, cb) {
+  onStart(store, () => {
+    const stop = cb();
+    if (typeof stop === "function") onStop(store, stop);
+  });
+}
+function action(_store, _name, fn) {
+  return (...args) => {
+    let result;
+    batch(() => {
+      result = fn(...args);
+    });
+    return result;
+  };
+}
+
+// src/compat/react/index.ts
+var react_exports = {};
+__export(react_exports, {
+  useStore: () => useStore,
+  useSubscribe: () => useSubscribe,
+  useSubscribeRecord: () => useSubscribeRecord
+});
+import { useCallback, useMemo, useRef, useSyncExternalStore } from "react";
+function useSubscribe(node2) {
+  return useSyncExternalStore(
+    (onStoreChange) => {
+      let disposed = false;
+      const unsub = node2.subscribe(() => {
+        if (!disposed) onStoreChange();
+      });
+      return () => {
+        disposed = true;
+        unsub();
+      };
+    },
+    () => node2.get(),
+    () => node2.get()
+    // Server snapshot
+  );
+}
+function useStore(node2) {
+  const value = useSubscribe(node2);
+  const setter = useCallback(
+    (v) => {
+      node2.down([[DIRTY], [DATA, v]]);
+    },
+    [node2]
+  );
+  return [value, setter];
+}
+function useSubscribeRecord(keysNode, factory) {
+  const factoryRef = useRef(factory);
+  factoryRef.current = factory;
+  const store = useMemo(() => {
+    const computeSnap = () => {
+      const snap = {};
+      const keys = keysNode.get() ?? [];
+      for (const key of keys) {
+        const nodes = factoryRef.current(key);
+        const values = {};
+        for (const field of Object.keys(nodes)) {
+          values[field] = nodes[field].get();
+        }
+        snap[key] = values;
+      }
+      return snap;
+    };
+    let currentSnapshot = computeSnap();
+    return {
+      subscribe: (onStoreChange) => {
+        let disposed = false;
+        let entrySubs = [];
+        const cleanupEntries = () => {
+          for (const unsub of entrySubs) unsub();
+          entrySubs = [];
+        };
+        const sync = (nextKeys) => {
+          cleanupEntries();
+          for (const key of nextKeys) {
+            const nodes = factoryRef.current(key);
+            for (const field of Object.keys(nodes)) {
+              const unsub = nodes[field].subscribe(() => {
+                currentSnapshot = computeSnap();
+                if (!disposed) onStoreChange();
+              });
+              entrySubs.push(unsub);
+            }
+          }
+          currentSnapshot = computeSnap();
+          if (!disposed) onStoreChange();
+        };
+        const keysUnsub = keysNode.subscribe((msgs) => {
+          const hasSettled = msgs.some((m) => messageTier(m[0]) >= 2);
+          if (!disposed && hasSettled) sync(keysNode.get() ?? []);
+        });
+        sync(keysNode.get() ?? []);
+        return () => {
+          disposed = true;
+          keysUnsub();
+          cleanupEntries();
+        };
+      },
+      getSnapshot: () => currentSnapshot
+    };
+  }, [keysNode]);
+  return useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
+}
+
+// src/compat/signals/index.ts
+var signals_exports = {};
+__export(signals_exports, {
+  Signal: () => Signal
+});
+var trackingStack = [];
+function pull3(n) {
+  let val = n.get();
+  const unsub = n.subscribe((msgs) => {
+    for (const [t, v] of msgs) {
+      if (t === DATA) val = v;
+    }
+  });
+  unsub();
+  return val;
+}
+var SignalState = class {
+  /** @internal */
+  _node;
+  _equals;
+  constructor(initial, opts) {
+    this._equals = opts?.equals ?? Object.is;
+    this._node = state(initial, {
+      ...opts,
+      resubscribable: true,
+      resetOnTeardown: true
+    });
+  }
+  get() {
+    const tracker = trackingStack[trackingStack.length - 1];
+    if (tracker) {
+      if (this._node.status === "disconnected") {
+        pull3(this._node);
+      }
+      return tracker(this._node);
+    }
+    if (this._node.status === "disconnected") {
+      return pull3(this._node);
+    }
+    return this._node.get();
+  }
+  set(value) {
+    if (this._equals(this.get(), value)) return;
+    batch(() => {
+      this._node.down([[DIRTY], [DATA, value]]);
+    });
+  }
+};
+var SignalComputed = class {
+  /** @internal */
+  _node;
+  constructor(computation, opts) {
+    this._node = dynamicNode(
+      (get) => {
+        trackingStack.push(get);
+        try {
+          return computation();
+        } finally {
+          trackingStack.pop();
+        }
+      },
+      {
+        ...opts,
+        describeKind: "derived",
+        resubscribable: true,
+        resetOnTeardown: true
+      }
+    );
+  }
+  get() {
+    const tracker = trackingStack[trackingStack.length - 1];
+    if (tracker) {
+      if (this._node.status === "disconnected") {
+        pull3(this._node);
+      }
+      return tracker(this._node);
+    }
+    if (this._node.status === "disconnected") {
+      return pull3(this._node);
+    }
+    return this._node.get();
+  }
+};
+var Signal = {
+  State: SignalState,
+  Computed: SignalComputed,
+  /**
+   * Subscribes to changes on a signal.
+   * Returns an unsubscribe callback.
+   *
+   * @example
+   * ```ts
+   * const count = new Signal.State(0);
+   * const unsub = Signal.sub(count, v => console.log(v));
+   * ```
+   */
+  sub: (signal, callback) => {
+    const handlers = typeof callback === "function" ? { data: callback, error: void 0, complete: void 0 } : callback;
+    return signal._node.subscribe((msgs) => {
+      for (const [t, v] of msgs) {
+        if (t === DATA) handlers.data?.(v);
+        if (t === ERROR) handlers.error?.(v);
+        if (t === COMPLETE) handlers.complete?.();
+      }
+    });
+  }
+};
+
+// src/compat/solid/index.ts
+var solid_exports = {};
+__export(solid_exports, {
+  useStore: () => useStore2,
+  useSubscribe: () => useSubscribe2,
+  useSubscribeRecord: () => useSubscribeRecord2
+});
+import { createSignal, getOwner, onCleanup } from "solid-js";
+function useSubscribe2(node2) {
+  const [value, setValue] = createSignal(node2.get(), { equals: false });
+  const unsub = node2.subscribe(() => {
+    setValue(() => node2.get());
+  });
+  if (getOwner()) {
+    onCleanup(() => unsub());
+  } else if (typeof console !== "undefined") {
+    console.warn(
+      "[graphrefly-ts] useSubscribe called outside a Solid reactive owner \u2014 subscription will not be auto-disposed."
+    );
+  }
+  return value;
+}
+function useStore2(node2) {
+  const value = useSubscribe2(node2);
+  const setter = (v) => {
+    node2.down([[DIRTY], [DATA, v]]);
+  };
+  return [value, setter];
+}
+function useSubscribeRecord2(keysNode, factory) {
+  const [value, setValue] = createSignal({}, { equals: false });
+  let entrySubs = [];
+  const cleanupEntries = () => {
+    for (const unsub of entrySubs) unsub();
+    entrySubs = [];
+  };
+  const buildSnapshot = () => {
+    const snap = {};
+    for (const key of keysNode.get() ?? []) {
+      const nodes = factory(key);
+      const values = {};
+      for (const field of Object.keys(nodes)) {
+        values[field] = nodes[field].get();
+      }
+      snap[key] = values;
+    }
+    return snap;
+  };
+  const sync = (nextKeys) => {
+    cleanupEntries();
+    for (const key of nextKeys) {
+      const nodes = factory(key);
+      for (const field of Object.keys(nodes)) {
+        const unsub = nodes[field].subscribe(() => {
+          setValue(() => buildSnapshot());
+        });
+        entrySubs.push(unsub);
+      }
+    }
+    setValue(() => buildSnapshot());
+  };
+  const keysUnsub = keysNode.subscribe((msgs) => {
+    if (msgs.some((m) => messageTier(m[0]) >= 2)) {
+      sync(keysNode.get() ?? []);
+    }
+  });
+  sync(keysNode.get() ?? []);
+  if (getOwner()) {
+    onCleanup(() => {
+      keysUnsub();
+      cleanupEntries();
+    });
+  } else if (typeof console !== "undefined") {
+    console.warn(
+      "[graphrefly-ts] useSubscribeRecord called outside a Solid reactive owner \u2014 subscription will not be auto-disposed."
+    );
+  }
+  return value;
+}
+
+// src/compat/svelte/index.ts
+var svelte_exports = {};
+__export(svelte_exports, {
+  useStore: () => useStore3,
+  useSubscribe: () => useSubscribe3,
+  useSubscribeRecord: () => useSubscribeRecord3
+});
+function useSubscribe3(node2) {
+  return {
+    subscribe(run) {
+      const unsub = node2.subscribe(() => {
+        run(node2.get());
+      });
+      run(node2.get());
+      return unsub;
+    }
+  };
+}
+function useStore3(node2) {
+  return {
+    subscribe(run) {
+      const unsub = node2.subscribe(() => {
+        run(node2.get());
+      });
+      run(node2.get());
+      return unsub;
+    },
+    set(value) {
+      node2.down([[DIRTY], [DATA, value]]);
+    },
+    update(updater) {
+      const next = updater(node2.get());
+      node2.down([[DIRTY], [DATA, next]]);
+    }
+  };
+}
+function useSubscribeRecord3(keysNode, factory) {
+  return {
+    subscribe(run) {
+      let entrySubs = [];
+      const cleanupEntries = () => {
+        for (const unsub of entrySubs) unsub();
+        entrySubs = [];
+      };
+      const buildSnapshot = () => {
+        const snap = {};
+        for (const key of keysNode.get() ?? []) {
+          const nodes = factory(key);
+          const values = {};
+          for (const field of Object.keys(nodes)) {
+            values[field] = nodes[field].get();
+          }
+          snap[key] = values;
+        }
+        return snap;
+      };
+      const sync = (nextKeys) => {
+        cleanupEntries();
+        for (const key of nextKeys) {
+          const nodes = factory(key);
+          for (const field of Object.keys(nodes)) {
+            const unsub = nodes[field].subscribe(() => {
+              run(buildSnapshot());
+            });
+            entrySubs.push(unsub);
+          }
+        }
+        run(buildSnapshot());
+      };
+      const keysUnsub = keysNode.subscribe((msgs) => {
+        if (msgs.some((m) => messageTier(m[0]) >= 2)) {
+          sync(keysNode.get() ?? []);
+        }
+      });
+      sync(keysNode.get() ?? []);
+      return () => {
+        keysUnsub();
+        cleanupEntries();
+      };
+    }
+  };
+}
+
+// src/compat/vue/index.ts
+var vue_exports = {};
+__export(vue_exports, {
+  useStore: () => useStore4,
+  useSubscribe: () => useSubscribe4,
+  useSubscribeRecord: () => useSubscribeRecord4
+});
+import {
+  computed as computed2,
+  getCurrentScope,
+  isRef,
+  onScopeDispose,
+  readonly,
+  shallowRef,
+  watch
+} from "vue";
+function useSubscribe4(node2) {
+  const ref = shallowRef(node2.get());
+  const unsub = node2.subscribe(() => {
+    ref.value = node2.get();
+  });
+  if (getCurrentScope()) {
+    onScopeDispose(() => unsub());
+  } else if (typeof console !== "undefined") {
+    console.warn(
+      "[graphrefly-ts] useSubscribe called outside a Vue scope \u2014 subscription will not be auto-disposed."
+    );
+  }
+  return readonly(ref);
+}
+function useStore4(node2) {
+  const inner = shallowRef(node2.get());
+  const unsub = node2.subscribe(() => {
+    inner.value = node2.get();
+  });
+  if (getCurrentScope()) {
+    onScopeDispose(() => unsub());
+  } else if (typeof console !== "undefined") {
+    console.warn(
+      "[graphrefly-ts] useStore called outside a Vue scope \u2014 subscription will not be auto-disposed."
+    );
+  }
+  return computed2({
+    get: () => inner.value,
+    set: (v) => {
+      node2.down([[DIRTY], [DATA, v]]);
+    }
+  });
+}
+function useSubscribeRecord4(keys, factory) {
+  const result = shallowRef({});
+  const activeSubs = /* @__PURE__ */ new Map();
+  let disposed = false;
+  let batchPending = false;
+  function scheduleBatch() {
+    if (batchPending) return;
+    batchPending = true;
+    queueMicrotask(() => {
+      if (disposed) return;
+      batchPending = false;
+      const snap = {};
+      for (const [key, entry] of activeSubs) {
+        snap[key] = { ...entry.values };
+      }
+      result.value = snap;
+    });
+  }
+  function sync(newKeys) {
+    for (const entry of activeSubs.values()) {
+      for (const unsub of entry.subs) unsub();
+    }
+    activeSubs.clear();
+    for (const key of newKeys) {
+      const nodes = factory(key);
+      const fields = Object.keys(nodes);
+      const values = {};
+      const subs = [];
+      for (const field of fields) {
+        const node2 = nodes[field];
+        values[field] = node2.get();
+        const unsub = node2.subscribe(() => {
+          values[field] = node2.get();
+          scheduleBatch();
+        });
+        subs.push(unsub);
+      }
+      activeSubs.set(key, { subs, values });
+    }
+    const snap = {};
+    for (const [key, entry] of activeSubs) {
+      snap[key] = { ...entry.values };
+    }
+    result.value = snap;
+  }
+  const readKeys = () => {
+    const current = typeof keys === "function" ? keys() : isRef(keys) ? keys.value : keys;
+    return [...current ?? []];
+  };
+  watch(readKeys, (newKeys) => sync(newKeys ?? []), { immediate: true });
+  if (getCurrentScope()) {
+    onScopeDispose(() => {
+      disposed = true;
+      for (const entry of activeSubs.values()) {
+        for (const unsub of entry.subs) unsub();
+      }
+      activeSubs.clear();
+    });
+  } else if (typeof console !== "undefined") {
+    console.warn(
+      "[graphrefly-ts] useSubscribeRecord called outside a Vue scope \u2014 subscription will not be auto-disposed."
+    );
+  }
+  return readonly(result);
+}
+
+// src/compat/zustand/index.ts
+var zustand_exports = {};
+__export(zustand_exports, {
+  create: () => create
+});
+function create(initializer) {
+  const g = new Graph("zustand");
+  const s = state(void 0, { name: "state" });
+  g.add("state", s);
+  const getState = () => s.get();
+  const setState = (partial, replace) => {
+    const prev = getState();
+    const next = typeof partial === "function" ? partial(prev) : partial;
+    const nextState = replace ? next : { ...prev, ...next };
+    s.down([[DATA, nextState]]);
+  };
+  const api = {
+    getState,
+    setState,
+    getInitialState: () => initialValue,
+    subscribe: (listener) => {
+      let prev = getState();
+      return s.subscribe((msgs) => {
+        for (const [t, v] of msgs) {
+          if (t === DATA) {
+            listener(v, prev);
+            prev = v;
+          }
+        }
+      });
+    },
+    destroy: g.destroy.bind(g)
+  };
+  const initialValue = initializer(setState, getState, api);
+  s.down([[DATA, initialValue]]);
+  return Object.assign(g, api);
+}
+
+// src/patterns/index.ts
+var patterns_exports = {};
+__export(patterns_exports, {
+  ai: () => ai_exports,
+  cqrs: () => cqrs_exports,
+  layout: () => reactive_layout_exports,
+  memory: () => memory_exports,
+  messaging: () => messaging_exports,
+  orchestration: () => orchestration_exports
+});
+
+// src/patterns/ai.ts
+var ai_exports = {};
+__export(ai_exports, {
+  AgentLoopGraph: () => AgentLoopGraph,
+  ChatStreamGraph: () => ChatStreamGraph,
+  ToolRegistryGraph: () => ToolRegistryGraph,
+  admissionFilter3D: () => admissionFilter3D,
+  agentLoop: () => agentLoop,
+  agentMemory: () => agentMemory,
+  chatStream: () => chatStream,
+  fromLLM: () => fromLLM,
+  fromLLMStream: () => fromLLMStream,
+  gaugesAsContext: () => gaugesAsContext,
+  graphFromSpec: () => graphFromSpec,
+  knobsAsTools: () => knobsAsTools,
+  llmConsolidator: () => llmConsolidator,
+  llmExtractor: () => llmExtractor,
+  suggestStrategy: () => suggestStrategy,
+  systemPromptBuilder: () => systemPromptBuilder,
+  toolRegistry: () => toolRegistry,
+  validateGraphDef: () => validateGraphDef
+});
+
+// src/patterns/memory.ts
+var memory_exports = {};
+__export(memory_exports, {
+  collection: () => collection,
+  decay: () => decay,
+  knowledgeGraph: () => knowledgeGraph,
+  lightCollection: () => lightCollection,
+  vectorIndex: () => vectorIndex
+});
+function decay(baseScore, ageSeconds, ratePerSecond, minScore = 0) {
+  if (!Number.isFinite(baseScore)) return minScore;
+  if (!Number.isFinite(ageSeconds) || ageSeconds <= 0) return Math.max(minScore, baseScore);
+  if (!Number.isFinite(ratePerSecond) || ratePerSecond <= 0) return Math.max(minScore, baseScore);
+  const decayed = baseScore * Math.exp(-ratePerSecond * ageSeconds);
+  return Math.max(minScore, decayed);
+}
+function assertMaxSize(maxSize) {
+  if (maxSize !== void 0 && maxSize < 1) {
+    throw new RangeError("maxSize must be >= 1");
+  }
+}
+function copyMap(m) {
+  return new Map(m);
+}
+function readMap(node2) {
+  return node2.get() ?? /* @__PURE__ */ new Map();
+}
+function readArray(node2) {
+  return node2.get() ?? [];
+}
+function cosineSimilarity(a, b) {
+  const n = Math.max(a.length, b.length);
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  for (let i = 0; i < n; i += 1) {
+    const av = a[i] ?? 0;
+    const bv = b[i] ?? 0;
+    dot += av * bv;
+    na += av * av;
+    nb += bv * bv;
+  }
+  if (na === 0 || nb === 0) return 0;
+  return dot / Math.sqrt(na * nb);
+}
+function lightCollection(opts = {}) {
+  const maxSize = opts.maxSize;
+  const policy2 = opts.policy ?? "fifo";
+  assertMaxSize(maxSize);
+  const entries = state(/* @__PURE__ */ new Map(), {
+    name: opts.name,
+    describeKind: "state"
+  });
+  function evictIfNeeded(next) {
+    if (maxSize === void 0) return;
+    while (next.size > maxSize) {
+      let victim;
+      for (const entry of next.values()) {
+        if (!victim) {
+          victim = entry;
+          continue;
+        }
+        const lhs = policy2 === "lru" ? entry.lastAccessNs : entry.createdAtNs;
+        const rhs = policy2 === "lru" ? victim.lastAccessNs : victim.createdAtNs;
+        if (lhs < rhs) victim = entry;
+      }
+      if (!victim) break;
+      next.delete(victim.id);
+    }
+  }
+  function commit(next) {
+    entries.down([[DATA, next]]);
+  }
+  return {
+    entries,
+    upsert(id, value) {
+      const now = monotonicNs();
+      const current = readMap(entries);
+      const prev = current.get(id);
+      const next = copyMap(current);
+      next.set(id, {
+        id,
+        value,
+        createdAtNs: prev?.createdAtNs ?? now,
+        lastAccessNs: now
+      });
+      evictIfNeeded(next);
+      commit(next);
+    },
+    remove(id) {
+      const next = copyMap(readMap(entries));
+      if (!next.delete(id)) return;
+      commit(next);
+    },
+    clear() {
+      if (readMap(entries).size === 0) return;
+      commit(/* @__PURE__ */ new Map());
+    },
+    get(id) {
+      const current = readMap(entries);
+      const found = current.get(id);
+      if (!found) return void 0;
+      if (policy2 === "lru") {
+        const now = monotonicNs();
+        const next = copyMap(current);
+        next.set(id, { ...found, lastAccessNs: now });
+        commit(next);
+      }
+      return found.value;
+    },
+    has(id) {
+      return readMap(entries).has(id);
+    }
+  };
+}
+function collection(name, opts = {}) {
+  const maxSize = opts.maxSize;
+  const policy2 = opts.policy ?? "lru";
+  const decayRate = opts.decayRate ?? 0;
+  const minScore = opts.minScore ?? 0;
+  const scoreFn = opts.score ?? (() => 1);
+  assertMaxSize(maxSize);
+  const graph = new Graph(name);
+  const items = state(/* @__PURE__ */ new Map(), {
+    name: "items",
+    describeKind: "state"
+  });
+  const ranked = derived(
+    [items],
+    ([snapshot]) => {
+      const typed = snapshot ?? /* @__PURE__ */ new Map();
+      const now = monotonicNs();
+      const out2 = [...typed.values()].map((entry) => {
+        const ageSeconds = (now - entry.lastAccessNs) / 1e9;
+        return {
+          ...entry,
+          score: decay(entry.baseScore, ageSeconds, decayRate, minScore)
+        };
+      });
+      out2.sort((a, b) => b.score - a.score || b.lastAccessNs - a.lastAccessNs);
+      return out2;
+    },
+    { name: "ranked", describeKind: "derived" }
+  );
+  const size = derived(
+    [items],
+    ([snapshot]) => (snapshot ?? /* @__PURE__ */ new Map()).size,
+    {
+      name: "size",
+      describeKind: "derived",
+      initial: 0
+    }
+  );
+  void ranked.subscribe(() => void 0);
+  void size.subscribe(() => void 0);
+  graph.add("items", items);
+  graph.add("ranked", ranked);
+  graph.add("size", size);
+  graph.connect("items", "ranked");
+  graph.connect("items", "size");
+  function effective(entry, now) {
+    const ageSeconds = (now - entry.lastAccessNs) / 1e9;
+    return decay(entry.baseScore, ageSeconds, decayRate, minScore);
+  }
+  function evictIfNeeded(next) {
+    if (maxSize === void 0) return;
+    while (next.size > maxSize) {
+      const now = monotonicNs();
+      let victim;
+      let victimScore = Number.POSITIVE_INFINITY;
+      for (const entry of next.values()) {
+        const score = effective(entry, now);
+        if (score < victimScore) {
+          victim = entry;
+          victimScore = score;
+          continue;
+        }
+        if (score === victimScore && victim) {
+          const lhs = policy2 === "lru" ? entry.lastAccessNs : entry.createdAtNs;
+          const rhs = policy2 === "lru" ? victim.lastAccessNs : victim.createdAtNs;
+          if (lhs < rhs) victim = entry;
+        }
+      }
+      if (!victim) break;
+      next.delete(victim.id);
+    }
+  }
+  function commit(next) {
+    items.down([[DATA, next]]);
+  }
+  const out = Object.assign(graph, {
+    upsert(id, value, upsertOpts) {
+      const now = monotonicNs();
+      const current = readMap(items);
+      const prev = current.get(id);
+      const baseScore = upsertOpts?.score ?? scoreFn(value);
+      const next = copyMap(current);
+      next.set(id, {
+        id,
+        value,
+        baseScore,
+        createdAtNs: prev?.createdAtNs ?? now,
+        lastAccessNs: now
+      });
+      evictIfNeeded(next);
+      commit(next);
+    },
+    remove(id) {
+      const next = copyMap(readMap(items));
+      if (!next.delete(id)) return;
+      commit(next);
+    },
+    clear() {
+      if (readMap(items).size === 0) return;
+      commit(/* @__PURE__ */ new Map());
+    },
+    getItem(id) {
+      const current = readMap(items);
+      const found = current.get(id);
+      if (!found) return void 0;
+      if (policy2 === "lru") {
+        const next = copyMap(current);
+        next.set(id, { ...found, lastAccessNs: monotonicNs() });
+        commit(next);
+      }
+      return found;
+    }
+  });
+  return out;
+}
+function vectorIndex(opts = {}) {
+  const backend = opts.backend ?? "flat";
+  const dimension = opts.dimension;
+  let hnsw;
+  if (backend === "hnsw") {
+    hnsw = opts.hnswFactory?.();
+    if (!hnsw) {
+      throw new Error(
+        'vectorIndex backend "hnsw" requires an optional dependency adapter; install your HNSW package and provide `hnswFactory`.'
+      );
+    }
+  }
+  const entries = state(/* @__PURE__ */ new Map(), {
+    describeKind: "state",
+    name: "vector-index"
+  });
+  function assertDimension(vector) {
+    if (dimension !== void 0 && vector.length !== dimension) {
+      throw new RangeError(
+        `vector dimension mismatch: expected ${dimension}, got ${vector.length}`
+      );
+    }
+  }
+  function commit(next) {
+    entries.down([[DATA, next]]);
+  }
+  return {
+    backend,
+    entries,
+    upsert(id, vector, meta) {
+      assertDimension(vector);
+      const next = copyMap(readMap(entries));
+      next.set(id, { id, vector: [...vector], meta });
+      if (backend === "hnsw") hnsw.upsert(id, vector, meta);
+      commit(next);
+    },
+    remove(id) {
+      const next = copyMap(readMap(entries));
+      if (!next.delete(id)) return;
+      if (backend === "hnsw") hnsw.remove(id);
+      commit(next);
+    },
+    clear() {
+      if (readMap(entries).size === 0) return;
+      if (backend === "hnsw") hnsw.clear();
+      commit(/* @__PURE__ */ new Map());
+    },
+    search(query, k = 5) {
+      assertDimension(query);
+      if (k <= 0) return [];
+      if (backend === "hnsw") return hnsw.search(query, k);
+      const ranked = [...readMap(entries).values()].map((row) => ({
+        id: row.id,
+        score: cosineSimilarity(query, row.vector),
+        meta: row.meta
+      })).sort((a, b) => b.score - a.score).slice(0, k);
+      return ranked;
+    }
+  };
+}
+function knowledgeGraph(name) {
+  const graph = new Graph(name);
+  const entities = state(/* @__PURE__ */ new Map(), {
+    name: "entities",
+    describeKind: "state"
+  });
+  const edges = state([], {
+    name: "edges",
+    describeKind: "state"
+  });
+  const adjacency = derived(
+    [edges],
+    ([rows]) => {
+      const typed = rows ?? [];
+      const out2 = /* @__PURE__ */ new Map();
+      for (const edge of typed) {
+        const prev = out2.get(edge.from) ?? [];
+        out2.set(edge.from, Object.freeze([...prev, edge]));
+      }
+      return out2;
+    },
+    { name: "adjacency", describeKind: "derived", initial: /* @__PURE__ */ new Map() }
+  );
+  void adjacency.subscribe(() => void 0);
+  graph.add("entities", entities);
+  graph.add("edges", edges);
+  graph.add("adjacency", adjacency);
+  graph.connect("edges", "adjacency");
+  function commitEntities(next) {
+    entities.down([[DATA, next]]);
+  }
+  function commitEdges(next) {
+    edges.down([[DATA, next]]);
+  }
+  const out = Object.assign(graph, {
+    upsertEntity(id, value) {
+      const next = copyMap(readMap(entities));
+      next.set(id, value);
+      commitEntities(next);
+    },
+    removeEntity(id) {
+      const nextEntities = copyMap(readMap(entities));
+      const existed = nextEntities.delete(id);
+      const currentEdges = readArray(edges);
+      const nextEdges = currentEdges.filter((edge) => edge.from !== id && edge.to !== id);
+      if (!existed && nextEdges.length === currentEdges.length) return;
+      commitEntities(nextEntities);
+      commitEdges(nextEdges);
+    },
+    link(from, to, relation, weight = 1) {
+      const key = `${from}\0${to}\0${relation}`;
+      const currentEdges = readArray(edges);
+      const existing = new Set(
+        currentEdges.map((edge) => `${edge.from}\0${edge.to}\0${edge.relation}`)
+      );
+      const next = [...currentEdges];
+      if (existing.has(key)) {
+        for (let i = 0; i < next.length; i += 1) {
+          const edge = next[i];
+          if (edge.from === from && edge.to === to && edge.relation === relation) {
+            next[i] = { ...edge, weight };
+            break;
+          }
+        }
+      } else {
+        next.push({ from, to, relation, weight });
+      }
+      commitEdges(next);
+    },
+    unlink(from, to, relation) {
+      const currentEdges = readArray(edges);
+      const next = currentEdges.filter(
+        (edge) => relation === void 0 ? !(edge.from === from && edge.to === to) : !(edge.from === from && edge.to === to && edge.relation === relation)
+      );
+      if (next.length === currentEdges.length) return;
+      commitEdges(next);
+    },
+    related(id, relation) {
+      return readArray(edges).filter(
+        (edge) => (edge.from === id || edge.to === id) && (relation === void 0 || edge.relation === relation)
+      );
+    }
+  });
+  return out;
+}
+
+// src/patterns/ai.ts
+function aiMeta(kind, extra) {
+  return {
+    ai: true,
+    ai_type: kind,
+    ...extra ?? {}
+  };
+}
+function keepalive(n) {
+  return n.subscribe(() => void 0);
+}
+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" && "get" in x && typeof x.get === "function";
+}
+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.get();
+    if (immediate !== void 0) {
+      return Promise.resolve(immediate);
+    }
+  }
+  const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  return new Promise((resolve, reject) => {
+    let timer;
+    const cleanup = () => {
+      if (timer !== void 0) clearTimeout(timer);
+    };
+    const unsub = resolved.subscribe((messages) => {
+      for (const msg of messages) {
+        if (msg[0] === DATA) {
+          cleanup();
+          unsub();
+          resolve(msg[1]);
+          return;
+        }
+        if (msg[0] === ERROR) {
+          cleanup();
+          unsub();
+          reject(msg[1]);
+          return;
+        }
+        if (msg[0] === COMPLETE) {
+          cleanup();
+          unsub();
+          reject(new Error("firstDataFromNode: completed without producing a value"));
+          return;
+        }
+      }
+    });
+    timer = setTimeout(() => {
+      unsub();
+      reject(new Error(`firstDataFromNode: timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+  });
+}
+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 fromLLMStream(adapter, messages, opts) {
+  const msgsNode = fromAny(messages);
+  let controller;
+  const log = reactiveLog([], { name: opts?.name ?? "llmStream" });
+  const eff = effect([msgsNode], ([msgs]) => {
+    controller?.abort();
+    log.clear();
+    const chatMsgs = msgs;
+    if (!chatMsgs || chatMsgs.length === 0) return;
+    controller = new AbortController();
+    const iter = adapter.stream(chatMsgs, {
+      model: opts?.model,
+      temperature: opts?.temperature,
+      maxTokens: opts?.maxTokens,
+      tools: opts?.tools,
+      systemPrompt: opts?.systemPrompt,
+      signal: controller.signal
+    });
+    const ctrl = controller;
+    (async () => {
+      try {
+        for await (const chunk of iter) {
+          if (ctrl.signal.aborted) break;
+          log.append(chunk);
+        }
+      } catch (_err) {
+      }
+    })();
+    return () => {
+      ctrl.abort();
+    };
+  });
+  const unsub = keepalive(eff);
+  return {
+    node: log.entries,
+    dispose() {
+      controller?.abort();
+      unsub();
+      eff.down([[TEARDOWN]]);
+    }
+  };
+}
+var ChatStreamGraph = class extends Graph {
+  _log;
+  _keepaliveSubs = [];
+  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.value.entries;
+        return entries.length === 0 ? void 0 : entries[entries.length - 1];
+      },
+      {
+        name: "latest",
+        describeKind: "derived",
+        meta: aiMeta("chat_latest"),
+        initial: void 0
+      }
+    );
+    this.add("latest", this.latest);
+    this.connect("messages", "latest");
+    this._keepaliveSubs.push(keepalive(this.latest));
+    this.messageCount = derived(
+      [this.messages],
+      ([snapshot]) => snapshot.value.entries.length,
+      {
+        name: "messageCount",
+        describeKind: "derived",
+        meta: aiMeta("chat_message_count"),
+        initial: 0
+      }
+    );
+    this.add("messageCount", this.messageCount);
+    this.connect("messages", "messageCount");
+    this._keepaliveSubs.push(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.get().value.entries;
+  }
+  destroy() {
+    for (const unsub of this._keepaliveSubs) unsub();
+    this._keepaliveSubs.length = 0;
+    super.destroy();
+  }
+};
+function chatStream(name, opts) {
+  return new ChatStreamGraph(name, opts);
+}
+var ToolRegistryGraph = class extends Graph {
+  definitions;
+  schemas;
+  _keepaliveSubs = [];
+  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.connect("definitions", "schemas");
+    this._keepaliveSubs.push(keepalive(this.schemas));
+  }
+  register(tool) {
+    const current = this.definitions.get();
+    const next = new Map(current);
+    next.set(tool.name, tool);
+    this.definitions.down([[DATA, next]]);
+  }
+  unregister(name) {
+    const current = this.definitions.get();
+    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.get();
+    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.get().get(name);
+  }
+  destroy() {
+    for (const unsub of this._keepaliveSubs) unsub();
+    this._keepaliveSubs.length = 0;
+    super.destroy();
+  }
+};
+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((_deps, 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((_deps, 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 && typeof snapshot === "object" && "value" in snapshot && typeof snapshot.value === "object" && snapshot.value !== null && "map" in snapshot.value) {
+    return snapshot.value.map ?? /* @__PURE__ */ new Map();
+  }
+  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 filter2 = opts.admissionFilter;
+    filteredSource = derived(
+      [srcNode],
+      ([raw]) => {
+        if (filter2(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 interval2 = opts.reflection?.interval ?? 3e5;
+    consolidateTrigger = fromTimer(interval2, { period: interval2 });
+  }
+  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.node);
+  graph.add("compact", distillBundle.compact);
+  graph.add("size", distillBundle.size);
+  graph.connect("store", "compact");
+  graph.connect("store", "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.node.get());
+      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.node;
+    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.archiveAdapter) {
+      archiveHandle = graph.autoCheckpoint(
+        tiersOpts.archiveAdapter,
+        tiersOpts.archiveCheckpointOptions
+      );
+    }
+    memoryTiersBundle = {
+      permanent,
+      activeEntries: storeNode,
+      archiveHandle,
+      tierOf,
+      markPermanent
+    };
+  }
+  if (vectors || kg) {
+    const embedFn = opts.embedFn;
+    const entityFn = opts.entityFn;
+    const storeNode = distillBundle.store.node;
+    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 queryInput = state(null, {
+      name: "retrievalQuery",
+      describeKind: "state"
+    });
+    graph.add("retrievalQuery", queryInput);
+    const contextNode = opts.context ? fromAny(opts.context) : state(null);
+    const traceState = state(null, {
+      name: "retrievalTrace",
+      describeKind: "state",
+      meta: aiMeta("retrieval_trace")
+    });
+    graph.add("retrievalTrace", traceState);
+    retrievalTraceNode = traceState;
+    const storeNode = distillBundle.store.node;
+    let lastTrace = null;
+    const retrievalDerived = derived(
+      [queryInput, storeNode, contextNode],
+      ([query, snapshot, ctx]) => {
+        if (!query) return [];
+        const q = query;
+        const storeMap = extractStoreMap(snapshot);
+        const candidateMap = /* @__PURE__ */ new Map();
+        let vectorCandidates = [];
+        if (vectors && q.vector) {
+          vectorCandidates = vectors.search(q.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 = [...q.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;
+        }
+        lastTrace = { vectorCandidates, graphExpanded, ranked, packed };
+        return packed;
+      },
+      {
+        name: "retrieval",
+        describeKind: "derived",
+        meta: aiMeta("retrieval_pipeline"),
+        initial: []
+      }
+    );
+    graph.add("retrieval", retrievalDerived);
+    graph.connect("retrievalQuery", "retrieval");
+    graph.connect("store", "retrieval");
+    keepaliveSubs.push(retrievalDerived.subscribe(() => void 0));
+    retrievalNode = retrievalDerived;
+    retrieveFn = (query) => {
+      queryInput.down([[DATA, query]]);
+      const result = retrievalDerived.get();
+      if (lastTrace) {
+        traceState.down([[DATA, lastTrace]]);
+      }
+      return result;
+    };
+  }
+  const origDestroy = graph.destroy.bind(graph);
+  graph.destroy = () => {
+    for (const unsub of keepaliveSubs) unsub();
+    keepaliveSubs.length = 0;
+    origDestroy();
+  };
+  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.get() ?? [];
+        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.get();
+    } 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 });
+  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 access = node2.meta.access;
+    if (access === "human" || access === "system") continue;
+    const description = node2.meta.description ?? `Set the value of ${path}`;
+    const valueSchema = metaToJsonSchema(node2.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 });
+  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 desc = node2.meta.description;
+    const format = node2.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 = node2.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 described = graph.describe({ actor: opts?.actor });
+  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
+  };
+}
+
+// src/patterns/messaging.ts
+var messaging_exports = {};
+__export(messaging_exports, {
+  JobFlowGraph: () => JobFlowGraph,
+  JobQueueGraph: () => JobQueueGraph,
+  SubscriptionGraph: () => SubscriptionGraph,
+  TopicBridgeGraph: () => TopicBridgeGraph,
+  TopicGraph: () => TopicGraph,
+  jobFlow: () => jobFlow,
+  jobQueue: () => jobQueue,
+  subscription: () => subscription,
+  topic: () => topic,
+  topicBridge: () => topicBridge
+});
+var DEFAULT_MAX_PER_PUMP = 2147483647;
+function requireNonNegativeInt(value, label) {
+  if (!Number.isFinite(value) || !Number.isInteger(value) || value < 0) {
+    throw new Error(`${label} must be a non-negative integer`);
+  }
+  return value;
+}
+function keepalive2(n) {
+  return n.subscribe(() => {
+  });
+}
+function messagingMeta(kind, extra) {
+  return {
+    messaging: true,
+    messaging_type: kind,
+    ...extra ?? {}
+  };
+}
+var TopicGraph = class extends Graph {
+  _log;
+  _keepaliveDisposers = [];
+  events;
+  latest;
+  constructor(name, opts = {}) {
+    super(name, opts.graph);
+    this._log = reactiveLog([], { name: "events", maxSize: opts.retainedLimit });
+    this.events = this._log.entries;
+    this.add("events", this.events);
+    this.latest = derived(
+      [this.events],
+      ([snapshot]) => {
+        const entries = snapshot.value.entries;
+        return entries.length === 0 ? void 0 : entries[entries.length - 1];
+      },
+      {
+        name: "latest",
+        describeKind: "derived",
+        meta: messagingMeta("topic_latest"),
+        initial: void 0
+      }
+    );
+    this.add("latest", this.latest);
+    this.connect("events", "latest");
+    this._keepaliveDisposers.push(keepalive2(this.latest));
+  }
+  destroy() {
+    for (const dispose of this._keepaliveDisposers) dispose();
+    this._keepaliveDisposers.length = 0;
+    super.destroy();
+  }
+  publish(value) {
+    this._log.append(value);
+  }
+  retained() {
+    const snapshot = this.events.get();
+    return snapshot.value.entries;
+  }
+};
+var SubscriptionGraph = class extends Graph {
+  _keepaliveDisposers = [];
+  source;
+  cursor;
+  available;
+  constructor(name, topicGraph, opts = {}) {
+    super(name, opts.graph);
+    const initialCursor = requireNonNegativeInt(opts.cursor ?? 0, "subscription cursor");
+    this.mount("topic", topicGraph);
+    const topicEvents = topicGraph.events;
+    this.source = derived([topicEvents], ([snapshot]) => snapshot, {
+      name: "source",
+      describeKind: "derived",
+      meta: messagingMeta("subscription_source"),
+      initial: topicEvents.get()
+    });
+    this.add("source", this.source);
+    this.cursor = state(initialCursor, {
+      name: "cursor",
+      describeKind: "state",
+      meta: messagingMeta("subscription_cursor")
+    });
+    this.add("cursor", this.cursor);
+    this.available = derived(
+      [this.source, this.cursor],
+      ([sourceSnapshot, cursor]) => {
+        const entries = sourceSnapshot.value.entries;
+        const start = Math.max(0, Math.trunc(cursor ?? 0));
+        return entries.slice(start);
+      },
+      {
+        name: "available",
+        describeKind: "derived",
+        meta: messagingMeta("subscription_available"),
+        initial: []
+      }
+    );
+    this.add("available", this.available);
+    this.connect("topic::events", "source");
+    this.connect("source", "available");
+    this.connect("cursor", "available");
+    this._keepaliveDisposers.push(keepalive2(this.source));
+    this._keepaliveDisposers.push(keepalive2(this.available));
+  }
+  destroy() {
+    for (const dispose of this._keepaliveDisposers) dispose();
+    this._keepaliveDisposers.length = 0;
+    super.destroy();
+  }
+  ack(count) {
+    const available = this.available.get();
+    const requested = count === void 0 ? available.length : requireNonNegativeInt(count, "subscription ack count");
+    const step = Math.min(requested, available.length);
+    if (step <= 0) return this.cursor.get();
+    const next = this.cursor.get() + step;
+    this.cursor.down([[DATA, next]]);
+    return next;
+  }
+  pull(limit, opts = {}) {
+    const available = this.available.get();
+    const max = limit === void 0 ? available.length : requireNonNegativeInt(limit, "subscription pull limit");
+    const out = available.slice(0, max);
+    if (opts.ack && out.length > 0) this.ack(out.length);
+    return out;
+  }
+};
+var JobQueueGraph = class extends Graph {
+  _pending;
+  _jobs;
+  _keepaliveDisposers = [];
+  _seq = 0;
+  pending;
+  jobs;
+  depth;
+  constructor(name, opts = {}) {
+    super(name, opts.graph);
+    this._pending = reactiveList([], { name: "pending" });
+    this._jobs = reactiveMap({ name: "jobs" });
+    this.pending = this._pending.items;
+    this.jobs = this._jobs.node;
+    this.add("pending", this.pending);
+    this.add("jobs", this.jobs);
+    this.depth = derived(
+      [this.pending],
+      ([snapshot]) => snapshot.value.items.length,
+      {
+        name: "depth",
+        describeKind: "derived",
+        meta: messagingMeta("queue_depth"),
+        initial: 0
+      }
+    );
+    this.add("depth", this.depth);
+    this.connect("pending", "depth");
+    this._keepaliveDisposers.push(keepalive2(this.depth));
+  }
+  destroy() {
+    for (const dispose of this._keepaliveDisposers) dispose();
+    this._keepaliveDisposers.length = 0;
+    super.destroy();
+  }
+  enqueue(payload, opts = {}) {
+    const id = opts.id ?? `${this.name}-${++this._seq}`;
+    if (this._jobs.get(id) !== void 0) {
+      throw new Error(`jobQueue("${this.name}"): duplicate job id "${id}"`);
+    }
+    const job = {
+      id,
+      payload,
+      attempts: 0,
+      metadata: Object.freeze({ ...opts.metadata ?? {} }),
+      state: "queued"
+    };
+    this._jobs.set(id, job);
+    this._pending.append(id);
+    return id;
+  }
+  claim(limit = 1) {
+    const max = requireNonNegativeInt(limit, "job queue claim limit");
+    if (max === 0) return [];
+    const out = [];
+    while (out.length < max) {
+      const snapshot = this.pending.get();
+      const ids = snapshot.value.items;
+      if (ids.length === 0) break;
+      const id = this._pending.pop(0);
+      const job = this._jobs.get(id);
+      if (!job || job.state !== "queued") continue;
+      const inflight = {
+        ...job,
+        state: "inflight",
+        attempts: job.attempts + 1
+      };
+      this._jobs.set(id, inflight);
+      out.push(inflight);
+    }
+    return out;
+  }
+  ack(id) {
+    const job = this._jobs.get(id);
+    if (!job || job.state !== "inflight") return false;
+    this._jobs.delete(id);
+    return true;
+  }
+  nack(id, opts = {}) {
+    const job = this._jobs.get(id);
+    if (!job || job.state !== "inflight") return false;
+    if (opts.requeue ?? true) {
+      this._jobs.set(id, { ...job, state: "queued" });
+      this._pending.append(id);
+      return true;
+    }
+    this._jobs.delete(id);
+    return true;
+  }
+};
+var JobFlowGraph = class extends Graph {
+  _stageNames;
+  _queues = /* @__PURE__ */ new Map();
+  _keepaliveDisposers = [];
+  _completed;
+  completed;
+  completedCount;
+  constructor(name, opts = {}) {
+    super(name, opts.graph);
+    const stages = (opts.stages ?? ["incoming", "processing", "done"]).map((v) => v.trim());
+    if (stages.length < 2) {
+      throw new Error(`jobFlow("${name}"): requires at least 2 stages`);
+    }
+    const unique = new Set(stages);
+    if (unique.size !== stages.length) {
+      throw new Error(`jobFlow("${name}"): stage names must be unique`);
+    }
+    this._stageNames = Object.freeze([...stages]);
+    for (const stage of this._stageNames) {
+      const q = jobQueue(`${name}-${stage}`);
+      this._queues.set(stage, q);
+      this.mount(stage, q);
+    }
+    this._completed = reactiveLog([], { name: "completed" });
+    this.completed = this._completed.entries;
+    this.add("completed", this.completed);
+    this.completedCount = derived(
+      [this.completed],
+      ([snapshot]) => snapshot.value.entries.length,
+      {
+        name: "completedCount",
+        describeKind: "derived",
+        meta: messagingMeta("job_flow_completed_count"),
+        initial: 0
+      }
+    );
+    this.add("completedCount", this.completedCount);
+    this.connect("completed", "completedCount");
+    this._keepaliveDisposers.push(keepalive2(this.completedCount));
+    const maxPerPump = Math.max(
+      1,
+      requireNonNegativeInt(opts.maxPerPump ?? DEFAULT_MAX_PER_PUMP, "job flow maxPerPump")
+    );
+    for (let i = 0; i < this._stageNames.length; i += 1) {
+      const stage = this._stageNames[i];
+      const current = this.queue(stage);
+      const next = i + 1 < this._stageNames.length ? this.queue(this._stageNames[i + 1]) : null;
+      const pump = node(
+        [current.pending],
+        () => {
+          let moved = 0;
+          while (moved < maxPerPump) {
+            const claim = current.claim(1);
+            if (claim.length === 0) break;
+            const job = claim[0];
+            if (!job) break;
+            if (next) {
+              next.enqueue(job.payload, {
+                metadata: {
+                  ...job.metadata,
+                  job_flow_from: stage
+                }
+              });
+            } else {
+              this._completed.append(job);
+            }
+            current.ack(job.id);
+            moved += 1;
+          }
+        },
+        {
+          name: `pump_${stage}`,
+          describeKind: "effect",
+          meta: messagingMeta("job_flow_pump")
+        }
+      );
+      this.add(`pump_${stage}`, pump);
+      this.connect(`${stage}::pending`, `pump_${stage}`);
+      this._keepaliveDisposers.push(keepalive2(pump));
+    }
+  }
+  destroy() {
+    for (const dispose of this._keepaliveDisposers) dispose();
+    this._keepaliveDisposers.length = 0;
+    super.destroy();
+  }
+  stages() {
+    return this._stageNames;
+  }
+  queue(stage) {
+    const q = this._queues.get(stage);
+    if (!q) throw new Error(`jobFlow("${this.name}"): unknown stage "${stage}"`);
+    return q;
+  }
+  enqueue(payload, opts = {}) {
+    return this.queue(this._stageNames[0]).enqueue(payload, opts);
+  }
+  retainedCompleted() {
+    const snapshot = this.completed.get();
+    return snapshot.value.entries;
+  }
+};
+var TopicBridgeGraph = class extends Graph {
+  _sourceSub;
+  _target;
+  _keepaliveDisposers = [];
+  bridgedCount;
+  constructor(name, sourceTopic, targetTopic, opts = {}) {
+    super(name, opts.graph);
+    this._sourceSub = subscription(`${name}-subscription`, sourceTopic, {
+      cursor: opts.cursor
+    });
+    this._target = targetTopic;
+    this.mount("subscription", this._sourceSub);
+    this.bridgedCount = state(0, {
+      name: "bridgedCount",
+      describeKind: "state",
+      meta: messagingMeta("topic_bridge_count")
+    });
+    this.add("bridgedCount", this.bridgedCount);
+    const maxPerPump = Math.max(
+      1,
+      requireNonNegativeInt(opts.maxPerPump ?? DEFAULT_MAX_PER_PUMP, "topic bridge maxPerPump")
+    );
+    const mapValue = opts.map ?? ((value) => value);
+    const pump = node(
+      [this._sourceSub.available],
+      () => {
+        const available = this._sourceSub.pull(maxPerPump, { ack: true });
+        if (available.length === 0) return;
+        let bridged = 0;
+        for (const value of available) {
+          const mapped = mapValue(value);
+          if (mapped === void 0) continue;
+          this._target.publish(mapped);
+          bridged += 1;
+        }
+        if (bridged > 0) {
+          const current = this.bridgedCount.get();
+          this.bridgedCount.down([[DATA, current + bridged]]);
+        }
+      },
+      {
+        name: "pump",
+        describeKind: "effect",
+        meta: messagingMeta("topic_bridge_pump")
+      }
+    );
+    this.add("pump", pump);
+    this.connect("subscription::available", "pump");
+    this._keepaliveDisposers.push(keepalive2(pump));
+  }
+  destroy() {
+    for (const dispose of this._keepaliveDisposers) dispose();
+    this._keepaliveDisposers.length = 0;
+    super.destroy();
+  }
+};
+function topic(name, opts) {
+  return new TopicGraph(name, opts);
+}
+function subscription(name, topicGraph, opts) {
+  return new SubscriptionGraph(name, topicGraph, opts);
+}
+function jobQueue(name, opts) {
+  return new JobQueueGraph(name, opts);
+}
+function jobFlow(name, opts) {
+  return new JobFlowGraph(name, opts);
+}
+function topicBridge(name, sourceTopic, targetTopic, opts) {
+  return new TopicBridgeGraph(name, sourceTopic, targetTopic, opts);
+}
+
+// src/patterns/orchestration.ts
+var orchestration_exports = {};
+__export(orchestration_exports, {
+  approval: () => approval,
+  branch: () => branch,
+  forEach: () => forEach2,
+  gate: () => gate2,
+  join: () => join,
+  loop: () => loop,
+  onFailure: () => onFailure,
+  pipeline: () => pipeline,
+  sensor: () => sensor,
+  subPipeline: () => subPipeline,
+  task: () => task,
+  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);
+  for (const path of depPaths) {
+    graph.connect(path, name);
+  }
+}
+function baseMeta(kind, meta) {
+  return {
+    orchestration: true,
+    orchestration_type: 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 step = node(
+    deps.map((d) => d.node),
+    run,
+    {
+      ...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 = node(
+    [src.node],
+    ([value]) => ({
+      branch: predicate(value) ? "then" : "else",
+      value
+    }),
+    {
+      ...opts,
+      name,
+      describeKind: "derived",
+      meta: baseMeta("branch", opts?.meta)
+    }
+  );
+  registerStep(graph, name, step, src.path ? [src.path] : []);
+  return step;
+}
+function gate2(graph, name, source, control, opts) {
+  const src = resolveDep(graph, source);
+  const ctrl = resolveDep(graph, control);
+  const step = node(
+    [src.node, ctrl.node],
+    (_deps, actions) => {
+      const opened = ctrl.node.get();
+      if (!opened) {
+        actions.down([[RESOLVED]]);
+        return void 0;
+      }
+      return src.node.get();
+    },
+    {
+      ...opts,
+      name,
+      describeKind: "operator",
+      meta: baseMeta("gate", 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],
+    (_deps, actions) => {
+      if (!isApproved(ctrl.node.get())) {
+        actions.down([[RESOLVED]]);
+        return void 0;
+      }
+      return src.node.get();
+    },
+    {
+      ...opts,
+      name,
+      describeKind: "operator",
+      meta: baseMeta("approval", opts?.meta)
+    }
+  );
+  registerStep(
+    graph,
+    name,
+    step,
+    [src.path, ctrl.path].filter((v) => typeof v === "string")
+  );
+  return step;
+}
+function forEach2(graph, name, source, run, opts) {
+  const src = resolveDep(graph, source);
+  let terminated = false;
+  const step = node([src.node], () => void 0, {
+    ...opts,
+    name,
+    describeKind: "effect",
+    completeWhenDepsComplete: false,
+    meta: baseMeta("forEach", opts?.meta),
+    onMessage(msg, depIndex, actions) {
+      if (terminated) return true;
+      if (depIndex !== 0) {
+        actions.down([msg]);
+        if (msg[0] === COMPLETE || msg[0] === ERROR) terminated = true;
+        return true;
+      }
+      if (msg[0] === DATA) {
+        try {
+          run(msg[1], actions);
+          actions.down([msg]);
+        } catch (err) {
+          terminated = true;
+          actions.down([[ERROR, err]]);
+        }
+        return true;
+      }
+      actions.down([msg]);
+      if (msg[0] === COMPLETE || msg[0] === ERROR) terminated = true;
+      return true;
+    }
+  });
+  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 = node(
+    resolved.map((d) => d.node),
+    (values) => values,
+    {
+      ...opts,
+      name,
+      describeKind: "derived",
+      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],
+    (_deps, actions) => {
+      let current = src.node.get();
+      const rawCount = staticIterations ?? iterDep?.node.get() ?? 1;
+      const count = coerceLoopIterations(rawCount);
+      for (let i = 0; i < count; i += 1) {
+        current = iterate(current, i, actions);
+      }
+      return 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;
+  const step = node(
+    [src.node],
+    () => {
+      for (const id of timers) clearTimeout(id);
+      timers.clear();
+      return () => {
+        for (const id of timers) clearTimeout(id);
+        timers.clear();
+        terminated = true;
+      };
+    },
+    {
+      ...opts,
+      name,
+      initial: src.node.get(),
+      describeKind: "operator",
+      completeWhenDepsComplete: false,
+      meta: baseMeta("wait", opts?.meta),
+      onMessage(msg, depIndex, actions) {
+        if (terminated) return true;
+        if (depIndex !== 0) {
+          actions.down([msg]);
+          if (msg[0] === COMPLETE || msg[0] === ERROR) terminated = true;
+          return true;
+        }
+        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);
+          return true;
+        }
+        if (msg[0] === COMPLETE) {
+          terminated = true;
+          completed = true;
+          if (timers.size === 0) {
+            actions.down([[COMPLETE]]);
+          }
+          return true;
+        }
+        if (msg[0] === ERROR) {
+          terminated = true;
+          for (const id of timers) clearTimeout(id);
+          timers.clear();
+          actions.down([msg]);
+          return true;
+        }
+        actions.down([msg]);
+        return true;
+      }
+    }
+  );
+  registerStep(graph, name, step, src.path ? [src.path] : []);
+  return step;
+}
+function onFailure(graph, name, source, recover, opts) {
+  const src = resolveDep(graph, source);
+  let terminated = false;
+  const step = node([src.node], () => void 0, {
+    ...opts,
+    name,
+    describeKind: "operator",
+    completeWhenDepsComplete: false,
+    meta: baseMeta("onFailure", opts?.meta),
+    onMessage(msg, _depIndex, actions) {
+      if (terminated) return true;
+      if (msg[0] === ERROR) {
+        try {
+          actions.emit(recover(msg[1], actions));
+        } catch (err) {
+          terminated = true;
+          actions.down([[ERROR, err]]);
+        }
+        return true;
+      }
+      actions.down([msg]);
+      if (msg[0] === COMPLETE) terminated = true;
+      return true;
+    }
+  });
+  registerStep(graph, name, step, src.path ? [src.path] : []);
+  return step;
+}
+
+// src/index.ts
+var version = "0.0.0";
+export {
+  COMPLETE,
+  CircuitOpenError,
+  DATA,
+  DEFAULT_ACTOR,
+  DIRTY,
+  DictCheckpointAdapter,
+  DynamicNodeImpl,
+  ERROR,
+  FileCheckpointAdapter,
+  GRAPH_META_SEGMENT,
+  Graph,
+  GuardDenied,
+  INVALIDATE,
+  JsonCodec,
+  MemoryCheckpointAdapter,
+  NS_PER_MS,
+  NS_PER_SEC,
+  PAUSE,
+  RESOLVED,
+  RESUME,
+  SqliteCheckpointAdapter,
+  TEARDOWN,
+  accessHintForGuard,
+  advanceVersion,
+  ai_exports as ai,
+  audit,
+  batch,
+  buffer,
+  bufferCount,
+  bufferTime,
+  cached,
+  catchError,
+  checkpointNodeValue,
+  circuitBreaker,
+  combine,
+  combineLatest,
+  compat_exports as compat,
+  concat,
+  concatMap,
+  constant,
+  core_exports as core,
+  cqrs_exports as cqrs,
+  createDagCborCodec,
+  createDagCborZstdCodec,
+  createTransport,
+  createVersioning,
+  createWatermarkController,
+  debounce,
+  debounceTime,
+  decorrelatedJitter,
+  defaultHash,
+  delay,
+  derived,
+  describeNode,
+  deserializeError,
+  distill,
+  distinctUntilChanged,
+  dynamicNode,
+  effect,
+  elementAt,
+  emitWithBatch,
+  empty,
+  escapeRegexChar,
+  exhaustMap,
+  exponential,
+  extra_exports as extra,
+  fibonacci,
+  filter,
+  find,
+  first,
+  firstValueFrom,
+  flatMap,
+  forEach,
+  fromAny,
+  fromAsyncIter,
+  fromCSV,
+  fromClickHouseWatch,
+  fromCron,
+  fromEvent,
+  fromFSWatch,
+  fromGitHook,
+  fromHTTP,
+  fromIDBRequest,
+  fromIDBTransaction,
+  fromIter,
+  fromKafka,
+  fromMCP,
+  fromNDJSON,
+  fromOTel,
+  fromPrometheus,
+  fromPromise,
+  fromRedisStream,
+  fromStatsD,
+  fromSyslog,
+  fromTimer,
+  fromWebSocket,
+  fromWebhook,
+  gate,
+  globToRegExp,
+  graph_exports as graph,
+  interval,
+  isBatching,
+  isKnownMessageType,
+  isPhase2Message,
+  isTerminalMessage,
+  isV1,
+  jotai_exports as jotai,
+  knownMessageTypes,
+  last,
+  reactive_layout_exports as layout,
+  linear,
+  logSlice,
+  map,
+  matchesAnyPattern,
+  matchesCron,
+  memory_exports as memory,
+  merge,
+  mergeMap,
+  messageTier,
+  messaging_exports as messaging,
+  metaSnapshot,
+  monotonicNs,
+  nameToSignal,
+  nanostores_exports as nanostores,
+  negotiateCodec,
+  nestjs_exports as nestjs,
+  never,
+  node,
+  normalizeActor,
+  observeGraph$,
+  observeNode$,
+  of,
+  orchestration_exports as orchestration,
+  pairwise,
+  parseCron,
+  parsePrometheusText,
+  parseStatsD,
+  parseSyslog,
+  partitionForBatch,
+  patterns_exports as patterns,
+  pausable,
+  pipe,
+  policy,
+  policyFromRules,
+  producer,
+  propagatesToMeta,
+  pubsub,
+  race,
+  rateLimiter,
+  reachable,
+  react_exports as react,
+  reactiveIndex,
+  reactiveList,
+  reactiveLog,
+  reactiveMap,
+  reduce,
+  repeat,
+  replay,
+  replayWAL,
+  rescue,
+  resolveBackoffPreset,
+  restoreGraphCheckpoint,
+  restoreGraphCheckpointIndexedDb,
+  retry,
+  sample,
+  saveGraphCheckpoint,
+  saveGraphCheckpointIndexedDb,
+  scan,
+  serializeError,
+  share,
+  shareReplay,
+  signalToName,
+  signals_exports as signals,
+  skip,
+  solid_exports as solid,
+  startWith,
+  state,
+  svelte_exports as svelte,
+  switchMap,
+  take,
+  takeUntil,
+  takeWhile,
+  tap,
+  throttle,
+  throttleTime,
+  throwError,
+  timeout,
+  toArray,
+  toKafka,
+  toMessages$,
+  toObservable,
+  toRedisStream,
+  toSSE,
+  toWebSocket,
+  tokenBucket,
+  tokenTracker,
+  verifiable,
+  version,
+  vue_exports as vue,
+  wallClockNs,
+  window,
+  windowCount,
+  windowTime,
+  withBreaker,
+  withLatestFrom,
+  withMaxAttempts,
+  withStatus,
+  workerBridge,
+  workerSelf,
+  zip,
+  zustand_exports as zustand
+};
+//# sourceMappingURL=index.js.map