@graphrefly/graphrefly 0.21.0 → 0.23.0

package/dist/chunk-4MQ2J6IG.js

@@ -1,1631 +0,0 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
-var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
-var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
-var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
-var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
-var __runInitializers = (array, flags, self, value) => {
-  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
-  return value;
-};
-var __decorateElement = (array, flags, name, decorators, target, extra) => {
-  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
-  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
-  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
-  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
-    return __privateGet(this, extra);
-  }, set [name](x) {
-    return __privateSet(this, extra, x);
-  } }, name));
-  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
-  for (var i = decorators.length - 1; i >= 0; i--) {
-    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
-    if (k) {
-      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
-      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
-      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
-    }
-    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
-    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
-    else if (typeof it !== "object" || it === null) __typeError("Object expected");
-    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
-  }
-  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
-};
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-
-// src/core/actor.ts
-var DEFAULT_ACTOR = { type: "system", id: "" };
-function normalizeActor(actor) {
-  if (actor == null) return DEFAULT_ACTOR;
-  const { type, id, ...rest } = actor;
-  return {
-    type: type ?? "system",
-    id: id ?? "",
-    ...rest
-  };
-}
-
-// src/core/guard.ts
-var GuardDenied = class extends Error {
-  actor;
-  action;
-  nodeName;
-  /**
-   * @param details - Actor, action, and optional node name for the denial.
-   * @param message - Optional override for the default error message.
-   */
-  constructor(details, message) {
-    super(
-      message ?? `GuardDenied: action "${String(details.action)}" denied for actor type "${String(details.actor.type)}"`
-    );
-    this.name = "GuardDenied";
-    this.actor = details.actor;
-    this.action = details.action;
-    this.nodeName = details.nodeName;
-  }
-  /** Qualified registry path when known (roadmap diagnostics: same as {@link nodeName}). */
-  get node() {
-    return this.nodeName;
-  }
-};
-function normalizeActions(action) {
-  if (Array.isArray(action)) {
-    return [...action];
-  }
-  return [action];
-}
-function matchesActions(set, action) {
-  return set.has(action) || set.has("*");
-}
-function policy(build) {
-  const rules = [];
-  const allow = (action, opts) => {
-    rules.push({
-      kind: "allow",
-      actions: new Set(normalizeActions(action)),
-      where: opts?.where ?? (() => true)
-    });
-  };
-  const deny = (action, opts) => {
-    rules.push({
-      kind: "deny",
-      actions: new Set(normalizeActions(action)),
-      where: opts?.where ?? (() => true)
-    });
-  };
-  build(allow, deny);
-  return (actor, action) => {
-    let denied = false;
-    let allowed = false;
-    for (const r of rules) {
-      if (!matchesActions(r.actions, action)) continue;
-      if (!r.where(actor)) continue;
-      if (r.kind === "deny") {
-        denied = true;
-      } else {
-        allowed = true;
-      }
-    }
-    if (denied) return false;
-    return allowed;
-  };
-}
-function policyFromRules(rules) {
-  return policy((allow, deny) => {
-    for (const rule of rules) {
-      const actorTypes = rule.actorType == null ? null : new Set(Array.isArray(rule.actorType) ? rule.actorType : [rule.actorType]);
-      const actorIds = rule.actorId == null ? null : new Set(Array.isArray(rule.actorId) ? rule.actorId : [rule.actorId]);
-      const claimEntries = Object.entries(rule.claims ?? {});
-      const where = (actor) => {
-        if (actorTypes !== null && !actorTypes.has(String(actor.type))) return false;
-        if (actorIds !== null && !actorIds.has(String(actor.id ?? ""))) return false;
-        for (const [key, value] of claimEntries) {
-          if (actor[key] !== value) return false;
-        }
-        return true;
-      };
-      if (rule.effect === "deny") {
-        deny(rule.action, { where });
-      } else {
-        allow(rule.action, { where });
-      }
-    }
-  });
-}
-var STANDARD_WRITE_TYPES = ["human", "llm", "wallet", "system"];
-function accessHintForGuard(guard) {
-  const allowed = STANDARD_WRITE_TYPES.filter((t) => guard({ type: t, id: "" }, "write"));
-  if (allowed.length === 0) return "restricted";
-  if (allowed.includes("human") && allowed.includes("llm") && allowed.every((t) => t === "human" || t === "llm" || t === "system")) {
-    return "both";
-  }
-  if (allowed.length === 1) return allowed[0];
-  return allowed.join("+");
-}
-
-// src/core/messages.ts
-var START = /* @__PURE__ */ Symbol.for("graphrefly/START");
-var DATA = /* @__PURE__ */ Symbol.for("graphrefly/DATA");
-var DIRTY = /* @__PURE__ */ Symbol.for("graphrefly/DIRTY");
-var RESOLVED = /* @__PURE__ */ Symbol.for("graphrefly/RESOLVED");
-var INVALIDATE = /* @__PURE__ */ Symbol.for("graphrefly/INVALIDATE");
-var PAUSE = /* @__PURE__ */ Symbol.for("graphrefly/PAUSE");
-var RESUME = /* @__PURE__ */ Symbol.for("graphrefly/RESUME");
-var TEARDOWN = /* @__PURE__ */ Symbol.for("graphrefly/TEARDOWN");
-var COMPLETE = /* @__PURE__ */ Symbol.for("graphrefly/COMPLETE");
-var ERROR = /* @__PURE__ */ Symbol.for("graphrefly/ERROR");
-var knownMessageTypes = [
-  START,
-  DATA,
-  DIRTY,
-  RESOLVED,
-  INVALIDATE,
-  PAUSE,
-  RESUME,
-  TEARDOWN,
-  COMPLETE,
-  ERROR
-];
-var knownMessageSet = new Set(knownMessageTypes);
-function isKnownMessageType(t) {
-  return knownMessageSet.has(t);
-}
-function messageTier(t) {
-  if (t === START) return 0;
-  if (t === DIRTY || t === INVALIDATE) return 1;
-  if (t === PAUSE || t === RESUME) return 2;
-  if (t === DATA || t === RESOLVED) return 3;
-  if (t === COMPLETE || t === ERROR) return 4;
-  if (t === TEARDOWN) return 5;
-  return 1;
-}
-function isPhase2Message(msg) {
-  const t = msg[0];
-  return t === DATA || t === RESOLVED;
-}
-function isTerminalMessage(t) {
-  return t === COMPLETE || t === ERROR;
-}
-function isLocalOnly(t) {
-  if (!knownMessageSet.has(t)) return false;
-  return messageTier(t) < 3;
-}
-function propagatesToMeta(t) {
-  return t === TEARDOWN;
-}
-
-// src/core/batch.ts
-var MAX_DRAIN_ITERATIONS = 1e3;
-var batchDepth = 0;
-var flushInProgress = false;
-var pendingPhase2 = [];
-var pendingPhase3 = [];
-function isBatching() {
-  return batchDepth > 0 || flushInProgress;
-}
-function batch(fn) {
-  batchDepth += 1;
-  let threw = false;
-  try {
-    fn();
-  } catch (e) {
-    threw = true;
-    throw e;
-  } finally {
-    batchDepth -= 1;
-    if (batchDepth === 0) {
-      if (threw) {
-        if (!flushInProgress) {
-          pendingPhase2.length = 0;
-          pendingPhase3.length = 0;
-        }
-      } else {
-        drainPending();
-      }
-    }
-  }
-}
-function drainPending() {
-  const ownsFlush = !flushInProgress;
-  if (ownsFlush) {
-    flushInProgress = true;
-  }
-  const errors = [];
-  try {
-    let iterations = 0;
-    while (pendingPhase2.length > 0 || pendingPhase3.length > 0) {
-      while (pendingPhase2.length > 0) {
-        iterations += 1;
-        if (iterations > MAX_DRAIN_ITERATIONS) {
-          pendingPhase2.length = 0;
-          pendingPhase3.length = 0;
-          throw new Error(
-            `batch drain exceeded ${MAX_DRAIN_ITERATIONS} iterations \u2014 likely a reactive cycle`
-          );
-        }
-        const ops = pendingPhase2.splice(0);
-        for (const run of ops) {
-          try {
-            run();
-          } catch (e) {
-            errors.push(e);
-          }
-        }
-      }
-      if (pendingPhase3.length > 0) {
-        iterations += 1;
-        if (iterations > MAX_DRAIN_ITERATIONS) {
-          pendingPhase2.length = 0;
-          pendingPhase3.length = 0;
-          throw new Error(
-            `batch drain exceeded ${MAX_DRAIN_ITERATIONS} iterations \u2014 likely a reactive cycle`
-          );
-        }
-        const ops = pendingPhase3.splice(0);
-        for (const run of ops) {
-          try {
-            run();
-          } catch (e) {
-            errors.push(e);
-          }
-        }
-      }
-    }
-  } finally {
-    if (ownsFlush) {
-      flushInProgress = false;
-    }
-  }
-  if (errors.length === 1) {
-    throw errors[0];
-  }
-  if (errors.length > 1) {
-    throw new AggregateError(errors, "batch drain: multiple callbacks threw");
-  }
-}
-function partitionForBatch(messages) {
-  const immediate = [];
-  const deferred = [];
-  const terminal = [];
-  for (const m of messages) {
-    if (isPhase2Message(m)) {
-      deferred.push(m);
-    } else if (isTerminalMessage(m[0])) {
-      terminal.push(m);
-    } else {
-      immediate.push(m);
-    }
-  }
-  return { immediate, deferred, terminal };
-}
-function downWithBatch(sink, messages, phase = 2, options) {
-  if (messages.length === 0) {
-    return;
-  }
-  if (options?.strategy === "sequential") {
-    _downSequential(sink, messages, phase);
-    return;
-  }
-  const queue = phase === 3 ? pendingPhase3 : pendingPhase2;
-  if (messages.length === 1) {
-    const t = messages[0][0];
-    if (t === DATA || t === RESOLVED) {
-      if (isBatching()) {
-        queue.push(() => sink(messages));
-      } else {
-        sink(messages);
-      }
-    } else if (isTerminalMessage(t)) {
-      if (isBatching()) {
-        queue.push(() => sink(messages));
-      } else {
-        sink(messages);
-      }
-    } else {
-      sink(messages);
-    }
-    return;
-  }
-  const { immediate, deferred, terminal } = partitionForBatch(messages);
-  if (immediate.length > 0) {
-    sink(immediate);
-  }
-  if (isBatching()) {
-    if (deferred.length > 0) {
-      queue.push(() => sink(deferred));
-    }
-    if (terminal.length > 0) {
-      queue.push(() => sink(terminal));
-    }
-  } else {
-    if (deferred.length > 0) {
-      sink(deferred);
-    }
-    if (terminal.length > 0) {
-      sink(terminal);
-    }
-  }
-}
-function _downSequential(sink, messages, phase = 2) {
-  const dataQueue = phase === 3 ? pendingPhase3 : pendingPhase2;
-  for (const msg of messages) {
-    const tier = messageTier(msg[0]);
-    if (tier === 3) {
-      if (isBatching()) {
-        const m = msg;
-        dataQueue.push(() => sink([m]));
-      } else {
-        sink([msg]);
-      }
-    } else if (tier >= 4) {
-      if (isBatching()) {
-        const m = msg;
-        pendingPhase3.push(() => sink([m]));
-      } else {
-        sink([msg]);
-      }
-    } else {
-      sink([msg]);
-    }
-  }
-}
-
-// src/core/clock.ts
-function monotonicNs() {
-  return Math.trunc(performance.now() * 1e6);
-}
-function wallClockNs() {
-  return Date.now() * 1e6;
-}
-
-// src/core/versioning.ts
-import { createHash, randomUUID } from "crypto";
-function canonicalizeForHash(value) {
-  if (value === void 0) return null;
-  if (typeof value === "number") {
-    if (!Number.isFinite(value)) {
-      throw new TypeError(`Cannot hash non-finite number: ${value}`);
-    }
-    if (Number.isInteger(value) && !Number.isSafeInteger(value)) {
-      throw new TypeError(
-        `Cannot hash integer outside safe range (|n| > 2^53-1): ${value}. Cross-language cid parity is not guaranteed for unsafe integers.`
-      );
-    }
-    return value;
-  }
-  if (typeof value === "string" || typeof value === "boolean" || value === null) {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    return value.map(canonicalizeForHash);
-  }
-  if (typeof value === "object" && value !== null) {
-    const sorted = {};
-    for (const k of Object.keys(value).sort()) {
-      sorted[k] = canonicalizeForHash(value[k]);
-    }
-    return sorted;
-  }
-  return null;
-}
-function defaultHash(value) {
-  const canonical = canonicalizeForHash(value ?? null);
-  const json = JSON.stringify(canonical);
-  return createHash("sha256").update(json).digest("hex").slice(0, 16);
-}
-function createVersioning(level, initialValue, opts) {
-  const id = opts?.id ?? randomUUID();
-  if (level === 0) {
-    return { id, version: 0 };
-  }
-  const hash = opts?.hash ?? defaultHash;
-  const cid = hash(initialValue);
-  return { id, version: 0, cid, prev: null };
-}
-function advanceVersion(info, newValue, hashFn) {
-  info.version += 1;
-  if ("cid" in info) {
-    info.prev = info.cid;
-    info.cid = hashFn(newValue);
-  }
-}
-function isV1(info) {
-  return "cid" in info;
-}
-
-// src/core/node-base.ts
-var NO_VALUE = /* @__PURE__ */ Symbol.for("graphrefly/NO_VALUE");
-var CLEANUP_RESULT = /* @__PURE__ */ Symbol.for("graphrefly/CLEANUP_RESULT");
-function cleanupResult(cleanup, ...args) {
-  const r = { [CLEANUP_RESULT]: true, cleanup };
-  if (args.length > 0) r.value = args[0];
-  return r;
-}
-var isCleanupResult = (value) => typeof value === "object" && value !== null && CLEANUP_RESULT in value;
-var isCleanupFn = (value) => typeof value === "function";
-function statusAfterMessage(status, msg) {
-  const t = msg[0];
-  if (t === DIRTY) return "dirty";
-  if (t === DATA) return "settled";
-  if (t === RESOLVED) return "resolved";
-  if (t === COMPLETE) return "completed";
-  if (t === ERROR) return "errored";
-  if (t === INVALIDATE) return "dirty";
-  if (t === TEARDOWN) return "disconnected";
-  return status;
-}
-function createIntBitSet(size) {
-  const fullMask = size >= 32 ? -1 : ~(-1 << size);
-  let bits = 0;
-  return {
-    set(i) {
-      bits |= 1 << i;
-    },
-    clear(i) {
-      bits &= ~(1 << i);
-    },
-    has(i) {
-      return (bits & 1 << i) !== 0;
-    },
-    covers(other) {
-      const otherBits = other._bits();
-      return (bits & otherBits) === otherBits;
-    },
-    any() {
-      return bits !== 0;
-    },
-    reset() {
-      bits = 0;
-    },
-    setAll() {
-      bits = fullMask;
-    },
-    _bits() {
-      return bits;
-    }
-  };
-}
-function createArrayBitSet(size) {
-  const words = new Uint32Array(Math.ceil(size / 32));
-  const lastBits = size % 32;
-  const lastWordMask = lastBits === 0 ? 4294967295 : (1 << lastBits) - 1 >>> 0;
-  return {
-    set(i) {
-      words[i >>> 5] |= 1 << (i & 31);
-    },
-    clear(i) {
-      words[i >>> 5] &= ~(1 << (i & 31));
-    },
-    has(i) {
-      return (words[i >>> 5] & 1 << (i & 31)) !== 0;
-    },
-    covers(other) {
-      const ow = other._words;
-      for (let w = 0; w < words.length; w++) {
-        if ((words[w] & ow[w]) >>> 0 !== ow[w]) return false;
-      }
-      return true;
-    },
-    any() {
-      for (let w = 0; w < words.length; w++) {
-        if (words[w] !== 0) return true;
-      }
-      return false;
-    },
-    reset() {
-      words.fill(0);
-    },
-    setAll() {
-      for (let w = 0; w < words.length - 1; w++) words[w] = 4294967295;
-      if (words.length > 0) words[words.length - 1] = lastWordMask;
-    },
-    _words: words
-  };
-}
-function createBitSet(size) {
-  return size <= 31 ? createIntBitSet(size) : createArrayBitSet(size);
-}
-var NodeBase = class {
-  // --- Identity (set once) ---
-  _optsName;
-  _registryName;
-  /** @internal Read by `describeNode` before inference. */
-  _describeKind;
-  meta;
-  // --- Options ---
-  _equals;
-  _resubscribable;
-  _resetOnTeardown;
-  _onResubscribe;
-  _onMessage;
-  /** @internal Read by `describeNode` for `accessHintForGuard`. */
-  _guard;
-  /** @internal Subclasses update this through {@link _recordMutation}. */
-  _lastMutation;
-  // --- Versioning ---
-  _hashFn;
-  _versioning;
-  // --- Lifecycle state ---
-  /** @internal Read by `describeNode` and `graph.ts`. */
-  _cached;
-  /** @internal Read externally via `get status()`. */
-  _status;
-  _terminal = false;
-  _active = false;
-  // --- Sink storage ---
-  /** @internal Read by `graph/profile.ts` for subscriber counts. */
-  _sinkCount = 0;
-  _singleDepSinkCount = 0;
-  _singleDepSinks = /* @__PURE__ */ new WeakSet();
-  _sinks = null;
-  // --- Actions + bound helpers ---
-  _actions;
-  _boundDownToSinks;
-  // --- Inspector hook (Graph observability) ---
-  _inspectorHook;
-  constructor(opts) {
-    this._optsName = opts.name;
-    this._describeKind = opts.describeKind;
-    this._equals = opts.equals ?? Object.is;
-    this._resubscribable = opts.resubscribable ?? false;
-    this._resetOnTeardown = opts.resetOnTeardown ?? false;
-    this._onResubscribe = opts.onResubscribe;
-    this._onMessage = opts.onMessage;
-    this._guard = opts.guard;
-    this._cached = "initial" in opts ? opts.initial : NO_VALUE;
-    this._status = "disconnected";
-    this._hashFn = opts.versioningHash ?? defaultHash;
-    this._versioning = opts.versioning != null ? createVersioning(opts.versioning, this._cached === NO_VALUE ? void 0 : this._cached, {
-      id: opts.versioningId,
-      hash: this._hashFn
-    }) : void 0;
-    const meta = {};
-    for (const [k, v] of Object.entries(opts.meta ?? {})) {
-      meta[k] = this._createMetaNode(k, v, opts);
-    }
-    Object.freeze(meta);
-    this.meta = meta;
-    const self = this;
-    this._actions = {
-      down(messages) {
-        self._onManualEmit();
-        self._downInternal(messages);
-      },
-      emit(value) {
-        self._onManualEmit();
-        self._downAutoValue(value);
-      },
-      up(messages) {
-        self._upInternal(messages);
-      }
-    };
-    this._boundDownToSinks = this._downToSinks.bind(this);
-  }
-  /**
-   * Subclass hook invoked by `actions.down` / `actions.emit`. Default no-op;
-   * {@link NodeImpl} overrides to set `_manualEmitUsed`.
-   */
-  _onManualEmit() {
-  }
-  // --- Identity getters ---
-  get name() {
-    return this._registryName ?? this._optsName;
-  }
-  /** @internal Assigned by `Graph.add` when registered without an options `name`. */
-  _assignRegistryName(localName) {
-    if (this._optsName !== void 0 || this._registryName !== void 0) return;
-    this._registryName = localName;
-  }
-  /**
-   * @internal Attach/remove inspector hook for graph-level observability.
-   * Returns a disposer that restores the previous hook.
-   */
-  _setInspectorHook(hook) {
-    const prev = this._inspectorHook;
-    this._inspectorHook = hook;
-    return () => {
-      if (this._inspectorHook === hook) {
-        this._inspectorHook = prev;
-      }
-    };
-  }
-  /** @internal Used by subclasses to surface inspector events. */
-  _emitInspectorHook(event) {
-    this._inspectorHook?.(event);
-  }
-  get status() {
-    return this._status;
-  }
-  get lastMutation() {
-    return this._lastMutation;
-  }
-  get v() {
-    return this._versioning;
-  }
-  /** @internal Used by `Graph.setVersioning` to retroactively apply versioning. */
-  _applyVersioning(level, opts) {
-    if (this._versioning != null) return;
-    this._hashFn = opts?.hash ?? this._hashFn;
-    this._versioning = createVersioning(
-      level,
-      this._cached === NO_VALUE ? void 0 : this._cached,
-      {
-        id: opts?.id,
-        hash: this._hashFn
-      }
-    );
-  }
-  hasGuard() {
-    return this._guard != null;
-  }
-  allowsObserve(actor) {
-    if (this._guard == null) return true;
-    return this._guard(normalizeActor(actor), "observe");
-  }
-  // --- Public transport ---
-  get() {
-    return this._cached === NO_VALUE ? void 0 : this._cached;
-  }
-  down(messages, options) {
-    if (messages.length === 0) return;
-    if (!options?.internal && this._guard != null) {
-      const actor = normalizeActor(options?.actor);
-      const delivery = options?.delivery ?? "write";
-      const action = delivery === "signal" ? "signal" : "write";
-      if (!this._guard(actor, action)) {
-        throw new GuardDenied({ actor, action, nodeName: this.name });
-      }
-      this._recordMutation(actor);
-    }
-    this._downInternal(messages);
-  }
-  /** @internal Record a successful guarded mutation (called by `down` and subclass `up`). */
-  _recordMutation(actor) {
-    this._lastMutation = { actor, timestamp_ns: wallClockNs() };
-  }
-  /**
-   * At-most-once deactivation guard. Both TEARDOWN (eager) and
-   * unsubscribe-body (lazy) call this. The `_active` flag ensures
-   * `_doDeactivate` runs exactly once per activation cycle.
-   */
-  _onDeactivate() {
-    if (!this._active) return;
-    this._active = false;
-    this._doDeactivate();
-  }
-  // --- Subscribe (uniform across node shapes) ---
-  subscribe(sink, hints) {
-    if (hints?.actor != null && this._guard != null) {
-      const actor = normalizeActor(hints.actor);
-      if (!this._guard(actor, "observe")) {
-        throw new GuardDenied({ actor, action: "observe", nodeName: this.name });
-      }
-    }
-    if (this._terminal && this._resubscribable) {
-      this._terminal = false;
-      this._cached = NO_VALUE;
-      this._status = "disconnected";
-      this._onResubscribe?.();
-    }
-    this._sinkCount += 1;
-    if (hints?.singleDep) {
-      this._singleDepSinkCount += 1;
-      this._singleDepSinks.add(sink);
-    }
-    if (!this._terminal) {
-      const startMessages = this._cached === NO_VALUE ? [[START]] : [[START], [DATA, this._cached]];
-      downWithBatch(sink, startMessages);
-    }
-    if (this._sinks == null) {
-      this._sinks = sink;
-    } else if (typeof this._sinks === "function") {
-      this._sinks = /* @__PURE__ */ new Set([this._sinks, sink]);
-    } else {
-      this._sinks.add(sink);
-    }
-    if (this._sinkCount === 1 && !this._terminal) {
-      this._active = true;
-      this._onActivate();
-    }
-    if (!this._terminal && this._status === "disconnected" && this._cached === NO_VALUE) {
-      this._status = "pending";
-    }
-    let removed = false;
-    return () => {
-      if (removed) return;
-      removed = true;
-      this._sinkCount -= 1;
-      if (this._singleDepSinks.has(sink)) {
-        this._singleDepSinkCount -= 1;
-        this._singleDepSinks.delete(sink);
-      }
-      if (this._sinks == null) return;
-      if (typeof this._sinks === "function") {
-        if (this._sinks === sink) this._sinks = null;
-      } else {
-        this._sinks.delete(sink);
-        if (this._sinks.size === 1) {
-          const [only] = this._sinks;
-          this._sinks = only;
-        } else if (this._sinks.size === 0) {
-          this._sinks = null;
-        }
-      }
-      if (this._sinks == null) {
-        this._onDeactivate();
-      }
-    };
-  }
-  // --- Down pipeline ---
-  /**
-   * Core outgoing dispatch. Applies terminal filter + local lifecycle
-   * update, then hands messages to `downWithBatch` for tier-aware delivery.
-   */
-  _downInternal(messages) {
-    if (messages.length === 0) return;
-    let sinkMessages = messages;
-    if (this._terminal && !this._resubscribable) {
-      const pass = messages.filter((m) => m[0] === TEARDOWN || m[0] === INVALIDATE);
-      if (pass.length === 0) return;
-      sinkMessages = pass;
-    }
-    this._handleLocalLifecycle(sinkMessages);
-    if (this._canSkipDirty()) {
-      let hasPhase2 = false;
-      for (let i = 0; i < sinkMessages.length; i++) {
-        const t = sinkMessages[i][0];
-        if (t === DATA || t === RESOLVED) {
-          hasPhase2 = true;
-          break;
-        }
-      }
-      if (hasPhase2) {
-        const filtered = [];
-        for (let i = 0; i < sinkMessages.length; i++) {
-          if (sinkMessages[i][0] !== DIRTY) filtered.push(sinkMessages[i]);
-        }
-        if (filtered.length > 0) {
-          downWithBatch(this._boundDownToSinks, filtered);
-        }
-        return;
-      }
-    }
-    downWithBatch(this._boundDownToSinks, sinkMessages);
-  }
-  _canSkipDirty() {
-    return this._sinkCount === 1 && this._singleDepSinkCount === 1;
-  }
-  _downToSinks(messages) {
-    if (this._sinks == null) return;
-    if (typeof this._sinks === "function") {
-      this._sinks(messages);
-      return;
-    }
-    const snapshot = [...this._sinks];
-    for (const sink of snapshot) {
-      sink(messages);
-    }
-  }
-  /**
-   * Update `_cached`, `_status`, `_terminal` from message batch before
-   * delivery. Subclass hooks `_onInvalidate` / `_onTeardown` let
-   * {@link NodeImpl} clear `_lastDepValues` and invoke cleanup fns.
-   */
-  _handleLocalLifecycle(messages) {
-    for (const m of messages) {
-      const t = m[0];
-      if (t === DATA) {
-        if (m.length < 2) {
-          continue;
-        }
-        this._cached = m[1];
-        if (this._versioning != null) {
-          advanceVersion(this._versioning, m[1], this._hashFn);
-        }
-      }
-      if (t === INVALIDATE) {
-        this._onInvalidate();
-        this._cached = NO_VALUE;
-      }
-      this._status = statusAfterMessage(this._status, m);
-      if (t === COMPLETE || t === ERROR) {
-        this._terminal = true;
-      }
-      if (t === TEARDOWN) {
-        if (this._resetOnTeardown) {
-          this._cached = NO_VALUE;
-        }
-        this._onTeardown();
-        try {
-          this._propagateToMeta(t);
-        } finally {
-          this._onDeactivate();
-        }
-      }
-      if (t !== TEARDOWN && propagatesToMeta(t)) {
-        this._propagateToMeta(t);
-      }
-    }
-  }
-  /**
-   * Subclass hook: invoked when INVALIDATE arrives (before `_cached` is
-   * cleared). {@link NodeImpl} uses this to run the fn cleanup fn and
-   * drop `_lastDepValues` so the next wave re-runs fn.
-   */
-  _onInvalidate() {
-  }
-  /**
-   * Subclass hook: invoked when TEARDOWN arrives, before `_onDeactivate`.
-   * {@link NodeImpl} uses this to run any pending cleanup fn.
-   */
-  _onTeardown() {
-  }
-  /** Forward a signal to all companion meta nodes (best-effort). */
-  _propagateToMeta(t) {
-    for (const metaNode of Object.values(this.meta)) {
-      try {
-        metaNode._downInternal([[t]]);
-      } catch {
-      }
-    }
-  }
-  /**
-   * Frame a computed value into the right protocol messages and dispatch
-   * via `_downInternal`. Used by `_runFn` and `actions.emit`.
-   */
-  _downAutoValue(value) {
-    const wasDirty = this._status === "dirty";
-    let unchanged;
-    try {
-      unchanged = this._cached !== NO_VALUE && this._equals(this._cached, value);
-    } catch (eqErr) {
-      const eqMsg = eqErr instanceof Error ? eqErr.message : String(eqErr);
-      const wrapped = new Error(`Node "${this.name}": equals threw: ${eqMsg}`, {
-        cause: eqErr
-      });
-      this._downInternal([[ERROR, wrapped]]);
-      return;
-    }
-    if (unchanged) {
-      this._downInternal(wasDirty ? [[RESOLVED]] : [[DIRTY], [RESOLVED]]);
-      return;
-    }
-    this._downInternal(wasDirty ? [[DATA, value]] : [[DIRTY], [DATA, value]]);
-  }
-};
-
-// src/core/node.ts
-var NodeImpl = class extends NodeBase {
-  // --- Dep configuration (set once) ---
-  _deps;
-  _fn;
-  _opts;
-  _hasDeps;
-  _isSingleDep;
-  _autoComplete;
-  // --- Wave tracking masks ---
-  _depDirtyMask;
-  _depSettledMask;
-  _depCompleteMask;
-  _allDepsCompleteMask;
-  // --- Identity-skip optimization ---
-  _lastDepValues;
-  _cleanup;
-  // --- Upstream bookkeeping ---
-  _upstreamUnsubs = [];
-  // --- Fn behavior flag ---
-  /** @internal Read by `describeNode` to infer `"operator"` label. */
-  _manualEmitUsed = false;
-  constructor(deps, fn, opts) {
-    super(opts);
-    this._deps = deps;
-    this._fn = fn;
-    this._opts = opts;
-    this._hasDeps = deps.length > 0;
-    this._isSingleDep = deps.length === 1 && fn != null;
-    this._autoComplete = opts.completeWhenDepsComplete ?? true;
-    if (!this._hasDeps && fn == null && this._cached !== NO_VALUE) {
-      this._status = "settled";
-    }
-    this._depDirtyMask = createBitSet(deps.length);
-    this._depSettledMask = createBitSet(deps.length);
-    this._depCompleteMask = createBitSet(deps.length);
-    this._allDepsCompleteMask = createBitSet(deps.length);
-    for (let i = 0; i < deps.length; i++) this._allDepsCompleteMask.set(i);
-    this.down = this.down.bind(this);
-    this.up = this.up.bind(this);
-  }
-  // --- Meta node factory (called from base constructor) ---
-  _createMetaNode(key, initialValue, opts) {
-    return node({
-      initial: initialValue,
-      name: `${opts.name ?? "node"}:meta:${key}`,
-      describeKind: "state",
-      ...opts.guard != null ? { guard: opts.guard } : {}
-    });
-  }
-  // --- Manual emit tracker (set by actions.down / actions.emit) ---
-  _onManualEmit() {
-    this._manualEmitUsed = true;
-  }
-  // --- Up / unsubscribe ---
-  up(messages, options) {
-    if (!this._hasDeps) return;
-    if (!options?.internal && this._guard != null) {
-      const actor = normalizeActor(options?.actor);
-      if (!this._guard(actor, "write")) {
-        throw new GuardDenied({ actor, action: "write", nodeName: this.name });
-      }
-      this._recordMutation(actor);
-    }
-    for (const dep of this._deps) {
-      if (options === void 0) {
-        dep.up?.(messages);
-      } else {
-        dep.up?.(messages, options);
-      }
-    }
-  }
-  _upInternal(messages) {
-    if (!this._hasDeps) return;
-    for (const dep of this._deps) {
-      dep.up?.(messages, { internal: true });
-    }
-  }
-  unsubscribe() {
-    if (!this._hasDeps) return;
-    this._disconnectUpstream();
-  }
-  // --- Activation (first-subscriber / last-subscriber hooks) ---
-  _onActivate() {
-    if (this._hasDeps) {
-      this._connectUpstream();
-      return;
-    }
-    if (this._fn) {
-      this._runFn();
-      return;
-    }
-  }
-  _doDeactivate() {
-    this._disconnectUpstream();
-    const cleanup = this._cleanup;
-    this._cleanup = void 0;
-    cleanup?.();
-    if (this._fn != null) {
-      this._cached = NO_VALUE;
-      this._lastDepValues = void 0;
-    }
-    if (this._hasDeps || this._fn != null) {
-      this._status = "disconnected";
-    }
-  }
-  // --- INVALIDATE / TEARDOWN hooks (clear fn state) ---
-  _onInvalidate() {
-    const cleanup = this._cleanup;
-    this._cleanup = void 0;
-    cleanup?.();
-    this._lastDepValues = void 0;
-  }
-  _onTeardown() {
-    const cleanup = this._cleanup;
-    this._cleanup = void 0;
-    cleanup?.();
-  }
-  // --- Upstream connect / disconnect ---
-  _connectUpstream() {
-    if (!this._hasDeps) return;
-    if (this._upstreamUnsubs.length > 0) return;
-    this._depDirtyMask.setAll();
-    this._depSettledMask.reset();
-    this._depCompleteMask.reset();
-    const depValuesBefore = this._lastDepValues;
-    const subHints = this._isSingleDep ? { singleDep: true } : void 0;
-    for (let i = 0; i < this._deps.length; i += 1) {
-      const dep = this._deps[i];
-      this._upstreamUnsubs.push(
-        dep.subscribe((msgs) => this._handleDepMessages(i, msgs), subHints)
-      );
-    }
-    if (this._fn && this._onMessage && !this._terminal && this._lastDepValues === depValuesBefore) {
-      this._runFn();
-    }
-  }
-  _disconnectUpstream() {
-    if (this._upstreamUnsubs.length === 0) return;
-    for (const unsub of this._upstreamUnsubs.splice(0)) {
-      unsub();
-    }
-    this._depDirtyMask.reset();
-    this._depSettledMask.reset();
-    this._depCompleteMask.reset();
-  }
-  // --- Wave handling ---
-  _handleDepMessages(index, messages) {
-    for (const msg of messages) {
-      this._emitInspectorHook({ kind: "dep_message", depIndex: index, message: msg });
-      const t = msg[0];
-      if (this._onMessage) {
-        try {
-          const consumed = this._onMessage(msg, index, this._actions);
-          if (consumed) {
-            if (t === START || t === DATA || t === RESOLVED) {
-              this._depDirtyMask.clear(index);
-              if (this._depDirtyMask.any() && this._depSettledMask.covers(this._depDirtyMask)) {
-                this._depDirtyMask.reset();
-                this._depSettledMask.reset();
-                this._runFn();
-              }
-            }
-            continue;
-          }
-        } catch (err) {
-          const errMsg = err instanceof Error ? err.message : String(err);
-          const wrapped = new Error(`Node "${this.name}": onMessage threw: ${errMsg}`, {
-            cause: err
-          });
-          this._downInternal([[ERROR, wrapped]]);
-          return;
-        }
-      }
-      if (messageTier(t) < 1) continue;
-      if (!this._fn) {
-        if (t === COMPLETE && this._deps.length > 1) {
-          this._depCompleteMask.set(index);
-          this._maybeCompleteFromDeps();
-          continue;
-        }
-        this._downInternal([msg]);
-        continue;
-      }
-      if (t === DIRTY) {
-        this._onDepDirty(index);
-        continue;
-      }
-      if (t === DATA || t === RESOLVED) {
-        this._onDepSettled(index);
-        continue;
-      }
-      if (t === COMPLETE) {
-        this._depCompleteMask.set(index);
-        this._depDirtyMask.clear(index);
-        this._depSettledMask.clear(index);
-        if (this._depDirtyMask.any() && this._depSettledMask.covers(this._depDirtyMask)) {
-          this._depDirtyMask.reset();
-          this._depSettledMask.reset();
-          this._runFn();
-        } else if (!this._depDirtyMask.any() && this._status === "dirty") {
-          this._depSettledMask.reset();
-          this._runFn();
-        }
-        this._maybeCompleteFromDeps();
-        continue;
-      }
-      if (t === ERROR) {
-        this._downInternal([msg]);
-        continue;
-      }
-      if (t === INVALIDATE || t === TEARDOWN || t === PAUSE || t === RESUME) {
-        this._downInternal([msg]);
-        continue;
-      }
-      this._downInternal([msg]);
-    }
-  }
-  _onDepDirty(index) {
-    const wasDirty = this._depDirtyMask.has(index);
-    this._depDirtyMask.set(index);
-    this._depSettledMask.clear(index);
-    if (!wasDirty) {
-      this._downInternal([[DIRTY]]);
-    }
-  }
-  _onDepSettled(index) {
-    if (!this._depDirtyMask.has(index)) {
-      this._onDepDirty(index);
-    }
-    this._depSettledMask.set(index);
-    if (this._depDirtyMask.any() && this._depSettledMask.covers(this._depDirtyMask)) {
-      this._depDirtyMask.reset();
-      this._depSettledMask.reset();
-      this._runFn();
-    }
-  }
-  _maybeCompleteFromDeps() {
-    if (this._autoComplete && this._deps.length > 0 && this._depCompleteMask.covers(this._allDepsCompleteMask)) {
-      this._downInternal([[COMPLETE]]);
-    }
-  }
-  // --- Fn execution ---
-  _runFn() {
-    if (!this._fn) return;
-    if (this._terminal && !this._resubscribable) return;
-    try {
-      const n = this._deps.length;
-      const depValues = new Array(n);
-      for (let i = 0; i < n; i++) depValues[i] = this._deps[i].get();
-      const prev = this._lastDepValues;
-      if (n > 0 && prev != null && prev.length === n) {
-        let allSame = true;
-        for (let i = 0; i < n; i++) {
-          if (!Object.is(depValues[i], prev[i])) {
-            allSame = false;
-            break;
-          }
-        }
-        if (allSame) {
-          if (this._status === "dirty") {
-            this._downInternal([[RESOLVED]]);
-          }
-          return;
-        }
-      }
-      const prevCleanup = this._cleanup;
-      this._cleanup = void 0;
-      prevCleanup?.();
-      this._manualEmitUsed = false;
-      this._lastDepValues = depValues;
-      this._emitInspectorHook({ kind: "run", depValues });
-      const out = this._fn(depValues, this._actions);
-      if (isCleanupResult(out)) {
-        this._cleanup = out.cleanup;
-        if (this._manualEmitUsed) return;
-        if ("value" in out) {
-          this._downAutoValue(out.value);
-        }
-        return;
-      }
-      if (isCleanupFn(out)) {
-        this._cleanup = out;
-        return;
-      }
-      if (this._manualEmitUsed) return;
-      if (out === void 0) return;
-      this._downAutoValue(out);
-    } catch (err) {
-      const errMsg = err instanceof Error ? err.message : String(err);
-      const wrapped = new Error(`Node "${this.name}": fn threw: ${errMsg}`, { cause: err });
-      this._downInternal([[ERROR, wrapped]]);
-    }
-  }
-};
-var isNodeArray = (value) => Array.isArray(value);
-var isNodeOptions = (value) => typeof value === "object" && value != null && !Array.isArray(value);
-function node(depsOrFn, fnOrOpts, optsArg) {
-  const deps = isNodeArray(depsOrFn) ? depsOrFn : [];
-  const fn = typeof depsOrFn === "function" ? depsOrFn : typeof fnOrOpts === "function" ? fnOrOpts : void 0;
-  let opts = {};
-  if (isNodeArray(depsOrFn)) {
-    opts = (isNodeOptions(fnOrOpts) ? fnOrOpts : optsArg) ?? {};
-  } else if (isNodeOptions(depsOrFn)) {
-    opts = depsOrFn;
-  } else {
-    opts = (isNodeOptions(fnOrOpts) ? fnOrOpts : optsArg) ?? {};
-  }
-  return new NodeImpl(deps, fn, opts);
-}
-
-// src/core/dynamic-node.ts
-var MAX_RERUN = 16;
-function dynamicNode(fn, opts) {
-  return new DynamicNodeImpl(fn, opts ?? {});
-}
-var DynamicNodeImpl = class extends NodeBase {
-  _fn;
-  _autoComplete;
-  // Dynamic deps tracking
-  /** @internal Read by `describeNode`. */
-  _deps = [];
-  _depUnsubs = [];
-  _depIndexMap = /* @__PURE__ */ new Map();
-  _depDirtyBits = /* @__PURE__ */ new Set();
-  _depSettledBits = /* @__PURE__ */ new Set();
-  _depCompleteBits = /* @__PURE__ */ new Set();
-  // Execution state
-  _running = false;
-  _rewiring = false;
-  _bufferedDepMessages = [];
-  _trackedValues = /* @__PURE__ */ new Map();
-  _rerunCount = 0;
-  constructor(fn, opts) {
-    super(opts);
-    this._fn = fn;
-    this._autoComplete = opts.completeWhenDepsComplete ?? true;
-    this.down = this.down.bind(this);
-    this.up = this.up.bind(this);
-  }
-  _createMetaNode(key, initialValue, opts) {
-    return node({
-      initial: initialValue,
-      name: `${opts.name ?? "dynamicNode"}:meta:${key}`,
-      describeKind: "state",
-      ...opts.guard != null ? { guard: opts.guard } : {}
-    });
-  }
-  /** Versioning not supported on DynamicNodeImpl (override base). */
-  get v() {
-    return void 0;
-  }
-  // --- Up / unsubscribe ---
-  up(messages, options) {
-    if (this._deps.length === 0) return;
-    if (!options?.internal && this._guard != null) {
-      const actor = normalizeActor(options?.actor);
-      if (!this._guard(actor, "write")) {
-        throw new GuardDenied({ actor, action: "write", nodeName: this.name });
-      }
-      this._recordMutation(actor);
-    }
-    for (const dep of this._deps) {
-      dep.up?.(messages, options);
-    }
-  }
-  _upInternal(messages) {
-    for (const dep of this._deps) {
-      dep.up?.(messages, { internal: true });
-    }
-  }
-  unsubscribe() {
-    this._disconnect();
-  }
-  // --- Activation hooks ---
-  _onActivate() {
-    this._runFn();
-  }
-  _doDeactivate() {
-    this._disconnect();
-  }
-  _disconnect() {
-    for (const unsub of this._depUnsubs) unsub();
-    this._depUnsubs = [];
-    this._deps = [];
-    this._depIndexMap.clear();
-    this._depDirtyBits.clear();
-    this._depSettledBits.clear();
-    this._depCompleteBits.clear();
-    this._cached = NO_VALUE;
-    this._status = "disconnected";
-  }
-  // --- Fn execution with rewire buffer ---
-  _runFn() {
-    if (this._terminal && !this._resubscribable) return;
-    if (this._running) return;
-    this._running = true;
-    this._rerunCount = 0;
-    let result;
-    try {
-      for (; ; ) {
-        const trackedDeps = [];
-        const trackedValuesMap = /* @__PURE__ */ new Map();
-        const trackedSet = /* @__PURE__ */ new Set();
-        const get = (dep) => {
-          if (!trackedSet.has(dep)) {
-            trackedSet.add(dep);
-            trackedDeps.push(dep);
-            trackedValuesMap.set(dep, dep.get());
-          }
-          return dep.get();
-        };
-        this._trackedValues = trackedValuesMap;
-        const depValues = [];
-        for (const dep of this._deps) depValues.push(dep.get());
-        this._emitInspectorHook({ kind: "run", depValues });
-        try {
-          result = this._fn(get);
-        } catch (err) {
-          const errMsg = err instanceof Error ? err.message : String(err);
-          const wrapped = new Error(`Node "${this.name}": fn threw: ${errMsg}`, {
-            cause: err
-          });
-          this._downInternal([[ERROR, wrapped]]);
-          return;
-        }
-        this._rewiring = true;
-        this._bufferedDepMessages = [];
-        try {
-          this._rewire(trackedDeps);
-        } finally {
-          this._rewiring = false;
-        }
-        let needsRerun = false;
-        for (const entry of this._bufferedDepMessages) {
-          for (const msg of entry.msgs) {
-            if (msg[0] === DATA) {
-              const dep = this._deps[entry.index];
-              const trackedValue = dep != null ? this._trackedValues.get(dep) : void 0;
-              const actualValue = msg[1];
-              if (!this._equals(trackedValue, actualValue)) {
-                needsRerun = true;
-                break;
-              }
-            }
-          }
-          if (needsRerun) break;
-        }
-        if (needsRerun) {
-          this._rerunCount += 1;
-          if (this._rerunCount > MAX_RERUN) {
-            this._bufferedDepMessages = [];
-            this._downInternal([
-              [
-                ERROR,
-                new Error(
-                  `dynamicNode "${this.name ?? "anonymous"}": rewire did not stabilize within ${MAX_RERUN} iterations`
-                )
-              ]
-            ]);
-            return;
-          }
-          this._bufferedDepMessages = [];
-          continue;
-        }
-        const drain = this._bufferedDepMessages;
-        this._bufferedDepMessages = [];
-        for (const entry of drain) {
-          for (const msg of entry.msgs) {
-            this._updateMasksForMessage(entry.index, msg);
-          }
-        }
-        this._depDirtyBits.clear();
-        this._depSettledBits.clear();
-        break;
-      }
-    } finally {
-      this._running = false;
-    }
-    this._downAutoValue(result);
-  }
-  _rewire(newDeps) {
-    const oldMap = this._depIndexMap;
-    const newMap = /* @__PURE__ */ new Map();
-    const newUnsubs = [];
-    for (let i = 0; i < newDeps.length; i++) {
-      const dep = newDeps[i];
-      newMap.set(dep, i);
-      const oldIdx = oldMap.get(dep);
-      if (oldIdx !== void 0) {
-        newUnsubs.push(this._depUnsubs[oldIdx]);
-        this._depUnsubs[oldIdx] = () => {
-        };
-      } else {
-        const idx = i;
-        const unsub = dep.subscribe((msgs) => this._handleDepMessages(idx, msgs));
-        newUnsubs.push(unsub);
-      }
-    }
-    for (const [dep, oldIdx] of oldMap) {
-      if (!newMap.has(dep)) {
-        this._depUnsubs[oldIdx]();
-      }
-    }
-    this._deps = newDeps;
-    this._depUnsubs = newUnsubs;
-    this._depIndexMap = newMap;
-    this._depDirtyBits.clear();
-    this._depSettledBits.clear();
-    const newCompleteBits = /* @__PURE__ */ new Set();
-    for (const oldIdx of this._depCompleteBits) {
-      for (const [dep, idx] of oldMap) {
-        if (idx === oldIdx && newMap.has(dep)) {
-          newCompleteBits.add(newMap.get(dep));
-          break;
-        }
-      }
-    }
-    this._depCompleteBits = newCompleteBits;
-  }
-  // --- Dep message handling ---
-  _handleDepMessages(index, messages) {
-    if (this._rewiring) {
-      this._bufferedDepMessages.push({ index, msgs: messages });
-      return;
-    }
-    for (const msg of messages) {
-      this._emitInspectorHook({ kind: "dep_message", depIndex: index, message: msg });
-      const t = msg[0];
-      if (this._onMessage) {
-        try {
-          if (this._onMessage(msg, index, this._actions)) continue;
-        } catch (err) {
-          const errMsg = err instanceof Error ? err.message : String(err);
-          const wrapped = new Error(`Node "${this.name}": onMessage threw: ${errMsg}`, {
-            cause: err
-          });
-          this._downInternal([[ERROR, wrapped]]);
-          return;
-        }
-      }
-      if (messageTier(t) < 1) continue;
-      if (t === DIRTY) {
-        const wasEmpty = this._depDirtyBits.size === 0;
-        this._depDirtyBits.add(index);
-        this._depSettledBits.delete(index);
-        if (wasEmpty) {
-          this._downInternal([[DIRTY]]);
-        }
-        continue;
-      }
-      if (t === DATA || t === RESOLVED) {
-        if (!this._depDirtyBits.has(index)) {
-          const wasEmpty = this._depDirtyBits.size === 0;
-          this._depDirtyBits.add(index);
-          if (wasEmpty) {
-            this._downInternal([[DIRTY]]);
-          }
-        }
-        this._depSettledBits.add(index);
-        if (this._allDirtySettled()) {
-          this._depDirtyBits.clear();
-          this._depSettledBits.clear();
-          if (!this._running) {
-            if (this._depValuesDifferFromTracked()) {
-              this._runFn();
-            }
-          }
-        }
-        continue;
-      }
-      if (t === COMPLETE) {
-        this._depCompleteBits.add(index);
-        this._depDirtyBits.delete(index);
-        this._depSettledBits.delete(index);
-        if (this._allDirtySettled()) {
-          this._depDirtyBits.clear();
-          this._depSettledBits.clear();
-          if (!this._running) this._runFn();
-        }
-        if (this._autoComplete && this._depCompleteBits.size >= this._deps.length && this._deps.length > 0) {
-          this._downInternal([[COMPLETE]]);
-        }
-        continue;
-      }
-      if (t === ERROR) {
-        this._downInternal([msg]);
-        continue;
-      }
-      if (t === INVALIDATE || t === TEARDOWN || t === PAUSE || t === RESUME) {
-        this._downInternal([msg]);
-        continue;
-      }
-      this._downInternal([msg]);
-    }
-  }
-  /**
-   * Update dep masks for a message without triggering `_runFn` — used
-   * during post-rewire drain so the wave state is consistent with the
-   * buffered activation cascade without recursing.
-   */
-  _updateMasksForMessage(index, msg) {
-    const t = msg[0];
-    if (t === DIRTY) {
-      this._depDirtyBits.add(index);
-      this._depSettledBits.delete(index);
-    } else if (t === DATA || t === RESOLVED) {
-      this._depDirtyBits.add(index);
-      this._depSettledBits.add(index);
-    } else if (t === COMPLETE) {
-      this._depCompleteBits.add(index);
-      this._depDirtyBits.delete(index);
-      this._depSettledBits.delete(index);
-    }
-  }
-  _allDirtySettled() {
-    if (this._depDirtyBits.size === 0) return false;
-    for (const idx of this._depDirtyBits) {
-      if (!this._depSettledBits.has(idx)) return false;
-    }
-    return true;
-  }
-  /**
-   * True if any current dep value differs from what the last `_runFn`
-   * saw via `get()`. Used to suppress redundant re-runs when deferred
-   * handshake messages arrive after `_rewire` for a dep whose value
-   * already matches `_trackedValues`.
-   */
-  _depValuesDifferFromTracked() {
-    for (const dep of this._deps) {
-      const current = dep.get();
-      const tracked = this._trackedValues.get(dep);
-      if (!this._equals(current, tracked)) return true;
-    }
-    return false;
-  }
-};
-
-// src/core/sugar.ts
-function state(initial, opts) {
-  return node([], { ...opts, initial });
-}
-function producer(fn, opts) {
-  return node(fn, { describeKind: "producer", ...opts });
-}
-function derived(deps, fn, opts) {
-  return node(deps, fn, { describeKind: "derived", ...opts });
-}
-function effect(deps, fn, opts) {
-  return node(deps, fn, { describeKind: "effect", ...opts });
-}
-function pipe(source, ...ops) {
-  let current = source;
-  for (const op of ops) {
-    current = op(current);
-  }
-  return current;
-}
-
-export {
-  __require,
-  __export,
-  __decoratorStart,
-  __runInitializers,
-  __decorateElement,
-  DEFAULT_ACTOR,
-  normalizeActor,
-  GuardDenied,
-  policy,
-  policyFromRules,
-  accessHintForGuard,
-  START,
-  DATA,
-  DIRTY,
-  RESOLVED,
-  INVALIDATE,
-  PAUSE,
-  RESUME,
-  TEARDOWN,
-  COMPLETE,
-  ERROR,
-  knownMessageTypes,
-  isKnownMessageType,
-  messageTier,
-  isPhase2Message,
-  isTerminalMessage,
-  isLocalOnly,
-  propagatesToMeta,
-  isBatching,
-  batch,
-  partitionForBatch,
-  downWithBatch,
-  monotonicNs,
-  wallClockNs,
-  defaultHash,
-  createVersioning,
-  advanceVersion,
-  isV1,
-  NO_VALUE,
-  CLEANUP_RESULT,
-  cleanupResult,
-  NodeImpl,
-  node,
-  dynamicNode,
-  DynamicNodeImpl,
-  state,
-  producer,
-  derived,
-  effect,
-  pipe
-};
-//# sourceMappingURL=chunk-4MQ2J6IG.js.map