stroid 0.1.3 → 0.1.4

package/dist/types/internals/diagnostics.d.ts

@@ -0,0 +1,21 @@
+export declare const __DEV__: boolean;
+export declare const isDev: () => boolean;
+export declare const critical: (msg: string, meta?: Record<string, unknown>) => void;
+export declare const warn: (msg: string, meta?: Record<string, unknown>) => void;
+export declare const warnAlways: (msg: string, meta?: Record<string, unknown>) => void;
+export declare const error: (msg: string, meta?: Record<string, unknown>) => void;
+export declare const log: (msg: string, meta?: Record<string, unknown>) => void;
+export declare const getInvalidFunctionStoreValueMessage: () => string;
+export declare const getMapSetStoreWarningMessage: () => string;
+export declare const getDateStoreWarningMessage: () => string;
+export declare const getSanitizeDateWarningMessage: () => string;
+export declare const getSanitizeMapWarningMessage: () => string;
+export declare const getSanitizeSetWarningMessage: () => string;
+export declare const getPathDepthExceededMessage: (depth: number, maxDepth: number, parts: string[]) => string;
+export declare const getDeepNestingWarningMessage: (depth: number, parts: string[]) => string;
+export declare const getPathReachedNullMessage: (parts: string[], part: string) => string;
+export declare const getPathNotObjectMessage: (part: string) => string;
+export declare const getInvalidStoreNameMessage: (name: string) => string;
+export declare const getStoreNameContainsSpacesMessage: (name: string) => string;
+export declare const getForbiddenStoreNameMessage: (name: string) => string;
+export declare const suggestStoreName: (name: string, existingNames: string[]) => void;

package/dist/types/internals/reporting.d.ts

@@ -0,0 +1,9 @@
+export type IssueSeverity = "warn" | "critical";
+export type IssueVisibility = "dev" | "always";
+export type IssueOptions = {
+    severity?: IssueSeverity;
+    visibility?: IssueVisibility;
+    onError?: (message: string) => void;
+};
+export declare const safeInvoke: <T extends unknown[]>(fn: ((...args: T) => void) | undefined, label: string, ...args: T) => void;
+export declare const reportIssue: (message: string, options?: IssueOptions) => void;

package/dist/types/internals/store-admin.d.ts

@@ -0,0 +1,7 @@
+import { type StoreRegistry } from "../core/store-registry.js";
+export declare const createStoreAdmin: (registry: StoreRegistry) => {
+    deleteExistingStore: (name: string) => void;
+    clearAllStores: () => string[];
+    clearStores: (pattern?: string) => string[];
+    reportStoreError: (name: string, message: string) => void;
+};

package/dist/types/internals/store-ops.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @module internals/store-ops
+ *
+ * LAYER: Internal subsystem
+ * OWNS:  Module-level behavior and exports for internals/store-ops.
+ *
+ * Consumers: Internal imports and public API.
+ */
+export { createStore } from "../core/store-create.js";
+export { replaceStore } from "../core/store-replace.js";
+export { setStore, setStoreWithContext } from "../core/store-set.js";
+export { getStore, hasStore } from "../core/store-read.js";
+export { subscribeStore } from "../core/store-notify.js";

package/dist/types/internals/test-reset.d.ts

@@ -0,0 +1,2 @@
+export declare const registerTestResetHook: (name: string, fn: () => void, order?: number) => void;
+export declare const runTestResets: () => void;

package/dist/types/internals/write-context.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @module internals/write-context
+ *
+ * LAYER: Internal subsystem
+ * OWNS:  Correlation/trace context for write chains.
+ *
+ * Consumers: store-write.ts, notification/delivery.ts, async-fetch.ts.
+ */
+import type { TraceContext } from "../types/utility.js";
+export type WriteContext = {
+    correlationId?: string;
+    traceContext?: TraceContext;
+};
+export type WriteContextRunner = {
+    run: <T>(context: WriteContext, fn: () => T) => T;
+    get: () => WriteContext | null;
+};
+export declare const injectWriteContextRunner: (runner: WriteContextRunner | null) => void;
+export declare const getWriteContext: () => WriteContext | null;
+export declare const runWithWriteContext: <T>(context: WriteContext | null | undefined, fn: () => T) => T;

package/dist/types/notification/delivery.d.ts

@@ -0,0 +1,3 @@
+import { type StoreRegistry } from "../core/store-registry.js";
+import type { FlushPlan } from "./priority.js";
+export declare const deliverFlush: (registry: StoreRegistry, plan: FlushPlan, flushVersion: number, onComplete: () => void) => void;

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

