@ersbeth/picoflow 2.1.0 → 2.3.0

package/dist/types/api/base/flowConfig.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Installs a global handler for errors that escape the reactive flush.
+ *
+ * All reactive work — recomputing derivations, running effects — happens inside an
+ * asynchronous flush. Without this hook, an error escaping the flush (an effect callback
+ * that throws with no `onError`, or a feedback loop between two effects) becomes an
+ * uncaught exception, which terminates a Node process. Installing a handler here makes
+ * that error catchable instead.
+ *
+ * Defaults to `console.error`. The handler replaces any previously installed handler —
+ * it is not additive.
+ *
+ * @param handler - Called with the error that escaped the flush.
+ *
+ * @public
+ */
+export declare function onFlushError(handler: (error: unknown) => void): void;

package/dist/types/api/base/flowDisposable.d.ts

@@ -38,4 +38,3 @@ export interface FlowDisposable {
  * @public
  */
 export declare function isDisposable(obj: unknown): obj is FlowDisposable;
-//# sourceMappingURL=flowDisposable.d.ts.map

package/dist/types/api/base/flowErrors.d.ts

@@ -0,0 +1 @@
+export { PicoFlowCycleError, PicoFlowDisposedError, PicoFlowError, PicoFlowInternalError } from '../../base/errors.js';

package/dist/types/api/base/flowObservable.d.ts

@@ -24,4 +24,3 @@ export interface FlowObservable<T> extends FlowDisposable, FlowSubscribable<T> {
      */
     trigger(): void;
 }
-//# sourceMappingURL=flowObservable.d.ts.map

package/dist/types/api/base/flowPrimitiveOptions.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Optional per-instance settings accepted by the primitive factories (`state`, `derivation`,
+ * `array`, `map`, `signal`, …).
+ *
+ * @public
+ */
+export interface FlowPrimitiveOptions {
+    /**
+     * Identifies this primitive in error messages, e.g. `"[PicoFlow] Primitive \"$count\" is disposed"`
+     * instead of the unnamed `"[PicoFlow] Primitive is disposed"`. Purely diagnostic — has no effect
+     * on reactive behavior.
+     */
+    name?: string;
+}

package/dist/types/api/base/flowSubscribable.d.ts

@@ -76,4 +76,3 @@ export interface FlowSubscribable<T> {
      */
     subscribe(onData: FlowOnDataListener<T>, onError?: FlowOnErrorListener, onPending?: FlowOnPendingListener): FlowEffect;
 }
-//# sourceMappingURL=flowSubscribable.d.ts.map

package/dist/types/api/base/flowTracker.d.ts

@@ -5,4 +5,3 @@ import { FlowDisposable } from './flowDisposable.js';
  */
 export interface FlowTracker extends FlowDisposable {
 }
-//# sourceMappingURL=flowTracker.d.ts.map

package/dist/types/api/base/index.d.ts

@@ -1,5 +1,7 @@
+export * from './flowConfig.js';
 export * from './flowDisposable.js';
+export * from './flowErrors.js';
 export * from './flowObservable.js';
+export * from './flowPrimitiveOptions.js';
 export * from './flowSubscribable.js';
 export * from './flowTracker.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/api/index.d.ts

@@ -1,3 +1,2 @@
 export * from './base/index.js';
 export * from './nodes/index.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/api/nodes/async/flowConstantAsync.d.ts

@@ -1,3 +1,4 @@
+import { FlowPrimitiveOptions } from '../../base/flowPrimitiveOptions.js';
 import { FlowValue } from '../flowValue.js';
 /** Function that initializes a value asynchronously. */
 export type InitFunctionAsync<T> = () => Promise<T>;
@@ -22,10 +23,10 @@ export interface FlowConstantAsync<T> extends FlowValue<T> {
  * reactive values, such as loading configuration or fetching initial data.
  *
  * @param value - Promise to resolve, or async function that returns a promise on first access
+ * @param options - Optional settings; `name` identifies this primitive in error messages
  * @returns A FlowConstantAsync that provides read-only access to the resolved value
  *
  * @public
  */
-export declare function constantAsync<T>(value: Promise<T>): FlowConstantAsync<T>;
-export declare function constantAsync<T>(initializer: InitFunctionAsync<T>): FlowConstantAsync<T>;
-//# sourceMappingURL=flowConstantAsync.d.ts.map
+export declare function constantAsync<T>(value: Promise<T>, options?: FlowPrimitiveOptions): FlowConstantAsync<T>;
+export declare function constantAsync<T>(initializer: InitFunctionAsync<T>, options?: FlowPrimitiveOptions): FlowConstantAsync<T>;

package/dist/types/api/nodes/async/flowDerivationAsync.d.ts

@@ -1,4 +1,4 @@
-import { FlowTracker } from '../../base/index.js';
+import { FlowPrimitiveOptions, FlowTracker } from '../../base/index.js';
 import { FlowValue } from '../flowValue.js';
 import { NotPromise } from '../utils.js';
 /** Function that derives a value asynchronously from dependencies and optionally the previous value. */
@@ -29,9 +29,9 @@ export interface FlowDerivationAsync<T> extends FlowValue<T> {
  * retry once resolved. Use for derived data from async sources like filtered API results or computed database queries.
  *
  * @param compute - Async function that accesses dependencies and returns a promise of the derived value
+ * @param options - Optional settings; `name` identifies this primitive in error messages
  * @returns A FlowDerivationAsync that provides read-only access to the resolved computed value
  *
  * @public
  */
-export declare function derivationAsync<T>(compute: DerivationFunctionAsync<T>): FlowDerivationAsync<T>;
-//# sourceMappingURL=flowDerivationAsync.d.ts.map
+export declare function derivationAsync<T>(compute: DerivationFunctionAsync<T>, options?: FlowPrimitiveOptions): FlowDerivationAsync<T>;

package/dist/types/api/nodes/async/flowStateAsync.d.ts

@@ -1,3 +1,4 @@
+import { FlowPrimitiveOptions } from '../../base/flowPrimitiveOptions.js';
 import { FlowValue } from '../flowValue.js';
 import { NotPromise } from '../utils.js';
 import { InitFunctionAsync } from './flowConstantAsync.js';
@@ -32,10 +33,10 @@ export interface FlowStateAsync<T> extends FlowValue<T> {
  * application logic, such as loading user profiles, fetching search results, or any async state updates.
  *
  * @param value - Initial promise to resolve, or lazy async initializer function
+ * @param options - Optional settings; `name` identifies this primitive in error messages
  * @returns A FlowStateAsync that can be read and modified with promises
  *
  * @public
  */
-export declare function stateAsync<T>(value: Promise<T>): FlowStateAsync<T>;
-export declare function stateAsync<T>(initializer: InitFunctionAsync<T>): FlowStateAsync<T>;
-//# sourceMappingURL=flowStateAsync.d.ts.map
+export declare function stateAsync<T>(value: Promise<T>, options?: FlowPrimitiveOptions): FlowStateAsync<T>;
+export declare function stateAsync<T>(initializer: InitFunctionAsync<T>, options?: FlowPrimitiveOptions): FlowStateAsync<T>;

package/dist/types/api/nodes/async/flowWritableDerivationAsync.d.ts

@@ -1,3 +1,4 @@
+import { FlowPrimitiveOptions } from '../../base/flowPrimitiveOptions.js';
 import { DerivationFunctionAsync, FlowDerivationAsync } from './flowDerivationAsync.js';
 import { FlowStateAsync } from './flowStateAsync.js';
 /**
@@ -22,9 +23,9 @@ export interface FlowWritableDerivationAsync<T> extends FlowStateAsync<T>, FlowD
  * such as editable async calculated fields or user-correctable async totals.
  *
  * @param compute - Async function that accesses dependencies and returns a promise of the derived value
+ * @param options - Optional settings; `name` identifies this primitive in error messages
  * @returns A FlowWritableDerivationAsync that provides both reactive async computation and manual control
  *
  * @public
  */
-export declare function writableDerivationAsync<T>(compute: DerivationFunctionAsync<T>): FlowWritableDerivationAsync<T>;
-//# sourceMappingURL=flowWritableDerivationAsync.d.ts.map
+export declare function writableDerivationAsync<T>(compute: DerivationFunctionAsync<T>, options?: FlowPrimitiveOptions): FlowWritableDerivationAsync<T>;

package/dist/types/api/nodes/async/index.d.ts

@@ -2,4 +2,3 @@ export * from './flowConstantAsync.js';
 export * from './flowDerivationAsync.js';
 export * from './flowStateAsync.js';
 export * from './flowWritableDerivationAsync.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/api/nodes/collections/flowArray.d.ts

@@ -1,3 +1,4 @@
+import { FlowPrimitiveOptions } from '../../base/flowPrimitiveOptions.js';
 import { FlowState } from '../sync/flowState.js';
 /**
  * Discriminated union representing all possible array mutation operations.
@@ -129,9 +130,9 @@ export interface FlowArray<T> extends FlowState<T[]> {
  * needs array-like operations with automatic change propagation.
  *
  * @param initial - Optional initial array of items
+ * @param options - Optional settings; `name` identifies this primitive in error messages
  * @returns A FlowArray with reactive mutation methods
  *
  * @public
  */
-export declare function array<T>(initial?: T[]): FlowArray<T>;
-//# sourceMappingURL=flowArray.d.ts.map
+export declare function array<T>(initial?: T[], options?: FlowPrimitiveOptions): FlowArray<T>;

package/dist/types/api/nodes/collections/flowMap.d.ts

@@ -1,3 +1,4 @@
+import { FlowPrimitiveOptions } from '../../base/flowPrimitiveOptions.js';
 import { FlowState } from '../sync/flowState.js';
 /**
  * Discriminated union representing all possible map mutation operations.
@@ -91,9 +92,9 @@ export interface FlowMap<K, V> extends FlowState<Map<K, V>> {
  * data that needs reactive updates.
  *
  * @param initial - Optional initial entries as a Record or Map
+ * @param options - Optional settings; `name` identifies this primitive in error messages
  * @returns A FlowMap with reactive mutation methods
  *
  * @public
  */
-export declare function map<K extends string | number | symbol, V>(initial?: Record<K, V> | Map<K, V>): FlowMap<K, V>;
-//# sourceMappingURL=flowMap.d.ts.map
+export declare function map<K extends string | number | symbol, V>(initial?: Record<K, V> | Map<K, V>, options?: FlowPrimitiveOptions): FlowMap<K, V>;

package/dist/types/api/nodes/collections/index.d.ts

@@ -1,3 +1,2 @@
 export * from './flowArray.js';
 export * from './flowMap.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/api/nodes/flowEffect.d.ts

@@ -26,4 +26,3 @@ export interface FlowEffect extends FlowDisposable {
  * @public
  */
 export declare function subscribe<T>(data: FlowDataTracker<T>, onData: FlowOnDataListener<T>, onError?: FlowOnErrorListener, onPending?: FlowOnPendingListener): FlowEffect;
-//# sourceMappingURL=flowEffect.d.ts.map

package/dist/types/api/nodes/flowSignal.d.ts

@@ -1,4 +1,5 @@
 import { FlowObservable } from '../base/flowObservable.js';
+import { FlowPrimitiveOptions } from '../base/flowPrimitiveOptions.js';
 /**
  * Manual trigger that notifies subscribers without carrying data.
  *
@@ -17,9 +18,9 @@ export interface FlowSignal extends FlowObservable<void> {
  * and reactive computations that depend on the signal. Unlike state or derivations, signals don't
  * carry data values - they simply represent that an event occurred.
  *
+ * @param options - Optional settings; `name` identifies this primitive in error messages
  * @returns A FlowSignal that can be triggered manually and subscribed to
  *
  * @public
  */
-export declare function signal(): FlowSignal;
-//# sourceMappingURL=flowSignal.d.ts.map
+export declare function signal(options?: FlowPrimitiveOptions): FlowSignal;

package/dist/types/api/nodes/flowValue.d.ts

@@ -33,4 +33,3 @@ export interface FlowValue<T> extends FlowObservable<T> {
      */
     pick(): Promise<T>;
 }
-//# sourceMappingURL=flowValue.d.ts.map

package/dist/types/api/nodes/index.d.ts

@@ -5,4 +5,3 @@ export * from './flowSignal.js';
 export * from './flowValue.js';
 export * from './sync/index.js';
 export * from './utils.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/api/nodes/sync/flowConstant.d.ts

@@ -1,3 +1,4 @@
+import { FlowPrimitiveOptions } from '../../base/flowPrimitiveOptions.js';
 import { FlowValue } from '../flowValue.js';
 import { NotPromise } from '../utils.js';
 /** Function that initializes a value. */
@@ -21,9 +22,9 @@ export interface FlowConstant<T> extends FlowValue<T> {
  * in the reactive graph. Useful for expensive one-time computations or static configuration.
  *
  * @param initializer - Function that computes the constant value on first access
+ * @param options - Optional settings; `name` identifies this primitive in error messages
  * @returns A FlowConstant that provides read-only access to the cached value
  *
  * @public
  */
-export declare function constant<T>(initializer: InitFunction<T>): FlowConstant<T>;
-//# sourceMappingURL=flowConstant.d.ts.map
+export declare function constant<T>(initializer: InitFunction<T>, options?: FlowPrimitiveOptions): FlowConstant<T>;

package/dist/types/api/nodes/sync/flowDerivation.d.ts

@@ -1,3 +1,4 @@
+import { FlowPrimitiveOptions } from '../../base/flowPrimitiveOptions.js';
 import { FlowTracker } from '../../base/flowTracker.js';
 import { FlowValue } from '../flowValue.js';
 import { NotPromise } from '../utils.js';
@@ -28,9 +29,9 @@ export interface FlowDerivation<T> extends FlowValue<T> {
  * synchronized with source state.
  *
  * @param compute - Function that accesses dependencies and computes the derived value
+ * @param options - Optional settings; `name` identifies this primitive in error messages
  * @returns A FlowDerivation that provides read-only access to the computed value
  *
  * @public
  */
-export declare function derivation<T>(compute: DerivationFunction<T>): FlowDerivation<T>;
-//# sourceMappingURL=flowDerivation.d.ts.map
+export declare function derivation<T>(compute: DerivationFunction<T>, options?: FlowPrimitiveOptions): FlowDerivation<T>;

package/dist/types/api/nodes/sync/flowState.d.ts

@@ -1,3 +1,4 @@
+import { FlowPrimitiveOptions } from '../../base/flowPrimitiveOptions.js';
 import { FlowValue } from '../flowValue.js';
 import { NotPromise } from '../utils.js';
 import { InitFunction } from './flowConstant.js';
@@ -30,10 +31,10 @@ export interface FlowState<T> extends FlowValue<T> {
  * changes through user actions, external events, or application logic rather than derived computations.
  *
  * @param value - Initial value for the state, or lazy initializer function
+ * @param options - Optional settings; `name` identifies this primitive in error messages
  * @returns A FlowState that can be read and modified
  *
  * @public
  */
-export declare function state<T>(value: NotPromise<T>): FlowState<T>;
-export declare function state<T>(initializer: InitFunction<T>): FlowState<T>;
-//# sourceMappingURL=flowState.d.ts.map
+export declare function state<T>(value: NotPromise<T>, options?: FlowPrimitiveOptions): FlowState<T>;
+export declare function state<T>(initializer: InitFunction<T>, options?: FlowPrimitiveOptions): FlowState<T>;

package/dist/types/api/nodes/sync/flowWritableDerivation.d.ts

@@ -1,3 +1,4 @@
+import { FlowPrimitiveOptions } from '../../base/flowPrimitiveOptions.js';
 import { DerivationFunction, FlowDerivation } from './flowDerivation.js';
 import { FlowState } from './flowState.js';
 /**
@@ -20,9 +21,9 @@ export interface FlowWritableDerivation<T> extends FlowState<T>, FlowDerivation<
  * derived but need occasional manual adjustments, such as editable calculated fields or user-correctable totals.
  *
  * @param compute - Function that accesses dependencies and computes the derived value
+ * @param options - Optional settings; `name` identifies this primitive in error messages
  * @returns A FlowWritableDerivation that provides both reactive computation and manual control
  *
  * @public
  */
-export declare function writableDerivation<T>(compute: DerivationFunction<T>): FlowWritableDerivation<T>;
-//# sourceMappingURL=flowWritableDerivation.d.ts.map
+export declare function writableDerivation<T>(compute: DerivationFunction<T>, options?: FlowPrimitiveOptions): FlowWritableDerivation<T>;

package/dist/types/api/nodes/sync/index.d.ts

@@ -2,4 +2,3 @@ export * from './flowConstant.js';
 export * from './flowDerivation.js';
 export * from './flowState.js';
 export * from './flowWritableDerivation.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/api/nodes/utils.d.ts

@@ -20,4 +20,3 @@ export type NotPromise<T> = T extends Promise<unknown> ? never : T;
  * @public
  */
 export type FlowReadonly<T> = Omit<FlowValue<T>, "set" | "refresh" | "trigger">;
-//# sourceMappingURL=utils.d.ts.map

package/dist/types/base/dependenciesRegistry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/base/dependentsRegistry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/base/disposable.d.ts

@@ -1,11 +1,15 @@
 import { FlowDisposable } from '../api/index.js';
+import { PicoFlowDisposedError } from './errors.js';
 /**
  * Base implementation of the disposable pattern for reactive primitives.
- * Throws an error if disposed multiple times.
+ * Concrete subclasses implement `dispose()` and are expected to throw if disposed multiple times.
  */
-export declare class Disposable implements FlowDisposable {
+export declare abstract class Disposable implements FlowDisposable {
     protected _disposed: boolean;
+    protected readonly _name?: string;
+    constructor(name?: string);
     get disposed(): boolean;
-    dispose(): void;
+    /** Builds the disposed-primitive error, naming the primitive when a `name` was given at creation. */
+    protected _disposedError(): PicoFlowDisposedError;
+    abstract dispose(): void;
 }
-//# sourceMappingURL=disposable.d.ts.map

package/dist/types/base/errors.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Base class for every typed error picoflow throws, so a consumer can `catch` a picoflow-specific
+ * failure with a single `instanceof PicoFlowError` check without matching on message text.
+ * @public
+ */
+export declare class PicoFlowError extends Error {
+    constructor(message: string);
+}
+/**
+ * Thrown when a disposed primitive (or its underlying scheduler) is read, written, or otherwise
+ * used after `dispose()`.
+ * @public
+ */
+export declare class PicoFlowDisposedError extends PicoFlowError {
+    constructor(message: string);
+}
+/**
+ * Thrown when the reactive flush detects a feedback loop that exceeds the maximum step guard.
+ * @public
+ */
+export declare class PicoFlowCycleError extends PicoFlowError {
+    constructor(message: string);
+}
+/**
+ * Thrown when a node reaches a state its own implementation considers unreachable. Reaching this
+ * indicates a picoflow bug rather than a misuse of the public API.
+ * @public
+ */
+export declare class PicoFlowInternalError extends PicoFlowError {
+    constructor(message: string);
+}

package/dist/types/base/executionStack.d.ts

@@ -11,20 +11,17 @@ export declare class ExecutionStack {
     private static readonly _effectQueue;
     private static _executionScheduled?;
     private static _coalesceResetScheduled;
+    /** Per-effect resets accumulated for the microtask scheduled below, so notifying more than one
+     * effect in the same sync turn doesn't discard every reset after the first (A2-SEM-5). */
+    private static _coalesceResets;
+    /** Routes any error escaping the flush loop; defaults to logging rather than crashing (A2-SEM-2, A2-SEC-1). */
+    private static _onFlushError;
     /**
      * 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.
      */
     private static _pastSyncTurn;
-    /** @internal Used by EffectNode to distinguish sync-batch from microtask notifications. */
-    static get pastSyncTurn(): boolean;
-    /**
-     * @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: () => void): void;
     static pushPending(node: IObserver): void;
     static pushEffect(effect: IObserver): void;
     private static _beginSyncTurn;
@@ -32,4 +29,3 @@ export declare class ExecutionStack {
     private static _drain;
     private static _execute;
 }
-//# sourceMappingURL=executionStack.d.ts.map

package/dist/types/base/index.d.ts

@@ -1,6 +1,8 @@
+export * from './dependenciesRegistry.js';
+export * from './dependentsRegistry.js';
 export * from './disposable.js';
+export * from './errors.js';
 export * from './executionStack.js';
 export * from './node.js';
 export * from './observable.js';
 export * from './observer.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/base/node.d.ts

@@ -6,8 +6,8 @@ import { IObserver } from './observer.js';
  * Base implementation for reactive nodes that propagate changes through the dependency graph.
  */
 export declare abstract class Node<T> extends Disposable implements IObservable<T>, IObserver {
-    private _dependencies;
-    private _dependents;
+    private _dependenciesRegistry;
+    private _dependentsRegistry;
     protected _status: ObservableStatus;
     get status(): ObservableStatus;
     set status(status: ObservableStatus);
@@ -16,12 +16,12 @@ export declare abstract class Node<T> extends Disposable implements IObservable<
     clearDependencies(): void;
     registerDependent(dependent: IObserver): void;
     unregisterDependent(dependent: IObserver): void;
+    markDependencyDisposed(): void;
     notifyDependents(): void;
     watch(tracker: FlowTracker): void;
     trigger(): void;
-    notify(): void;
     dispose(): void;
+    abstract notify(): void;
     abstract execute(): void;
     abstract subscribe(onValue: FlowOnDataListener<T>, onError?: FlowOnErrorListener, onPending?: FlowOnPendingListener): FlowEffect;
 }
-//# sourceMappingURL=node.d.ts.map

package/dist/types/base/observable.d.ts

@@ -20,7 +20,7 @@ export interface IObservable<T> extends FlowObservable<T> {
  * Base implementation managing the dependency graph for reactive observables.
  */
 export declare abstract class Observable<T> extends Disposable implements IObservable<T> {
-    private _dependents;
+    private _dependentsRegistry;
     protected _status: ObservableStatus;
     get status(): ObservableStatus;
     set status(status: ObservableStatus);
@@ -32,4 +32,3 @@ export declare abstract class Observable<T> extends Disposable implements IObser
     dispose(): void;
     abstract subscribe(onValue: FlowOnDataListener<T>, onError?: FlowOnErrorListener, onPending?: FlowOnPendingListener): FlowEffect;
 }
-//# sourceMappingURL=observable.d.ts.map

package/dist/types/base/observer.d.ts

@@ -9,12 +9,21 @@ export interface IObserver {
     clearDependencies(): void;
     notify(): void;
     execute(): void;
+    /**
+     * Called by a dependency's `dispose()` on each of its remaining dependents, so an
+     * observer already queued for the next flush can skip that run instead of reading
+     * through the now-disposed dependency and throwing (A2-SEM-1).
+     */
+    markDependencyDisposed(): void;
 }
 /**
  * Base implementation managing dependency tracking for reactive observers.
  */
 export declare abstract class Observer extends Disposable implements IObserver {
-    private _dependencies;
+    private _dependenciesRegistry;
+    /** Set when a dependency disposed while this observer was queued; consumed by the next execute(). */
+    protected _dependencyDisposed: boolean;
+    markDependencyDisposed(): void;
     registerDependency(dependency: IObservable<unknown>): void;
     unregisterDependency(dependency: IObservable<unknown>): void;
     clearDependencies(): void;
@@ -22,4 +31,3 @@ export declare abstract class Observer extends Disposable implements IObserver {
     abstract notify(): void;
     abstract execute(): void;
 }
-//# sourceMappingURL=observer.d.ts.map

package/dist/types/converters/index.d.ts

@@ -1,2 +1 @@
 export * from './solid.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/converters/solid.d.ts

@@ -47,4 +47,3 @@ import { FlowTracker, FlowValue, NotPromise } from '../api/index.js';
  */
 export declare function from<T>(flow: FlowValue<T>): Resource<T>;
 export declare function from<T>(flow: (t: FlowTracker) => NotPromise<T>): Resource<T>;
-//# sourceMappingURL=solid.d.ts.map

package/dist/types/index.d.ts

@@ -1,3 +1,2 @@
 export * from './api/index.js';
 export * from './converters/index.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/nodes/actionNode.d.ts

@@ -1,23 +1 @@
-import { FlowEffect, FlowOnDataListener, FlowOnErrorListener, FlowOnPendingListener, NotPromise, UpdateFunction } from '../api/index.js';
-import { ValueSyncNode } from './valueSyncNode.js';
-/**
- * Reactive state that tracks the latest action while delivering every emitted action
- * to `.subscribe()` callbacks, including multiple mutations within the same batch.
- *
- * Two read models:
- * - get() / pick(): last-write-wins snapshot (current action value).
- * - subscribe(): event stream — one onData call per emitted action, even when several
- *   mutations happen before the next flush. Each subscriber owns its own queue so
- *   delivery is not shared or stolen between subscribers.
- *
- * @internal
- */
-export declare class ActionNode<T extends NotPromise<unknown>> extends ValueSyncNode<T> {
-    private _slots;
-    private _enqueueForSubscribers;
-    set(value: NotPromise<T>): void;
-    set(updater: UpdateFunction<T>): void;
-    subscribe(onValue: FlowOnDataListener<T>, onError?: FlowOnErrorListener, onPending?: FlowOnPendingListener): FlowEffect;
-    dispose(): void;
-}
-//# sourceMappingURL=actionNode.d.ts.map
+export {};

package/dist/types/nodes/arrayNode.d.ts

@@ -1,26 +1 @@
-import { FlowArray, FlowArrayAction, FlowTracker, NotPromise, UpdateFunction } from '../api/index.js';
-import { ActionNode } from './actionNode.js';
-import { ValueSyncNode } from './valueSyncNode.js';
-/**
- * Internal implementation of reactive array with mutation tracking.
- * @internal
- */
-export declare class ArrayNode<T> extends ValueSyncNode<T[]> implements FlowArray<T> {
-    $lastAction: ActionNode<FlowArrayAction<T>>;
-    protected _value: T[];
-    constructor(value?: T[]);
-    get(tracker: FlowTracker): T[];
-    pick(): Promise<T[]>;
-    get length(): number;
-    set(items: NotPromise<T[]>): T[];
-    set(updater: UpdateFunction<T[]>): T[];
-    update(index: number, item: T): T | undefined;
-    push(item: T): void;
-    pop(): T | undefined;
-    unshift(item: T): void;
-    shift(): T | undefined;
-    splice(start: number, deleteCount: number, ...newItems: T[]): T[];
-    clear(): T[];
-    dispose(): void;
-}
-//# sourceMappingURL=arrayNode.d.ts.map
+export {};

package/dist/types/nodes/effectNode.d.ts

@@ -1,32 +1 @@
-import { FlowDataTracker, FlowEffect, FlowOnDataListener, FlowOnErrorListener, FlowOnPendingListener } from '../api/index.js';
-import { Observer } from '../base/index.js';
-/**
- * Reactive effect that automatically re-executes when its dependencies change.
- *
- * Scheduling uses epoch-based coalescing:
- * - Multiple dependency changes in the same synchronous turn produce one queue entry
- *   but may still require multiple runs when notifications arrive in later microtasks
- *   (e.g. async pending → resolved).
- * - Re-notifications during execute() (cascading effects) enqueue a fresh run because
- *   _queued is cleared at the start of execute().
- *
- * @internal
- */
-export declare class EffectNode<T> extends Observer implements FlowEffect {
-    private _data;
-    private _onData;
-    private _onError?;
-    private _onPending?;
-    /** True while this effect is already waiting in the effect queue for the next flush. */
-    private _queued;
-    /** Guards the single coalesced bump of _notifyEpoch while _queued during one sync turn. */
-    private _coalescedWhileQueued;
-    /** Monotonic count of notifications that must eventually be executed. */
-    private _notifyEpoch;
-    /** How many notification epochs have been executed so far. */
-    private _executedEpoch;
-    constructor(data: FlowDataTracker<T>, onData: FlowOnDataListener<T>, onError?: FlowOnErrorListener, onPending?: FlowOnPendingListener);
-    notify(): void;
-    execute(): void;
-}
-//# sourceMappingURL=effectNode.d.ts.map
+export {};

package/dist/types/nodes/index.d.ts

@@ -6,4 +6,3 @@ export * from './signalNode.js';
 export * from './valueAsyncNode.js';
 export * from './valueNode.js';
 export * from './valueSyncNode.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/nodes/mapNode.d.ts

@@ -1,20 +1 @@
-import { FlowMap, FlowMapAction, NotPromise, UpdateFunction } from '../api/index.js';
-import { ActionNode } from './actionNode.js';
-import { ValueSyncNode } from './valueSyncNode.js';
-/**
- * Internal implementation of reactive map with mutation tracking.
- * @internal
- */
-export declare class MapNode<K, V> extends ValueSyncNode<Map<K, V>> implements FlowMap<K, V> {
-    $lastAction: ActionNode<FlowMapAction<K, V>>;
-    protected _value: Map<K, V>;
-    constructor(value?: Map<K, V>);
-    add(key: K, value: V): void;
-    update(key: K, value: V): V;
-    delete(key: K): V;
-    set(map: NotPromise<Map<K, V>>): Map<K, V>;
-    set(updater: UpdateFunction<Map<K, V>>): Map<K, V>;
-    clear(): Map<K, V>;
-    dispose(): void;
-}
-//# sourceMappingURL=mapNode.d.ts.map
+export {};