@ersbeth/picoflow 1.1.2 → 2.0.1

package/dist/picoflow.js

@@ -1,1650 +1,984 @@
-import { createSignal, createMemo, createResource, onMount, onCleanup } from 'solid-js';
+import { createResource, onMount, createEffect, resetErrorBoundaries, onCleanup } from 'solid-js';
 
 function isDisposable(obj) {
   return obj !== null && obj !== void 0 && typeof obj.dispose === "function";
 }
 
-class FlowGraph {
-  static _effectsQueue = [];
-  static _actionQueue = [];
-  static _processingActionQueue = false;
-  /**
-   * Resets all internal queues and processing state.
-   *
-   * @remarks
-   * Use this method primarily for testing scenarios where you need to ensure
-   * a clean state between test runs. It clears pending effects and queued
-   * operations.
-   *
-   * @example
-   * ```typescript
-   * beforeEach(() => {
-   *   FlowGraph.clear();
-   * });
-   * ```
-   *
-   * @public
-   */
-  static clear() {
-    FlowGraph._effectsQueue = [];
-    FlowGraph._actionQueue = [];
-    FlowGraph._processingActionQueue = false;
-  }
-  /**
-   * Queues a trigger notification for processing.
-   *
-   * @param notify - Function to call when the trigger is processed.
-   * @returns A promise that resolves after the trigger is processed.
-   *
-   * @remarks
-   * This method is used internally by reactive primitives to coordinate
-   * signal triggers. The promise resolves after all associated effects
-   * have been executed.
-   *
-   * @public
-   */
-  static requestTrigger(notify) {
-    const promiseWithResolvers = Promise.withResolvers();
-    FlowGraph._actionQueue.push({
-      ...promiseWithResolvers,
-      type: "trigger",
-      notify
-    });
-    FlowGraph._processActionQueue();
-    return promiseWithResolvers.promise;
-  }
-  /**
-   * Queues a read operation for processing.
-   *
-   * @param read - Function that performs the read operation.
-   * @returns A promise that resolves with the read value.
-   *
-   * @remarks
-   * This method is used internally by reactive primitives to coordinate
-   * read operations. The read function is executed and its result (or promise)
-   * is returned.
-   *
-   * @public
-   */
-  static requestRead(read) {
-    const promiseWithResolvers = Promise.withResolvers();
-    FlowGraph._actionQueue.push({
-      ...promiseWithResolvers,
-      type: "read",
-      read
-    });
-    FlowGraph._processActionQueue();
-    return promiseWithResolvers.promise;
-  }
-  /**
-   * Queues a write operation with update logic for processing.
-   *
-   * @param notify - Function to call if the update succeeds.
-   * @param update - Function that performs the update and returns whether
-   * it changed the value.
-   * @returns A promise that resolves after the write is processed.
-   *
-   * @remarks
-   * This method is used internally by reactive primitives to coordinate
-   * write operations. The update function is executed, and if it returns true
-   * (or a promise resolving to true), the notify function is called to
-   * trigger dependent effects.
-   *
-   * @public
-   */
-  static requestWrite(notify, update) {
-    const promiseWithResolvers = Promise.withResolvers();
-    FlowGraph._actionQueue.push({
-      ...promiseWithResolvers,
-      type: "write",
-      notify,
-      update
+class PendingError extends Error {
+  pendingPromise;
+  constructor(promise) {
+    super("[PicoFlow] PendingResolver 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;
     });
-    FlowGraph._processActionQueue();
-    return promiseWithResolvers.promise;
-  }
-  /**
-   * Queues effects for execution after the current operation completes.
-   *
-   * @param effects - Array of effects to queue for execution.
-   *
-   * @remarks
-   * This method is used internally by reactive primitives to schedule effect
-   * execution. Effects are executed after the current read/write/trigger
-   * operation completes, ensuring proper ordering of reactive updates.
-   *
-   * @public
-   */
-  static pushEffects(effects) {
-    FlowGraph._effectsQueue.push(...effects);
-  }
-  /** @internal */
-  static _processActionQueue = async () => {
-    if (FlowGraph._processingActionQueue) return;
-    FlowGraph._processingActionQueue = true;
-    while (FlowGraph._actionQueue.length > 0) {
-      const actionRequest = FlowGraph._actionQueue.shift();
-      if (!actionRequest) break;
-      if (actionRequest.type === "read") {
-        try {
-          const read = actionRequest.read();
-          let value;
-          if (read instanceof Promise) {
-            value = await read;
-          } else {
-            value = read;
-          }
-          actionRequest.resolve(value);
-        } catch (error) {
-          const safeError = error instanceof Error ? error : new Error(String(error));
-          actionRequest.reject(safeError);
+  }
+  get computed() {
+    return this._computed.promise;
+  }
+  get aborted() {
+    return this._aborted;
+  }
+  get finished() {
+    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;
+    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);
         }
-        continue;
       }
-      if (actionRequest.type === "write") {
-        try {
-          const updateResult = actionRequest.update();
-          let updated = false;
-          if (updateResult instanceof Promise) {
-            updated = await updateResult;
-          } else {
-            updated = updateResult;
-          }
-          if (!updated) {
-            actionRequest.resolve();
-            continue;
-          }
-          actionRequest.notify();
-        } catch (error) {
-          const safeError = error instanceof Error ? error : new Error(String(error));
-          actionRequest.reject(safeError);
-          continue;
-        }
+    });
+  }
+  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");
+    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);
       }
-      if (actionRequest.type === "trigger") {
-        actionRequest.notify();
+    });
+  }
+  abort() {
+    this._iteration++;
+    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._resolver.computed.then(this._onResolve).catch(this._onReject).finally(() => this._settled.resolve());
+  }
+  get settled() {
+    if (this._disposed) throw new Error("[PicoFlow] ComputationScheduler is disposed");
+    return this._settled.promise;
+  }
+  get disposed() {
+    return this._disposed;
+  }
+  overwrite(promise) {
+    if (this._disposed) throw new Error("[PicoFlow] ComputationScheduler is disposed");
+    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._resolver.overwrite(promise);
+  }
+  compute() {
+    if (this._disposed) throw new Error("[PicoFlow] ComputationScheduler is disposed");
+    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._resolver.compute();
+  }
+  dispose() {
+    this._resolver.abort();
+    this._disposed = true;
+  }
+}
+
+class SyncResolver {
+  _compute;
+  _iteration = 0;
+  _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] 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;
+    try {
+      const value = this._compute();
+      if (this._iteration === currentIteration && !this._aborted) {
+        this._finished = true;
+        this._onValue(value);
       }
-      let effectError = null;
-      for (const effect of FlowGraph._effectsQueue) {
-        try {
-          await effect._requestExec();
-        } catch (error) {
-          effectError = error instanceof Error ? error : new Error(String(error));
-          break;
+    } catch (error) {
+      if (this._iteration === currentIteration && !this._aborted) {
+        if (!(error instanceof PendingError)) {
+          this._finished = true;
+          this._onError(error);
         }
       }
-      FlowGraph._effectsQueue = [];
-      if (effectError) {
-        actionRequest.reject(effectError);
-      } else {
-        actionRequest.resolve();
-      }
     }
-    FlowGraph._processingActionQueue = false;
-  };
+  }
+  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);
+    }
+  }
+  abort() {
+    this._iteration++;
+    this._aborted = true;
+  }
 }
 
