@ersbeth/picoflow 1.1.1 → 2.0.0

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

@@ -0,0 +1,25 @@
+import { FlowObservable } from '../../../api/base';
+/**
+ * Manual trigger that notifies subscribers without carrying data.
+ *
+ * Unlike reactive state or derivations, signals don't hold values. They serve as event emitters
+ * that notify dependents when explicitly triggered. Use signals for side effects that should run
+ * in response to manual actions rather than data changes.
+ *
+ * @public
+ */
+export interface FlowSignal extends FlowObservable<void> {
+}
+/**
+ * Creates a signal that can be manually triggered to notify dependents.
+ *
+ * Signals act as event emitters in the reactive graph. Call `trigger()` to notify all subscribers
+ * 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.
+ *
+ * @returns A FlowSignal that can be triggered manually and subscribed to
+ *
+ * @public
+ */
+export declare function signal(): FlowSignal;
+//# sourceMappingURL=flowSignal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flowSignal.d.ts","sourceRoot":"","sources":["../../../../src/api/nodes/flowSignal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAGjD;;;;;;;;GAQG;AACH,MAAM,WAAW,UAAW,SAAQ,cAAc,CAAC,IAAI,CAAC;CAAG;AAE3D;;;;;;;;;;GAUG;AACH,wBAAgB,MAAM,IAAI,UAAU,CAEnC"}

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

@@ -0,0 +1,35 @@
+import { FlowObservable, FlowTracker } from '../../../api/base';
+/**
+ * Base interface for reactive values that can be read synchronously or asynchronously.
+ *
+ * FlowValue extends FlowObservable with methods to access the current value. Use `get()` to read
+ * the value reactively (establishing a dependency), or `pick()` to read it non-reactively. All
+ * value-based primitives (state, derivation, constant, and their async variants) implement this
+ * interface, providing a consistent API for value access across the reactive system.
+ *
+ * @public
+ */
+export interface FlowValue<T> extends FlowObservable<T> {
+    /**
+     * Gets the current value and establishes a reactive dependency.
+     *
+     * When called from within a reactive computation, this method registers the value as a dependency,
+     * ensuring the computation re-executes when the value changes. The value is computed on first access
+     * (if lazy) and then cached. For async values, throws PendingError while the value is resolving.
+     *
+     * @param tracker - Tracker that records this value as a dependency
+     * @returns The current value
+     */
+    get(tracker: FlowTracker): T;
+    /**
+     * Asynchronously gets the current value without establishing a reactive dependency.
+     *
+     * This method reads the value non-reactively, meaning it won't trigger re-execution of the calling
+     * computation when the value changes. The value is computed on first access (if lazy) and then cached.
+     * For async values, the promise resolves once the value is available.
+     *
+     * @returns Promise that resolves with the current value
+     */
+    pick(): Promise<T>;
+}
+//# sourceMappingURL=flowValue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flowValue.d.ts","sourceRoot":"","sources":["../../../../src/api/nodes/flowValue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9D;;;;;;;;;GASG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAC;IACnD;;;;;;;;;OASG;IACH,GAAG,CAAC,OAAO,EAAE,WAAW,GAAG,CAAC,CAAC;IAE7B;;;;;;;;OAQG;IACH,IAAI,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC;CACtB"}

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

@@ -0,0 +1,8 @@
+export * from './async';
+export * from './collections';
+export * from './flowEffect';
+export * from './flowSignal';
+export * from './flowValue';
+export * from './sync';
+export * from './utils';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/api/nodes/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC"}

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

