@graphrefly/graphrefly 0.21.0 → 0.23.0

package/dist/chunk-NZMBRXQV.js

@@ -0,0 +1,2330 @@
+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/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 DIRTY_MSG = Object.freeze([DIRTY]);
+var RESOLVED_MSG = Object.freeze([RESOLVED]);
+var INVALIDATE_MSG = Object.freeze([INVALIDATE]);
+var START_MSG = Object.freeze([START]);
+var COMPLETE_MSG = Object.freeze([COMPLETE]);
+var TEARDOWN_MSG = Object.freeze([TEARDOWN]);
+var DIRTY_ONLY_BATCH = Object.freeze([DIRTY_MSG]);
+var RESOLVED_ONLY_BATCH = Object.freeze([RESOLVED_MSG]);
+var INVALIDATE_ONLY_BATCH = Object.freeze([INVALIDATE_MSG]);
+var COMPLETE_ONLY_BATCH = Object.freeze([COMPLETE_MSG]);
+var TEARDOWN_ONLY_BATCH = Object.freeze([TEARDOWN_MSG]);
+
+// src/graph/codec.ts
+var JsonCodec = {
+  name: "json",
+  version: 1,
+  contentType: "application/json",
+  encode(snapshot) {
+    const json = JSON.stringify(snapshot);
+    return new TextEncoder().encode(json);
+  },
+  decode(buffer, _codecVersion) {
+    const json = new TextDecoder().decode(buffer);
+    return JSON.parse(json);
+  }
+};
+function createDagCborCodec(dagCbor) {
+  return {
+    name: "dag-cbor",
+    version: 1,
+    contentType: "application/dag-cbor",
+    encode: (snapshot) => dagCbor.encode(snapshot),
+    decode: (buffer, _codecVersion) => dagCbor.decode(buffer)
+  };
+}
+function createDagCborZstdCodec(dagCbor, zstd) {
+  return {
+    name: "dag-cbor-zstd",
+    version: 1,
+    contentType: "application/dag-cbor+zstd",
+    encode: (snapshot) => zstd.compressSync(dagCbor.encode(snapshot)),
+    decode: (buffer, _codecVersion) => dagCbor.decode(zstd.decompressSync(buffer))
+  };
+}
+var ENVELOPE_VERSION = 1;
+var ENVELOPE_MIN_LEN = 4;
+function encodeEnvelope(codec, payload) {
+  const nameBytes = new TextEncoder().encode(codec.name);
+  if (nameBytes.length === 0 || nameBytes.length > 255) {
+    throw new Error(
+      `encodeEnvelope: codec name "${codec.name}" encodes to ${nameBytes.length} bytes (must be 1\u2013255)`
+    );
+  }
+  const cv = codec.version;
+  if (!Number.isInteger(cv) || cv < 0 || cv > 65535) {
+    throw new Error(
+      `encodeEnvelope: codec.version ${cv} out of u16 range (expected integer 0\u201365535)`
+    );
+  }
+  const totalLen = 1 + 1 + nameBytes.length + 2 + payload.length;
+  if (totalLen > 4294967295) {
+    throw new Error(
+      `encodeEnvelope: total envelope size ${totalLen} exceeds 2^32-1 bytes (payload ${payload.length} bytes)`
+    );
+  }
+  const out = new Uint8Array(totalLen);
+  let i = 0;
+  out[i++] = ENVELOPE_VERSION;
+  out[i++] = nameBytes.length;
+  out.set(nameBytes, i);
+  i += nameBytes.length;
+  out[i++] = cv >>> 8 & 255;
+  out[i++] = cv & 255;
+  out.set(payload, i);
+  return out;
+}
+function decodeEnvelope(bytes, config) {
+  if (bytes.length < ENVELOPE_MIN_LEN) {
+    throw new Error(`decodeEnvelope: bytes too short (${bytes.length} < ${ENVELOPE_MIN_LEN})`);
+  }
+  let i = 0;
+  const envVersion = bytes[i++];
+  if (envVersion !== ENVELOPE_VERSION) {
+    throw new Error(
+      `decodeEnvelope: unsupported envelope version ${envVersion} (expected ${ENVELOPE_VERSION})`
+    );
+  }
+  const nameLen = bytes[i++];
+  if (nameLen === 0) {
+    throw new Error("decodeEnvelope: name_len must be >= 1");
+  }
+  if (i + nameLen + 2 > bytes.length) {
+    throw new Error(
+      `decodeEnvelope: envelope truncated (need ${i + nameLen + 2} bytes, have ${bytes.length})`
+    );
+  }
+  const name = new TextDecoder().decode(bytes.subarray(i, i + nameLen));
+  i += nameLen;
+  const codecVersion = (bytes[i] << 8 | bytes[i + 1]) >>> 0;
+  i += 2;
+  const payload = bytes.subarray(i);
+  const codec = config.lookupCodec(name);
+  if (codec == null) {
+    throw new Error(
+      `decodeEnvelope: codec "${name}" not registered (envelope codec_v=${codecVersion})`
+    );
+  }
+  return { codec, codecVersion, payload };
+}
+function registerBuiltinCodecs(config) {
+  config.registerCodec(JsonCodec);
+}
+function replayWAL(entries) {
+  if (entries.length === 0) {
+    throw new Error("WAL is empty \u2014 need at least one full snapshot");
+  }
+  const first = entries[0];
+  if (first.mode !== "full") {
+    throw new Error("WAL must start with a full record carrying a baseline snapshot");
+  }
+  let result = JSON.parse(JSON.stringify(first.snapshot));
+  let prevSeq = first.seq;
+  for (let i = 1; i < entries.length; i++) {
+    const entry = entries[i];
+    if (entry.seq <= prevSeq) {
+      throw new Error(
+        `WAL chain broken at index ${i}: seq=${entry.seq} must exceed prev seq=${prevSeq}`
+      );
+    }
+    if (entry.mode === "full") {
+      result = JSON.parse(JSON.stringify(entry.snapshot));
+      prevSeq = entry.seq;
+      continue;
+    }
+    const diff = entry.diff;
+    for (const path of diff.nodesRemoved) {
+      delete result.nodes[path];
+    }
+    const addedFull = diff.nodesAddedFull;
+    if (addedFull != null) {
+      for (const [path, slice] of Object.entries(addedFull)) {
+        result.nodes[path] = JSON.parse(JSON.stringify(slice));
+      }
+    }
+    for (const change of diff.nodesChanged) {
+      const existing = result.nodes[change.path];
+      if (existing == null) continue;
+      existing[change.field] = change.to;
+    }
+    prevSeq = entry.seq;
+  }
+  return result;
+}
+
+// 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/batch.ts
+var MAX_DRAIN_ITERATIONS = 1e3;
+var batchDepth = 0;
+var flushInProgress = false;
+var drainPhase2 = [];
+var drainPhase3 = [];
+var drainPhase4 = [];
+var flushHooks = [];
+function isBatching() {
+  return batchDepth > 0 || flushInProgress;
+}
+function isExplicitlyBatching() {
+  return batchDepth > 0;
+}
+function registerBatchFlushHook(hook) {
+  if (batchDepth > 0) {
+    flushHooks.push(hook);
+  } else {
+    hook();
+  }
+}
+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) {
+          const hooks = flushHooks.splice(0);
+          for (const h of hooks) {
+            try {
+              h();
+            } catch {
+            }
+          }
+          drainPhase2.length = 0;
+          drainPhase3.length = 0;
+          drainPhase4.length = 0;
+        }
+      } else {
+        drainPending();
+      }
+    }
+  }
+}
+function drainPending() {
+  const ownsFlush = !flushInProgress;
+  if (ownsFlush) flushInProgress = true;
+  const errors = [];
+  let iterations = 0;
+  try {
+    while (drainPhase2.length > 0 || drainPhase3.length > 0 || drainPhase4.length > 0 || ownsFlush && flushHooks.length > 0) {
+      if (ownsFlush && flushHooks.length > 0) {
+        const hooks = flushHooks.splice(0);
+        for (const h of hooks) {
+          try {
+            h();
+          } catch (e) {
+            errors.push(e);
+          }
+        }
+        continue;
+      }
+      iterations += 1;
+      if (iterations > MAX_DRAIN_ITERATIONS) {
+        drainPhase2.length = 0;
+        drainPhase3.length = 0;
+        drainPhase4.length = 0;
+        throw new Error(
+          `batch drain exceeded ${MAX_DRAIN_ITERATIONS} iterations \u2014 likely a reactive cycle`
+        );
+      }
+      const queue = drainPhase2.length > 0 ? drainPhase2 : drainPhase3.length > 0 ? drainPhase3 : drainPhase4;
+      const ops = queue.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 downWithBatch(sink, messages, tierOf) {
+  if (messages.length === 0) return;
+  if (messages.length === 1) {
+    const tier = tierOf(messages[0][0]);
+    if (tier < 3 || !isBatching()) {
+      sink(messages);
+      return;
+    }
+    const queue = tier >= 5 ? drainPhase4 : tier === 4 ? drainPhase3 : drainPhase2;
+    queue.push(() => sink(messages));
+    return;
+  }
+  const n = messages.length;
+  let phase2Start = n;
+  let phase3Start = n;
+  let phase4Start = n;
+  let i = 0;
+  while (i < n && tierOf(messages[i][0]) < 3) i++;
+  phase2Start = i;
+  while (i < n && tierOf(messages[i][0]) === 3) i++;
+  phase3Start = i;
+  while (i < n && tierOf(messages[i][0]) === 4) i++;
+  phase4Start = i;
+  const batching = isBatching();
+  if (phase2Start > 0) {
+    const immediate = messages.slice(0, phase2Start);
+    sink(immediate);
+  }
+  if (phase3Start > phase2Start) {
+    const phase2 = messages.slice(phase2Start, phase3Start);
+    if (batching) drainPhase2.push(() => sink(phase2));
+    else sink(phase2);
+  }
+  if (phase4Start > phase3Start) {
+    const phase3 = messages.slice(phase3Start, phase4Start);
+    if (batching) drainPhase3.push(() => sink(phase3));
+    else sink(phase3);
+  }
+  if (n > phase4Start) {
+    const phase4 = messages.slice(phase4Start, n);
+    if (batching) drainPhase4.push(() => sink(phase4));
+    else sink(phase4);
+  }
+}
+
+// src/core/clock.ts
+function monotonicNs() {
+  return Math.trunc(performance.now() * 1e6);
+}
+function wallClockNs() {
+  return Date.now() * 1e6;
+}
+
+// src/core/config.ts
+var GraphReFlyConfig = class {
+  _messageTypes = /* @__PURE__ */ new Map();
+  _codecs = /* @__PURE__ */ new Map();
+  _onMessage;
+  _onSubscribe;
+  _defaultVersioning;
+  _defaultHashFn;
+  _inspectorEnabled = !(typeof process !== "undefined" && process.env?.NODE_ENV === "production");
+  _globalInspector;
+  _frozen = false;
+  /**
+   * Pre-bound tier lookup — shared by every node bound to this config. Since
+   * the registry is frozen on first hook access, this closure can be built
+   * once in the constructor and handed directly to `downWithBatch` /
+   * `_frameBatch` paths without per-node or per-emission `.bind(config)`
+   * allocation.
+   */
+  tierOf;
+  constructor(init) {
+    this._onMessage = init.onMessage;
+    this._onSubscribe = init.onSubscribe;
+    this._defaultVersioning = init.defaultVersioning;
+    this._defaultHashFn = init.defaultHashFn;
+    this.tierOf = (t) => {
+      const reg = this._messageTypes.get(t);
+      return reg != null ? reg.tier : 1;
+    };
+  }
+  // --- Hook getters (freeze on read) ---
+  get onMessage() {
+    this._frozen = true;
+    return this._onMessage;
+  }
+  get onSubscribe() {
+    this._frozen = true;
+    return this._onSubscribe;
+  }
+  // --- Hook setters (throw when frozen) ---
+  set onMessage(v) {
+    this._assertUnfrozen();
+    this._onMessage = v;
+  }
+  set onSubscribe(v) {
+    this._assertUnfrozen();
+    this._onSubscribe = v;
+  }
+  /**
+   * Default versioning level applied to every node bound to this config,
+   * unless the node's own `opts.versioning` provides an explicit override.
+   * Setting this is only allowed before the config freezes (i.e., before
+   * the first node is created) so every node in the graph sees a
+   * consistent starting level. Individual nodes can still opt into a
+   * higher level via `opts.versioning`, or post-hoc via
+   * `NodeImpl._applyVersioning(level)` when the node is quiescent.
+   *
+   * v0 is the minimum opt-in — unversioned nodes (`undefined`) skip
+   * the version counter entirely. v1 adds content-addressed cid.
+   * Future levels (v2, v3) are reserved for linked-history and
+   * cryptographic attestation extensions.
+   */
+  get defaultVersioning() {
+    return this._defaultVersioning;
+  }
+  set defaultVersioning(v) {
+    this._assertUnfrozen();
+    this._defaultVersioning = v;
+  }
+  /**
+   * Default content-hash function applied to every versioned node bound
+   * to this config, unless the node's own `opts.versioningHash` provides
+   * an explicit override. Use this when a graph needs a non-default hash
+   * — e.g., swap the vendored sync SHA-256 for a faster non-crypto hash
+   * (xxHash, FNV-1a) in hot-path workloads, or a stronger hash when
+   * versioning v1 cids are used as audit anchors.
+   *
+   * Only settable before the config freezes. Individual nodes can still
+   * override via `opts.versioningHash`.
+   */
+  get defaultHashFn() {
+    return this._defaultHashFn;
+  }
+  set defaultHashFn(v) {
+    this._assertUnfrozen();
+    this._defaultHashFn = v;
+  }
+  /**
+   * When `false`, structured observation options (`causal`, `timeline`)
+   * and `Graph.trace()` writes are no-ops. Raw `Graph.observe()` always
+   * works. Default: `true` outside production (`NODE_ENV !== "production"`).
+   *
+   * Settable at any time — inspector gating is an operational concern, not
+   * a protocol invariant, so it does NOT require freeze before node creation.
+   */
+  get inspectorEnabled() {
+    return this._inspectorEnabled;
+  }
+  set inspectorEnabled(v) {
+    this._inspectorEnabled = v;
+  }
+  /**
+   * Process-global observability hook (Redux-DevTools-style full-graph
+   * tracer). Fires once per outgoing batch from every node bound to this
+   * config, gated by {@link inspectorEnabled}. See {@link GlobalInspectorHook}.
+   *
+   * Settable at any time — like {@link inspectorEnabled} this is operational,
+   * not protocol-shaping, so it does NOT trigger config freeze.
+   */
+  get globalInspector() {
+    return this._globalInspector;
+  }
+  set globalInspector(v) {
+    this._globalInspector = v;
+  }
+  // --- Registry (writes require unfrozen; reads are free lookups) ---
+  /**
+   * Register a custom message type. Must be called before any node that
+   * uses this config has been created — otherwise throws. Default
+   * `wireCrossing` is `tier >= 3`.
+   */
+  registerMessageType(t, input) {
+    this._assertUnfrozen();
+    this._messageTypes.set(t, {
+      tier: input.tier,
+      wireCrossing: input.wireCrossing ?? input.tier >= 3,
+      metaPassthrough: input.metaPassthrough ?? true
+    });
+    return this;
+  }
+  /** Tier for `t`. Unknown types default to tier 1 (immediate, after START). */
+  messageTier(t) {
+    const reg = this._messageTypes.get(t);
+    return reg != null ? reg.tier : 1;
+  }
+  /**
+   * Whether `t` is registered as wire-crossing. Unknown types default to
+   * `true` (spec §1.3.6 forward-compat — unknowns cross the wire).
+   */
+  isWireCrossing(t) {
+    const reg = this._messageTypes.get(t);
+    return reg != null ? reg.wireCrossing : true;
+  }
+  /** Convenience inverse of {@link isWireCrossing}. */
+  isLocalOnly(t) {
+    return !this.isWireCrossing(t);
+  }
+  /**
+   * Whether `t` is forwarded to meta companions by `Graph.signal`. Defaults
+   * to `true` for unknowns (forward-compat — new types pass through meta by
+   * default; opt-in filter via `registerMessageType({metaPassthrough: false})`).
+   */
+  isMetaPassthrough(t) {
+    const reg = this._messageTypes.get(t);
+    return reg != null ? reg.metaPassthrough : true;
+  }
+  /** Whether `t` is a registered (built-in or custom) type. */
+  isKnownMessageType(t) {
+    return this._messageTypes.has(t);
+  }
+  // --- Codec registry (writes require unfrozen; reads are free lookups) ---
+  /**
+   * Register a graph codec by `codec.name`. Used by the envelope-based
+   * `graph.snapshot({format: "bytes", codec: name})` path and
+   * `Graph.decode(bytes)` auto-dispatch. Must be called before any node
+   * bound to this config is created — otherwise throws.
+   *
+   * Re-registering the same name overwrites, so user codecs can shadow
+   * built-in ones before freeze (e.g., to swap a zstd-wrapped dag-cbor in
+   * for `"dag-cbor"`).
+   */
+  registerCodec(codec) {
+    this._assertUnfrozen();
+    this._codecs.set(codec.name, codec);
+    return this;
+  }
+  /**
+   * Resolve a registered codec by name. Returns `undefined` for unknown
+   * names. Typed callers cast to their concrete codec interface (e.g.,
+   * `config.lookupCodec<GraphCodec>("json")`) — this method stays
+   * layer-pure (no import of graph-layer types into `core/`).
+   */
+  lookupCodec(name) {
+    return this._codecs.get(name);
+  }
+  /** @internal Used by tests and dev tooling — check freeze state without triggering it. */
+  _isFrozen() {
+    return this._frozen;
+  }
+  _assertUnfrozen() {
+    if (this._frozen) {
+      throw new Error(
+        "GraphReFlyConfig is frozen: a node has already captured this config. Register custom types and set hooks before creating any node."
+      );
+    }
+  }
+};
+function registerBuiltins(cfg) {
+  cfg.registerMessageType(START, { tier: 0, wireCrossing: false });
+  cfg.registerMessageType(DIRTY, { tier: 1, wireCrossing: false });
+  cfg.registerMessageType(INVALIDATE, {
+    tier: 1,
+    wireCrossing: false,
+    metaPassthrough: false
+  });
+  cfg.registerMessageType(PAUSE, { tier: 2, wireCrossing: false });
+  cfg.registerMessageType(RESUME, { tier: 2, wireCrossing: false });
+  cfg.registerMessageType(DATA, { tier: 3, wireCrossing: true });
+  cfg.registerMessageType(RESOLVED, { tier: 3, wireCrossing: true });
+  cfg.registerMessageType(COMPLETE, {
+    tier: 4,
+    wireCrossing: true,
+    metaPassthrough: false
+  });
+  cfg.registerMessageType(ERROR, {
+    tier: 4,
+    wireCrossing: true,
+    metaPassthrough: false
+  });
+  cfg.registerMessageType(TEARDOWN, {
+    tier: 5,
+    wireCrossing: true,
+    metaPassthrough: false
+  });
+}
+
+// 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/versioning.ts
+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;
+}
+var SHA256_K = /* @__PURE__ */ new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var UTF8_ENCODER = /* @__PURE__ */ new TextEncoder();
+function sha256Hex(msg) {
+  const bytes = UTF8_ENCODER.encode(msg);
+  const msgLen = bytes.length;
+  const bitLen = msgLen * 8;
+  const totalLen = msgLen + 9 + 63 & ~63;
+  const padded = new Uint8Array(totalLen);
+  padded.set(bytes);
+  padded[msgLen] = 128;
+  const dv = new DataView(padded.buffer);
+  dv.setUint32(totalLen - 4, bitLen >>> 0, false);
+  dv.setUint32(totalLen - 8, Math.floor(bitLen / 4294967296) >>> 0, false);
+  let h0 = 1779033703;
+  let h1 = 3144134277;
+  let h2 = 1013904242;
+  let h3 = 2773480762;
+  let h4 = 1359893119;
+  let h5 = 2600822924;
+  let h6 = 528734635;
+  let h7 = 1541459225;
+  const W = new Uint32Array(64);
+  const rotr = (x, n) => x >>> n | x << 32 - n;
+  for (let off = 0; off < totalLen; off += 64) {
+    for (let i = 0; i < 16; i++) W[i] = dv.getUint32(off + i * 4, false);
+    for (let i = 16; i < 64; i++) {
+      const w15 = W[i - 15];
+      const w2 = W[i - 2];
+      const s0 = rotr(w15, 7) ^ rotr(w15, 18) ^ w15 >>> 3;
+      const s1 = rotr(w2, 17) ^ rotr(w2, 19) ^ w2 >>> 10;
+      W[i] = W[i - 16] + s0 + W[i - 7] + s1 >>> 0;
+    }
+    let a = h0;
+    let b = h1;
+    let c = h2;
+    let d = h3;
+    let e = h4;
+    let f = h5;
+    let g = h6;
+    let h = h7;
+    for (let i = 0; i < 64; i++) {
+      const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const ch = e & f ^ ~e & g;
+      const t1 = h + S1 + ch + SHA256_K[i] + W[i] >>> 0;
+      const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const mj = a & b ^ a & c ^ b & c;
+      const t2 = S0 + mj >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + t1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 >>> 0;
+    }
+    h0 = h0 + a >>> 0;
+    h1 = h1 + b >>> 0;
+    h2 = h2 + c >>> 0;
+    h3 = h3 + d >>> 0;
+    h4 = h4 + e >>> 0;
+    h5 = h5 + f >>> 0;
+    h6 = h6 + g >>> 0;
+    h7 = h7 + h >>> 0;
+  }
+  const toHex = (x) => x.toString(16).padStart(8, "0");
+  return toHex(h0) + toHex(h1) + toHex(h2) + toHex(h3) + toHex(h4) + toHex(h5) + toHex(h6) + toHex(h7);
+}
+function defaultHash(value) {
+  const canonical = canonicalizeForHash(value ?? null);
+  const json = JSON.stringify(canonical);
+  return sha256Hex(json).slice(0, 16);
+}
+function randomUuid() {
+  const c = globalThis.crypto;
+  if (c?.randomUUID) return c.randomUUID();
+  const r = () => Math.floor(Math.random() * 4294967296).toString(16).padStart(8, "0");
+  const hex = r() + r() + r() + r();
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-${(parseInt(hex.slice(16, 17), 16) & 3 | 8).toString(16)}${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
+}
+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.ts
+var noopUnsub = () => {
+};
+var MAX_RERUN_DEPTH = 100;
+function createDepRecord(n) {
+  return {
+    node: n,
+    unsub: null,
+    prevData: void 0,
+    dirty: false,
+    involvedThisWave: false,
+    dataBatch: [],
+    terminal: void 0
+  };
+}
+function resetDepRecord(d) {
+  d.prevData = void 0;
+  d.dirty = false;
+  d.involvedThisWave = false;
+  d.dataBatch.length = 0;
+  d.terminal = void 0;
+}
+function normalizeMessages(input) {
+  if (input.length === 0) return input;
+  return typeof input[0] === "symbol" ? [input] : input;
+}
+var defaultOnMessage = (node2, msg, ctx, _actions) => {
+  if (ctx.direction === "down-in") {
+    node2._onDepMessage(ctx.depIndex, msg);
+  }
+  return void 0;
+};
+var defaultOnSubscribe = (node2, sink, _ctx, _actions) => {
+  const impl = node2;
+  if (impl._status === "completed" || impl._status === "errored") return;
+  const cached = impl._cached;
+  const initial = cached === void 0 ? [START_MSG] : [START_MSG, [DATA, cached]];
+  if (impl._status === "dirty") initial.push(DIRTY_MSG);
+  downWithBatch(sink, initial, impl._config.tierOf);
+};
+var defaultConfig = new GraphReFlyConfig({
+  onMessage: defaultOnMessage,
+  onSubscribe: defaultOnSubscribe
+});
+registerBuiltins(defaultConfig);
+registerBuiltinCodecs(defaultConfig);
+function configure(fn) {
+  if (defaultConfig._isFrozen()) {
+    throw new Error(
+      "configure() called after a node was created \u2014 the default GraphReFlyConfig is frozen. Call configure(...) at application startup, before any node factories run."
+    );
+  }
+  fn(defaultConfig);
+}
+var NodeImpl = class _NodeImpl {
+  // --- Identity ---
+  _optsName;
+  _describeKind;
+  meta;
+  /**
+   * Cached `Object.keys(meta).length > 0` check. `meta` is frozen at
+   * construction so this boolean never flips. Used by `_emit` to skip
+   * the meta TEARDOWN fan-out block allocation on the common "no meta"
+   * hot path.
+   */
+  _hasMeta;
+  // --- Config ---
+  _config;
+  // --- Topology ---
+  /** Mutable for autoTrackNode / Graph.connect() post-construction dep addition. */
+  _deps;
+  _sinks = null;
+  _sinkCount = 0;
+  // --- State ---
+  _cached;
+  _status;
+  _cleanup;
+  _store = {};
+  _waveHasNewData = false;
+  _hasNewTerminal = false;
+  _hasCalledFnOnce = false;
+  _paused = false;
+  _pendingWave = false;
+  _isExecutingFn = false;
+  _pendingRerun = false;
+  _rerunDepth = 0;
+  // --- Settlement counter (A3) ---
+  /**
+   * Count of deps currently in `dirty === true`. `_maybeRunFnOnSettlement`
+   * treats `0` as "wave settled" — O(1) check for full dep settlement.
+   */
+  _dirtyDepCount = 0;
+  // --- Per-batch emit accumulator (Bug 2: K+1 fan-in fix) ---
+  /**
+   * Inside an explicit `batch(() => ...)` scope, every `_emit` accumulates
+   * its already-framed messages here instead of dispatching synchronously.
+   * At batch end, `_flushBatchPending` runs (registered via
+   * `registerBatchFlushHook`) and delivers the whole accumulated batch as
+   * one `downWithBatch` call — collapsing what would otherwise be K
+   * separate sink invocations into one. This is the fix for the diamond
+   * fan-in K+1 over-fire.
+   *
+   * `null` outside batch (or after flush). Only ever appended to within
+   * a single explicit batch lifetime; reset to `null` on flush. State
+   * updates (cache, version, status) still happen per-emit via
+   * `_updateState` — only the downstream delivery is coalesced.
+   */
+  _batchPendingMessages = null;
+  // --- PAUSE/RESUME lock tracking (C0) ---
+  /**
+   * Set of active pause locks held against this node. Every `[PAUSE, lockId]`
+   * adds its `lockId` to the set; every `[RESUME, lockId]` removes it.
+   * `_paused` is a derived quantity: `_pauseLocks.size > 0`. Multi-pauser
+   * correctness — one controller releasing its lock does NOT resume the
+   * node while another controller still holds its lock.
+   */
+  _pauseLocks = null;
+  /**
+   * Buffered DATA messages held while paused. Only populated when
+   * `_pausable === "resumeAll"` (bufferAll mode). On final lock release
+   * the buffer is replayed through the node's outgoing pipeline in the
+   * order received. Non-bufferAll pause mode drops DATA on the floor
+   * (upstream is expected to honor PAUSE by suppressing production).
+   */
+  _pauseBuffer = null;
+  // --- Options (frozen at construction) ---
+  _fn;
+  _equals;
+  _resubscribable;
+  _resetOnTeardown;
+  _autoComplete;
+  _autoError;
+  _pausable;
+  _guard;
+  _hashFn;
+  _versioning;
+  /**
+   * Explicit versioning level, tracked separately from `_versioning` so
+   * monotonicity checks and future v2/v3 extensions don't rely on the
+   * fragile `"cid" in _versioning` shape discriminator. `undefined` means
+   * the node has no versioning attached; `0` / `1` / future levels name
+   * the tier. Mutated in lockstep with `_versioning` by the constructor
+   * and by `_applyVersioning`.
+   */
+  _versioningLevel;
+  // --- ABAC ---
+  _lastMutation;
+  /**
+   * @internal Per-node inspector hooks for `Graph.observe(path,
+   * { causal, derived })`. Fires in `_onDepMessage` and `_execFn`.
+   * Attached via `_setInspectorHook` (returns a disposer). Multiple
+   * observers can attach simultaneously — all registered hooks fire for
+   * every event.
+   */
+  _inspectorHooks;
+  // --- Actions (built once in the constructor) ---
+  _actions;
+  constructor(deps, fn, opts) {
+    this._config = opts.config ?? defaultConfig;
+    void this._config.onMessage;
+    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._autoComplete = opts.completeWhenDepsComplete ?? true;
+    this._autoError = opts.errorWhenDepsError ?? true;
+    this._pausable = opts.pausable ?? true;
+    this._guard = opts.guard;
+    this._fn = fn;
+    this._cached = opts.initial !== void 0 ? opts.initial : void 0;
+    this._status = deps.length === 0 && fn == null && this._cached !== void 0 ? "settled" : "sentinel";
+    this._hashFn = opts.versioningHash ?? this._config.defaultHashFn ?? defaultHash;
+    const versioningLevel = opts.versioning ?? this._config.defaultVersioning;
+    this._versioningLevel = versioningLevel;
+    this._versioning = versioningLevel != null ? createVersioning(versioningLevel, this._cached === void 0 ? void 0 : this._cached, {
+      id: opts.versioningId,
+      hash: this._hashFn
+    }) : void 0;
+    this._deps = deps.map(createDepRecord);
+    const meta = {};
+    for (const [k, v] of Object.entries(opts.meta ?? {})) {
+      const metaOpts = {
+        initial: v,
+        name: `${opts.name ?? "node"}:meta:${k}`,
+        describeKind: "state",
+        config: this._config
+      };
+      if (opts.guard != null) metaOpts.guard = opts.guard;
+      meta[k] = new _NodeImpl([], void 0, metaOpts);
+    }
+    Object.freeze(meta);
+    this.meta = meta;
+    this._hasMeta = Object.keys(meta).length > 0;
+    const self = this;
+    this._actions = {
+      emit(value) {
+        self._emit([[DATA, value]]);
+      },
+      down(messageOrMessages) {
+        self._emit(normalizeMessages(messageOrMessages));
+      },
+      up(messageOrMessages) {
+        self._emitUp(normalizeMessages(messageOrMessages));
+      }
+    };
+    this.down = this.down.bind(this);
+    this.up = this.up.bind(this);
+  }
+  // --- Derived state ---
+  get _isTerminal() {
+    return this._status === "completed" || this._status === "errored";
+  }
+  // --- Public getters ---
+  get name() {
+    return this._optsName;
+  }
+  get status() {
+    return this._status;
+  }
+  get cache() {
+    return this._cached === void 0 ? void 0 : this._cached;
+  }
+  get lastMutation() {
+    return this._lastMutation;
+  }
+  get v() {
+    return this._versioning;
+  }
+  hasGuard() {
+    return this._guard != null;
+  }
+  /**
+   * @internal Retroactively attach (or upgrade) versioning state on this
+   * node. Intended for `Graph.setVersioning(level)` bulk application and
+   * for rare cases where a specific node needs to be bumped to a higher
+   * level (e.g., `v0 → v1`) after construction.
+   *
+   * **Safety:** the mutation is rejected mid-wave. Specifically,
+   * throws if the node is currently executing its fn (`_isExecutingFn`).
+   * Callers at quiescent points — before the first sink subscribes, or
+   * after all sinks unsubscribe, or between external `down()` / `emit()`
+   * invocations — are safe. The re-entrance window that motivated §10.6.4
+   * removal was the "transition `_versioning` from `undefined` to a fresh
+   * object mid-`_updateState`" case; that path is now guarded.
+   *
+   * **Monotonicity:** levels can only go up. Downgrade (e.g., `v1 → v0`)
+   * is a no-op — once a node carries higher-level metadata, dropping it
+   * mid-graph would tear the linked-history invariant for v1 and above.
+   *
+   * **Linked-history boundary (D1, 2026-04-13):** upgrading v0 → v1
+   * produces a **fresh history root**. The new v1 state has `cid =
+   * hash(currentCachedValue)` and `prev = null`, not a synthetic `prev`
+   * anchored to any previous v0 value. The v0 monotonic `version` counter
+   * is preserved across the upgrade, but the linked-cid chain (spec §7)
+   * starts fresh at the upgrade point. Downstream audit tools that walk
+   * `v.cid.prev` backwards through time will see a `null` boundary at
+   * the upgrade — **this is intentional**: v0 had no cid to link to, and
+   * fabricating one would lie about the hash. Callers that require an
+   * unbroken cid chain from birth must attach versioning at construction
+   * via `opts.versioning` or `config.defaultVersioning`, not retroactively.
+   *
+   * @param level - New minimum versioning level.
+   * @param opts - Optional id / hash overrides; applied only if the
+   *   node currently has no versioning state.
+   */
+  _applyVersioning(level, opts) {
+    if (this._isExecutingFn) {
+      throw new Error(
+        `Node "${this.name}": _applyVersioning cannot run mid-fn \u2014 call it outside of \`_execFn\` (typically at graph setup time before the first subscribe).`
+      );
+    }
+    const currentLevel = this._versioningLevel;
+    if (currentLevel != null && level <= currentLevel) {
+      return;
+    }
+    const hash = opts?.hash ?? this._hashFn;
+    if (hash !== this._hashFn) this._hashFn = hash;
+    const initialValue = this._cached === void 0 ? void 0 : this._cached;
+    const current = this._versioning;
+    const preservedId = current?.id ?? opts?.id;
+    const preservedVersion = current?.version ?? 0;
+    const fresh = createVersioning(level, initialValue, {
+      id: preservedId,
+      hash
+    });
+    fresh.version = preservedVersion;
+    this._versioning = fresh;
+    this._versioningLevel = level;
+  }
+  /**
+   * @internal Attach an inspector hook. Returns a disposer that removes
+   * the hook. Used by `Graph.observe(path, { causal, derived })` to build
+   * causal traces. Multiple hooks may be attached concurrently — all fire
+   * for every event in registration order. Passing `undefined` is a no-op
+   * and returns a no-op disposer.
+   */
+  _setInspectorHook(hook) {
+    if (hook == null) return () => {
+    };
+    if (this._inspectorHooks == null) this._inspectorHooks = /* @__PURE__ */ new Set();
+    this._inspectorHooks.add(hook);
+    return () => {
+      this._inspectorHooks?.delete(hook);
+      if (this._inspectorHooks?.size === 0) this._inspectorHooks = void 0;
+    };
+  }
+  allowsObserve(actor) {
+    if (this._guard == null) return true;
+    return this._guard(normalizeActor(actor), "observe");
+  }
+  // --- Guard helper ---
+  _checkGuard(options) {
+    if (options?.internal || this._guard == null) return;
+    const actor = normalizeActor(options?.actor);
+    const action = options?.delivery === "signal" ? "signal" : "write";
+    if (!this._guard(actor, action)) {
+      throw new GuardDenied({ actor, action, nodeName: this.name });
+    }
+    this._lastMutation = { actor, timestamp_ns: wallClockNs() };
+  }
+  // --- Public transport ---
+  down(messageOrMessages, options) {
+    const messages = normalizeMessages(messageOrMessages);
+    if (messages.length === 0) return;
+    this._checkGuard(options);
+    this._emit(messages);
+  }
+  emit(value, options) {
+    this._checkGuard(options);
+    this._emit([[DATA, value]]);
+  }
+  up(messageOrMessages, options) {
+    if (this._deps.length === 0) return;
+    const messages = normalizeMessages(messageOrMessages);
+    if (messages.length === 0) return;
+    this._checkGuard(options);
+    const forwardOpts = options ?? { internal: true };
+    this._validateUpTiers(messages);
+    for (const d of this._deps) {
+      d.node.up?.(messages, forwardOpts);
+    }
+  }
+  /**
+   * @internal Internal up-path used by `actions.up(...)` from inside fn.
+   * Same tier validation as public `up`, but bypasses the guard check
+   * since the fn context is already inside an authorized operation.
+   */
+  _emitUp(messages) {
+    if (this._deps.length === 0) return;
+    if (messages.length === 0) return;
+    this._validateUpTiers(messages);
+    for (const d of this._deps) {
+      d.node.up?.(messages, { internal: true });
+    }
+  }
+  /**
+   * @internal Enforce spec §1.2 — up-direction messages are restricted to
+   * tier 0–2 and tier 5 (START, DIRTY, INVALIDATE, PAUSE, RESUME,
+   * TEARDOWN). Tier 3 (DATA/RESOLVED) and tier 4 (COMPLETE/ERROR) are
+   * downstream-only. Emitting tier-3/4 via `up` would bypass equals
+   * substitution and cache advance entirely and is a protocol bug.
+   */
+  _validateUpTiers(messages) {
+    const tierOf = this._config.tierOf;
+    for (const m of messages) {
+      const tier = tierOf(m[0]);
+      if (tier === 3 || tier === 4) {
+        throw new Error(
+          `Node "${this.name}": tier-${tier} messages cannot flow up \u2014 DATA/RESOLVED/COMPLETE/ERROR are downstream-only. Use \`down(...)\` for value delivery; \`up(...)\` is for control signals (DIRTY, INVALIDATE, PAUSE, RESUME, TEARDOWN).`
+        );
+      }
+    }
+  }
+  subscribe(sink, actor) {
+    if (actor != null && this._guard != null) {
+      const a = normalizeActor(actor);
+      if (!this._guard(a, "observe")) {
+        throw new GuardDenied({ actor: a, action: "observe", nodeName: this.name });
+      }
+    }
+    const wasTerminal = this._isTerminal;
+    const afterTerminalReset = wasTerminal && this._resubscribable;
+    if (afterTerminalReset) {
+      this._cached = void 0;
+      this._status = "sentinel";
+      this._store = {};
+      this._hasCalledFnOnce = false;
+      this._waveHasNewData = false;
+      this._hasNewTerminal = false;
+      this._paused = false;
+      this._pendingWave = false;
+      this._pendingRerun = false;
+      this._isExecutingFn = false;
+      this._rerunDepth = 0;
+      this._dirtyDepCount = 0;
+      this._pauseLocks = null;
+      this._pauseBuffer = null;
+      for (const d of this._deps) resetDepRecord(d);
+    }
+    this._sinkCount += 1;
+    let subCleanup;
+    try {
+      subCleanup = this._config.onSubscribe(
+        this,
+        sink,
+        { sinkCount: this._sinkCount, afterTerminalReset },
+        this._actions
+      );
+    } catch (err) {
+      this._sinkCount -= 1;
+      throw err;
+    }
+    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);
+    }
+    const isTerminalNow = this._isTerminal;
+    if (this._sinkCount === 1 && !isTerminalNow) {
+      try {
+        this._activate();
+      } catch (err) {
+        this._sinkCount -= 1;
+        this._removeSink(sink);
+        if (this._sinkCount === 0) this._status = "sentinel";
+        if (typeof subCleanup === "function") {
+          try {
+            subCleanup();
+          } catch {
+          }
+        }
+        throw err;
+      }
+    }
+    if (this._status === "sentinel" && this._cached === void 0) {
+      this._status = "pending";
+    }
+    let removed = false;
+    return () => {
+      if (removed) return;
+      removed = true;
+      this._sinkCount -= 1;
+      this._removeSink(sink);
+      if (typeof subCleanup === "function") subCleanup();
+      if (this._sinks == null) this._deactivate();
+    };
+  }
+  _removeSink(sink) {
+    if (this._sinks === sink) {
+      this._sinks = null;
+    } else if (this._sinks != null && typeof this._sinks !== "function") {
+      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;
+      }
+    }
+  }
+  // --- Lifecycle ---
+  /**
+   * @internal First-sink activation. For a producer (no deps + fn),
+   * invokes fn once. For a compute node (has deps), subscribes to every
+   * dep with the pre-set-dirty trick so the first-run gate waits for
+   * every dep to settle at least once.
+   */
+  _activate() {
+    if (this._deps.length === 0) {
+      if (this._fn) this._execFn();
+      return;
+    }
+    this._dirtyDepCount = 0;
+    const initialLen = this._deps.length;
+    let subscribedCount = 0;
+    try {
+      for (let i = 0; i < initialLen; i++) {
+        const depIdx = i;
+        const dep = this._deps[i];
+        dep.unsub = noopUnsub;
+        dep.unsub = dep.node.subscribe((msgs) => {
+          if (dep.unsub === null) return;
+          const tierOf = this._config.tierOf;
+          let sawSettlement = false;
+          for (const m of msgs) {
+            if (tierOf(m[0]) >= 3) sawSettlement = true;
+            this._config.onMessage(
+              this,
+              m,
+              { direction: "down-in", depIndex: depIdx },
+              this._actions
+            );
+          }
+          if (sawSettlement) this._maybeRunFnOnSettlement();
+        });
+        subscribedCount++;
+      }
+    } catch (err) {
+      this._deps[subscribedCount].unsub = null;
+      for (let j = 0; j < subscribedCount; j++) {
+        const d = this._deps[j];
+        if (d.unsub != null) {
+          const u = d.unsub;
+          d.unsub = null;
+          try {
+            u();
+          } catch {
+          }
+          resetDepRecord(d);
+        }
+      }
+      this._dirtyDepCount = 0;
+      throw err;
+    }
+  }
+  /**
+   * @internal Append a dep post-construction. Used by `autoTrackNode`
+   * (runtime dep discovery) and `Graph.connect()` (post-construction
+   * wiring). Subscribes immediately — if DATA arrives synchronously
+   * during subscribe and fn is currently executing, the re-run is
+   * deferred via `_pendingRerun` flag (see `_execFn` guard).
+   *
+   * **Dedup:** idempotent on duplicate `depNode` — if `depNode` is
+   * already in `_deps`, returns the existing index without mutating
+   * state. Callers can safely invoke `_addDep` without their own
+   * "already added" check. `autoTrackNode` still keeps a `depIndexMap`
+   * as a fast-path lookup for known deps (returning cached `data[idx]`
+   * without calling `_addDep` at all); this internal dedup is the
+   * backstop for any caller that doesn't track its own dep set.
+   *
+   * @returns The index of the new dep in `_deps`, or the existing index
+   *   if the dep was already present.
+   */
+  _addDep(depNode) {
+    for (let i = 0; i < this._deps.length; i++) {
+      if (this._deps[i].node === depNode) return i;
+    }
+    const depIdx = this._deps.length;
+    const record = createDepRecord(depNode);
+    this._deps.push(record);
+    if (this._sinks == null) return depIdx;
+    record.dirty = true;
+    this._dirtyDepCount++;
+    if (this._status !== "dirty") this._emit(DIRTY_ONLY_BATCH);
+    record.unsub = noopUnsub;
+    try {
+      record.unsub = depNode.subscribe((msgs) => {
+        if (record.unsub === null) return;
+        const tierOf = this._config.tierOf;
+        let sawSettlement = false;
+        for (const m of msgs) {
+          if (tierOf(m[0]) >= 3) sawSettlement = true;
+          this._config.onMessage(
+            this,
+            m,
+            { direction: "down-in", depIndex: depIdx },
+            this._actions
+          );
+        }
+        if (sawSettlement) this._maybeRunFnOnSettlement();
+      });
+    } catch (err) {
+      record.unsub = null;
+      this._deps.pop();
+      this._dirtyDepCount--;
+      throw err;
+    }
+    return depIdx;
+  }
+  /**
+   * @internal Unsubscribes from deps, fires fn cleanup (both shapes),
+   * clears wave/store state, and (for compute nodes) drops `_cached` per
+   * the ROM/RAM rule. Idempotent: second call is a no-op.
+   *
+   * @param skipStatusUpdate — When `true`, the caller takes responsibility
+   *   for setting `_status` after deactivation (e.g. TEARDOWN always sets
+   *   `"sentinel"` unconditionally). When `false` (default), deactivation
+   *   applies the ROM rule: compute nodes → `"sentinel"`, state nodes
+   *   preserve their current status.
+   */
+  _deactivate(skipStatusUpdate = false) {
+    const cleanup = this._cleanup;
+    this._cleanup = void 0;
+    if (typeof cleanup === "function") {
+      try {
+        cleanup();
+      } catch (err) {
+        this._emit([[ERROR, this._wrapFnError("cleanup threw", err)]]);
+      }
+    } else if (cleanup != null && typeof cleanup.deactivation === "function") {
+      try {
+        cleanup.deactivation();
+      } catch (err) {
+        this._emit([[ERROR, this._wrapFnError("cleanup.deactivation threw", err)]]);
+      }
+    }
+    for (const d of this._deps) {
+      if (d.unsub != null) {
+        const u = d.unsub;
+        d.unsub = null;
+        try {
+          u();
+        } catch {
+        }
+      }
+      resetDepRecord(d);
+    }
+    this._waveHasNewData = false;
+    this._hasNewTerminal = false;
+    this._hasCalledFnOnce = false;
+    this._paused = false;
+    this._pendingWave = false;
+    this._pendingRerun = false;
+    this._rerunDepth = 0;
+    this._store = {};
+    this._dirtyDepCount = 0;
+    this._pauseLocks = null;
+    this._pauseBuffer = null;
+    if (this._fn != null) {
+      this._cached = void 0;
+    }
+    if (!skipStatusUpdate) {
+      if (this._fn != null || this._deps.length > 0) {
+        if (!this._isTerminal || this._resubscribable) {
+          this._status = "sentinel";
+        }
+      }
+    }
+  }
+  // --- Dep message dispatch (§3.5 singleton default) ---
+  /**
+   * @internal Default per-tier dispatch for incoming dep messages. Called
+   * by `defaultOnMessage`. Updates the DepRecord, triggers wave
+   * completion, and forwards passthrough traffic.
+   */
+  _onDepMessage(depIndex, msg) {
+    const dep = this._deps[depIndex];
+    const t = msg[0];
+    if (this._inspectorHooks != null) {
+      const ev = { kind: "dep_message", depIndex, message: msg };
+      for (const hook of this._inspectorHooks) hook(ev);
+    }
+    if (t === START) return;
+    if (t === DIRTY) {
+      this._depDirtied(dep);
+      return;
+    }
+    if (t === INVALIDATE) {
+      this._depInvalidated(dep);
+      this._emit(INVALIDATE_ONLY_BATCH);
+      return;
+    }
+    if (t === PAUSE || t === RESUME) {
+      this._emit([msg]);
+      return;
+    }
+    if (t === TEARDOWN) {
+      this._emit(TEARDOWN_ONLY_BATCH);
+      return;
+    }
+    if (t === DATA) {
+      this._depSettledAsData(dep, msg[1]);
+    } else if (t === RESOLVED) {
+      this._depSettledAsResolved(dep);
+    } else if (t === COMPLETE) {
+      this._depSettledAsTerminal(dep, true);
+    } else if (t === ERROR) {
+      this._depSettledAsTerminal(dep, msg[1]);
+    } else {
+      this._emit([msg]);
+      return;
+    }
+    if (!this._fn) {
+      if (t === DATA || t === RESOLVED) {
+        this._emit([msg]);
+      }
+      if (t === COMPLETE || t === ERROR) {
+        this._maybeAutoTerminalAfterWave();
+      }
+      return;
+    }
+  }
+  // --- Centralized dep-state transitions (A3 settlement counters) ---
+  //
+  // Every mutation to `DepRecord.dirty` / `DepRecord.prevData` /
+  // `DepRecord.terminal` must go through one of these helpers so the
+  // `_dirtyDepCount` and `_sentinelDepCount` counters stay in sync with
+  // the per-record flags. `_maybeRunFnOnSettlement` reads the counters
+  // and never re-scans the `_deps` array.
+  /**
+   * Called when a dep transitions `dirty: false → true` (either from an
+   * incoming DIRTY, or pre-set during `_activate` / `_addDep` /
+   * `_depInvalidated`). No-op if the dep is already dirty. Fires the
+   * downstream DIRTY emit if we're the first to dirty this wave.
+   */
+  _depDirtied(dep) {
+    if (dep.dirty) return;
+    dep.dirty = true;
+    dep.involvedThisWave = true;
+    this._dirtyDepCount++;
+    if (this._status !== "dirty") {
+      this._emit(DIRTY_ONLY_BATCH);
+    }
+  }
+  /**
+   * Called when a dep delivers new DATA: clears dirty, stores the payload,
+   * marks wave-has-data, and — if this is the dep's first DATA — clears
+   * its sentinel slot so the first-run gate can open.
+   */
+  _depSettledAsData(dep, value) {
+    if (dep.dirty) {
+      dep.dirty = false;
+      this._dirtyDepCount--;
+    }
+    dep.involvedThisWave = true;
+    dep.dataBatch.push(value);
+    this._waveHasNewData = true;
+  }
+  /**
+   * Called when a dep emits RESOLVED (wave settled, value unchanged).
+   * Clears dirty; does NOT touch `prevData` / `terminal` / sentinel
+   * count — sentinel only exits on first DATA or terminal, not RESOLVED.
+   */
+  _depSettledAsResolved(dep) {
+    if (dep.dirty) {
+      dep.dirty = false;
+      this._dirtyDepCount--;
+    }
+  }
+  /**
+   * Called when a dep delivers COMPLETE (`terminal = true`) or ERROR
+   * (`terminal = errorPayload`). Clears dirty, stores the terminal, and
+   * — if the dep had never contributed a DATA yet — leaves sentinel
+   * since the gate treats "terminated without data" as gate-open too.
+   */
+  _depSettledAsTerminal(dep, terminal) {
+    if (dep.dirty) {
+      dep.dirty = false;
+      this._dirtyDepCount--;
+    }
+    dep.terminal = terminal;
+    dep.involvedThisWave = true;
+    this._hasNewTerminal = true;
+  }
+  /**
+   * Called when a dep emits INVALIDATE: clears prevData, terminal, and
+   * dataBatch. The dep is now back in the "never delivered a real value"
+   * state — `prevData === undefined` so the sentinel check in fn will fire.
+   */
+  _depInvalidated(dep) {
+    dep.prevData = void 0;
+    dep.terminal = void 0;
+    dep.dataBatch.length = 0;
+    if (!dep.dirty) {
+      dep.dirty = true;
+      dep.involvedThisWave = true;
+      this._dirtyDepCount++;
+    } else {
+      dep.involvedThisWave = false;
+    }
+  }
+  _maybeRunFnOnSettlement() {
+    if (this._isTerminal && !this._resubscribable) return;
+    if (this._dirtyDepCount > 0) return;
+    if (this._paused) {
+      this._pendingWave = true;
+      return;
+    }
+    if (!this._waveHasNewData && !this._hasNewTerminal && this._hasCalledFnOnce) {
+      this._clearWaveFlags();
+      this._emit(RESOLVED_ONLY_BATCH);
+      this._maybeAutoTerminalAfterWave();
+      return;
+    }
+    if (this._fn) this._execFn();
+    this._maybeAutoTerminalAfterWave();
+  }
+  _maybeAutoTerminalAfterWave() {
+    if (this._deps.length === 0) return;
+    if (this._isTerminal) return;
+    const erroredDep = this._deps.find((d) => d.terminal !== void 0 && d.terminal !== true);
+    if (erroredDep != null) {
+      if (this._autoError) {
+        this._emit([[ERROR, erroredDep.terminal]]);
+      }
+      return;
+    }
+    if (this._autoComplete && this._deps.every((d) => d.terminal !== void 0)) {
+      this._emit(COMPLETE_ONLY_BATCH);
+    }
+  }
+  // --- Fn execution ---
+  /**
+   * @internal Runs the node fn once. Default cleanup (function form) fires
+   * before the new run; `{ deactivation }` cleanup survives.
+   */
+  _execFn() {
+    if (!this._fn) return;
+    if (this._isTerminal && !this._resubscribable) return;
+    if (this._isExecutingFn) {
+      this._pendingRerun = true;
+      return;
+    }
+    const prevCleanup = this._cleanup;
+    if (typeof prevCleanup === "function") {
+      this._cleanup = void 0;
+      try {
+        prevCleanup();
+      } catch (err) {
+        this._emit([[ERROR, this._wrapFnError("cleanup threw", err)]]);
+        return;
+      }
+    }
+    const batchData = this._deps.map(
+      (d) => !d.involvedThisWave ? void 0 : d.dataBatch.length > 0 ? [...d.dataBatch] : []
+    );
+    const prevData = this._deps.map((d) => d.prevData);
+    for (let i = 0; i < this._deps.length; i++) {
+      const batch2 = batchData[i];
+      if (batch2 != null && batch2.length > 0) {
+        this._deps[i].prevData = batch2[batch2.length - 1];
+      }
+    }
+    const terminalDeps = this._deps.map((d) => d.terminal);
+    const ctx = { prevData, terminalDeps, store: this._store };
+    this._hasCalledFnOnce = true;
+    this._clearWaveFlags();
+    if (this._inspectorHooks != null) {
+      const ev = { kind: "run", batchData, prevData };
+      for (const hook of this._inspectorHooks) hook(ev);
+    }
+    this._isExecutingFn = true;
+    try {
+      const result = this._fn(batchData, this._actions, ctx);
+      if (typeof result === "function") {
+        this._cleanup = result;
+      } else if (result != null && typeof result === "object" && typeof result.deactivation === "function") {
+        this._cleanup = result;
+      }
+    } catch (err) {
+      this._emit([[ERROR, this._wrapFnError("fn threw", err)]]);
+    } finally {
+      this._isExecutingFn = false;
+      if (this._pendingRerun) {
+        this._pendingRerun = false;
+        this._rerunDepth += 1;
+        if (this._rerunDepth > MAX_RERUN_DEPTH) {
+          this._rerunDepth = 0;
+          this._emit([
+            [
+              ERROR,
+              new Error(
+                `Node "${this.name}": _pendingRerun depth exceeded ${MAX_RERUN_DEPTH} \u2014 likely a reactive cycle`
+              )
+            ]
+          ]);
+        } else {
+          this._maybeRunFnOnSettlement();
+        }
+      } else {
+        this._rerunDepth = 0;
+      }
+      this._clearWaveFlags();
+    }
+  }
+  _clearWaveFlags() {
+    this._waveHasNewData = false;
+    this._hasNewTerminal = false;
+    for (const d of this._deps) {
+      d.involvedThisWave = false;
+      d.dataBatch.length = 0;
+    }
+  }
+  _wrapFnError(label, err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return new Error(`Node "${this.name}": ${label}: ${msg}`, { cause: err });
+  }
+  // --- Framing (tier sort + synthetic DIRTY prefix) ---
+  /**
+   * @internal Stable tier sort + synthetic DIRTY prefix for an outgoing
+   * batch. Fast path: already-monotone single-tier batches (the common
+   * case from interned singletons like `DIRTY_ONLY_BATCH`) return the
+   * input unchanged. General path: decorate-sort-undecorate into a new
+   * array, then prepend `[DIRTY]` after any tier-0 START entries when
+   * a tier-3 payload is present and the node isn't already dirty.
+   *
+   * Single source of truth for the spec §1.3.1 framing invariant. Every
+   * outgoing path hits `_frameBatch` exactly once via `_emit`.
+   */
+  _frameBatch(messages) {
+    const tierOf = this._config.tierOf;
+    if (messages.length === 1) {
+      const t = tierOf(messages[0][0]);
+      if (t === 3 && this._status !== "dirty") {
+        return [DIRTY_MSG, messages[0]];
+      }
+      return messages;
+    }
+    let monotone = true;
+    let hasTier3 = false;
+    let hasDirty = false;
+    let prevTier = -1;
+    for (const m of messages) {
+      const tier = tierOf(m[0]);
+      if (tier < prevTier) monotone = false;
+      if (tier === 3) hasTier3 = true;
+      if (m[0] === DIRTY) hasDirty = true;
+      prevTier = tier;
+    }
+    let sorted = messages;
+    if (!monotone) {
+      const indexed = messages.map((m, i) => ({ m, i, tier: tierOf(m[0]) }));
+      indexed.sort((a, b) => a.tier - b.tier || a.i - b.i);
+      sorted = indexed.map((x) => x.m);
+    }
+    if (hasTier3 && !hasDirty && this._status !== "dirty") {
+      let insertAt = 0;
+      while (insertAt < sorted.length && tierOf(sorted[insertAt][0]) === 0) insertAt++;
+      if (insertAt === 0) return [DIRTY_MSG, ...sorted];
+      return [...sorted.slice(0, insertAt), DIRTY_MSG, ...sorted.slice(insertAt)];
+    }
+    return sorted;
+  }
+  // --- Emit pipeline ---
+  /**
+   * @internal The unified dispatch waist — one call = one wave.
+   *
+   * Pipeline stages, in order:
+   *
+   *   1. Early-return on empty batch.
+   *   2. Terminal filter — post-COMPLETE/ERROR only TEARDOWN/INVALIDATE
+   *      still propagate so graph teardown and cache-clear still work.
+   *   3. Tier sort (stable) — the batch can be in any order when it
+   *      arrives; the walker downstream (`downWithBatch`) assumes
+   *      ascending tier monotone, and so does `_updateState`'s tier-3
+   *      slice walk. This is the single source of truth for ordering.
+   *   4. Synthetic DIRTY prefix — if a tier-3 payload is present, no
+   *      DIRTY is already in the batch, and the node isn't already in
+   *      `"dirty"` status, prepend `[DIRTY]` after any tier-0 START
+   *      entries. Guarantees spec §1.3.1 (DIRTY precedes DATA within
+   *      the same batch) uniformly across every entry point.
+   *   5. PAUSE/RESUME lock bookkeeping (C0) — update `_pauseLocks`,
+   *      derive `_paused`, filter unknown-lockId RESUME, replay
+   *      bufferAll buffer on final lock release.
+   *   6. Meta TEARDOWN fan-out — notify meta children before
+   *      `_updateState`'s TEARDOWN branch calls `_deactivate`. Hoisted
+   *      out of the walk to keep `_updateState` re-entrance-free.
+   *   7. `_updateState` — walk the batch in tier order, advancing
+   *      `_cached` / `_status` / `_versioning` and running equals
+   *      substitution on tier-3 DATA (§3.5.1). Returns
+   *      `{finalMessages, equalsError?}`.
+   *   8. `downWithBatch` dispatch (or bufferAll capture if paused with
+   *      `pausable: "resumeAll"`).
+   *   9. Recursive ERROR emission if equals threw mid-walk.
+   *
+   * `node.down` / `node.emit` / `actions.down` / `actions.emit` all
+   * converge here — the unified `_emit` waist (spec §1.3.1).
+   */
+  _emit(messages) {
+    if (messages.length === 0) return;
+    let deliverable = messages;
+    const terminal = this._isTerminal;
+    if (terminal && !this._resubscribable) {
+      const pass = messages.filter((m) => m[0] === TEARDOWN || m[0] === INVALIDATE);
+      if (pass.length === 0) return;
+      deliverable = pass;
+    }
+    deliverable = this._frameBatch(deliverable);
+    let filtered = null;
+    for (let i = 0; i < deliverable.length; i++) {
+      const m = deliverable[i];
+      const t = m[0];
+      if (t !== PAUSE && t !== RESUME) {
+        if (filtered != null) filtered.push(m);
+        continue;
+      }
+      if (m.length < 2) {
+        throw new Error(
+          `Node "${this.name}": [[${t === PAUSE ? "PAUSE" : "RESUME"}]] must carry a lockId payload \u2014 bare PAUSE/RESUME is a protocol violation (C0 rule). Use \`[[PAUSE, lockId]]\` / \`[[RESUME, lockId]]\`.`
+        );
+      }
+      let forward = true;
+      if (this._pausable !== false) {
+        const lockId = m[1];
+        if (t === PAUSE) {
+          if (this._pauseLocks == null) this._pauseLocks = /* @__PURE__ */ new Set();
+          this._pauseLocks.add(lockId);
+          this._paused = true;
+          if (this._pausable === "resumeAll" && this._pauseBuffer == null) {
+            this._pauseBuffer = [];
+          }
+        } else {
+          if (this._pauseLocks == null || !this._pauseLocks.has(lockId)) {
+            forward = false;
+          } else {
+            this._pauseLocks.delete(lockId);
+            if (this._pauseLocks.size === 0) {
+              this._paused = false;
+              if (this._pauseBuffer != null && this._pauseBuffer.length > 0) {
+                const drain = this._pauseBuffer;
+                this._pauseBuffer = [];
+                this._emit(drain);
+              }
+              if (this._pendingWave) {
+                this._pendingWave = false;
+                this._maybeRunFnOnSettlement();
+              }
+            }
+          }
+        }
+      }
+      if (!forward) {
+        if (filtered == null) filtered = deliverable.slice(0, i);
+      } else if (filtered != null) {
+        filtered.push(m);
+      }
+    }
+    if (filtered != null) {
+      if (filtered.length === 0) return;
+      deliverable = filtered;
+    }
+    if (this._hasMeta && deliverable.some((m) => m[0] === TEARDOWN)) {
+      for (const k of Object.keys(this.meta)) {
+        try {
+          this.meta[k]._emit(TEARDOWN_ONLY_BATCH);
+        } catch {
+        }
+      }
+    }
+    const { finalMessages, equalsError } = this._updateState(deliverable);
+    if (finalMessages.length > 0 && this._config.inspectorEnabled) {
+      const inspector = this._config.globalInspector;
+      if (inspector != null) {
+        try {
+          inspector({ kind: "emit", node: this, messages: finalMessages });
+        } catch {
+        }
+      }
+    }
+    if (finalMessages.length > 0) {
+      if (this._paused && this._pausable === "resumeAll" && this._pauseBuffer != null) {
+        const tierOf = this._config.tierOf;
+        const immediate = [];
+        for (const m of finalMessages) {
+          const tier = tierOf(m[0]);
+          if (tier < 3 || tier === 5) {
+            immediate.push(m);
+          } else {
+            this._pauseBuffer.push(m);
+          }
+        }
+        if (immediate.length > 0) {
+          this._dispatchOrAccumulate(immediate);
+        }
+      } else {
+        this._dispatchOrAccumulate(finalMessages);
+      }
+    }
+    if (equalsError != null) {
+      this._emit([[ERROR, equalsError]]);
+    }
+  }
+  /**
+   * @internal Walk an outgoing (already-framed) batch, updating own
+   * cache / status / versioning and running equals substitution on
+   * every tier-3 DATA (§3.5.1). Framing — tier sort and synthetic
+   * DIRTY prefix — has already happened upstream in `_frameBatch`.
+   * This walk trusts the input is in monotone tier order and that the
+   * spec §1.3.1 DIRTY/RESOLVED precedence invariant is already
+   * satisfied by the frame.
+   *
+   * Equals substitution: every DATA payload is compared against the
+   * live `_cached`; when equal, the tuple is rewritten to `[RESOLVED]`
+   * in a per-call copy and cache is not re-advanced. `.cache` remains
+   * coherent with "the last DATA payload this node actually sent
+   * downstream".
+   *
+   * Returns `{ finalMessages, equalsError? }`:
+   * - `finalMessages` — the array to deliver to sinks (may be
+   *   `messages` unchanged, a rewritten copy with DATA→RESOLVED
+   *   substitutions, or a truncated prefix when equals throws mid-walk).
+   * - `equalsError` — present only when the configured `equals` function
+   *   threw on some DATA message. `_emit` delivers the prefix first,
+   *   then emits a fresh ERROR batch via a recursive `_emit` call so
+   *   subscribers observe `[...walked_prefix, ERROR]` in order.
+   */
+  _updateState(messages) {
+    const tierOf = this._config.tierOf;
+    let rewritten;
+    let equalsError;
+    let abortedAt = -1;
+    let dataCount = 0;
+    for (const m of messages) {
+      if (tierOf(m[0]) === 3) dataCount++;
+    }
+    const checkEquals = dataCount <= 1;
+    let lastDataIdx = -1;
+    if (this._versioning != null && dataCount > 1) {
+      for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i][0] === DATA) {
+          lastDataIdx = i;
+          break;
+        }
+      }
+    }
+    for (let i = 0; i < messages.length; i++) {
+      const m = messages[i];
+      const t = m[0];
+      if (t === DATA) {
+        if (m.length >= 2) {
+          let unchanged = false;
+          if (checkEquals && this._cached !== void 0) {
+            try {
+              unchanged = this._equals(this._cached, m[1]);
+            } catch (err) {
+              equalsError = this._wrapFnError("equals threw", err);
+              abortedAt = i;
+              break;
+            }
+          }
+          if (unchanged) {
+            if (rewritten == null) rewritten = messages.slice(0, i);
+            rewritten.push(RESOLVED_MSG);
+            this._status = "resolved";
+            continue;
+          }
+          this._cached = m[1];
+          if (this._versioning != null) {
+            if (lastDataIdx < 0 || i === lastDataIdx) {
+              advanceVersion(this._versioning, m[1], this._hashFn);
+            }
+          }
+        }
+        this._status = "settled";
+        if (rewritten != null) rewritten.push(m);
+      } else {
+        if (rewritten != null) rewritten.push(m);
+        if (t === DIRTY) {
+          this._status = "dirty";
+        } else if (t === RESOLVED) {
+          this._status = "resolved";
+        } else if (t === COMPLETE) {
+          this._status = "completed";
+        } else if (t === ERROR) {
+          this._status = "errored";
+        } else if (t === INVALIDATE) {
+          this._cached = void 0;
+          this._status = "dirty";
+          const c = this._cleanup;
+          if (typeof c === "function") {
+            this._cleanup = void 0;
+            try {
+              c();
+            } catch {
+            }
+          }
+        } else if (t === TEARDOWN) {
+          if (this._resetOnTeardown) this._cached = void 0;
+          this._deactivate(
+            /* skipStatusUpdate */
+            true
+          );
+          this._status = "sentinel";
+        }
+      }
+    }
+    const base = abortedAt >= 0 ? rewritten ?? messages.slice(0, abortedAt) : rewritten ?? messages;
+    return equalsError != null ? { finalMessages: base, equalsError } : { finalMessages: base };
+  }
+  _deliverToSinks = (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);
+  };
+  /**
+   * @internal Dispatch entry point that respects the per-batch emit
+   * accumulator (Bug 2). Inside an explicit `batch()` scope, append to
+   * `_batchPendingMessages` and register a flush hook on first append.
+   * Outside batch — or during a drain (where `flushInProgress` is true
+   * but `batchDepth` is 0) — dispatch synchronously through `downWithBatch`.
+   *
+   * Per-emit state updates (`_frameBatch`, `_updateState`) have already
+   * happened by the time we reach here; only the **downstream delivery**
+   * is coalesced. Cache, version, and status are visible mid-batch on
+   * the emitting node itself.
+   */
+  _dispatchOrAccumulate(messages) {
+    if (isExplicitlyBatching()) {
+      if (this._batchPendingMessages === null) {
+        this._batchPendingMessages = [];
+        registerBatchFlushHook(() => this._flushBatchPending());
+      }
+      for (const m of messages) this._batchPendingMessages.push(m);
+      return;
+    }
+    downWithBatch(this._deliverToSinks, messages, this._config.tierOf);
+  }
+  /**
+   * @internal Flushes the accumulated batch through `downWithBatch` and
+   * clears the pending state. Idempotent — safe to call when pending is
+   * already null or empty (e.g. on a `batch()` throw, where the hook
+   * fires for cleanup but the drainPhase queues are wiped after).
+   *
+   * Critical: the accumulated batch is interleaved per-emit framings like
+   * `[DIRTY, DATA(1), DIRTY, DATA(2)]` — non-monotone tier order. We must
+   * re-frame to sort by tier before handing to `downWithBatch`, which
+   * assumes pre-sorted input. `_frameBatch` also handles the synthetic
+   * DIRTY prepend rule (no-op here — `hasDirty` is true since each
+   * accumulated emit already carries its own DIRTY prefix).
+   */
+  _flushBatchPending() {
+    const pending = this._batchPendingMessages;
+    if (pending === null) return;
+    this._batchPendingMessages = null;
+    if (pending.length === 0) return;
+    const framed = this._frameBatch(pending);
+    downWithBatch(this._deliverToSinks, framed, this._config.tierOf);
+  }
+};
+var isNodeArray = (value) => Array.isArray(value);
+var isNodeOptionsObject = (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 = (isNodeOptionsObject(fnOrOpts) ? fnOrOpts : optsArg) ?? {};
+  } else if (isNodeOptionsObject(depsOrFn)) {
+    opts = depsOrFn;
+  } else {
+    opts = (isNodeOptionsObject(fnOrOpts) ? fnOrOpts : optsArg) ?? {};
+  }
+  return new NodeImpl(deps, fn, opts);
+}
+
+// src/core/sugar.ts
+function sentinelGuard(batchData, ctx, allowPartial) {
+  if (allowPartial) return false;
+  return batchData.some(
+    (batch2, i) => !(batch2 != null && batch2.length > 0) && ctx.prevData[i] === void 0
+  );
+}
+function state(initial, opts) {
+  return node([], { ...opts, initial });
+}
+function producer(fn, opts) {
+  const wrapped = (_data, actions, ctx) => fn(actions, ctx) ?? void 0;
+  return node(wrapped, { describeKind: "producer", ...opts });
+}
+function derived(deps, fn, opts) {
+  const allowPartial = opts?.partial ?? false;
+  const wrapped = (batchData, actions, ctx) => {
+    if (sentinelGuard(batchData, ctx, allowPartial)) {
+      actions.down([[RESOLVED]]);
+      return void 0;
+    }
+    const data = batchData.map(
+      (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+    );
+    actions.emit(fn(data, ctx));
+    return void 0;
+  };
+  return node(deps, wrapped, { describeKind: "derived", ...opts });
+}
+function effect(deps, fn, opts) {
+  const allowPartial = opts?.partial ?? false;
+  const wrapped = (batchData, actions, ctx) => {
+    if (sentinelGuard(batchData, ctx, allowPartial)) {
+      actions.down([[RESOLVED]]);
+      return void 0;
+    }
+    const data = batchData.map(
+      (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+    );
+    return fn(data, actions, ctx) ?? void 0;
+  };
+  return node(deps, wrapped, { describeKind: "effect", ...opts });
+}
+function dynamicNode(allDeps, fn, opts) {
+  const depIndex = /* @__PURE__ */ new Map();
+  allDeps.forEach((d, i) => {
+    depIndex.set(d, i);
+  });
+  return derived(
+    allDeps,
+    // data[i] is already sugar-unwrapped to a scalar by derived()'s wrapper.
+    (data, ctx) => {
+      const track = (dep) => {
+        const i = depIndex.get(dep);
+        if (i == null) {
+          throw new Error(`dynamicNode: untracked dep "${dep.name ?? "<unnamed>"}"`);
+        }
+        return data[i];
+      };
+      return fn(track, ctx);
+    },
+    opts
+  );
+}
+function autoTrackNode(fn, opts) {
+  let implRef;
+  const depIndexMap = /* @__PURE__ */ new Map();
+  const allowPartial = opts?.partial ?? false;
+  const wrappedFn = (batchData, actions, ctx) => {
+    let foundNew = false;
+    const track = (dep) => {
+      const idx = depIndexMap.get(dep);
+      if (idx !== void 0) {
+        if (idx < batchData.length) {
+          const batch2 = batchData[idx];
+          if (batch2 != null && batch2.length > 0) return batch2.at(-1);
+          return ctx.prevData[idx];
+        }
+        return dep.cache;
+      }
+      foundNew = true;
+      const newIdx = implRef._addDep(dep);
+      depIndexMap.set(dep, newIdx);
+      return dep.cache;
+    };
+    if (!allowPartial && depIndexMap.size > 0) {
+      for (const [, idx] of depIndexMap) {
+        if (idx < batchData.length) {
+          const batch2 = batchData[idx];
+          if (!(batch2 != null && batch2.length > 0) && ctx.prevData[idx] === void 0) {
+            actions.down([[RESOLVED]]);
+            return void 0;
+          }
+        }
+      }
+    }
+    try {
+      const result = fn(track, ctx);
+      if (!foundNew) {
+        actions.emit(result);
+        if (ctx.store.__autoTrackLastDiscoveryError != null) {
+          delete ctx.store.__autoTrackLastDiscoveryError;
+        }
+      }
+    } catch (err) {
+      if (!foundNew) throw err;
+      ctx.store.__autoTrackLastDiscoveryError = err;
+    }
+    return void 0;
+  };
+  implRef = new NodeImpl([], wrappedFn, {
+    describeKind: "derived",
+    ...opts
+  });
+  return implRef;
+}
+function pipe(source, ...ops) {
+  let current = source;
+  for (const op of ops) current = op(current);
+  return current;
+}
+
+export {
+  __require,
+  __export,
+  __decoratorStart,
+  __runInitializers,
+  __decorateElement,
+  START,
+  DATA,
+  DIRTY,
+  RESOLVED,
+  INVALIDATE,
+  PAUSE,
+  RESUME,
+  TEARDOWN,
+  COMPLETE,
+  ERROR,
+  DIRTY_MSG,
+  RESOLVED_MSG,
+  INVALIDATE_MSG,
+  START_MSG,
+  COMPLETE_MSG,
+  TEARDOWN_MSG,
+  DIRTY_ONLY_BATCH,
+  RESOLVED_ONLY_BATCH,
+  INVALIDATE_ONLY_BATCH,
+  COMPLETE_ONLY_BATCH,
+  TEARDOWN_ONLY_BATCH,
+  JsonCodec,
+  createDagCborCodec,
+  createDagCborZstdCodec,
+  ENVELOPE_VERSION,
+  encodeEnvelope,
+  decodeEnvelope,
+  registerBuiltinCodecs,
+  replayWAL,
+  DEFAULT_ACTOR,
+  normalizeActor,
+  isBatching,
+  batch,
+  downWithBatch,
+  monotonicNs,
+  wallClockNs,
+  GraphReFlyConfig,
+  registerBuiltins,
+  GuardDenied,
+  policy,
+  policyFromRules,
+  accessHintForGuard,
+  defaultHash,
+  createVersioning,
+  advanceVersion,
+  isV1,
+  defaultConfig,
+  configure,
+  NodeImpl,
+  node,
+  state,
+  producer,
+  derived,
+  effect,
+  dynamicNode,
+  autoTrackNode,
+  pipe
+};
+//# sourceMappingURL=chunk-NZMBRXQV.js.map