@nisli/core 0.55.0 → 0.57.0

package/dist/bundler/resource.js

@@ -0,0 +1,99 @@
+import { getCurrentComponent, hasContext } from "./context.js";
+import { disposable } from "./disposable.js";
+import { __enrollPending } from "./settle.js";
+import { effect, signal } from "./signal.js";
+function resource(source, loader) {
+  const data = signal(void 0);
+  const loading = signal(false);
+  const error = signal(null);
+  const refreshVersion = signal(0);
+  let generation = 0;
+  let disposed = false;
+  let stopEffect = () => {
+  };
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    generation++;
+    stopEffect();
+    loading.value = false;
+  };
+  if (hasContext()) {
+    getCurrentComponent().addDisposer(dispose);
+  }
+  stopEffect = effect(() => {
+    refreshVersion.value;
+    const currentGeneration = ++generation;
+    let sourceValue;
+    try {
+      sourceValue = source();
+    } catch (cause) {
+      loading.value = false;
+      error.value = toError(cause);
+      return;
+    }
+    if (sourceValue === void 0) {
+      data.value = void 0;
+      loading.value = false;
+      error.value = null;
+      return;
+    }
+    const controller = new AbortController();
+    loading.value = true;
+    error.value = null;
+    const enabledSource = sourceValue;
+    const isStale = () => disposed || controller.signal.aborted || currentGeneration !== generation;
+    const settled = __enrollPending();
+    void Promise.resolve().then(async () => {
+      if (isStale()) {
+        settled();
+        return;
+      }
+      try {
+        const value = await loader(enabledSource, controller.signal);
+        if (isStale()) {
+          settled();
+          return;
+        }
+        data.value = value;
+        loading.value = false;
+        settled();
+      } catch (cause) {
+        if (isStale()) {
+          settled();
+          return;
+        }
+        error.value = toError(cause);
+        loading.value = false;
+        settled();
+      }
+    });
+    return () => {
+      if (currentGeneration === generation) generation++;
+      controller.abort();
+      settled();
+    };
+  });
+  const result = {
+    data,
+    loading,
+    error,
+    refresh() {
+      if (!disposed) refreshVersion.value++;
+    },
+    dispose
+  };
+  return disposable(result, dispose);
+}
+function toError(cause) {
+  if (cause instanceof Error) return cause;
+  try {
+    return new Error(String(cause));
+  } catch {
+    return new Error("Unknown error");
+  }
+}
+export {
+  resource
+};
+//# sourceMappingURL=resource.js.map