-class FlowEffect {
+class SyncScheduler {
+  _compute;
+  _resolver;
+  _onResolve;
+  _onReject;
+  _settled = Promise.withResolvers();
   _disposed = false;
-  _dependencies = /* @__PURE__ */ new Set();
-  _apply;
-  settled;
-  /**
-   * Creates a new effect and runs it once immediately.
-   *
-   * @param apply - Side-effect function receiving the tracking context (`t`).
-   * It can be sync or async (returning `Promise<void>`).
-   *
-   * @remarks
-   * Use `t` to opt-in to reactive tracking:
-   * - `observable.get(t)` / `signal.watch(t)` to re-run when they change
-   * - `observable.pick()` for reads that should not re-run the effect
-   *
-   * The effect schedules its first run during construction. Each subsequent
-   * change to a tracked dependency queues another run.
-   *
-   * @public
-   */
-  constructor(apply) {
-    this._apply = apply;
-    this.settled = FlowGraph.requestRead(() => this._exec());
-  }
-  /**
-   * Stops the effect and detaches it from all tracked dependencies.
-   *
-   * @remarks
-   * Call this when the effect's work is no longer needed (e.g., component
-   * unmount, teardown of a feature). After disposal:
-   * - The effect will not re-run.
-   * - All dependency links are removed.
-   * - Calling `dispose()` again throws an error.
-   *
-   * @example
-   * ```typescript
-   * const fx = effect((t) => $signal.watch(t));
-   * // ... later
-   * fx.dispose();
-   * ```
-   *
-   * @public
-   */
+  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 Error("[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 Error("[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() {
-    if (this._disposed) throw new Error("[PicoFlow] Effect is disposed");
-    Array.from(this._dependencies).forEach((dependency) => {
-      this._unregisterDependency(dependency);
-    });
+    this._resolver.abort();
     this._disposed = true;
   }
-  /**
-   * Whether the effect has been disposed.
-   *
-   * @returns `true` once disposal has run; `false` while the effect is active.
-   *
-   * @public
-   */
+}
+
+class Disposable {
+  _disposed = false;
   get disposed() {
     return this._disposed;
   }
-  /** @internal */
-  async _requestExec() {
-    this.settled = this._exec();
-    return this.settled;
+  dispose() {
+    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this._disposed = true;
   }
-  /** @internal */
-  _registerDependency(dependency) {
-    this._dependencies.add(dependency);
-    dependency._registerEffect(this);
+}
+
+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);
+    });
   }
-  /** @internal */
-  _unregisterDependency(dependency) {
-    this._dependencies.delete(dependency);
-    dependency._unregisterEffect(this);
-  }
-  async _exec() {
-    if (this._disposed)
-      throw new Error("[PicoFlow] Effect is disposed");
-    const result = this._apply(this);
-    if (result instanceof Promise) {
-      await result;
-    }
+  static _execute() {
+    ExecutionStack._pendingQueue.forEach((node) => {
+      node.execute();
+    });
+    ExecutionStack._pendingQueue.length = 0;
+    ExecutionStack._effectQueue.forEach((effect) => {
+      effect.execute();
+    });
+    ExecutionStack._effectQueue.length = 0;
   }
 }
-function effect(fn) {
-  return new FlowEffect(fn);
-}
 
-class FlowSignal {
-  /**
-   * Triggers the signal and notifies all dependents.
-   *
-   * @remarks
-   * Any effect/derivation that called `watch(t)` on this signal will re-run.
-   * Returns a promise that settles after notifications complete.
-   *
-   * @throws Error if the signal is disposed.
-   *
-   * @example
-   * ```typescript
-   * const $tick = signal();
-   *
-   * effect((t) => {
-   *   $tick.watch(t);
-   *   console.log("tick");
-   * });
-   *
-   * $tick.trigger(); // logs "tick"
-   * ```
-   *
-   * @public
-   */
-  async trigger() {
+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");
-    return FlowGraph.requestTrigger(() => this._notify());
-  }
-  /**
-   * Registers this signal as a dependency in the current tracking context.
-   *
-   * @param context - The tracking context (`t`) provided to effects/derivations.
-   *
-   * @remarks
-   * Signals have no value to read; calling `watch(t)` simply means “re-run me
-   * when this signal is triggered.” Call this inside an effect/derivation
-   * callback where a tracking context is available.
-   *
-   * @throws Error if the signal has been disposed.
-   *
-   * @example
-   * ```typescript
-   * const $refresh = signal();
-   *
-   * effect((t) => {
-   *   $refresh.watch(t);
-   *   console.log("refresh triggered");
-   * });
-   *
-   * $refresh.trigger(); // logs "refresh triggered"
-   * ```
-   *
-   * @public
-   */
-  watch(caller) {
+    this._dependencies.add(dependency);
+    dependency.registerDependent(this);
+  }
+  unregisterDependency(dependency) {
     if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    caller._registerDependency(this);
-  }
-  /**
-   * Disposes the signal and cleans up its dependencies/listeners.
-   *
-   * @remarks
-   * After disposal the signal must not be used; calling `trigger` or `watch`
-   * will throw. If `options?.self` is true, only this signal is disposed; when
-   * false or omitted, dependents may also be disposed depending on the
-   * implementation.
-   *
-   * @throws Error if the signal is already disposed.
-   *
-   * @example
-   * ```typescript
-   * const $refresh = signal();
-   * // ... use it
-   * $refresh.dispose();
-   * ```
-   *
-   * @public
-   */
-  dispose(options) {
+    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");
-    if (options?.self) {
-      Array.from(this._effects).forEach((effect) => {
-        effect._unregisterDependency(this);
-      });
-      Array.from(this._listeners).forEach((listener) => {
-        listener._unregisterDependency(this);
-      });
-    } else {
-      Array.from(this._effects).forEach((effect) => {
-        effect.dispose();
-      });
-      Array.from(this._listeners).forEach((listener) => {
-        listener.dispose();
-      });
-    }
+    Array.from(this._dependents).forEach((dependant) => {
+      dependant.unregisterDependency(this);
+      this.unregisterDependent(dependant);
+    });
     Array.from(this._dependencies).forEach((dependency) => {
-      this._unregisterDependency(dependency);
+      this.unregisterDependency(dependency);
     });
     this._disposed = true;
   }
-  /**
-   * Whether the signal has been disposed.
-   *
-   * @returns `true` if disposed; `false` while active.
-   *
-   * @remarks Use to guard operations or avoid double disposal.
-   *
-   * @public
-   */
-  get disposed() {
-    return this._disposed;
+}
+
+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();
+    });
   }
-  /* INTERNAL ------------------------------------------------------------- */
-  _disposed = false;
-  _dependencies = /* @__PURE__ */ new Set();
-  _listeners = /* @__PURE__ */ new Set();
-  _effects = /* @__PURE__ */ new Set();
-  _notify() {
-    FlowGraph.pushEffects(Array.from(this._effects));
-    this._listeners.forEach((listener) => {
-      listener._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;
   }
-  /** @internal */
-  _registerDependency(dependency) {
+}
+
+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._registerListener(this);
+    dependency.registerDependent(this);
   }
-  /** @internal */
-  _unregisterDependency(dependency) {
+  unregisterDependency(dependency) {
+    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
     this._dependencies.delete(dependency);
-    dependency._unregisterListener(this);
+    dependency.unregisterDependent(this);
   }
-  /** @internal */
-  _registerListener(signal2) {
-    this._listeners.add(signal2);
+  clearDependencies() {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this._dependencies.forEach((dependency) => {
+      dependency.unregisterDependent(this);
+    });
+    this._dependencies.clear();
   }
-  /** @internal */
-  _unregisterListener(signal2) {
-    this._listeners.delete(signal2);
+  dispose() {
+    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    Array.from(this._dependencies).forEach((dependency) => {
+      this.unregisterDependency(dependency);
+    });
+    this._disposed = true;
   }
-  /** @internal */
-  _registerEffect(effect) {
-    this._effects.add(effect);
+}
+
+class EffectNode extends Observer {
+  _data;
+  _onData;
+  _onError;
+  _onPending;
+  constructor(data, onData, onError, onPending) {
+    super();
+    this._data = data;
+    this._onData = onData;
+    this._onError = onError;
+    this._onPending = onPending;
+    this.execute();
   }
-  /** @internal */
-  _unregisterEffect(effect) {
-    this._effects.delete(effect);
+  notify() {
+    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    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)));
+        } else {
+          throw error;
+        }
+      }
+    }
   }
 }
