stroid 0.0.3 → 0.1.0

package/dist/types/computed-graph.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @module computed-graph
+ *
+ * LAYER: Internal graph engine
+ * OWNS:  Dependency tracking, cycle detection, topological ordering,
+ *        computed entry CRUD. Zero React. Zero async.
+ *
+ * Consumers: computed.ts (public API), store-notify.ts (flush ordering),
+ *            store-admin.ts (cleanup on delete), runtime-tools.ts (diagnostics)
+ */
+import { type ComputedEntry } from "./store-registry.js";
+export declare const detectCycle: (name: string, deps: string[]) => string | null;
+export declare const registerComputed: (name: string, deps: string[], compute: (...args: unknown[]) => unknown) => boolean;
+export declare const unregisterComputed: (name: string) => void;
+export declare const markStale: (name: string) => void;
+export declare const isComputed: (name: string) => boolean;
+export declare const getComputedEntry: (name: string) => ComputedEntry | undefined;
+export declare const getTopoOrderedComputeds: (changedSources: string[]) => string[];
+export declare const getFullComputedGraph: () => {
+    nodes: string[];
+    edges: Array<{
+        from: string;
+        to: string;
+    }>;
+    dependencies: Record<string, string[]>;
+    dependents: Record<string, string[]>;
+};
+export declare const getComputedDepsFor: (name: string) => {
+    deps: string[];
+    dependents: string[];
+} | null;

package/dist/types/computed.d.ts

@@ -0,0 +1,15 @@
+import type { StoreDefinition, StoreKey, StoreName, StateFor, StoreValue } from "./store-lifecycle.js";
+export type ComputedOptions = {
+    autoDispose?: boolean;
+    onError?: (err: unknown) => void;
+};
+type DepHandle = StoreDefinition<string, StoreValue> | StoreKey<string, StoreValue>;
+type DepValue<T> = T extends StoreDefinition<string, infer S> ? Readonly<S> | null : T extends StoreKey<string, infer S> ? Readonly<S> | null : T extends StoreName ? Readonly<StateFor<T>> | null : StoreValue | null;
+export declare function createComputed<TResult, Deps extends readonly (StoreName | DepHandle)[]>(name: string, deps: Deps, compute: (...args: {
+    [K in keyof Deps]: DepValue<Deps[K]>;
+}) => TResult, options?: ComputedOptions): StoreDefinition<string, TResult> | undefined;
+export declare const invalidateComputed: (name: string) => void;
+export declare const deleteComputed: (name: string) => void;
+export declare const isComputedStore: (name: string) => boolean;
+export declare const _resetComputedForTests: () => void;
+export {};

package/dist/types/config.d.ts

@@ -0,0 +1,2 @@
+export { configureStroid, resetConfig } from "./internals/config.js";
+export type { LogSink, StroidConfig, FlushConfig, RevalidateOnFocusConfig, } from "./internals/config.js";

package/dist/types/core.d.ts

@@ -0,0 +1 @@
+export * from "./index.js";

package/dist/types/devfreeze.d.ts

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

package/dist/types/feature-registry.d.ts