package/dist/bundler/resource.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/resource.ts"],
+  "sourcesContent": ["/**\n * resource.ts \u2014 Local async derivations with reactive source tracking.\n *\n * `resource()` is the async counterpart to a local computed value: source\n * dependencies are tracked synchronously, while the loader runs outside the\n * reactive observer and commits only the newest live generation.\n */\n\nimport { getCurrentComponent, hasContext } from './context.js';\nimport { disposable, type DisposableResource } from './disposable.js';\nimport { __enrollPending } from './settle.js';\nimport { effect, signal, type ReadonlySignal } from './signal.js';\n\nexport interface ResourceResult<T> extends DisposableResource {\n  /** Latest successful value. Retained while a newer load is pending. */\n  readonly data: ReadonlySignal<T | undefined>;\n  /** True while the current generation is loading. */\n  readonly loading: ReadonlySignal<boolean>;\n  /** Error from the current generation, or null. */\n  readonly error: ReadonlySignal<Error | null>;\n  /** Re-run the loader for the current source value. */\n  refresh(): void;\n  /** Stop source tracking and invalidate/abort outstanding work. */\n  dispose(): void;\n}\n\n/**\n * Derive local async state from a synchronously tracked source.\n *\n * Only signal reads inside `source` are dependencies. `loader` starts in a\n * microtask, outside the active observer, so signal reads before or after its\n * first await never accidentally widen the source set.\n */\nexport function resource<S, T>(\n  source: () => S | undefined,\n  loader: (source: S, signal: AbortSignal) => PromiseLike<T>,\n): ResourceResult<T> {\n  const data = signal<T | undefined>(undefined);\n  const loading = signal(false);\n  const error = signal<Error | null>(null);\n  const refreshVersion = signal(0);\n\n  let generation = 0;\n  let disposed = false;\n  let stopEffect: () => void = () => {};\n\n  const dispose = () => {\n    if (disposed) return;\n    disposed = true;\n    generation++;\n    stopEffect();\n    loading.value = false;\n  };\n\n  // Register the full resource disposer before effect() registers its own\n  // lower-level disposer, so component teardown first invalidates generations\n  // and then performs the idempotent raw effect cleanup.\n  if (hasContext()) {\n    getCurrentComponent().addDisposer(dispose);\n  }\n\n  stopEffect = effect(() => {\n    refreshVersion.value;\n    const currentGeneration = ++generation;\n\n    let sourceValue: S | undefined;\n    try {\n      sourceValue = source();\n    } catch (cause) {\n      loading.value = false;\n      error.value = toError(cause);\n      return;\n    }\n\n    // `undefined` is the single disabled sentinel. It covers the markdown\n    // consumer's empty-content branch without growing an options surface.\n    if (sourceValue === undefined) {\n      data.value = undefined;\n      loading.value = false;\n      error.value = null;\n      return;\n    }\n\n    const controller = new AbortController();\n    loading.value = true;\n    error.value = null;\n    const enabledSource = sourceValue as S;\n    const isStale = () => (\n      disposed\n      || controller.signal.aborted\n      || currentGeneration !== generation\n    );\n\n    // settle() enrollment (ADR 0030.2 T2): this generation is a pending\n    // logical request from here until COMMIT (data/error write) or ABORT\n    // (the cleanup below) \u2014 never raw loader settlement, so an\n    // abort-ignoring loader cannot wedge settle(). Idempotent.\n    const settled = __enrollPending();\n\n    // The microtask boundary is deliberate: loader signal reads are NOT source\n    // dependencies, and synchronous loader throws become normal rejections.\n    void Promise.resolve().then(async () => {\n      if (isStale()) { settled(); return; }\n\n      try {\n        const value = await loader(enabledSource, controller.signal);\n        if (isStale()) { settled(); return; }\n        data.value = value;\n        loading.value = false;\n        settled();\n      } catch (cause) {\n        if (isStale()) { settled(); return; }\n        error.value = toError(cause);\n        loading.value = false;\n        settled();\n      }\n    });\n\n    return () => {\n      if (currentGeneration === generation) generation++;\n      controller.abort();\n      settled();\n    };\n  });\n\n  const result = {\n    data,\n    loading,\n    error,\n    refresh() {\n      if (!disposed) refreshVersion.value++;\n    },\n    dispose,\n  };\n  return disposable(result, dispose);\n}\n\nfunction toError(cause: unknown): Error {\n  if (cause instanceof Error) return cause;\n\n  try {\n    return new Error(String(cause));\n  } catch {\n    return new Error('Unknown error');\n  }\n}\n"],
+  "mappings": "AAQA,SAAS,qBAAqB,kBAAkB;AAChD,SAAS,kBAA2C;AACpD,SAAS,uBAAuB;AAChC,SAAS,QAAQ,cAAmC;AAsB7C,SAAS,SACd,QACA,QACmB;AACnB,QAAM,OAAO,OAAsB,MAAS;AAC5C,QAAM,UAAU,OAAO,KAAK;AAC5B,QAAM,QAAQ,OAAqB,IAAI;AACvC,QAAM,iBAAiB,OAAO,CAAC;AAE/B,MAAI,aAAa;AACjB,MAAI,WAAW;AACf,MAAI,aAAyB,MAAM;AAAA,EAAC;AAEpC,QAAM,UAAU,MAAM;AACpB,QAAI,SAAU;AACd,eAAW;AACX;AACA,eAAW;AACX,YAAQ,QAAQ;AAAA,EAClB;AAKA,MAAI,WAAW,GAAG;AAChB,wBAAoB,EAAE,YAAY,OAAO;AAAA,EAC3C;AAEA,eAAa,OAAO,MAAM;AACxB,mBAAe;AACf,UAAM,oBAAoB,EAAE;AAE5B,QAAI;AACJ,QAAI;AACF,oBAAc,OAAO;AAAA,IACvB,SAAS,OAAO;AACd,cAAQ,QAAQ;AAChB,YAAM,QAAQ,QAAQ,KAAK;AAC3B;AAAA,IACF;AAIA,QAAI,gBAAgB,QAAW;AAC7B,WAAK,QAAQ;AACb,cAAQ,QAAQ;AAChB,YAAM,QAAQ;AACd;AAAA,IACF;AAEA,UAAM,aAAa,IAAI,gBAAgB;AACvC,YAAQ,QAAQ;AAChB,UAAM,QAAQ;AACd,UAAM,gBAAgB;AACtB,UAAM,UAAU,MACd,YACG,WAAW,OAAO,WAClB,sBAAsB;AAO3B,UAAM,UAAU,gBAAgB;AAIhC,SAAK,QAAQ,QAAQ,EAAE,KAAK,YAAY;AACtC,UAAI,QAAQ,GAAG;AAAE,gBAAQ;AAAG;AAAA,MAAQ;AAEpC,UAAI;AACF,cAAM,QAAQ,MAAM,OAAO,eAAe,WAAW,MAAM;AAC3D,YAAI,QAAQ,GAAG;AAAE,kBAAQ;AAAG;AAAA,QAAQ;AACpC,aAAK,QAAQ;AACb,gBAAQ,QAAQ;AAChB,gBAAQ;AAAA,MACV,SAAS,OAAO;AACd,YAAI,QAAQ,GAAG;AAAE,kBAAQ;AAAG;AAAA,QAAQ;AACpC,cAAM,QAAQ,QAAQ,KAAK;AAC3B,gBAAQ,QAAQ;AAChB,gBAAQ;AAAA,MACV;AAAA,IACF,CAAC;AAED,WAAO,MAAM;AACX,UAAI,sBAAsB,WAAY;AACtC,iBAAW,MAAM;AACjB,cAAQ;AAAA,IACV;AAAA,EACF,CAAC;AAED,QAAM,SAAS;AAAA,IACb;AAAA,IACA;AAAA,IACA;AAAA,IACA,UAAU;AACR,UAAI,CAAC,SAAU,gBAAe;AAAA,IAChC;AAAA,IACA;AAAA,EACF;AACA,SAAO,WAAW,QAAQ,OAAO;AACnC;AAEA,SAAS,QAAQ,OAAuB;AACtC,MAAI,iBAAiB,MAAO,QAAO;AAEnC,MAAI;AACF,WAAO,IAAI,MAAM,OAAO,KAAK,CAAC;AAAA,EAChC,QAAQ;AACN,WAAO,IAAI,MAAM,eAAe;AAAA,EAClC;AACF;",
+  "names": []
+}

