@volynets/reflex-store 0.0.0-stage → 0.0.1

package/dist/selectors/index.d.ts

@@ -0,0 +1,13 @@
+/// <reference lib="esnext.disposable" />
+import { c as StoreProjectionOptions, P as ProjectionOptions } from '../types/shared-CdTKzvLe.js';
+export { K as KeyedOptions } from '../types/shared-CdTKzvLe.js';
+import { S as StoreDisposable, A as Accessor, a as DisposableAccessor } from '../types/keyed-CdSYzIOc.js';
+export { c as createKeyedProjection, b as createSelector } from '../types/keyed-CdSYzIOc.js';
+import '../types/createStore-BJ66-pfq.js';
+
+declare function createStoreProjection<T extends object>(fn: (draft: T) => void | T, seed: Partial<T>, options?: StoreProjectionOptions<T>): T & StoreDisposable;
+
+declare function createProjection<T extends object>(fn: (draft: T) => void | T, seed: Partial<T>, options?: StoreProjectionOptions<T>): T & StoreDisposable;
+declare function createProjection<T, K, R>(source: Accessor<T>, keyOf: (value: T) => K, project: (value: T) => R, options?: ProjectionOptions<K, R>): DisposableAccessor<K, R | undefined>;
+
+export { ProjectionOptions, StoreProjectionOptions, createProjection, createStoreProjection };

package/dist/selectors/index.js

@@ -0,0 +1,15 @@
+import { d as createKeyedProjection, e as createStoreProjection } from '../chunks/keyed-C-QvvUv4.js';
+export { a as createSelector } from '../chunks/keyed-C-QvvUv4.js';
+import '@volynets/reflex-runtime/internal';
+import '../chunks/shared-BHHficW8.js';
+import '../chunks/names-BF36AyM3.js';
+import '@volynets/reflex';
+
+function createProjection(sourceOrProject, keyOrSeed, projectOrOptions, options) {
+    if (typeof keyOrSeed === "function" && typeof projectOrOptions === "function") {
+        return createKeyedProjection(sourceOrProject, keyOrSeed, projectOrOptions, options ?? {});
+    }
+    return createStoreProjection(sourceOrProject, keyOrSeed, projectOrOptions ?? {});
+}
+
+export { createKeyedProjection, createProjection, createStoreProjection };

package/dist/selectors/shared.d.ts

@@ -0,0 +1,3 @@
+/// <reference lib="esnext.disposable" />
+export { K as KeyedOptions, M as Missing, P as ProjectionOptions, c as StoreProjectionOptions, k as cloneProjectionValue, l as createStoreReaderProxy, m as getMissing, n as isObject, p as readProjectionPath, q as sameValue } from '../types/shared-CdTKzvLe.js';
+import '../types/createStore-BJ66-pfq.js';

package/dist/selectors/shared.js

@@ -0,0 +1,2 @@
+export { h as cloneProjectionValue, m as createStoreReaderProxy, n as getMissing, p as isObject, j as readProjectionPath, q as sameValue } from '../chunks/shared-BHHficW8.js';
+import '@volynets/reflex-runtime/internal';

package/dist/store.d.ts

@@ -0,0 +1,9 @@
+/// <reference lib="esnext.disposable" />
+export { C as CompiledStore, b as StoreShape, c as createStore } from './types/createStore-BJ66-pfq.js';
+import { C as CompiledStoreTransformOptions, a as CompiledStoreTransformResult } from './types/contracts-BCsRPdQb.js';
+export { b as CompiledStoreDiagnostic, c as CompiledStoreLoweringTarget, d as CompiledStoreLoweringTargetOptions, e as CompiledStorePathContext, f as CompiledStoreTemporaryContext, g as CompiledStoreTransformError } from './types/contracts-BCsRPdQb.js';
+
+declare function compileStore(code: string, id?: string, options?: CompiledStoreTransformOptions): CompiledStoreTransformResult;
+declare function transformCompiledStore(code: string, id?: string, options?: CompiledStoreTransformOptions): CompiledStoreTransformResult;
+
+export { CompiledStoreTransformOptions, CompiledStoreTransformResult, compileStore, transformCompiledStore };

package/dist/store.js