@@ -0,0 +1,69 @@
+import type { NormalizedOptions, StoreValue } from "./adapters/options.js";
+export type FeatureName = "persist" | "sync" | "devtools";
+export interface FeatureMetrics {
+    notifyCount: number;
+    totalNotifyMs: number;
+    lastNotifyMs: number;
+}
+export interface StoreFeatureMeta {
+    createdAt: string;
+    updatedAt: string;
+    updatedAtMs: number;
+    updateCount: number;
+    version: number;
+    metrics: FeatureMetrics;
+    options: NormalizedOptions;
+}
+export interface BaseFeatureContext {
+    name: string;
+    options: NormalizedOptions;
+    getMeta: () => StoreFeatureMeta | undefined;
+    getStoreValue: () => StoreValue;
+    getAllStores: () => Record<string, StoreValue>;
+    getInitialState: () => StoreValue;
+    hasStore: () => boolean;
+    setStoreValue: (value: StoreValue) => void;
+    applyFeatureState: (value: StoreValue, updatedAtMs?: number) => void;
+    notify: () => void;
+    reportStoreError: (message: string) => void;
+    warn: (message: string) => void;
+    log: (message: string) => void;
+    hashState: (value: unknown) => number;
+    deepClone: <T>(value: T) => T;
+    sanitize: (value: unknown) => unknown;
+    validate: (next: StoreValue) => {
+        ok: boolean;
+        value?: StoreValue;
+    };
+    isDev: () => boolean;
+}
+export interface FeatureCreateContext extends BaseFeatureContext {
+}
+export interface FeatureWriteContext extends BaseFeatureContext {
+    action: string;
+    prev: StoreValue;
+    next: StoreValue;
+}
+export interface FeatureDeleteContext extends BaseFeatureContext {
+    prev: StoreValue;
+}
+export interface DevtoolsFeatureApi {
+    getHistory?: (name: string, limit?: number) => unknown[];
+    clearHistory?: (name?: string) => void;
+    getPersistQueueDepth?: (name: string) => number;
+}
+export interface StoreFeatureRuntime {
+    onStoreCreate?: (ctx: FeatureCreateContext) => void;
+    onStoreWrite?: (ctx: FeatureWriteContext) => void;
+    beforeStoreDelete?: (ctx: FeatureDeleteContext) => void;
+    afterStoreDelete?: (ctx: FeatureDeleteContext) => void;
+    resetAll?: () => void;
+    api?: DevtoolsFeatureApi;
+}
+export type StoreFeatureFactory = () => StoreFeatureRuntime;
+export declare const registerStoreFeature: (name: FeatureName, factory: StoreFeatureFactory) => void;
+export declare const hasRegisteredStoreFeature: (name: FeatureName) => boolean;
+export declare const getStoreFeatureFactory: (name: FeatureName) => StoreFeatureFactory | undefined;
+export declare const getRegisteredFeatureNames: () => FeatureName[];
+export declare const setFeatureRegistrationHook: (hook: ((name: FeatureName, factory: StoreFeatureFactory) => void) | null) => void;
+export declare const resetRegisteredStoreFeaturesForTests: () => void;

package/dist/types/features/lifecycle.d.ts

@@ -0,0 +1,28 @@
+import type { StoreValue } from "../adapters/options.js";
+export declare const MIDDLEWARE_ABORT: unique symbol;
+export type LifecycleIssueReporter = (message: string, visibility?: "dev" | "always") => void;
+export declare const runMiddleware: ({ name, payload, middlewares, reportIssue, warn, }: {
+    name: string;
+    payload: {
+        action: string;
+        prev: StoreValue;
+        next: StoreValue;
+        path: unknown;
+    };
+    middlewares: Array<(ctx: {
+        action: string;
+        name: string;
+        prev: StoreValue;
+        next: StoreValue;
+        path: unknown;
+    }) => StoreValue | void>;
+    reportIssue: LifecycleIssueReporter;
+    warn: (message: string) => void;
+}) => StoreValue | typeof MIDDLEWARE_ABORT;
+export declare const runStoreHook: ({ name, label, fn, args, reportIssue, }: {
+    name: string;
+    label: "onCreate" | "onSet" | "onReset" | "onDelete";
+    fn: ((...args: any[]) => void) | undefined;
+    args: any[];
+    reportIssue: LifecycleIssueReporter;
+}) => void;

package/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+export { createStore, createStoreStrict, setStore, setStoreBatch, getStore, deleteStore, resetStore, hasStore, hydrateStores, } from "./store.js";
+export { createComputed, invalidateComputed, deleteComputed, isComputedStore, } from "./computed.js";
+export { namespace, store } from "./store.js";
+export type { Path, PathValue, PartialDeep, StoreDefinition, StoreValue, StoreKey, StoreName, StateFor, StoreStateMap, StrictStoreMap, WriteResult, PersistOptions, StoreOptions, SyncOptions, } from "./store.js";
+export { configureStroid } from "./config.js";
+export * as queryIntegrations from "./integrations/query.js";

package/dist/types/integrations/query.d.ts

