@ersbeth/picoflow 2.0.3 → 2.2.0

package/dist/picoflow.js

@@ -1,5 +1,242 @@
 import { createResource, onMount, createEffect, resetErrorBoundaries, onCleanup } from 'solid-js';
 
+class Disposable {
+  _disposed = false;
+  get disposed() {
+    return this._disposed;
+  }
+}
+
+class ExecutionStack {
+  static _MAX_FLUSH_STEPS = 1e4;
+  static _pendingQueue = [];
+  static _effectQueue = [];
+  static _executionScheduled;
+  static _coalesceResetScheduled = false;
+  /** 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) {
+    if (ExecutionStack._coalesceResetScheduled) return;
+    ExecutionStack._coalesceResetScheduled = true;
+    queueMicrotask(() => {
+      ExecutionStack._pastSyncTurn = true;
+      ExecutionStack._coalesceResetScheduled = false;
+      onReset();
+    });
+  }
+  /** @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 Error("[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 {
+  _dependencies = /* @__PURE__ */ new Set();
+  _dependents = /* @__PURE__ */ new Set();
+  _status = "resolved";
+  get status() {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    return this._status;
+  }
+  set status(status) {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this._status = status;
+  }
+  registerDependency(dependency) {
+    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this._dependencies.add(dependency);
+    dependency.registerDependent(this);
+  }
+  unregisterDependency(dependency) {
+    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this._dependencies.delete(dependency);
+    dependency.unregisterDependent(this);
+  }
+  clearDependencies() {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this._dependencies.forEach((dependency) => {
+      dependency.unregisterDependent(this);
+    });
+    this._dependencies.clear();
+  }
+  registerDependent(dependent) {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this._dependents.add(dependent);
+  }
+  unregisterDependent(dependent) {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this._dependents.delete(dependent);
+  }
+  markDependencyDisposed() {
+  }
+  notifyDependents() {
+    if (this.disposed) return;
+    this._dependents.forEach((dependent) => {
+      dependent.notify();
+    });
+  }
+  watch(tracker) {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    tracker.registerDependency(this);
+  }
+  trigger() {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this.notifyDependents();
+  }
+  dispose() {
+    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    Array.from(this._dependents).forEach((dependant) => {
+      dependant.markDependencyDisposed();
+      dependant.unregisterDependency(this);
+      this.unregisterDependent(dependant);
+    });
+    Array.from(this._dependencies).forEach((dependency) => {
+      this.unregisterDependency(dependency);
+    });
+    this._disposed = true;
+  }
+}
+
+class Observable extends Disposable {
+  _dependents = /* @__PURE__ */ new Set();
+  _status = "resolved";
+  get status() {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    return this._status;
+  }
+  set status(status) {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this._status = status;
+  }
+  registerDependent(dependent) {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this._dependents.add(dependent);
+  }
+  unregisterDependent(dependent) {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this._dependents.delete(dependent);
+  }
+  notifyDependents() {
+    if (this.disposed) return;
+    this._dependents.forEach((dependent) => {
+      dependent.notify();
+    });
+  }
+  watch(tracker) {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    tracker.registerDependency(this);
+  }
+  trigger() {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this.notifyDependents();
+  }
+  dispose() {
+    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    Array.from(this._dependents).forEach((dependant) => {
+      dependant.markDependencyDisposed();
+      dependant.unregisterDependency(this);
+      this.unregisterDependent(dependant);
+    });
+    this._disposed = true;
+  }
+}
+
+class Observer extends Disposable {
+  _dependencies = /* @__PURE__ */ new Set();
+  /** 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 new Error("[PicoFlow] Primitive is disposed");
+    this._dependencies.add(dependency);
+    dependency.registerDependent(this);
+  }
+  unregisterDependency(dependency) {
+    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this._dependencies.delete(dependency);
+    dependency.unregisterDependent(this);
+  }
+  clearDependencies() {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this._dependencies.forEach((dependency) => {
+      dependency.unregisterDependent(this);
+    });
+    this._dependencies.clear();
+  }
+  dispose() {
+    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    Array.from(this._dependencies).forEach((dependency) => {
+      this.unregisterDependency(dependency);
+    });
+    this._disposed = true;
+  }
+}
+
+function onFlushError(handler) {
+  ExecutionStack.setFlushErrorHandler(handler);
+}
+
 function isDisposable(obj) {
   return obj !== null && obj !== void 0 && typeof obj.dispose === "function";
 }
@@ -7,7 +244,7 @@ function isDisposable(obj) {
 class PendingError extends Error {
   pendingPromise;
   constructor(promise) {
-    super("[PicoFlow] PendingResolver pending");
+    super("[PicoFlow] Computation is pending");
     this.name = "PendingError";
     this.pendingPromise = promise;
   }
@@ -36,8 +273,8 @@ class AsyncResolver {
     return this._finished;
   }
   compute() {
-    if (this._finished) throw new Error("[Picoflow] PendingResolver: Can't restart a settled resolver");
-    if (this._aborted) throw new Error("[Picoflow] PendingResolver: Can't restart an aborted resolver");
+    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) => {
@@ -51,8 +288,8 @@ class AsyncResolver {
     });
   }
   overwrite(promise) {
-    if (this._finished) throw new Error("[Picoflow] PendingResolver: Can't overwrite a settled resolver");
-    if (this._aborted) throw new Error("[Picoflow] PendingResolver: Can't overwrite an aborted resolver");
+    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) => {
@@ -81,7 +318,7 @@ class AsyncScheduler {
     this._onResolve = onResolve;
     this._onReject = onReject;
     this._resolver = new AsyncResolver(compute);
-    this._resolver.computed.then(this._onResolve).catch(this._onReject).finally(() => this._settled.resolve());
+    this._attachHandlers(this._resolver);
   }
   get settled() {
     if (this._disposed) throw new Error("[PicoFlow] ComputationScheduler is disposed");
@@ -95,7 +332,7 @@ class AsyncScheduler {
     if (this._resolver.finished) {
       this._resolver = new AsyncResolver(this._compute);
       this._settled = Promise.withResolvers();
-      this._resolver.computed.then(this._onResolve).catch(this._onReject).finally(() => this._settled.resolve());
+      this._attachHandlers(this._resolver);
     }
     this._resolver.overwrite(promise);
   }
@@ -104,10 +341,19 @@ class AsyncScheduler {
     if (this._resolver.finished) {
       this._resolver = new AsyncResolver(this._compute);
       this._settled = Promise.withResolvers();
-      this._resolver.computed.then(this._onResolve).catch(this._onReject).finally(() => this._settled.resolve());
+      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;
@@ -116,7 +362,6 @@ class AsyncScheduler {
 
 class SyncResolver {
   _compute;
-  _iteration = 0;
   _aborted = false;
   _finished = false;
   _onValue;
@@ -133,18 +378,16 @@ class SyncResolver {
     return this._finished;
   }
   compute() {
-    if (this._finished) throw new Error("[Picoflow] PendingResolver: Can't restart a settled resolver");
-    if (this._aborted) throw new Error("[Picoflow] PendingResolver: Can't restart an aborted resolver");
-    this._iteration++;
-    const currentIteration = this._iteration;
+    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._iteration === currentIteration && !this._aborted) {
+      if (!this._finished && !this._aborted) {
         this._finished = true;
         this._onValue(value);
       }
     } catch (error) {
-      if (this._iteration === currentIteration && !this._aborted) {
+      if (!this._finished && !this._aborted) {
         if (!(error instanceof PendingError)) {
           this._finished = true;
           this._onError(error);
@@ -153,17 +396,12 @@ class SyncResolver {
     }
   }
   overwrite(value) {
-    if (this._finished) throw new Error("[Picoflow] PendingResolver: Can't overwrite a settled resolver");
-    if (this._aborted) throw new Error("[Picoflow] PendingResolver: Can't overwrite an aborted resolver");
-    this._iteration++;
-    const currentIteration = this._iteration;
-    if (this._iteration === currentIteration && !this._aborted) {
-      this._finished = true;
-      this._onValue(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._iteration++;
     this._aborted = true;
   }
 }
@@ -212,230 +450,91 @@ class SyncScheduler {
   }
 }
 
-class Disposable {
-  _disposed = false;
-  get disposed() {
-    return this._disposed;
-  }
-  dispose() {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._disposed = true;
-  }
-}
-
-class ExecutionStack {
-  static _pendingQueue = [];
-  static _effectQueue = [];
-  static _executionScheduled;
-  static pushPending(node) {
-    ExecutionStack._scheduleExecution();
-    ExecutionStack._pendingQueue.push(node);
-  }
-  static pushEffect(effect) {
-    ExecutionStack._scheduleExecution();
-    ExecutionStack._effectQueue.push(effect);
-  }
-  static _scheduleExecution() {
-    if (ExecutionStack._executionScheduled) return;
-    ExecutionStack._executionScheduled = new Promise((resolve) => {
-      setTimeout(() => {
-        ExecutionStack._executionScheduled = void 0;
-        ExecutionStack._execute();
-        resolve();
-      }, 0);
-    });
-  }
-  static _execute() {
-    ExecutionStack._pendingQueue.forEach((node) => {
-      node.execute();
-    });
-    ExecutionStack._pendingQueue.length = 0;
-    ExecutionStack._effectQueue.forEach((effect) => {
-      effect.execute();
-    });
-    ExecutionStack._effectQueue.length = 0;
-  }
-}
-
-class Node extends Disposable {
-  _dependencies = /* @__PURE__ */ new Set();
-  _dependents = /* @__PURE__ */ new Set();
-  _status = "resolved";
-  get status() {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    return this._status;
-  }
-  set status(status) {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._status = status;
-  }
-  registerDependency(dependency) {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._dependencies.add(dependency);
-    dependency.registerDependent(this);
-  }
-  unregisterDependency(dependency) {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._dependencies.delete(dependency);
-    dependency.unregisterDependent(this);
-  }
-  clearDependencies() {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._dependencies.forEach((dependency) => {
-      dependency.unregisterDependent(this);
-    });
-    this._dependencies.clear();
-  }
-  registerDependent(dependent) {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._dependents.add(dependent);
-  }
-  unregisterDependent(dependent) {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._dependents.delete(dependent);
-  }
-  notifyDependents() {
-    if (this.disposed) return;
-    this._dependents.forEach((dependent) => {
-      dependent.notify();
-    });
-  }
-  watch(tracker) {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    tracker.registerDependency(this);
-  }
-  trigger() {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this.notifyDependents();
-  }
-  notify() {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    if (this.status === "dirty") return;
-    this.status = "dirty";
-    this.notifyDependents();
-  }
-  dispose() {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    Array.from(this._dependents).forEach((dependant) => {
-      dependant.unregisterDependency(this);
-      this.unregisterDependent(dependant);
-    });
-    Array.from(this._dependencies).forEach((dependency) => {
-      this.unregisterDependency(dependency);
-    });
-    this._disposed = true;
-  }
-}
-
-class Observable extends Disposable {
-  _dependents = /* @__PURE__ */ new Set();
-  _status = "resolved";
-  get status() {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    return this._status;
-  }
-  set status(status) {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._status = status;
-  }
-  registerDependent(dependent) {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._dependents.add(dependent);
-  }
-  unregisterDependent(dependent) {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._dependents.delete(dependent);
-  }
-  notifyDependents() {
-    if (this.disposed) return;
-    this._dependents.forEach((dependent) => {
-      dependent.notify();
-    });
-  }
-  watch(tracker) {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    tracker.registerDependency(this);
-  }
-  trigger() {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this.notifyDependents();
-  }
-  dispose() {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    Array.from(this._dependents).forEach((dependant) => {
-      dependant.unregisterDependency(this);
-      this.unregisterDependent(dependant);
-    });
-    this._disposed = true;
-  }
-}
-
-class Observer extends Disposable {
-  _dependencies = /* @__PURE__ */ new Set();
-  registerDependency(dependency) {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._dependencies.add(dependency);
-    dependency.registerDependent(this);
-  }
-  unregisterDependency(dependency) {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._dependencies.delete(dependency);
-    dependency.unregisterDependent(this);
-  }
-  clearDependencies() {
-    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._dependencies.forEach((dependency) => {
-      dependency.unregisterDependent(this);
-    });
-    this._dependencies.clear();
-  }
-  dispose() {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    Array.from(this._dependencies).forEach((dependency) => {
-      this.unregisterDependency(dependency);
-    });
-    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;
   constructor(data, onData, onError, onPending) {
     super();
     this._data = data;
     this._onData = onData;
     this._onError = onError;
     this._onPending = onPending;
+    this._notifyEpoch = 1;
     this.execute();
   }
   notify() {
     if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    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() {
-    try {
-      if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-      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)));
+    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 {
-          throw error;
+          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;
   watch(tracker) {
@@ -570,12 +669,14 @@ class ValueAsyncNode extends ValueNode {
     );
   }
   _onResolve(value) {
+    if (this.disposed) return;
     this.status = "resolved";
     this._value = value;
     this._error = void 0;
     this.notifyDependents();
   }
   _onReject(error) {
+    if (this.disposed) return;
     this.status = "error";
     this._error = error;
     this.notifyDependents();
@@ -724,11 +825,66 @@ class ValueSyncNode extends ValueNode {
   }
 }
 
+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 new Error("[PicoFlow] Primitive is disposed");
+    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 new Error("[PicoFlow] Primitive is disposed");
+    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
+    );
+    const originalDispose = effect.dispose.bind(effect);
+    effect.dispose = () => {
+      this._slots.delete(slot);
+      originalDispose();
+    };
+    return effect;
+  }
+  dispose() {
+    this._slots.clear();
+    super.dispose();
+  }
+}
+
 class ArrayNode extends ValueSyncNode {
   $lastAction;
   constructor(value = []) {
     super(value);
-    this.$lastAction = new ValueSyncNode({
+    this.$lastAction = new ActionNode({
       type: "set",
       setItems: value,
       clearedItems: []
@@ -759,7 +915,7 @@ class ArrayNode extends ValueSyncNode {
   }
   update(index, item) {
     if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    if (index < 0 || index >= this._value.length) {
+    if (index < 0 || index >= this._value.length || !Number.isInteger(index)) {
       throw new Error("[PicoFlow] Index out of bounds");
     }
     const previousValue = this._value[index];
@@ -781,6 +937,7 @@ class ArrayNode extends ValueSyncNode {
   }
   pop() {
     if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    if (this._value.length === 0) return void 0;
     const item = this._value.pop();
     this.notifyDependents();
     this.$lastAction.set({ type: "pop", removedItem: item });
@@ -794,6 +951,7 @@ class ArrayNode extends ValueSyncNode {
   }
   shift() {
     if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    if (this._value.length === 0) return void 0;
     const item = this._value.shift();
     this.notifyDependents();
     this.$lastAction.set({ type: "shift", removedItem: item });
@@ -822,9 +980,9 @@ class ArrayNode extends ValueSyncNode {
   }
   dispose() {
     super.dispose();
-    this._value.forEach((item) => {
-      if (item instanceof Disposable) item.dispose();
-    });
+    if (!this.$lastAction.disposed) {
+      this.$lastAction.dispose();
+    }
     this._value = [];
   }
 }
@@ -837,7 +995,7 @@ class MapNode extends ValueSyncNode {
   $lastAction;
   constructor(value = /* @__PURE__ */ new Map()) {
     super(value);
-    this.$lastAction = new ValueSyncNode({
+    this.$lastAction = new ActionNode({
       type: "set",
       setMap: value,
       clearedMap: /* @__PURE__ */ new Map()
@@ -845,8 +1003,7 @@ class MapNode extends ValueSyncNode {
   }
   add(key, value) {
     if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    const previousValue = this._value.get(key);
-    if (previousValue) {
+    if (this._value.has(key)) {
       throw new Error("[PicoFlow] Key already exists");
     }
     this._value.set(key, value);
@@ -855,8 +1012,8 @@ class MapNode extends ValueSyncNode {
   }
   update(key, value) {
     if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    if (!this._value.has(key)) throw new Error("[PicoFlow] Key does not exist");
     const previousValue = this._value.get(key);
-    if (!previousValue) throw new Error("[PicoFlow] Key does not exist");
     this._value.set(key, value);
     this.notifyDependents();
     this.$lastAction.set({
@@ -869,8 +1026,8 @@ class MapNode extends ValueSyncNode {
   }
   delete(key) {
     if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    if (!this._value.has(key)) throw new Error("[PicoFlow] Key does not exist");
     const value = this._value.get(key);
-    if (value === void 0) throw new Error("[PicoFlow] Key does not exist");
     this._value.delete(key);
     this.notifyDependents();
     this.$lastAction.set({ type: "delete", key, removedValue: value });
@@ -897,9 +1054,9 @@ class MapNode extends ValueSyncNode {
   }
   dispose() {
     super.dispose();
-    this._value.forEach((item) => {
-      if (item instanceof Disposable) item.dispose();
-    });
+    if (!this.$lastAction.disposed) {
+      this.$lastAction.dispose();
+    }
     this._value.clear();
   }
 }
@@ -943,7 +1100,18 @@ function writableDerivation(compute) {
   return new ValueSyncNode(compute);
 }
 
-function fromNode(node) {
+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(() => {
@@ -968,23 +1136,28 @@ function fromNode(node) {
     resource.error ?? resource();
     resetErrorBoundaries();
   });
-  onCleanup(() => fx.dispose());
+  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);
+  return fromNode(derivation, { disposeNode: true });
 }
 function from(flow) {
-  if (flow instanceof ValueAsyncNode || flow instanceof ValueSyncNode) {
+  if (isValueNode(flow)) {
     return fromNode(flow);
   }
   if (typeof flow === "function") {
     return fromGetter(flow);
   }
-  throw new Error("Invalid flow type");
+  throw new Error(`[PicoFlow] from(): expected a FlowValue or getter function, received ${describeFlowInput(flow)}`);
 }
 
-export { array, constant, constantAsync, derivation, derivationAsync, from, isDisposable, map, signal, state, stateAsync, subscribe, writableDerivation, writableDerivationAsync };
+export { array, constant, constantAsync, derivation, derivationAsync, from, isDisposable, map, onFlushError, signal, state, stateAsync, subscribe, writableDerivation, writableDerivationAsync };