@@ -0,0 +1,4 @@
+export { c as createStore } from './chunks/createStore-DHj16Ehk.js';
+export { C as CompiledStoreTransformError, c as compileStore, t as transformCompiledStore } from './chunks/compiler-CW_P8WsZ.js';
+import 'util';
+import 'fs';

package/dist/types/contracts-BCsRPdQb.d.ts

@@ -0,0 +1,78 @@
+/// <reference lib="esnext.disposable" />
+interface CompiledStorePathContext {
+    path: readonly string[];
+    mangledPath: string;
+}
+interface CompiledStoreTemporaryContext {
+    index: number;
+    label: string;
+}
+interface CompiledStoreLoweringTarget {
+    runtimeModule: string;
+    scope: {
+        exportName: string;
+        localName: string;
+        actionMethod: string;
+        /** Legacy factory targets may return a zero-argument constructor. */
+        curried?: boolean;
+    };
+    signal: {
+        /** Defaults to runtimeModule for custom targets. */
+        runtimeModule?: string;
+        exportName: string;
+        localName: string;
+    };
+    identifiers: {
+        context: string;
+        value: string;
+        read: (context: CompiledStorePathContext) => string;
+        set: (context: CompiledStorePathContext) => string;
+        write: (context: CompiledStorePathContext) => string;
+        temporary: (context: CompiledStoreTemporaryContext) => string;
+    };
+}
+type CompiledStoreLoweringTargetOptions = {
+    runtimeModule?: string;
+    scope?: Partial<CompiledStoreLoweringTarget["scope"]>;
+    /** @deprecated Use scope. Legacy model targets are invoked as factories. */
+    model?: Partial<CompiledStoreLoweringTarget["scope"]>;
+    signal?: Partial<CompiledStoreLoweringTarget["signal"]>;
+    identifiers?: Partial<CompiledStoreLoweringTarget["identifiers"]>;
+};
+type DiagnosticCode = "unsupported-shape" | "unsupported-binding" | "unsupported-write" | "dynamic-access" | "branch-alias" | "spread-reflection" | "delete" | "optional-chain";
+interface CompiledStoreDiagnostic {
+    code: DiagnosticCode;
+    message: string;
+}
+interface CompiledStoreTransformOptions {
+    /**
+     * Emits the runtime import needed by generated code.
+     *
+     * Test harnesses can disable this and provide `__reflex_createStoreScope` and
+     * `__reflex_signal` in scope manually.
+     */
+    importRuntime?: boolean;
+    /** Omit the facade when every store use lowers directly to a declared leaf. */
+    eraseFacade?: boolean;
+    /** Store scope module used by generated code. */
+    runtimeModule?: string;
+    /** Customize every runtime symbol emitted by the canonical lowering. */
+    loweringTarget?: CompiledStoreLoweringTargetOptions;
+    /**
+     * `throw` is the compiler default because unsupported store syntax should be
+     * found during development, not discovered as a runtime semantic mismatch.
+     */
+    onDiagnostic?: "throw" | "collect";
+}
+interface CompiledStoreTransformResult {
+    code: string;
+    diagnostics: CompiledStoreDiagnostic[];
+    map: string | null;
+}
+declare class CompiledStoreTransformError extends Error {
+    readonly diagnostics: CompiledStoreDiagnostic[];
+    constructor(diagnostics: CompiledStoreDiagnostic[]);
+}
+
+export { CompiledStoreTransformError as g };
+export type { CompiledStoreTransformOptions as C, CompiledStoreTransformResult as a, CompiledStoreDiagnostic as b, CompiledStoreLoweringTarget as c, CompiledStoreLoweringTargetOptions as d, CompiledStorePathContext as e, CompiledStoreTemporaryContext as f };

package/dist/types/createStore-BJ66-pfq.d.ts

