@graphrefly/graphrefly 0.25.0 → 0.26.0

package/dist/index.js

@@ -1,3 +1,32 @@
+import {
+  reactive_layout_exports
+} from "./chunk-ZQMEI34O.js";
+import {
+  compat_exports,
+  signals_exports
+} from "./chunk-SN4YWWYO.js";
+import {
+  nanostores_exports
+} from "./chunk-N6UR7YVY.js";
+import {
+  cqrs_exports,
+  nestjs_exports
+} from "./chunk-IZYUSJC7.js";
+import {
+  react_exports
+} from "./chunk-J22W6HV3.js";
+import {
+  solid_exports
+} from "./chunk-HXZEYDUR.js";
+import {
+  svelte_exports
+} from "./chunk-OHISZPOJ.js";
+import {
+  vue_exports
+} from "./chunk-MJ2NKQQL.js";
+import {
+  zustand_exports
+} from "./chunk-JYXEWPH4.js";
 import {
   CircuitOpenError,
   NS_PER_MS,
@@ -48,6 +77,7 @@ import {
   fromCSV,
   fromClickHouseWatch,
   fromDrizzle,
+  fromFSWatch,
   fromGitHook,
   fromHTTP,
   fromHTTPPoll,
@@ -148,33 +178,29 @@ import {
   workerBridge,
   workerSelf,
   zip
-} from "./chunk-IAHGTNOZ.js";
-import {
-  cqrs_exports,
-  nestjs_exports
-} from "./chunk-EVR6UFUV.js";
-import {
-  core_exports
-} from "./chunk-QOWVNWOC.js";
+} from "./chunk-AMCG74RZ.js";
 import {
   NativeLogBackend,
   createWatermarkController,
   reactiveLog,
   toObservable
-} from "./chunk-PY4XCDLR.js";
+} from "./chunk-RB6QPHJ7.js";
+import {
+  core_exports
+} from "./chunk-3ZWCKRHX.js";
 import {
-  graph_exports
-} from "./chunk-MW4VAKAO.js";
+  graph_exports,
+  watchTopologyTree
+} from "./chunk-6LDQFTYS.js";
 import {
-  analyzeAndMeasure,
-  computeLineBreaks,
-  reactive_layout_exports
-} from "./chunk-TKE3JGOH.js";
+  demo_shell_exports
+} from "./chunk-FQMKGR6L.js";
+import "./chunk-LCE3GF5P.js";
 import {
   domainMeta,
   trackingKey,
   tryIncrementBounded
-} from "./chunk-HWPIFSW2.js";
+} from "./chunk-JSCT3CR4.js";
 import {
   cached,
   empty,
@@ -186,7 +212,6 @@ import {
   fromAsyncIter,
   fromCron,
   fromEvent,
-  fromFSWatch,
   fromIter,
   fromPromise,
   fromRaf,
@@ -204,53 +229,35 @@ import {
   shareReplay,
   throwError,
   toArray
-} from "./chunk-L2GLW2U7.js";
+} from "./chunk-BVZYTZ5H.js";
 import {
   GRAPH_META_SEGMENT,
   Graph,
   OVERHEAD,
   SIZEOF_SYMBOL,
+  SNAPSHOT_VERSION,
   diffForWAL,
+  explainPath,
   graphProfile,
   reachable,
   sizeof
-} from "./chunk-XOFWRC73.js";
-import {
-  describeNode,
-  resolveDescribeFields
-} from "./chunk-H4RVA4VE.js";
+} from "./chunk-THTWHNU4.js";
 import {
   ResettableTimer
 } from "./chunk-7TAQJHQV.js";
 import {
-  COMPLETE,
-  COMPLETE_MSG,
-  COMPLETE_ONLY_BATCH,
-  DATA,
+  resolveDescribeFields
+} from "./chunk-VYPWMZ6H.js";
+import {
+  jotai_exports
+} from "./chunk-XGPU467M.js";
+import {
   DEFAULT_ACTOR,
-  DIRTY,
-  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,
@@ -281,855 +288,61 @@ import {
   replayWAL,
   state,
   wallClockNs
-} from "./chunk-5DJTTKX3.js";
-
-// src/compat/index.ts
-var compat_exports = {};
-__export(compat_exports, {
-  jotai: () => jotai_exports,
-  nanostores: () => nanostores_exports,
-  nestjs: () => nestjs_exports,
-  react: () => react_exports,
-  signals: () => signals_exports,
-  solid: () => solid_exports,
-  svelte: () => svelte_exports,
-  vue: () => vue_exports,
-  zustand: () => zustand_exports
-});
-
-// src/compat/jotai/index.ts
-var jotai_exports = {};
-__export(jotai_exports, {
-  atom: () => atom
-});
-function atom(initialOrRead, writeOrOptions, options) {
-  if (typeof initialOrRead === "function") {
-    const read = initialOrRead;
-    if (typeof writeOrOptions === "function") {
-      return createDerivedAtom(read, writeOrOptions, options);
-    }
-    return createDerivedAtom(read, void 0, writeOrOptions);
-  }
-  return createPrimitiveAtom(initialOrRead, writeOrOptions);
-}
-function pull(n) {
-  let val = n.cache;
-  let err;
-  const unsub = n.subscribe((msgs) => {
-    for (const [t, v] of msgs) {
-      if (t === DATA) val = v;
-      if (t === ERROR) err = v;
-    }
-  });
-  unsub();
-  if (err) throw err;
-  return val;
-}
-function createPrimitiveAtom(initial, options) {
-  const n = state(initial, {
-    ...options,
-    resubscribable: true,
-    resetOnTeardown: true
-  });
-  return {
-    get: () => {
-      if (n.status === "sentinel") {
-        return pull(n);
-      }
-      return n.cache;
-    },
-    // 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 === "sentinel" ? pull(n) : n.cache;
-      n.emit(fn(current));
-    },
-    subscribe: (cb) => {
-      let initial2 = true;
-      return n.subscribe((msgs) => {
-        for (const [t, v] of msgs) {
-          if (t === DATA) {
-            if (initial2) {
-              initial2 = false;
-              continue;
-            }
-            cb(v);
-          }
-        }
-      });
-    },
-    meta: n.meta,
-    _node: n
-  };
-}
-function createDerivedAtom(read, write, options) {
-  const n = autoTrackNode(
-    (track) => read((a) => {
-      const dn = a._node;
-      if (dn.status === "sentinel") {
-        pull(dn);
-      }
-      return track(dn);
-    }),
-    {
-      ...options,
-      resubscribable: true,
-      resetOnTeardown: true
-    }
-  );
-  const result = {
-    get: () => {
-      if (n.status === "sentinel") {
-        return pull(n);
-      }
-      return n.cache;
-    },
-    subscribe: (cb) => {
-      let initial = true;
-      return n.subscribe((msgs) => {
-        for (const [t, v] of msgs) {
-          if (t === DATA) {
-            if (initial) {
-              initial = false;
-              continue;
-            }
-            cb(v);
-          }
-        }
-      });
-    },
-    meta: n.meta,
-    _node: n
-  };
-  if (write) {
-    const getFn = (a) => a.get();
-    const setFn = (a, value) => a.set(value);
-    const writable = result;
-    writable.set = (value) => write(getFn, setFn, value);
-    writable.update = (fn) => {
-      const current = n.status === "sentinel" ? pull(n) : n.cache;
-      return write(getFn, setFn, fn(current));
-    };
-    return writable;
-  }
-  return result;
-}
-
-// src/compat/nanostores/index.ts
-var nanostores_exports = {};
-__export(nanostores_exports, {
-  action: () => action,
-  atom: () => atom2,
-  computed: () => computed,
-  getValue: () => getValue,
-  map: () => map2,
-  onMount: () => onMount,
-  onStart: () => onStart,
-  onStop: () => onStop
-});
-var START_LISTENERS = /* @__PURE__ */ new WeakMap();
-var STOP_LISTENERS = /* @__PURE__ */ new WeakMap();
-function trigger(node2, map3) {
-  const callbacks = map3.get(node2);
-  if (callbacks) {
-    for (const cb of callbacks) cb();
-  }
-}
-function createStore(node2, extra = {}) {
-  let listeners = 0;
-  const store = {
-    ...extra,
-    get: () => getVal(node2),
-    subscribe: (cb) => {
-      if (listeners === 0) trigger(node2, START_LISTENERS);
-      listeners++;
-      const sub = node2.subscribe((msgs) => {
-        for (const [t, v] of msgs) {
-          if (t === DATA) cb(v);
-        }
-      });
-      return () => {
-        sub();
-        listeners--;
-        if (listeners === 0) trigger(node2, STOP_LISTENERS);
-      };
-    },
-    listen: (cb) => {
-      if (listeners === 0) trigger(node2, START_LISTENERS);
-      listeners++;
-      let initial = true;
-      const sub = node2.subscribe((msgs) => {
-        for (const [t, v] of msgs) {
-          if (t === DATA) {
-            if (initial) {
-              initial = false;
-              continue;
-            }
-            cb(v);
-          }
-        }
-      });
-      return () => {
-        sub();
-        listeners--;
-        if (listeners === 0) trigger(node2, STOP_LISTENERS);
-      };
-    },
-    _node: node2
-  };
-  return store;
-}
-function pull2(n) {
-  let val = n.cache;
-  let err;
-  const unsub = n.subscribe((msgs) => {
-    for (const [t, v] of msgs) {
-      if (t === DATA) val = v;
-      if (t === ERROR) err = v;
-    }
-  });
-  unsub();
-  if (err) throw err;
-  return val;
-}
-function getVal(n) {
-  if (n.status === "sentinel") {
-    return pull2(n);
-  }
-  return n.cache;
-}
-function atom2(initial) {
-  const n = state(initial, {
-    resubscribable: true,
-    resetOnTeardown: true
-  });
-  return createStore(n, {
-    // `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(
-    depNodes,
-    (track) => {
-      const vals = storeArray.map((s) => {
-        const node2 = s._node;
-        if (node2.status === "sentinel") {
-          pull2(node2);
-        }
-        return track(node2);
-      });
-      return fn(...vals);
-    },
-    {
-      resubscribable: true,
-      resetOnTeardown: true,
-      equals: Object.is
-    }
-  );
-  return createStore(n);
-}
-function map2(initial) {
-  const n = state(initial, {
-    resubscribable: true,
-    resetOnTeardown: true,
-    equals: () => false
-  });
-  return createStore(n, {
-    // `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.emit({ ...current, [key]: value });
-    }
-  });
-}
-function getValue(store) {
-  return store.get();
-}
-function onStart(store, cb) {
-  const node2 = store._node;
-  let callbacks = START_LISTENERS.get(node2);
-  if (!callbacks) {
-    callbacks = /* @__PURE__ */ new Set();
-    START_LISTENERS.set(node2, callbacks);
-  }
-  callbacks.add(cb);
-}
-function onStop(store, cb) {
-  const node2 = store._node;
-  let callbacks = STOP_LISTENERS.get(node2);
-  if (!callbacks) {
-    callbacks = /* @__PURE__ */ new Set();
-    STOP_LISTENERS.set(node2, callbacks);
-  }
-  callbacks.add(cb);
-}
-function onMount(store, cb) {
-  onStart(store, () => {
-    const stop = cb();
-    if (typeof stop === "function") onStop(store, stop);
-  });
-}
-function action(_store, _name, fn) {
-  return (...args) => {
-    let result;
-    batch(() => {
-      result = fn(...args);
-    });
-    return result;
-  };
-}
-
-// src/compat/react/index.ts
-var react_exports = {};
-__export(react_exports, {
-  useStore: () => useStore,
-  useSubscribe: () => useSubscribe,
-  useSubscribeRecord: () => useSubscribeRecord
-});
-import { useCallback, useMemo, useRef, useSyncExternalStore } from "react";
-function useSubscribe(node2) {
-  return useSyncExternalStore(
-    (onStoreChange) => {
-      let disposed = false;
-      const unsub = node2.subscribe(() => {
-        if (!disposed) onStoreChange();
-      });
-      return () => {
-        disposed = true;
-        unsub();
-      };
-    },
-    () => node2.cache,
-    () => node2.cache
-    // Server snapshot
-  );
-}
-function useStore(node2) {
-  const value = useSubscribe(node2);
-  const setter = useCallback(
-    (v) => {
-      node2.down([[DIRTY], [DATA, v]]);
-    },
-    [node2]
-  );
-  return [value, setter];
-}
-function useSubscribeRecord(keysNode, factory) {
-  const factoryRef = useRef(factory);
-  factoryRef.current = factory;
-  const store = useMemo(() => {
-    const computeSnap = () => {
-      const snap = {};
-      const keys = keysNode.cache ?? [];
-      for (const key of keys) {
-        const nodes = factoryRef.current(key);
-        const values = {};
-        for (const field of Object.keys(nodes)) {
-          values[field] = nodes[field].cache;
-        }
-        snap[key] = values;
-      }
-      return snap;
-    };
-    let currentSnapshot = computeSnap();
-    return {
-      subscribe: (onStoreChange) => {
-        let disposed = false;
-        let entrySubs = [];
-        const cleanupEntries = () => {
-          for (const unsub of entrySubs) unsub();
-          entrySubs = [];
-        };
-        const sync = (nextKeys) => {
-          cleanupEntries();
-          for (const key of nextKeys) {
-            const nodes = factoryRef.current(key);
-            for (const field of Object.keys(nodes)) {
-              const unsub = nodes[field].subscribe(() => {
-                currentSnapshot = computeSnap();
-                if (!disposed) onStoreChange();
-              });
-              entrySubs.push(unsub);
-            }
-          }
-          currentSnapshot = computeSnap();
-          if (!disposed) onStoreChange();
-        };
-        const keysUnsub = keysNode.subscribe((msgs) => {
-          const hasSettled = msgs.some((m) => m[0] === DATA || m[0] === RESOLVED);
-          if (!disposed && hasSettled) sync(keysNode.cache ?? []);
-        });
-        sync(keysNode.cache ?? []);
-        return () => {
-          disposed = true;
-          keysUnsub();
-          cleanupEntries();
-        };
-      },
-      getSnapshot: () => currentSnapshot
-    };
-  }, [keysNode]);
-  return useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
-}
-
-// src/compat/signals/index.ts
-var signals_exports = {};
-__export(signals_exports, {
-  Signal: () => Signal
-});
-var trackingStack = [];
-function pull3(n) {
-  let val = n.cache;
-  const unsub = n.subscribe((msgs) => {
-    for (const [t, v] of msgs) {
-      if (t === DATA) val = v;
-    }
-  });
-  unsub();
-  return val;
-}
-var SignalState = class {
-  /** @internal */
-  _node;
-  _equals;
-  constructor(initial, opts) {
-    this._equals = opts?.equals ?? Object.is;
-    this._node = state(initial, {
-      ...opts,
-      resubscribable: true,
-      resetOnTeardown: true
-    });
-  }
-  get() {
-    const tracker = trackingStack[trackingStack.length - 1];
-    if (tracker) {
-      if (this._node.status === "sentinel") {
-        pull3(this._node);
-      }
-      return tracker(this._node);
-    }
-    if (this._node.status === "sentinel") {
-      return pull3(this._node);
-    }
-    return this._node.cache;
-  }
-  set(value) {
-    if (this._equals(this.get(), value)) return;
-    batch(() => {
-      this._node.down([[DIRTY], [DATA, value]]);
-    });
-  }
-};
-var SignalComputed = class {
-  /** @internal */
-  _node;
-  constructor(computation, opts) {
-    this._node = autoTrackNode(
-      (track) => {
-        trackingStack.push(track);
-        try {
-          return computation();
-        } finally {
-          trackingStack.pop();
-        }
-      },
-      {
-        ...opts,
-        describeKind: "derived",
-        resubscribable: true,
-        resetOnTeardown: true
-      }
-    );
-  }
-  get() {
-    const tracker = trackingStack[trackingStack.length - 1];
-    if (tracker) {
-      if (this._node.status === "sentinel") {
-        pull3(this._node);
-      }
-      return tracker(this._node);
-    }
-    if (this._node.status === "sentinel") {
-      return pull3(this._node);
-    }
-    return this._node.cache;
-  }
-};
-var Signal = {
-  State: SignalState,
-  Computed: SignalComputed,
-  /**
-   * Subscribes to changes on a signal.
-   * Returns an unsubscribe callback.
-   *
-   * @example
-   * ```ts
-   * const count = new Signal.State(0);
-   * const unsub = Signal.sub(count, v => console.log(v));
-   * ```
-   */
-  sub: (signal, callback) => {
-    const handlers = typeof callback === "function" ? { data: callback, error: void 0, complete: void 0 } : callback;
-    let initial = true;
-    return signal._node.subscribe((msgs) => {
-      for (const [t, v] of msgs) {
-        if (t === DATA) {
-          if (initial) {
-            initial = false;
-            continue;
-          }
-          handlers.data?.(v);
-        }
-        if (t === ERROR) handlers.error?.(v);
-        if (t === COMPLETE) handlers.complete?.();
-      }
-    });
-  }
-};
-
-// src/compat/solid/index.ts
-var solid_exports = {};
-__export(solid_exports, {
-  useStore: () => useStore2,
-  useSubscribe: () => useSubscribe2,
-  useSubscribeRecord: () => useSubscribeRecord2
-});
-import { createSignal, getOwner, onCleanup } from "solid-js";
-function useSubscribe2(node2) {
-  const [value, setValue] = createSignal(node2.cache, { equals: false });
-  const unsub = node2.subscribe(() => {
-    setValue(() => node2.cache);
-  });
-  if (getOwner()) {
-    onCleanup(() => unsub());
-  } else if (typeof console !== "undefined") {
-    console.warn(
-      "[graphrefly-ts] useSubscribe called outside a Solid reactive owner \u2014 subscription will not be auto-disposed."
-    );
-  }
-  return value;
-}
-function useStore2(node2) {
-  const value = useSubscribe2(node2);
-  const setter = (v) => {
-    node2.down([[DIRTY], [DATA, v]]);
-  };
-  return [value, setter];
-}
-function useSubscribeRecord2(keysNode, factory) {
-  const [value, setValue] = createSignal({}, { equals: false });
-  let entrySubs = [];
-  const cleanupEntries = () => {
-    for (const unsub of entrySubs) unsub();
-    entrySubs = [];
-  };
-  const buildSnapshot = () => {
-    const snap = {};
-    for (const key of keysNode.cache ?? []) {
-      const nodes = factory(key);
-      const values = {};
-      for (const field of Object.keys(nodes)) {
-        values[field] = nodes[field].cache;
-      }
-      snap[key] = values;
-    }
-    return snap;
-  };
-  const sync = (nextKeys) => {
-    cleanupEntries();
-    for (const key of nextKeys) {
-      const nodes = factory(key);
-      for (const field of Object.keys(nodes)) {
-        const unsub = nodes[field].subscribe(() => {
-          setValue(() => buildSnapshot());
-        });
-        entrySubs.push(unsub);
-      }
-    }
-    setValue(() => buildSnapshot());
-  };
-  const keysUnsub = keysNode.subscribe((msgs) => {
-    if (msgs.some((m) => m[0] === DATA || m[0] === RESOLVED)) {
-      sync(keysNode.cache ?? []);
-    }
-  });
-  sync(keysNode.cache ?? []);
-  if (getOwner()) {
-    onCleanup(() => {
-      keysUnsub();
-      cleanupEntries();
-    });
-  } else if (typeof console !== "undefined") {
-    console.warn(
-      "[graphrefly-ts] useSubscribeRecord called outside a Solid reactive owner \u2014 subscription will not be auto-disposed."
-    );
-  }
-  return value;
-}
-
-// src/compat/svelte/index.ts
-var svelte_exports = {};
-__export(svelte_exports, {
-  useStore: () => useStore3,
-  useSubscribe: () => useSubscribe3,
-  useSubscribeRecord: () => useSubscribeRecord3
-});
-function useSubscribe3(node2) {
-  return {
-    subscribe(run) {
-      const unsub = node2.subscribe(() => {
-        run(node2.cache);
-      });
-      run(node2.cache);
-      return unsub;
-    }
-  };
-}
-function useStore3(node2) {
-  return {
-    subscribe(run) {
-      const unsub = node2.subscribe(() => {
-        run(node2.cache);
-      });
-      run(node2.cache);
-      return unsub;
-    },
-    set(value) {
-      node2.down([[DIRTY], [DATA, value]]);
-    },
-    update(updater) {
-      const next = updater(node2.cache);
-      node2.down([[DIRTY], [DATA, next]]);
-    }
-  };
-}
-function useSubscribeRecord3(keysNode, factory) {
-  return {
-    subscribe(run) {
-      let entrySubs = [];
-      const cleanupEntries = () => {
-        for (const unsub of entrySubs) unsub();
-        entrySubs = [];
-      };
-      const buildSnapshot = () => {
-        const snap = {};
-        for (const key of keysNode.cache ?? []) {
-          const nodes = factory(key);
-          const values = {};
-          for (const field of Object.keys(nodes)) {
-            values[field] = nodes[field].cache;
-          }
-          snap[key] = values;
-        }
-        return snap;
-      };
-      const sync = (nextKeys) => {
-        cleanupEntries();
-        for (const key of nextKeys) {
-          const nodes = factory(key);
-          for (const field of Object.keys(nodes)) {
-            const unsub = nodes[field].subscribe(() => {
-              run(buildSnapshot());
-            });
-            entrySubs.push(unsub);
-          }
-        }
-        run(buildSnapshot());
-      };
-      const keysUnsub = keysNode.subscribe((msgs) => {
-        if (msgs.some((m) => m[0] === DATA || m[0] === RESOLVED)) {
-          sync(keysNode.cache ?? []);
-        }
-      });
-      sync(keysNode.cache ?? []);
-      return () => {
-        keysUnsub();
-        cleanupEntries();
-      };
-    }
-  };
-}
-
-// src/compat/vue/index.ts
-var vue_exports = {};
-__export(vue_exports, {
-  useStore: () => useStore4,
-  useSubscribe: () => useSubscribe4,
-  useSubscribeRecord: () => useSubscribeRecord4
-});
+} from "./chunk-PHOUUNK7.js";
 import {
-  computed as computed2,
-  getCurrentScope,
-  isRef,
-  onScopeDispose,
-  readonly,
-  shallowRef,
-  watch
-} from "vue";
-function useSubscribe4(node2) {
-  const ref = shallowRef(node2.cache);
-  const unsub = node2.subscribe(() => {
-    ref.value = node2.cache;
-  });
-  if (getCurrentScope()) {
-    onScopeDispose(() => unsub());
-  } else if (typeof console !== "undefined") {
-    console.warn(
-      "[graphrefly-ts] useSubscribe called outside a Vue scope \u2014 subscription will not be auto-disposed."
-    );
-  }
-  return readonly(ref);
-}
-function useStore4(node2) {
-  const inner = shallowRef(node2.cache);
-  const unsub = node2.subscribe(() => {
-    inner.value = node2.cache;
-  });
-  if (getCurrentScope()) {
-    onScopeDispose(() => unsub());
-  } else if (typeof console !== "undefined") {
-    console.warn(
-      "[graphrefly-ts] useStore called outside a Vue scope \u2014 subscription will not be auto-disposed."
-    );
-  }
-  return computed2({
-    get: () => inner.value,
-    set: (v) => {
-      node2.down([[DIRTY], [DATA, v]]);
-    }
-  });
-}
-function useSubscribeRecord4(keys, factory) {
-  const result = shallowRef({});
-  const activeSubs = /* @__PURE__ */ new Map();
-  function flushResult() {
-    const snap = {};
-    for (const [key, entry] of activeSubs) {
-      snap[key] = { ...entry.values };
-    }
-    result.value = snap;
-  }
-  function sync(newKeys) {
-    for (const entry of activeSubs.values()) {
-      for (const unsub of entry.subs) unsub();
-    }
-    activeSubs.clear();
-    for (const key of newKeys) {
-      const nodes = factory(key);
-      const fields = Object.keys(nodes);
-      const values = {};
-      const subs = [];
-      for (const field of fields) {
-        const node2 = nodes[field];
-        values[field] = node2.cache;
-        const unsub = node2.subscribe(() => {
-          values[field] = node2.cache;
-          flushResult();
-        });
-        subs.push(unsub);
-      }
-      activeSubs.set(key, { subs, values });
-    }
-    const snap = {};
-    for (const [key, entry] of activeSubs) {
-      snap[key] = { ...entry.values };
-    }
-    result.value = snap;
-  }
-  const readKeys = () => {
-    const current = typeof keys === "function" ? keys() : isRef(keys) ? keys.value : keys;
-    return [...current ?? []];
-  };
-  watch(readKeys, (newKeys) => sync(newKeys ?? []), { immediate: true });
-  if (getCurrentScope()) {
-    onScopeDispose(() => {
-      for (const entry of activeSubs.values()) {
-        for (const unsub of entry.subs) unsub();
-      }
-      activeSubs.clear();
-    });
-  } else if (typeof console !== "undefined") {
-    console.warn(
-      "[graphrefly-ts] useSubscribeRecord called outside a Vue scope \u2014 subscription will not be auto-disposed."
-    );
-  }
-  return readonly(result);
-}
-
-// src/compat/zustand/index.ts
-var zustand_exports = {};
-__export(zustand_exports, {
-  create: () => create
-});
-var alwaysDiffer = () => false;
-function create(initializer) {
-  const g = new Graph("zustand");
-  const s = state(void 0, {
-    name: "state",
-    equals: alwaysDiffer
-  });
-  g.add("state", s);
-  const getState = () => s.cache;
-  const setState = (partial, replace) => {
-    const prev = s.cache;
-    const next = typeof partial === "function" ? partial(prev) : partial;
-    s.emit(replace ? next : { ...prev, ...next });
-  };
-  const api = {
-    getState,
-    setState,
-    getInitialState: () => initialValue,
-    subscribe: (listener) => {
-      let initial = true;
-      let prev = s.cache;
-      return s.subscribe((msgs) => {
-        for (const [t, v] of msgs) {
-          if (t === DATA) {
-            if (initial) {
-              initial = false;
-              continue;
-            }
-            listener(v, prev);
-            prev = v;
-          }
-        }
-      });
-    },
-    destroy: g.destroy.bind(g)
-  };
-  const initialValue = initializer(setState, getState, api);
-  s.emit(initialValue);
-  return Object.assign(g, api);
-}
+  COMPLETE,
+  COMPLETE_MSG,
+  COMPLETE_ONLY_BATCH,
+  DATA,
+  DIRTY,
+  DIRTY_MSG,
+  DIRTY_ONLY_BATCH,
+  ERROR,
+  INVALIDATE,
+  INVALIDATE_MSG,
+  INVALIDATE_ONLY_BATCH,
+  PAUSE,
+  RESOLVED,
+  RESOLVED_MSG,
+  RESOLVED_ONLY_BATCH,
+  RESUME,
+  START,
+  START_MSG,
+  TEARDOWN,
+  TEARDOWN_MSG,
+  TEARDOWN_ONLY_BATCH,
+  __export
+} from "./chunk-SX52TAR4.js";
 
 // src/patterns/index.ts
 var patterns_exports = {};
 __export(patterns_exports, {
+  SNAPSHOT_WIRE_VERSION: () => SNAPSHOT_WIRE_VERSION,
+  SurfaceError: () => SurfaceError,
+  accountability: () => audit_exports,
   ai: () => ai_exports,
+  asSurfaceError: () => asSurfaceError,
   cqrs: () => cqrs_exports,
+  createGraph: () => createGraph,
+  deleteSnapshot: () => deleteSnapshot,
   demoShell: () => demo_shell_exports,
+  diffSnapshots: () => diffSnapshots,
   domainTemplates: () => domain_templates_exports,
   graphspec: () => graphspec_exports,
+  guarded: () => guarded_execution_exports,
   harness: () => harness_exports,
   layout: () => reactive_layout_exports,
+  lens: () => lens_exports,
+  listSnapshots: () => listSnapshots,
   memory: () => memory_exports,
   messaging: () => messaging_exports,
   orchestration: () => orchestration_exports,
-  reduction: () => reduction_exports
+  reduction: () => reduction_exports,
+  resilientPipeline: () => resilient_pipeline_exports,
+  restoreSnapshot: () => restoreSnapshot,
+  runReduction: () => runReduction,
+  saveSnapshot: () => saveSnapshot,
+  surface: () => surface_exports
 });
 
 // src/patterns/ai.ts