package/dist/bundler/settle.js

@@ -0,0 +1,43 @@
+import { tick } from "./signal.js";
+const pending = /* @__PURE__ */ new Set();
+function __enrollPending() {
+  let resolve;
+  const entry = new Promise((res) => {
+    resolve = res;
+  });
+  pending.add(entry);
+  let done = false;
+  return () => {
+    if (done) return;
+    done = true;
+    pending.delete(entry);
+    resolve();
+  };
+}
+function __resetPending() {
+  pending.clear();
+}
+function __pendingCount() {
+  return pending.size;
+}
+import { diag, isDev } from "./diagnostics.js";
+import { registerResetHook } from "./injector.js";
+registerResetHook(__resetPending);
+async function settle() {
+  for (let i = 0; i < 50; i++) {
+    await tick();
+    if (pending.size === 0) return;
+    await Promise.allSettled([...pending]);
+  }
+  if (process.env.NODE_ENV !== "production" && isDev()) diag(
+    "N603",
+    "settle() did not reach quiescence within 50 iterations \u2014 something keeps scheduling new async work (a self-invalidating query or a polling loop?). settle() is a test/verify primitive; under live background refetch it is unbounded by design. Returning anyway."
+  );
+}
+export {
+  __enrollPending,
+  __pendingCount,
+  __resetPending,
+  settle
+};
+//# sourceMappingURL=settle.js.map

