@ersbeth/picoflow 2.3.1 → 3.0.0

package/dist/picoflow.js

@@ -1,1283 +0,0 @@
-import { createResource, onMount, createEffect, resetErrorBoundaries, onCleanup } from 'solid-js';
-
-class DependenciesRegistry {
-  _dependencies = /* @__PURE__ */ new Set();
-  register(dependency, dependent) {
-    this._dependencies.add(dependency);
-    dependency.registerDependent(dependent);
-  }
-  unregister(dependency, dependent) {
-    this._dependencies.delete(dependency);
-    dependency.unregisterDependent(dependent);
-  }
-  clear(dependent) {
-    this._dependencies.forEach((dependency) => {
-      dependency.unregisterDependent(dependent);
-    });
-    this._dependencies.clear();
-  }
-  forEach(fn) {
-    Array.from(this._dependencies).forEach(fn);
-  }
-}
-
-class DependentsRegistry {
-  _dependents = /* @__PURE__ */ new Set();
-  register(dependent) {
-    this._dependents.add(dependent);
-  }
-  unregister(dependent) {
-    this._dependents.delete(dependent);
-  }
-  notifyAll() {
-    this._dependents.forEach((dependent) => {
-      dependent.notify();
-    });
-  }
-  forEach(fn) {
-    Array.from(this._dependents).forEach(fn);
-  }
-}
-
-class PicoFlowError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "PicoFlowError";
-  }
-}
-class PicoFlowDisposedError extends PicoFlowError {
-  constructor(message) {
-    super(message);
-    this.name = "PicoFlowDisposedError";
-  }
-}
-class PicoFlowCycleError extends PicoFlowError {
-  constructor(message) {
-    super(message);
-    this.name = "PicoFlowCycleError";
-  }
-}
-class PicoFlowInternalError extends PicoFlowError {
-  constructor(message) {
-    super(message);
-    this.name = "PicoFlowInternalError";
-  }
-}
-
-class Disposable {
-  _disposed = false;
-  _name;
-  constructor(name) {
-    this._name = name;
-  }
-  get disposed() {
-    return this._disposed;
-  }
-  /** Builds the disposed-primitive error, naming the primitive when a `name` was given at creation. */
-  _disposedError() {
-    return new PicoFlowDisposedError(
-      this._name ? `[PicoFlow] Primitive "${this._name}" is disposed` : "[PicoFlow] Primitive is disposed"
-    );
-  }
-}
-
-class ExecutionStack {
-  static _MAX_FLUSH_STEPS = 1e4;
-  static _pendingQueue = [];
-  static _effectQueue = [];
-  static _executionScheduled;
-  static _coalesceResetScheduled = false;
-  /** Per-effect resets accumulated for the microtask scheduled below, so notifying more than one
-   * effect in the same sync turn doesn't discard every reset after the first (A2-SEM-5). */
-  static _coalesceResets = /* @__PURE__ */ new Set();
-  /** Routes any error escaping the flush loop; defaults to logging rather than crashing (A2-SEM-2, A2-SEC-1). */
-  static _onFlushError = (error) => console.error(error);
-  /**
-   * True once the current synchronous call stack has finished and microtasks have started.
-   * EffectNode uses this to treat microtask notifications (e.g. async resolve) differently
-   * from coalesced sync-batch notifications.
-   */
-  static _pastSyncTurn = false;
-  /** @internal Used by EffectNode to distinguish sync-batch from microtask notifications. */
-  static get pastSyncTurn() {
-    return ExecutionStack._pastSyncTurn;
-  }
-  /**
-   * @internal Runs after the current sync turn ends (queueMicrotask).
-   * Marks pastSyncTurn so the next coalesced effect notify can bump its epoch,
-   * and resets per-effect coalesce flags via onReset.
-   */
-  static scheduleCoalesceReset(onReset) {
-    ExecutionStack._coalesceResets.add(onReset);
-    if (ExecutionStack._coalesceResetScheduled) return;
-    ExecutionStack._coalesceResetScheduled = true;
-    queueMicrotask(() => {
-      ExecutionStack._pastSyncTurn = true;
-      ExecutionStack._coalesceResetScheduled = false;
-      const resets = ExecutionStack._coalesceResets;
-      ExecutionStack._coalesceResets = /* @__PURE__ */ new Set();
-      resets.forEach((reset) => {
-        reset();
-      });
-    });
-  }
-  /** @internal Wired to the public `onFlushError()` API in `src/api/base/flowConfig.ts`. */
-  static setFlushErrorHandler(handler) {
-    ExecutionStack._onFlushError = handler;
-  }
-  static pushPending(node) {
-    ExecutionStack._beginSyncTurn();
-    ExecutionStack._scheduleExecution();
-    ExecutionStack._pendingQueue.push(node);
-  }
-  static pushEffect(effect) {
-    ExecutionStack._beginSyncTurn();
-    ExecutionStack._scheduleExecution();
-    ExecutionStack._effectQueue.push(effect);
-  }
-  static _beginSyncTurn() {
-    ExecutionStack._pastSyncTurn = false;
-  }
-  static _scheduleExecution() {
-    if (ExecutionStack._executionScheduled) return;
-    ExecutionStack._executionScheduled = new Promise((resolve) => {
-      setTimeout(() => {
-        ExecutionStack._executionScheduled = void 0;
-        ExecutionStack._execute();
-        resolve();
-      }, 0);
-    });
-  }
-  static _drain(queue) {
-    for (let i = 0; i < queue.length; i++) {
-      if (i >= ExecutionStack._MAX_FLUSH_STEPS) {
-        ExecutionStack._pendingQueue.length = 0;
-        ExecutionStack._effectQueue.length = 0;
-        ExecutionStack._onFlushError(
-          new PicoFlowCycleError("[PicoFlow] Reactive update cycle exceeded maximum depth")
-        );
-        return;
-      }
-      const node = queue[i];
-      try {
-        node?.execute();
-      } catch (error) {
-        ExecutionStack._onFlushError(error);
-      }
-    }
-    queue.length = 0;
-  }
-  static _execute() {
-    ExecutionStack._drain(ExecutionStack._pendingQueue);
-    ExecutionStack._drain(ExecutionStack._effectQueue);
-  }
-}
-
-class Node extends Disposable {
-  _dependenciesRegistry = new DependenciesRegistry();
-  _dependentsRegistry = new DependentsRegistry();
-  _status = "resolved";
-  get status() {
-    if (this.disposed) throw this._disposedError();
-    return this._status;
-  }
-  set status(status) {
-    if (this.disposed) throw this._disposedError();
-    this._status = status;
-  }
-  registerDependency(dependency) {
-    if (this._disposed) throw this._disposedError();
-    this._dependenciesRegistry.register(dependency, this);
-  }
-  unregisterDependency(dependency) {
-    if (this._disposed) throw this._disposedError();
-    this._dependenciesRegistry.unregister(dependency, this);
-  }
-  clearDependencies() {
-    if (this.disposed) throw this._disposedError();
-    this._dependenciesRegistry.clear(this);
-  }
-  registerDependent(dependent) {
-    if (this.disposed) throw this._disposedError();
-    this._dependentsRegistry.register(dependent);
-  }
-  unregisterDependent(dependent) {
-    if (this.disposed) throw this._disposedError();
-    this._dependentsRegistry.unregister(dependent);
-  }
-  markDependencyDisposed() {
-  }
-  notifyDependents() {
-    if (this.disposed) return;
-    this._dependentsRegistry.notifyAll();
-  }
-  watch(tracker) {
-    if (this.disposed) throw this._disposedError();
-    tracker.registerDependency(this);
-  }
-  trigger() {
-    if (this.disposed) throw this._disposedError();
-    this.notifyDependents();
-  }
-  dispose() {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._dependentsRegistry.forEach((dependant) => {
-      dependant.markDependencyDisposed();
-      dependant.unregisterDependency(this);
-      this.unregisterDependent(dependant);
-    });
-    this._dependenciesRegistry.forEach((dependency) => {
-      this.unregisterDependency(dependency);
-    });
-    this._disposed = true;
-  }
-}
-
-class Observable extends Disposable {
-  _dependentsRegistry = new DependentsRegistry();
-  _status = "resolved";
-  get status() {
-    if (this.disposed) throw this._disposedError();
-    return this._status;
-  }
-  set status(status) {
-    if (this.disposed) throw this._disposedError();
-    this._status = status;
-  }
-  registerDependent(dependent) {
-    if (this.disposed) throw this._disposedError();
-    this._dependentsRegistry.register(dependent);
-  }
-  unregisterDependent(dependent) {
-    if (this.disposed) throw this._disposedError();
-    this._dependentsRegistry.unregister(dependent);
-  }
-  notifyDependents() {
-    if (this.disposed) return;
-    this._dependentsRegistry.notifyAll();
-  }
-  watch(tracker) {
-    if (this.disposed) throw this._disposedError();
-    tracker.registerDependency(this);
-  }
-  trigger() {
-    if (this.disposed) throw this._disposedError();
-    this.notifyDependents();
-  }
-  dispose() {
-    if (this._disposed) throw this._disposedError();
-    this._dependentsRegistry.forEach((dependant) => {
-      dependant.markDependencyDisposed();
-      dependant.unregisterDependency(this);
-      this.unregisterDependent(dependant);
-    });
-    this._disposed = true;
-  }
-}
-
-class Observer extends Disposable {
-  _dependenciesRegistry = new DependenciesRegistry();
-  /** Set when a dependency disposed while this observer was queued; consumed by the next execute(). */
-  _dependencyDisposed = false;
-  markDependencyDisposed() {
-    this._dependencyDisposed = true;
-  }
-  registerDependency(dependency) {
-    if (this._disposed) throw this._disposedError();
-    this._dependenciesRegistry.register(dependency, this);
-  }
-  unregisterDependency(dependency) {
-    if (this._disposed) throw this._disposedError();
-    this._dependenciesRegistry.unregister(dependency, this);
-  }
-  clearDependencies() {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._dependenciesRegistry.clear(this);
-  }
-  dispose() {
-    if (this._disposed) throw this._disposedError();
-    this._dependenciesRegistry.clear(this);
-    this._disposed = true;
-  }
-}
-
-function onFlushError(handler) {
-  ExecutionStack.setFlushErrorHandler(handler);
-}
-
-function isDisposable(obj) {
-  return obj !== null && obj !== void 0 && typeof obj.dispose === "function";
-}
-
-class PendingError extends Error {
-  pendingPromise;
-  constructor(promise) {
-    super("[PicoFlow] Computation is pending");
-    this.name = "PendingError";
-    this.pendingPromise = promise;
-  }
-}
-
-class AsyncResolver {
-  _compute;
-  _computed = Promise.withResolvers();
-  _iteration = 0;
-  _aborted = false;
-  _finished = false;
-  constructor(compute) {
-    this._compute = compute;
-    this._computed.promise.catch(() => {
-    }).finally(() => {
-      this._finished = true;
-    });
-  }
-  get computed() {
-    return this._computed.promise;
-  }
-  get aborted() {
-    return this._aborted;
-  }
-  get finished() {
-    return this._finished;
-  }
-  compute() {
-    if (this._finished) throw new Error("[PicoFlow] AsyncResolver: Can't restart a settled resolver");
-    if (this._aborted) throw new Error("[PicoFlow] AsyncResolver: Can't restart an aborted resolver");
-    this._iteration++;
-    const currentIteration = this._iteration;
-    this._compute().then((value) => {
-      if (this._iteration === currentIteration && !this._aborted) this._computed.resolve(value);
-    }).catch((error) => {
-      if (this._iteration === currentIteration && !this._aborted) {
-        if (!(error instanceof PendingError)) {
-          this._computed.reject(error);
-        }
-      }
-    });
-  }
-  overwrite(promise) {
-    if (this._finished) throw new Error("[PicoFlow] AsyncResolver: Can't overwrite a settled resolver");
-    if (this._aborted) throw new Error("[PicoFlow] AsyncResolver: Can't overwrite an aborted resolver");
-    this._iteration++;
-    const currentIteration = this._iteration;
-    promise.then((value) => {
-      if (this._iteration === currentIteration && !this._aborted) this._computed.resolve(value);
-    }).catch((error) => {
-      if (this._iteration === currentIteration && !this._aborted) {
-        this._computed.reject(error);
-      }
-    });
-  }
-  abort() {
-    this._aborted = true;
-  }
-}
-
-class AsyncScheduler {
-  _compute;
-  _resolver;
-  _onResolve;
-  _onReject;
-  _settled = Promise.withResolvers();
-  _disposed = false;
-  constructor(compute, onResolve, onReject) {
-    this._compute = compute;
-    this._onResolve = onResolve;
-    this._onReject = onReject;
-    this._resolver = new AsyncResolver(compute);
-    this._attachHandlers(this._resolver);
-  }
-  get settled() {
-    if (this._disposed) throw new PicoFlowDisposedError("[PicoFlow] ComputationScheduler is disposed");
-    return this._settled.promise;
-  }
-  get disposed() {
-    return this._disposed;
-  }
-  overwrite(promise) {
-    if (this._disposed) throw new PicoFlowDisposedError("[PicoFlow] ComputationScheduler is disposed");
-    if (this._resolver.finished) {
-      this._resolver = new AsyncResolver(this._compute);
-      this._settled = Promise.withResolvers();
-      this._attachHandlers(this._resolver);
-    }
-    this._resolver.overwrite(promise);
-  }
-  compute() {
-    if (this._disposed) throw new PicoFlowDisposedError("[PicoFlow] ComputationScheduler is disposed");
-    if (this._resolver.finished) {
-      this._resolver = new AsyncResolver(this._compute);
-      this._settled = Promise.withResolvers();
-      this._attachHandlers(this._resolver);
-    }
-    this._resolver.compute();
-  }
-  _attachHandlers(resolver) {
-    resolver.computed.then((value) => {
-      if (this._disposed) return;
-      this._onResolve(value);
-    }).catch((error) => {
-      if (this._disposed) return;
-      this._onReject(error);
-    }).finally(() => this._settled.resolve());
-  }
-  dispose() {
-    this._resolver.abort();
-    this._disposed = true;
-  }
-}
-
-class SyncResolver {
-  _compute;
-  _aborted = false;
-  _finished = false;
-  _onValue;
-  _onError;
-  constructor(compute, onValue, onError) {
-    this._compute = compute;
-    this._onValue = onValue;
-    this._onError = onError;
-  }
-  get aborted() {
-    return this._aborted;
-  }
-  get finished() {
-    return this._finished;
-  }
-  compute() {
-    if (this._finished) throw new Error("[PicoFlow] SyncResolver: Can't restart a settled resolver");
-    if (this._aborted) throw new Error("[PicoFlow] SyncResolver: Can't restart an aborted resolver");
-    try {
-      const value = this._compute();
-      if (!this._finished && !this._aborted) {
-        this._finished = true;
-        this._onValue(value);
-      }
-    } catch (error) {
-      if (!this._finished && !this._aborted) {
-        if (!(error instanceof PendingError)) {
-          this._finished = true;
-          this._onError(error);
-        }
-      }
-    }
-  }
-  overwrite(value) {
-    if (this._finished) throw new Error("[PicoFlow] SyncResolver: Can't overwrite a settled resolver");
-    if (this._aborted) throw new Error("[PicoFlow] SyncResolver: Can't overwrite an aborted resolver");
-    this._finished = true;
-    this._onValue(value);
-  }
-  abort() {
-    this._aborted = true;
-  }
-}
-
-class SyncScheduler {
-  _compute;
-  _resolver;
-  _onResolve;
-  _onReject;
-  _settled = Promise.withResolvers();
-  _disposed = false;
-  constructor(compute, onResolve, onReject) {
-    this._compute = compute;
-    this._onResolve = (value) => {
-      onResolve(value);
-      this._settled.resolve();
-    };
-    this._onReject = (error) => {
-      onReject(error);
-      this._settled.resolve();
-    };
-    this._resolver = new SyncResolver(compute, this._onResolve, this._onReject);
-  }
-  get settled() {
-    return this._settled.promise;
-  }
-  overwrite(value) {
-    if (this._disposed) throw new PicoFlowDisposedError("[PicoFlow] ComputationScheduler is disposed");
-    if (this._resolver.finished) {
-      this._settled = Promise.withResolvers();
-      this._resolver = new SyncResolver(this._compute, this._onResolve, this._onReject);
-    }
-    this._resolver.overwrite(value);
-  }
-  compute() {
-    if (this._disposed) throw new PicoFlowDisposedError("[PicoFlow] ComputationScheduler is disposed");
-    if (this._resolver.finished) {
-      this._settled = Promise.withResolvers();
-      this._resolver = new SyncResolver(this._compute, this._onResolve, this._onReject);
-    }
-    this._resolver.compute();
-  }
-  dispose() {
-    this._resolver.abort();
-    this._disposed = true;
-  }
-}
-
-class EffectNode extends Observer {
-  _data;
-  _onData;
-  _onError;
-  _onPending;
-  /** True while this effect is already waiting in the effect queue for the next flush. */
-  _queued = false;
-  /** Guards the single coalesced bump of _notifyEpoch while _queued during one sync turn. */
-  _coalescedWhileQueued = false;
-  /** Monotonic count of notifications that must eventually be executed. */
-  _notifyEpoch = 0;
-  /** How many notification epochs have been executed so far. */
-  _executedEpoch = 0;
-  /** Callbacks registered via {@link onDispose}, run once after dispose() tears down the graph edges. */
-  _disposeListeners = [];
-  constructor(data, onData, onError, onPending) {
-    super();
-    this._data = data;
-    this._onData = onData;
-    this._onError = onError;
-    this._onPending = onPending;
-    this._notifyEpoch = 1;
-    this.execute();
-  }
-  /**
-   * Registers a callback to run once this effect is disposed, after the graph edges are torn
-   * down. Lets a caller that wraps an effect (e.g. {@link ActionNode.subscribe}) attach its own
-   * teardown without patching `dispose` on the returned instance (A2-ARCH-8).
-   * @internal
-   */
-  onDispose(fn) {
-    this._disposeListeners.push(fn);
-  }
-  dispose() {
-    super.dispose();
-    this._disposeListeners.forEach((fn) => {
-      fn();
-    });
-  }
-  notify() {
-    if (this._disposed) throw this._disposedError();
-    if (this._queued) {
-      if (!this._coalescedWhileQueued) {
-        this._coalescedWhileQueued = true;
-        if (ExecutionStack.pastSyncTurn) {
-          this._notifyEpoch++;
-        }
-      }
-      return;
-    }
-    this._notifyEpoch++;
-    this._queued = true;
-    ExecutionStack.scheduleCoalesceReset(() => {
-      this._coalescedWhileQueued = false;
-    });
-    ExecutionStack.pushEffect(this);
-  }
-  execute() {
-    this._queued = false;
-    if (this._disposed) {
-      this._executedEpoch = this._notifyEpoch;
-      return;
-    }
-    if (this._dependencyDisposed) {
-      this._dependencyDisposed = false;
-      this._executedEpoch = this._notifyEpoch;
-      return;
-    }
-    const targetEpoch = this._notifyEpoch;
-    while (this._executedEpoch < targetEpoch) {
-      this._executedEpoch++;
-      if (this._disposed) {
-        this._executedEpoch = this._notifyEpoch;
-        return;
-      }
-      if (this._dependencyDisposed) {
-        this._dependencyDisposed = false;
-        this._executedEpoch = this._notifyEpoch;
-        return;
-      }
-      try {
-        this.clearDependencies();
-        const data = this._data(this);
-        this._onData(data);
-      } catch (error) {
-        if (error instanceof PendingError) {
-          this._onPending?.();
-        } else {
-          if (this._onError) {
-            this._onError(error instanceof Error ? error : new Error(String(error)));
-          } else {
-            throw error;
-          }
-        }
-      }
-    }
-  }
-}
-
-const PICOFLOW_VALUE_NODE = /* @__PURE__ */ Symbol.for("picoflow.node");
-class ValueNode extends Node {
-  [PICOFLOW_VALUE_NODE] = true;
-  _value;
-  _error;
-  /** Builds the "unreachable state" error, naming the primitive when a `name` was given at creation. */
-  _internalError() {
-    return new PicoFlowInternalError(
-      this._name ? `[PicoFlow] Internal error (${this._name})` : "[PicoFlow] Internal error"
-    );
-  }
-  /**
-   * Hook called just before a tracked read throws `PendingError`, i.e. a dependent registered while
-   * this node is mid-flight and has no other way to learn the computation later settled (A2-PERF-4).
-   * No-op by default; overridden by {@link ValueAsyncNode} to know when its own post-resolve
-   * `notifyDependents()` call cannot be skipped even if the resolved value is unchanged.
-   */
-  _markPendingRead() {
-  }
-  watch(tracker) {
-    if (this.disposed) throw this._disposedError();
-    super.watch(tracker);
-    switch (this.status) {
-      case "resolved":
-        return;
-      case "error":
-        throw this._error;
-      case "pending": {
-        this._markPendingRead();
-        throw new PendingError(this._scheduler.settled);
-      }
-      case "dirty": {
-        this.execute();
-        switch (this.status) {
-          case "pending":
-            this._markPendingRead();
-            throw new PendingError(this._scheduler.settled);
-          case "resolved":
-            return;
-          case "error":
-            throw this._error;
-          case "dirty": {
-            throw this._internalError();
-          }
-        }
-      }
-    }
-  }
-  notify() {
-    if (this.disposed) throw this._disposedError();
-    if (this.status === "dirty") return;
-    if (this.status === "pending") {
-      ExecutionStack.pushPending(this);
-    }
-    this.status = "dirty";
-    this.notifyDependents();
-  }
-  dispose() {
-    super.dispose();
-    this._scheduler.dispose();
-  }
-  get(tracker) {
-    if (this.disposed) throw this._disposedError();
-    super.watch(tracker);
-    switch (this.status) {
-      case "resolved":
-        return this._value;
-      case "error":
-        throw this._error;
-      case "pending": {
-        this._markPendingRead();
-        throw new PendingError(this._scheduler.settled);
-      }
-      case "dirty": {
-        this.execute();
-        switch (this.status) {
-          case "resolved":
-            return this._value;
-          case "error":
-            throw this._error;
-          case "pending": {
-            this._markPendingRead();
-            throw new PendingError(this._scheduler.settled);
-          }
-          case "dirty": {
-            throw this._internalError();
-          }
-        }
-      }
-    }
-  }
-  async pick() {
-    if (this.disposed) throw this._disposedError();
-    switch (this.status) {
-      case "resolved":
-        return this._value;
-      case "pending": {
-        await this._scheduler.settled;
-        if (this.status === "resolved") return this._value;
-        if (this.status === "error") throw this._error;
-        throw this._internalError();
-      }
-      case "error":
-        throw this._error;
-      case "dirty": {
-        this.execute();
-        switch (this.status) {
-          case "resolved":
-            return this._value;
-          case "pending": {
-            await this._scheduler.settled;
-            if (this.status === "resolved") return this._value;
-            if (this.status === "error") throw this._error;
-            throw this._internalError();
-          }
-          case "error":
-            throw this._error;
-          case "dirty": {
-            throw this._internalError();
-          }
-        }
-      }
-    }
-  }
-  execute() {
-    if (this.disposed) return;
-    this.clearDependencies();
-    this.status = "pending";
-    this._scheduler.compute();
-  }
-  subscribe(onValue, onError, onPending) {
-    if (this.disposed) throw this._disposedError();
-    const effect = new EffectNode((t) => this.get(t), onValue, onError, onPending);
-    return effect;
-  }
-}
-
-class ValueAsyncNode extends ValueNode {
-  _scheduler;
-  _compute;
-  /** Set by {@link ValueNode._markPendingRead} when a dependent registers while this node is mid-flight. */
-  _hasPendingReader = false;
-  /**
-   * True only while the in-flight computation was started by `set()`, which already ran its own
-   * eager `notifyDependents()` cascade before this resolution. `refresh()` and a recompute pulled
-   * lazily after an upstream `notify()` have no such pre-cascade — for them, `_onResolve`'s own
-   * `notifyDependents()` call is the only notification, so it must never be skipped (A2-PERF-4).
-   */
-  _pendingFromSet = false;
-  constructor(promiseOrCompute, name) {
-    super(name);
-    if (typeof promiseOrCompute === "function") {
-      this._compute = () => promiseOrCompute(this, this._value);
-    } else {
-      this._compute = () => promiseOrCompute;
-    }
-    this.status = "dirty";
-    this._scheduler = new AsyncScheduler(
-      () => this._compute(),
-      (value) => this._onResolve(value),
-      (error) => this._onReject(error)
-    );
-  }
-  _onResolve(value) {
-    if (this.disposed) return;
-    const changed = value !== this._value;
-    const hadPendingReader = this._hasPendingReader;
-    const pendingFromSet = this._pendingFromSet;
-    this._hasPendingReader = false;
-    this._pendingFromSet = false;
-    this.status = "resolved";
-    this._value = value;
-    this._error = void 0;
-    if (changed || hadPendingReader || !pendingFromSet) this.notifyDependents();
-  }
-  _markPendingRead() {
-    this._hasPendingReader = true;
-  }
-  _onReject(error) {
-    if (this.disposed) return;
-    this.status = "error";
-    this._error = error;
-    this.notifyDependents();
-  }
-  set(promiseOrUpdater) {
-    if (this.disposed) throw this._disposedError();
-    if (typeof promiseOrUpdater === "function") {
-      const updater = promiseOrUpdater;
-      switch (this.status) {
-        case "resolved": {
-          this.status = "pending";
-          this._pendingFromSet = true;
-          this._scheduler.overwrite(updater(this._value));
-          this.notifyDependents();
-          return;
-        }
-        case "pending":
-        case "error":
-        case "dirty": {
-          this.status = "pending";
-          this._pendingFromSet = true;
-          this._scheduler.overwrite(updater(this._value));
-          this.notifyDependents();
-          return;
-        }
-      }
-    } else {
-      this.status = "pending";
-      this._pendingFromSet = true;
-      const promise = promiseOrUpdater;
-      this._scheduler.overwrite(promise);
-      this.notifyDependents();
-    }
-  }
-  refresh() {
-    if (this.disposed) throw this._disposedError();
-    this.execute();
-  }
-}
-
-function constantAsync(valueOrInitializer, options) {
-  return new ValueAsyncNode(valueOrInitializer, options?.name);
-}
-
-function derivationAsync(compute, options) {
-  return new ValueAsyncNode(compute, options?.name);
-}
-
-function stateAsync(valueOrInitializer, options) {
-  return new ValueAsyncNode(valueOrInitializer, options?.name);
-}
-
-function writableDerivationAsync(compute, options) {
-  return new ValueAsyncNode(compute, options?.name);
-}
-
-class ValueSyncNode extends ValueNode {
-  _scheduler;
-  _compute;
-  constructor(valueOrCompute, name) {
-    super(name);
-    if (typeof valueOrCompute === "function") {
-      this._compute = () => valueOrCompute(this, this._value);
-    } else {
-      this._compute = () => valueOrCompute;
-    }
-    this.status = "dirty";
-    this._scheduler = new SyncScheduler(
-      () => this._compute(),
-      (value) => this._onResolve(value),
-      (error) => this._onReject(error)
-    );
-    if (typeof valueOrCompute !== "function") {
-      this._scheduler.compute();
-    }
-  }
-  _onResolve(value) {
-    this.status = "resolved";
-    this._value = value;
-    this._error = void 0;
-  }
-  _onReject(error) {
-    this.status = "error";
-    this._error = error;
-  }
-  set(valueOrUpdater) {
-    if (this.disposed) throw this._disposedError();
-    if (typeof valueOrUpdater === "function") {
-      const updater = valueOrUpdater;
-      switch (this.status) {
-        case "resolved": {
-          const nextValue = updater(this._value);
-          if (nextValue === this._value) return;
-          this.status = "pending";
-          this._scheduler.overwrite(nextValue);
-          this.notifyDependents();
-          return;
-        }
-        case "pending":
-        case "error":
-        case "dirty": {
-          const nextValue = updater(this._value);
-          this.status = "pending";
-          this._scheduler.overwrite(nextValue);
-          this.notifyDependents();
-          return;
-        }
-      }
-    } else {
-      const nextValue = valueOrUpdater;
-      switch (this.status) {
-        case "resolved": {
-          if (nextValue === this._value) return;
-          this.status = "pending";
-          this._scheduler.overwrite(nextValue);
-          this.notifyDependents();
-          return;
-        }
-        case "pending":
-        case "error":
-        case "dirty": {
-          this.status = "pending";
-          this._scheduler.overwrite(nextValue);
-          this.notifyDependents();
-          return;
-        }
-      }
-    }
-  }
-  refresh() {
-    if (this.disposed) throw this._disposedError();
-    const currentValue = this._value;
-    const currentStatus = this.status;
-    this.execute();
-    switch (this.status) {
-      case "resolved": {
-        const nextValue = this._value;
-        if (nextValue === currentValue && currentStatus === this.status) return;
-        this.notifyDependents();
-        return;
-      }
-      case "error":
-      case "pending":
-      case "dirty": {
-        this.notifyDependents();
-        return;
-      }
-    }
-  }
-}
-
-class ActionNode extends ValueSyncNode {
-  _slots = /* @__PURE__ */ new Set();
-  _enqueueForSubscribers(action) {
-    for (const slot of this._slots) {
-      slot.queue.push(action);
-    }
-  }
-  set(valueOrUpdater) {
-    if (this.disposed) throw this._disposedError();
-    if (typeof valueOrUpdater === "function") {
-      const updater = valueOrUpdater;
-      const nextValue2 = updater(this._value);
-      if (this.status === "resolved" && nextValue2 === this._value) return;
-      this._enqueueForSubscribers(nextValue2);
-      super.set(updater);
-      return;
-    }
-    const nextValue = valueOrUpdater;
-    if (this.status === "resolved" && nextValue === this._value) return;
-    this._enqueueForSubscribers(nextValue);
-    super.set(nextValue);
-  }
-  subscribe(onValue, onError, onPending) {
-    if (this.disposed) throw this._disposedError();
-    const slot = { queue: [] };
-    this._slots.add(slot);
-    const effect = new EffectNode(
-      (tracker) => {
-        this.watch(tracker);
-        if (slot.queue.length === 0) {
-          return [this.get(tracker)];
-        }
-        return slot.queue.splice(0);
-      },
-      (actions) => {
-        for (const action of actions) {
-          onValue(action);
-        }
-      },
-      onError,
-      onPending
-    );
-    effect.onDispose(() => {
-      this._slots.delete(slot);
-    });
-    return effect;
-  }
-  dispose() {
-    this._slots.clear();
-    super.dispose();
-  }
-}
-
-class ArrayNode extends ValueSyncNode {
-  $lastAction;
-  constructor(value = [], name) {
-    super(value, name);
-    this.$lastAction = new ActionNode({
-      type: "set",
-      setItems: value,
-      clearedItems: []
-    });
-  }
-  get(tracker) {
-    const values = super.get(tracker);
-    return [...values];
-  }
-  async pick() {
-    const values = await super.pick();
-    return [...values];
-  }
-  get length() {
-    if (this.disposed) throw this._disposedError();
-    return this._value.length;
-  }
-  set(itemsOrUpdater) {
-    if (this.disposed) throw this._disposedError();
-    const previousValue = this._value;
-    super.set(itemsOrUpdater);
-    this.$lastAction.set({
-      type: "set",
-      setItems: this._value,
-      clearedItems: previousValue
-    });
-    return previousValue;
-  }
-  update(index, item) {
-    if (this.disposed) throw this._disposedError();
-    if (index < 0 || index >= this._value.length || !Number.isInteger(index)) {
-      throw new Error("[PicoFlow] Index out of bounds");
-    }
-    const previousValue = this._value[index];
-    this._value[index] = item;
-    this.notifyDependents();
-    this.$lastAction.set({
-      type: "update",
-      index,
-      setItem: item,
-      clearedItem: previousValue
-    });
-    return previousValue;
-  }
-  push(item) {
-    if (this.disposed) throw this._disposedError();
-    this._value.push(item);
-    this.notifyDependents();
-    this.$lastAction.set({ type: "push", addedItem: item });
-  }
-  pop() {
-    if (this.disposed) throw this._disposedError();
-    if (this._value.length === 0) return void 0;
-    const item = this._value.pop();
-    this.notifyDependents();
-    this.$lastAction.set({ type: "pop", removedItem: item });
-    return item;
-  }
-  unshift(item) {
-    if (this.disposed) throw this._disposedError();
-    this._value.unshift(item);
-    this.notifyDependents();
-    this.$lastAction.set({ type: "unshift", addedItem: item });
-  }
-  shift() {
-    if (this.disposed) throw this._disposedError();
-    if (this._value.length === 0) return void 0;
-    const item = this._value.shift();
-    this.notifyDependents();
-    this.$lastAction.set({ type: "shift", removedItem: item });
-    return item;
-  }
-  splice(start, deleteCount, ...newItems) {
-    if (this.disposed) throw this._disposedError();
-    const items = this._value.splice(start, deleteCount, ...newItems);
-    this.notifyDependents();
-    this.$lastAction.set({
-      type: "splice",
-      start,
-      deleteCount,
-      addedItems: newItems,
-      removedItems: items
-    });
-    return items;
-  }
-  clear() {
-    if (this.disposed) throw this._disposedError();
-    const previousValue = [...this._value];
-    this._value = [];
-    this.notifyDependents();
-    this.$lastAction.set({ type: "clear", clearedItems: previousValue });
-    return previousValue;
-  }
-  dispose() {
-    super.dispose();
-    if (!this.$lastAction.disposed) {
-      this.$lastAction.dispose();
-    }
-    this._value = [];
-  }
-}
-
-function array(initial, options) {
-  return new ArrayNode(initial, options?.name);
-}
-
-class MapNode extends ValueSyncNode {
-  $lastAction;
-  constructor(value = /* @__PURE__ */ new Map(), name) {
-    super(value, name);
-    this.$lastAction = new ActionNode({
-      type: "set",
-      setMap: value,
-      clearedMap: /* @__PURE__ */ new Map()
-    });
-  }
-  add(key, value) {
-    if (this.disposed) throw this._disposedError();
-    if (this._value.has(key)) {
-      throw new Error("[PicoFlow] Key already exists");
-    }
-    this._value.set(key, value);
-    this.notifyDependents();
-    this.$lastAction.set({ type: "add", key, addedValue: value });
-  }
-  update(key, value) {
-    if (this.disposed) throw this._disposedError();
-    if (!this._value.has(key)) throw new Error("[PicoFlow] Key does not exist");
-    const previousValue = this._value.get(key);
-    this._value.set(key, value);
-    this.notifyDependents();
-    this.$lastAction.set({
-      type: "update",
-      key,
-      setValue: value,
-      clearedValue: previousValue
-    });
-    return previousValue;
-  }
-  delete(key) {
-    if (this.disposed) throw this._disposedError();
-    if (!this._value.has(key)) throw new Error("[PicoFlow] Key does not exist");
-    const value = this._value.get(key);
-    this._value.delete(key);
-    this.notifyDependents();
-    this.$lastAction.set({ type: "delete", key, removedValue: value });
-    return value;
-  }
-  set(mapOrUpdater) {
-    if (this.disposed) throw this._disposedError();
-    const previousValue = this._value;
-    super.set(mapOrUpdater);
-    this.$lastAction.set({
-      type: "set",
-      setMap: this._value,
-      clearedMap: previousValue
-    });
-    return previousValue;
-  }
-  clear() {
-    if (this.disposed) throw this._disposedError();
-    const previousValue = this._value;
-    this._value = /* @__PURE__ */ new Map();
-    this.notifyDependents();
-    this.$lastAction.set({ type: "clear", clearedMap: previousValue });
-    return previousValue;
-  }
-  dispose() {
-    super.dispose();
-    if (!this.$lastAction.disposed) {
-      this.$lastAction.dispose();
-    }
-    this._value.clear();
-  }
-}
-
-function map(initial, options) {
-  if (initial instanceof Map) {
-    return new MapNode(initial, options?.name);
-  }
-  return new MapNode(new Map(initial ? Object.entries(initial) : []), options?.name);
-}
-
-function subscribe(data, onData, onError, onPending) {
-  return new EffectNode(data, onData, onError, onPending);
-}
-
-class SignalNode extends Observable {
-  subscribe(onTrigger, onError, onPending) {
-    if (this.disposed) throw this._disposedError();
-    const effect = new EffectNode((t) => this.watch(t), onTrigger, onError, onPending);
-    return effect;
-  }
-}
-
-function signal(options) {
-  return new SignalNode(options?.name);
-}
-
-function constant(initializer, options) {
-  return new ValueSyncNode(initializer, options?.name);
-}
-
-function derivation(compute, options) {
-  return new ValueSyncNode(compute, options?.name);
-}
-
-function state(valueOrInitializer, options) {
-  return new ValueSyncNode(valueOrInitializer, options?.name);
-}
-
-function writableDerivation(compute, options) {
-  return new ValueSyncNode(compute, options?.name);
-}
-
-function describeFlowInput(value) {
-  if (value === null) return "null";
-  if (typeof value === "object") {
-    const name = value.constructor?.name;
-    return name ? `object (${name})` : "object";
-  }
-  return typeof value;
-}
-function isValueNode(flow) {
-  return typeof flow === "object" && flow !== null && PICOFLOW_VALUE_NODE in flow;
-}
-function fromNode(node, options) {
-  const [resource, { refetch }] = createResource(() => node.pick());
-  let fx;
-  onMount(() => {
-    fx = subscribe(
-      // data
-      (t) => node.get(t),
-      // onData
-      () => {
-        refetch();
-      },
-      // onError
-      () => {
-        refetch();
-      },
-      // onPending
-      () => {
-        refetch();
-      }
-    );
-  });
-  createEffect(() => {
-    resource.error ?? resource();
-    resetErrorBoundaries();
-  });
-  onCleanup(() => {
-    fx.dispose();
-    if (options?.disposeNode && !node.disposed) {
-      node.dispose();
-    }
-  });
-  return resource;
-}
-function fromGetter(getter) {
-  const derivation = new ValueSyncNode((t) => {
-    return getter(t);
-  });
-  return fromNode(derivation, { disposeNode: true });
-}
-function from(flow) {
-  if (isValueNode(flow)) {
-    return fromNode(flow);
-  }
-  if (typeof flow === "function") {
-    return fromGetter(flow);
-  }
-  throw new Error(`[PicoFlow] from(): expected a FlowValue or getter function, received ${describeFlowInput(flow)}`);
-}
-
-export { PicoFlowCycleError, PicoFlowDisposedError, PicoFlowError, PicoFlowInternalError, array, constant, constantAsync, derivation, derivationAsync, from, isDisposable, map, onFlushError, signal, state, stateAsync, subscribe, writableDerivation, writableDerivationAsync };