@@ -0,0 +1,8 @@
+import type { FetchInput, FetchOptions } from "../async-cache.js";
+import type { StoreDefinition, StoreKey, StoreName } from "../store-lifecycle.js";
+type StoreTarget = StoreDefinition<string, unknown> | StoreKey<string, unknown> | StoreName;
+export declare const reactQueryKey: (storeName: StoreTarget, cacheKey?: string | number) => (string | number)[];
+export declare const createReactQueryFetcher: (storeName: StoreTarget, input: FetchInput, options?: FetchOptions) => () => Promise<unknown>;
+export declare const swrKey: (storeName: StoreTarget, cacheKey?: string | number) => (string | number)[];
+export declare const createSwrFetcher: (storeName: StoreTarget, input: FetchInput, options?: FetchOptions) => () => Promise<unknown>;
+export {};

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

@@ -0,0 +1,62 @@
+import type { SnapshotMode, MiddlewareCtx, StoreValue } from "../adapters/options.js";
+export type LogSink = {
+    log?: (msg: string, meta?: Record<string, unknown>) => void;
+    warn?: (msg: string, meta?: Record<string, unknown>) => void;
+    critical?: (msg: string, meta?: Record<string, unknown>) => void;
+};
+export type AsyncCloneMode = "none" | "shallow" | "deep";
+export type FlushConfig = {
+    chunkSize?: number;
+    chunkDelayMs?: number;
+    priorityStores?: string[];
+};
+export type RevalidateOnFocusConfig = {
+    debounceMs?: number;
+    maxConcurrent?: number;
+    staggerMs?: number;
+};
+export type StroidConfig = {
+    logSink?: LogSink;
+    flush?: FlushConfig;
+    revalidateOnFocus?: RevalidateOnFocusConfig;
+    namespace?: string;
+    strictMissingFeatures?: boolean;
+    strictFeatures?: boolean;
+    assertRuntime?: boolean;
+    strictMutatorReturns?: boolean;
+    asyncAutoCreate?: boolean;
+    asyncCloneResult?: AsyncCloneMode;
+    defaultSnapshotMode?: SnapshotMode;
+    middleware?: Array<(ctx: MiddlewareCtx) => StoreValue | void>;
+    /**
+     * Allow hydrateStores to accept untrusted snapshots without explicit opt-in.
+     * Default: false (hydration requires an explicit trust opt-in).
+     */
+    allowUntrustedHydration?: boolean;
+    /**
+     * Optional custom mutator engine (e.g. Immer's produce) to enable structural sharing.
+     */
+    mutatorProduce?: <T>(base: T, recipe: (draft: T) => void) => T;
+};
+type ResolvedConfig = {
+    logSink: LogSink;
+    flush: Required<FlushConfig>;
+    revalidateOnFocus: Required<RevalidateOnFocusConfig>;
+    namespace: string;
+    strictMissingFeatures: boolean;
+    assertRuntime: boolean;
+    strictMutatorReturns: boolean;
+    asyncAutoCreate: boolean;
+    asyncCloneResult: AsyncCloneMode;
+    defaultSnapshotMode: SnapshotMode;
+    middleware: Array<(ctx: MiddlewareCtx) => StoreValue | void>;
+    allowUntrustedHydration: boolean;
+    mutatorProduce?: <T>(base: T, recipe: (draft: T) => void) => T;
+};
+export declare const getConfig: () => ResolvedConfig;
+export declare const configureStroid: (next?: StroidConfig) => void;
+export declare const resetConfig: () => void;
+export declare const _resetConfigForTests: () => void;
+export declare const getNamespace: () => string;
+export declare const setNamespace: (ns: string) => void;
+export {};

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/hooks-warnings.d.ts

@@ -0,0 +1,6 @@
+export declare const hasBroadUseStoreWarning: (name: string) => boolean;
+export declare const markBroadUseStoreWarning: (name: string) => void;
+export declare const hasMissingUseStoreWarning: (name: string) => boolean;
+export declare const markMissingUseStoreWarning: (name: string) => void;
+export declare const resetBroadUseStoreWarnings: () => void;
+export declare const resetMissingUseStoreWarnings: () => void;

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

