@graphrefly/graphrefly 0.21.0 → 0.23.0

package/dist/index.js

@@ -1,20 +1,19 @@
 import {
   CircuitOpenError,
-  DictCheckpointAdapter,
-  FileCheckpointAdapter,
-  MemoryCheckpointAdapter,
   NS_PER_MS,
   NS_PER_SEC,
-  SqliteCheckpointAdapter,
+  NativeIndexBackend,
+  NativeListBackend,
+  NativeMapBackend,
+  NativePubSubBackend,
+  RateLimiterOverflowError,
   TimeoutError,
   audit,
   buffer,
   bufferCount,
   bufferTime,
-  cache,
   cascadingCache,
   catchError,
-  checkpointNodeValue,
   checkpointToRedis,
   checkpointToS3,
   circuitBreaker,
@@ -24,19 +23,24 @@ import {
   concatMap,
   constant,
   createTransport,
+  csvRows,
   debounce,
   debounceTime,
   decorrelatedJitter,
   delay,
   deserializeError,
+  dictStorage,
   distill,
   distinctUntilChanged,
   elementAt,
   exhaustMap,
   exponential,
+  externalBundle,
+  externalProducer,
   extra_exports,
   fallback,
   fibonacci,
+  fileStorage,
   filter,
   find,
   first,
@@ -46,6 +50,8 @@ import {
   fromDrizzle,
   fromGitHook,
   fromHTTP,
+  fromHTTPPoll,
+  fromHTTPStream,
   fromIDBRequest,
   fromIDBTransaction,
   fromKafka,
@@ -59,19 +65,25 @@ import {
   fromPulsar,
   fromRabbitMQ,
   fromRedisStream,
+  fromSSE,
   fromSqlite,
+  fromSqliteCursor,
   fromStatsD,
   fromSyslog,
   fromWebSocket,
+  fromWebSocketReconnect,
   fromWebhook,
+  indexedDbStorage,
   interval,
   last,
   linear,
   lru,
   map,
+  memoryStorage,
   merge,
   mergeMap,
   nameToSignal,
+  ndjsonRows,
   pairwise,
   parsePrometheusText,
   parseStatsD,
@@ -83,20 +95,19 @@ import {
   reactiveIndex,
   reactiveList,
   reactiveMap,
+  reactiveSink,
   reduce,
   repeat,
   rescue,
   resolveBackoffPreset,
-  restoreGraphCheckpoint,
-  restoreGraphCheckpointIndexedDb,
   retry,
+  retrySource,
   sample,
-  saveGraphCheckpoint,
-  saveGraphCheckpointIndexedDb,
   scan,
   serializeError,
   signalToName,
   skip,
+  sqliteStorage,
   switchMap,
   take,
   takeUntil,
@@ -104,11 +115,11 @@ import {
   tap,
   throttle,
   throttleTime,
-  tieredStorage,
   timeout,
   toCSV,
   toClickHouse,
   toFile,
+  toHTTP,
   toKafka,
   toLoki,
   toMongo,
@@ -116,14 +127,15 @@ import {
   toPostgres,
   toPulsar,
   toRabbitMQ,
+  toReadableStream,
   toRedisStream,
   toS3,
   toSSE,
+  toSSEBytes,
   toSqlite,
   toTempo,
   toWebSocket,
   tokenBucket,
-  tokenTracker,
   valve,
   verifiable,
   window,
@@ -136,29 +148,35 @@ import {
   workerBridge,
   workerSelf,
   zip
-} from "./chunk-ECN37NVS.js";
+} from "./chunk-XTLYW4FR.js";
 import {
   cqrs_exports,
-  domainMeta,
-  nestjs_exports,
-  trackingKey
-} from "./chunk-XWBVAO2R.js";
-import {
-  JsonCodec,
-  createDagCborCodec,
-  createDagCborZstdCodec,
-  graph_exports,
-  negotiateCodec,
-  replayWAL
-} from "./chunk-G66H6ZRK.js";
+  nestjs_exports
+} from "./chunk-PNUZM7PC.js";
 import {
-  DEFAULT_DOWN,
-  bridge,
   core_exports
-} from "./chunk-DOSLSFKL.js";
+} from "./chunk-263BEJJO.js";
 import {
-  cached,
+  NativeLogBackend,
   createWatermarkController,
+  reactiveLog,
+  toObservable
+} from "./chunk-JFONSPNF.js";
+import {
+  graph_exports
+} from "./chunk-2GQLMQVJ.js";
+import {
+  analyzeAndMeasure,
+  computeLineBreaks,
+  reactive_layout_exports
+} from "./chunk-PX6PDUJ5.js";
+import {
+  domainMeta,
+  trackingKey,
+  tryIncrementBounded
+} from "./chunk-32N5A454.js";
+import {
+  cached,
   empty,
   escapeRegexChar,
   firstValueFrom,
@@ -174,86 +192,95 @@ import {
   fromTimer,
   globToRegExp,
   keepalive,
-  logSlice,
   matchesAnyPattern,
   matchesCron,
   never,
   of,
   parseCron,
   reactiveCounter,
-  reactiveLog,
   replay,
   share,
   shareReplay,
   throwError,
-  toArray,
-  toObservable
-} from "./chunk-VOQFK7YN.js";
-import {
-  ResettableTimer
-} from "./chunk-WZ2Z2CRV.js";
-import {
-  analyzeAndMeasure,
-  computeLineBreaks,
-  reactive_layout_exports
-} from "./chunk-ZTCDY5NQ.js";
+  toArray
+} from "./chunk-CWYPA63G.js";
 import {
   GRAPH_META_SEGMENT,
   Graph,
+  OVERHEAD,
+  SIZEOF_SYMBOL,
+  diffForWAL,
   graphProfile,
   reachable,
   sizeof
-} from "./chunk-2UDLYZHT.js";
+} from "./chunk-XRFJJ2IU.js";
 import {
   describeNode,
   resolveDescribeFields
-} from "./chunk-7IGHIFTT.js";
+} from "./chunk-HVBX5KIW.js";
+import {
+  ResettableTimer
+} from "./chunk-7TAQJHQV.js";
 import {
-  CLEANUP_RESULT,
   COMPLETE,
+  COMPLETE_MSG,
+  COMPLETE_ONLY_BATCH,
   DATA,
   DEFAULT_ACTOR,
   DIRTY,
-  DynamicNodeImpl,
+  DIRTY_MSG,
+  DIRTY_ONLY_BATCH,
+  ENVELOPE_VERSION,
   ERROR,
+  GraphReFlyConfig,
   GuardDenied,
   INVALIDATE,
+  INVALIDATE_MSG,
+  INVALIDATE_ONLY_BATCH,
+  JsonCodec,
+  NodeImpl,
   PAUSE,
   RESOLVED,
+  RESOLVED_MSG,
+  RESOLVED_ONLY_BATCH,
   RESUME,
   START,
+  START_MSG,
   TEARDOWN,
+  TEARDOWN_MSG,
+  TEARDOWN_ONLY_BATCH,
   __export,
   accessHintForGuard,
   advanceVersion,
+  autoTrackNode,
   batch,
-  cleanupResult,
+  configure,
+  createDagCborCodec,
+  createDagCborZstdCodec,
   createVersioning,
+  decodeEnvelope,
+  defaultConfig,
   defaultHash,
   derived,
   downWithBatch,
   dynamicNode,
   effect,
+  encodeEnvelope,
   isBatching,
-  isKnownMessageType,
-  isLocalOnly,
-  isPhase2Message,
-  isTerminalMessage,
   isV1,
-  knownMessageTypes,
-  messageTier,
   monotonicNs,
   node,
   normalizeActor,
-  partitionForBatch,
   pipe,
   policy,
   policyFromRules,
   producer,
-  propagatesToMeta,
+  registerBuiltinCodecs,
+  registerBuiltins,
+  replayWAL,
   state,
   wallClockNs
-} from "./chunk-4MQ2J6IG.js";
+} from "./chunk-NZMBRXQV.js";
 
 // src/compat/index.ts
 var compat_exports = {};
@@ -285,7 +312,7 @@ function atom(initialOrRead, writeOrOptions, options) {
   return createPrimitiveAtom(initialOrRead, writeOrOptions);
 }
 function pull(n) {
-  let val = n.get();
+  let val = n.cache;
   let err;
   const unsub = n.subscribe((msgs) => {
     for (const [t, v] of msgs) {
@@ -305,15 +332,19 @@ function createPrimitiveAtom(initial, options) {
   });
   return {
     get: () => {
-      if (n.status === "disconnected") {
+      if (n.status === "sentinel") {
         return pull(n);
       }
-      return n.get();
+      return n.cache;
     },
-    set: (value) => n.down([[DATA, value]]),
+    // Use `n.emit` (not raw `n.down`) so writes go through the framed
+    // emit pipeline: bundle() auto-prefixes DIRTY (diamond-safe wave
+    // coordination) and the equals check folds same-value writes to
+    // RESOLVED (no spurious subscriber fires).
+    set: (value) => n.emit(value),
     update: (fn) => {
-      const current = n.status === "disconnected" ? pull(n) : n.get();
-      n.down([[DATA, fn(current)]]);
+      const current = n.status === "sentinel" ? pull(n) : n.cache;
+      n.emit(fn(current));
     },
     subscribe: (cb) => {
       let initial2 = true;
@@ -334,13 +365,13 @@ function createPrimitiveAtom(initial, options) {
   };
 }
 function createDerivedAtom(read, write, options) {
-  const n = dynamicNode(
-    (get) => read((a) => {
+  const n = autoTrackNode(
+    (track) => read((a) => {
       const dn = a._node;
-      if (dn.status === "disconnected") {
+      if (dn.status === "sentinel") {
         pull(dn);
       }
-      return get(dn);
+      return track(dn);
     }),
     {
       ...options,
@@ -350,10 +381,10 @@ function createDerivedAtom(read, write, options) {
   );
   const result = {
     get: () => {
-      if (n.status === "disconnected") {
+      if (n.status === "sentinel") {
         return pull(n);
       }
-      return n.get();
+      return n.cache;
     },
     subscribe: (cb) => {
       let initial = true;
@@ -378,7 +409,7 @@ function createDerivedAtom(read, write, options) {
     const writable = result;
     writable.set = (value) => write(getFn, setFn, value);
     writable.update = (fn) => {
-      const current = n.status === "disconnected" ? pull(n) : n.get();
+      const current = n.status === "sentinel" ? pull(n) : n.cache;
       return write(getFn, setFn, fn(current));
     };
     return writable;
@@ -451,7 +482,7 @@ function createStore(node2, extra = {}) {
   return store;
 }
 function pull2(n) {
-  let val = n.get();
+  let val = n.cache;
   let err;
   const unsub = n.subscribe((msgs) => {
     for (const [t, v] of msgs) {
@@ -464,10 +495,10 @@ function pull2(n) {
   return val;
 }
 function getVal(n) {
-  if (n.status === "disconnected") {
+  if (n.status === "sentinel") {
     return pull2(n);
   }
-  return n.get();
+  return n.cache;
 }
 function atom2(initial) {
   const n = state(initial, {
@@ -475,19 +506,26 @@ function atom2(initial) {
     resetOnTeardown: true
   });
   return createStore(n, {
-    set: (value) => n.down([[DATA, value]])
+    // `n.emit` routes through the framed pipeline: `bundle()` auto-
+    // prefixes `[DIRTY]` (diamond-safe wave coordination) and the
+    // node's `equals` (default `Object.is`) folds same-value writes
+    // into `RESOLVED`. Matches nanostores' documented Object.is
+    // dedup semantics without any custom check.
+    set: (value) => n.emit(value)
   });
 }
 function computed(stores, fn) {
   const storeArray = Array.isArray(stores) ? stores : [stores];
+  const depNodes = storeArray.map((s) => s._node);
   const n = dynamicNode(
-    (get) => {
+    depNodes,
+    (track) => {
       const vals = storeArray.map((s) => {
         const node2 = s._node;
-        if (node2.status === "disconnected") {
+        if (node2.status === "sentinel") {
           pull2(node2);
         }
-        return get(node2);
+        return track(node2);
       });
       return fn(...vals);
     },
@@ -506,10 +544,14 @@ function map2(initial) {
     equals: () => false
   });
   return createStore(n, {
-    set: (value) => n.down([[DATA, value]]),
+    // `map`'s state node is configured with `equals: () => false`
+    // above, so every `emit` produces DATA (even for same-key same-
+    // value sets). The `emit` path is still required for diamond
+    // coordination (`[DIRTY]` auto-prefix via `bundle()`).
+    set: (value) => n.emit(value),
     setKey: (key, value) => {
       const current = getVal(n);
-      n.down([[DATA, { ...current, [key]: value }]]);
+      n.emit({ ...current, [key]: value });
     }
   });
 }
@@ -570,8 +612,8 @@ function useSubscribe(node2) {
         unsub();
       };
     },
-    () => node2.get(),
-    () => node2.get()
+    () => node2.cache,
+    () => node2.cache
     // Server snapshot
   );
 }
@@ -591,12 +633,12 @@ function useSubscribeRecord(keysNode, factory) {
   const store = useMemo(() => {
     const computeSnap = () => {
       const snap = {};
-      const keys = keysNode.get() ?? [];
+      const keys = keysNode.cache ?? [];
       for (const key of keys) {
         const nodes = factoryRef.current(key);
         const values = {};
         for (const field of Object.keys(nodes)) {
-          values[field] = nodes[field].get();
+          values[field] = nodes[field].cache;
         }
         snap[key] = values;
       }
@@ -627,10 +669,10 @@ function useSubscribeRecord(keysNode, factory) {
           if (!disposed) onStoreChange();
         };
         const keysUnsub = keysNode.subscribe((msgs) => {
-          const hasSettled = msgs.some((m) => messageTier(m[0]) >= 3);
-          if (!disposed && hasSettled) sync(keysNode.get() ?? []);
+          const hasSettled = msgs.some((m) => m[0] === DATA || m[0] === RESOLVED);
+          if (!disposed && hasSettled) sync(keysNode.cache ?? []);
         });
-        sync(keysNode.get() ?? []);
+        sync(keysNode.cache ?? []);
         return () => {
           disposed = true;
           keysUnsub();
@@ -650,7 +692,7 @@ __export(signals_exports, {
 });
 var trackingStack = [];
 function pull3(n) {
-  let val = n.get();
+  let val = n.cache;
   const unsub = n.subscribe((msgs) => {
     for (const [t, v] of msgs) {
       if (t === DATA) val = v;
@@ -674,15 +716,15 @@ var SignalState = class {
   get() {
     const tracker = trackingStack[trackingStack.length - 1];
     if (tracker) {
-      if (this._node.status === "disconnected") {
+      if (this._node.status === "sentinel") {
         pull3(this._node);
       }
       return tracker(this._node);
     }
-    if (this._node.status === "disconnected") {
+    if (this._node.status === "sentinel") {
       return pull3(this._node);
     }
-    return this._node.get();
+    return this._node.cache;
   }
   set(value) {
     if (this._equals(this.get(), value)) return;
@@ -695,9 +737,9 @@ var SignalComputed = class {
   /** @internal */
   _node;
   constructor(computation, opts) {
-    this._node = dynamicNode(
-      (get) => {
-        trackingStack.push(get);
+    this._node = autoTrackNode(
+      (track) => {
+        trackingStack.push(track);
         try {
           return computation();
         } finally {
@@ -715,15 +757,15 @@ var SignalComputed = class {
   get() {
     const tracker = trackingStack[trackingStack.length - 1];
     if (tracker) {
-      if (this._node.status === "disconnected") {
+      if (this._node.status === "sentinel") {
         pull3(this._node);
       }
       return tracker(this._node);
     }
-    if (this._node.status === "disconnected") {
+    if (this._node.status === "sentinel") {
       return pull3(this._node);
     }
-    return this._node.get();
+    return this._node.cache;
   }
 };
 var Signal = {
@@ -767,9 +809,9 @@ __export(solid_exports, {
 });
 import { createSignal, getOwner, onCleanup } from "solid-js";
 function useSubscribe2(node2) {
-  const [value, setValue] = createSignal(node2.get(), { equals: false });
+  const [value, setValue] = createSignal(node2.cache, { equals: false });
   const unsub = node2.subscribe(() => {
-    setValue(() => node2.get());
+    setValue(() => node2.cache);
   });
   if (getOwner()) {
     onCleanup(() => unsub());
@@ -796,11 +838,11 @@ function useSubscribeRecord2(keysNode, factory) {
   };
   const buildSnapshot = () => {
     const snap = {};
-    for (const key of keysNode.get() ?? []) {
+    for (const key of keysNode.cache ?? []) {
       const nodes = factory(key);
       const values = {};
       for (const field of Object.keys(nodes)) {
-        values[field] = nodes[field].get();
+        values[field] = nodes[field].cache;
       }
       snap[key] = values;
     }
@@ -820,11 +862,11 @@ function useSubscribeRecord2(keysNode, factory) {
     setValue(() => buildSnapshot());
   };
   const keysUnsub = keysNode.subscribe((msgs) => {
-    if (msgs.some((m) => messageTier(m[0]) >= 3)) {
-      sync(keysNode.get() ?? []);
+    if (msgs.some((m) => m[0] === DATA || m[0] === RESOLVED)) {
+      sync(keysNode.cache ?? []);
     }
   });
-  sync(keysNode.get() ?? []);
+  sync(keysNode.cache ?? []);
   if (getOwner()) {
     onCleanup(() => {
       keysUnsub();
@@ -849,9 +891,9 @@ function useSubscribe3(node2) {
   return {
     subscribe(run) {
       const unsub = node2.subscribe(() => {
-        run(node2.get());
+        run(node2.cache);
       });
-      run(node2.get());
+      run(node2.cache);
       return unsub;
     }
   };
@@ -860,16 +902,16 @@ function useStore3(node2) {
   return {
     subscribe(run) {
       const unsub = node2.subscribe(() => {
-        run(node2.get());
+        run(node2.cache);
       });
-      run(node2.get());
+      run(node2.cache);
       return unsub;
     },
     set(value) {
       node2.down([[DIRTY], [DATA, value]]);
     },
     update(updater) {
-      const next = updater(node2.get());
+      const next = updater(node2.cache);
       node2.down([[DIRTY], [DATA, next]]);
     }
   };
@@ -884,11 +926,11 @@ function useSubscribeRecord3(keysNode, factory) {
       };
       const buildSnapshot = () => {
         const snap = {};
-        for (const key of keysNode.get() ?? []) {
+        for (const key of keysNode.cache ?? []) {
           const nodes = factory(key);
           const values = {};
           for (const field of Object.keys(nodes)) {
-            values[field] = nodes[field].get();
+            values[field] = nodes[field].cache;
           }
           snap[key] = values;
         }
@@ -908,11 +950,11 @@ function useSubscribeRecord3(keysNode, factory) {
         run(buildSnapshot());
       };
       const keysUnsub = keysNode.subscribe((msgs) => {
-        if (msgs.some((m) => messageTier(m[0]) >= 3)) {
-          sync(keysNode.get() ?? []);
+        if (msgs.some((m) => m[0] === DATA || m[0] === RESOLVED)) {
+          sync(keysNode.cache ?? []);
         }
       });
-      sync(keysNode.get() ?? []);
+      sync(keysNode.cache ?? []);
       return () => {
         keysUnsub();
         cleanupEntries();
@@ -938,9 +980,9 @@ import {
   watch
 } from "vue";
 function useSubscribe4(node2) {
-  const ref = shallowRef(node2.get());
+  const ref = shallowRef(node2.cache);
   const unsub = node2.subscribe(() => {
-    ref.value = node2.get();
+    ref.value = node2.cache;
   });
   if (getCurrentScope()) {
     onScopeDispose(() => unsub());
@@ -952,9 +994,9 @@ function useSubscribe4(node2) {
   return readonly(ref);
 }
 function useStore4(node2) {
-  const inner = shallowRef(node2.get());
+  const inner = shallowRef(node2.cache);
   const unsub = node2.subscribe(() => {
-    inner.value = node2.get();
+    inner.value = node2.cache;
   });
   if (getCurrentScope()) {
     onScopeDispose(() => unsub());
@@ -1000,9 +1042,9 @@ function useSubscribeRecord4(keys, factory) {
       const subs = [];
       for (const field of fields) {
         const node2 = nodes[field];
-        values[field] = node2.get();
+        values[field] = node2.cache;
         const unsub = node2.subscribe(() => {
-          values[field] = node2.get();
+          values[field] = node2.cache;
           scheduleBatch();
         });
         subs.push(unsub);
@@ -1041,16 +1083,20 @@ var zustand_exports = {};
 __export(zustand_exports, {
   create: () => create
 });
+var alwaysDiffer = () => false;
 function create(initializer) {
   const g = new Graph("zustand");
-  const s = state(void 0, { name: "state" });
+  const s = state(void 0, {
+    name: "state",
+    equals: alwaysDiffer
+  });
   g.add("state", s);
-  const getState = () => s.get();
+  const getState = () => s.cache;
   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]]);
+    s.emit(nextState);
   };
   const api = {
     getState,
@@ -1075,7 +1121,7 @@ function create(initializer) {
     destroy: g.destroy.bind(g)
   };
   const initialValue = initializer(setState, getState, api);
-  s.down([[DATA, initialValue]]);
+  s.emit(initialValue);
   return Object.assign(g, api);
 }
 
@@ -1151,10 +1197,10 @@ function copyMap(m) {
   return new Map(m);
 }
 function readMap(node2) {
-  return node2.get() ?? /* @__PURE__ */ new Map();
+  return node2.cache ?? /* @__PURE__ */ new Map();
 }
 function readArray(node2) {
-  return node2.get() ?? [];
+  return node2.cache ?? [];
 }
 function cosineSimilarity(a, b) {
   const n = Math.max(a.length, b.length);
@@ -1284,8 +1330,6 @@ function collection(name, opts = {}) {
   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);
@@ -1443,7 +1487,6 @@ function knowledgeGraph(name) {
   graph.add("entities", entities);
   graph.add("edges", edges);
   graph.add("adjacency", adjacency);
-  graph.connect("edges", "adjacency");
   function commitEntities(next) {
     entities.down([[DATA, next]]);
   }
@@ -1507,11 +1550,13 @@ var messaging_exports = {};
 __export(messaging_exports, {
   JobFlowGraph: () => JobFlowGraph,
   JobQueueGraph: () => JobQueueGraph,
+  MessagingHubGraph: () => MessagingHubGraph,
   SubscriptionGraph: () => SubscriptionGraph,
   TopicBridgeGraph: () => TopicBridgeGraph,
   TopicGraph: () => TopicGraph,
   jobFlow: () => jobFlow,
   jobQueue: () => jobQueue,
+  messagingHub: () => messagingHub,
   subscription: () => subscription,
   topic: () => topic,
   topicBridge: () => topicBridge
@@ -1529,7 +1574,24 @@ function messagingMeta(kind, extra) {
 var TopicGraph = class extends Graph {
   _log;
   events;
+  /**
+   * Most recently published value, or `null` when the topic has no entries
+   * yet. Spec §5.12 reserves `undefined` as the protocol-internal "never
+   * sent DATA" sentinel — `null` is the idiomatic "empty / no value" signal
+   * for domain nodes. F7.
+   *
+   * **Caveat when `T` itself includes `null`** (e.g., `topic<number | null>`):
+   * `latest === null` is ambiguous — it could mean "no publish yet" OR "a
+   * `null` value was published". Use {@link hasLatest} to disambiguate, or
+   * observe {@link events} directly and track length yourself.
+   */
   latest;
+  /**
+   * Reactive `true` once the topic has at least one published entry.
+   * Disambiguates "`null` never published" from "`null` was published" when
+   * `T` includes `null`.
+   */
+  hasLatest;
   constructor(name, opts = {}) {
     super(name, opts.graph);
     this._log = reactiveLog([], { name: "events", maxSize: opts.retainedLimit });
@@ -1539,40 +1601,62 @@ var TopicGraph = class extends Graph {
       [this.events],
       ([snapshot]) => {
         const entries = snapshot;
-        return entries.length === 0 ? void 0 : entries[entries.length - 1];
+        return entries.length === 0 ? null : entries[entries.length - 1];
       },
       {
         name: "latest",
         describeKind: "derived",
-        meta: messagingMeta("topic_latest"),
-        initial: void 0
+        meta: messagingMeta("topic_latest")
       }
     );
     this.add("latest", this.latest);
-    this.connect("events", "latest");
     this.addDisposer(keepalive(this.latest));
+    this.hasLatest = derived(
+      [this.events],
+      ([snapshot]) => snapshot.length > 0,
+      {
+        name: "hasLatest",
+        describeKind: "derived",
+        meta: messagingMeta("topic_has_latest")
+      }
+    );
+    this.add("hasLatest", this.hasLatest);
+    this.addDisposer(keepalive(this.hasLatest));
+    this.addDisposer(() => {
+      this.events.down([[COMPLETE]]);
+    });
+    this.addDisposer(() => this._log.disposeAllViews());
   }
   publish(value) {
     this._log.append(value);
   }
   retained() {
-    return this.events.get();
+    return this.events.cache;
   }
 };
 var SubscriptionGraph = class extends Graph {
   source;
   cursor;
   available;
+  /**
+   * Reference to the upstream topic graph. Intentionally NOT mounted
+   * under this subscription: a subscription is a VIEW over an
+   * externally-owned topic. Double-mounting (e.g. hub-owned topic +
+   * sub-mount here) would make either-side teardown leave the other
+   * holding a dead reference. Node-level `derived([topicEvents], …)`
+   * still wires the data dependency across graph boundaries. D1(e).
+   */
+  topic;
   constructor(name, topicGraph, opts = {}) {
     super(name, opts.graph);
     const initialCursor = requireNonNegativeInt(opts.cursor ?? 0, "subscription cursor");
-    this.mount("topic", topicGraph);
+    this.topic = topicGraph;
     const topicEvents = topicGraph.events;
     this.source = derived([topicEvents], ([snapshot]) => snapshot, {
       name: "source",
       describeKind: "derived",
       meta: messagingMeta("subscription_source"),
-      initial: topicEvents.get()
+      initial: topicEvents.cache
     });
     this.add("source", this.source);
     this.cursor = state(initialCursor, {
@@ -1596,23 +1680,20 @@ var SubscriptionGraph = class extends Graph {
       }
     );
     this.add("available", this.available);
-    this.connect("topic::events", "source");
-    this.connect("source", "available");
-    this.connect("cursor", "available");
     this.addDisposer(keepalive(this.source));
     this.addDisposer(keepalive(this.available));
   }
   ack(count) {
-    const available = this.available.get();
+    const available = this.available.cache;
     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]]);
+    if (step <= 0) return this.cursor.cache;
+    const next = this.cursor.cache + step;
+    this.cursor.emit(next);
     return next;
   }
   pull(limit, opts = {}) {
-    const available = this.available.get();
+    const available = this.available.cache;
     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);
@@ -1641,7 +1722,6 @@ var JobQueueGraph = class extends Graph {
       initial: 0
     });
     this.add("depth", this.depth);
-    this.connect("pending", "depth");
     this.addDisposer(keepalive(this.depth));
   }
   enqueue(payload, opts = {}) {
@@ -1665,7 +1745,7 @@ var JobQueueGraph = class extends Graph {
     if (max === 0) return [];
     const out = [];
     while (out.length < max) {
-      const ids = this.pending.get();
+      const ids = this.pending.cache;
       if (ids.length === 0) break;
       const id = this._pending.pop(0);
       const job = this._jobs.get(id);
@@ -1734,7 +1814,6 @@ var JobFlowGraph = class extends Graph {
       }
     );
     this.add("completedCount", this.completedCount);
-    this.connect("completed", "completedCount");
     this.addDisposer(keepalive(this.completedCount));
     const maxPerPump = Math.max(
       1,
@@ -1774,7 +1853,6 @@ var JobFlowGraph = class extends Graph {
         }
       );
       this.add(`pump_${stage}`, pump);
-      this.connect(`${stage}::pending`, `pump_${stage}`);
       this.addDisposer(keepalive(pump));
     }
   }
@@ -1790,7 +1868,7 @@ var JobFlowGraph = class extends Graph {
     return this.queue(this._stageNames[0]).enqueue(payload, opts);
   }
   retainedCompleted() {
-    return this.completed.get();
+    return this.completed.cache;
   }
 };
 var TopicBridgeGraph = class extends Graph {
@@ -1828,7 +1906,7 @@ var TopicBridgeGraph = class extends Graph {
           bridged += 1;
         }
         if (bridged > 0) {
-          const current = this.bridgedCount.get();
+          const current = this.bridgedCount.cache;
           this.bridgedCount.down([[DATA, current + bridged]]);
         }
       },
@@ -1839,13 +1917,112 @@ var TopicBridgeGraph = class extends Graph {
       }
     );
     this.add("pump", pump);
-    this.connect("subscription::available", "pump");
     this.addDisposer(keepalive(pump));
   }
 };
+var MessagingHubGraph = class extends Graph {
+  _topics = /* @__PURE__ */ new Map();
+  _version = 0;
+  _defaultTopicOptions;
+  constructor(name, opts = {}) {
+    super(name, opts.graph);
+    this._defaultTopicOptions = { ...opts.defaultTopicOptions ?? {} };
+  }
+  /** Monotonic counter advancing on topic create/remove. */
+  get version() {
+    return this._version;
+  }
+  /** Number of topics currently in the hub. */
+  get size() {
+    return this._topics.size;
+  }
+  /** Checks topic existence without creating. */
+  has(name) {
+    return this._topics.has(name);
+  }
+  /** Iterator over topic names. */
+  topicNames() {
+    return this._topics.keys();
+  }
+  /**
+   * Returns the {@link TopicGraph} for `name`, creating lazily on first call.
+   * Subsequent calls with the same name return the same instance (options on
+   * repeat calls are ignored — the topic is already configured).
+   */
+  topic(name, opts) {
+    let t = this._topics.get(name);
+    if (t === void 0) {
+      const effective = { ...this._defaultTopicOptions, ...opts ?? {} };
+      t = new TopicGraph(name, effective);
+      this._topics.set(name, t);
+      this.mount(name, t);
+      this._version += 1;
+    }
+    return t;
+  }
+  /**
+   * Publishes a value to the topic, lazily creating it on first publish.
+   *
+   * **Late-subscriber caveat:** the topic is created lazily, so subscribers
+   * that attach AFTER a publish only see the retained window (governed by
+   * `retainedLimit` on `TopicOptions` / `defaultTopicOptions`). If
+   * `retainedLimit === 0` is set explicitly, early publishes are
+   * effectively dropped — prefer an unset `retainedLimit` (unbounded
+   * retention) or subscribe before publishing when late-subscribers matter.
+   */
+  publish(name, value) {
+    this.topic(name).publish(value);
+  }
+  /**
+   * Bulk publish — issues all publishes inside one outer batch. New topics
+   * are created on demand. No-op if `entries` yields nothing.
+   *
+   * **Iterable consumption (F6):** `entries` is consumed once (single-pass)
+   * INSIDE the batch frame. If the iterator throws mid-way, the batch is
+   * discarded and NO publishes are visible to subscribers (all-or-nothing).
+   * Pass an array or `Set` for multi-shot callers.
+   */
+  publishMany(entries) {
+    batch(() => {
+      for (const [name, value] of entries) {
+        this.topic(name).publish(value);
+      }
+    });
+  }
+  /**
+   * Creates a {@link SubscriptionGraph} over a named topic. The topic is
+   * lazily created if missing. Subscription lifecycle is owned by the caller —
+   * the hub does NOT mount the subscription.
+   *
+   * @param subName - Local name for the subscription graph.
+   * @param topicName - Hub topic to subscribe to.
+   * @param opts - `SubscriptionOptions` (initial cursor, etc.).
+   */
+  subscribe(subName, topicName, opts) {
+    const t = this.topic(topicName);
+    return new SubscriptionGraph(subName, t, opts);
+  }
+  /**
+   * Unmounts and tears down the topic's graph. Returns `true` if the topic
+   * existed. Subscribers receive `TEARDOWN` via {@link Graph.remove}.
+   */
+  removeTopic(name) {
+    if (!this._topics.has(name)) return false;
+    try {
+      this.remove(name);
+    } finally {
+      this._topics.delete(name);
+      this._version += 1;
+    }
+    return true;
+  }
+};
 function topic(name, opts) {
   return new TopicGraph(name, opts);
 }
+function messagingHub(name, opts) {
+  return new MessagingHubGraph(name, opts);
+}
 function subscription(name, topicGraph, opts) {
   return new SubscriptionGraph(name, topicGraph, opts);
 }
@@ -1902,9 +2079,7 @@ function findRegisteredNodePath(graph, target) {
 }
 function registerStep(graph, name, step, depPaths) {
   graph.add(name, step);
-  for (const path of depPaths) {
-    graph.connect(path, name);
-  }
+  void depPaths;
 }
 function baseMeta(kind, meta) {
   return domainMeta("orchestration", kind, meta);
@@ -1933,9 +2108,16 @@ function task(graph, name, run, opts) {
   const depRefs = opts?.deps ?? [];
   const deps = depRefs.map((dep) => resolveDep(graph, dep));
   const { deps: _deps, ...nodeOpts } = opts ?? {};
+  const wrapped = (batchData, actions, ctx) => {
+    const data = batchData.map(
+      (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+    );
+    actions.emit(run(data, ctx));
+    return void 0;
+  };
   const step = node(
     deps.map((d) => d.node),
-    run,
+    wrapped,
     {
       ...nodeOpts,
       name,
@@ -1953,7 +2135,7 @@ function task(graph, name, run, opts) {
 }
 function branch(graph, name, source, predicate, opts) {
   const src = resolveDep(graph, source);
-  const step = node(
+  const step = derived(
     [src.node],
     ([value]) => ({
       branch: predicate(value) ? "then" : "else",
@@ -1962,7 +2144,6 @@ function branch(graph, name, source, predicate, opts) {
     {
       ...opts,
       name,
-      describeKind: "derived",
       meta: baseMeta("branch", opts?.meta)
     }
   );
@@ -1974,18 +2155,28 @@ function valve2(graph, name, source, control, opts) {
   const ctrl = resolveDep(graph, control);
   const step = node(
     [src.node, ctrl.node],
-    (_deps, actions) => {
-      const opened = ctrl.node.get();
-      if (!opened) {
+    (batchData, actions, ctx) => {
+      const batch0 = batchData[0];
+      const batch1 = batchData[1];
+      const ctrlVal = batch1 != null && batch1.length > 0 ? batch1.at(-1) : ctx.prevData[1];
+      if (batch0 == null || batch0.length === 0) {
+        if (batch1 != null && batch1.length > 0 && ctrlVal && ctx.prevData[0] !== void 0) {
+          actions.emit(ctx.prevData[0]);
+        } else {
+          actions.down([[RESOLVED]]);
+        }
+        return;
+      }
+      if (!ctrlVal) {
         actions.down([[RESOLVED]]);
-        return void 0;
+        return;
       }
-      return src.node.get();
+      for (const v of batch0) actions.emit(v);
     },
     {
       ...opts,
       name,
-      describeKind: "operator",
+      describeKind: "derived",
       meta: baseMeta("valve", opts?.meta)
     }
   );
@@ -2003,17 +2194,28 @@ function approval(graph, name, source, approver, opts) {
   const isApproved = opts?.isApproved ?? ((value) => Boolean(value));
   const step = node(
     [src.node, ctrl.node],
-    (_deps, actions) => {
-      if (!isApproved(ctrl.node.get())) {
+    (batchData, actions, ctx) => {
+      const batch0 = batchData[0];
+      const batch1 = batchData[1];
+      const ctrlVal = batch1 != null && batch1.length > 0 ? batch1.at(-1) : ctx.prevData[1];
+      if (ctrlVal === void 0 || !isApproved(ctrlVal)) {
         actions.down([[RESOLVED]]);
-        return void 0;
+        return;
+      }
+      if (batch0 == null || batch0.length === 0) {
+        if (batch1 != null && batch1.length > 0 && ctx.prevData[0] !== void 0) {
+          actions.emit(ctx.prevData[0]);
+        } else {
+          actions.down([[RESOLVED]]);
+        }
+        return;
       }
-      return src.node.get();
+      for (const v of batch0) actions.emit(v);
     },
     {
       ...opts,
       name,
-      describeKind: "operator",
+      describeKind: "derived",
       meta: baseMeta("approval", opts?.meta)
     }
   );
@@ -2034,12 +2236,17 @@ function gate(graph, name, source, opts) {
   const src = resolveDep(graph, source);
   const pendingNode = state([], { name: "pending", equals: () => false });
   const isOpenNode = state(startOpen, { name: "isOpen" });
-  const countNode = node([pendingNode], ([arr]) => arr.length, {
-    name: "count",
-    describeKind: "derived"
+  const countNode = derived([pendingNode], ([arr]) => arr.length, {
+    name: "count"
   });
   let queue = [];
   let torn = false;
+  let latestIsOpen = startOpen;
+  const isOpenUnsub = isOpenNode.subscribe((msgs) => {
+    for (const m of msgs) {
+      if (m[0] === DATA) latestIsOpen = m[1];
+    }
+  });
   function syncPending() {
     pendingNode.down([[DATA, [...queue]]]);
   }
@@ -2056,38 +2263,37 @@ function gate(graph, name, source, opts) {
   function guardTorn(method) {
     if (torn) throw new Error(`gate: ${method}() called after gate was torn down`);
   }
-  const output = node([src.node], () => void 0, {
-    name,
-    describeKind: "operator",
-    meta: baseMeta("gate", opts?.meta),
-    onMessage(msg, _depIndex, actions) {
-      if (msg[0] === DATA) {
-        if (isOpenNode.get()) {
-          actions.emit(msg[1]);
-        } else {
-          enqueue(msg[1]);
-          actions.down([[RESOLVED]]);
-        }
-        return true;
-      }
-      if (msg[0] === TEARDOWN) {
+  const output = node(
+    [src.node],
+    (batchData, actions, ctx) => {
+      const terminal = ctx.terminalDeps[0];
+      if (terminal !== void 0) {
         torn = true;
         queue = [];
         syncPending();
-        actions.down([msg]);
-        return true;
+        actions.down(terminal === true ? [[COMPLETE]] : [[ERROR, terminal]]);
+        return;
       }
-      if (msg[0] === COMPLETE || msg[0] === ERROR) {
-        torn = true;
-        queue = [];
-        syncPending();
-        actions.down([msg]);
-        return true;
+      const batch0 = batchData[0];
+      if (batch0 == null || batch0.length === 0) {
+        actions.down([[RESOLVED]]);
+        return;
       }
-      actions.down([msg]);
-      return true;
+      for (const v of batch0) {
+        if (latestIsOpen) {
+          actions.emit(v);
+        } else {
+          enqueue(v);
+          actions.down([[RESOLVED]]);
+        }
+      }
+    },
+    {
+      name,
+      describeKind: "derived",
+      meta: baseMeta("gate", opts?.meta)
     }
-  });
+  );
   const controller = {
     node: output,
     pending: pendingNode,
@@ -2116,12 +2322,14 @@ function gate(graph, name, source, opts) {
     },
     open() {
       guardTorn("open");
-      isOpenNode.down([[DATA, true]]);
-      const items = dequeue(queue.length);
-      for (const item of items) {
-        if (torn) break;
-        output.down([[DATA, item]]);
-      }
+      batch(() => {
+        isOpenNode.down([[DATA, true]]);
+        const items = dequeue(queue.length);
+        for (const item of items) {
+          if (torn) break;
+          output.down([[DATA, item]]);
+        }
+      });
     },
     close() {
       guardTorn("close");
@@ -2129,58 +2337,65 @@ function gate(graph, name, source, opts) {
     }
   };
   graph.addDisposer(countNode.subscribe(() => void 0));
+  graph.addDisposer(isOpenUnsub);
   registerStep(graph, name, output, src.path ? [src.path] : []);
   const internal = new Graph(`${name}_state`);
   internal.add("pending", pendingNode);
   internal.add("isOpen", isOpenNode);
   internal.add("count", countNode);
-  internal.connect("pending", "count");
   graph.mount(`${name}_state`, internal);
   return controller;
 }
 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;
+  const step = node(
+    [src.node],
+    (batchData, actions, ctx) => {
+      if (terminated) {
+        actions.down([[RESOLVED]]);
+        return;
+      }
+      const terminal = ctx.terminalDeps[0];
+      if (terminal !== void 0) {
+        terminated = true;
+        actions.down(terminal === true ? [[COMPLETE]] : [[ERROR, terminal]]);
+        return;
+      }
+      const batch0 = batchData[0];
+      if (batch0 == null || batch0.length === 0) {
+        actions.down([[RESOLVED]]);
+        return;
       }
-      if (msg[0] === DATA) {
+      for (const v of batch0) {
         try {
-          run(msg[1], actions);
-          actions.down([msg]);
+          run(v, actions);
         } catch (err) {
           terminated = true;
           actions.down([[ERROR, err]]);
+          return;
         }
-        return true;
       }
-      actions.down([msg]);
-      if (msg[0] === COMPLETE || msg[0] === ERROR) terminated = true;
-      return true;
+    },
+    {
+      ...opts,
+      name,
+      describeKind: "effect",
+      completeWhenDepsComplete: false,
+      meta: baseMeta("forEach", opts?.meta)
     }
-  });
+  );
   registerStep(graph, name, step, src.path ? [src.path] : []);
   return step;
 }
 function join(graph, name, deps, opts) {
   const resolved = deps.map((dep) => resolveDep(graph, dep));
-  const step = node(
+  const step = derived(
     resolved.map((d) => d.node),
     (values) => values,
     {
       ...opts,
       name,
-      describeKind: "derived",
       meta: baseMeta("join", opts?.meta)
     }
   );
@@ -2199,14 +2414,16 @@ function loop(graph, name, source, iterate, opts) {
   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;
+    (depValues, actions, ctx) => {
+      const batch0 = depValues[0];
+      let current = batch0 != null && batch0.length > 0 ? batch0.at(-1) : ctx.prevData[0];
+      const batch1 = iterDep ? depValues[1] : void 0;
+      const rawCount = staticIterations ?? (iterDep ? batch1 != null && batch1.length > 0 ? batch1.at(-1) : ctx.prevData[1] : 1);
       const count = coerceLoopIterations(rawCount);
       for (let i = 0; i < count; i += 1) {
         current = iterate(current, i, actions);
       }
-      return current;
+      actions.emit(current);
     },
     {
       ...opts,
@@ -2262,7 +2479,7 @@ function wait(graph, name, source, ms, opts) {
     for (const id of timers) clearTimeout(id);
     timers.clear();
   }
-  const srcVal = src.node.get();
+  const srcVal = src.node.cache;
   const initialOpt = srcVal !== void 0 ? { initial: srcVal } : {};
   const step = node(
     [],
@@ -2307,46 +2524,50 @@ function wait(graph, name, source, ms, opts) {
       ...opts,
       name,
       ...initialOpt,
-      describeKind: "operator",
+      describeKind: "derived",
       completeWhenDepsComplete: false,
       meta: baseMeta("wait", opts?.meta)
     }
   );
   graph.add(name, step);
-  if (src.path) {
-    try {
-      graph.connect(src.path, name);
-    } catch (e) {
-      if (!(e instanceof Error && /dep|edge|connect/i.test(e.message))) throw e;
-    }
-  }
   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]]);
+  const step = node(
+    [],
+    (_data, actions) => {
+      const unsub = src.node.subscribe((msgs) => {
+        for (const msg of msgs) {
+          if (terminated) return;
+          if (msg[0] === ERROR) {
+            try {
+              actions.emit(recover(msg[1], actions));
+            } catch (err) {
+              terminated = true;
+              actions.down([[ERROR, err]]);
+            }
+          } else {
+            actions.down([msg]);
+            if (msg[0] === COMPLETE) terminated = true;
+          }
         }
-        return true;
-      }
-      actions.down([msg]);
-      if (msg[0] === COMPLETE) terminated = true;
-      return true;
+      });
+      return () => unsub();
+    },
+    {
+      ...opts,
+      name,
+      describeKind: "derived",
+      completeWhenDepsComplete: false,
+      // onFailure handles errors via manual subscription (recover callback).
+      // Disable auto-propagation so dep-channel ERROR doesn't terminate this
+      // node before the recover callback has a chance to emit a replacement value.
+      errorWhenDepsError: false,
+      meta: baseMeta("onFailure", opts?.meta)
     }
-  });
+  );
   registerStep(graph, name, step, src.path ? [src.path] : []);
   return step;
 }
@@ -2359,7 +2580,7 @@ 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";
+  return typeof x === "object" && x !== null && "subscribe" in x && typeof x.subscribe === "function" && "cache" in x;
 }
 function isAsyncIterableLike(x) {
   return x != null && typeof x === "object" && Symbol.asyncIterator in x && typeof x[Symbol.asyncIterator] === "function";
@@ -2367,7 +2588,7 @@ function isAsyncIterableLike(x) {
 var DEFAULT_TIMEOUT_MS = 3e4;
 function firstDataFromNode(resolved, opts) {
   if (resolved.status === "settled") {
-    const immediate = resolved.get();
+    const immediate = resolved.cache;
     if (immediate !== void 0) {
       return Promise.resolve(immediate);
     }
@@ -2507,43 +2728,94 @@ function streamExtractor(streamTopic, extractFn, opts) {
     {
       name: opts?.name ?? "extractor",
       describeKind: "derived",
-      initial: null
+      initial: null,
+      meta: aiMeta("stream_extractor"),
+      ...opts?.equals ? { equals: opts.equals } : {}
     }
   );
 }
+var keywordFlagsEqual = (a, b) => {
+  if (a === b) return true;
+  if (a == null || b == null) return a === b;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    const x = a[i];
+    const y = b[i];
+    if (x.label !== y.label || x.pattern !== y.pattern || x.match !== y.match || x.position !== y.position) {
+      return false;
+    }
+  }
+  return true;
+};
 function keywordFlagExtractor(streamTopic, opts) {
+  const maxPatternLength = opts.maxPatternLength ?? 128;
   return derived(
     [streamTopic.latest],
-    ([chunk]) => {
+    ([chunk], ctx) => {
       if (chunk == null) return [];
       const accumulated = chunk.accumulated;
-      const flags = [];
+      if (!("flags" in ctx.store)) {
+        ctx.store.flags = [];
+        ctx.store.scannedTo = 0;
+      }
+      const flags = ctx.store.flags;
+      const scannedTo = ctx.store.scannedTo;
+      const startOffset = Math.max(0, scannedTo - maxPatternLength);
+      const region = accumulated.slice(startOffset);
+      let added = false;
       for (const { pattern, label } of opts.patterns) {
         const re = new RegExp(pattern.source, `${pattern.flags.replace("g", "")}g`);
-        for (const m of accumulated.matchAll(re)) {
-          flags.push({ label, pattern, match: m[0], position: m.index });
+        for (const m of region.matchAll(re)) {
+          const pos = startOffset + m.index;
+          if (pos + m[0].length <= scannedTo) continue;
+          flags.push({ label, pattern, match: m[0], position: pos });
+          added = true;
         }
       }
-      return flags;
+      ctx.store.scannedTo = accumulated.length;
+      return added ? [...flags] : flags.slice();
     },
     {
       name: opts.name ?? "keyword-flag-extractor",
       describeKind: "derived",
-      initial: []
+      initial: [],
+      meta: aiMeta("keyword_flag_extractor"),
+      equals: keywordFlagsEqual
     }
   );
 }
+var toolCallsEqual = (a, b) => {
+  if (a === b) return true;
+  if (a == null || b == null) return a === b;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    const x = a[i];
+    const y = b[i];
+    if (x.startIndex !== y.startIndex || x.name !== y.name || x.raw !== y.raw) {
+      return false;
+    }
+  }
+  return true;
+};
 function toolCallExtractor(streamTopic, opts) {
   return derived(
     [streamTopic.latest],
-    ([chunk]) => {
+    ([chunk], ctx) => {
       if (chunk == null) return [];
       const accumulated = chunk.accumulated;
-      const calls = [];
-      let i = 0;
+      if (!("calls" in ctx.store)) {
+        ctx.store.calls = [];
+        ctx.store.scanFrom = 0;
+      }
+      const calls = ctx.store.calls;
+      let i = ctx.store.scanFrom;
+      let added = false;
       while (i < accumulated.length) {
         const start = accumulated.indexOf("{", i);
-        if (start === -1) break;
+        if (start === -1) {
+          ctx.store.scanFrom = accumulated.length;
+          break;
+        }
         let depth = 0;
         let end = -1;
         let inString = false;
@@ -2567,7 +2839,10 @@ function toolCallExtractor(streamTopic, opts) {
             }
           }
         }
-        if (end === -1) break;
+        if (end === -1) {
+          ctx.store.scanFrom = start;
+          break;
+        }
         const raw = accumulated.slice(start, end + 1);
         try {
           const parsed = JSON.parse(raw);
@@ -2578,20 +2853,28 @@ function toolCallExtractor(streamTopic, opts) {
               raw,
               startIndex: start
             });
+            added = true;
           }
         } catch {
         }
         i = end + 1;
+        ctx.store.scanFrom = i;
       }
-      return calls;
+      return added ? [...calls] : calls.slice();
     },
     {
       name: opts?.name ?? "tool-call-extractor",
       describeKind: "derived",
-      initial: []
+      initial: [],
+      meta: aiMeta("tool_call_extractor"),
+      equals: toolCallsEqual
     }
   );
 }
+var costMeterEqual = (a, b) => {
+  if (a === b) return true;
+  return a.chunkCount === b.chunkCount && a.charCount === b.charCount && a.estimatedTokens === b.estimatedTokens;
+};
 function costMeterExtractor(streamTopic, opts) {
   const charsPerToken = opts?.charsPerToken ?? 4;
   return derived(
@@ -2609,7 +2892,9 @@ function costMeterExtractor(streamTopic, opts) {
     {
       name: opts?.name ?? "cost-meter",
       describeKind: "derived",
-      initial: { chunkCount: 0, charCount: 0, estimatedTokens: 0 }
+      initial: { chunkCount: 0, charCount: 0, estimatedTokens: 0 },
+      meta: aiMeta("cost_meter_extractor"),
+      equals: costMeterEqual
     }
   );
 }
@@ -2761,7 +3046,7 @@ function promptNode(adapter, deps, prompt, opts) {
   const format = opts?.format ?? "text";
   const retries = opts?.retries ?? 0;
   const useCache = opts?.cache ?? false;
-  const cache2 = useCache ? /* @__PURE__ */ new Map() : null;
+  const cache = useCache ? /* @__PURE__ */ new Map() : null;
   const messagesNode = derived(
     deps,
     (values) => {
@@ -2784,8 +3069,8 @@ function promptNode(adapter, deps, prompt, opts) {
       return state(null);
     }
     const cacheKey = useCache ? JSON.stringify(msgs.map((m) => [m.role, m.content])) : "";
-    if (cache2?.has(cacheKey)) {
-      return state(cache2.get(cacheKey));
+    if (cache?.has(cacheKey)) {
+      return state(cache.get(cacheKey));
     }
     async function attempt(remaining) {
       try {
@@ -2798,8 +3083,8 @@ function promptNode(adapter, deps, prompt, opts) {
           });
           if (input && typeof input.then === "function") {
             input.then(resolve, reject);
-          } else if (input && typeof input.get === "function") {
-            resolve(input.get());
+          } else if (input && typeof input.subscribe === "function") {
+            resolve(input.cache);
           } else {
             resolve(input);
           }
@@ -2811,7 +3096,7 @@ function promptNode(adapter, deps, prompt, opts) {
         } else {
           parsed = content;
         }
-        cache2?.set(cacheKey, parsed);
+        cache?.set(cacheKey, parsed);
         return parsed;
       } catch (err) {
         if (remaining > 0) return attempt(remaining - 1);
@@ -2839,17 +3124,15 @@ var ChatStreamGraph = class extends Graph {
       [this.messages],
       ([snapshot]) => {
         const entries = snapshot;
-        return entries.length === 0 ? void 0 : entries[entries.length - 1];
+        return entries.length === 0 ? null : entries[entries.length - 1];
       },
       {
         name: "latest",
         describeKind: "derived",
-        meta: aiMeta("chat_latest"),
-        initial: void 0
+        meta: aiMeta("chat_latest")
       }
     );
     this.add("latest", this.latest);
-    this.connect("messages", "latest");
     this.addDisposer(keepalive(this.latest));
     this.messageCount = derived(
       [this.messages],
@@ -2862,7 +3145,6 @@ var ChatStreamGraph = class extends Graph {
       }
     );
     this.add("messageCount", this.messageCount);
-    this.connect("messages", "messageCount");
     this.addDisposer(keepalive(this.messageCount));
   }
   append(role, content, extra) {
@@ -2875,7 +3157,7 @@ var ChatStreamGraph = class extends Graph {
     this._log.clear();
   }
   allMessages() {
-    return this.messages.get();
+    return this.messages.cache;
   }
 };
 function chatStream(name, opts) {
@@ -2903,31 +3185,30 @@ var ToolRegistryGraph = class extends Graph {
       }
     );
     this.add("schemas", this.schemas);
-    this.connect("definitions", "schemas");
     this.addDisposer(keepalive(this.schemas));
   }
   register(tool) {
-    const current = this.definitions.get();
+    const current = this.definitions.cache;
     const next = new Map(current);
     next.set(tool.name, tool);
     this.definitions.down([[DATA, next]]);
   }
   unregister(name) {
-    const current = this.definitions.get();
+    const current = this.definitions.cache;
     if (!current.has(name)) return;
     const next = new Map(current);
     next.delete(name);
     this.definitions.down([[DATA, next]]);
   }
   async execute(name, args) {
-    const defs = this.definitions.get();
+    const defs = this.definitions.cache;
     const tool = defs.get(name);
     if (!tool) throw new Error(`toolRegistry: unknown tool "${name}"`);
     const raw = tool.handler(args);
     return resolveToolHandlerResult(raw);
   }
   getDefinition(name) {
-    return this.definitions.get().get(name);
+    return this.definitions.cache?.get(name);
   }
 };
 function toolRegistry(name, opts) {
@@ -2962,7 +3243,7 @@ function llmExtractor(systemPrompt, opts) {
         })
       }
     ];
-    return producer((_deps, actions) => {
+    return producer((actions) => {
       let active = true;
       const result = opts.adapter.invoke(messages, {
         model: opts.model,
@@ -3012,7 +3293,7 @@ function llmConsolidator(systemPrompt, opts) {
       { role: "system", content: systemPrompt },
       { role: "user", content: JSON.stringify({ memories: entriesArray }) }
     ];
-    return producer((_deps, actions) => {
+    return producer((actions) => {
       let active = true;
       const result = opts.adapter.invoke(messages, {
         model: opts.model,
@@ -3127,8 +3408,6 @@ function agentMemory(name, source, opts) {
   graph.add("store", distillBundle.store.entries);
   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 });
@@ -3151,7 +3430,7 @@ function agentMemory(name, source, opts) {
     const permanentKeys = /* @__PURE__ */ new Set();
     const tierOf = (key) => {
       if (permanentKeys.has(key)) return "permanent";
-      const storeMap = extractStoreMap(distillBundle.store.entries.get());
+      const storeMap = extractStoreMap(distillBundle.store.entries.cache);
       if (storeMap.has(key)) return "active";
       return "archived";
     };
@@ -3210,10 +3489,10 @@ function agentMemory(name, source, opts) {
     });
     keepaliveSubs.push(tierClassifier.subscribe(() => void 0));
     let archiveHandle = null;
-    if (tiersOpts.archiveAdapter) {
-      archiveHandle = graph.autoCheckpoint(
-        tiersOpts.archiveAdapter,
-        tiersOpts.archiveCheckpointOptions
+    if (tiersOpts.archiveTier) {
+      archiveHandle = graph.attachStorage(
+        [tiersOpts.archiveTier],
+        tiersOpts.archiveStorageOptions ?? {}
       );
     }
     memoryTiersBundle = {
@@ -3259,12 +3538,14 @@ function agentMemory(name, source, opts) {
     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 retrievalOutput = state([], {
+      name: "retrieval",
+      describeKind: "state",
+      meta: aiMeta("retrieval_pipeline")
+    });
+    graph.add("retrieval", retrievalOutput);
+    retrievalNode = retrievalOutput;
     const traceState = state(null, {
       name: "retrievalTrace",
       describeKind: "state",
@@ -3272,97 +3553,81 @@ function agentMemory(name, source, opts) {
     });
     graph.add("retrievalTrace", traceState);
     retrievalTraceNode = traceState;
-    const storeNode = distillBundle.store.entries;
-    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"]) });
-            }
+    retrieveFn = (query) => {
+      const storeMap = extractStoreMap(distillBundle.store.entries.cache);
+      const ctx = contextNode.cache;
+      const candidateMap = /* @__PURE__ */ new Map();
+      let vectorCandidates = [];
+      if (vectors && query.vector) {
+        vectorCandidates = vectors.search(query.vector, topK);
+        for (const vc of vectorCandidates) {
+          const mem = storeMap.get(vc.id);
+          if (mem) {
+            candidateMap.set(vc.id, { value: mem, sources: /* @__PURE__ */ new Set(["vector"]) });
           }
         }
-        const graphExpanded = [];
-        if (kg) {
-          const seedIds = [...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);
+      }
+      const graphExpanded = [];
+      if (kg) {
+        const seedIds = [...query.entityIds ?? [], ...[...candidateMap.keys()]];
+        const visited = /* @__PURE__ */ new Set();
+        let frontier = seedIds;
+        for (let depth = 0; depth < graphDepth; depth++) {
+          const nextFrontier = [];
+          for (const id of frontier) {
+            if (visited.has(id)) continue;
+            visited.add(id);
+            const related = kg.related(id);
+            for (const edge of related) {
+              const targetId = edge.to;
+              if (!visited.has(targetId)) {
+                nextFrontier.push(targetId);
+                const mem = storeMap.get(targetId);
+                if (mem) {
+                  const existing = candidateMap.get(targetId);
+                  if (existing) {
+                    existing.sources.add("graph");
+                  } else {
+                    candidateMap.set(targetId, { value: mem, sources: /* @__PURE__ */ new Set(["graph"]) });
                   }
+                  graphExpanded.push(targetId);
                 }
               }
             }
-            frontier = nextFrontier;
           }
+          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;
+      }
+      for (const [key, mem] of storeMap) {
+        if (!candidateMap.has(key)) {
+          candidateMap.set(key, { value: mem, sources: /* @__PURE__ */ new Set(["store"]) });
         }
-        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]]);
+      const ranked = [];
+      for (const [key, { value, sources }] of candidateMap) {
+        const score = scoreFn(value, ctx);
+        ranked.push({ key, value, score, sources: [...sources] });
       }
-      return result;
+      ranked.sort((a, b) => b.score - a.score);
+      const packed = [];
+      let usedBudget = 0;
+      for (const entry of ranked) {
+        const c = costFn(entry.value);
+        if (usedBudget + c > budget && packed.length > 0) break;
+        packed.push(entry);
+        usedBudget += c;
+      }
+      const trace = {
+        vectorCandidates,
+        graphExpanded,
+        ranked,
+        packed
+      };
+      batch(() => {
+        retrievalOutput.down([[DATA, packed]]);
+        traceState.down([[DATA, trace]]);
+      });
+      return packed;
     };
   }
   graph.addDisposer(() => {
@@ -3466,7 +3731,7 @@ var AgentLoopGraph = class extends Graph {
           this._statusState.down([[DATA, "thinking"]]);
         });
         const msgs = this.chat.allMessages();
-        const toolSchemas = this.tools.schemas.get() ?? [];
+        const toolSchemas = this.tools.schemas.cache ?? [];
         const response = await this._invokeLLM(msgs, toolSchemas, signal);
         if (signal.aborted) throw new Error("agentLoop: aborted");
         this.lastResponse.down([[DATA, response]]);
@@ -3501,7 +3766,7 @@ var AgentLoopGraph = class extends Graph {
       this._statusState.down([[DATA, "done"]]);
       this._running = false;
       this._abortController = null;
-      return this.lastResponse.get();
+      return this.lastResponse.cache;
     } catch (err) {
       this._statusState.down([[DATA, "error"]]);
       this._running = false;
@@ -3997,7 +4262,7 @@ function demoShell(opts) {
     ([ref, _tick]) => {
       const demo = ref;
       if (!demo) return "";
-      return demo.toMermaid();
+      return demo.describe({ format: "mermaid" });
     },
     { name: "graph/mermaid" }
   );
@@ -4053,7 +4318,6 @@ function demoShell(opts) {
       cb(line);
     });
     g.add("highlight/apply-code-scroll", applyCodeScroll);
-    g.connect("highlight/code-scroll", "highlight/apply-code-scroll");
   }
   if (onHighlight?.visual) {
     const cb = onHighlight.visual;
@@ -4061,7 +4325,6 @@ function demoShell(opts) {
       cb(selector);
     });
     g.add("highlight/apply-visual", applyVisual);
-    g.connect("highlight/visual", "highlight/apply-visual");
   }
   if (onHighlight?.graph) {
     const cb = onHighlight.graph;
@@ -4069,7 +4332,6 @@ function demoShell(opts) {
       cb(nodeId);
     });
     g.add("highlight/apply-graph", applyGraph);
-    g.connect("highlight/graph", "highlight/apply-graph");
   }
   const inspectSelected = state(null, {
     name: "inspect/selected-node"
@@ -4085,7 +4347,7 @@ function demoShell(opts) {
       try {
         const nd = demo.resolve(p);
         const nodeDesc = describeNode(nd, standardFields);
-        return { path: p, ...nodeDesc, value: nd.get() };
+        return { path: p, ...nodeDesc, value: nd.cache };
       } catch {
         return null;
       }
@@ -4109,7 +4371,7 @@ function demoShell(opts) {
     [metaDebug, demoGraphTick],
     ([debug, _tick]) => {
       if (!debug) return "";
-      return g.toMermaid();
+      return g.describe({ format: "mermaid" });
     },
     { name: "meta/shell-mermaid" }
   );
@@ -4175,35 +4437,7 @@ function demoShell(opts) {
     g.add("layout/graph-labels", graphLabels);
     g.add("layout/code-lines", codeLines);
     g.add("layout/side-width-hint", sideWidthHint);
-    g.connect("graph/describe", "layout/graph-labels");
-    g.connect("layout/code-text", "layout/code-lines");
-    g.connect("pane/side-width", "layout/code-lines");
-    g.connect("layout/graph-labels", "layout/side-width-hint");
-  }
-  g.connect("pane/main-ratio", "pane/main-width");
-  g.connect("viewport/width", "pane/main-width");
-  g.connect("pane/fullscreen", "pane/main-width");
-  g.connect("pane/main-width", "pane/side-width");
-  g.connect("viewport/width", "pane/side-width");
-  g.connect("pane/fullscreen", "pane/side-width");
-  g.connect("pane/side-split", "pane/graph-height-ratio");
-  g.connect("pane/fullscreen", "pane/graph-height-ratio");
-  g.connect("pane/graph-height-ratio", "pane/code-height-ratio");
-  g.connect("pane/fullscreen", "pane/code-height-ratio");
-  g.connect("demo/graph-ref", "graph/mermaid");
-  g.connect("demo/graph-tick", "graph/mermaid");
-  g.connect("demo/graph-ref", "graph/describe");
-  g.connect("demo/graph-tick", "graph/describe");
-  g.connect("hover/target", "highlight/code-scroll");
-  g.connect("hover/target", "highlight/visual");
-  g.connect("hover/target", "highlight/graph");
-  g.connect("inspect/selected-node", "inspect/node-detail");
-  g.connect("demo/graph-ref", "inspect/node-detail");
-  g.connect("demo/graph-tick", "inspect/node-detail");
-  g.connect("demo/graph-ref", "inspect/trace-log");
-  g.connect("demo/graph-tick", "inspect/trace-log");
-  g.connect("meta/debug", "meta/shell-mermaid");
-  g.connect("demo/graph-tick", "meta/shell-mermaid");
+  }
   let tickCounter = 0;
   return {
     graph: g,
@@ -4288,14 +4522,14 @@ function _addBranch(graph, source, rulesNode, rule) {
   let sourcePhase2 = false;
   let sourceValue = _noValue;
   let pendingDirty = false;
+  let latestRules = rulesNode.cache ?? [];
   function resolve(actions) {
     if (sourcePhase2) {
       sourcePhase2 = false;
       const value = sourceValue;
       sourceValue = _noValue;
       if (value !== _noValue) {
-        const currentRules = rulesNode.get();
-        const currentRule = currentRules.find((r) => r.name === rule.name);
+        const currentRule = latestRules.find((r) => r.name === rule.name);
         let matches = false;
         try {
           matches = currentRule?.classify(value) ?? false;
@@ -4321,55 +4555,75 @@ function _addBranch(graph, source, rulesNode, rule) {
       }
     }
   }
-  const filterNode = node([source, rulesNode], () => void 0, {
-    describeKind: "operator",
-    meta: baseMeta2("stratify_branch", { branch: rule.name }),
-    onMessage(msg, depIndex, actions) {
-      const t = msg[0];
-      if (t === DIRTY) {
-        if (depIndex === 0) {
-          sourceDirty = true;
-          pendingDirty = true;
-        } else {
-          rulesDirty = true;
+  const filterNode = node(
+    [],
+    (_data, filterActions) => {
+      const srcUnsub = source.subscribe((msgs) => {
+        for (const msg of msgs) {
+          _handleStratifyMessage(msg, 0, filterActions);
         }
-        return true;
-      }
-      if (t === DATA || t === RESOLVED) {
-        if (depIndex === 0) {
-          sourceDirty = false;
-          sourcePhase2 = true;
-          sourceValue = t === DATA ? msg[1] : _noValue;
-        } else {
-          rulesDirty = false;
+      });
+      const rulesUnsub = rulesNode.subscribe((msgs) => {
+        for (const msg of msgs) {
+          _handleStratifyMessage(msg, 1, filterActions);
         }
-        if (sourceDirty || rulesDirty) return true;
-        resolve(actions);
-        return true;
+      });
+      return () => {
+        srcUnsub();
+        rulesUnsub();
+      };
+    },
+    {
+      describeKind: "derived",
+      meta: baseMeta2("stratify_branch", { branch: rule.name }),
+      completeWhenDepsComplete: false
+    }
+  );
+  function _handleStratifyMessage(msg, depIndex, actions) {
+    const t = msg[0];
+    if (t === DIRTY) {
+      if (depIndex === 0) {
+        sourceDirty = true;
+        pendingDirty = true;
+      } else {
+        rulesDirty = true;
       }
-      if (t === COMPLETE || t === ERROR || t === TEARDOWN) {
+      return true;
+    }
+    if (t === DATA || t === RESOLVED) {
+      if (depIndex === 0) {
         sourceDirty = false;
-        rulesDirty = false;
-        sourcePhase2 = false;
-        sourceValue = _noValue;
-        pendingDirty = false;
-        if (depIndex === 0) {
-          actions.down([msg]);
+        sourcePhase2 = true;
+        sourceValue = t === DATA ? msg[1] : _noValue;
+      } else {
+        if (t === DATA) {
+          latestRules = msg[1];
         }
-        return true;
+        rulesDirty = false;
       }
-      if (depIndex === 1) return true;
-      return false;
-    },
-    completeWhenDepsComplete: false
-  });
+      if (sourceDirty || rulesDirty) return true;
+      resolve(actions);
+      return true;
+    }
+    if (t === COMPLETE || t === ERROR || t === TEARDOWN) {
+      sourceDirty = false;
+      rulesDirty = false;
+      sourcePhase2 = false;
+      sourceValue = _noValue;
+      pendingDirty = false;
+      if (depIndex === 0) {
+        actions.down([msg]);
+      }
+      return true;
+    }
+    if (depIndex === 1) return true;
+    return false;
+  }
   graph.add(branchName, filterNode);
-  graph.connect("source", branchName);
   if (rule.ops) {
     const transformed = rule.ops(filterNode);
     const transformedName = `branch/${rule.name}/out`;
     graph.add(transformedName, transformed);
-    graph.connect(branchName, transformedName);
   }
 }
 function funnel(name, sources, stages, opts) {
@@ -4398,12 +4652,14 @@ function funnel(name, sources, stages, opts) {
     const stageInputPath = `${stage.name}::input`;
     const stageInput = g.resolve(stageInputPath);
     const bridgeName = `__bridge_${prevOutputPath}\u2192${stage.name}_input`;
-    const br = bridge(prevNode, stageInput, {
-      name: bridgeName,
-      down: DEFAULT_DOWN.filter((t) => t !== TEARDOWN)
-    });
+    const br = effect(
+      [prevNode],
+      ([data]) => {
+        stageInput.down([[DATA, data]]);
+      },
+      { name: bridgeName }
+    );
     g.add(bridgeName, br);
-    g.connect(prevOutputPath, bridgeName);
     g.addDisposer(keepalive(br));
     prevOutputPath = `${stage.name}::output`;
   }
@@ -4423,39 +4679,41 @@ function feedback(graph, condition, reentry, opts) {
   const condNode = graph.resolve(condition);
   const reentryNode = graph.resolve(reentry);
   const feedbackEffectName = `__feedback_effect_${condition}`;
-  const feedbackEffect = node([condNode], void 0, {
-    name: feedbackEffectName,
-    describeKind: "effect",
-    meta: {
-      ...baseMeta2("feedback_effect", {
-        feedbackFrom: condition,
-        feedbackTo: reentry
-      }),
-      _internal: true
+  const feedbackEffect = node(
+    [],
+    (_data, _feedbackActions) => {
+      const unsub = condNode.subscribe((msgs) => {
+        for (const msg of msgs) {
+          const t = msg[0];
+          if (t === DATA) {
+            const condValue = msg[1];
+            if (condValue == null) return;
+            batch(() => {
+              if (tryIncrementBounded(counter, maxIter)) {
+                reentryNode.down([[DATA, condValue]]);
+              }
+            });
+          } else if (t === COMPLETE || t === ERROR) {
+            const terminal = t === ERROR && msg.length > 1 ? [ERROR, msg[1]] : [t];
+            counter.down([terminal]);
+          }
+        }
+      });
+      return () => unsub();
     },
-    onMessage(msg, _depIndex, _actions) {
-      const t = msg[0];
-      if (t === DATA) {
-        const currentCount = counter.get();
-        if (currentCount >= maxIter) return true;
-        const condValue = msg[1];
-        if (condValue == null) return true;
-        batch(() => {
-          counter.down([[DATA, currentCount + 1]]);
-          reentryNode.down([[DATA, condValue]]);
-        });
-        return true;
-      }
-      if (t === COMPLETE || t === ERROR) {
-        const terminal = t === ERROR && msg.length > 1 ? [ERROR, msg[1]] : [t];
-        counter.down([terminal]);
-        return true;
+    {
+      name: feedbackEffectName,
+      describeKind: "effect",
+      meta: {
+        ...baseMeta2("feedback_effect", {
+          feedbackFrom: condition,
+          feedbackTo: reentry
+        }),
+        _internal: true
       }
-      return false;
     }
-  });
+  );
   graph.add(feedbackEffectName, feedbackEffect);
-  graph.connect(condition, feedbackEffectName);
   graph.addDisposer(keepalive(feedbackEffect));
   return graph;
 }
@@ -4467,8 +4725,9 @@ function budgetGate(source, constraints, opts) {
   let paused = false;
   let pendingResolved = false;
   const lockId = /* @__PURE__ */ Symbol("budget-gate");
+  const latestValues = new Array(constraints.length);
   function checkBudget() {
-    return constraints.every((c) => c.check(c.node.get()));
+    return constraints.every((c, i) => c.check(latestValues[i]));
   }
   function flushBuffer(actions) {
     while (buffer2.length > 0 && checkBudget()) {
@@ -4481,78 +4740,103 @@ function budgetGate(source, constraints, opts) {
       actions.down([[RESOLVED]]);
     }
   }
-  return node(allDeps, () => void 0, {
-    ...opts,
-    describeKind: "operator",
-    meta: baseMeta2("budget_gate", opts?.meta),
-    onMessage(msg, depIndex, actions) {
-      const t = msg[0];
-      if (depIndex === 0) {
-        if (t === DATA) {
-          if (checkBudget() && buffer2.length === 0) {
-            actions.emit(msg[1]);
-          } else {
-            buffer2.push(msg[1]);
-            if (!paused) {
-              paused = true;
-              actions.up([[PAUSE, lockId]]);
+  return node(
+    [],
+    (_data, gateActions) => {
+      for (let i = 0; i < constraints.length; i++) {
+        latestValues[i] = constraints[i].node.cache;
+      }
+      const unsubs = [];
+      for (let depIdx = 0; depIdx < allDeps.length; depIdx++) {
+        const dep = allDeps[depIdx];
+        unsubs.push(
+          dep.subscribe((msgs) => {
+            for (const msg of msgs) {
+              _handleBudgetMessage(msg, depIdx, gateActions);
             }
-          }
-          return true;
-        }
-        if (t === DIRTY) {
-          actions.down([[DIRTY]]);
-          return true;
-        }
-        if (t === RESOLVED) {
-          if (buffer2.length === 0) {
-            actions.down([[RESOLVED]]);
-          } else {
-            pendingResolved = true;
-          }
-          return true;
-        }
-        if (t === COMPLETE || t === ERROR) {
-          for (const item of buffer2) {
-            actions.emit(item);
-          }
-          buffer2 = [];
-          pendingResolved = false;
-          if (paused) {
-            paused = false;
-            actions.up([[RESUME, lockId]]);
-          }
-          actions.down([msg]);
-          return true;
-        }
-        return false;
+          })
+        );
       }
-      if (t === DATA || t === RESOLVED) {
-        if (checkBudget() && buffer2.length > 0) {
-          flushBuffer(actions);
-          if (buffer2.length === 0 && paused) {
-            paused = false;
-            actions.up([[RESUME, lockId]]);
+      return () => {
+        for (const u of unsubs) u();
+      };
+    },
+    {
+      ...opts,
+      describeKind: "derived",
+      meta: baseMeta2("budget_gate", opts?.meta)
+    }
+  );
+  function _handleBudgetMessage(msg, depIndex, actions) {
+    const t = msg[0];
+    if (depIndex === 0) {
+      if (t === DATA) {
+        if (checkBudget() && buffer2.length === 0) {
+          actions.emit(msg[1]);
+        } else {
+          buffer2.push(msg[1]);
+          if (!paused) {
+            paused = true;
+            actions.up([[PAUSE, lockId]]);
           }
-        } else if (!checkBudget() && !paused && buffer2.length > 0) {
-          paused = true;
-          actions.up([[PAUSE, lockId]]);
         }
         return true;
       }
       if (t === DIRTY) {
+        actions.down([[DIRTY]]);
         return true;
       }
-      if (t === ERROR) {
-        actions.down([msg]);
+      if (t === RESOLVED) {
+        if (buffer2.length === 0) {
+          actions.down([[RESOLVED]]);
+        } else {
+          pendingResolved = true;
+        }
         return true;
       }
-      if (t === COMPLETE) {
+      if (t === COMPLETE || t === ERROR) {
+        for (const item of buffer2) {
+          actions.emit(item);
+        }
+        buffer2 = [];
+        pendingResolved = false;
+        if (paused) {
+          paused = false;
+          actions.up([[RESUME, lockId]]);
+        }
+        actions.down([msg]);
         return true;
       }
       return false;
     }
-  });
+    if (t === DATA) {
+      latestValues[depIndex - 1] = msg[1];
+    }
+    if (t === DATA || t === RESOLVED) {
+      if (checkBudget() && buffer2.length > 0) {
+        flushBuffer(actions);
+        if (buffer2.length === 0 && paused) {
+          paused = false;
+          actions.up([[RESUME, lockId]]);
+        }
+      } else if (!checkBudget() && !paused && buffer2.length > 0) {
+        paused = true;
+        actions.up([[PAUSE, lockId]]);
+      }
+      return true;
+    }
+    if (t === DIRTY) {
+      return true;
+    }
+    if (t === ERROR) {
+      actions.down([msg]);
+      return true;
+    }
+    if (t === COMPLETE) {
+      return true;
+    }
+    return false;
+  }
 }
 function scorer(sources, weights, opts) {
   if (sources.length === 0) throw new RangeError("scorer requires at least one source");
@@ -4584,7 +4868,11 @@ function scorer(sources, weights, opts) {
       };
     },
     {
-      ...opts,
+      ...opts ? {
+        equals: opts.equals,
+        resubscribable: opts.resubscribable,
+        resetOnTeardown: opts.resetOnTeardown
+      } : {},
       describeKind: "derived",
       meta: baseMeta2("scorer", opts?.meta)
     }
@@ -4672,12 +4960,6 @@ function observabilityGraph(name, opts) {
     }
   );
   g.add("correlate", correlateNode);
-  for (const b of branches) {
-    try {
-      g.connect(`stratify::branch/${b.name}`, "correlate");
-    } catch {
-    }
-  }
   const sloCheckFn = opts.sloCheck ?? (() => ({ pass: true }));
   const sloValue = derived([correlateNode], (vals) => vals[0], {
     meta: baseMeta3("observability", { stage: "slo_value" })
@@ -4687,8 +4969,6 @@ function observabilityGraph(name, opts) {
   });
   g.add("slo_value", sloValue);
   g.add("slo_verified", sloVerified);
-  g.connect("correlate", "slo_value");
-  g.connect("slo_value", "slo_verified");
   const weightValues = opts.weights ?? branches.map(() => 1);
   const signalNodes = branchNodes.map(
     (bn) => derived([bn], (vals) => vals[0] != null ? 1 : 0)
@@ -4714,8 +4994,6 @@ function observabilityGraph(name, opts) {
     }
   );
   g.add("output", output);
-  g.connect("alerts", "output");
-  g.connect("slo_verified", "output");
   const fbReentry = state(null, {
     meta: baseMeta3("observability", { stage: "feedback_reentry" })
   });
@@ -4732,7 +5010,6 @@ function observabilityGraph(name, opts) {
     }
   );
   g.add("feedback_condition", fbCondition);
-  g.connect("slo_verified", "feedback_condition");
   feedback(g, "feedback_condition", "feedback_reentry", {
     maxIterations: opts.maxFeedbackIterations ?? 5
   });
@@ -4754,7 +5031,6 @@ function issueTrackerGraph(name, opts) {
     meta: baseMeta3("issue_tracker", { stage: "extract" })
   });
   g.add("extract", extractNode);
-  g.connect("source", "extract");
   const verifyFn = opts.verify ?? (() => ({ valid: true }));
   const verifyNode = derived(
     [extractNode],
@@ -4767,7 +5043,6 @@ function issueTrackerGraph(name, opts) {
     }
   );
   g.add("verify", verifyNode);
-  g.connect("extract", "verify");
   const knownPatterns = state([], {
     meta: baseMeta3("issue_tracker", { stage: "known_patterns" })
   });
@@ -4783,8 +5058,6 @@ function issueTrackerGraph(name, opts) {
     { meta: baseMeta3("issue_tracker", { stage: "regression" }) }
   );
   g.add("regression", regressionNode);
-  g.connect("extract", "regression");
-  g.connect("known_patterns", "regression");
   const severitySignal = derived([extractNode], (vals) => {
     const issue = vals[0];
     return issue?.severity ?? 0;
@@ -4811,9 +5084,6 @@ function issueTrackerGraph(name, opts) {
     { meta: baseMeta3("issue_tracker", { stage: "output" }) }
   );
   g.add("output", output);
-  g.connect("verify", "output");
-  g.connect("regression", "output");
-  g.connect("priority", "output");
   const fbReentry = state(null, {
     meta: baseMeta3("issue_tracker", { stage: "feedback_reentry" })
   });
@@ -4833,7 +5103,6 @@ function issueTrackerGraph(name, opts) {
     }
   );
   g.add("feedback_condition", fbCondition);
-  g.connect("verify", "feedback_condition");
   feedback(g, "feedback_condition", "feedback_reentry", {
     maxIterations: opts.maxFeedbackIterations ?? 3
   });
@@ -4852,7 +5121,6 @@ function contentModerationGraph(name, opts) {
     meta: baseMeta3("content_moderation", { stage: "classify" })
   });
   g.add("classify", classifyNode);
-  g.connect("source", "classify");
   const strat = stratify("stratify", classifyNode, [
     { name: "safe", classify: (v) => v.label === "safe" },
     { name: "review", classify: (v) => v.label === "review" },
@@ -4880,7 +5148,6 @@ function contentModerationGraph(name, opts) {
   g.add("__review_accumulator", reviewAccumulator);
   g.addDisposer(keepalive(reviewAccumulator));
   try {
-    g.connect("stratify::branch/review", "__review_accumulator");
   } catch {
   }
   const policy2 = state(
@@ -4921,8 +5188,6 @@ function contentModerationGraph(name, opts) {
     { meta: baseMeta3("content_moderation", { stage: "output" }) }
   );
   g.add("output", output);
-  g.connect("classify", "output");
-  g.connect("priority", "output");
   const fbCondition = derived(
     [reviewLog.entries, policy2],
     (vals) => {
@@ -4959,7 +5224,6 @@ function dataQualityGraph(name, opts) {
     { meta: baseMeta3("data_quality", { stage: "validate" }) }
   );
   g.add("validate", validateNode);
-  g.connect("source", "validate");
   const detectAnomalyFn = opts.detectAnomaly ?? ((record) => ({
     anomaly: false,
     score: 0,
@@ -4971,7 +5235,6 @@ function dataQualityGraph(name, opts) {
     { meta: baseMeta3("data_quality", { stage: "anomaly" }) }
   );
   g.add("anomaly", anomalyNode);
-  g.connect("source", "anomaly");
   const baseline = state(null, {
     meta: baseMeta3("data_quality", {
       stage: "baseline",
@@ -4988,7 +5251,6 @@ function dataQualityGraph(name, opts) {
     }
   });
   g.add("__baseline_updater", baselineUpdater);
-  g.connect("validate", "__baseline_updater");
   keepalive(baselineUpdater);
   const detectDriftFn = opts.detectDrift ?? (() => ({ drift: false }));
   const driftNode = derived(
@@ -4997,8 +5259,6 @@ function dataQualityGraph(name, opts) {
     { meta: baseMeta3("data_quality", { stage: "drift" }) }
   );
   g.add("drift", driftNode);
-  g.connect("source", "drift");
-  g.connect("baseline", "drift");
   const suggestFn = opts.suggest ?? (() => null);
   const remediateNode = derived(
     [validateNode, anomalyNode],
@@ -5009,8 +5269,6 @@ function dataQualityGraph(name, opts) {
     { meta: baseMeta3("data_quality", { stage: "remediate" }) }
   );
   g.add("remediate", remediateNode);
-  g.connect("validate", "remediate");
-  g.connect("anomaly", "remediate");
   const output = derived(
     [validateNode, anomalyNode, driftNode, remediateNode],
     (vals) => ({
@@ -5022,10 +5280,6 @@ function dataQualityGraph(name, opts) {
     { meta: baseMeta3("data_quality", { stage: "output" }) }
   );
   g.add("output", output);
-  g.connect("validate", "output");
-  g.connect("anomaly", "output");
-  g.connect("drift", "output");
-  g.connect("remediate", "output");
   const validationRules = state([], {
     meta: baseMeta3("data_quality", { stage: "validation_rules" })
   });
@@ -5042,7 +5296,6 @@ function dataQualityGraph(name, opts) {
     }
   );
   g.add("feedback_condition", fbCondition);
-  g.connect("anomaly", "feedback_condition");
   feedback(g, "feedback_condition", "validation_rules", {
     maxIterations: opts.maxFeedbackIterations ?? 3
   });
@@ -5568,20 +5821,6 @@ ${catalogValidation.errors.join("\n")}`
     } catch {
     }
   }
-  for (const [name, raw] of Object.entries(spec.nodes)) {
-    if (raw.type === "template") continue;
-    const n = raw;
-    for (const dep of n.deps ?? []) {
-      try {
-        g.connect(dep, name);
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : "";
-        if (!msg.includes("constructor deps") && !msg.includes("already")) {
-          throw err;
-        }
-      }
-    }
-  }
   for (const fb of spec.feedback ?? []) {
     feedback(g, fb.from, fb.to, {
       maxIterations: fb.maxIterations
@@ -6472,6 +6711,7 @@ function harnessLoop(name, opts) {
   }
   const routerInput = withLatestFrom(triageNode, triageInput);
   const router = effect([routerInput], ([pair]) => {
+    if (pair == null) return;
     const [classification, triagePair] = pair;
     if (!classification || !classification.route) return;
     const intakeItem = triagePair?.[0];
@@ -6517,32 +6757,43 @@ function harnessLoop(name, opts) {
       retries: 1
     }
   );
+  const executeContextNode = withLatestFrom(
+    executeNode,
+    executeInput
+  );
   const verifyResults = new TopicGraph("verify-results", { retainedLimit });
   const verifyNode = promptNode(
     adapter,
-    [executeNode, executeInput],
-    opts.verifyPrompt ?? ((execution, item) => DEFAULT_VERIFY_PROMPT.replace("{{execution}}", JSON.stringify(execution)).replace(
-      "{{item}}",
-      JSON.stringify(item)
-    )),
+    [executeContextNode],
+    opts.verifyPrompt ?? ((ctxPair) => {
+      const [execution, item] = ctxPair;
+      return DEFAULT_VERIFY_PROMPT.replace("{{execution}}", JSON.stringify(execution)).replace(
+        "{{item}}",
+        JSON.stringify(item)
+      );
+    }),
     {
       name: "verify",
       format: "json",
       retries: 1
     }
   );
-  const verifyWithExec = withLatestFrom(verifyNode, executeNode);
   const verifyContext = withLatestFrom(
-    verifyWithExec,
-    executeInput
+    verifyNode,
+    executeContextNode
   );
   const maxReingestions = opts.maxReingestions ?? 1;
   const maxTotalRetries = Math.min(opts.maxTotalRetries ?? maxRetries * 10, 100);
   const maxTotalReingestions = Math.min(opts.maxTotalReingestions ?? maxReingestions * 10, 100);
   const totalRetries = state(0);
   const totalReingestions = state(0);
-  const fastRetry = effect([verifyContext], ([ctx]) => {
-    const [[vo, execRaw], item] = ctx;
+  const fastRetry = node([verifyContext], (batchData, _actions) => {
+    const batch2 = batchData[0];
+    if (batch2 == null || batch2.length === 0) return;
+    const ctxVal = batch2[batch2.length - 1];
+    if (ctxVal == null) return;
+    const [vo, execCtx] = ctxVal;
+    const [execRaw, item] = execCtx ?? [null, null];
     if (!vo || !item) return;
     const exec = {
       item,
@@ -6567,8 +6818,7 @@ function harnessLoop(name, opts) {
       detail: vr.findings.join("; ")
     });
     const itemRetries = item._retries ?? 0;
-    if (errClass === "self-correctable" && itemRetries < maxRetries && (totalRetries.get() ?? 0) < maxTotalRetries) {
-      totalRetries.down([[DIRTY], [DATA, (totalRetries.get() ?? 0) + 1]]);
+    if (errClass === "self-correctable" && itemRetries < maxRetries && tryIncrementBounded(totalRetries, maxTotalRetries)) {
       const key = trackingKey(item);
       const retryItem = {
         ...item,
@@ -6582,8 +6832,7 @@ function harnessLoop(name, opts) {
       verifyResults.publish(vr);
       const key = trackingKey(item);
       const itemReingestions = item._reingestions ?? 0;
-      if (itemReingestions < maxReingestions && (totalReingestions.get() ?? 0) < maxTotalReingestions) {
-        totalReingestions.down([[DIRTY], [DATA, (totalReingestions.get() ?? 0) + 1]]);
+      if (itemReingestions < maxReingestions && tryIncrementBounded(totalReingestions, maxTotalReingestions)) {
         intake.publish({
           source: "eval",
           summary: `Verification failed for: ${key}`,
@@ -6636,9 +6885,9 @@ function harnessProfile(harness, opts) {
   return {
     ...base,
     queueDepths,
-    strategyEntries: harness.strategy.node.get()?.size ?? 0,
-    totalRetries: harness.totalRetries.get() ?? 0,
-    totalReingestions: harness.totalReingestions.get() ?? 0
+    strategyEntries: harness.strategy.node.cache?.size ?? 0,
+    totalRetries: harness.totalRetries.cache ?? 0,
+    totalReingestions: harness.totalReingestions.cache ?? 0
   };
 }
 
@@ -6745,56 +6994,69 @@ function truncate(s, max) {
 // src/index.ts
 var version = "0.0.0";
 export {
-  CLEANUP_RESULT,
   COMPLETE,
+  COMPLETE_MSG,
+  COMPLETE_ONLY_BATCH,
   CircuitOpenError,
   DATA,
   DEFAULT_ACTOR,
-  DEFAULT_DOWN,
   DIRTY,
-  DictCheckpointAdapter,
-  DynamicNodeImpl,
+  DIRTY_MSG,
+  DIRTY_ONLY_BATCH,
+  ENVELOPE_VERSION,
   ERROR,
-  FileCheckpointAdapter,
   GRAPH_META_SEGMENT,
   Graph,
+  GraphReFlyConfig,
   GuardDenied,
   INVALIDATE,
+  INVALIDATE_MSG,
+  INVALIDATE_ONLY_BATCH,
   JsonCodec,
-  MemoryCheckpointAdapter,
   NS_PER_MS,
   NS_PER_SEC,
+  NativeIndexBackend,
+  NativeListBackend,
+  NativeLogBackend,
+  NativeMapBackend,
+  NativePubSubBackend,
+  NodeImpl,
   PAUSE,
   RESOLVED,
+  RESOLVED_MSG,
+  RESOLVED_ONLY_BATCH,
   RESUME,
+  RateLimiterOverflowError,
   ResettableTimer,
+  OVERHEAD as SIZEOF_OVERHEAD,
+  SIZEOF_SYMBOL,
   START,
-  SqliteCheckpointAdapter,
+  START_MSG,
   TEARDOWN,
+  TEARDOWN_MSG,
+  TEARDOWN_ONLY_BATCH,
   TimeoutError,
   accessHintForGuard,
   advanceVersion,
   ai_exports as ai,
   audit,
+  autoTrackNode,
   batch,
-  bridge,
   buffer,
   bufferCount,
   bufferTime,
-  cache,
   cached,
   cascadingCache,
   catchError,
-  checkpointNodeValue,
   checkpointToRedis,
   checkpointToS3,
   circuitBreaker,
-  cleanupResult,
   combine,
   combineLatest,
   compat_exports as compat,
   concat,
   concatMap,
+  configure,
   constant,
   core_exports as core,
   cqrs_exports as cqrs,
@@ -6803,14 +7065,19 @@ export {
   createTransport,
   createVersioning,
   createWatermarkController,
+  csvRows,
   debounce,
   debounceTime,
+  decodeEnvelope,
   decorrelatedJitter,
+  defaultConfig,
   defaultHash,
   delay,
   demo_shell_exports as demoShell,
   derived,
   deserializeError,
+  dictStorage,
+  diffForWAL,
   distill,
   distinctUntilChanged,
   domain_templates_exports as domainTemplates,
@@ -6819,12 +7086,16 @@ export {
   effect,
   elementAt,
   empty,
+  encodeEnvelope,
   escapeRegexChar,
   exhaustMap,
   exponential,
+  externalBundle,
+  externalProducer,
   extra_exports as extra,
   fallback,
   fibonacci,
+  fileStorage,
   filter,
   find,
   first,
@@ -6842,6 +7113,8 @@ export {
   fromFSWatch,
   fromGitHook,
   fromHTTP,
+  fromHTTPPoll,
+  fromHTTPStream,
   fromIDBRequest,
   fromIDBTransaction,
   fromIter,
@@ -6857,44 +7130,42 @@ export {
   fromPulsar,
   fromRabbitMQ,
   fromRedisStream,
+  fromSSE,
   fromSqlite,
+  fromSqliteCursor,
   fromStatsD,
   fromSyslog,
   fromTimer,
   fromWebSocket,
+  fromWebSocketReconnect,
   fromWebhook,
   globToRegExp,
   graph_exports as graph,
   graphProfile,
   graphspec_exports as graphspec,
   harness_exports as harness,
+  indexedDbStorage,
   interval,
   isBatching,
-  isKnownMessageType,
-  isLocalOnly,
-  isPhase2Message,
-  isTerminalMessage,
   isV1,
   jotai_exports as jotai,
   keepalive,
-  knownMessageTypes,
   last,
   reactive_layout_exports as layout,
   linear,
-  logSlice,
   lru,
   map,
   matchesAnyPattern,
   matchesCron,
   memory_exports as memory,
+  memoryStorage,
   merge,
   mergeMap,
-  messageTier,
   messaging_exports as messaging,
   monotonicNs,
   nameToSignal,
   nanostores_exports as nanostores,
-  negotiateCodec,
+  ndjsonRows,
   nestjs_exports as nestjs,
   never,
   node,
@@ -6906,14 +7177,12 @@ export {
   parsePrometheusText,
   parseStatsD,
   parseSyslog,
-  partitionForBatch,
   patterns_exports as patterns,
   pausable,
   pipe,
   policy,
   policyFromRules,
   producer,
-  propagatesToMeta,
   pubsub,
   race,
   rateLimiter,
@@ -6924,20 +7193,20 @@ export {
   reactiveList,
   reactiveLog,
   reactiveMap,
+  reactiveSink,
   reduce,
   reduction_exports as reduction,
+  registerBuiltinCodecs,
+  registerBuiltins,
   repeat,
   replay,
   replayWAL,
   rescue,
   resolveBackoffPreset,
   resolveDescribeFields,
-  restoreGraphCheckpoint,
-  restoreGraphCheckpointIndexedDb,
   retry,
+  retrySource,
   sample,
-  saveGraphCheckpoint,
-  saveGraphCheckpointIndexedDb,
   scan,
   serializeError,
   share,
@@ -6947,6 +7216,7 @@ export {
   sizeof,
   skip,
   solid_exports as solid,
+  sqliteStorage,
   state,
   svelte_exports as svelte,
   switchMap,
@@ -6957,12 +7227,12 @@ export {
   throttle,
   throttleTime,
   throwError,
-  tieredStorage,
   timeout,
   toArray,
   toCSV,
   toClickHouse,
   toFile,
+  toHTTP,
   toKafka,
   toLoki,
   toMongo,
@@ -6971,14 +7241,15 @@ export {
   toPostgres,
   toPulsar,
   toRabbitMQ,
+  toReadableStream,
   toRedisStream,
   toS3,
   toSSE,
+  toSSEBytes,
   toSqlite,
   toTempo,
   toWebSocket,
   tokenBucket,
-  tokenTracker,
   valve,
   verifiable,
   version,