@volynets/reflex-store 0.0.0-stage → 0.0.2

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-store/runtime"
+     */
+    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-Dsb3E2ck.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/reactivity.ts

@@ -0,0 +1,33 @@
+// Application wiring for this example; the store does not own a host runtime.
+import {
+  createRuntimeContext,
+  createWatcher,
+  disposeWatcher,
+  runWatcher,
+  switchRuntimeContext,
+} from "@volynets/reflex-runtime/internal";
+import {
+  createRuntimeSchedulerBinding,
+  resolveEffectSchedulerMode,
+  type EffectStrategy,
+} from "@volynets/reflex-scheduler";
+
+export function createRuntime({
+  effectStrategy = "eager",
+}: { effectStrategy?: EffectStrategy } = {}) {
+  const context = createRuntimeContext();
+  const scheduler = createRuntimeSchedulerBinding(
+    resolveEffectSchedulerMode(effectStrategy),
+    context,
+  );
+  context.nodeInvalidatedHook = scheduler.onNodeInvalidated;
+  context.hostFlushHook = scheduler.onHostFlush;
+  switchRuntimeContext(context);
+  return { flush: scheduler.flush };
+}
+
+export function effect(callback: () => void | (() => void)): () => void {
+  const node = createWatcher(callback);
+  runWatcher(node);
+  return () => disposeWatcher(node);
+}

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

@@ -0,0 +1,159 @@
+import { createRuntime, effect } from "./reactivity";
+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()],
+});

package/package.json

@@ -1,6 +1,121 @@
 {
   "name": "@volynets/reflex-store",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.2",
+  "type": "module",
+  "description": "State management primitives for Reflex",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./advanced": {
+      "types": "./dist/advanced.d.ts",
+      "import": "./dist/advanced.js"
+    },
+    "./selectors": {
+      "types": "./dist/selectors/index.d.ts",
+      "import": "./dist/selectors/index.js"
+    },
+    "./selectors/shared": {
+      "types": "./dist/selectors/shared.d.ts",
+      "import": "./dist/selectors/shared.js"
+    },
+    "./store": {
+      "types": "./dist/store.d.ts",
+      "import": "./dist/store.js"
+    },
+    "./compiled-store": {
+      "types": "./dist/compiled-store.d.ts",
+      "import": "./dist/compiled-store.js"
+    },
+    "./vite": {
+      "types": "./dist/vite.d.ts",
+      "import": "./dist/vite.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime.d.ts",
+      "import": "./dist/runtime.js"
+    },
+    "./runtime/internal": {
+      "types": "./dist/runtime/internal.d.ts",
+      "import": "./dist/runtime/internal.js"
+    },
+    "./runtime/core": {
+      "types": "./dist/runtime/core.d.ts",
+      "import": "./dist/runtime/core.js"
+    }
+  },
+  "files": [
+    "dist",
+    "examples/task-board",
+    "src/store/README.md",
+    "src/store/TRANSFORM_SPEC.md",
+    "SPECIFICATION.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "clean": "node ../../tooling/build/clean.mjs .",
+    "build": "node scripts/build.mjs",
+    "bench": "vitest bench --config vite.config.ts bench/semantic-workloads.bench.ts",
+    "bench:full": "vitest bench --mode full --config vite.config.ts bench/semantic-workloads.bench.ts",
+    "bench:hot-paths": "node --expose-gc bench/hot-paths.node.mjs",
+    "bench:metrics": "vitest run --config vite.metrics.config.ts tests/semantic-workloads.metrics.test.ts",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "test": "vitest run --config vite.config.ts",
+    "typecheck": "tsc --noEmit -p tsconfig.json && tsc -p tsconfig.example.json",
+    "prepublishOnly": "pnpm check:release",
+    "check:release": "pnpm build:all && pnpm lint && pnpm test && pnpm test:dev && pnpm typecheck && pnpm check:artifacts && node scripts/packed-runtime-identity.mjs",
+    "test:dev": "vitest run --config vite.dev.config.ts",
+    "test:differential": "vitest run --config vite.config.ts tests/compiler.differential.test.ts tests/runtime.differential.test.ts",
+    "test:integration": "vitest run --config vite.config.ts tests/store.integration.test.ts tests/vite-user-dx.test.ts tests/task-board",
+    "test:packed-runtime": "pnpm build:all && node scripts/packed-runtime-identity.mjs",
+    "build:all": "node ../../tooling/build/run.mjs @volynets/reflex-store",
+    "check:artifacts": "node ../../tooling/build/verify-artifacts.mjs --directory .",
+    "prepack": "pnpm build && pnpm check:artifacts"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^29.0.3",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-replace": "^6.0.3",
+    "@rollup/plugin-swc": "^0.4.0",
+    "@swc/core": "^1.15.18",
+    "@swc/wasm": "^1.16.13",
+    "@types/node": "^26.1.2",
+    "@volynets/reflex-runtime": "workspace:*",
+    "@volynets/reflex-scheduler": "workspace:^",
+    "rollup": "^4.54.0",
+    "rollup-plugin-dts": "^6.4.1",
+    "@volynets/reflex-framework": "workspace:*"
+  },
+  "keywords": [
+    "reflex",
+    "state",
+    "store",
+    "selector",
+    "reactivity"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/volynetstyle/Reflex.git",
+    "directory": "packages/reflex-store"
+  },
+  "homepage": "https://github.com/volynetstyle/Reflex/tree/main/packages/reflex-store",
+  "bugs": {
+    "url": "https://github.com/volynetstyle/Reflex/issues"
+  },
+  "engines": {
+    "node": ">=20.19.0"
+  },
+  "peerDependencies": {
+    "@volynets/reflex-runtime": "^1.0.1",
+    "@volynets/reflex-framework": "^0.1.4"
+  },
+  "private": false
+}