@@ -0,0 +1,10 @@
+/**
+ * @module notification/index
+ *
+ * LAYER: Notification pipeline
+ * OWNS:  Orchestrating flush scheduling without owning sub-responsibilities.
+ *
+ * Consumers: store-notify.ts
+ */
+import type { StoreRegistry } from "../core/store-registry.js";
+export declare const scheduleFlush: (registry: StoreRegistry) => void;

package/dist/types/notification/metrics.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @module notification/metrics
+ *
+ * LAYER: Notification pipeline
+ * OWNS:  Notify timing and metric aggregation.
+ *
+ * Consumers: notification/delivery.ts
+ */
+import type { FeatureMetrics, StoreFeatureMeta } from "../features/feature-registry.js";
+export declare const createMetrics: (metrics?: FeatureMetrics) => FeatureMetrics;
+export declare const recordMetrics: (metrics: FeatureMetrics, elapsedMs: number) => FeatureMetrics;
+export declare const commitMetrics: (metaEntry: StoreFeatureMeta | undefined, metrics: FeatureMetrics) => void;

package/dist/types/notification/priority.d.ts

@@ -0,0 +1,9 @@
+import type { NotifyState } from "../core/store-registry.js";
+export type FlushPlan = {
+    names: string[];
+    sliceSize: number;
+    chunkDelayMs: number;
+    runInline: boolean;
+    prioritySet: Set<string> | null;
+};
+export declare const buildFlushPlan: (state: NotifyState) => FlushPlan;

package/dist/types/notification/scheduler.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @module notification/scheduler
+ *
+ * LAYER: Notification pipeline
+ * OWNS:  Flush scheduling and chunk timers.
+ *
+ * Consumers: notification/index.ts, notification/delivery.ts
+ */
+import { type StoreRegistry } from "../core/store-registry.js";
+export declare const scheduleChunk: (fn: () => void, delayMs: number) => void;
+export declare const scheduleFlush: (registry: StoreRegistry, flush: (registry: StoreRegistry) => void) => void;

package/dist/types/notification/snapshot.d.ts

@@ -0,0 +1,8 @@
+import type { SnapshotMode } from "../adapters/options.js";
+import type { StoreValue } from "../core/store-lifecycle/types.js";
+export declare const resolveSnapshotMode: (metaEntry: {
+    options?: {
+        snapshot?: SnapshotMode;
+    };
+} | undefined, fallback: SnapshotMode) => SnapshotMode;
+export declare const cloneSnapshot: (value: StoreValue, mode: SnapshotMode) => StoreValue;

package/dist/types/runtime-admin/index.d.ts

@@ -0,0 +1,2 @@
+export declare const clearAllStores: () => void;
+export declare const clearStores: (pattern?: string) => void;

package/dist/types/runtime-tools/index.d.ts

@@ -0,0 +1,63 @@
+import type { StoreFeatureMeta } from "../features/feature-registry.js";
+import { getAsyncMetrics } from "../async/fetch.js";
+import type { ComputedDescriptor, RuntimeGraph, RuntimeNodeId } from "../computed/types.js";
+export declare const listStores: (pattern?: string) => string[];
+export declare const getStoreMeta: (name: string) => StoreFeatureMeta | null;
+export declare const getInitialState: () => Record<string, unknown>;
+export declare const getMetrics: (name: string) => StoreFeatureMeta["metrics"] | null;
+export declare const getSubscriberCount: (name: string) => number;
+export declare const getAsyncInflightCount: (name: string) => number;
+export type ColdStoreReport = {
+    name: string;
+    createdAt: string;
+    lastReadAt: string | null;
+    updateCount: number;
+    readCount: number;
+    subscriberCount: number;
+    ageMs: number;
+    verdict: "cold" | "write-only" | "stale" | "active";
+};
+export declare const findColdStores: (options?: {
+    unreadThresholdMs?: number;
+    includeWriteOnly?: boolean;
+}) => ColdStoreReport[];
+export type StoreHealthEntry = {
+    name: string;
+    meta: StoreFeatureMeta | null;
+    metrics: StoreFeatureMeta["metrics"] | null;
+    async: {
+        inflight: number;
+        lastCorrelationId: string | null;
+        traceContext: StoreFeatureMeta["lastTraceContext"] | null;
+    };
+    persist: {
+        queueDepth: number;
+    };
+};
+export type StoreHealthReport = {
+    stores: StoreHealthEntry[];
+    async: ReturnType<typeof getAsyncMetrics>;
+    registry: {
+        totalStores: number;
+        coldStores: ColdStoreReport[];
+    };
+};
+export declare const getStoreHealth: (name?: string) => StoreHealthEntry | StoreHealthReport | null;
+export declare const getPersistQueueDepth: (name: string) => number;
+export declare const getComputedGraph: () => {
+    nodes: string[];
+    edges: Array<{
+        from: string;
+        to: string;
+    }>;
+    dependencies: Record<string, string[]>;
+    dependents: Record<string, string[]>;
+};
+export declare const getRuntimeGraph: () => RuntimeGraph;
+export declare const getComputedDeps: (name: string) => {
+    deps: string[];
+    dependents: string[];
+} | null;
+export declare const getComputedDescriptor: (nodeId: RuntimeNodeId) => ComputedDescriptor | null;
+export declare const evaluateComputed: (nodeId: RuntimeNodeId, snapshot: Record<string, unknown>) => unknown;
+export type { ComputedClassification, ComputedDescriptor, RuntimeEdgeType, RuntimeGraph, RuntimeGraphEdge, RuntimeGraphGranularity, RuntimeGraphNode, RuntimeNodeId, RuntimeNodeType, } from "../computed/types.js";

