@graphrefly/graphrefly 0.1.0

package/dist/chunk-5X3LAO3B.js

@@ -0,0 +1,1571 @@
+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/messages.ts
+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 = [
+  DATA,
+  DIRTY,
+  RESOLVED,
+  INVALIDATE,
+  PAUSE,
+  RESUME,
+  TEARDOWN,
+  COMPLETE,
+  ERROR
+];
+function isKnownMessageType(t) {
+  return knownMessageTypes.includes(t);
+}
+function messageTier(t) {
+  if (t === DIRTY || t === INVALIDATE) return 0;
+  if (t === PAUSE || t === RESUME) return 1;
+  if (t === DATA || t === RESOLVED) return 2;
+  if (t === COMPLETE || t === ERROR) return 3;
+  if (t === TEARDOWN) return 4;
+  return 0;
+}
+function isPhase2Message(msg) {
+  const t = msg[0];
+  return t === DATA || t === RESOLVED;
+}
+function isTerminalMessage(t) {
+  return t === COMPLETE || t === ERROR;
+}
+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;
+  }
+  let firstError;
+  let hasError = false;
+  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) {
+            if (!hasError) {
+              firstError = e;
+              hasError = true;
+            }
+          }
+        }
+      }
+      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) {
+            if (!hasError) {
+              firstError = e;
+              hasError = true;
+            }
+          }
+        }
+      }
+    }
+  } finally {
+    if (ownsFlush) {
+      flushInProgress = false;
+    }
+  }
+  if (hasError) {
+    throw firstError;
+  }
+}
+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 emitWithBatch(emit, messages, phase = 2) {
+  if (messages.length === 0) {
+    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(() => emit(messages));
+      } else {
+        emit(messages);
+      }
+    } else if (isTerminalMessage(t)) {
+      if (isBatching()) {
+        queue.push(() => emit(messages));
+      } else {
+        emit(messages);
+      }
+    } else {
+      emit(messages);
+    }
+    return;
+  }
+  const { immediate, deferred, terminal } = partitionForBatch(messages);
+  if (immediate.length > 0) {
+    emit(immediate);
+  }
+  if (isBatching()) {
+    if (deferred.length > 0) {
+      queue.push(() => emit(deferred));
+    }
+    if (terminal.length > 0) {
+      queue.push(() => emit(terminal));
+    }
+  } else {
+    if (deferred.length > 0) {
+      emit(deferred);
+    }
+    if (terminal.length > 0) {
+      emit(terminal);
+    }
+  }
+}
+
+// src/core/clock.ts
+function monotonicNs() {
+  return Math.trunc(performance.now() * 1e6);
+}
+function wallClockNs() {
+  return Date.now() * 1e6;
+}
+
+// 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
+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.ts
+function createIntBitSet() {
+  let bits = 0;
+  return {
+    set(i) {
+      bits |= 1 << i;
+    },
+    clear(i) {
+      bits &= ~(1 << i);
+    },
+    has(i) {
+      return (bits & 1 << i) !== 0;
+    },
+    covers(other) {
+      return (bits & other._bits()) === other._bits();
+    },
+    any() {
+      return bits !== 0;
+    },
+    reset() {
+      bits = 0;
+    },
+    _bits() {
+      return bits;
+    }
+  };
+}
+function createArrayBitSet(size) {
+  const words = new Uint32Array(Math.ceil(size / 32));
+  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);
+    },
+    _words: words
+  };
+}
+function createBitSet(size) {
+  return size <= 31 ? createIntBitSet() : createArrayBitSet(size);
+}
+var isNodeArray = (value) => Array.isArray(value);
+var isNodeOptions = (value) => typeof value === "object" && value != null && !Array.isArray(value);
+var isCleanupFn = (value) => typeof value === "function";
+var 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;
+};
+var NodeImpl = class {
+  // --- Configuration (set once, never reassigned) ---
+  _optsName;
+  _registryName;
+  /** @internal — read by {@link describeNode} before inference. */
+  _describeKind;
+  meta;
+  _deps;
+  _fn;
+  _opts;
+  _equals;
+  _onMessage;
+  /** @internal — read by {@link describeNode} for `accessHintForGuard`. */
+  _guard;
+  _lastMutation;
+  _hasDeps;
+  _autoComplete;
+  _isSingleDep;
+  // --- Mutable state ---
+  _cached;
+  _status;
+  _terminal = false;
+  _connected = false;
+  _producerStarted = false;
+  _connecting = false;
+  _manualEmitUsed = false;
+  _sinkCount = 0;
+  _singleDepSinkCount = 0;
+  // --- Object/collection state ---
+  _depDirtyMask;
+  _depSettledMask;
+  _depCompleteMask;
+  _allDepsCompleteMask;
+  _lastDepValues;
+  _cleanup;
+  _sinks = null;
+  _singleDepSinks = /* @__PURE__ */ new WeakSet();
+  _upstreamUnsubs = [];
+  _actions;
+  _boundEmitToSinks;
+  _inspectorHook;
+  _versioning;
+  _hashFn;
+  constructor(deps, fn, opts) {
+    this._deps = deps;
+    this._fn = fn;
+    this._opts = opts;
+    this._optsName = opts.name;
+    this._describeKind = opts.describeKind;
+    this._equals = opts.equals ?? Object.is;
+    this._onMessage = opts.onMessage;
+    this._guard = opts.guard;
+    this._hasDeps = deps.length > 0;
+    this._autoComplete = opts.completeWhenDepsComplete ?? true;
+    this._isSingleDep = deps.length === 1 && fn != null;
+    this._cached = opts.initial;
+    this._status = this._hasDeps ? "disconnected" : "settled";
+    this._hashFn = opts.versioningHash ?? defaultHash;
+    this._versioning = opts.versioning != null ? createVersioning(opts.versioning, this._cached, {
+      id: opts.versioningId,
+      hash: this._hashFn
+    }) : void 0;
+    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);
+    const meta = {};
+    for (const [k, v] of Object.entries(opts.meta ?? {})) {
+      meta[k] = node({
+        initial: v,
+        name: `${opts.name ?? "node"}:meta:${k}`,
+        describeKind: "state",
+        ...opts.guard != null ? { guard: opts.guard } : {}
+      });
+    }
+    Object.freeze(meta);
+    this.meta = meta;
+    const self = this;
+    this._actions = {
+      down(messages) {
+        self._manualEmitUsed = true;
+        self._downInternal(messages);
+      },
+      emit(value) {
+        self._manualEmitUsed = true;
+        self._emitAutoValue(value);
+      },
+      up(messages) {
+        self._upInternal(messages);
+      }
+    };
+    this.down = this.down.bind(this);
+    this.up = this.up.bind(this);
+    this._boundEmitToSinks = this._emitToSinks.bind(this);
+  }
+  get name() {
+    return this._registryName ?? this._optsName;
+  }
+  /**
+   * When a node is registered with {@link Graph.add} without an options `name`,
+   * the graph assigns the registry local name for introspection (parity with graphrefly-py).
+   */
+  _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;
+      }
+    };
+  }
+  // --- Public interface (Node<T>) ---
+  get status() {
+    return this._status;
+  }
+  get lastMutation() {
+    return this._lastMutation;
+  }
+  get v() {
+    return this._versioning;
+  }
+  /**
+   * Retroactively apply versioning to a node that was created without it.
+   * No-op if versioning is already enabled.
+   *
+   * Version starts at 0 regardless of prior DATA emissions — it tracks
+   * changes from the moment versioning is enabled, not historical ones.
+   *
+   * @internal — used by {@link Graph.setVersioning}.
+   */
+  _applyVersioning(level, opts) {
+    if (this._versioning != null) return;
+    this._hashFn = opts?.hash ?? this._hashFn;
+    this._versioning = createVersioning(level, 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");
+  }
+  get() {
+    return 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._lastMutation = { actor, timestamp_ns: wallClockNs() };
+    }
+    this._downInternal(messages);
+  }
+  _downInternal(messages) {
+    if (messages.length === 0) return;
+    let lifecycleMessages = messages;
+    let sinkMessages = messages;
+    if (this._terminal && !this._opts.resubscribable) {
+      const terminalPassthrough = messages.filter((m) => m[0] === TEARDOWN || m[0] === INVALIDATE);
+      if (terminalPassthrough.length === 0) return;
+      lifecycleMessages = terminalPassthrough;
+      sinkMessages = terminalPassthrough;
+    }
+    this._handleLocalLifecycle(lifecycleMessages);
+    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) {
+          emitWithBatch(this._boundEmitToSinks, filtered);
+        }
+        return;
+      }
+    }
+    emitWithBatch(this._boundEmitToSinks, sinkMessages);
+  }
+  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._opts.resubscribable) {
+      this._terminal = false;
+      this._status = this._hasDeps ? "disconnected" : "settled";
+      this._opts.onResubscribe?.();
+    }
+    this._sinkCount += 1;
+    if (hints?.singleDep) {
+      this._singleDepSinkCount += 1;
+      this._singleDepSinks.add(sink);
+    }
+    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._hasDeps) {
+      this._connectUpstream();
+    } else if (this._fn) {
+      this._startProducer();
+    }
+    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._disconnectUpstream();
+        this._stopProducer();
+      }
+    };
+  }
+  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._lastMutation = { actor, timestamp_ns: wallClockNs() };
+    }
+    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();
+  }
+  // --- Private methods (prototype, _ prefix) ---
+  _emitToSinks(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);
+    }
+  }
+  _handleLocalLifecycle(messages) {
+    for (const m of messages) {
+      const t = m[0];
+      if (t === DATA) {
+        this._cached = m[1];
+        if (this._versioning != null) {
+          advanceVersion(this._versioning, m[1], this._hashFn);
+        }
+      }
+      if (t === INVALIDATE) {
+        const cleanupFn = this._cleanup;
+        this._cleanup = void 0;
+        cleanupFn?.();
+        this._cached = void 0;
+        this._lastDepValues = void 0;
+      }
+      this._status = statusAfterMessage(this._status, m);
+      if (t === COMPLETE || t === ERROR) {
+        this._terminal = true;
+      }
+      if (t === TEARDOWN) {
+        if (this._opts.resetOnTeardown) {
+          this._cached = void 0;
+        }
+        const teardownCleanup = this._cleanup;
+        this._cleanup = void 0;
+        teardownCleanup?.();
+        try {
+          this._propagateToMeta(t);
+        } finally {
+          this._disconnectUpstream();
+          this._stopProducer();
+        }
+      }
+      if (t !== TEARDOWN && propagatesToMeta(t)) {
+        this._propagateToMeta(t);
+      }
+    }
+  }
+  /** Propagate a signal to all companion meta nodes (best-effort). */
+  _propagateToMeta(t) {
+    for (const metaNode of Object.values(this.meta)) {
+      try {
+        metaNode._downInternal([[t]]);
+      } catch {
+      }
+    }
+  }
+  _canSkipDirty() {
+    return this._sinkCount === 1 && this._singleDepSinkCount === 1;
+  }
+  _emitAutoValue(value) {
+    const wasDirty = this._status === "dirty";
+    const unchanged = this._equals(this._cached, value);
+    if (unchanged) {
+      this._downInternal(wasDirty ? [[RESOLVED]] : [[DIRTY], [RESOLVED]]);
+      return;
+    }
+    this._cached = value;
+    this._downInternal(wasDirty ? [[DATA, value]] : [[DIRTY], [DATA, value]]);
+  }
+  _runFn() {
+    if (!this._fn) return;
+    if (this._terminal && !this._opts.resubscribable) return;
+    if (this._connecting) 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._inspectorHook?.({ kind: "run", depValues });
+      const out = this._fn(depValues, this._actions);
+      if (isCleanupFn(out)) {
+        this._cleanup = out;
+        return;
+      }
+      if (this._manualEmitUsed) return;
+      if (out === void 0) return;
+      this._emitAutoValue(out);
+    } catch (err) {
+      this._downInternal([[ERROR, err]]);
+    }
+  }
+  _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]]);
+    }
+  }
+  _handleDepMessages(index, messages) {
+    for (const msg of messages) {
+      this._inspectorHook?.({ 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) {
+          this._downInternal([[ERROR, err]]);
+          return;
+        }
+      }
+      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]);
+    }
+  }
+  _connectUpstream() {
+    if (!this._hasDeps || this._connected) return;
+    this._connected = true;
+    this._depDirtyMask.reset();
+    this._depSettledMask.reset();
+    this._depCompleteMask.reset();
+    this._status = "settled";
+    const subHints = this._isSingleDep ? { singleDep: true } : void 0;
+    this._connecting = true;
+    try {
+      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)
+        );
+      }
+    } finally {
+      this._connecting = false;
+    }
+    if (this._fn) {
+      this._runFn();
+    }
+  }
+  _stopProducer() {
+    if (!this._producerStarted) return;
+    this._producerStarted = false;
+    const producerCleanup = this._cleanup;
+    this._cleanup = void 0;
+    producerCleanup?.();
+  }
+  _startProducer() {
+    if (this._deps.length !== 0 || !this._fn || this._producerStarted) return;
+    this._producerStarted = true;
+    this._runFn();
+  }
+  _disconnectUpstream() {
+    if (!this._connected) return;
+    for (const unsub of this._upstreamUnsubs.splice(0)) {
+      unsub();
+    }
+    this._connected = false;
+    this._depDirtyMask.reset();
+    this._depSettledMask.reset();
+    this._depCompleteMask.reset();
+    this._status = "disconnected";
+  }
+};
+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
+function dynamicNode(fn, opts) {
+  return new DynamicNodeImpl(fn, opts ?? {});
+}
+var DynamicNodeImpl = class {
+  _optsName;
+  _registryName;
+  _describeKind;
+  meta;
+  _fn;
+  _equals;
+  _resubscribable;
+  _resetOnTeardown;
+  _autoComplete;
+  _onMessage;
+  _onResubscribe;
+  /** @internal — read by {@link describeNode} for `accessHintForGuard`. */
+  _guard;
+  _lastMutation;
+  _inspectorHook;
+  // Sink tracking
+  _sinkCount = 0;
+  _singleDepSinkCount = 0;
+  _singleDepSinks = /* @__PURE__ */ new WeakSet();
+  // Actions object (for onMessage handler)
+  _actions;
+  _boundEmitToSinks;
+  // Mutable state
+  _cached;
+  _status = "disconnected";
+  _terminal = false;
+  _connected = false;
+  _rewiring = false;
+  // re-entrancy guard
+  // Dynamic deps tracking
+  _deps = [];
+  _depUnsubs = [];
+  _depIndexMap = /* @__PURE__ */ new Map();
+  // node → index in _deps
+  _dirtyBits = /* @__PURE__ */ new Set();
+  _settledBits = /* @__PURE__ */ new Set();
+  _completeBits = /* @__PURE__ */ new Set();
+  // Sinks
+  _sinks = null;
+  constructor(fn, opts) {
+    this._fn = fn;
+    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._onMessage = opts.onMessage;
+    this._onResubscribe = opts.onResubscribe;
+    this._guard = opts.guard;
+    this._inspectorHook = void 0;
+    const meta = {};
+    for (const [k, v] of Object.entries(opts.meta ?? {})) {
+      meta[k] = node({
+        initial: v,
+        name: `${opts.name ?? "dynamicNode"}:meta:${k}`,
+        describeKind: "state",
+        ...opts.guard != null ? { guard: opts.guard } : {}
+      });
+    }
+    Object.freeze(meta);
+    this.meta = meta;
+    const self = this;
+    this._actions = {
+      down(messages) {
+        self._downInternal(messages);
+      },
+      emit(value) {
+        self._emitAutoValue(value);
+      },
+      up(messages) {
+        for (const dep of self._deps) {
+          dep.up?.(messages, { internal: true });
+        }
+      }
+    };
+    this._boundEmitToSinks = this._emitToSinks.bind(this);
+  }
+  get name() {
+    return this._registryName ?? this._optsName;
+  }
+  /** @internal */
+  _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;
+      }
+    };
+  }
+  get status() {
+    return this._status;
+  }
+  get lastMutation() {
+    return this._lastMutation;
+  }
+  /** Versioning not yet supported on DynamicNodeImpl. */
+  get v() {
+    return void 0;
+  }
+  hasGuard() {
+    return this._guard != null;
+  }
+  allowsObserve(actor) {
+    if (this._guard == null) return true;
+    return this._guard(normalizeActor(actor), "observe");
+  }
+  get() {
+    return 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._lastMutation = { actor, timestamp_ns: wallClockNs() };
+    }
+    this._downInternal(messages);
+  }
+  _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) {
+          emitWithBatch(this._boundEmitToSinks, filtered);
+        }
+        return;
+      }
+    }
+    emitWithBatch(this._boundEmitToSinks, sinkMessages);
+  }
+  _canSkipDirty() {
+    return this._sinkCount === 1 && this._singleDepSinkCount === 1;
+  }
+  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._status = "disconnected";
+      this._onResubscribe?.();
+    }
+    this._sinkCount += 1;
+    if (hints?.singleDep) {
+      this._singleDepSinkCount += 1;
+      this._singleDepSinks.add(sink);
+    }
+    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._connected) {
+      this._connect();
+    }
+    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._disconnect();
+      }
+    };
+  }
+  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._lastMutation = { actor, timestamp_ns: wallClockNs() };
+    }
+    for (const dep of this._deps) {
+      dep.up?.(messages, options);
+    }
+  }
+  unsubscribe() {
+    this._disconnect();
+  }
+  // --- Private methods ---
+  _emitToSinks(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);
+    }
+  }
+  _handleLocalLifecycle(messages) {
+    for (const m of messages) {
+      const t = m[0];
+      if (t === DATA) this._cached = m[1];
+      if (t === INVALIDATE) {
+        this._cached = void 0;
+      }
+      if (t === DATA || t === RESOLVED) {
+        this._status = "settled";
+      } else if (t === DIRTY) {
+        this._status = "dirty";
+      } else if (t === COMPLETE) {
+        this._status = "completed";
+        this._terminal = true;
+      } else if (t === ERROR) {
+        this._status = "errored";
+        this._terminal = true;
+      }
+      if (t === TEARDOWN) {
+        if (this._resetOnTeardown) this._cached = void 0;
+        try {
+          this._propagateToMeta(t);
+        } finally {
+          this._disconnect();
+        }
+      }
+      if (t !== TEARDOWN && propagatesToMeta(t)) {
+        this._propagateToMeta(t);
+      }
+    }
+  }
+  /** Propagate a signal to all companion meta nodes (best-effort). */
+  _propagateToMeta(t) {
+    for (const metaNode of Object.values(this.meta)) {
+      try {
+        metaNode.down([[t]], { internal: true });
+      } catch {
+      }
+    }
+  }
+  _emitAutoValue(value) {
+    const wasDirty = this._status === "dirty";
+    const unchanged = this._equals(this._cached, value);
+    if (unchanged) {
+      this._downInternal(wasDirty ? [[RESOLVED]] : [[DIRTY], [RESOLVED]]);
+      return;
+    }
+    this._cached = value;
+    this._downInternal(wasDirty ? [[DATA, value]] : [[DIRTY], [DATA, value]]);
+  }
+  _connect() {
+    if (this._connected) return;
+    this._connected = true;
+    this._status = "settled";
+    this._dirtyBits.clear();
+    this._settledBits.clear();
+    this._completeBits.clear();
+    this._runFn();
+  }
+  _disconnect() {
+    if (!this._connected) return;
+    for (const unsub of this._depUnsubs) unsub();
+    this._depUnsubs = [];
+    this._deps = [];
+    this._depIndexMap.clear();
+    this._dirtyBits.clear();
+    this._settledBits.clear();
+    this._completeBits.clear();
+    this._connected = false;
+    this._status = "disconnected";
+  }
+  _runFn() {
+    if (this._terminal && !this._resubscribable) return;
+    if (this._rewiring) return;
+    const trackedDeps = [];
+    const trackedSet = /* @__PURE__ */ new Set();
+    const get = (dep) => {
+      if (!trackedSet.has(dep)) {
+        trackedSet.add(dep);
+        trackedDeps.push(dep);
+      }
+      return dep.get();
+    };
+    try {
+      const depValues = [];
+      for (const dep of this._deps) {
+        depValues.push(dep.get());
+      }
+      this._inspectorHook?.({ kind: "run", depValues });
+      const result = this._fn(get);
+      this._rewire(trackedDeps);
+      if (result === void 0) return;
+      this._emitAutoValue(result);
+    } catch (err) {
+      this._downInternal([[ERROR, err]]);
+    }
+  }
+  _rewire(newDeps) {
+    this._rewiring = true;
+    try {
+      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._dirtyBits.clear();
+      this._settledBits.clear();
+      const newCompleteBits = /* @__PURE__ */ new Set();
+      for (const oldIdx of this._completeBits) {
+        const dep = [...oldMap.entries()].find(([, idx]) => idx === oldIdx)?.[0];
+        if (dep && newMap.has(dep)) {
+          newCompleteBits.add(newMap.get(dep));
+        }
+      }
+      this._completeBits = newCompleteBits;
+    } finally {
+      this._rewiring = false;
+    }
+  }
+  _handleDepMessages(index, messages) {
+    if (this._rewiring) return;
+    for (const msg of messages) {
+      this._inspectorHook?.({ 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) {
+          this._downInternal([[ERROR, err]]);
+          return;
+        }
+      }
+      if (t === DIRTY) {
+        this._dirtyBits.add(index);
+        this._settledBits.delete(index);
+        if (this._dirtyBits.size === 1) {
+          emitWithBatch(this._boundEmitToSinks, [[DIRTY]]);
+        }
+        continue;
+      }
+      if (t === DATA || t === RESOLVED) {
+        if (!this._dirtyBits.has(index)) {
+          this._dirtyBits.add(index);
+          emitWithBatch(this._boundEmitToSinks, [[DIRTY]]);
+        }
+        this._settledBits.add(index);
+        if (this._allDirtySettled()) {
+          this._dirtyBits.clear();
+          this._settledBits.clear();
+          this._runFn();
+        }
+        continue;
+      }
+      if (t === COMPLETE) {
+        this._completeBits.add(index);
+        this._dirtyBits.delete(index);
+        this._settledBits.delete(index);
+        if (this._allDirtySettled()) {
+          this._dirtyBits.clear();
+          this._settledBits.clear();
+          this._runFn();
+        }
+        if (this._autoComplete && this._completeBits.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]);
+    }
+  }
+  _allDirtySettled() {
+    if (this._dirtyBits.size === 0) return false;
+    for (const idx of this._dirtyBits) {
+      if (!this._settledBits.has(idx)) return false;
+    }
+    return true;
+  }
+};
+
+// 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) {
+  return node(deps, fn, { describeKind: "effect" });
+}
+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,
+  DATA,
+  DIRTY,
+  RESOLVED,
+  INVALIDATE,
+  PAUSE,
+  RESUME,
+  TEARDOWN,
+  COMPLETE,
+  ERROR,
+  knownMessageTypes,
+  isKnownMessageType,
+  messageTier,
+  isPhase2Message,
+  isTerminalMessage,
+  propagatesToMeta,
+  isBatching,
+  batch,
+  partitionForBatch,
+  emitWithBatch,
+  monotonicNs,
+  wallClockNs,
+  GuardDenied,
+  policy,
+  policyFromRules,
+  accessHintForGuard,
+  defaultHash,
+  createVersioning,
+  advanceVersion,
+  isV1,
+  NodeImpl,
+  node,
+  dynamicNode,
+  DynamicNodeImpl,
+  state,
+  producer,
+  derived,
+  effect,
+  pipe
+};
+//# sourceMappingURL=chunk-5X3LAO3B.js.map