package/dist/bundler/settle.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/settle.ts"],
+  "sourcesContent": ["/**\n * settle.ts \u2014 Awaitable async quiescence (ADR 0030.2 T2).\n *\n * `await settle()` resolves when every framework-started logical async\n * request has TERMINATED and the reactive graph is quiescent. Query runs\n * (query.ts) and resource loads (resource.ts) enroll here when they start\n * and deregister at *termination* \u2014 commit, terminal error after retries,\n * or abort \u2014 never at raw promise settlement. An abort-ignoring fetcher\n * whose run was superseded therefore cannot wedge `settle()`: the run's\n * registry entry closed at the abort even though the underlying promise\n * never resolves.\n *\n * ```ts\n * mount(app);\n * await settle();\n * expect(screen.textContent).toContain('loaded');   // no waitFor polling\n * ```\n *\n * Contract and bounds:\n * - This is a **test/verify primitive** (and the SSG pre-snapshot barrier).\n *   Awaiting it in a live app with continuous background refetch/polling is\n *   unbounded *by design* \u2014 each commit may legally schedule the next\n *   request. A scope argument waits for a second consumer (ADR 0030.2 \u00A78).\n * - Each iteration awaits the pending registry, then `tick()` (signal.ts's\n *   bounded microtask-drain contract). Timer-scheduled work is NOT awaited\n *   beyond what a pending logical request itself spans.\n * - Iteration-capped at 50 like `tick()`; hitting the cap emits diagnostic\n *   N603 and resolves \u2014 never a silent hang, never an unbounded loop.\n *\n * MERGE ITEM: `__resetPending()` should be folded into `resetInjector()`\n * (injector.ts is owned by another worktree); until then test teardown\n * calls it directly.\n */\n\nimport { tick } from './signal.js';\n\n// \u2500\u2500 Pending logical-request registry \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n/**\n * One entry per in-flight logical request. The promise is a *termination*\n * promise resolved by the enroller's `done()` callback \u2014 deliberately not\n * the fetcher/loader promise itself (see module doc).\n */\nconst pending = new Set<Promise<void>>();\n\n/**\n * Enroll a logical async request. Returns its `done()` terminator: call it\n * at commit, terminal error, or abort. Idempotent \u2014 a superseded run whose\n * terminator was already invoked by the superseding path may safely call\n * it again from its own settlement branch.\n *\n * @internal \u2014 called by query.ts runs and resource.ts loader generations.\n */\nexport function __enrollPending(): () => void {\n  let resolve!: () => void;\n  const entry = new Promise<void>((res) => { resolve = res; });\n  pending.add(entry);\n  let done = false;\n  return () => {\n    if (done) return;\n    done = true;\n    pending.delete(entry);\n    resolve();\n  };\n}\n\n/**\n * Reset the registry. Test-teardown escape hatch: entries orphaned by a\n * test that never terminated its fetchers would otherwise leak into the\n * next test's `settle()`.\n *\n * @internal\n */\nexport function __resetPending(): void {\n  pending.clear();\n}\n\n/** Current number of enrolled (unterminated) logical requests. @internal */\nexport function __pendingCount(): number {\n  return pending.size;\n}\n\n// \u2500\u2500 Diagnostics + test isolation \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// Reporting goes through the core diagnostics leaf. The pending registry\n// self-registers with resetInjector() so test teardown clears it without\n// an upside-down import (settle \u2192 injector, never the reverse).\nimport { diag, isDev } from './diagnostics.js';\nimport { registerResetHook } from './injector.js';\n\nregisterResetHook(__resetPending);\n\n// \u2500\u2500 settle() \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n/**\n * Await async quiescence: loop `tick()` \u2192 `Promise.allSettled(pending)`\n * until a full `tick()` leaves the pending registry empty.\n *\n * The `tick()` *first* ordering matters: observer effects created since\n * the last flush are what *start* runs (and enroll them) \u2014 the registry\n * can only be trusted empty after the reactive graph has flushed.\n */\nexport async function settle(): Promise<void> {\n  for (let i = 0; i < 50; i++) {\n    await tick();\n    if (pending.size === 0) return;\n    await Promise.allSettled([...pending]);\n  }\n  if (process.env.NODE_ENV !== 'production' && isDev()) diag(\n    'N603',\n    'settle() did not reach quiescence within 50 iterations \u2014 something '\n    + 'keeps scheduling new async work (a self-invalidating query or a '\n    + 'polling loop?). settle() is a test/verify primitive; under live '\n    + 'background refetch it is unbounded by design. Returning anyway.',\n  );\n}\n"],
+  "mappings": "AAkCA,SAAS,YAAY;AASrB,MAAM,UAAU,oBAAI,IAAmB;AAUhC,SAAS,kBAA8B;AAC5C,MAAI;AACJ,QAAM,QAAQ,IAAI,QAAc,CAAC,QAAQ;AAAE,cAAU;AAAA,EAAK,CAAC;AAC3D,UAAQ,IAAI,KAAK;AACjB,MAAI,OAAO;AACX,SAAO,MAAM;AACX,QAAI,KAAM;AACV,WAAO;AACP,YAAQ,OAAO,KAAK;AACpB,YAAQ;AAAA,EACV;AACF;AASO,SAAS,iBAAuB;AACrC,UAAQ,MAAM;AAChB;AAGO,SAAS,iBAAyB;AACvC,SAAO,QAAQ;AACjB;AAMA,SAAS,MAAM,aAAa;AAC5B,SAAS,yBAAyB;AAElC,kBAAkB,cAAc;AAYhC,eAAsB,SAAwB;AAC5C,WAAS,IAAI,GAAG,IAAI,IAAI,KAAK;AAC3B,UAAM,KAAK;AACX,QAAI,QAAQ,SAAS,EAAG;AACxB,UAAM,QAAQ,WAAW,CAAC,GAAG,OAAO,CAAC;AAAA,EACvC;AACA,MAAI,QAAQ,IAAI,aAAa,gBAAgB,MAAM,EAAG;AAAA,IACpD;AAAA,IACA;AAAA,EAIF;AACF;",
+  "names": []
+}