package/dist/types/store.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @module store
+ *
+ * LAYER: Store runtime
+ * OWNS:  Module-level behavior and exports for store.
+ *
+ * Consumers: Internal imports and public API.
+ */
+export type { Path, PathDepth, PathValue, PartialDeep, HydrateSnapshotFor, HydrationFailure, HydrationResult, StoreDefinition, StoreValue, StoreKey, StoreName, StateFor, StoreStateMap, StrictStoreMap, WriteResult, } from "./core/store-lifecycle/types.js";
+export type { FeatureOptions, FeatureOptionsMap, PersistConfig, PersistOptions, MiddlewareCtx, StoreOptions, SnapshotMode, SyncOptions, } from "./adapters/options.js";
+export { setStore, replaceStore, deleteStore, resetStore, hydrateStores, } from "./core/store-write.js";
+export { createStore, createStoreStrict } from "./core/store-create.js";
+export { setStoreBatch, subscribeStore, subscribeInternal as _subscribe, subscribe, getStoreSnapshot, getSnapshot as _getSnapshot, } from "./core/store-notify.js";
+export { getStore, hasStore, isLazyStore, isStoreMaterialized, isLazyPending, _hasStoreEntryInternal, _getStoreValueRef, _getFeatureApi, getInitialState, getMetrics, } from "./core/store-read.js";
+export { clearAllStores, clearStores } from "./runtime-admin/index.js";
+export { store, namespace } from "./core/store-name.js";

package/dist/types/types/utility.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @module types/utility
+ *
+ * LAYER: Types
+ * OWNS:  Shared utility types for cross-module reuse.
+ *
+ * Consumers: store-create.ts, store-name.ts, computed.ts, testing.ts.
+ */
+export type NonFunction<T> = T extends Function ? never : T;
+export type DeepReadonly<T> = {
+    readonly [K in keyof T]: DeepReadonly<T[K]>;
+};
+export type StoreId = string | symbol;
+export type TraceContext = {
+    traceId: string;
+    spanId: string;
+} & Record<string, unknown>;

package/dist/types/utils/clone.d.ts

@@ -0,0 +1,4 @@
+export declare const shallowClone: <T>(value: T) => T;
+export declare const deepClone: <T>(value: T) => T;
+export declare const shallowEqual: (a: unknown, b: unknown) => boolean;
+export declare const produceClone: <T>(base: T, recipe: (draft: T) => void) => T;

package/dist/types/utils/devfreeze.d.ts

@@ -0,0 +1,2 @@
+export declare const devShallowFreeze: <T>(value: T) => T;
+export declare const devDeepFreeze: <T>(value: T) => T;

package/dist/types/utils/hash.d.ts

@@ -0,0 +1,8 @@
+export declare const crc32: (str: string) => number;
+/**
+ * Non-cryptographic checksum for integrity (best-effort). Do not use for security.
+ * String inputs preserve the legacy CRC32(JSON.stringify(value)) behavior to keep
+ * persisted checksums stable across versions.
+ */
+export declare const hashState: (value: unknown) => number;
+export declare const checksumState: (value: unknown) => number;

package/dist/types/utils/path.d.ts