@@ -0,0 +1,29 @@
+import { FlowValue } from '../flowValue';
+import { NotPromise } from '../utils';
+/** Function that initializes a value. */
+export type InitFunction<T> = () => NotPromise<T>;
+/**
+ * Read-only reactive value that computes once on initialization and never changes.
+ *
+ * Constants provide lazy initialization - the value isn't computed until first accessed via `get()` or `pick()`.
+ * Once computed, the value is cached forever. Use constants for expensive computations that only need to run once,
+ * such as loading configuration, computing static lookups, or initializing resources.
+ *
+ * @public
+ */
+export interface FlowConstant<T> extends FlowValue<T> {
+}
+/**
+ * Creates a constant reactive value that initializes lazily and never recomputes.
+ *
+ * The initializer function runs once on first access, and the result is cached permanently.
+ * Unlike state or derivations, constants never react to changes - they represent immutable values
+ * in the reactive graph. Useful for expensive one-time computations or static configuration.
+ *
+ * @param initializer - Function that computes the constant value on first access
+ * @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

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

@@ -0,0 +1 @@
+{"version":3,"file":"flowConstant.d.ts","sourceRoot":"","sources":["../../../../../src/api/nodes/sync/flowConstant.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAE3C,yCAAyC;AACzC,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,MAAM,UAAU,CAAC,CAAC,CAAC,CAAC;AAElD;;;;;;;;GAQG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC,CAAE,SAAQ,SAAS,CAAC,CAAC,CAAC;CAAG;AAExD;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,WAAW,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAEzE"}

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

@@ -0,0 +1,36 @@
+import { FlowTracker } from '../../base';
+import { FlowValue } from '../flowValue';
+import { NotPromise } from '../utils';
+/** Function that derives a value from dependencies and optionally the previous value. */
+export type DerivationFunction<T> = (tracker: FlowTracker, previous?: NotPromise<T> | undefined) => NotPromise<T>;
+/**
+ * Read-only reactive value that recomputes automatically when dependencies change.
+ *
+ * Derivations track reactive values accessed during computation and automatically recompute when any
+ * tracked dependency changes. The computed value is cached until dependencies change, avoiding unnecessary
+ * recomputations. Use derivations for values derived from other reactive state, such as filtered lists,
+ * computed properties, or aggregated data.
+ *
+ * @public
+ */
+export interface FlowDerivation<T> extends FlowValue<T> {
+    /**
+     * Forces the derivation to recompute even if dependencies haven't changed.
+     */
+    refresh(): void;
+}
+/**
+ * Creates a derived reactive value that automatically recomputes when dependencies change.
+ *
+ * The compute function runs when any tracked dependency changes, and the result is cached until the next change.
+ * Access reactive values within the compute function to establish dependencies automatically. The derivation
+ * computes lazily on first access and then reactively thereafter. Use for derived data that should stay
+ * synchronized with source state.
+ *
+ * @param compute - Function that accesses dependencies and computes the derived value
+ * @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

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

@@ -0,0 +1 @@
+{"version":3,"file":"flowDerivation.d.ts","sourceRoot":"","sources":["../../../../../src/api/nodes/sync/flowDerivation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAE3C,yFAAyF;AACzF,MAAM,MAAM,kBAAkB,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,WAAW,EAAE,QAAQ,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,SAAS,KAAK,UAAU,CAAC,CAAC,CAAC,CAAC;AAElH;;;;;;;;;GASG;AACH,MAAM,WAAW,cAAc,CAAC,CAAC,CAAE,SAAQ,SAAS,CAAC,CAAC,CAAC;IACnD;;OAEG;IACH,OAAO,IAAI,IAAI,CAAC;CACnB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAE/E"}

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

@@ -0,0 +1,39 @@
+import { FlowValue } from '../flowValue';
+import { NotPromise } from '../utils';
+import { InitFunction } from './flowConstant';
+/** Function that updates a value based on the previous value. */
+export type UpdateFunction<T> = (previous: NotPromise<T> | undefined) => NotPromise<T>;
+/**
+ * Writable reactive value that can be updated manually and notifies dependents on changes.
+ *
+ * State is the simplest writable reactive primitive. Unlike derivations, it has no dependencies and never
+ * recomputes automatically - changes only occur when you explicitly call `set()`. Use state for user input,
+ * application state, or any data that changes imperatively. Changes propagate automatically to all dependents.
+ *
+ * @public
+ */
+export interface FlowState<T> extends FlowValue<T> {
+    /**
+     * Updates the state with a new value or via an updater function.
+     * Notifies all dependents after the update.
+     *
+     * @param value - New value to set, or function that receives current value and returns new value
+     */
+    set(value: NotPromise<T>): void;
+    set(updater: UpdateFunction<T>): void;
+}
+/**
+ * Creates a mutable reactive state that can be read and updated imperatively.
+ *
+ * State can be initialized with a direct value or a lazy initializer function. Changes propagate
+ * automatically to all reactive computations that depend on this state. Use state for data that
+ * changes through user actions, external events, or application logic rather than derived computations.
+ *
+ * @param value - Initial value for the state, or lazy initializer function
+ * @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

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

@@ -0,0 +1 @@
+{"version":3,"file":"flowState.d.ts","sourceRoot":"","sources":["../../../../../src/api/nodes/sync/flowState.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD,iEAAiE;AACjE,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,SAAS,KAAK,UAAU,CAAC,CAAC,CAAC,CAAC;AAEvF;;;;;;;;GAQG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC,CAAE,SAAQ,SAAS,CAAC,CAAC,CAAC;IAC9C;;;;;OAKG;IACH,GAAG,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAChC,GAAG,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;CACzC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;AAC7D,wBAAgB,KAAK,CAAC,CAAC,EAAE,WAAW,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC"}

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

@@ -0,0 +1,28 @@
+import { DerivationFunction, FlowDerivation } from './flowDerivation';
+import { FlowState } from './flowState';
+/**
+ * Writable reactive value that recomputes automatically when dependencies change, but can be manually overridden.
+ *
+ * Writable derivations combine reactive computation with manual control. They track dependencies and recompute
+ * like regular derivations, but you can also call `set()` to override the computed value temporarily. Use this
+ * for computed values that users can edit, such as formatted fields, calculated totals that can be adjusted,
+ * or any value that is usually derived but sometimes needs manual correction.
+ *
+ * @public
+ */
+export interface FlowWritableDerivation<T> extends FlowState<T>, FlowDerivation<T> {
+}
+/**
+ * Creates a derived value that recomputes automatically but can also be manually overridden.
+ *
+ * The compute function tracks dependencies and recomputes when they change, just like a regular derivation.
+ * However, you can also call `set()` to override the computed value. Use this for values that are normally
+ * 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
+ * @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

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

@@ -0,0 +1 @@
+{"version":3,"file":"flowWritableDerivation.d.ts","sourceRoot":"","sources":["../../../../../src/api/nodes/sync/flowWritableDerivation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC3E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;;;;;;GASG;AACH,MAAM,WAAW,sBAAsB,CAAC,CAAC,CAAE,SAAQ,SAAS,CAAC,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC;CAAG;AAErF;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,OAAO,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAAG,sBAAsB,CAAC,CAAC,CAAC,CAE/F"}

package/dist/types/{flow → api}/nodes/sync/index.d.ts

@@ -1,6 +1,5 @@
 export * from './flowConstant';
 export * from './flowDerivation';
-export * from './flowNode';
-export * from './flowReadonly';
 export * from './flowState';
+export * from './flowWritableDerivation';
 //# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/api/nodes/sync/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAc,0BAA0B,CAAC"}

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

@@ -0,0 +1,22 @@
+/**
+ * Type that excludes Promise values from a type union.
+ *
+ * This utility type ensures that synchronous reactive primitives (like `state`, `constant`, `derivation`)
+ * only accept non-Promise values. Use this to prevent accidental mixing of sync and async values, which
+ * would cause runtime errors. For async values, use the async variants (like `stateAsync`, `constantAsync`).
+ *
+ * @public
+ */
+export type NotPromise<T> = T extends Promise<unknown> ? never : T;
+/**
+ * Type that restricts mutation methods to create read-only versions of reactive primitives.
+ *
+ * This utility type removes mutation methods (`set`, `refresh`, `trigger`) from a reactive primitive,
+ * creating a read-only interface. Use this when you want to expose reactive values to consumers who
+ * should observe but not modify them, such as passing state to child components or external modules
+ * while maintaining encapsulation of write access.
+ *
+ * @public
+ */
+export type FlowReadonly<T> = Omit<T, "set" | "refresh" | "trigger">;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/api/nodes/utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,SAAS,OAAO,CAAC,OAAO,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC;AAEnE;;;;;;;;;GASG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,KAAK,GAAG,SAAS,GAAG,SAAS,CAAC,CAAC"}

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