@@ -0,0 +1,8 @@
+export type IssueSeverity = "warn" | "critical";
+export type IssueVisibility = "dev" | "always";
+export type IssueOptions = {
+    severity?: IssueSeverity;
+    visibility?: IssueVisibility;
+    onError?: (message: string) => 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 "../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,3 @@
+export { createStore, replaceStore } from "../store-write.js";
+export { getStore, hasStore } from "../store-read.js";
+export { subscribeStore } from "../store-notify.js";

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

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

package/dist/types/store-lifecycle/bind.d.ts

@@ -0,0 +1,3 @@
+import type { StoreRegistry } from "../store-registry.js";
+export declare const bindRegistry: (scopeOrRegistry?: string | StoreRegistry) => void;
+export declare const useRegistry: (scopeId: string) => void;

package/dist/types/store-lifecycle/hooks.d.ts

@@ -0,0 +1,44 @@
+import { warn, log, hashState, deepClone, sanitize, isDev } from "../utils.js";
+import { MIDDLEWARE_ABORT } from "../features/lifecycle.js";
+import { type StoreFeatureMeta } from "../feature-registry.js";
+import type { NormalizedOptions } from "../adapters/options.js";
+import type { StoreValue } from "./types.js";
+type BaseFeatureContext = {
+    name: string;
+    options: StoreFeatureMeta["options"];
+    getMeta: () => StoreFeatureMeta | undefined;
+    getStoreValue: () => StoreValue;
+    getAllStores: () => Record<string, StoreValue>;
+    getInitialState: () => StoreValue | undefined;
+    hasStore: () => boolean;
+    setStoreValue: (value: StoreValue) => void;
+    applyFeatureState: (value: StoreValue, updatedAtMs?: number) => void;
+    notify: () => void;
+    reportStoreError: (message: string) => void;
+    warn: typeof warn;
+    log: typeof log;
+    hashState: typeof hashState;
+    deepClone: typeof deepClone;
+    sanitize: typeof sanitize;
+    validate: (next: StoreValue) => {
+        ok: true;
+        value: StoreValue;
+    } | {
+        ok: false;
+    };
+    isDev: typeof isDev;
+};
+export declare const clearFeatureContexts: () => void;
+export declare const createBaseFeatureContext: (name: string) => BaseFeatureContext | null;
+export declare const runFeatureCreateHooks: (name: string, notify: (name: string) => void) => void;
+export declare const runFeatureWriteHooks: (name: string, action: string, prev: StoreValue, next: StoreValue, notify: (name: string) => void) => void;
+export declare const runFeatureDeleteHooks: (name: string, prev: StoreValue, notify: (name: string) => void) => void;
+export declare const runMiddlewareForStore: (name: string, payload: {
+    action: string;
+    prev: StoreValue;
+    next: StoreValue;
+    path: unknown;
+}) => StoreValue | typeof MIDDLEWARE_ABORT;
+export declare const runStoreHookSafe: (name: string, label: "onCreate" | "onSet" | "onReset" | "onDelete", fn: ((...args: any[]) => void) | undefined, args: any[]) => void;
+export declare const resolveFeatureAvailability: (name: string, options: NormalizedOptions) => NormalizedOptions;
+export {};

package/dist/types/store-lifecycle/identity.d.ts

@@ -0,0 +1,23 @@
+import { type IssueSeverity, type IssueVisibility } from "../internals/reporting.js";
+import type { FeatureName } from "../feature-registry.js";
+import type { StoreDefinition } from "./types.js";
+export declare const getSsrWarningIssued: (name?: string) => boolean;
+export declare const markSsrWarningIssued: (name: string) => void;
+export declare const resetSsrWarningFlag: () => void;
+export declare const qualifyName: (raw: string) => string;
+export declare const nameOf: (name: string | StoreDefinition<string, unknown>) => string;
+export declare const exists: (name: string) => boolean;
+export declare const reportStoreIssue: (name: string, message: string, options?: {
+    severity?: IssueSeverity;
+    visibility?: IssueVisibility;
+}) => void;
+export declare const reportStoreCreationIssue: (message: string, onError?: (message: string) => void, options?: {
+    severity?: IssueSeverity;
+    visibility?: IssueVisibility;
+}) => void;
+export declare const reportStoreWarning: (name: string, message: string, visibility?: IssueVisibility) => void;
+export declare const reportStoreCreationWarning: (message: string, onError?: (message: string) => void, visibility?: IssueVisibility) => void;
+export declare const reportStoreError: (name: string, message: string) => void;
+export declare const reportStoreCreationError: (message: string, onError?: (message: string) => void) => void;
+export declare const warnMissingFeature: (storeName: string, featureName: FeatureName, onError?: (message: string) => void) => void;
+export declare const getFeatureApi: (name: FeatureName) => import("../feature-registry.js").DevtoolsFeatureApi | undefined;

package/dist/types/store-lifecycle/registry.d.ts

@@ -0,0 +1,39 @@
+import { getStoreRegistry, type StoreRegistry } from "../store-registry.js";
+import { type FeatureName, type StoreFeatureRuntime, type StoreFeatureMeta } from "../feature-registry.js";
+import { createStoreAdmin } from "../internals/store-admin.js";
+import type { StoreValue, Subscriber } from "./types.js";
+export { defaultRegistryScope } from "../store-registry.js";
+export declare const setRegistryContext: (scope: string, registry: StoreRegistry) => void;
+export declare const getRegistry: () => StoreRegistry;
+export declare const setPathCacheInvalidator: (fn: (name: string) => void) => void;
+export declare const stores: Record<string, unknown>;
+export declare const subscribers: Record<string, Set<Subscriber>>;
+export declare const initialStates: Record<string, unknown>;
+export declare const initialFactories: Record<string, (() => StoreValue) | undefined>;
+export declare const meta: Record<string, StoreFeatureMeta>;
+export declare const snapshotCache: Record<string, {
+    version: number;
+    snapshot: StoreValue | null;
+}>;
+export declare const featureRuntimes: Map<FeatureName, StoreFeatureRuntime>;
+export declare const storeAdmin: {
+    deleteExistingStore: (name: string) => void;
+    clearAllStores: () => string[];
+    clearStores: (pattern?: string) => string[];
+    reportStoreError: (name: string, message: string) => void;
+};
+export declare const getStoreAdmin: () => ReturnType<typeof createStoreAdmin>;
+export declare const getFeatureRuntime: (name: FeatureName) => StoreFeatureRuntime | undefined;
+export declare const initializeRegisteredFeatureRuntimes: () => void;
+export declare const hasStoreEntryInternal: (name: string) => boolean;
+export declare const getStoreValueRef: (name: string) => StoreValue | undefined;
+export declare const setStoreValueInternal: (name: string, value: StoreValue) => void;
+export declare const applyFeatureState: (name: string, value: StoreValue, updatedAtMs?: number) => void;
+export declare const clearAllRegistries: () => void;
+export declare const resetFeaturesForTests: () => void;
+export declare const getMetaEntry: (name: string) => StoreFeatureMeta | undefined;
+export declare const isDeleting: (name: string) => boolean;
+export declare const resolveScope: (scopeOrRegistry?: string | ReturnType<typeof getStoreRegistry>) => {
+    scope: string;
+    registry: StoreRegistry;
+};

package/dist/types/store-lifecycle/types.d.ts

@@ -0,0 +1,39 @@
+type Primitive = string | number | boolean | bigint | symbol | null | undefined;
+type PrevDepth = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+type PathInternal<T, Depth extends number> = Depth extends 0 ? never : T extends Primitive ? never : {
+    [K in keyof T & (string | number)]: T[K] extends Primitive | Array<unknown> ? `${K}` : `${K}` | `${K}.${PathInternal<T[K], PrevDepth[Depth]>}`;
+}[keyof T & (string | number)];
+export type PathDepth<T, Depth extends number> = PathInternal<T, Depth>;
+export type Path<T, Depth extends number = 10> = PathInternal<T, Depth>;
+export type PathValue<T, P extends Path<T>> = P extends `${infer K}.${infer Rest}` ? K extends keyof T ? Rest extends Path<T[K]> ? PathValue<T[K], Rest> : never : never : P extends keyof T ? T[P] : never;
+export type PartialDeep<T> = T extends Primitive ? T : unknown extends T ? T : {
+    [K in keyof T]?: PartialDeep<T[K]>;
+};
+export type StoreValue = unknown;
+export interface StoreStateMap {
+}
+export interface StrictStoreMap {
+}
+type RegisteredStoreMap = StoreStateMap & StrictStoreMap;
+declare const storeNameBrand: unique symbol;
+type BrandedStoreName = string & {
+    readonly [storeNameBrand]: true;
+};
+export type StoreName = (keyof RegisteredStoreMap & string) | BrandedStoreName;
+export type StateFor<Name extends string> = Name extends keyof RegisteredStoreMap ? RegisteredStoreMap[Name] : StoreValue;
+export type UnregisteredStoreName<Name extends string> = never;
+export type StoreKey<Name extends string = string, State = StoreValue> = StoreDefinition<Name, State> & {
+    __store?: true;
+};
+export interface StoreDefinition<Name extends string = string, State = StoreValue> {
+    name: Name;
+    state?: State;
+}
+export type WriteResult = {
+    ok: true;
+} | {
+    ok: false;
+    reason: "not-found" | "validate" | "path" | "middleware" | "ssr" | "invalid-args";
+};
+export type Subscriber = (value: StoreValue | null) => void;
+export {};

package/dist/types/store-lifecycle/validation.d.ts

@@ -0,0 +1,45 @@
+import { type SupportedType, PathInput } from "../utils.js";
+import { type ValidateOption } from "../adapters/options.js";
+import type { StoreValue } from "./types.js";
+type PathSafetyVerdict = {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};
+type PathValidationCacheNode = {
+    children: Map<string, PathValidationCacheNode>;
+    verdicts?: Map<SupportedType, PathSafetyVerdict>;
+};
+export declare const pathValidationCache: Map<string, PathValidationCacheNode>;
+export declare const resetPathValidationCache: (registry: object) => void;
+export declare const validatePathSafety: (storeName: string, base: StoreValue, path: PathInput, nextValue: unknown) => {
+    ok: boolean;
+    reason?: string;
+};
+export declare const sanitizeValue: (name: string, value: unknown, onError?: (message: string) => void, options?: {
+    reuseInput?: boolean;
+}) => {
+    ok: true;
+    value: StoreValue;
+} | {
+    ok: false;
+};
+export declare const runValidation: (name: string, value: StoreValue, validate: ValidateOption | undefined, onError?: (message: string) => void) => {
+    ok: true;
+    value: StoreValue;
+} | {
+    ok: false;
+};
+export declare const normalizeCommittedState: (name: string, value: unknown, validate: ValidateOption | undefined, onError?: (message: string) => void, options?: {
+    reuseInput?: boolean;
+}) => {
+    ok: true;
+    value: StoreValue;
+} | {
+    ok: false;
+};
+export declare const invalidatePathCache: (name: string) => void;
+export declare const clearPathValidationCache: () => void;
+export declare const materializeInitial: (name: string) => boolean;
+export {};

package/dist/types/store-lifecycle.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @module store-lifecycle
+ *
+ * LAYER: Core Engine
+ * OWNS:  Registry state variables (stores, meta, subscribers, ...) and all
+ *        pure primitives that operate on them (sanitize, validate, path-safety,
+ *        feature hook dispatch).
+ *
+ * DOES NOT KNOW about: createStore(), setStore(), React hooks,
+ *        or any specific feature plugin by name.
+ *
+ * Consumers: store-write (write API), store-read, store-notify,
+ *            hooks-core.
+ */
+export type { Path, PathDepth, PathValue, PartialDeep, StoreValue, StoreKey, StoreDefinition, StoreName, StateFor, WriteResult, Subscriber, StoreStateMap, StrictStoreMap, UnregisteredStoreName, } from "./store-lifecycle/types.js";
+export { stores, meta, subscribers, initialStates, initialFactories, snapshotCache, featureRuntimes, storeAdmin, getStoreAdmin, getFeatureRuntime, hasStoreEntryInternal, getStoreValueRef, setStoreValueInternal, applyFeatureState, clearAllRegistries, resetFeaturesForTests, getMetaEntry, getRegistry, defaultRegistryScope, } from "./store-lifecycle/registry.js";
+export { sanitizeValue, normalizeCommittedState, runValidation, validatePathSafety, invalidatePathCache, clearPathValidationCache, materializeInitial, pathValidationCache, } from "./store-lifecycle/validation.js";
+export { runFeatureCreateHooks, runFeatureWriteHooks, runFeatureDeleteHooks, runMiddlewareForStore, runStoreHookSafe, resolveFeatureAvailability, clearFeatureContexts, createBaseFeatureContext, } from "./store-lifecycle/hooks.js";
+export { nameOf, qualifyName, exists, getFeatureApi, reportStoreCreationError, reportStoreError, reportStoreWarning, reportStoreCreationWarning, getSsrWarningIssued, markSsrWarningIssued, resetSsrWarningFlag, warnMissingFeature, } from "./store-lifecycle/identity.js";
+export { bindRegistry, useRegistry } from "./store-lifecycle/bind.js";

package/dist/types/store-name.d.ts

@@ -0,0 +1,19 @@
+import type { StoreKey, StoreValue } from "./store-lifecycle.js";
+import { createStore } from "./store-write.js";
+/**
+ * Helper to get an auto-completable, literal-typed store handle without creating it.
+ *
+ * Example:
+ *   const user = store("user");
+ *   setStore(user, "name", "Alex");
+ */
+export declare const store: <Name extends string, State = StoreValue>(name: Name) => StoreKey<Name, State>;
+export declare const namespace: (ns: string) => {
+    store: <Name extends string, State = unknown>(name: Name) => StoreKey<Name, State>;
+    create: <Name extends string, State>(name: Name, data: State, options?: Parameters<typeof createStore>[2]) => import("./store-lifecycle.js").StoreDefinition<string, unknown> | undefined;
+    createStrict: <Name extends string, State>(name: Name, data: State, options?: Parameters<typeof createStore>[2]) => import("./store-lifecycle.js").StoreDefinition<string, unknown>;
+    set: (name: any, ...rest: any[]) => any;
+    get: (name: any, ...rest: any[]) => any;
+    delete: (name: string) => void;
+    reset: (name: string) => import("./store-lifecycle.js").WriteResult;
+};

package/dist/types/store-notify.d.ts

@@ -0,0 +1,12 @@
+import { type StoreValue, type Subscriber } from "./store-lifecycle.js";
+export declare const notify: (name: string) => void;
+export declare const setStoreBatch: (fn: () => unknown) => void;
+export declare const subscribeStore: (name: string, fn: Subscriber) => (() => void);
+/** @deprecated Use subscribeStore instead. */
+export declare const subscribeInternal: (name: string, fn: Subscriber) => (() => void);
+/** @deprecated Use subscribeStore instead. */
+export declare const subscribe: (name: string, fn: Subscriber) => (() => void);
+export declare const getStoreSnapshot: (name: string) => StoreValue | null;
+/** @deprecated Use getStoreSnapshot instead. */
+export declare const getSnapshot: (name: string) => StoreValue | null;
+export declare const resetNotifyStateForTests: () => void;

package/dist/types/store-read.d.ts

@@ -0,0 +1,12 @@
+import { meta, hasStoreEntryInternal, getStoreValueRef, getFeatureApi, type Path, type PathValue, type StoreDefinition, type StoreValue, type StoreKey, type StoreName, type StateFor } from "./store-lifecycle.js";
+type StoreSnapshot<T> = T extends object ? Readonly<T> : T;
+export declare function getStore<Name extends string, State, P extends Path<State>>(name: StoreDefinition<Name, State>, path: P): StoreSnapshot<PathValue<State, P>> | null;
+export declare function getStore<Name extends string, State>(name: StoreDefinition<Name, State>, path?: undefined): StoreSnapshot<State> | null;
+export declare function getStore<Name extends string, State, P extends Path<State>>(name: StoreKey<Name, State>, path: P): StoreSnapshot<PathValue<State, P>> | null;
+export declare function getStore<Name extends string, State>(name: StoreKey<Name, State>, path?: undefined): StoreSnapshot<State> | null;
+export declare function getStore<Name extends StoreName, P extends Path<StateFor<Name>>>(name: Name, path: P): StoreSnapshot<PathValue<StateFor<Name>, P>> | null;
+export declare function getStore<Name extends StoreName>(name: Name, path?: undefined): StoreSnapshot<StateFor<Name>> | null;
+export declare const hasStore: (name: string) => boolean;
+export { hasStoreEntryInternal as _hasStoreEntryInternal, getStoreValueRef as _getStoreValueRef, getFeatureApi as _getFeatureApi };
+export declare const getInitialState: () => Record<string, StoreValue>;
+export declare const getMetrics: (name: string) => (typeof meta)[string]["metrics"] | null;

package/dist/types/store-registry.d.ts

@@ -0,0 +1,74 @@
+/**
+ * @module store-registry
+ *
+ * LAYER: Dumb Data Container
+ * OWNS:  The shape of a StoreRegistry, the global map of all scoped registries,
+ *        and the SSR carrier-context injection point.
+ *
+ * DOES NOT KNOW about: validation, features, hooks, React, or any write logic.
+ * It is a plain key-value store factory — nothing more.
+ *
+ * Consumers: store-lifecycle (binds a registry scope on startup / SSR switch).
+ */
+import type { FeatureName, StoreFeatureMeta, StoreFeatureRuntime } from "./feature-registry.js";
+import type { AsyncRegistry } from "./async-registry.js";
+export type RegistryStoreValue = unknown;
+export type RegistrySubscriber = (value: RegistryStoreValue | null) => void;
+export type RegistrySnapshotEntry = {
+    version: number;
+    snapshot: RegistryStoreValue | null;
+};
+export type TransactionState = {
+    depth: number;
+    pending: Array<() => void>;
+    stagedValues: Map<string, RegistryStoreValue>;
+    failed: boolean;
+    error?: Error;
+};
+export type ComputedEntry = {
+    deps: string[];
+    compute: (...args: unknown[]) => unknown;
+    stale: boolean;
+};
+export type StoreRegistry = {
+    stores: Record<string, RegistryStoreValue>;
+    subscribers: Record<string, Set<RegistrySubscriber>>;
+    initialStates: Record<string, RegistryStoreValue>;
+    initialFactories: Record<string, (() => RegistryStoreValue) | undefined>;
+    metaEntries: Record<string, StoreFeatureMeta>;
+    snapshotCache: Record<string, RegistrySnapshotEntry>;
+    featureRuntimes: Map<FeatureName, StoreFeatureRuntime>;
+    deletingStores: Set<string>;
+    computedEntries: Record<string, ComputedEntry>;
+    computedDependents: Record<string, Set<string>>;
+    computedCleanups: Map<string, () => void>;
+    transaction: TransactionState;
+    async: AsyncRegistry;
+};
+export declare const normalizeStoreRegistryScope: (scope: string) => string;
+export declare const defaultRegistryScope: string;
+export declare const getDefaultStoreRegistry: () => StoreRegistry;
+export declare const setRegistryScope: (scope: string) => void;
+export declare const clearRegistryScopeOverrideForTests: () => void;
+export declare const createStoreRegistry: () => StoreRegistry;
+export declare const getStoreRegistry: (scope: string) => StoreRegistry;
+export declare const hasStoreEntry: (registry: StoreRegistry, name: string) => boolean;
+export declare const isStoreDeleting: (registry: StoreRegistry, name: string) => boolean;
+export declare const clearStoreRegistries: (registry: StoreRegistry) => void;
+export declare const resetAllStoreRegistriesForTests: () => void;
+export type CarrierContext = Record<string, unknown>;
+export interface CarrierRunner {
+    run<T>(carrier: CarrierContext, fn: () => T): T;
+    get(): CarrierContext | null;
+}
+export declare const injectCarrierRunner: (runner: CarrierRunner) => void;
+export declare const getRequestCarrier: () => CarrierContext | null;
+export interface RegistryRunner {
+    run<T>(registry: StoreRegistry, fn: () => T): T;
+    get(): StoreRegistry | null;
+    enterWith?: (registry: StoreRegistry) => void;
+}
+export declare const injectRegistryRunner: (runner: RegistryRunner) => void;
+export declare const runWithRegistry: <T>(registry: StoreRegistry, fn: () => T) => T;
+export declare const getActiveStoreRegistry: (fallback?: StoreRegistry) => StoreRegistry;
+export declare const enterRegistry: (registry: StoreRegistry) => void;