@volynets/reflex 0.1.1 → 0.1.2

package/dist/globals.d.ts

@@ -171,7 +171,84 @@ declare global {
   const __DEV__: boolean;
 }
 
+/**
+ * Creates a lazy derived accessor.
+ *
+ * `computed` runs `fn` only when the returned accessor is read. During that
+ * evaluation it tracks the reactive values that `fn` touches, caches the
+ * result, and reuses the cached value for subsequent clean reads.
+ *
+ * @typeParam T - Derived value type.
+ *
+ * @param fn - Pure synchronous computation that derives a value from reactive
+ * reads.
+ *
+ * @returns Tracked accessor that returns the latest derived value.
+ *
+ * @example
+ * ```ts
+ * createRuntime();
+ *
+ * const [count, setCount] = signal(1);
+ * const doubled = computed(() => count() * 2);
+ *
+ * console.log(doubled()); // 2
+ *
+ * setCount(2);
+ *
+ * console.log(doubled()); // 4
+ * ```
+ *
+ * @remarks
+ * - `fn` does not run until the first read.
+ * - Dependencies are tracked dynamically on each execution, so branch changes
+ *   automatically update the dependency set.
+ * - Dirty computeds recompute on demand when read again.
+ * - Reading a computed does not require `rt.flush()`; `flush()` is only for
+ *   scheduled effects.
+ * - Keep `fn` pure and synchronous.
+ *
+ * @see memo
+ * @see effect
+ */
 declare function computed<T>(fn: () => T): Accessor<T>;