@@ -0,0 +1,11 @@
+import { FlowDisposable } from '../../api/base/flowDisposable';
+/**
+ * Base implementation of the disposable pattern for reactive primitives.
+ * Throws an error if disposed multiple times.
+ */
+export declare class Disposable implements FlowDisposable {
+    protected _disposed: boolean;
+    get disposed(): boolean;
+    dispose(): void;
+}
+//# sourceMappingURL=disposable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"disposable.d.ts","sourceRoot":"","sources":["../../../src/base/disposable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAEhE;;;GAGG;AACH,qBAAa,UAAW,YAAW,cAAc;IAC7C,SAAS,CAAC,SAAS,UAAS;IAE5B,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED,OAAO,IAAI,IAAI;CAIlB"}

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

@@ -0,0 +1,14 @@
+import { IObserver } from './observer';
+/**
+ * Global scheduler that batches and executes reactive computations asynchronously.
+ */
+export declare class ExecutionStack {
+    private static readonly _pendingQueue;
+    private static readonly _effectQueue;
+    private static _executionScheduled?;
+    static pushPending(node: IObserver): void;
+    static pushEffect(effect: IObserver): void;
+    private static _scheduleExecution;
+    private static _execute;
+}
+//# sourceMappingURL=executionStack.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"executionStack.d.ts","sourceRoot":"","sources":["../../../src/base/executionStack.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C;;GAEG;AACH,qBAAa,cAAc;IACvB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAmB;IACxD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,YAAY,CAAmB;IACvD,OAAO,CAAC,MAAM,CAAC,mBAAmB,CAAC,CAAgB;IAEnD,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI;IAKzC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI;IAK1C,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAWjC,OAAO,CAAC,MAAM,CAAC,QAAQ;CAU1B"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/base/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,QAAQ,CAAC;AACvB,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC"}

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