@@ -4167,308 +3380,418 @@ async function suggestStrategy(graph, problem, adapter, opts) {
   };
 }
 
-// src/patterns/demo-shell.ts
-var demo_shell_exports = {};
-__export(demo_shell_exports, {
-  demoShell: () => demoShell
+// src/patterns/audit.ts
+var audit_exports = {};
+__export(audit_exports, {
+  AuditTrailGraph: () => AuditTrailGraph,
+  PolicyEnforcerGraph: () => PolicyEnforcerGraph,
+  auditTrail: () => auditTrail,
+  complianceSnapshot: () => complianceSnapshot,
+  policyEnforcer: () => policyEnforcer,
+  reactiveExplainPath: () => reactiveExplainPath
 });
-function clamp01(v) {
-  return Math.max(0, Math.min(1, v));
-}
-function demoShell(opts) {
-  const mainRatioInit = clamp01(opts?.mainRatio ?? 0.65);
-  const sideSplitInit = clamp01(opts?.sideSplit ?? 0.5);
-  const viewportInit = Math.max(0, opts?.viewportWidth ?? 1280);
-  const registry = opts?.nodeRegistry ?? /* @__PURE__ */ new Map();
-  const adapter = opts?.adapter ?? null;
-  const layoutFont = opts?.layoutFont ?? "14px monospace";
-  const onHighlight = opts?.onHighlight;
-  const g = new Graph("demo-shell");
-  const paneMainRatio = state(mainRatioInit, { name: "pane/main-ratio" });
-  const paneSideSplit = state(sideSplitInit, { name: "pane/side-split" });
-  const paneFullscreen = state(null, {
-    name: "pane/fullscreen"
-  });
-  const viewportWidth = state(viewportInit, { name: "viewport/width" });
-  g.add("pane/main-ratio", paneMainRatio);
-  g.add("pane/side-split", paneSideSplit);
-  g.add("pane/fullscreen", paneFullscreen);
-  g.add("viewport/width", viewportWidth);
-  const paneMainWidth = derived(
-    [paneMainRatio, viewportWidth, paneFullscreen],
-    ([ratio, vw, fs]) => {
-      const r = ratio;
-      const w = vw;
-      const fullscreen = fs;
-      if (fullscreen === "main") return w;
-      if (fullscreen === "graph" || fullscreen === "code") return 0;
-      return Math.round(w * r);
-    },
-    { name: "pane/main-width" }
-  );
-  const paneSideWidth = derived(
-    [paneMainWidth, viewportWidth, paneFullscreen],
-    ([main, vw, fs]) => {
-      const fullscreen = fs;
-      const w = vw;
-      if (fullscreen === "main") return 0;
-      if (fullscreen === "graph" || fullscreen === "code") return w;
-      return w - main;
-    },
-    { name: "pane/side-width" }
-  );
-  const paneGraphHeight = derived(
-    [paneSideSplit, paneFullscreen],
-    ([split, fs]) => {
-      const fullscreen = fs;
-      if (fullscreen === "graph") return 1;
-      if (fullscreen === "code") return 0;
-      if (fullscreen === "main") return 0;
-      return clamp01(split);
-    },
-    { name: "pane/graph-height-ratio" }
-  );
-  const paneCodeHeight = derived(
-    [paneGraphHeight, paneFullscreen],
-    ([graphH, fs]) => {
-      const fullscreen = fs;
-      if (fullscreen === "code") return 1;
-      if (fullscreen === "graph" || fullscreen === "main") return 0;
-      return 1 - graphH;
-    },
-    { name: "pane/code-height-ratio" }
-  );
-  g.add("pane/main-width", paneMainWidth);
-  g.add("pane/side-width", paneSideWidth);
-  g.add("pane/graph-height-ratio", paneGraphHeight);
-  g.add("pane/code-height-ratio", paneCodeHeight);
-  const demoGraphRef = state(null, {
-    name: "demo/graph-ref"
-  });
-  const demoGraphTick = state(0, { name: "demo/graph-tick" });
-  g.add("demo/graph-ref", demoGraphRef);
-  g.add("demo/graph-tick", demoGraphTick);
-  const graphMermaid = derived(
-    [demoGraphRef, demoGraphTick],
-    ([ref, _tick]) => {
-      const demo = ref;
-      if (!demo) return "";
-      return demo.describe({ format: "mermaid" });
-    },
-    { name: "graph/mermaid" }
-  );
-  const graphDescribe = derived(
-    [demoGraphRef, demoGraphTick],
-    ([ref, _tick]) => {
-      const demo = ref;
-      if (!demo) return null;
-      const { expand: _, ...snapshot } = demo.describe({ detail: "standard" });
-      return snapshot;
-    },
-    { name: "graph/describe" }
-  );
-  g.add("graph/mermaid", graphMermaid);
-  g.add("graph/describe", graphDescribe);
-  const hoverTarget = state(null, { name: "hover/target" });
-  g.add("hover/target", hoverTarget);
-  const highlightCodeScroll = derived(
-    [hoverTarget],
-    ([target]) => {
-      const t = target;
-      if (!t) return null;
-      const entry = registry.get(t.id);
-      return entry ? entry.codeLine : null;
-    },
-    { name: "highlight/code-scroll" }
-  );
-  const highlightVisual = derived(
-    [hoverTarget],
-    ([target]) => {
-      const t = target;
-      if (!t) return null;
-      const entry = registry.get(t.id);
-      return entry ? entry.visualSelector : null;
-    },
-    { name: "highlight/visual" }
-  );
-  const highlightGraph = derived(
-    [hoverTarget],
-    ([target]) => {
-      const t = target;
-      if (!t) return null;
-      return t.id;
-    },
-    { name: "highlight/graph" }
-  );
-  g.add("highlight/code-scroll", highlightCodeScroll);
-  g.add("highlight/visual", highlightVisual);
-  g.add("highlight/graph", highlightGraph);
-  if (onHighlight?.codeScroll) {
-    const cb = onHighlight.codeScroll;
-    const applyCodeScroll = effect([highlightCodeScroll], ([line]) => {
-      cb(line);
+function auditMeta(kind, extra) {
+  return domainMeta("audit", kind, extra);
+}
+var DEFAULT_INCLUDE_TYPES = /* @__PURE__ */ new Set([
+  "data",
+  "error",
+  "complete",
+  "teardown"
+]);
+var AuditTrailGraph = class extends Graph {
+  entries;
+  count;
+  _log;
+  _target;
+  constructor(target, opts) {
+    super(opts.name ?? `${target.name}_audit`, opts.graph);
+    this._target = target;
+    this._log = reactiveLog([], {
+      name: "entries",
+      ...opts.maxSize != null ? { maxSize: opts.maxSize } : {}
     });
-    g.add("highlight/apply-code-scroll", applyCodeScroll);
+    this.entries = this._log.entries;
+    this.add("entries", this.entries);
+    this.count = derived(
+      [this.entries],
+      ([snapshot]) => snapshot.length,
+      { name: "count", describeKind: "derived", meta: auditMeta("count") }
+    );
+    this.add("count", this.count);
+    this.addDisposer(keepalive(this.count));
+    const includeTypes = opts.includeTypes != null ? new Set(opts.includeTypes) : DEFAULT_INCLUDE_TYPES;
+    const filter2 = opts.filter;
+    let seq = 0;
+    const handle = target.observe({ timeline: true, structured: true });
+    const offEvent = handle.onEvent((event) => {
+      if (event.type === "derived") return;
+      const type = event.type;
+      if (!includeTypes.has(type)) return;
+      const path = event.path ?? "";
+      const entry = {
+        seq: seq++,
+        timestamp_ns: event.timestamp_ns ?? monotonicNs(),
+        wall_clock_ns: wallClockNs(),
+        path,
+        type
+      };
+      const node2 = path ? safeNode(target, path) : void 0;
+      const lastMutation = node2?.lastMutation;
+      if (lastMutation != null) entry.actor = lastMutation.actor;
+      if (type === "data") entry.value = event.data;
+      if (type === "error") entry.error = event.data;
+      const reason = path ? safeAnnotation(target, path) : void 0;
+      if (reason != null) entry.reason = reason;
+      if (filter2 != null && !filter2(entry)) return;
+      this._log.append(entry);
+    });
+    this.addDisposer(() => {
+      offEvent();
+      handle.dispose();
+    });
+    this.addDisposer(() => this._log.disposeAllViews());
+  }
+  /** All entries currently in the ring (snapshot). */
+  all() {
+    return this.entries.cache ?? [];
+  }
+  /** Entries matching `path`. Order preserved. */
+  byNode(path) {
+    return this.all().filter((e) => e.path === path);
+  }
+  /** Entries whose `actor.id` matches. Use `byActorType` for type filtering. */
+  byActor(actorId) {
+    return this.all().filter((e) => e.actor?.id === actorId);
+  }
+  /** Entries whose `actor.type` matches (e.g. `"llm"`, `"human"`). */
+  byActorType(type) {
+    return this.all().filter((e) => e.actor?.type === type);
+  }
+  /**
+   * Entries with `timestamp_ns` in `[start_ns, end_ns)` (end exclusive).
+   * Omit `end_ns` to query open-ended.
+   */
+  byTimeRange(start_ns, end_ns) {
+    return this.all().filter((e) => {
+      if (e.timestamp_ns < start_ns) return false;
+      if (end_ns != null && e.timestamp_ns >= end_ns) return false;
+      return true;
+    });
+  }
+  /** Reference to the audited graph (escape hatch for tooling). */
+  get target() {
+    return this._target;
+  }
+};
+function auditTrail(target, opts = {}) {
+  return new AuditTrailGraph(target, opts);
+}
+var PolicyEnforcerGraph = class extends Graph {
+  policies;
+  violations;
+  violationCount;
+  _target;
+  _mode;
+  _currentGuard;
+  constructor(target, policies, opts) {
+    super(opts.name ?? `${target.name}_policy`, opts.graph);
+    this._target = target;
+    this._mode = opts.mode ?? "audit";
+    const policiesNode = isNode(policies) ? policies : state(policies, { name: "policies" });
+    this.policies = policiesNode;
+    this.add("policies", this.policies);
+    this.violations = new TopicGraph("violations", {
+      retainedLimit: opts.violationsLimit ?? 1e3
+    });
+    this.mount("violations", this.violations);
+    this.violationCount = derived(
+      [this.violations.events],
+      ([snapshot]) => snapshot.length,
+      {
+        name: "violationCount",
+        describeKind: "derived",
+        meta: auditMeta("policy_violation_count")
+      }
+    );
+    this.add("violationCount", this.violationCount);
+    this.addDisposer(keepalive(this.violationCount));
+    const initialRules = policiesNode.cache ?? [];
+    let latestRules = initialRules;
+    this._currentGuard = policyFromRules(latestRules);
+    const offPolicies = policiesNode.subscribe((msgs) => {
+      for (const m of msgs) {
+        if (m[0] === DATA) {
+          latestRules = m[1] ?? [];
+          this._currentGuard = policyFromRules(latestRules);
+        }
+      }
+    });
+    this.addDisposer(offPolicies);
+    const paths = opts.paths != null ? [...opts.paths] : collectPaths(target);
+    if (this._mode === "enforce") {
+      const restorers = /* @__PURE__ */ new Map();
+      const wrapAndPush = (path) => {
+        if (restorers.has(path)) return;
+        const node2 = safeNode(target, path);
+        if (!(node2 instanceof NodeImpl)) return;
+        const pathGuard = (actor, action) => {
+          const ok = this._currentGuard(actor, action);
+          if (!ok) {
+            this._publishViolation(actor, action, path, "blocked");
+          }
+          return ok;
+        };
+        restorers.set(path, node2._pushGuard(pathGuard));
+      };
+      for (const path of paths) wrapAndPush(path);
+      if (opts.paths == null) {
+        const offTopology = watchTopologyTree(target, (event, emitter, prefix) => {
+          if (event.kind === "added") {
+            if (event.nodeKind === "node") {
+              wrapAndPush(`${prefix}${event.name}`);
+            } else {
+              const child = emitter._mounts.get(event.name);
+              if (!(child instanceof Graph)) return;
+              const mountPrefix = `${prefix}${event.name}::`;
+              const localPaths = collectPaths(child);
+              for (const localPath of localPaths) {
+                wrapAndPush(
+                  localPath === "" ? `${prefix}${event.name}` : `${mountPrefix}${localPath}`
+                );
+              }
+            }
+          } else if (event.kind === "removed") {
+            if (event.nodeKind === "node") {
+              const qp = `${prefix}${event.name}`;
+              const r = restorers.get(qp);
+              if (r != null) {
+                r();
+                restorers.delete(qp);
+              }
+            } else {
+              const mountQp = `${prefix}${event.name}`;
+              const mountPrefix = `${mountQp}::`;
+              for (const [p, r] of restorers) {
+                if (p === mountQp || p.startsWith(mountPrefix)) {
+                  r();
+                  restorers.delete(p);
+                }
+              }
+            }
+          }
+        });
+        this.addDisposer(offTopology);
+      } else {
+        const offCleanup = target.topology.subscribe((msgs) => {
+          for (const m of msgs) {
+            if (m[0] !== DATA) continue;
+            const event = m[1];
+            if (event.kind !== "removed" || event.nodeKind !== "node") continue;
+            const r = restorers.get(event.name);
+            if (r != null) {
+              r();
+              restorers.delete(event.name);
+            }
+          }
+        });
+        this.addDisposer(offCleanup);
+      }
+      this.addDisposer(() => {
+        for (const r of restorers.values()) r();
+        restorers.clear();
+      });
+    } else {
+      const handle = target.observe({ timeline: true, structured: true });
+      const off = handle.onEvent((event) => {
+        if (event.type !== "data" && event.type !== "error") return;
+        const path = event.path ?? "";
+        if (!path) return;
+        if (opts.paths != null && !opts.paths.includes(path)) return;
+        const node2 = safeNode(target, path);
+        const lastMutation = node2?.lastMutation;
+        if (lastMutation == null) return;
+        const action = "write";
+        if (this._currentGuard(lastMutation.actor, action)) return;
+        this._publishViolation(lastMutation.actor, action, path, "observed");
+      });
+      this.addDisposer(() => {
+        off();
+        handle.dispose();
+      });
+    }
   }
-  if (onHighlight?.visual) {
-    const cb = onHighlight.visual;
-    const applyVisual = effect([highlightVisual], ([selector]) => {
-      cb(selector);
+  _publishViolation(actor, action, path, result) {
+    this.violations.publish({
+      timestamp_ns: monotonicNs(),
+      wall_clock_ns: wallClockNs(),
+      path,
+      actor,
+      action,
+      mode: this._mode,
+      result
     });
-    g.add("highlight/apply-visual", applyVisual);
   }
-  if (onHighlight?.graph) {
-    const cb = onHighlight.graph;
-    const applyGraph = effect([highlightGraph], ([nodeId]) => {
-      cb(nodeId);
-    });
-    g.add("highlight/apply-graph", applyGraph);
+  /** Snapshot of recorded violations. */
+  all() {
+    return this.violations.retained();
+  }
+  get mode() {
+    return this._mode;
   }
-  const inspectSelected = state(null, {
-    name: "inspect/selected-node"
+  get target() {
+    return this._target;
+  }
+};
+function policyEnforcer(target, policies, opts = {}) {
+  return new PolicyEnforcerGraph(target, policies, opts);
+}
+function reactiveExplainPath(target, from, to, opts) {
+  let v = 0;
+  const version2 = state(v, { name: "explain_version" });
+  const handle = target.observe({ timeline: true, structured: true });
+  const off = handle.onEvent((event) => {
+    const t = event.type;
+    if (t !== "data" && t !== "error" && t !== "complete" && t !== "teardown") return;
+    v += 1;
+    version2.emit(v);
   });
-  g.add("inspect/selected-node", inspectSelected);
-  const standardFields = resolveDescribeFields("standard");
-  const inspectNodeDetail = derived(
-    [inspectSelected, demoGraphRef, demoGraphTick],
-    ([path, ref, _tick]) => {
-      const demo = ref;
-      const p = path;
-      if (!demo || !p) return null;
-      try {
-        const nd = demo.resolve(p);
-        const nodeDesc = describeNode(nd, standardFields);
-        return { path: p, ...nodeDesc, value: nd.cache };
-      } catch {
-        return null;
+  const explainOpts = {
+    ...opts?.maxDepth != null ? { maxDepth: opts.maxDepth } : {},
+    ...opts?.findCycle === true ? { findCycle: true } : {}
+  };
+  const node2 = derived([version2], () => target.explain(from, to, explainOpts), {
+    name: opts?.name ?? "explain",
+    describeKind: "derived",
+    equals: (a, b) => a.found === b.found && a.reason === b.reason && a.steps.length === b.steps.length && causalStepsEqual(a.steps, b.steps),
+    meta: auditMeta("explain_path", { from, to })
+  });
+  const stopKeepalive = keepalive(node2);
+  return {
+    node: node2,
+    dispose() {
+      off();
+      handle.dispose();
+      stopKeepalive();
+    }
+  };
+}
+function causalStepsEqual(a, b) {
+  for (let i = 0; i < a.length; i++) {
+    const x = a[i];
+    const y = b[i];
+    if (x.path !== y.path) return false;
+    if (x.type !== y.type) return false;
+    if (x.status !== y.status) return false;
+    if (x.hop !== y.hop) return false;
+    if (x.dep_index !== y.dep_index) return false;
+    if (x.reason !== y.reason) return false;
+    if (x.value !== y.value) return false;
+    if (x.lastMutation !== y.lastMutation) return false;
+    const xv = x.v;
+    const yv = y.v;
+    if (xv !== yv) {
+      if (xv == null || yv == null) return false;
+      if (xv.id !== yv.id || xv.version !== yv.version) return false;
+    }
+  }
+  return true;
+}
+function complianceSnapshot(target, opts = {}) {
+  const result = {
+    format_version: 1,
+    timestamp_ns: monotonicNs(),
+    wall_clock_ns: wallClockNs(),
+    graph: target.snapshot()
+  };
+  if (opts.actor != null) result.actor = opts.actor;
+  if (opts.audit != null) {
+    const entries = [...opts.audit.all()];
+    result.audit = { count: entries.length, entries };
+  }
+  if (opts.policies != null) {
+    const rules = opts.policies.policies.cache ?? [];
+    result.policies = {
+      mode: opts.policies.mode,
+      rules,
+      violations: [...opts.policies.all()]
+    };
+  }
+  const fingerprint = computeFingerprint(result);
+  return { ...result, fingerprint };
+}
+function isNode(x) {
+  return typeof x === "object" && x !== null && "subscribe" in x;
+}
+function safeNode(target, path) {
+  try {
+    return target.node(path);
+  } catch {
+    return void 0;
+  }
+}
+function safeAnnotation(target, path) {
+  try {
+    return target.annotation(path);
+  } catch {
+    return void 0;
+  }
+}
+function collectPaths(target) {
+  const described = target.describe({ detail: "minimal" });
+  return Object.keys(described.nodes);
+}
+function computeFingerprint(value) {
+  return defaultHash(JSON.stringify(canonicalize(value)));
+}
+function canonicalize(value) {
+  const stack = /* @__PURE__ */ new Set();
+  const walk = (v) => {
+    if (v === void 0) return { __undefined: true };
+    if (v === null) return null;
+    const t = typeof v;
+    if (t === "bigint") return { __bigint: v.toString() };
+    if (t !== "object") return v;
+    const obj = v;
+    if (stack.has(obj)) return { __circular: true };
+    stack.add(obj);
+    try {
+      if (Array.isArray(obj)) {
+        return obj.map(walk);
       }
-    },
-    { name: "inspect/node-detail" }
-  );
-  const inspectTraceLog = derived(
-    [demoGraphRef, demoGraphTick],
-    ([ref, _tick]) => {
-      const demo = ref;
-      if (!demo) return [];
-      return demo.trace();
-    },
-    { name: "inspect/trace-log" }
-  );
-  g.add("inspect/node-detail", inspectNodeDetail);
-  g.add("inspect/trace-log", inspectTraceLog);
-  const metaDebug = state(false, { name: "meta/debug" });
-  g.add("meta/debug", metaDebug);
-  const metaShellMermaid = derived(
-    [metaDebug, demoGraphTick],
-    ([debug, _tick]) => {
-      if (!debug) return "";
-      return g.describe({ format: "mermaid" });
-    },
-    { name: "meta/shell-mermaid" }
-  );
-  g.add("meta/shell-mermaid", metaShellMermaid);
-  const codeTextNode = state("", { name: "layout/code-text" });
-  g.add("layout/code-text", codeTextNode);
-  if (adapter) {
-    const measureCache = /* @__PURE__ */ new Map();
-    const graphLabels = derived(
-      [graphDescribe],
-      ([desc]) => {
-        const d = desc;
-        if (!d) return /* @__PURE__ */ new Map();
-        const result = /* @__PURE__ */ new Map();
-        for (const [name] of Object.entries(d.nodes)) {
-          const segments = analyzeAndMeasure(name, layoutFont, adapter, measureCache);
-          const lb = computeLineBreaks(segments, Infinity, adapter, layoutFont, measureCache);
-          const width = lb.lines.reduce((max, l) => Math.max(max, l.width), 0);
-          const height = lb.lineCount * 20;
-          result.set(name, { width, height });
-        }
-        return result;
-      },
-      {
-        name: "layout/graph-labels",
-        equals: (a, b) => {
-          if (a === b) return true;
-          const ma = a;
-          const mb = b;
-          if (ma.size !== mb.size) return false;
-          for (const [k, v] of ma) {
-            const bv = mb.get(k);
-            if (!bv || bv.width !== v.width || bv.height !== v.height) return false;
-          }
-          return true;
-        }
+      if (obj instanceof Date) {
+        return { __date: obj.toISOString() };
       }
-    );
-    const codeLines = derived(
-      [codeTextNode, paneSideWidth],
-      ([text, sideW]) => {
-        const t = text;
-        if (!t) return { lineCount: 0, lines: [] };
-        const segments = analyzeAndMeasure(t, layoutFont, adapter, measureCache);
-        const maxW = sideW - 40;
-        return computeLineBreaks(segments, Math.max(100, maxW), adapter, layoutFont, measureCache);
-      },
-      { name: "layout/code-lines" }
-    );
-    const sideWidthHint = derived(
-      [graphLabels],
-      ([labels]) => {
-        const m = labels;
-        if (m.size === 0) return 200;
-        let maxW = 0;
-        for (const { width } of m.values()) {
-          if (width > maxW) maxW = width;
-        }
-        return Math.max(200, Math.round(maxW + 80));
-      },
-      { name: "layout/side-width-hint" }
-    );
-    g.add("layout/graph-labels", graphLabels);
-    g.add("layout/code-lines", codeLines);
-    g.add("layout/side-width-hint", sideWidthHint);
-  }
-  let tickCounter = 0;
-  return {
-    graph: g,
-    setMainRatio(ratio) {
-      g.set("pane/main-ratio", clamp01(ratio));
-    },
-    setSideSplit(ratio) {
-      g.set("pane/side-split", clamp01(ratio));
-    },
-    setFullscreen(pane) {
-      g.set("pane/fullscreen", pane);
-    },
-    setViewportWidth(width) {
-      g.set("viewport/width", Math.max(0, width));
-    },
-    setHoverTarget(target) {
-      g.set("hover/target", target);
-    },
-    setDemoGraph(demo) {
-      g.set("demo/graph-ref", demo);
-    },
-    bumpGraphTick() {
-      g.set("demo/graph-tick", ++tickCounter);
-    },
-    selectNode(path) {
-      g.set("inspect/selected-node", path);
-    },
-    setMetaDebug(on) {
-      g.set("meta/debug", on);
-    },
-    setCodeText(text) {
-      g.set("layout/code-text", text);
-    },
-    batch(fn) {
-      batch(fn);
-    },
-    destroy() {
-      g.destroy();
+      if (obj instanceof RegExp) {
+        return { __regexp: { source: obj.source, flags: obj.flags } };
+      }
+      if (obj instanceof Map) {
+        const entries = [...obj.entries()].map(([k, mv]) => [
+          walk(k),
+          walk(mv)
+        ]);
+        return { __map: entries };
+      }
+      if (obj instanceof Set) {
+        const items = [...obj].map(walk);
+        return { __set: items };
+      }
+      if (ArrayBuffer.isView(obj)) {
+        const ta = obj;
+        const arr = new Array(ta.length);
+        for (let i = 0; i < ta.length; i++) arr[i] = ta[i] ?? 0;
+        return { __typed_array: { ctor: obj.constructor.name, data: arr } };
+      }
+      const out = {};
+      for (const k of Object.keys(obj).sort()) {
+        out[k] = walk(obj[k]);
+      }
+      return out;
+    } finally {
+      stack.delete(obj);
     }
   };
+  return walk(value);
 }
 
 // src/patterns/domain-templates.ts
@@ -6301,6 +5624,65 @@ ${validation.errors.join("\n")}`);
   return parsed;
 }
 
+// src/patterns/guarded-execution.ts
+var guarded_execution_exports = {};
+__export(guarded_execution_exports, {
+  GuardedExecutionGraph: () => GuardedExecutionGraph,
+  guardedExecution: () => guardedExecution
+});
+var GuardedExecutionGraph = class extends Graph {
+  enforcer;
+  violations;
+  _target;
+  _defaultActor;
+  constructor(target, opts) {
+    super(opts.name ?? `${target.name}_guarded`, opts.graph);
+    this._target = target;
+    this._defaultActor = opts.actor;
+    const enforcerOpts = {
+      mode: opts.mode ?? "enforce",
+      name: "enforcer"
+    };
+    if (opts.violationsLimit != null) enforcerOpts.violationsLimit = opts.violationsLimit;
+    this.enforcer = policyEnforcer(target, opts.policies, enforcerOpts);
+    this.violations = this.enforcer.violations;
+    this.mount("enforcer", this.enforcer);
+  }
+  /**
+   * Describe the **target** graph scoped to the configured actor. Returns
+   * only nodes the actor is permitted to see (via the target's node guards
+   * filtering `describe()` via `actor`).
+   *
+   * Pass `{actor}` in opts to override the configured actor for this call.
+   * Pass any standard {@link GraphDescribeOptions} fields (`detail`,
+   * `fields`, `filter`) — they apply to the target's describe.
+   *
+   * **Mode interaction:**
+   * - In `mode: "enforce"` (default), the enforcer stacks a policy-derived
+   *   guard on every target node. `scopedDescribe({actor})` then filters by
+   *   the AND of per-node guards AND the stacked policy guard.
+   * - In `mode: "audit"`, NO guards are stacked — `scopedDescribe` filters
+   *   purely by the target's pre-existing per-node guards. If a target has
+   *   no node-level guards, the policy rules you pass have no effect on
+   *   visibility (they only populate the `violations` topic on writes).
+   */
+  scopedDescribe(opts) {
+    const actor = opts?.actor ?? this._defaultActor;
+    const describeOpts = {
+      ...opts,
+      ...actor != null ? { actor } : {}
+    };
+    return this._target.describe(describeOpts);
+  }
+  /** The wrapped graph (escape hatch for tooling). */
+  get target() {
+    return this._target;
+  }
+};
+function guardedExecution(target, opts) {
+  return new GuardedExecutionGraph(target, opts);
+}
+
 // src/patterns/harness/index.ts
 var harness_exports = {};
 __export(harness_exports, {
@@ -6379,8 +5761,8 @@ function evalIntakeBridge(evalSource2, intakeTopic, opts) {
     { name: opts?.name ?? "eval-intake-bridge" }
   );
 }
-function evalSource(trigger2, runner) {
-  return switchMap(trigger2, () => fromAny(runner()));
+function evalSource(trigger, runner) {
+  return switchMap(trigger, () => fromAny(runner()));
 }
 function beforeAfterCompare(before, after) {
   return derived(
@@ -6982,6 +6364,636 @@ function truncate(s, max) {
   return s.length > max ? `${s.slice(0, max - 1)}\u2026` : s;
 }
 
+// src/patterns/lens.ts
+var lens_exports = {};
+__export(lens_exports, {
+  LensGraph: () => LensGraph,
+  graphLens: () => graphLens,
+  watchTopologyTree: () => watchTopologyTree
+});
+function lensMeta(kind) {
+  return domainMeta("lens", kind);
+}
+function computeTopologyStats(described) {
+  const paths = Object.keys(described.nodes);
+  const depsByPath = /* @__PURE__ */ new Map();
+  const dependents = /* @__PURE__ */ new Map();
+  for (const path of paths) {
+    const deps = described.nodes[path]?.deps ?? [];
+    depsByPath.set(path, deps);
+    for (const dep of deps) {
+      if (!dependents.has(dep)) dependents.set(dep, /* @__PURE__ */ new Set());
+      dependents.get(dep).add(path);
+    }
+  }
+  const sources = [];
+  const sinks = [];
+  for (const path of paths) {
+    if ((depsByPath.get(path) ?? []).length === 0) sources.push(path);
+    if (!dependents.has(path)) sinks.push(path);
+  }
+  sources.sort();
+  sinks.sort();
+  const edgeCount = described.edges.length;
+  const WHITE = 0;
+  const GRAY = 1;
+  const BLACK = 2;
+  const color = /* @__PURE__ */ new Map();
+  for (const p of paths) color.set(p, WHITE);
+  let hasCycles = false;
+  const longestFrom = /* @__PURE__ */ new Map();
+  const dfs = (path) => {
+    const c = color.get(path) ?? WHITE;
+    if (c === GRAY) {
+      hasCycles = true;
+      return 0;
+    }
+    if (c === BLACK) return longestFrom.get(path) ?? 0;
+    color.set(path, GRAY);
+    let best = 0;
+    const kids = dependents.get(path);
+    if (kids != null) {
+      for (const k of kids) {
+        const childLongest = dfs(k);
+        if (childLongest + 1 > best) best = childLongest + 1;
+      }
+    }
+    color.set(path, BLACK);
+    longestFrom.set(path, best);
+    return best;
+  };
+  let depth = 0;
+  for (const src of sources) {
+    const d = dfs(src);
+    if (d > depth) depth = d;
+  }
+  for (const p of paths) {
+    if (color.get(p) === WHITE) dfs(p);
+  }
+  return {
+    nodeCount: paths.length,
+    edgeCount,
+    subgraphCount: described.subgraphs.length,
+    sources,
+    sinks,
+    depth,
+    hasCycles
+  };
+}
+function computeHealthReport(described) {
+  const problems = [];
+  for (const [path, desc] of Object.entries(described.nodes)) {
+    if (desc.status !== "errored") continue;
+    const entry = { path, status: "errored" };
+    const upstream = reachable(described, path, "upstream", {});
+    for (const p of upstream) {
+      if (p === path) continue;
+      if (described.nodes[p]?.status === "errored") {
+        entry.upstreamCause = p;
+        break;
+      }
+    }
+    problems.push(entry);
+  }
+  problems.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+  return { ok: problems.length === 0, problems };
+}
+function topologyStatsEqual(a, b) {
+  return a.nodeCount === b.nodeCount && a.edgeCount === b.edgeCount && a.subgraphCount === b.subgraphCount && a.depth === b.depth && a.hasCycles === b.hasCycles && stringArrayEqual(a.sources, b.sources) && stringArrayEqual(a.sinks, b.sinks);
+}
+function healthReportEqual(a, b) {
+  if (a.ok !== b.ok) return false;
+  if (a.problems.length !== b.problems.length) return false;
+  for (let i = 0; i < a.problems.length; i++) {
+    const x = a.problems[i];
+    const y = b.problems[i];
+    if (x.path !== y.path) return false;
+    if (x.status !== y.status) return false;
+    if (x.upstreamCause !== y.upstreamCause) return false;
+  }
+  return true;
+}
+function stringArrayEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+var LensGraph = class extends Graph {
+  /**
+   * Aggregate structural stats — `nodeCount`, `edgeCount`, `sources`,
+   * `sinks`, `depth`, `hasCycles`, `subgraphCount`. Recomputes on every
+   * structural change via {@link watchTopologyTree} (transitive).
+   *
+   * Named `stats` (not `topology`) because `Graph.topology` already names
+   * the raw `TopologyEvent` stream on every graph including `LensGraph`;
+   * giving the lens its own `topology` accessor with an incompatible
+   * `Node<TopologyStats>` type would break Liskov substitutability.
+   */
+  stats;
+  health;
+  /**
+   * Per-path flow tracker — a live {@link ReactiveMapBundle} keyed by
+   * qualified path. Use `.get(path)` / `.has(path)` / `.size` for O(1)
+   * sync queries; subscribe to `.entries` for a reactive snapshot of the
+   * whole map. Lazy — the snapshot is materialized only while `.entries`
+   * has subscribers.
+   *
+   * Shape intentionally differs from `stats` / `health` (which are plain
+   * `Node<Report>`) because `flow` is a keyed collection, not a single
+   * aggregate value. The map shape exposes cheaper queries than any
+   * snapshot-based design.
+   */
+  flow;
+  _target;
+  constructor(target, opts = {}) {
+    super(opts.name ?? `${target.name}_lens`, opts.graph);
+    this._target = target;
+    let statsVersion = 0;
+    let healthVersion = 0;
+    const statsTick = state(0, { name: "stats_tick" });
+    const healthTick = state(0, { name: "health_tick" });
+    this.add("stats_tick", statsTick);
+    this.add("health_tick", healthTick);
+    const mapOpts = { name: "flow" };
+    if (opts.maxFlowPaths != null) mapOpts.maxSize = opts.maxFlowPaths;
+    this.flow = reactiveMap(mapOpts);
+    this.add("flow", this.flow.entries);
+    const pathFilter = opts.pathFilter;
+    const offTopology = watchTopologyTree(target, (event, _emitter, prefix) => {
+      statsVersion += 1;
+      statsTick.emit(statsVersion);
+      healthVersion += 1;
+      healthTick.emit(healthVersion);
+      if (event.kind === "removed") {
+        if (event.nodeKind === "node") {
+          const qp = `${prefix}${event.name}`;
+          this.flow.delete(qp);
+        } else {
+          const mountPrefix = `${prefix}${event.name}::`;
+          const keysToDelete = [];
+          for (const relativePath of event.audit.nodes) {
+            const qualified = relativePath === "" ? `${prefix}${event.name}` : `${mountPrefix}${relativePath}`;
+            keysToDelete.push(qualified);
+          }
+          if (keysToDelete.length > 0) this.flow.deleteMany(keysToDelete);
+        }
+      }
+    });
+    this.addDisposer(offTopology);
+    const observeHandle = target.observe({ timeline: true, structured: true });
+    const offObserve = observeHandle.onEvent((event) => {
+      const t = event.type;
+      if (t === "error" || t === "complete" || t === "data" || t === "teardown") {
+        healthVersion += 1;
+        healthTick.emit(healthVersion);
+      }
+      if (t === "data") {
+        const path = event.path ?? "";
+        if (!path) return;
+        if (pathFilter != null && !pathFilter(path)) return;
+        const existing = this.flow.get(path);
+        const count = existing != null ? existing.count + 1 : 1;
+        this.flow.set(path, { path, count, lastUpdate_ns: monotonicNs() });
+      }
+    });
+    this.addDisposer(() => {
+      offObserve();
+      observeHandle.dispose();
+    });
+    this.stats = derived(
+      [statsTick],
+      () => computeTopologyStats(target.describe({ detail: "minimal" })),
+      {
+        name: "stats",
+        describeKind: "derived",
+        equals: topologyStatsEqual,
+        meta: lensMeta("stats")
+      }
+    );
+    this.add("stats", this.stats);
+    this.addDisposer(keepalive(this.stats));
+    this.health = derived(
+      [healthTick],
+      () => computeHealthReport(target.describe({ detail: "standard" })),
+      {
+        name: "health",
+        describeKind: "derived",
+        equals: healthReportEqual,
+        meta: lensMeta("health")
+      }
+    );
+    this.add("health", this.health);
+    this.addDisposer(keepalive(this.health));
+  }
+  /**
+   * Live causal chain from `from` to `to`. Recomputes whenever the target
+   * mutates. Disposed automatically when the lens is destroyed.
+   *
+   * **Lifetime note:** every call to `why()` registers a lens-owned disposer
+   * that runs on `lens.destroy()`. The returned `dispose` function releases
+   * the internal subscription but does NOT remove the lens-owned disposer —
+   * so heavy calling (e.g. per render frame) accumulates no-op disposers
+   * until lens teardown. Cache the returned handle for long-lived queries.
+   *
+   * @param from - Qualified path of the upstream endpoint.
+   * @param to - Qualified path of the downstream endpoint.
+   * @param opts - See {@link reactiveExplainPath}.
+   */
+  why(from, to, opts) {
+    const handle = reactiveExplainPath(this._target, from, to, opts);
+    this.addDisposer(handle.dispose);
+    return handle;
+  }
+  /** Reference to the lensed graph. */
+  get target() {
+    return this._target;
+  }
+};
+function graphLens(target, opts) {
+  return new LensGraph(target, opts);
+}
+
+// src/patterns/resilient-pipeline.ts
+var resilient_pipeline_exports = {};
+__export(resilient_pipeline_exports, {
+  NS_PER_MS: () => NS_PER_MS,
+  NS_PER_SEC: () => NS_PER_SEC,
+  resilientPipeline: () => resilientPipeline
+});
+function resilientPipeline(source, opts = {}) {
+  let current = source;
+  if (opts.rateLimit != null) {
+    current = rateLimiter(current, opts.rateLimit);
+  }
+  if (opts.budget != null && opts.budget.length > 0) {
+    current = budgetGate(current, opts.budget);
+  }
+  let breakerState;
+  if (opts.breaker != null) {
+    const breaker = circuitBreaker(opts.breaker);
+    const onOpen = opts.breakerOnOpen ?? "skip";
+    const wrapped = withBreaker(breaker, { onOpen })(current);
+    current = wrapped.node;
+    breakerState = wrapped.breakerState;
+  }
+  if (opts.timeoutMs != null) {
+    if (opts.timeoutMs <= 0) throw new RangeError("timeoutMs must be > 0");
+    if (opts.timeoutMs > 9e6) {
+      throw new RangeError(
+        "timeoutMs must be <= 9_000_000 (\u22482.5h) to stay within safe ns arithmetic"
+      );
+    }
+    current = timeout(current, opts.timeoutMs * NS_PER_MS);
+  }
+  if (opts.retry != null) {
+    current = retry(current, opts.retry);
+  }
+  if (opts.fallback !== void 0) {
+    current = fallback(current, opts.fallback);
+  }
+  const withStatusBundle = withStatus(current, { initialStatus: opts.initialStatus ?? "pending" });
+  return {
+    node: withStatusBundle.node,
+    status: withStatusBundle.status,
+    error: withStatusBundle.error,
+    breakerState
+  };
+}
+
+// src/patterns/surface/index.ts
+var surface_exports = {};
+__export(surface_exports, {
+  SNAPSHOT_WIRE_VERSION: () => SNAPSHOT_WIRE_VERSION,
+  SurfaceError: () => SurfaceError,
+  asSurfaceError: () => asSurfaceError,
+  createGraph: () => createGraph,
+  deleteSnapshot: () => deleteSnapshot,
+  diffSnapshots: () => diffSnapshots,
+  listSnapshots: () => listSnapshots,
+  restoreSnapshot: () => restoreSnapshot,
+  runReduction: () => runReduction,
+  saveSnapshot: () => saveSnapshot
+});
+
+// src/patterns/surface/errors.ts
+var SurfaceError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details) {
+    super(message);
+    this.name = "SurfaceError";
+    this.code = code;
+    if (details !== void 0) this.details = details;
+  }
+  /**
+   * JSON-safe payload for wire serialization. Defensively validates
+   * `details` — if it can't be round-tripped through `JSON.stringify`
+   * (cyclic refs, `BigInt`, `Error` instance not pre-toJSON'd), the
+   * payload falls back to `{code, message}` only rather than crashing
+   * the MCP/CLI wrapper when it serializes this error onto the wire.
+   */
+  toJSON() {
+    const out = { code: this.code, message: this.message };
+    if (this.details !== void 0) {
+      const safe = safeDetails(this.details);
+      if (safe !== void 0) out.details = safe;
+    }
+    return out;
+  }
+};
+function safeDetails(details) {
+  try {
+    return JSON.parse(JSON.stringify(details));
+  } catch {
+    return void 0;
+  }
+}
+function asSurfaceError(err, fallbackCode = "internal-error") {
+  if (err instanceof SurfaceError) return err;
+  const message = err instanceof Error ? err.message : String(err);
+  return new SurfaceError(fallbackCode, message);
+}
+
+// src/patterns/surface/create.ts
+function createGraph(spec, opts) {
+  const structural = validateSpec(spec);
+  if (!structural.valid) {
+    throw new SurfaceError(
+      "invalid-spec",
+      `GraphSpec validation failed:
+${structural.errors.join("\n")}`,
+      { errors: structural.errors }
+    );
+  }
+  const catalog = opts?.catalog ?? {};
+  const catalogValidation = validateSpecAgainstCatalog(spec, catalog);
+  if (!catalogValidation.valid) {
+    throw new SurfaceError(
+      "catalog-error",
+      `Catalog validation failed:
+${catalogValidation.errors.join("\n")}`,
+      { errors: catalogValidation.errors }
+    );
+  }
+  try {
+    return compileSpec(spec, opts);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new SurfaceError("catalog-error", message);
+  }
+}
+
+// src/patterns/surface/reduce.ts
+var DEFAULT_TIMEOUT_MS2 = 3e4;
+async function runReduction(spec, input, opts) {
+  const inputPath = opts?.inputPath ?? "input";
+  const outputPath = opts?.outputPath ?? "output";
+  const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+  const graph = createGraph(spec, { catalog: opts?.catalog });
+  let outputNode;
+  try {
+    outputNode = graph.resolve(outputPath);
+  } catch {
+    graph.destroy();
+    throw new SurfaceError(
+      "node-not-found",
+      `reduce: output path "${outputPath}" is not registered`,
+      { path: outputPath }
+    );
+  }
+  try {
+    graph.resolve(inputPath);
+  } catch {
+    graph.destroy();
+    throw new SurfaceError(
+      "node-not-found",
+      `reduce: input path "${inputPath}" is not registered`,
+      { path: inputPath }
+    );
+  }
+  try {
+    return await new Promise((resolve, reject) => {
+      let primed = false;
+      let settled = false;
+      let timer;
+      let unsub;
+      let shouldUnsub = false;
+      const finish = (action) => {
+        if (settled) return;
+        settled = true;
+        if (timer !== void 0) clearTimeout(timer);
+        if (unsub !== void 0) {
+          unsub();
+          unsub = void 0;
+        } else {
+          shouldUnsub = true;
+        }
+        action();
+      };
+      unsub = outputNode.subscribe((msgs) => {
+        for (const m of msgs) {
+          if (settled) return;
+          if (!primed) continue;
+          if (m[0] === DATA) {
+            finish(() => resolve(m[1]));
+            return;
+          }
+          if (m[0] === RESOLVED) {
+            const cached2 = outputNode.cache;
+            finish(() => resolve(cached2));
+            return;
+          }
+          if (m[0] === ERROR) {
+            const payload = m[1];
+            const message = payload instanceof Error ? payload.message : String(payload);
+            const cause = payload instanceof Error ? payload : void 0;
+            finish(
+              () => reject(
+                new SurfaceError(
+                  "internal-error",
+                  `reduce: output emitted ERROR: ${message}`,
+                  cause != null ? { cause } : void 0
+                )
+              )
+            );
+            return;
+          }
+          if (m[0] === COMPLETE) {
+            finish(
+              () => reject(
+                new SurfaceError(
+                  "internal-error",
+                  `reduce: output COMPLETEd without a post-push DATA`
+                )
+              )
+            );
+            return;
+          }
+        }
+      });
+      if (shouldUnsub) {
+        unsub?.();
+        unsub = void 0;
+      }
+      primed = true;
+      try {
+        graph.set(inputPath, input);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const cause = err instanceof Error ? err : void 0;
+        finish(
+          () => reject(
+            new SurfaceError(
+              "internal-error",
+              `reduce: failed to set input on "${inputPath}": ${message}`,
+              cause != null ? { path: inputPath, cause } : { path: inputPath }
+            )
+          )
+        );
+        return;
+      }
+      if (!settled && Number.isFinite(timeoutMs) && timeoutMs > 0) {
+        timer = setTimeout(() => {
+          finish(
+            () => reject(
+              new SurfaceError(
+                "reduce-timeout",
+                `reduce: no output emitted within ${timeoutMs}ms`,
+                { timeoutMs, outputPath }
+              )
+            )
+          );
+        }, timeoutMs);
+        timer.unref?.();
+      }
+    });
+  } finally {
+    graph.destroy();
+  }
+}
+
+// src/patterns/surface/snapshot.ts
+var SNAPSHOT_WIRE_VERSION = SNAPSHOT_VERSION;
+function unwrapCheckpoint(raw, snapshotId) {
+  if (raw == null || typeof raw !== "object") {
+    throw new SurfaceError("snapshot-not-found", `snapshot "${snapshotId}" not found in tier`, {
+      snapshotId
+    });
+  }
+  const record = raw;
+  if ("mode" in record) {
+    if (record.mode === "full" && "snapshot" in record) {
+      return record.snapshot;
+    }
+    if (record.mode === "diff") {
+      throw new SurfaceError(
+        "restore-failed",
+        `snapshot "${snapshotId}" is a diff record; restore the baseline and replay WAL instead`,
+        { snapshotId, mode: "diff" }
+      );
+    }
+    throw new SurfaceError(
+      "restore-failed",
+      `snapshot "${snapshotId}" has unknown mode "${String(record.mode)}"`,
+      { snapshotId, mode: String(record.mode) }
+    );
+  }
+  if ("nodes" in record && "edges" in record && "subgraphs" in record && "name" in record) {
+    return record;
+  }
+  throw new SurfaceError(
+    "restore-failed",
+    `snapshot "${snapshotId}" payload is not a GraphCheckpointRecord or GraphPersistSnapshot`,
+    { snapshotId }
+  );
+}
+async function saveSnapshot(graph, snapshotId, tier) {
+  let snapshot;
+  try {
+    snapshot = graph.snapshot();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new SurfaceError(
+      "snapshot-failed",
+      `snapshot "${snapshotId}" serialization failed: ${message}`,
+      { snapshotId }
+    );
+  }
+  const record = {
+    mode: "full",
+    seq: 0,
+    timestamp_ns: wallClockNs(),
+    format_version: SNAPSHOT_WIRE_VERSION,
+    snapshot
+  };
+  try {
+    await tier.save(snapshotId, record);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new SurfaceError("snapshot-failed", `snapshot "${snapshotId}" save failed: ${message}`, {
+      snapshotId
+    });
+  }
+  return { snapshotId, timestamp_ns: record.timestamp_ns };
+}
+async function restoreSnapshot(snapshotId, tier, opts) {
+  const raw = await tier.load(snapshotId);
+  const snapshot = unwrapCheckpoint(raw, snapshotId);
+  try {
+    return Graph.fromSnapshot(
+      snapshot,
+      opts?.factories ? { factories: opts.factories } : void 0
+    );
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new SurfaceError(
+      "restore-failed",
+      `snapshot "${snapshotId}" restore failed: ${message}`,
+      {
+        snapshotId
+      }
+    );
+  }
+}
+async function diffSnapshots(snapshotIdA, snapshotIdB, tier) {
+  const [rawA, rawB] = await Promise.all([tier.load(snapshotIdA), tier.load(snapshotIdB)]);
+  const snapshotA = unwrapCheckpoint(rawA, snapshotIdA);
+  const snapshotB = unwrapCheckpoint(rawB, snapshotIdB);
+  return Graph.diff(snapshotA, snapshotB);
+}
+async function listSnapshots(tier) {
+  if (typeof tier.list !== "function") {
+    throw new SurfaceError(
+      "tier-no-list",
+      "StorageTier does not implement list(); wrap the tier with an enumerator or use a different backend"
+    );
+  }
+  return tier.list();
+}
+async function deleteSnapshot(snapshotId, tier) {
+  if (typeof tier.clear !== "function") {
+    throw new SurfaceError(
+      "snapshot-failed",
+      `StorageTier is append-only (no clear()); cannot delete "${snapshotId}"`,
+      { snapshotId }
+    );
+  }
+  try {
+    await tier.clear(snapshotId);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new SurfaceError(
+      "snapshot-failed",
+      `snapshot "${snapshotId}" delete failed: ${message}`,
+      {
+        snapshotId
+      }
+    );
+  }
+}
+
 // src/index.ts
 var version = "0.0.0";
 export {
@@ -7021,15 +7033,20 @@ export {
   ResettableTimer,
   OVERHEAD as SIZEOF_OVERHEAD,
   SIZEOF_SYMBOL,
+  SNAPSHOT_VERSION,
+  SNAPSHOT_WIRE_VERSION,
   START,
   START_MSG,
+  SurfaceError,
   TEARDOWN,
   TEARDOWN_MSG,
   TEARDOWN_ONLY_BATCH,
   TimeoutError,
   accessHintForGuard,
+  audit_exports as accountability,
   advanceVersion,
   ai_exports as ai,
+  asSurfaceError,
   audit,
   autoTrackNode,
   batch,
@@ -7053,6 +7070,7 @@ export {
   cqrs_exports as cqrs,
   createDagCborCodec,
   createDagCborZstdCodec,
+  createGraph,
   createTransport,
   createVersioning,
   createWatermarkController,
@@ -7064,11 +7082,13 @@ export {
   defaultConfig,
   defaultHash,
   delay,
+  deleteSnapshot,
   demo_shell_exports as demoShell,
   derived,
   deserializeError,
   dictStorage,
   diffForWAL,
+  diffSnapshots,
   distill,
   distinctUntilChanged,
   domain_templates_exports as domainTemplates,
@@ -7080,6 +7100,7 @@ export {
   encodeEnvelope,
   escapeRegexChar,
   exhaustMap,
+  explainPath,
   exponential,
   externalBundle,
   externalProducer,
@@ -7135,6 +7156,7 @@ export {
   graph_exports as graph,
   graphProfile,
   graphspec_exports as graphspec,
+  guarded_execution_exports as guarded,
   harness_exports as harness,
   indexedDbStorage,
   interval,
@@ -7144,7 +7166,9 @@ export {
   keepalive,
   last,
   reactive_layout_exports as layout,
+  lens_exports as lens,
   linear,
+  listSnapshots,
   lru,
   map,
   matchesAnyPattern,
@@ -7194,11 +7218,15 @@ export {
   replay,
   replayWAL,
   rescue,
+  resilient_pipeline_exports as resilientPipeline,
   resolveBackoffPreset,
   resolveDescribeFields,
+  restoreSnapshot,
   retry,
   retrySource,
+  runReduction,
   sample,
+  saveSnapshot,
   scan,
   serializeError,
   share,
@@ -7210,6 +7238,7 @@ export {
   solid_exports as solid,
   sqliteStorage,
   state,
+  surface_exports as surface,
   svelte_exports as svelte,
   switchMap,
   take,
@@ -7247,6 +7276,7 @@ export {
   version,
   vue_exports as vue,
   wallClockNs,
+  watchTopologyTree,
   window,
   windowCount,
   windowTime,