@@ -0,0 +1,5 @@
+export type PathInput = string | readonly string[] | string[];
+export declare const parsePath: (path: PathInput) => string[];
+export declare const validateDepth: (path: PathInput) => boolean;
+export declare const getByPath: (obj: unknown, path: PathInput) => unknown;
+export declare const setByPath: <T extends Record<string, unknown> | unknown[]>(obj: T, path: PathInput, value: unknown) => T;

package/dist/types/utils/validation.d.ts

@@ -0,0 +1,14 @@
+export declare const FORBIDDEN_OBJECT_KEYS: Set<string>;
+export declare const runSchemaValidation: (schema: unknown, value: unknown) => {
+    ok: boolean;
+    data?: unknown;
+    error?: unknown;
+};
+declare const SUPPORTED_TYPES: readonly ["object", "array", "string", "number", "boolean", "null"];
+export type SupportedType = typeof SUPPORTED_TYPES[number] | "function" | "map" | "set" | "date" | "undefined" | "bigint" | "symbol";
+export declare const getType: (value: unknown) => SupportedType;
+export declare const isValidData: (value: unknown) => boolean;
+export declare const canReuseSanitized: (value: unknown) => boolean;
+export declare const sanitize: (value: unknown) => unknown;
+export declare const isValidStoreName: (name: string) => boolean;
+export {};

package/dist/types/utils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @module utils
+ *
+ * LAYER: Utilities
+ * OWNS:  Module-level behavior and exports for utils.
+ *
+ * Consumers: Internal imports and public API.
+ */
+export { __DEV__, isDev, warn, warnAlways, error, log, critical, suggestStoreName, } from "./internals/diagnostics.js";
+export { crc32, hashState, checksumState } from "./utils/hash.js";
+export { shallowClone, deepClone, shallowEqual, produceClone } from "./utils/clone.js";
+export { parsePath, validateDepth, getByPath, setByPath, type PathInput } from "./utils/path.js";
+export { runSchemaValidation, getType, isValidData, canReuseSanitized, sanitize, isValidStoreName, type SupportedType, } from "./utils/validation.js";

package/dist/types.d.ts

@@ -59,7 +59,7 @@ type WriteResult = {
     ok: true;
 } | {
     ok: false;
-    reason: "not-found" | "validate" | "path" | "middleware" | "ssr" | "invalid-args" | "lazy-uninitialized";
+    reason: "not-found" | "validate" | "path" | "middleware" | "ssr" | "invalid-args" | "lazy-uninitialized" | "unsupported-op" | "unsupported-path-shape";
 };
 
-export type { HydrateSnapshotFor as H, PartialDeep as P, StoreStateMap as S, WriteResult as W, StoreDefinition as a, StoreKey as b, StoreName as c, StoreValue as d, StateFor as e, StrictStoreMap as f, HydrationResult as g, HydrationFailure as h, Path as i, PathValue as j };
+export type { HydrateSnapshotFor as H, PartialDeep as P, StoreValue as S, WriteResult as W, StoreDefinition as a, StoreKey as b, StoreStateMap as c, StoreName as d, StateFor as e, StrictStoreMap as f, HydrationResult as g, HydrationFailure as h, Path as i, PathValue as j };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "stroid",
-  "version": "0.1.3",
-  "description": "SSR-Safe, Named-store state engine for JavaScript/React with optional persistence, async caching, sync, and devtools.",
+  "version": "0.1.4",
+  "description": "Deterministic state engine for React and JavaScript with SSR-safe isolation, multi-store coordination, and decision-driven state workflows.",
   "keywords": [
     "state-management",
     "state",
@@ -24,6 +24,10 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./psr": {
+      "types": "./dist/psr.d.ts",
+      "import": "./dist/psr.js"
+    },
     "./core": {
       "types": "./dist/core.d.ts",
       "import": "./dist/core.js"
@@ -80,14 +84,6 @@
       "types": "./dist/react/index.d.ts",
       "import": "./dist/react/index.js"
     },
-    "./vue": {
-      "types": "./dist/vue/index.d.ts",
-      "import": "./dist/vue/index.js"
-    },
-    "./svelte": {
-      "types": "./dist/svelte/index.d.ts",
-      "import": "./dist/svelte/index.js"
-    },
     "./testing": {
       "types": "./dist/testing.d.ts",
       "import": "./dist/testing.js"
@@ -96,11 +92,17 @@
   },
   "types": "dist/index.d.ts",
   "files": [
-    "dist",
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "dist/**/*.d.cts",
+    "dist/**/*.json",
     "README.md",
     "CHANGELOG.md",
     "LICENSE"
   ],