@@ -0,0 +1,27 @@
+import { FlowEffect, FlowOnDataListener, FlowOnErrorListener, FlowOnPendingListener, FlowTracker } from '../../api';
+import { Disposable } from './disposable';
+import { IObservable, ObservableStatus } from './observable';
+import { IObserver } from './observer';
+/**
+ * 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;
+    protected _status: ObservableStatus;
+    get status(): ObservableStatus;
+    set status(status: ObservableStatus);
+    registerDependency(dependency: IObservable<unknown>): void;
+    unregisterDependency(dependency: IObservable<unknown>): void;
+    clearDependencies(): void;
+    registerDependent(dependent: IObserver): void;
+    unregisterDependent(dependent: IObserver): void;
+    notifyDependents(): void;
+    watch(tracker: FlowTracker): void;
+    trigger(): void;
+    notify(): void;
+    dispose(): void;
+    abstract execute(): void;
+    abstract subscribe(onValue: FlowOnDataListener<T>, onError?: FlowOnErrorListener, onPending?: FlowOnPendingListener): FlowEffect;
+}
+//# sourceMappingURL=node.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/base/node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,WAAW,EAAE,MAAM,OAAO,CAAC;AACrH,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAClE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C;;GAEG;AACH,8BAAsB,IAAI,CAAC,CAAC,CAAE,SAAQ,UAAW,YAAW,WAAW,CAAC,CAAC,CAAC,EAAE,SAAS;IACjF,OAAO,CAAC,aAAa,CAAmC;IACxD,OAAO,CAAC,WAAW,CAAwB;IAC3C,SAAS,CAAC,OAAO,EAAE,gBAAgB,CAAc;IAEjD,IAAI,MAAM,IAAI,gBAAgB,CAG7B;IAED,IAAI,MAAM,CAAC,MAAM,EAAE,gBAAgB,EAGlC;IAED,kBAAkB,CAAC,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,GAAG,IAAI;IAM1D,oBAAoB,CAAC,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,GAAG,IAAI;IAM5D,iBAAiB,IAAI,IAAI;IAQzB,iBAAiB,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI;IAK7C,mBAAmB,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI;IAK/C,gBAAgB,IAAI,IAAI;IAOxB,KAAK,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;IAKjC,OAAO,IAAI,IAAI;IAKf,MAAM,IAAI,IAAI;IAOL,OAAO,IAAI,IAAI;IAaxB,QAAQ,CAAC,OAAO,IAAI,IAAI;IAExB,QAAQ,CAAC,SAAS,CACd,OAAO,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC9B,OAAO,CAAC,EAAE,mBAAmB,EAC7B,SAAS,CAAC,EAAE,qBAAqB,GAClC,UAAU;CAChB"}

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

@@ -0,0 +1,37 @@
+import { FlowEffect, FlowTracker } from '../../api';
+import { FlowObservable } from '../../api/base/flowObservable';
+import { FlowOnDataListener, FlowOnErrorListener, FlowOnPendingListener } from '../../api/base/flowSubscribable';
+import { Disposable } from './disposable';
+import { IObserver } from './observer';
+/**
+ * Status of an observable: resolved (has value), pending (async in progress), error (failed), or dirty (needs recomputation).
+ */
+export type ObservableStatus = "resolved" | "pending" | "error" | "dirty";
+/**
+ * Internal interface extending FlowObservable with dependency graph management methods.
+ */
+export interface IObservable<T> extends FlowObservable<T> {
+    get status(): ObservableStatus;
+    set status(status: ObservableStatus);
+    registerDependent(dependent: IObserver): void;
+    unregisterDependent(dependent: IObserver): void;
+    notifyDependents(): void;
+    subscribe(onValue: FlowOnDataListener<T>, onError?: FlowOnErrorListener, onPending?: FlowOnPendingListener): FlowEffect;
+}
+/**
+ * Base implementation managing the dependency graph for reactive observables.
+ */
+export declare abstract class Observable<T> extends Disposable implements IObservable<T> {
+    private _dependents;
+    protected _status: ObservableStatus;
+    get status(): ObservableStatus;
+    set status(status: ObservableStatus);
+    registerDependent(dependent: IObserver): void;
+    unregisterDependent(dependent: IObserver): void;
+    notifyDependents(): void;
+    watch(tracker: FlowTracker): void;
+    trigger(): void;
+    dispose(): void;
+    abstract subscribe(onValue: FlowOnDataListener<T>, onError?: FlowOnErrorListener, onPending?: FlowOnPendingListener): FlowEffect;
+}
+//# sourceMappingURL=observable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"observable.d.ts","sourceRoot":"","sources":["../../../src/base/observable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,OAAO,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,KAAK,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AAClH,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,UAAU,GAAG,SAAS,GAAG,OAAO,GAAG,OAAO,CAAC;AAE1E;;GAEG;AACH,MAAM,WAAW,WAAW,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAC;IACrD,IAAI,MAAM,IAAI,gBAAgB,CAAC;IAC/B,IAAI,MAAM,CAAC,MAAM,EAAE,gBAAgB,EAAE;IACrC,iBAAiB,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI,CAAC;IAC9C,mBAAmB,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI,CAAC;IAChD,gBAAgB,IAAI,IAAI,CAAC;IACzB,SAAS,CACL,OAAO,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC9B,OAAO,CAAC,EAAE,mBAAmB,EAC7B,SAAS,CAAC,EAAE,qBAAqB,GAClC,UAAU,CAAC;CACjB;AAED;;GAEG;AACH,8BAAsB,UAAU,CAAC,CAAC,CAAE,SAAQ,UAAW,YAAW,WAAW,CAAC,CAAC,CAAC;IAC5E,OAAO,CAAC,WAAW,CAAwB;IAC3C,SAAS,CAAC,OAAO,EAAE,gBAAgB,CAAc;IAEjD,IAAI,MAAM,IAAI,gBAAgB,CAG7B;IAED,IAAI,MAAM,CAAC,MAAM,EAAE,gBAAgB,EAGlC;IAED,iBAAiB,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI;IAK7C,mBAAmB,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI;IAK/C,gBAAgB,IAAI,IAAI;IAOxB,KAAK,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;IAKjC,OAAO,IAAI,IAAI;IAKN,OAAO,IAAI,IAAI;IAUxB,QAAQ,CAAC,SAAS,CACd,OAAO,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC9B,OAAO,CAAC,EAAE,mBAAmB,EAC7B,SAAS,CAAC,EAAE,qBAAqB,GAClC,UAAU;CAChB"}

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