-function signal() {
-  return new FlowSignal();
-}
 
-class FlowNodeAsync extends FlowSignal {
-  _promise;
-  _dirty = true;
-  _compute;
-  /**
-   * Creates a new FlowNodeAsync.
-   *
-   * @param compute - Either a constant Promise or a compute function that derives the value.
-   *
-   * @remarks
-   * The constructor accepts two different initialization modes:
-   *
-   * - **Constant Promise**: Creates a mutable reactive node that can be updated via `set()`.
-   *   The Promise is stored immediately and can be changed at any time. The Promise resolves
-   *   to the value of type T.
-   *
-   * - **Compute function**: Creates a computed reactive node that automatically tracks dependencies
-   *   and recomputes when they change. The compute function receives a tracking context (`t`)
-   *   that should be used to access dependencies via `.get(t)`. The function must return a
-   *   `Promise<T>`. The function is not executed immediately; it runs lazily on first access.
-   *   The computed value can be temporarily overridden using `set()`, but the override is cleared
-   *   on the next recomputation (triggered by dependency changes).
-   *
-   * @example
-   * ```typescript
-   * // Mutable state with constant Promise
-   * const $count = new FlowNodeAsync(Promise.resolve(0));
-   * await $count.set(Promise.resolve(5));
-   *
-   * // Computed derivation with async function
-   * const $a = new FlowNodeAsync(Promise.resolve(10));
-   * const $b = new FlowNodeAsync(Promise.resolve(20));
-   * const $sum = new FlowNodeAsync(async (t) => {
-   *   const a = await $a.get(t);
-   *   const b = await $b.get(t);
-   *   return a + b;
-   * });
-   *
-   * // Lazy evaluation - compute function hasn't run yet
-   * console.log(await $sum.pick()); // Now it computes: 30
-   * ```
-   *
-   * @public
-   */
-  constructor(compute) {
-    super();
-    if (typeof compute === "function") {
-      this._compute = compute;
-    } else {
-      this._promise = compute;
-      this._dirty = false;
+class ValueNode extends Node {
+  _value;
+  _error;
+  watch(tracker) {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    super.watch(tracker);
+    switch (this.status) {
+      case "resolved":
+        return;
+      case "error":
+        throw this._error;
+      case "pending": {
+        throw new PendingError(this._scheduler.settled);
+      }
+      case "dirty": {
+        this.execute();
+        switch (this.status) {
+          case "pending":
+            throw new PendingError(this._scheduler.settled);
+          case "resolved":
+            return;
+          case "error":
+            throw this._error;
+          case "dirty": {
+            throw new Error("[PicoFlow] Internal error");
+          }
+        }
+      }
     }
   }
-  get settled() {
-    return this._promise;
+  notify() {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    if (this.status === "dirty") return;
+    if (this.status === "pending") {
+      ExecutionStack.pushPending(this);
+    }
+    this.status = "dirty";
+    this.notifyDependents();
   }
-  async watch(tracker) {
-    if (this._disposed)
-      return Promise.reject(new Error("[PicoFlow] Primitive is disposed"));
+  dispose() {
+    super.dispose();
+    this._scheduler.dispose();
+  }
+  get(tracker) {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
     super.watch(tracker);
-    return this._computeValue();
-  }
-  /**
-   * Gets the current value with dependency tracking.
-   *
-   * @param tracker - The tracking context for reactive tracking. This observable is registered
-   * as a dependency when accessed through this method.
-   *
-   * @returns A Promise that resolves to the current value of type T.
-   *
-   * @remarks
-   * Use `get(t)` within effects and derivations to create reactive dependencies. The tracker
-   * parameter must be provided from the reactive context (typically the `t` parameter in effect
-   * or derivation callbacks).
-   *
-   * **Important:** This method returns a `Promise<T>`, not `T`. You must await the Promise to
-   * get the actual value. The Promise is cached until dependencies change, ensuring efficient
-   * access patterns.
-   *
-   * To read a value without creating a dependency, use `pick()` instead.
-   *
-   * @example
-   * ```typescript
-   * effect(async (t) => {
-   *   const tracked = await $state.get(t);     // Dependency registered, await the Promise
-   *   const untracked = await $other.pick();   // No dependency
-   * });
-   * ```
-   *
-   * @throws Error if the node has been disposed.
-   *
-   * @public
-   */
-  async get(tracker) {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    await this._computeValue();
-    if (tracker) super.watch(tracker);
-    return this._promise;
-  }
-  /**
-   * Updates the node with a new value.
-   *
-   * @param value - A new Promise or a callback function that computes a new Promise based on the current value.
-   *
-   * @returns A promise that resolves after the update is processed and all dependent effects have been notified.
-   *
-   * @remarks
-   * This method can be used in two ways:
-   *
-   * **For mutable state nodes** (constructed with a constant Promise):
-   * - Updates the stored Promise directly
-   * - All dependents are notified of the change
-   *
-   * **For computed nodes** (constructed with a compute function):
-   * - Temporarily overrides the computed value
-   * - The override persists until the next recomputation, which occurs when:
-   *   - A tracked dependency changes, or
-   *   - The node is refreshed
-   * - This allows temporarily overriding computed values for testing or manual control
-   *
-   * **Value Comparison:**
-   * The Promises are resolved and their values are compared. If the resolved new value is strictly
-   * equal (`===`) to the current resolved value, no update occurs and subscribers are not notified.
-   * This prevents unnecessary re-renders and effect executions.
-   *
-   * **Asynchronous Processing:**
-   * The update is processed asynchronously through the reactive graph, ensuring proper
-   * ordering of updates and effect execution. The method returns a Promise that resolves
-   * after the update is complete.
-   *
-   * @throws Error if the node has been disposed.
-   *
-   * @example
-   * ```typescript
-   * // Mutable state usage
-   * const $count = new FlowNodeAsync(Promise.resolve(0));
-   * await $count.set(Promise.resolve(5));
-   * await $count.set(async (current) => Promise.resolve(current + 1)); // 6
-   *
-   * // Temporary override of computed value
-   * const $source = new FlowNodeAsync(Promise.resolve(10));
-   * const $doubled = new FlowNodeAsync(async (t) => {
-   *   const val = await $source.get(t);
-   *   return val * 2;
-   * });
-   *
-   * console.log(await $doubled.pick()); // 20
-   *
-   * // Temporarily override
-   * await $doubled.set(Promise.resolve(50));
-   * console.log(await $doubled.pick()); // 50 (override active)
-   *
-   * // Dependency change clears override
-   * await $source.set(Promise.resolve(15));
-   * console.log(await $doubled.pick()); // 30 (recomputed, override cleared)
-   * ```
-   *
-   * @public
-   */
-  async set(value) {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    const update = async () => {
-      await this._computeValue();
-      const currentValue = await this._promise;
-      const nextPromise = typeof value === "function" ? value(currentValue) : value;
-      const nextValue = await nextPromise;
-      this._promise = nextPromise;
-      return nextValue !== currentValue;
-    };
-    const notify = () => {
-      super._notify();
-    };
-    return FlowGraph.requestWrite(notify, update);
-  }
-  /**
-   * Forces recomputation of the value, even if it's not marked as dirty.
-   *
-   * @returns A promise that resolves after the recomputation is complete and all
-   * dependent effects have been notified.
-   *
-   * @remarks
-   * This method is useful when you need to force a recomputation of a computed value,
-   * for example when the computation depends on external data that has changed outside
-   * the reactive system.
-   *
-   * **Behavior:**
-   * - For nodes with a compute function: Forces the compute function to run again,
-   *   even if no dependencies have changed. This effectively clears any temporary
-   *   override that was set using `set()`.
-   * - For nodes without a compute function (mutable state): Recomputes the current
-   *   value (which is just the stored value), useful for consistency but typically
-   *   not necessary.
-   *
-   * The recomputation happens asynchronously through the reactive graph, ensuring
-   * proper ordering of updates and effect execution.
-   *
-   * @throws Error if the node has been disposed.
-   *
-   * @example
-   * ```typescript
-   * const $externalData = new FlowNode(() => fetchExternalData());
-   *
-   * // Some external event occurs that changes the data source
-   * externalDataChanged();
-   *
-   * // Force recomputation to get the new value
-   * await $externalData.refresh();
-   *
-   * // For computed nodes with temporary overrides
-   * const $computed = new FlowNode((t) => $source.get(t) * 2);
-   * $computed.set(100); // Temporary override
-   * await $computed.refresh(); // Clears override, recomputes from source
-   * ```
-   *
-   * @public
-   */
-  async refresh() {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    const update = async () => {
-      await this._computeValue();
-      const currentValue = await this._promise;
-      await this._computeValue({ force: true });
-      const nextValue = await this._promise;
-      return nextValue !== currentValue;
-    };
-    const notify = () => {
-      super._notify();
-    };
-    return await FlowGraph.requestWrite(notify, update);
-  }
-  /**
-   * Gets the current value without any dependency tracking.
-   *
-   * @returns A promise that resolves with the current value of type T.
-   *
-   * @remarks
-   * This method reads the value asynchronously through the reactive graph, ensuring proper ordering of
-   * read operations. Unlike `get(t)`, this method does not create a reactive dependency.
-   *
-   * **Important:** This is an async method that returns `Promise<T>`. Always use `await` when calling it.
-   *
-   * Use `pick()` when you want to read a snapshot of the current value without creating a reactive
-   * dependency. This is useful for:
-   * - Reading initial values outside reactive contexts
-   * - Accessing configuration that shouldn't trigger updates
-   * - Mixing tracked and untracked reads in the same effect
-   *
-   * @example
-   * ```typescript
-   * // Read a snapshot outside reactive context
-   * const currentValue = await $state.pick();
-   *
-   * // Mix tracked and untracked reads
-   * effect(async (t) => {
-   *   const tracked = await $reactive.get(t);    // Triggers re-runs
-   *   const snapshot = await $config.pick();    // Doesn't trigger re-runs
-   *   processData(tracked, snapshot);
-   * });
-   * ```
-   *
-   * @throws Error if the node has been disposed.
-   *
-   * @public
-   */
-  async pick() {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    await FlowGraph.requestRead(() => this._computeValue());
-    return this._promise;
-  }
-  /**
-   * Subscribes a listener function to changes of this node.
-   *
-   * @param listener - A callback function that receives the new value whenever it changes.
-   *
-   * @returns A disposer function that cancels the subscription when called.
-   *
-   * @remarks
-   * This method creates a reactive subscription that automatically tracks this node as a dependency.
-   * The listener is executed:
-   * - Immediately with the current value when the subscription is created
-   * - Automatically whenever the value changes
-   *
-   * **Important:** The listener receives a `Promise<T>`, not `T`. You must await the Promise
-   * within the listener to access the actual value. The Promise is the same one returned by `get()`,
-   * so it's cached until dependencies change.
-   *
-   * The subscription uses a {@link FlowEffect} internally to manage the reactive tracking and
-   * automatic re-execution. When the value changes, the listener is called with the new Promise
-   * after the update is processed through the reactive graph.
-   *
-   * **Cleanup:**
-   * Always call the returned disposer function when you no longer need the subscription to
-   * prevent memory leaks and unnecessary computations.
-   *
-   * @example
-   * ```typescript
-   * const $count = new FlowNodeAsync(Promise.resolve(0));
-   *
-   * // Subscribe to changes
-   * const unsubscribe = $count.subscribe(async (valuePromise) => {
-   *   const value = await valuePromise;
-   *   console.log(`Count is now: ${value}`);
-   * });
-   * // Logs immediately: "Count is now: 0"
-   *
-   * await $count.set(Promise.resolve(5));
-   * // Logs: "Count is now: 5"
-   *
-   * // Clean up when done
-   * unsubscribe();
-   * ```
-   *
-   * @throws Error if the node has been disposed.
-   *
-   * @public
-   */
-  subscribe(listener) {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    const effect = new FlowEffect((t) => {
-      listener(this.get(t));
-    });
-    return () => effect.dispose();
+    switch (this.status) {
+      case "resolved":
+        return this._value;
+      case "error":
+        throw this._error;
+      case "pending": {
+        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": {
+            throw new PendingError(this._scheduler.settled);
+          }
+          case "dirty": {
+            throw new Error("[PicoFlow] Internal error");
+          }
+        }
+      }
+    }
   }
-  /* INTERNAL --------------------------------------------------------- */
-  /* @internal */
-  _notify() {
-    if (this._dirty) {
-      return;
+  async pick() {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    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 new Error("[PicoFlow] Internal error");
+      }
+      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 new Error("[PicoFlow] Internal error");
+          }
+          case "error":
+            throw this._error;
+          case "dirty": {
+            throw new Error("[PicoFlow] Internal error");
+          }
+        }
+      }
     }
-    this._dirty = true;
-    super._notify();
-  }
-  async _computeValue(options) {
-    if (!this._dirty && !options?.force) return;
-    if (!this._compute) {
-      this._dirty = false;
-      return;
+  }
+  execute() {
+    if (this.disposed) return;
+    this.clearDependencies();
+    this.status = "pending";
+    this._scheduler.compute();
+  }
+  subscribe(onValue, onError, onPending) {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    const effect = new EffectNode((t) => this.get(t), onValue, onError, onPending);
+    return effect;
+  }
+}
+
+class ValueAsyncNode extends ValueNode {
+  _scheduler;
+  _compute;
+  constructor(promiseOrCompute) {
+    super();
+    if (typeof promiseOrCompute === "function") {
+      this._compute = () => promiseOrCompute(this, this._value);
+    } else {
+      this._compute = () => promiseOrCompute;
     }
-    this._dirty = false;
-    const dependencies = [...this._dependencies];
-    this._dependencies.clear();
-    this._promise = this._compute(this);
-    await this._promise;
-    const dependenciesToRemove = dependencies.filter(
-      (dependency) => !this._dependencies.has(dependency)
+    this.status = "dirty";
+    this._scheduler = new AsyncScheduler(
+      () => this._compute(),
+      (value) => this._onResolve(value),
+      (error) => this._onReject(error)
     );
-    dependenciesToRemove.forEach((dependency) => {
-      dependency._unregisterDependency(this);
-    });
+  }
+  _onResolve(value) {
+    this.status = "resolved";
+    this._value = value;
+    this._error = void 0;
+    this.notifyDependents();
+  }
+  _onReject(error) {
+    this.status = "error";
+    this._error = error;
+    this.notifyDependents();
+  }
+  set(promiseOrUpdater) {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    if (typeof promiseOrUpdater === "function") {
+      const updater = promiseOrUpdater;
+      switch (this.status) {
+        case "resolved": {
+          this.status = "pending";
+          this._scheduler.overwrite(updater(this._value));
+          this.notifyDependents();
+          return;
+        }
+        case "pending":
+        case "error":
+        case "dirty": {
+          this.status = "pending";
+          this._scheduler.overwrite(updater(this._value));
+          this.notifyDependents();
+          return;
+        }
+      }
+    } else {
+      this.status = "pending";
+      const promise = promiseOrUpdater;
+      this._scheduler.overwrite(promise);
+      this.notifyDependents();
+    }
+  }
+  refresh() {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this.execute();
   }
 }
 
-function constantAsync(value) {
-  return new FlowNodeAsync(value);
+function constantAsync(valueOrInitializer) {
+  return new ValueAsyncNode(valueOrInitializer);
 }
 
-function derivationAsync(fn) {
-  return new FlowNodeAsync(fn);
+function derivationAsync(compute) {
+  return new ValueAsyncNode(compute);
 }
 
-function stateAsync(value) {
-  return new FlowNodeAsync(value);
+function stateAsync(valueOrInitializer) {
+  return new ValueAsyncNode(valueOrInitializer);
 }
 
-class FlowNode extends FlowSignal {
-  _value;
-  _dirty = true;
+function writableDerivationAsync(compute) {
+  return new ValueAsyncNode(compute);
+}
+
+class ValueSyncNode extends ValueNode {
+  _scheduler;
   _compute;
-  /**
-   * Creates a new FlowNode.
-   *
-   * @param compute - Either a constant value or a compute function that derives the value.
-   *
-   * @remarks
-   * The constructor accepts two different initialization modes:
-   *
-   * - **Constant value**: Creates a mutable reactive node that can be updated via `set()`.
-   *   The value is stored immediately and can be changed at any time.
-   *
-   * - **Compute function**: Creates a computed reactive node that automatically tracks dependencies
-   *   and recomputes when they change. The compute function receives a tracking context (`t`)
-   *   that should be used to access dependencies via `.get(t)`. The function is not executed
-   *   immediately; it runs lazily on first access. The computed value can be temporarily
-   *   overridden using `set()`, but the override is cleared on the next recomputation
-   *   (triggered by dependency changes or `refresh()`).
-   *
-   * @example
-   * ```typescript
-   * // Mutable state with constant value
-   * const $count = new FlowNode(0);
-   * $count.set(5);
-   *
-   * // Computed derivation with function
-   * const $a = new FlowNode(10);
-   * const $b = new FlowNode(20);
-   * const $sum = new FlowNode((t) => $a.get(t) + $b.get(t));
-   *
-   * // Lazy evaluation - compute function hasn't run yet
-   * console.log(await $sum.pick()); // Now it computes: 30
-   * ```
-   *
-   * @public
-   */
-  constructor(compute) {
+  constructor(valueOrCompute) {
     super();
-    if (typeof compute === "function") {
-      this._compute = compute;
+    if (typeof valueOrCompute === "function") {
+      this._compute = () => valueOrCompute(this, this._value);
     } else {
-      this._value = compute;
-      this._dirty = false;
+      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();
     }
   }
-  watch(tracker) {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._computeValue();
-    super.watch(tracker);
-  }
-  /**
-   * Gets the current value with dependency tracking.
-   *
-   * @param tracker - The tracking context for reactive tracking. This observable is registered
-   * as a dependency when accessed through this method.
-   *
-   * @returns The current value of type T.
-   *
-   * @remarks
-   * Use `get(t)` within effects and derivations to create reactive dependencies. The tracker
-   * parameter must be provided from the reactive context (typically the `t` parameter in effect
-   * or derivation callbacks).
-   *
-   * To read a value without creating a dependency, use `pick()` instead.
-   *
-   * @example
-   * ```typescript
-   * effect((t) => {
-   *   const tracked = $state.get(t);     // Dependency registered
-   *   const untracked = await $other.pick(); // No dependency
-   * });
-   * ```
-   *
-   * @throws Error if the node has been disposed.
-   *
-   * @public
-   */
-  get(tracker) {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    this._computeValue();
-    if (tracker) super.watch(tracker);
-    return this._value;
-  }
-  /**
-   * Updates the node with a new value.
-   *
-   * @param value - A new value or a callback function that computes a new value based on the current value.
-   *
-   * @returns A promise that resolves after the update is processed and all dependent effects have been notified.
-   *
-   * @remarks
-   * This method can be used in two ways:
-   *
-   * **For mutable state nodes** (constructed with a constant value):
-   * - Updates the stored value directly
-   * - All dependents are notified of the change
-   *
-   * **For computed nodes** (constructed with a compute function):
-   * - Temporarily overrides the computed value
-   * - The override persists until the next recomputation, which occurs when:
-   *   - A tracked dependency changes, or
-   *   - `refresh()` is called
-   * - This allows temporarily overriding computed values for testing or manual control
-   *
-   * **Value Comparison:**
-   * If the new value is strictly equal (`===`) to the current value, no update occurs
-   * and subscribers are not notified. This prevents unnecessary re-renders and effect
-   * executions.
-   *
-   * **Asynchronous Processing:**
-   * The update is processed asynchronously through the reactive graph, ensuring proper
-   * ordering of updates and effect execution.
-   *
-   * @throws Error if the node has been disposed.
-   *
-   * @example
-   * ```typescript
-   * // Mutable state usage
-   * const $count = new FlowNode(0);
-   * await $count.set(5);
-   * await $count.set(current => current + 1); // 6
-   *
-   * // Temporary override of computed value
-   * const $source = new FlowNode(10);
-   * const $doubled = new FlowNode((t) => $source.get(t) * 2);
-   *
-   * console.log(await $doubled.pick()); // 20
-   *
-   * // Temporarily override
-   * await $doubled.set(50);
-   * console.log(await $doubled.pick()); // 50 (override active)
-   *
-   * // Dependency change clears override
-   * await $source.set(15);
-   * console.log(await $doubled.pick()); // 30 (recomputed, override cleared)
-   * ```
-   *
-   * @public
-   */
-  set(value) {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    const update = () => {
-      this._computeValue();
-      const currentValue = this._value;
-      const next = typeof value === "function" ? value(currentValue) : value;
-      this._value = next;
-      return next !== currentValue;
-    };
-    const notify = () => {
-      super._notify();
-    };
-    return FlowGraph.requestWrite(notify, update);
-  }
-  /**
-   * Forces recomputation of the value, even if it's not marked as dirty.
-   *
-   * @returns A promise that resolves after the recomputation is complete and all
-   * dependent effects have been notified.
-   *
-   * @remarks
-   * This method is useful when you need to force a recomputation of a computed value,
-   * for example when the computation depends on external data that has changed outside
-   * the reactive system.
-   *
-   * **Behavior:**
-   * - For nodes with a compute function: Forces the compute function to run again,
-   *   even if no dependencies have changed. This effectively clears any temporary
-   *   override that was set using `set()`.
-   * - For nodes without a compute function (mutable state): Recomputes the current
-   *   value (which is just the stored value), useful for consistency but typically
-   *   not necessary.
-   *
-   * The recomputation happens asynchronously through the reactive graph, ensuring
-   * proper ordering of updates and effect execution.
-   *
-   * @throws Error if the node has been disposed.
-   *
-   * @example
-   * ```typescript
-   * const $externalData = new FlowNode(() => fetchExternalData());
-   *
-   * // Some external event occurs that changes the data source
-   * externalDataChanged();
-   *
-   * // Force recomputation to get the new value
-   * await $externalData.refresh();
-   *
-   * // For computed nodes with temporary overrides
-   * const $computed = new FlowNode((t) => $source.get(t) * 2);
-   * $computed.set(100); // Temporary override
-   * await $computed.refresh(); // Clears override, recomputes from source
-   * ```
-   *
-   * @public
-   */
-  async refresh() {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    const update = () => {
-      this._computeValue();
-      const currentValue = this._value;
-      this._computeValue({ force: true });
-      const nextValue = this._value;
-      return nextValue !== currentValue;
-    };
-    const notify = () => {
-      super._notify();
-    };
-    return await FlowGraph.requestWrite(notify, update);
-  }
-  /**
-   * Gets the current value without any dependency tracking.
-   *
-   * @returns A promise that resolves with the current value of type T.
-   *
-   * @remarks
-   * This method reads the value asynchronously through the reactive graph, ensuring proper ordering of
-   * read operations. Unlike `get(t)`, this method does not create a reactive dependency.
-   *
-   * Use `pick()` when you want to read a snapshot of the current value without creating a reactive
-   * dependency. This is useful for:
-   * - Reading initial values outside reactive contexts
-   * - Accessing configuration that shouldn't trigger updates
-   * - Mixing tracked and untracked reads in the same effect
-   *
-   * **Note:** This is an async method. Always use `await` when calling it.
-   *
-   * @example
-   * ```typescript
-   * // Read a snapshot outside reactive context
-   * const currentValue = await $state.pick();
-   *
-   * // Mix tracked and untracked reads
-   * effect(async (t) => {
-   *   const tracked = $reactive.get(t);        // Triggers re-runs
-   *   const snapshot = await $config.pick();    // Doesn't trigger re-runs
-   *   processData(tracked, snapshot);
-   * });
-   * ```
-   *
-   * @throws Error if the node has been disposed.
-   *
-   * @public
-   */
-  async pick() {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    await FlowGraph.requestRead(() => this._computeValue());
-    return this._value;
-  }
-  /**
-   * Subscribes a listener function to changes of this node.
-   *
-   * @param listener - A callback function that receives the new value whenever it changes.
-   *
-   * @returns A disposer function that cancels the subscription when called.
-   *
-   * @remarks
-   * This method creates a reactive subscription that automatically tracks this node as a dependency.
-   * The listener is executed:
-   * - Immediately with the current value when the subscription is created
-   * - Automatically whenever the value changes
-   *
-   * The subscription uses a {@link FlowEffect} internally to manage the reactive tracking and
-   * automatic re-execution. When the value changes, the listener is called with the new value
-   * after the update is processed through the reactive graph.
-   *
-   * **Cleanup:**
-   * Always call the returned disposer function when you no longer need the subscription to
-   * prevent memory leaks and unnecessary computations.
-   *
-   * @example
-   * ```typescript
-   * const $count = new FlowNode(0);
-   *
-   * // Subscribe to changes
-   * const unsubscribe = $count.subscribe((value) => {
-   *   console.log(`Count is now: ${value}`);
-   * });
-   * // Logs immediately: "Count is now: 0"
-   *
-   * await $count.set(5);
-   * // Logs: "Count is now: 5"
-   *
-   * // Clean up when done
-   * unsubscribe();
-   * ```
-   *
-   * @throws Error if the node has been disposed.
-   *
-   * @public
-   */
-  subscribe(listener) {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    const effect = new FlowEffect((t) => {
-      listener(this.get(t));
-    });
-    return () => effect.dispose();
-  }
-  /* INTERNAL --------------------------------------------------------- */
-  /* @internal */
-  _notify() {
-    if (this._dirty) {
-      return;
+  _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 new Error("[PicoFlow] Primitive is disposed");
+    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;
+        }
+      }
     }
-    this._dirty = true;
-    super._notify();
-  }
-  _computeValue(options) {
-    if (!this._dirty && !options?.force) return;
-    if (!this._compute) {
-      this._dirty = false;
-      return;
+  }
+  refresh() {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    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;
+      }
     }
-    this._dirty = false;
-    const dependencies = [...this._dependencies];
-    this._dependencies.clear();
-    this._value = this._compute(this);
-    const dependenciesToRemove = dependencies.filter(
-      (dependency) => !this._dependencies.has(dependency)
-    );
-    dependenciesToRemove.forEach((dependency) => {
-      dependency._unregisterDependency(this);
-    });
   }
 }
 
-function constant(value) {
-  return new FlowNode(value);
-}
-
-function derivation(fn) {
-  return new FlowNode(fn);
-}
-
-function state(value) {
-  return new FlowNode(value);
-}
-
-class FlowArray extends FlowNode {
-  /**
-   * Last action performed on the FlowArray.
-   * @public
-   */
+class ArrayNode extends ValueSyncNode {
   $lastAction;
-  /**
-   * Creates an instance of FlowArray.
-   * @param value - Initial array value.
-   * @public
-   */
   constructor(value = []) {
     super(value);
-    this.$lastAction = state({
+    this.$lastAction = new ValueSyncNode({
       type: "set",
-      items: value
+      setItems: value,
+      clearedItems: []
     });
   }
-  /**
-   * Gets the current length of the array.
-   * @returns The length of the array.
-   * @public
-   */
+  get(tracker) {
+    const values = super.get(tracker);
+    return [...values];
+  }
+  async pick() {
+    const values = await super.pick();
+    return [...values];
+  }
   get length() {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
     return this._value.length;
   }
-  /**
-   * Internal method to get the raw value.
-   * @internal
-   */
-  _getRaw() {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    return [...this._value];
-  }
-  /**
-   * Replaces the entire array with new items.
-   * @param items - The new array of items.
-   * @public
-   */
-  async set(items) {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    const update = () => {
-      const currentValue = this._value;
-      if (currentValue !== items) {
-        currentValue.forEach((item) => {
-          if (isDisposable(item)) item.dispose({ self: true });
-        });
-        this._value = items;
-        this.$lastAction.set({ type: "set", items });
-      }
-      return currentValue !== items;
-    };
-    const notify = () => {
-      super._notify();
-    };
-    return FlowGraph.requestWrite(notify, update);
-  }
-  /**
-   * Replaces an item at a specific index.
-   * @param index - The index of the item to replace.
-   * @param item - The new item.
-   * @public
-   */
-  async update(index, item) {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    const update = () => {
-      if (index < 0 || index >= this._value.length) {
-        throw new Error("[PicoFlow] Index out of bounds");
-      }
-      const currentValue = this._value[index];
-      if (currentValue !== item) {
-        if (isDisposable(currentValue)) {
-          currentValue.dispose({ self: true });
-        }
-        this._value[index] = item;
-        this.$lastAction.set({ type: "update", index, item });
-      }
-      return currentValue !== item;
-    };
-    const notify = () => {
-      super._notify();
-    };
-    return FlowGraph.requestWrite(notify, update);
-  }
-  /**
-   * Appends an item to the end of the array.
-   * @param item - The item to append.
-   * @public
-   */
-  async push(item) {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    const update = () => {
-      this._value.push(item);
-      this.$lastAction.set({ type: "push", item });
-      return true;
-    };
-    const notify = () => {
-      super._notify();
-    };
-    return FlowGraph.requestWrite(notify, update);
+  set(itemsOrUpdater) {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    const previousValue = this._value;
+    super.set(itemsOrUpdater);
+    this.$lastAction.set({
+      type: "set",
+      setItems: this._value,
+      clearedItems: previousValue
+    });
+    return previousValue;
   }
-  /**
-   * Removes the last item from the array.
-   * @public
-   */
-  async pop() {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    const update = () => {
-      const item = this._value.pop();
-      if (item !== void 0) {
-        if (isDisposable(item)) {
-          item.dispose({ self: true });
-        }
-        this.$lastAction.set({ type: "pop" });
-        return true;
-      }
-      return false;
-    };
-    const notify = () => {
-      super._notify();
-    };
-    return FlowGraph.requestWrite(notify, update);
-  }
-  /**
-   * Inserts an item at the beginning of the array.
-   * @param item - The item to insert.
-   * @public
-   */
-  async unshift(item) {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    const update = () => {
-      this._value.unshift(item);
-      this.$lastAction.set({ type: "unshift", item });
-      return true;
-    };
-    const notify = () => {
-      super._notify();
-    };
-    return FlowGraph.requestWrite(notify, update);
+  update(index, item) {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    if (index < 0 || index >= this._value.length) {
+      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 new Error("[PicoFlow] Primitive is disposed");
+    this._value.push(item);
+    this.notifyDependents();
+    this.$lastAction.set({ type: "push", addedItem: item });
+  }
+  pop() {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    const item = this._value.pop();
+    this.notifyDependents();
+    this.$lastAction.set({ type: "pop", removedItem: item });
+    return item;
+  }
+  unshift(item) {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    this._value.unshift(item);
+    this.notifyDependents();
+    this.$lastAction.set({ type: "unshift", addedItem: item });
+  }
+  shift() {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    const item = this._value.shift();
+    this.notifyDependents();
+    this.$lastAction.set({ type: "shift", removedItem: item });
+    return item;
+  }
+  splice(start, deleteCount, ...newItems) {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    const items = this._value.splice(start, deleteCount, ...newItems);
+    this.notifyDependents();
+    this.$lastAction.set({
+      type: "splice",
+      start,
+      deleteCount,
+      addedItems: newItems,
+      removedItems: items
+    });
+    return items;
   }
-  /**
-   * Removes the first item from the array.
-   * @public
-   */
-  async shift() {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    const update = () => {
-      const item = this._value.shift();
-      if (item !== void 0) {
-        if (isDisposable(item)) {
-          item.dispose({ self: true });
-        }
-        this.$lastAction.set({ type: "shift" });
-        return true;
-      }
-      return false;
-    };
-    const notify = () => {
-      super._notify();
-    };
-    return FlowGraph.requestWrite(notify, update);
-  }
-  /**
-   * Changes the content of the array.
-   * @param start - The starting index.
-   * @param deleteCount - Number of items to remove.
-   * @param newItems - New items to add.
-   * @public
-   */
-  async splice(start, deleteCount, ...newItems) {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    const update = () => {
-      const items = this._value.splice(start, deleteCount, ...newItems);
-      items.forEach((item) => {
-        if (isDisposable(item)) item.dispose({ self: true });
-      });
-      this.$lastAction.set({
-        type: "splice",
-        start,
-        deleteCount,
-        items: newItems
-      });
-      return true;
-    };
-    const notify = () => {
-      super._notify();
-    };
-    return FlowGraph.requestWrite(notify, update);
+  clear() {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    const previousValue = [...this._value];
+    this._value = [];
+    this.notifyDependents();
+    this.$lastAction.set({ type: "clear", clearedItems: previousValue });
+    return previousValue;
   }
-  /**
-   * Clears all items from the array.
-   * @public
-   */
-  async clear() {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    const update = () => {
-      const items = [...this._value];
-      items.forEach((item) => {
-        if (isDisposable(item)) item.dispose({ self: true });
-      });
-      this._value = [];
-      this.$lastAction.set({ type: "clear" });
-      return true;
-    };
-    const notify = () => {
-      super._notify();
-    };
-    return FlowGraph.requestWrite(notify, update);
-  }
-  /**
-   * Disposes the FlowArray and its items.
-   * @param options - Disposal options.
-   * @public
-   */
-  dispose(options) {
-    super.dispose(options);
+  dispose() {
+    super.dispose();
     this._value.forEach((item) => {
-      if (isDisposable(item)) item.dispose(options);
+      if (item instanceof Disposable) item.dispose();
     });
     this._value = [];
   }
-  /* INTERNAL */
 }
+
 function array(initial) {
-  return new FlowArray(initial);
+  return new ArrayNode(initial);
 }
 
-class FlowMap extends FlowNode {
-  /**
-   * Last action performed on the FlowMap.
-   * @public
-   */
+class MapNode extends ValueSyncNode {
   $lastAction;
-  /**
-   * Creates an instance of FlowMap.
-   * @param value - Initial map value.
-   * @public
-   */
   constructor(value = /* @__PURE__ */ new Map()) {
     super(value);
-    this.$lastAction = state({
+    this.$lastAction = new ValueSyncNode({
       type: "set",
-      map: value
+      setMap: value,
+      clearedMap: /* @__PURE__ */ new Map()
     });
   }
-  /**
-   * Adds a new key-value pair to the map.
-   *
-   * @param key - The key to add.
-   * @param value - The value to associate with the key.
-   * @throws If the FlowMap instance is disposed.
-   * @throws If the key already exists in the map.
-   *
-   * @remarks
-   * Adds a new entry to the internal map, emits the key-value pair via {@link FlowMap.$lastAction},
-   * and notifies all subscribers of the change.
-   *
-   * @public
-   */
-  async add(key, value) {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    const update = () => {
-      const currentValue = this._value.get(key);
-      if (currentValue) {
-        throw new Error("[PicoFlow] Key already exists");
-      }
-      this._value.set(key, value);
-      this.$lastAction.set({ type: "add", key, value });
-      return true;
-    };
-    const notify = () => {
-      super._notify();
-    };
-    return FlowGraph.requestWrite(notify, update);
-  }
-  /**
-   * Updates an existing key-value pair in the map.
-   *
-   * @param key - The key to update.
-   * @param value - The new value to associate with the key.
-   * @throws If the FlowMap instance is disposed.
-   * @throws If the key does not exist in the map.
-   *
-   * @remarks
-   * Updates an existing entry in the internal map, emits the key-value pair via {@link FlowMap.$lastAction},
-   * and notifies all subscribers of the change.
-   *
-   * @public
-   */
-  async update(key, value) {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    const update = () => {
-      const currentValue = this._value.get(key);
-      if (!currentValue) throw new Error("[PicoFlow] Key does not exist");
-      if (currentValue !== value) {
-        if (isDisposable(currentValue)) currentValue.dispose({ self: true });
-        this._value.set(key, value);
-        this.$lastAction.set({ type: "update", key, value });
-        return true;
-      }
-      return false;
-    };
-    const notify = () => {
-      super._notify();
-    };
-    return FlowGraph.requestWrite(notify, update);
-  }
-  /**
-   * Deletes the value at the specified key from the underlying map.
-   *
-   * @param key - The key to delete.
-   * @throws If the FlowMap instance is disposed.
-   *
-   * @remarks
-   * Removes the key from the internal map, emits the deleted key and its value via {@link FlowMap.$lastAction},
-   * and notifies all subscribers of the change.
-   *
-   * @public
-   */
-  async delete(key) {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    const update = () => {
-      const value = this._value.get(key);
-      if (value === void 0) throw new Error("[PicoFlow] Key does not exist");
-      if (isDisposable(value)) value.dispose({ self: true });
-      this._value.delete(key);
-      this.$lastAction.set({ type: "delete", key, value });
-      return true;
-    };
-    const notify = () => {
-      super._notify();
-    };
-    return FlowGraph.requestWrite(notify, update);
-  }
-  /**
-   * Replaces the entire map with new entries.
-   *
-   * @param map - The new map of entries.
-   * @throws If the FlowMap instance is disposed.
-   *
-   * @remarks
-   * Replaces all entries in the internal map, disposes the old values (if they are disposable),
-   * emits the new map via {@link FlowMap.$lastAction}, and notifies all subscribers of the change.
-   *
-   * @public
-   */
-  async set(map2) {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    const update = () => {
-      const currentValue = this._value;
-      if (currentValue !== map2) {
-        currentValue.forEach((item) => {
-          if (isDisposable(item)) item.dispose({ self: true });
-        });
-      }
-      this._value = map2;
-      if (currentValue !== map2) {
-        this.$lastAction.set({ type: "set", map: map2 });
-      }
-      return currentValue !== map2;
-    };
-    const notify = () => {
-      super._notify();
-    };
-    return FlowGraph.requestWrite(notify, update);
-  }
-  /**
-   * Clears all entries from the map.
-   *
-   * @throws If the FlowMap instance is disposed.
-   *
-   * @remarks
-   * Removes all entries from the internal map, disposes the removed values (if they are disposable),
-   * emits a clear action via {@link FlowMap.$lastAction}, and notifies all subscribers of the change.
-   *
-   * @public
-   */
-  async clear() {
-    if (this._disposed) throw new Error("[PicoFlow] Primitive is disposed");
-    const update = () => {
-      const items = [...this._value.values()];
-      items.forEach((item) => {
-        if (isDisposable(item)) item.dispose({ self: true });
-      });
-      this._value.clear();
-      this.$lastAction.set({ type: "clear" });
-      return true;
-    };
-    const notify = () => {
-      super._notify();
-    };
-    return FlowGraph.requestWrite(notify, update);
-  }
-  /**
-   * Disposes the FlowMap and its values.
-   * @param options - Disposal options.
-   * @public
-   */
-  dispose(options) {
-    super.dispose(options);
+  add(key, value) {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    const previousValue = this._value.get(key);
+    if (previousValue) {
+      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 new Error("[PicoFlow] Primitive is disposed");
+    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({
+      type: "update",
+      key,
+      setValue: value,
+      clearedValue: previousValue
+    });
+    return previousValue;
+  }
+  delete(key) {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    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 });
+    return value;
+  }
+  set(mapOrUpdater) {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    const previousValue = this._value;
+    super.set(mapOrUpdater);
+    this.$lastAction.set({
+      type: "set",
+      setMap: this._value,
+      clearedMap: previousValue
+    });
+    return previousValue;
+  }
+  clear() {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    const previousValue = this._value;
+    this._value = /* @__PURE__ */ new Map();
+    this.notifyDependents();
+    this.$lastAction.set({ type: "clear", clearedMap: previousValue });
+    return previousValue;
+  }
+  dispose() {
+    super.dispose();
     this._value.forEach((item) => {
-      if (isDisposable(item)) item.dispose(options);
+      if (item instanceof Disposable) item.dispose();
     });
     this._value.clear();
   }
 }
+
 function map(initial) {
   if (initial instanceof Map) {
-    return new FlowMap(initial);
+    return new MapNode(initial);
   }
-  return new FlowMap(
-    new Map(initial ? Object.entries(initial) : [])
-  );
+  return new MapNode(new Map(initial ? Object.entries(initial) : []));
 }
 
-class SolidState {
-  /**
-   * Returns the current value.
-   */
-  get;
-  /**
-   * Sets the value or updates it using a getter function.
-   */
-  set;
-  /**
-   * Creates a new SolidState with the given initial value.
-   * @param initialValue - The initial value.
-   */
-  constructor(initialValue) {
-    const [get, set] = createSignal(initialValue);
-    this.get = get;
-    this.set = set;
-  }
+function subscribe(data, onData, onError, onPending) {
+  return new EffectNode(data, onData, onError, onPending);
 }
-class SolidDerivation {
-  /**
-   * Returns the current derived value.
-   */
-  get;
-  /**
-   * Creates a new SolidDerivation from a getter function or value.
-   * @param calculator - The getter function or value.
-   */
-  constructor(calculator) {
-    const get = createMemo(calculator);
-    this.get = get;
+
+class SignalNode extends Observable {
+  subscribe(onTrigger, onError, onPending) {
+    if (this.disposed) throw new Error("[PicoFlow] Primitive is disposed");
+    const effect = new EffectNode((t) => this.watch(t), onTrigger, onError, onPending);
+    return effect;
   }
 }
-class SolidResource {
-  /**
-   * Returns the current value (or undefined if not yet loaded).
-   */
-  get;
-  /**
-   * Returns the current resource state.
-   */
-  state;
-  /**
-   * Returns the latest successfully loaded value (or undefined).
-   */
-  latest;
-  /**
-   * Triggers a refetch of the resource.
-   */
-  refetch;
-  set;
-  /**
-   * Creates a new SolidResource from a fetcher function.
-   * @param fetcher - The async fetcher function.
-   */
-  constructor(fetcher) {
-    const [get, set] = createResource(fetcher);
-    this.get = get;
-    this.state = () => get.state;
-    this.latest = () => get.latest;
-    this.refetch = () => set.refetch();
-    this.set = (value) => set.mutate(value);
-  }
+
+function signal() {
+  return new SignalNode();
+}
+
+function constant(initializer) {
+  return new ValueSyncNode(initializer);
+}
+
+function derivation(compute) {
+  return new ValueSyncNode(compute);
+}
+
+function state(valueOrInitializer) {
+  return new ValueSyncNode(valueOrInitializer);
+}
+
+function writableDerivation(compute) {
+  return new ValueSyncNode(compute);
 }
 
 function fromNode(node) {
-  let initialized = false;
-  const solidResource = new SolidResource(async () => {
-    let value;
-    if (initialized) {
-      value = await node.get(null);
-    } else {
-      value = await node.pick();
-      initialized = true;
-    }
-    return value;
-  });
+  const [resource, { refetch }] = createResource(() => node.pick());
   let fx;
   onMount(() => {
-    fx = new FlowEffect(async (t) => {
-      const watched = node.watch(t);
-      if (watched instanceof Promise) {
-        await watched;
+    fx = subscribe(
+      // data
+      (t) => node.get(t),
+      // onData
+      () => {
+        refetch();
+      },
+      // onError
+      () => {
+        refetch();
+      },
+      // onPending
+      () => {
+        refetch();
       }
-      solidResource.refetch();
-    });
+    );
+  });
+  createEffect(() => {
+    resource.error ?? resource();
+    resetErrorBoundaries();
   });
   onCleanup(() => fx.dispose());
-  return solidResource;
+  return resource;
 }
 function fromGetter(getter) {
-  const derivation = new FlowNodeAsync(async (t) => {
+  const derivation = new ValueSyncNode((t) => {
     return getter(t);
   });
   return fromNode(derivation);
 }
 function from(flow) {
-  if (flow instanceof FlowNodeAsync || flow instanceof FlowNode) {
+  if (flow instanceof ValueAsyncNode || flow instanceof ValueSyncNode) {
     return fromNode(flow);
   }
   if (typeof flow === "function") {
@@ -1653,4 +987,4 @@ function from(flow) {
   throw new Error("Invalid flow type");
 }
 
-export { FlowArray, FlowEffect, FlowGraph, FlowMap, FlowNode, FlowNodeAsync, FlowSignal, SolidDerivation, SolidResource, SolidState, array, constant, constantAsync, derivation, derivationAsync, effect, from, isDisposable, map, signal, state, stateAsync };
+export { array, constant, constantAsync, derivation, derivationAsync, from, isDisposable, map, signal, state, stateAsync, subscribe, writableDerivation, writableDerivationAsync };