+/**
+ * Creates a computed accessor and warms it eagerly once.
+ *
+ * `memo` has the same dependency tracking and caching semantics as
+ * `computed()`, but it performs one eager read immediately after creation.
+ * This is useful when you want the initial value materialized up front while
+ * still interacting with a normal accessor afterward.
+ *
+ * @typeParam T - Derived value type.
+ *
+ * @param fn - Pure synchronous computation that derives a value from reactive
+ * reads.
+ *
+ * @returns Tracked accessor that returns the latest memoized value.
+ *
+ * @example
+ * ```ts
+ * createRuntime();
+ *
+ * const [price, setPrice] = signal(100);
+ * const total = memo(() => price() * 1.2);
+ *
+ * console.log(total()); // 120
+ *
+ * setPrice(200);
+ *
+ * console.log(total()); // 240
+ * ```
+ *
+ * @remarks
+ * - `memo(fn)` is equivalent to `computed(fn)` plus one immediate warm-up read.
+ * - After the warm-up, clean reads reuse the cached value exactly like
+ *   `computed()`.
+ * - Later invalidations still follow normal computed semantics.
+ *
+ * @see computed
+ */
 declare function memo<T>(fn: () => T): Accessor<T>;
 
 /**
@@ -207,14 +284,14 @@ interface Reactivable {
 type ComputeFn<T> = (() => T) | null;
 declare class ReactiveNode<T = unknown> implements Reactivable {
     state: number;
-    compute: ComputeFn<T>;
     firstOut: ReactiveEdge | null;
     firstIn: ReactiveEdge | null;
     lastOut: ReactiveEdge | null;
     lastIn: ReactiveEdge | null;
     depsTail: ReactiveEdge | null;
+    compute: ComputeFn<T>;
     payload: T;
-    constructor(payload: T | undefined, compute: ComputeFn<T>, state: number);
+    constructor(payload: T, compute: ComputeFn<T>, state: number);
 }
 
 /**
@@ -223,13 +300,14 @@ declare class ReactiveNode<T = unknown> implements Reactivable {
  * incoming list, so pointer rewrites must keep both views in sync.
  */
 declare class ReactiveEdge {
-    from: ReactiveNode;
-    to: ReactiveNode;
+    version: number;
     prevOut: ReactiveEdge | null;
     nextOut: ReactiveEdge | null;
+    from: ReactiveNode;
+    to: ReactiveNode;
     prevIn: ReactiveEdge | null;
     nextIn: ReactiveEdge | null;
-    constructor(from: ReactiveNode, to: ReactiveNode, prevOut: ReactiveEdge | null, nextOut: ReactiveEdge | null, prevIn: ReactiveEdge | null, nextIn: ReactiveEdge | null);
+    constructor(version: number, prevOut: ReactiveEdge | null, nextOut: ReactiveEdge | null, from: ReactiveNode, to: ReactiveNode, prevIn: ReactiveEdge | null, nextIn: ReactiveEdge | null);
 }
 
 interface EngineHooks {
@@ -237,63 +315,241 @@ interface EngineHooks {
     onReactiveSettled?(): void;
 }
 type CleanupRegistrar = (cleanup: () => void) => void;
+type TrackReadFallback = (source: ReactiveNode, consumer: ReactiveNode, prev: ReactiveEdge | null, nextExpected: ReactiveEdge | null, version: number) => ReactiveEdge;
+interface ExecutionContextOptions {
+    trackReadFallback?: TrackReadFallback;
+}
 type OnEffectInvalidatedHook = EngineHooks["onEffectInvalidated"];
 type OnReactiveSettledHook = EngineHooks["onReactiveSettled"];
-/**
- * ExecutionContext управляет состоянием вычисления и уведомлениями host'у.
- *
- * Ключевые принципы:
- * - Контекст НЕ глобальный - это объект, передаваемый по параметрам
- * - Host полностью контролирует scheduling эффектов
- * - Контекст только отслеживает текущее состояние вычисления
- *
- * Поля:
- * - activeComputed: текущий узел в процессе вычисления (для trackRead)
- * - propagationDepth: глубина каскада инвалидаций
- * - cleanupRegistrar: функция для регистрации cleanup в эффектах
- */
 declare class ExecutionContext {
     activeComputed: ReactiveNode | null;
+    trackingVersion: number;
     propagationDepth: number;
     cleanupRegistrar: CleanupRegistrar | null;
-    readonly hooks: EngineHooks;
-    onEffectInvalidatedHook: OnEffectInvalidatedHook;
-    onReactiveSettledHook: OnReactiveSettledHook;
-    private hookMask;
-    constructor(hooks?: EngineHooks);
+    trackReadFallback: TrackReadFallback;
+    onEffectInvalidated: OnEffectInvalidatedHook;
+    onReactiveSettled: OnReactiveSettledHook;
+    runtimeOnEffectInvalidated: OnEffectInvalidatedHook;
+    runtimeOnReactiveSettled: OnReactiveSettledHook;
+    effectInvalidatedDispatch: OnEffectInvalidatedHook;
+    settledDispatch: OnReactiveSettledHook;
+    constructor(hooks?: EngineHooks, options?: ExecutionContextOptions);
     dispatchWatcherEvent(node: ReactiveNode): void;
     maybeNotifySettled(): void;
     enterPropagation(): void;
     leavePropagation(): void;
     resetState(): void;
+    setOptions(options?: ExecutionContextOptions): void;
     setHooks(hooks?: EngineHooks): void;
+    setRuntimeHooks(onEffectInvalidated?: OnEffectInvalidatedHook, onReactiveSettled?: OnReactiveSettledHook): void;
     registerWatcherCleanup(cleanup: () => void): void;
     withCleanupRegistrar<T>(registrar: CleanupRegistrar | null, fn: () => T): T;
-    private setOnEffectInvalidatedHook;
-    private setOnReactiveSettledHook;
-    private updateHookMask;
+    private refreshDispatchers;
 }
 
 
+/**
+ * Callback used to register cleanup produced by nested helpers with an
+ * enclosing effect scope.
+ */
+type EffectCleanupRegistrar = (cleanup: Destructor) => void;
+/**
+ * Runs `fn` with a temporary cleanup registrar installed on the active runtime
+ * context.
+ *
+ * Helpers that allocate resources during `fn` can forward their teardown to
+ * `registrar`, allowing the surrounding effect or integration to dispose them
+ * automatically.
+ *
+ * @typeParam T - Return type of `fn`.
+ *
+ * @param registrar - Cleanup registrar to expose during `fn`, or `null` to run
+ * without one.
+ * @param fn - Callback executed with the temporary registrar installed.
+ *
+ * @returns The value returned by `fn`.
+ *
+ * @remarks
+ * - The registrar is scoped to the duration of `fn`.
+ * - This is a low-level integration helper. Most application code should use
+ *   `effect()` directly.
+ */
+declare function withEffectCleanupRegistrar<T>(registrar: EffectCleanupRegistrar | null, fn: () => T): T;
+/**
+ * Creates a reactive effect.
+ *
+ * `effect` runs `fn` immediately, tracks any reactive values read during that
+ * run, and schedules re-execution when those dependencies change.
+ *
+ * @param fn - Effect body. It may return a cleanup function that runs before
+ * the next execution and when the effect is disposed.
+ *
+ * @returns Destructor that disposes the effect and runs the latest cleanup, if
+ * present.
+ *
+ * @example
+ * ```ts
+ * const rt = createRuntime();
+ * const [count, setCount] = signal(0);
+ *
+ * const stop = effect(() => {
+ *   console.log(count());
+ * });
+ *
+ * setCount(1);
+ * rt.flush();
+ *
+ * stop();
+ * ```
+ *
+ * @remarks
+ * - The first run happens synchronously during `effect()` creation.
+ * - With the default runtime strategy, later re-runs are queued until
+ *   `rt.flush()`.
+ * - With `createRuntime({ effectStrategy: "sab" })`, invalidations stay lazy
+ *   during propagation but auto-deliver after the outermost `rt.batch()`.
+ * - With `createRuntime({ effectStrategy: "eager" })`, invalidations flush
+ *   automatically.
+ * - Reads performed inside cleanup do not become dependencies of the next run.
+ * - Disposing the returned scope prevents future re-runs.
+ *
+ * @see createRuntime
+ * @see computed
+ * @see memo
+ */
 declare function effect(fn: EffectFn): Destructor;
 
-type EffectStrategy = "flush" | "eager";
+type EffectStrategy = "flush" | "eager" | "sab";
 
 interface RuntimeOptions {
+    /**
+     * Optional low-level runtime hooks forwarded to the execution context.
+     *
+     * These hooks are composed with Reflex's scheduler integration rather than
+     * replacing it.
+     */
     hooks?: EngineHooks;
+    /**
+     * Controls when invalidated effects are executed.
+     *
+     * - `"flush"` queues reruns until `rt.flush()` is called.
+     * - `"sab"` keeps lazy enqueue semantics but stabilizes effects after the
+     *   outermost `rt.batch()` exits.
+     * - `"eager"` flushes reruns automatically.
+     *
+     * @default "flush"
+     */
     effectStrategy?: EffectStrategy;
 }
+/**
+ * Push-based event stream that allows observers to subscribe to future values.
+ *
+ * `Event` is the read-only view of an event source. It does not expose
+ * mutation, only observation.
+ *
+ * @typeParam T - Event payload type.
+ */
 interface Event<T> {
+    /**
+     * Registers a callback for future event deliveries.
+     *
+     * @param fn - Callback invoked for each emitted value.
+     *
+     * @returns Destructor that unsubscribes `fn`.
+     */
     subscribe(fn: (value: T) => void): Destructor;
 }
+/**
+ * Mutable event source created by `Runtime.event()`.
+ *
+ * @typeParam T - Event payload type.
+ */
 interface EventSource<T> extends Event<T> {
+    /**
+     * Emits a value to current subscribers using the runtime dispatcher.
+     *
+     * Nested emits are queued after the current delivery completes, preserving
+     * FIFO ordering across sources created by the same runtime.
+     *
+     * @param value - Event payload to deliver.
+     */
     emit(value: T): void;
 }
+/**
+ * Connected Reflex runtime returned by `createRuntime()`.
+ *
+ * The runtime owns the event dispatcher, effect scheduler, and execution
+ * context used by the top-level Reflex primitives.
+ */
 interface Runtime {
+    batch<T>(fn: () => T): T;
+    /**
+     * Creates a new mutable event source associated with this runtime.
+     *
+     * @typeParam T - Event payload type.
+     *
+     * @returns Event source with `emit(value)` and `subscribe(fn)`.
+     */
     event<T>(): EventSource<T>;
+    /**
+     * Flushes queued effect re-runs immediately.
+     *
+     * In the default `"flush"` strategy, call this after writes when you want
+     * scheduled effects to observe the latest stable snapshot. In `"sab"` and
+     * `"eager"` it remains available as an explicit synchronization escape hatch.
+     */
     flush(): void;
+    /**
+     * Underlying execution context used by this runtime.
+     *
+     * Most application code does not need this. It exists for low-level
+     * integrations, tests, and diagnostics.
+     */
     readonly ctx: ExecutionContext;
 }
+/**
+ * Creates and installs the active Reflex runtime.
+ *
+ * `createRuntime` wires together an execution context, effect scheduler, and
+ * event dispatcher, then makes that context the default runtime used by the
+ * top-level Reflex primitives exported from this package.
+ *
+ * @param options - Optional runtime configuration:
+ * - `effectStrategy` controls whether invalidated effects flush on
+ *   `rt.flush()`, stabilize after the outermost batch, or run automatically.
+ * - `hooks` installs low-level runtime hooks that are composed with Reflex's
+ *   scheduler integration.
+ *
+ * @returns Connected runtime with event creation, flushing, and context
+ * access.
+ *
+ * @example
+ * ```ts
+ * const rt = createRuntime();
+ * const ticks = rt.event<number>();
+ * const [count, setCount] = signal(0);
+ *
+ * ticks.subscribe((value) => {
+ *   setCount((current) => current + value);
+ * });
+ *
+ * effect(() => {
+ *   console.log(count());
+ * });
+ *
+ * ticks.emit(1);
+ * rt.flush();
+ * ```
+ *
+ * @remarks
+ * - Call this once during app startup or per test case to establish the active
+ *   runtime.
+ * - Creating a new runtime replaces the previously active default context.
+ * - `rt.flush()` is primarily for scheduled effects; signals and computed
+ *   reads stay current without it.
+ * - Event sources created by `rt.event()` share one dispatcher and preserve
+ *   FIFO delivery order.
+ */
 declare function createRuntime(options?: RuntimeOptions): Runtime;
 
 type EventValue<E extends Event<unknown>> = E extends Event<infer T> ? T : never;
@@ -413,9 +669,54 @@ declare function scan<T, A>(source: Event<T>, seed: A, reducer: (acc: A, value:
  */
 declare function hold<T>(source: Event<T>, initial: T): [read: Accessor<T>, dispose: Destructor];
 
-interface SignalOptions {
-    name: string;
-}
-declare function signal<T>(initialValue: T, options?: SignalOptions): readonly [value: Accessor<T>, setValue: Setter<T>];
+/**
+ * Creates writable reactive state.
+ *
+ * `signal` returns a tuple containing a tracked read accessor and a setter.
+ * Reading the accessor inside `computed()`, `memo()`, or `effect()` registers
+ * a dependency. Writing through the setter updates the stored value
+ * synchronously and invalidates downstream reactive consumers only when the
+ * value actually changes.
+ *
+ * @typeParam T - Signal value type.
+ *
+ * @param initialValue - Initial signal value returned until a later write
+ * replaces it.
+ * @param options - Optional development diagnostics. `options.name` is used
+ * only in development builds when formatting setter error messages.
+ *
+ * @returns A readonly tuple:
+ * - `value` - tracked accessor that returns the current signal value.
+ * - `setValue` - setter that accepts either a direct value or an updater
+ *   function receiving the previous value. The setter returns the committed
+ *   next value.
+ *
+ * @example
+ * ```ts
+ * createRuntime();
+ *
+ * const [count, setCount] = signal(0);
+ *
+ * console.log(count()); // 0
+ *
+ * setCount(1);
+ * setCount((prev) => prev + 1);
+ *
+ * console.log(count()); // 2
+ * ```
+ *
+ * @remarks
+ * - Reads are synchronous and always return the latest committed value.
+ * - Same-value writes do not invalidate downstream computed values or effects.
+ * - Calling `setValue()` with no argument is only valid when `T` includes
+ *   `undefined`.
+ * - In typical app code, call `createRuntime()` during setup before building
+ *   the rest of the reactive graph.
+ *
+ * @see computed
+ * @see memo
+ * @see effect
+ */
+declare function signal<T>(initialValue: T): readonly [Accessor<T>, Setter<T>];
 
-export { computed, createRuntime, effect, filter, hold, map, memo, merge, scan, signal, subscribeOnce };
+export { computed, createRuntime, effect, filter, hold, map, memo, merge, scan, signal, subscribeOnce, withEffectCleanupRegistrar };

package/dist/unstable/index.d.ts

@@ -1,31 +1,226 @@
 /// <reference path="../globals.d.ts" />
 
+/**
+ * Current lifecycle state of a resource request.
+ *
+ * - `"idle"` - no active request is in flight.
+ * - `"pending"` - the current request is still running.
+ * - `"resolved"` - the latest current request completed successfully.
+ * - `"rejected"` - the latest current request failed.
+ */
 type ResourceStatus = "idle" | "pending" | "resolved" | "rejected";
+/**
+ * Guard object bound to a single resource request token.
+ *
+ * Loaders receive a guard so they can tell whether their work is still current
+ * before committing side effects or returning follow-up work.
+ */
 interface ResourceGuard {
+    /**
+     * Monotonic token identifying the request that produced this guard.
+     */
     readonly token: number;
+    /**
+     * Returns `true` while this request is still current and the resource has not
+     * been disposed.
+     */
     alive(): boolean;
 }
+/**
+ * Mutable handle for manually settling a resource request.
+ *
+ * Manual resources expose this handle from `start()`. It extends
+ * `ResourceGuard` with methods that attempt to resolve or reject the current
+ * request.
+ *
+ * @typeParam T - Resolved value type.
+ * @typeParam E - Rejection type.
+ */
 interface ResourceHandle<T, E = unknown> extends ResourceGuard {
+    /**
+     * Resolves the request with `value`.
+     *
+     * @param value - Value to commit as the latest successful result.
+     *
+     * @returns `true` if the value was accepted, or `false` if this handle is
+     * stale or the resource has already been disposed.
+     */
     resolve(value: T): boolean;
+    /**
+     * Rejects the request with `error`.
+     *
+     * @param error - Error to commit as the latest failure.
+     *
+     * @returns `true` if the error was accepted, or `false` if this handle is
+     * stale or the resource has already been disposed.
+     */
     reject(error: E): boolean;
 }
+/**
+ * Reactive view of a resource request lifecycle.
+ *
+ * A resource exposes tracked accessors for its status, latest value, latest
+ * error, and current request token, along with imperative controls to reset or
+ * dispose the resource.
+ *
+ * @typeParam T - Resolved value type.
+ * @typeParam E - Rejection type.
+ */
 interface Resource<T, E = unknown> {
+    /**
+     * Tracked accessor that returns the current request lifecycle state.
+     */
     readonly status: Accessor<ResourceStatus>;
+    /**
+     * Tracked accessor that returns the latest successfully resolved value, if
+     * one exists.
+     *
+     * The last resolved value is retained while a newer request is pending or
+     * rejected.
+     */
     readonly value: Accessor<T | undefined>;
+    /**
+     * Tracked accessor that returns the latest rejected error, if one exists.
+     */
     readonly error: Accessor<E | undefined>;
+    /**
+     * Tracked accessor that returns the current monotonic request token.
+     *
+     * The token increments whenever a new request starts, the resource is
+     * cleared, or the resource is disposed.
+     */
     readonly token: Accessor<number>;
+    /**
+     * Resets the resource to the `"idle"` state and invalidates any in-flight
+     * request.
+     */
     clear(): void;
+    /**
+     * Disposes the resource permanently and invalidates any in-flight request.
+     *
+     * After disposal, the resource stops reacting to future source changes or
+     * refetch requests.
+     */
     dispose(): void;
 }
+/**
+ * Imperative resource whose requests are started and settled manually.
+ *
+ * @typeParam T - Resolved value type.
+ * @typeParam E - Rejection type.
+ */
 interface ManualResource<T, E = unknown> extends Resource<T, E> {
+    /**
+     * Starts a new request and returns a handle that can resolve or reject it.
+     *
+     * Starting a new request invalidates all older handles.
+     */
     start(): ResourceHandle<T, E>;
 }
+/**
+ * Auto-loading resource backed by a loader function.
+ *
+ * @typeParam T - Resolved value type.
+ * @typeParam E - Rejection type.
+ */
 interface AsyncResource<T, E = unknown> extends Resource<T, E> {
+    /**
+     * Requests another load.
+     *
+     * In the default runtime strategy, the reload starts when the surrounding
+     * runtime flushes scheduled effects.
+     */
     refetch(): void;
 }
+/**
+ * Loader used by `resource(load)`.
+ *
+ * It receives a guard for the current request and may return either a value or
+ * a promise-like value.
+ *
+ * @typeParam T - Resolved value type.
+ */
 type ResourceJob<T> = (guard: ResourceGuard) => T | PromiseLike<T>;
+/**
+ * Loader used by `resource(source, load)`.
+ *
+ * It receives the latest source value plus a guard for the current request, and
+ * may return either a value or a promise-like value.
+ *
+ * @typeParam S - Source value type.
+ * @typeParam T - Resolved value type.
+ */
 type ResourceLoader<S, T> = (source: S, guard: ResourceGuard) => T | PromiseLike<T>;
+/**
+ * Returns `true` when the resource's current request is pending.
+ *
+ * @param resource - Resource to inspect.
+ *
+ * @returns Whether `resource.status()` currently equals `"pending"`.
+ */
 declare function isPending(resource: Resource<unknown, unknown>): boolean;
+/**
+ * Creates an unstable resource for manual or loader-driven async state.
+ *
+ * `resource` models request lifecycles with tracked accessors for `status`,
+ * `value`, `error`, and `token`. It can be used in three modes:
+ *
+ * - `resource<T, E>()` creates a manual resource. Call `start()` to begin a
+ *   request, then settle that request through the returned handle.
+ * - `resource(load)` creates an auto-loading resource that starts immediately
+ *   and can be reloaded with `refetch()`.
+ * - `resource(source, load)` creates a source-driven resource that reloads
+ *   whenever `source()` changes.
+ *
+ * @typeParam S - Source value type for the source-driven overload.
+ * @typeParam T - Resolved value type.
+ * @typeParam E - Rejection type tracked by `error()`.
+ *
+ * @param sourceOrLoad - Either the reactive source accessor to watch or the
+ *   no-source loader function, depending on the overload.
+ * @param maybeLoad - Loader used with the source-driven overload.
+ *
+ * @returns Either a `ManualResource` or an `AsyncResource`, depending on the
+ * selected overload.
+ *
+ * @example
+ * ```ts
+ * import { createRuntime, signal } from "@volynets/reflex";
+ * import { resource } from "@volynets/reflex/unstable";
+ *
+ * const rt = createRuntime();
+ * const [userId, setUserId] = signal(1);
+ *
+ * const user = resource(() => userId(), async (id) => {
+ *   await Promise.resolve();
+ *   return { id, name: `user-${id}` };
+ * });
+ *
+ * console.log(user.status()); // "pending"
+ *
+ * setUserId(2);
+ * rt.flush();
+ * ```
+ *
+ * @remarks
+ * - This API is exported from `@volynets/reflex/unstable` and may change
+ *   between releases.
+ * - Each new request increments `token()`. Older handles and stale async
+ *   resolutions are ignored automatically.
+ * - `value()` retains the last resolved value while a newer request is pending
+ *   or rejected.
+ * - `clear()` resets the resource to `"idle"` and invalidates the current
+ *   request.
+ * - `dispose()` invalidates the current request and permanently stops future
+ *   updates.
+ * - `refetch()` and source changes schedule a new load through the runtime.
+ *   With the default effect strategy, call `rt.flush()` to start it.
+ * - If a source accessor or loader throws synchronously, the current request
+ *   is rejected with that error.
+ *
+ * @see isPending
+ * @see createRuntime
+ */
 declare function resource<T, E = unknown>(): ManualResource<T, E>;
 declare function resource<T, E = unknown>(load: ResourceJob<T>): AsyncResource<T, E>;
 declare function resource<S, T, E = unknown>(source: Accessor<S>, load: ResourceLoader<S, T>): AsyncResource<T, E>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volynets/reflex",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "type": "module",
   "description": "Public Reflex facade with a connected runtime",
   "license": "MIT",
@@ -10,17 +10,26 @@
   "sideEffects": false,
   "exports": {
     ".": {
+      "source": {
+        "types": "./src/index.ts",
+        "default": "./src/index.ts"
+      },
       "types": "./dist/globals.d.ts",
       "import": "./dist/esm/index.js",
       "require": "./dist/cjs/index.cjs"
     },
     "./unstable": {
+      "source": {
+        "types": "./src/unstable/index.ts",
+        "default": "./src/unstable/index.ts"
+      },
       "types": "./dist/unstable/index.d.ts",
       "import": "./dist/esm/unstable/index.js",
       "require": "./dist/cjs/unstable/index.cjs"
     }
   },
   "files": [
+    "src",
     "dist/cjs",
     "dist/esm",
     "dist/globals.d.ts",