@@ -0,0 +1,25 @@
+import { Disposable } from './disposable';
+import { IObservable } from './observable';
+/**
+ * Internal interface for reactive computations that track dependencies and respond to changes.
+ */
+export interface IObserver {
+    registerDependency(dependency: IObservable<unknown>): void;
+    unregisterDependency(dependency: IObservable<unknown>): void;
+    clearDependencies(): void;
+    notify(): void;
+    execute(): void;
+}
+/**
+ * Base implementation managing dependency tracking for reactive observers.
+ */
+export declare abstract class Observer extends Disposable implements IObserver {
+    private _dependencies;
+    registerDependency(dependency: IObservable<unknown>): void;
+    unregisterDependency(dependency: IObservable<unknown>): void;
+    clearDependencies(): void;
+    dispose(): void;
+    abstract notify(): void;
+    abstract execute(): void;
+}
+//# sourceMappingURL=observer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"observer.d.ts","sourceRoot":"","sources":["../../../src/base/observer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD;;GAEG;AACH,MAAM,WAAW,SAAS;IACtB,kBAAkB,CAAC,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC;IAC3D,oBAAoB,CAAC,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC;IAC7D,iBAAiB,IAAI,IAAI,CAAC;IAC1B,MAAM,IAAI,IAAI,CAAC;IACf,OAAO,IAAI,IAAI,CAAC;CACnB;AAED;;GAEG;AACH,8BAAsB,QAAS,SAAQ,UAAW,YAAW,SAAS;IAClE,OAAO,CAAC,aAAa,CAAmC;IAExD,kBAAkB,CAAC,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,GAAG,IAAI;IAM1D,oBAAoB,CAAC,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,GAAG,IAAI;IAM5D,iBAAiB,IAAI,IAAI;IAQhB,OAAO,IAAI,IAAI;IAQxB,QAAQ,CAAC,MAAM,IAAI,IAAI;IACvB,QAAQ,CAAC,OAAO,IAAI,IAAI;CAC3B"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/converters/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC"}

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