@@ -0,0 +1,43 @@
+/// <reference lib="esnext.disposable" />
+declare const storeBoundary: unique symbol;
+type StoreBoundary<T> = T & {
+    readonly [storeBoundary]: T;
+};
+/** Marks one compiled store value as a replaceable leaf. */
+declare function leaf<T>(value: T): StoreBoundary<T>;
+
+type StoreLeaf = string | number | boolean | bigint | symbol | null | undefined | readonly unknown[] | ((...args: any[]) => unknown) | StoreBoundary<unknown>;
+declare const compiledShape: unique symbol;
+type Same<A, B> = (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false;
+type StoreData<T> = {
+    [K in keyof T as T[K] extends (...args: any[]) => unknown ? never : Same<Pick<T, K>, {
+        -readonly [P in K]: T[P];
+    }> extends true ? K : never]: T[K] extends StoreBoundary<infer V> ? V : T[K] extends StoreShape ? StoreData<T[K]> : T[K];
+};
+interface StoreOptions {
+    name?: string;
+}
+type StoreShape = {
+    [key: string]: StoreLeaf | StoreShape;
+};
+type CompiledValue<T> = T extends StoreBoundary<infer TLeaf> ? TLeaf : T extends StoreShape ? CompiledBranch<T> : T;
+type CompiledBranch<TShape extends StoreShape> = {
+    -readonly [K in keyof TShape]: CompiledValue<TShape[K]>;
+};
+type CompiledStore<TShape extends StoreShape> = CompiledBranch<TShape> & {
+    readonly [compiledShape]: TShape;
+    dispose(): void;
+    [Symbol.dispose](): void;
+};
+/**
+ * Declares a compile-time store shape for the compiled-store transform.
+ *
+ * Data properties become leaf cells; methods become batched actions; getters
+ * become lazy computed values. leaf() and opaque() mark object values as
+ * replaceable leaves. If this function executes at runtime, the transform did
+ * not run.
+ */
+declare function createStore<TShape extends StoreShape>(_shape: TShape, _options?: StoreOptions): CompiledStore<TShape>;
+
+export { createStore as c, leaf as l };
+export type { CompiledStore as C, StoreData as S, StoreOptions as a, StoreShape as b, StoreBoundary as d };

package/dist/types/internal-BIzJSPwN.d.ts

@@ -0,0 +1,18 @@
+/// <reference lib="esnext.disposable" />
+import '@volynets/reflex-runtime/internal';
+
+interface StoreCell<T> {
+    (): T;
+    set(value: T): void;
+    peek(): T;
+    collect(): void;
+    dispose(): void;
+    [Symbol.dispose](): void;
+}
+/** Compiler target: a direct leaf address, materialized only by a tracked read. */
+declare function createStoreCell<T>(initial: T, options?: {
+    name?: string;
+}): StoreCell<T>;
+
+export { createStoreCell as c };
+export type { StoreCell as S };

package/dist/types/keyed-CdSYzIOc.d.ts

@@ -0,0 +1,18 @@
+/// <reference lib="esnext.disposable" />
+import { K as KeyedOptions, P as ProjectionOptions } from './shared-CdTKzvLe.js';
+
+interface StoreDisposable {
+    [Symbol.dispose](): void;
+}
+type Destructor = () => void;
+type Accessor<T> = () => T;
+type DisposableAccessor<K, V> = ((key: K) => V) & StoreDisposable & {
+    collect(): void;
+    dispose(): void;
+};
+
+declare function createSelector<T>(source: Accessor<T>, options?: KeyedOptions<T>): DisposableAccessor<T, boolean>;
+declare function createKeyedProjection<T, K, R>(source: Accessor<T>, keyOf: (value: T) => K, project: (value: T) => R, options?: ProjectionOptions<K, R>): DisposableAccessor<K, R | undefined>;
+
+export { createSelector as b, createKeyedProjection as c };
+export type { Accessor as A, Destructor as D, StoreDisposable as S, DisposableAccessor as a };

package/dist/types/shared-CdTKzvLe.d.ts

@@ -0,0 +1,114 @@
+/// <reference lib="esnext.disposable" />
+import { d as StoreBoundary, b as StoreShape, C as CompiledStore, S as StoreData } from './createStore-BJ66-pfq.js';
+
+/** Publish a synchronous logical action at one runtime batch boundary. */
+declare function transaction<T>(action: () => T): T;
+interface ReactiveMapOptions<V> {
+    name?: string;
+    /** Values are reference boundaries; equivalent replacements retain the old value. */
+    equals?: (previous: V, next: V) => boolean;
+}
+declare class ReactiveMap<K, V> implements Iterable<[K, V]> {
+    private initial?;
+    private readonly options;
+    private data?;
+    private disposed;
+    private readonly valuesByKey;
+    private readonly existsByKey;
+    private sizeNode?;
+    private keysNode?;
+    private valuesNode?;
+    constructor(initial?: (Iterable<readonly [K, V]> | (() => Iterable<readonly [K, V]>)) | undefined, options?: ReactiveMapOptions<V>);
+    private backing;
+    get size(): number;
+    get [Symbol.toStringTag](): string;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    set(key: K, value: V): this;
+    private commitSet;
+    delete(key: K): boolean;
+    clear(): void;
+    keys(): MapIterator<K>;
+    values(): MapIterator<V>;
+    entries(): MapIterator<[K, V]>;
+    [Symbol.iterator](): MapIterator<[K, V]>;
+    forEach(callback: (value: V, key: K, map: ReactiveMap<K, V>) => void, thisArg?: unknown): void;
+    collect(): void;
+    [Symbol.dispose](): void;
+    dispose(): void;
+}
+/** A native Set-shaped membership collection over keyed reactive observations. */
+declare class ReactiveSet<T> implements Iterable<T> {
+    private readonly members;
+    constructor(initial?: Iterable<T> | (() => Iterable<T>), options?: {
+        name?: string;
+    });
+    get size(): number;
+    get [Symbol.toStringTag](): string;
+    has(value: T): boolean;
+    add(value: T): this;
+    delete(value: T): boolean;
+    clear(): void;
+    values(): MapIterator<T>;
+    keys(): MapIterator<T>;
+    entries(): IterableIterator<[T, T]>;
+    [Symbol.iterator](): MapIterator<T>;
+    forEach(callback: (value: T, key: T, set: ReactiveSet<T>) => void, thisArg?: unknown): void;
+    collect(): void;
+    dispose(): void;
+    [Symbol.dispose](): void;
+}
+declare function reactiveSet<T>(initial?: Iterable<T> | (() => Iterable<T>), options?: {
+    name?: string;
+}): ReactiveSet<T>;
+declare function createReactiveMap<K, V>(initial?: Iterable<readonly [K, V]> | (() => Iterable<readonly [K, V]>), options?: ReactiveMapOptions<V>): ReactiveMap<K, V>;
+
+type Depth = "deep" | "shallow" | "ref" | "opaque";
+declare const deep: <T extends object>(value: T) => T;
+declare const shallow: <T extends object>(value: T) => T;
+declare const ref: <T extends object>(value: T) => T;
+declare const opaque: <T extends object>(value: T) => StoreBoundary<T>;
+/** Copy structural data, retaining explicit reference boundaries and foreign objects. */
+declare function cloneValue<T>(value: T, seen?: Map<object, unknown>): T;
+/** An untracked backing view. Mutating it bypasses reactivity and is unsupported. */
+declare function raw<K, V>(store: ReactiveMap<K, V>): Map<K, V>;
+declare function raw<T>(store: ReactiveSet<T>): Set<T>;
+declare function raw<T>(store: T): T;
+type Snapshot<T> = T extends ReactiveSet<infer V> ? ReadonlySet<V> : T extends Set<infer V> ? ReadonlySet<V> : T extends ReactiveMap<infer K, infer V> ? ReadonlyMap<K, Snapshot<V>> : T extends Map<infer K, infer V> ? ReadonlyMap<K, Snapshot<V>> : T extends readonly (infer V)[] ? readonly Snapshot<V>[] : T extends object ? {
+    readonly [K in keyof T]: Snapshot<T[K]>;
+} : T;
+/** An untracked point-in-time copy. Opaque/foreign values remain by reference. */
+declare function snapshot<T extends StoreShape>(store: CompiledStore<T>): Snapshot<StoreData<T>>;
+declare function snapshot<T>(store: T): Snapshot<T>;
+declare function disposeStore(store: object): void;
+/** Reclaim locations with no consumers at an explicit owner lifecycle boundary. */
+declare function collectStore(store: object): void;
+
+declare const MISSING: unique symbol;
+type AnyRecord = Record<PropertyKey, unknown>;
+type Missing = typeof MISSING;
+interface KeyedOptions<T> {
+    name?: string;
+    equals?: (prev: T, next: T) => boolean;
+}
+interface ProjectionOptions<K, R> {
+    name?: string;
+    keyEquals?: (prev: K, next: K) => boolean;
+    equals?: (prev: R, next: R) => boolean;
+    fallback?: R;
+}
+interface StoreProjectionOptions<T extends object> {
+    name?: string;
+    clone?: (value: T) => T;
+    equals?: (previous: T, next: T) => boolean;
+    depth?: "deep" | "shallow";
+}
+declare function sameValue<T>(prev: T, next: T): boolean;
+declare function getMissing(): Missing;
+declare function isObject(value: unknown): value is AnyRecord;
+
+declare function readProjectionPath(value: unknown, path: readonly PropertyKey[]): unknown;
+declare function createStoreReaderProxy<T extends object>(readState: () => T, path?: readonly PropertyKey[]): T;
+
+export { ReactiveMap as R, ReactiveSet as b, collectStore as d, createReactiveMap as e, deep as f, disposeStore as g, reactiveSet as h, ref as i, snapshot as j, cloneValue as k, createStoreReaderProxy as l, getMissing as m, isObject as n, opaque as o, readProjectionPath as p, sameValue as q, raw as r, shallow as s, transaction as t };
+export type { Depth as D, KeyedOptions as K, Missing as M, ProjectionOptions as P, Snapshot as S, ReactiveMapOptions as a, StoreProjectionOptions as c };

package/dist/vite.d.ts

@@ -0,0 +1,68 @@
+/// <reference lib="esnext.disposable" />
+import { d as CompiledStoreLoweringTargetOptions } from './types/contracts-BCsRPdQb.js';
+
+type TransformResult = {
+    code: string;
+    map: null | {
+        version: 3;
+        sources: string[];
+        names: string[];
+        mappings: string;
+        sourcesContent?: (string | null)[];
+    };
+};
+interface ReflexStorePlugin {
+    name: string;
+    enforce: "pre";
+    transform(this: DiagnosticReporter, code: string, id: string): TransformResult | null;
+}
+
+type Selector = string | RegExp | readonly (string | RegExp)[];
+type DiagnosticMode = "error" | "warn" | "collect";
+type DiagnosticReporter = {
+    warn(warning: string): void;
+    error(error: string): never;
+};
+interface ReflexStoreVitePluginOptions {
+    /**
+     * Files eligible for the compiled-store transform.
+     *
+     * @default /\.[cm]?[jt]sx?$/
+     */
+    include?: Selector;
+    /**
+     * Files excluded from the compiled-store transform.
+     *
+     * @default /\/node_modules\//
+     */
+    exclude?: Selector;
+    /**
+     * Runtime module used by generated code.
+     *
+     * @default "@volynets/reflex"
+     */
+    runtimeModule?: string;
+    eraseFacade?: boolean;
+    /** Customize the runtime primitives and every generated identifier. */
+    loweringTarget?: CompiledStoreLoweringTargetOptions;
+    /**
+     * Compile bare `createStore({ ... })` calls even when the file does not
+     * import `createStore` from `@volynets/reflex-store`.
+     *
+     * The default keeps the plugin conservative and avoids touching unrelated
+     * libraries that also expose a `createStore` function.
+     *
+     * @default false
+     */
+    compileBareCreateStore?: boolean;
+    /**
+     * How unsupported phase-1 syntax is surfaced through Vite.
+     *
+     * @default "error"
+     */
+    diagnostics?: DiagnosticMode;
+}
+declare function reflexStoreVitePlugin(options?: ReflexStoreVitePluginOptions): ReflexStorePlugin;
+
+export { reflexStoreVitePlugin as default, reflexStoreVitePlugin as reflexStore, reflexStoreVitePlugin };
+export type { ReflexStorePlugin, ReflexStoreVitePluginOptions };

package/dist/vite.js

@@ -0,0 +1,87 @@
+import { c as compileStore, C as CompiledStoreTransformError } from './chunks/compiler-CW_P8WsZ.js';
+import 'util';
+import 'fs';
+
+const DEFAULT_INCLUDE = /\.[cm]?[jt]sx?$/;
+const DEFAULT_EXCLUDE = /\/node_modules\//;
+const STORE_IMPORT_RE = /from\s*["'](?:@volynets\/reflex-store|@reflex\/store)(?:\/(?:store|compiled-store|advanced))?["']/;
+function reflexStoreVitePlugin(options = {}) {
+    const include = options.include ?? DEFAULT_INCLUDE;
+    const exclude = options.exclude ?? DEFAULT_EXCLUDE;
+    const diagnostics = options.diagnostics ?? "error";
+    return {
+        name: "reflex-store",
+        enforce: "pre",
+        transform (code, id) {
+            const normalizedId = normalizeId(id);
+            if (!matchesSelector(include, normalizedId)) {
+                return null;
+            }
+            if (matchesSelector(exclude, normalizedId)) {
+                return null;
+            }
+            if (!shouldCompileCode(code, options.compileBareCreateStore ?? false)) {
+                return null;
+            }
+            try {
+                const result = compileStore(code, normalizedId, {
+                    importRuntime: true,
+                    eraseFacade: options.eraseFacade,
+                    onDiagnostic: diagnostics === "error" ? "throw" : "collect",
+                    loweringTarget: options.loweringTarget,
+                    runtimeModule: options.runtimeModule
+                });
+                reportDiagnostics(this, result.diagnostics, diagnostics);
+                return {
+                    code: result.code,
+                    map: parseSourceMap(result.map)
+                };
+            } catch (error) {
+                if (error instanceof CompiledStoreTransformError) {
+                    this.error(formatDiagnostics(error.diagnostics));
+                }
+                throw error;
+            }
+        }
+    };
+}
+function shouldCompileCode(code, compileBareCreateStore) {
+    if (!code.includes("createStore")) {
+        return false;
+    }
+    return compileBareCreateStore || STORE_IMPORT_RE.test(code);
+}
+function normalizeId(id) {
+    return id.split("?")[0].replace(/\\/g, "/");
+}
+function matchesSelector(selector, id) {
+    if (isSelectorArray(selector)) {
+        return selector.some((item)=>matchesSelector(item, id));
+    }
+    if (typeof selector === "string") {
+        return id.includes(selector);
+    }
+    return selector.test(id);
+}
+function isSelectorArray(selector) {
+    return Array.isArray(selector);
+}
+function parseSourceMap(map) {
+    return map === null ? null : JSON.parse(map);
+}
+function reportDiagnostics(context, diagnostics, mode) {
+    if (diagnostics.length === 0 || mode === "collect") {
+        return;
+    }
+    const message = formatDiagnostics(diagnostics);
+    if (mode === "warn") {
+        context.warn(message);
+        return;
+    }
+    context.error(message);
+}
+function formatDiagnostics(diagnostics) {
+    return diagnostics.map((diagnostic)=>diagnostic.message).join("\n");
+}
+
+export { reflexStoreVitePlugin as default, reflexStoreVitePlugin as reflexStore, reflexStoreVitePlugin };

package/examples/task-board/README.md

@@ -0,0 +1,15 @@
+# Task board example
+
+The example uses reactiveMap for dynamic task IDs, createStore for closed UI
+state, selector for selection observations, derive for summary fields and action
+for coherent mutations. The Vite plugin enables compilation.
+
+The implementation is [src/task-board.ts](./src/task-board.ts). Run its contracts:
+
+```sh
+pnpm --filter @volynets/reflex-store test:integration
+```
+
+The tests cover summary-field precision, keyed map reads, selection locality,
+batching, pull freshness, ownership and no-op moves. The package also includes
+production contracts for compiled methods/getters and snapshot/hydration.

package/examples/task-board/src/task-board.ts

@@ -0,0 +1,159 @@
+import { createRuntime, effect } from "@volynets/reflex-store/runtime";
+import {
+  action,
+  createStore,
+  derive,
+  reactiveMap,
+  selector,
+} from "@volynets/reflex-store";
+
+export type TaskStatus = "backlog" | "active" | "done";
+
+export interface Task {
+  id: string;
+  title: string;
+  assignee: string;
+  status: TaskStatus;
+}
+
+export interface BoardSummary {
+  total: number;
+  visible: number;
+  completed: number;
+  activeTitle: string;
+  filterLabel: string;
+}
+
+export const taskBoardRuntime = createRuntime({ effectStrategy: "flush" });
+
+const INITIAL_TASKS: readonly Task[] = [
+  { id: "T-101", title: "Design checkout", assignee: "Ada", status: "active" },
+  { id: "T-102", title: "Add audit log", assignee: "Lin", status: "backlog" },
+  { id: "T-103", title: "Ship billing", assignee: "Ada", status: "done" },
+];
+
+export const tasks = reactiveMap<string, Task>(
+  INITIAL_TASKS.map((task) => [task.id, task] as const),
+);
+
+const ui = createStore({
+  filter: {
+    status: "all" as TaskStatus | "all",
+    query: "",
+  },
+  selection: {
+    taskId: "T-101",
+  },
+});
+
+const EMPTY_TASK: Readonly<Task> = Object.freeze({
+  id: "",
+  title: "No task selected",
+  assignee: "",
+  status: "backlog",
+});
+
+export const isTaskSelected = selector(() => ui.selection.taskId);
+
+export const taskById = (taskId: string): Task | undefined => tasks.get(taskId);
+
+export const summary = derive<BoardSummary>(() => {
+  const allTasks = [...tasks.values()];
+  const status = ui.filter.status;
+  const normalizedQuery = ui.filter.query.trim().toLocaleLowerCase();
+  const selectedTask = tasks.get(ui.selection.taskId) ?? EMPTY_TASK;
+
+  let completed = 0;
+  let visible = 0;
+
+  for (const task of allTasks) {
+    if (task.status === "done") completed++;
+
+    if (
+      (status === "all" || task.status === status) &&
+      (normalizedQuery === "" ||
+        task.title.toLocaleLowerCase().includes(normalizedQuery))
+    ) {
+      visible++;
+    }
+  }
+
+  return {
+    total: allTasks.length,
+    completed,
+    visible,
+    activeTitle: selectedTask.title,
+    filterLabel:
+      normalizedQuery === "" ? status : status + ":" + normalizedQuery,
+  };
+});
+
+const resetBoard = action(() => {
+  tasks.clear();
+  for (const task of INITIAL_TASKS) tasks.set(task.id, task);
+  ui.filter.status = "all";
+  ui.filter.query = "";
+  ui.selection.taskId = "T-101";
+});
+
+export const boardActions = {
+  select: action((taskId: string) => {
+    if (ui.selection.taskId !== taskId) ui.selection.taskId = taskId;
+  }),
+
+  setFilter: action((status: TaskStatus | "all", query = "") => {
+    if (ui.filter.status !== status) ui.filter.status = status;
+    if (ui.filter.query !== query) ui.filter.query = query;
+  }),
+
+  move: action((taskId: string, status: TaskStatus) => {
+    const task = tasks.get(taskId);
+    if (!task || task.status === status) return;
+    tasks.set(taskId, { ...task, status });
+  }),
+
+  reset() {
+    resetBoard();
+    taskBoardRuntime.flush();
+  },
+
+  flush() {
+    taskBoardRuntime.flush();
+  },
+};
+
+export function runTaskBoardScenario() {
+  const renders: string[] = [];
+
+  const stop = effect(() => {
+    renders.push(
+      summary.filterLabel +
+        "|" +
+        summary.visible +
+        "|" +
+        summary.completed +
+        "|" +
+        summary.activeTitle,
+    );
+  });
+
+  boardActions.setFilter("active");
+  boardActions.select("T-102");
+  taskBoardRuntime.flush();
+
+  boardActions.move("T-102", "active");
+  taskBoardRuntime.flush();
+
+  stop();
+
+  const activeTask = taskById("T-102");
+
+  return {
+    activeTask: activeTask === undefined ? undefined : activeTask.title,
+    completed: summary.completed,
+    isSelected: isTaskSelected("T-102"),
+    renders,
+    total: summary.total,
+    visible: summary.visible,
+  };
+}

package/examples/task-board/vite.config.ts

@@ -0,0 +1,6 @@
+import { defineConfig } from "vite";
+import reflexStore from "@volynets/reflex-store/vite";
+
+export default defineConfig({
+  plugins: [reflexStore()],
+});