package/dist/bundler/signal.js

@@ -0,0 +1,403 @@
+let contextHook = null;
+function setContextHook(hook) {
+  contextHook = hook;
+}
+const SIGNAL_BRAND = /* @__PURE__ */ Symbol.for("backlog.signal");
+let activeObserver = null;
+let runningEffect = null;
+let globalEpoch = 0;
+let nextEffectOrder = 0;
+import { diag as emitDiag, isDev } from "./diagnostics.js";
+import { disposable } from "./disposable.js";
+function diag(code, message, detail) {
+  if (!isDev()) return;
+  emitDiag(code, message, detail);
+}
+const pendingEffects = /* @__PURE__ */ new Set();
+let flushScheduled = false;
+function scheduleFlush() {
+  if (!flushScheduled) {
+    flushScheduled = true;
+    queueMicrotask(flushPendingEffects);
+  }
+}
+function flushPendingEffects() {
+  flushScheduled = false;
+  const effects = [...pendingEffects].sort((a, b) => a.order - b.order);
+  pendingEffects.clear();
+  for (const effect2 of effects) {
+    if (!effect2.disposed) {
+      runEffect(effect2);
+    }
+  }
+}
+var NodeState = /* @__PURE__ */ ((NodeState2) => {
+  NodeState2[NodeState2["Clean"] = 0] = "Clean";
+  NodeState2[NodeState2["MaybeDirty"] = 1] = "MaybeDirty";
+  NodeState2[NodeState2["Dirty"] = 2] = "Dirty";
+  return NodeState2;
+})(NodeState || {});
+const NO_COMPUTED_ERROR = /* @__PURE__ */ Symbol("no-computed-error");
+class SignalImpl {
+  [SIGNAL_BRAND] = true;
+  /** @internal */
+  _node;
+  constructor(initialValue) {
+    this._node = {
+      value: initialValue,
+      lastChanged: globalEpoch,
+      observers: /* @__PURE__ */ new Set()
+    };
+  }
+  get value() {
+    if (activeObserver) {
+      activeObserver.sources.add(this._node);
+      this._node.observers.add(activeObserver);
+    }
+    return this._node.value;
+  }
+  set value(newValue) {
+    if (Object.is(this._node.value, newValue)) return;
+    if (process.env.NODE_ENV !== "production" && isDev() && runningEffect !== null && runningEffect.sources.has(this._node)) {
+      diag(
+        "N302",
+        "Effect wrote to a signal it also reads \u2014 the write re-schedules the effect. If this does not converge to an equal value it is an infinite loop. Derive the value with computed() instead.",
+        runningEffect.createdAt ? { effect: runningEffect.createdAt } : void 0
+      );
+    }
+    this._node.value = newValue;
+    this._node.lastChanged = ++globalEpoch;
+    notifyObservers(this._node.observers, 2 /* Dirty */);
+  }
+  peek() {
+    return this._node.value;
+  }
+  subscribe(fn) {
+    return effect(() => {
+      const value = this.value;
+      untrack(() => fn(value));
+    });
+  }
+}
+function notifyObservers(observers, flavor) {
+  for (const observer of observers) {
+    observer.notify(flavor);
+  }
+}
+class ComputedImpl {
+  [SIGNAL_BRAND] = true;
+  /** @internal */
+  _node;
+  compute;
+  state = 2 /* Dirty */;
+  // Start dirty so first read computes
+  sources = /* @__PURE__ */ new Set();
+  computing = false;
+  error = NO_COMPUTED_ERROR;
+  /**
+   * globalEpoch snapshot at the end of the last update()/validation pass.
+   * A MaybeDirty computed recomputes only if some source's lastChanged
+   * advanced past this — otherwise it revalidates to Clean for free.
+   */
+  lastValidated = 0;
+  constructor(fn) {
+    this.compute = fn;
+    this._node = {
+      value: void 0,
+      lastChanged: 0,
+      observers: /* @__PURE__ */ new Set(),
+      pull: () => {
+        this.peek();
+      }
+    };
+  }
+  get value() {
+    if (this.computing) {
+      throw new Error("Circular dependency detected in computed()");
+    }
+    if (activeObserver) {
+      activeObserver.sources.add(this._node);
+      this._node.observers.add(activeObserver);
+    }
+    if (this.state !== 0 /* Clean */) {
+      this.update();
+    }
+    if (this.error !== NO_COMPUTED_ERROR) {
+      throw this.error;
+    }
+    return this._node.value;
+  }
+  peek() {
+    if (this.computing) {
+      throw new Error("Circular dependency detected in computed()");
+    }
+    if (this.state !== 0 /* Clean */) {
+      this.update();
+    }
+    if (this.error !== NO_COMPUTED_ERROR) {
+      throw this.error;
+    }
+    return this._node.value;
+  }
+  /**
+   * MaybeDirty validation: pull each source (computeds recompute lazily) and
+   * report whether any source's change-epoch advanced past our last
+   * validation. A pulled source may throw — its error-state transition
+   * already bumped its change-epoch, so the epoch comparison decides.
+   */
+  sourcesChanged() {
+    for (const source of this.sources) {
+      if ("pull" in source) {
+        try {
+          source.pull();
+        } catch (_) {
+        }
+      }
+      if (source.lastChanged > this.lastValidated) return true;
+    }
+    return false;
+  }
+  update() {
+    if (this.state === 1 /* MaybeDirty */ && !this.sourcesChanged()) {
+      this.state = 0 /* Clean */;
+      this.lastValidated = globalEpoch;
+      return;
+    }
+    for (const source of this.sources) {
+      source.observers.delete(this);
+    }
+    this.sources.clear();
+    const prevObserver = activeObserver;
+    activeObserver = this;
+    this.computing = true;
+    const wasError = this.error !== NO_COMPUTED_ERROR;
+    try {
+      const newValue = this.compute();
+      this.error = NO_COMPUTED_ERROR;
+      if (!Object.is(this._node.value, newValue)) {
+        this._node.value = newValue;
+        this._node.lastChanged = ++globalEpoch;
+      } else if (wasError) {
+        this._node.lastChanged = ++globalEpoch;
+      }
+    } catch (error) {
+      this.error = error;
+      if (!wasError) {
+        this._node.lastChanged = ++globalEpoch;
+      }
+      throw error;
+    } finally {
+      this.computing = false;
+      activeObserver = prevObserver;
+      this.state = 0 /* Clean */;
+      this.lastValidated = globalEpoch;
+    }
+  }
+  /** @internal — called by the ReactiveNode interface when a source changes */
+  notify(flavor) {
+    if (flavor > this.state) {
+      const wasClean = this.state === 0 /* Clean */;
+      this.state = flavor;
+      if (wasClean) {
+        notifyObservers(this._node.observers, 1 /* MaybeDirty */);
+      }
+    }
+  }
+  subscribe(fn) {
+    return effect(() => {
+      const value = this.value;
+      untrack(() => fn(value));
+    });
+  }
+  // ReactiveNode interface — used by dependency tracking
+  get sources_() {
+    return this.sources;
+  }
+}
+Object.defineProperty(ComputedImpl.prototype, "sources", {
+  enumerable: false
+});
+const MAX_EFFECT_RERUNS = 100;
+function createEffectNode(fn) {
+  return {
+    state: 2 /* Dirty */,
+    fn,
+    cleanup: null,
+    disposed: false,
+    sources: /* @__PURE__ */ new Set(),
+    disposers: [],
+    order: nextEffectOrder++,
+    lastRunEpoch: 0,
+    selfReschedules: 0,
+    notify(flavor) {
+      if (this.disposed) return;
+      if (flavor > this.state) this.state = flavor;
+      pendingEffects.add(this);
+      scheduleFlush();
+    }
+  };
+}
+function effectSourcesChanged(node) {
+  for (const source of node.sources) {
+    if ("pull" in source) {
+      try {
+        source.pull();
+      } catch (_) {
+      }
+    }
+    if (source.lastChanged > node.lastRunEpoch) return true;
+  }
+  return false;
+}
+function isThenable(value) {
+  return value !== null && typeof value === "object" && typeof value.then === "function";
+}
+function runEffect(node) {
+  if (node.disposed) return;
+  if (node.state === 1 /* MaybeDirty */ && !effectSourcesChanged(node)) {
+    node.state = 0 /* Clean */;
+    return;
+  }
+  if (node.cleanup) {
+    try {
+      node.cleanup();
+    } catch (_) {
+    }
+    node.cleanup = null;
+  }
+  for (const source of node.sources) {
+    source.observers.delete(node);
+  }
+  node.sources.clear();
+  node.state = 0 /* Clean */;
+  const prevObserver = activeObserver;
+  const prevRunning = process.env.NODE_ENV !== "production" ? runningEffect : null;
+  activeObserver = node;
+  if (process.env.NODE_ENV !== "production") runningEffect = node;
+  try {
+    const result = node.fn();
+    if (typeof result === "function") {
+      node.cleanup = result;
+    } else if (isThenable(result)) {
+      if (process.env.NODE_ENV !== "production" && isDev() && !node.asyncWarned) {
+        node.asyncWarned = true;
+        diag(
+          "N310",
+          "effect() callback returned a Promise \u2014 effects must be synchronous. Async state belongs in resource(). The returned Promise is not a cleanup function; its rejection is contained by the effect error path.",
+          node.createdAt ? { effect: node.createdAt } : void 0
+        );
+      }
+      result.then(void 0, (err) => {
+        console.error("Effect error:", err);
+      });
+    }
+  } catch (err) {
+    console.error("Effect error:", err);
+  } finally {
+    activeObserver = prevObserver;
+    if (process.env.NODE_ENV !== "production") runningEffect = prevRunning;
+    node.lastRunEpoch = globalEpoch;
+  }
+  if (pendingEffects.has(node)) {
+    if (++node.selfReschedules > MAX_EFFECT_RERUNS) {
+      if (process.env.NODE_ENV !== "production" && isDev()) diag(
+        "N301",
+        `Effect exceeded maximum re-run limit (${MAX_EFFECT_RERUNS}). This usually means the effect writes to a signal it reads. The effect has been disposed to prevent a UI freeze.`,
+        node.createdAt ? { effect: node.createdAt } : void 0
+      );
+      node.disposed = true;
+      for (const source of node.sources) {
+        source.observers.delete(node);
+      }
+      node.sources.clear();
+      pendingEffects.delete(node);
+    }
+  } else {
+    node.selfReschedules = 0;
+  }
+}
+function signal(initialValue) {
+  return new SignalImpl(initialValue);
+}
+function computed(fn) {
+  return new ComputedImpl(fn);
+}
+function effect(fn, ..._rejectAsync) {
+  const node = createEffectNode(fn);
+  if (process.env.NODE_ENV !== "production" && isDev()) {
+    node.createdAt = new Error("effect() created here").stack;
+  }
+  runEffect(node);
+  const dispose = () => {
+    node.disposed = true;
+    if (node.cleanup) {
+      try {
+        node.cleanup();
+      } catch (_) {
+      }
+      node.cleanup = null;
+    }
+    for (const source of node.sources) {
+      source.observers.delete(node);
+    }
+    node.sources.clear();
+    pendingEffects.delete(node);
+  };
+  if (contextHook) {
+    const addDisposer = contextHook();
+    if (addDisposer) {
+      addDisposer(dispose);
+    }
+  }
+  return disposable(dispose, dispose);
+}
+function isSignal(value) {
+  return value !== null && typeof value === "object" && SIGNAL_BRAND in value;
+}
+function untrack(fn) {
+  const prev = activeObserver;
+  activeObserver = null;
+  try {
+    return fn();
+  } finally {
+    activeObserver = prev;
+  }
+}
+function flush() {
+  let guard = 0;
+  while (pendingEffects.size > 0) {
+    flushPendingEffects();
+    if (++guard > 1e5) {
+      if (process.env.NODE_ENV !== "production" && isDev()) diag(
+        "N303",
+        "flush() cascade cap reached (100000 passes) \u2014 effects keep scheduling more effects (a cross-effect write cycle?). Breaking out to avoid a freeze; pending work remains unflushed."
+      );
+      break;
+    }
+  }
+}
+async function tick() {
+  flush();
+  for (let i = 0; i < 50; i++) {
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    if (pendingEffects.size === 0) return;
+    flush();
+  }
+  if (process.env.NODE_ENV !== "production" && isDev()) diag(
+    "N303",
+    "tick() iteration cap (50) reached with effects still pending \u2014 something keeps scheduling reactive work every task (a self-perpetuating scheduler?). Returning with work still queued."
+  );
+}
+export {
+  SIGNAL_BRAND,
+  computed,
+  effect,
+  flush,
+  flush as flushEffects,
+  isSignal,
+  setContextHook,
+  signal,
+  tick,
+  untrack
+};
+//# sourceMappingURL=signal.js.map