@@ -0,0 +1,46 @@
+import { Resource } from 'solid-js';
+import { FlowObservable, FlowTracker, NotPromise } from '../../api';
+/**
+ * Converts a PicoFlow observable or getter function into a SolidJS resource.
+ *
+ * @param flow - The FlowObservable or getter function to convert.
+ * @returns A SolidJS Resource that wraps the value or computation.
+ *
+ * @remarks
+ * This function bridges PicoFlow's reactive system with SolidJS, allowing you to use
+ * PicoFlow primitives and computations within Solid components. All conversions return a
+ * SolidJS Resource, which can handle both synchronous and asynchronous values seamlessly.
+ *
+ * The conversion works with:
+ * - **FlowObservable**: Any PicoFlow reactive primitive (e.g., from `state()`, `derivation()`, `stateAsync()`, `derivationAsync()`)
+ * - **Getter functions**: Computation functions that use a FlowTracker to access reactive values
+ *
+ * The created Resource automatically subscribes to the PicoFlow observables and updates
+ * when their values change. The subscription is properly cleaned up when the Solid
+ * component unmounts.
+ *
+ * @example
+ * ```typescript
+ * import { from } from 'picoflow/solid';
+ * import { state, derivation } from 'picoflow';
+ *
+ * // Convert a PicoFlow state to a Solid resource
+ * const $count = state(0);
+ * const solidCount = from($count);
+ *
+ * // Use in a Solid component
+ * function Counter() {
+ *   return <div>Count: {solidCount()}</div>;
+ * }
+ *
+ * // Or convert a computation function
+ * const solidDerived = from((t) => {
+ *   return $count.get(t) * 2;
+ * });
+ * ```
+ *
+ * @public
+ */
+export declare function from<T>(flow: FlowObservable<T>): Resource<T>;
+export declare function from<T>(flow: (t: FlowTracker) => NotPromise<T>): Resource<T>;
+//# sourceMappingURL=solid.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"solid.d.ts","sourceRoot":"","sources":["../../../src/converters/solid.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoD,KAAK,QAAQ,EAAwB,MAAM,UAAU,CAAC;AACjH,OAAO,EAAmB,KAAK,cAAc,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAa,MAAM,OAAO,CAAC;AAsD3G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;AAC9D,wBAAgB,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,WAAW,KAAK,UAAU,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC"}