+  "publishConfig": {
+    "tag": "beta"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Himesh-Bhattarai/stroid.git"
@@ -110,26 +112,35 @@
   },
   "homepage": "https://github.com/Himesh-Bhattarai/stroid#readme",
   "sideEffects": [
-    "./src/persist.ts",
-    "./src/sync.ts",
-    "./src/devtools/index.ts",
-    "./src/core/store-notify.ts",
-    "./dist/persist.js",
-    "./dist/sync.js",
-    "./dist/devtools.js"
+    "./src/core/store-notify.ts"
   ],
   "scripts": {
     "test": "node --import ./tests/preload.mjs --import tsx --import ./tests/setup.ts --test-concurrency=1 --test tests/unit/**/*.test.ts tests/unit/**/*.test.tsx tests/integration/**/*.test.ts tests/integration/**/*.test.tsx tests/regression/**/*.test.ts tests/ssr/**/*.test.ts tests/utils/**/*.test.ts",
     "test:coverage": "c8 node --import ./tests/preload.mjs --import tsx --import ./tests/setup.ts --test tests/unit/**/*.test.ts tests/unit/**/*.test.tsx tests/integration/**/*.test.ts tests/integration/**/*.test.tsx tests/regression/**/*.test.ts tests/ssr/**/*.test.ts tests/utils/**/*.test.ts",
-    "test:performance": "node --import ./tests/preload.mjs --import tsx --import ./tests/setup.ts --test-concurrency=1 --test tests/performance/**/*.test.ts",
+    "test:performance": "node --import ./tests/preload.mjs --import tsx --import ./tests/setup.ts --test-concurrency=1 --test tests/performance/notify-flush.perf.test.ts tests/performance/snapshot-cache.perf.test.ts tests/performance/stress-memory.perf.test.ts tests/performance/subscriber-concurrent.perf.test.ts tests/performance/sync-lite.perf.test.ts --test-force-exit",
     "test:heavy": "npm run test:performance",
+    "test:package": "node --import ./tests/preload.mjs --import tsx --import ./tests/setup.ts --test-concurrency=1 --test tests/package/**/*.test.ts",
     "check:react-types": "node scripts/check-react-types.mjs",
     "docs:api": "api-extractor run --local",
     "test:dts": "tsc -p tsconfig.dtscheck.json --noEmit",
-    "test:types": "npm run build && npm run check:react-types && npm run docs:api && npm run test:dts && tsc -p tsconfig.typetests.json",
+    "test:types": "npm run build && npm run test:package && npm run check:react-types && npm run docs:api && npm run test:dts && tsc -p tsconfig.typetests.json",
     "typecheck": "tsc -p tsconfig.types.json",
     "typecheck:layers": "tsc -b tsconfig.layers.json",
     "build": "tsup && node scripts/normalize-dts.mjs",
+    "benchmark:compare": "node --expose-gc --import tsx scripts/compare-state-libraries.ts",
+    "benchmark:core-small": "node --expose-gc --import tsx scripts/core-small-benchmark.ts",
+    "benchmark:subscriber": "node --expose-gc --import tsx scripts/subscriber-benchmark.ts",
+    "benchmark:subscriber:concurrent": "node --expose-gc --import tsx scripts/subscriber-concurrent-benchmark.ts",
+    "benchmark:selector": "node --expose-gc --import tsx scripts/selector-benchmark.ts",
+    "benchmark:deep-update": "node --expose-gc --import tsx scripts/deep-update-benchmark.ts",
+    "benchmark:lifecycle": "node --expose-gc --import tsx scripts/lifecycle-benchmark.ts",
+    "benchmark:ssr-isolation": "node --expose-gc --import tsx scripts/ssr-isolation-benchmark.ts",
+    "benchmark:atomic-failure": "node --expose-gc --import tsx scripts/atomic-failure-benchmark.ts",
+    "benchmark:race": "node --expose-gc --import tsx scripts/race-condition-benchmark.ts",
+    "benchmark:determinism": "node --expose-gc --import tsx scripts/determinism-replay-benchmark.ts",
+    "benchmark:memory-leak": "node --expose-gc --import tsx scripts/memory-leak-benchmark.ts",
+    "benchmark:governance": "node --expose-gc --import tsx scripts/governance-lifecycle-benchmark.ts",
+    "benchmark:guarantees": "node --expose-gc --import tsx scripts/guarantee-benchmark-suite.ts",
     "test:all": "npm test && npm run test:types",
     "test:full": "npm run test:coverage && npm run test:types"
   },