package/dist/types/index.d.ts

@@ -1,64 +1,3 @@
-/**
- * @packageDocumentation
- *
- * # PicoFlow
- *
- * PicoFlow is a lightweight reactive dataflow library that provides a comprehensive set of
- * reactive primitives for building reactive applications with explicit dependency tracking.
- *
- * ## Core Concepts
- *
- * **Reactive Primitives:**
- * - {@link FlowSignal}: Event-like notifications without values
- * - {@link FlowState}: Mutable reactive values
- * - {@link FlowConstant}: Immutable reactive values (computed once)
- * - {@link FlowDerivation}: Computed values that track dependencies
- * - {@link FlowEffect}: Side effects that run when dependencies change
- *
- * **Advanced Primitives:**
- * - {@link FlowArray}: Reactive arrays with mutation tracking
- * - {@link FlowMap}: Reactive maps with operation tracking
- * - {@link FlowResource}: Async data fetching returning `T | undefined`
- * - {@link FlowResourceAsync}: Async data fetching returning `Promise<T>`
- * - {@link FlowStream}: Event streams from external sources
- * - {@link FlowStreamAsync}: Async event streams returning Promises
- *
- * **Tracking Context:**
- * - {@link TrackingContext}: The core mechanism for explicit dependency tracking
- * - Use `observable.get(t)` to read with tracking
- * - Use `observable.pick()` to read without tracking
- * - Use `signal.watch(t)` to track signals without values
- *
- * ## Key Features
- *
- * - **Explicit tracking**: Full control over what triggers re-execution via TrackingContext
- * - **Lazy evaluation**: Derivations compute only when accessed
- * - **Fine-grained reactivity**: Track specific operations on collections
- * - **Resource management**: Automatic cleanup with dispose patterns
- * - **SolidJS integration**: Seamless bridge to SolidJS primitives
- *
- * ## Basic Usage
- *
- * ```typescript
- * import { state, effect, derivation } from 'picoflow';
- *
- * // Create reactive state
- * const $count = state(0);
- *
- * // Create derived value
- * const $double = derivation((t) => $count.get(t) * 2);
- *
- * // Create effect
- * effect((t) => {
- *   console.log('Count:', $count.get(t), 'Double:', $double.get(t));
- * });
- *
- * // Update state
- * $count.set(1); // Logs: "Count: 1 Double: 2"
- * ```
- *
- * @see {@link https://github.com/yourusername/picoflow | GitHub Repository}
- */
-export * from './flow';
-export * from './solid';
+export * from './api';
+export * from './converters';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AAEH,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC;AACtB,cAAc,cAAc,CAAC"}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=arrayNode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"arrayNode.d.ts","sourceRoot":"","sources":["../../../src/nodes/arrayNode.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=effectNode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"effectNode.d.ts","sourceRoot":"","sources":["../../../src/nodes/effectNode.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,9 @@
+export * from '../base/executionStack';
+export * from './arrayNode';
+export * from './effectNode';
+export * from './mapNode';
+export * from './signalNode';
+export * from './valueAsyncNode';
+export * from './valueNode';
+export * from './valueSyncNode';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/nodes/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC"}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mapNode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mapNode.d.ts","sourceRoot":"","sources":["../../../src/nodes/mapNode.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=signalNode.d.ts.map

package/dist/types/nodes/signalNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signalNode.d.ts","sourceRoot":"","sources":["../../../src/nodes/signalNode.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=valueAsyncNode.d.ts.map

package/dist/types/nodes/valueAsyncNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueAsyncNode.d.ts","sourceRoot":"","sources":["../../../src/nodes/valueAsyncNode.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=valueNode.d.ts.map

package/dist/types/nodes/valueNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueNode.d.ts","sourceRoot":"","sources":["../../../src/nodes/valueNode.ts"],"names":[],"mappings":""}