stroid 0.1.0 → 0.1.2

package/dist/types/{store-lifecycle → core/store-lifecycle}/validation.d.ts

@@ -1,5 +1,13 @@
-import { type SupportedType, PathInput } from "../utils.js";
-import { type ValidateOption } from "../adapters/options.js";
+/**
+ * @module store-lifecycle/validation
+ *
+ * LAYER: Store lifecycle
+ * OWNS:  Module-level behavior and exports for store-lifecycle/validation.
+ *
+ * Consumers: Internal imports and public API.
+ */
+import { type SupportedType, PathInput } from "../../utils.js";
+import { type ValidateOption } from "../../adapters/options.js";
 import type { StoreValue } from "./types.js";
 type PathSafetyVerdict = {
     ok: true;
@@ -41,5 +49,5 @@ export declare const normalizeCommittedState: (name: string, value: unknown, val
 };
 export declare const invalidatePathCache: (name: string) => void;
 export declare const clearPathValidationCache: () => void;
-export declare const materializeInitial: (name: string) => boolean;
+export declare const materializeInitial: (name: string, registry?: import("../store-registry.js").StoreRegistry) => boolean;
 export {};

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

@@ -0,0 +1,28 @@
+/**
+ * @module store-name
+ *
+ * LAYER: Store runtime
+ * OWNS:  Module-level behavior and exports for store-name.
+ *
+ * Consumers: Internal imports and public API.
+ */
+import type { StoreKey, StoreValue } from "./store-lifecycle/types.js";
+import type { StoreOptions } from "../adapters/options.js";
+import type { NonFunction } from "../types/utility.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: NonFunction<State>, options?: StoreOptions<State>) => import("./store-lifecycle/types.js").StoreDefinition<string, State> | undefined;
+    createStrict: <Name extends string, State>(name: Name, data: NonFunction<State>, options?: StoreOptions<State>) => import("./store-lifecycle/types.js").StoreDefinition<string, State>;
+    set: (name: any, ...rest: any[]) => any;
+    get: (name: any, ...rest: any[]) => any;
+    delete: (name: string) => void;
+    reset: (name: string) => import("./store-lifecycle/types.js").WriteResult;
+};

package/dist/types/{store-notify.d.ts → core/store-notify.d.ts}

@@ -1,4 +1,4 @@
-import { type StoreValue, type Subscriber } from "./store-lifecycle.js";
+import type { StoreValue, Subscriber } from "./store-lifecycle/types.js";
 export declare const notify: (name: string) => void;
 export declare const setStoreBatch: (fn: () => unknown) => void;
 export declare const subscribeStore: (name: string, fn: Subscriber) => (() => void);

package/dist/types/{store-read.d.ts → core/store-read.d.ts}

@@ -1,4 +1,7 @@
-import { meta, hasStoreEntryInternal, getStoreValueRef, getFeatureApi, type Path, type PathValue, type StoreDefinition, type StoreValue, type StoreKey, type StoreName, type StateFor } from "./store-lifecycle.js";
+import { hasStoreEntryInternal, getStoreValueRef } from "./store-lifecycle/registry.js";
+import { getFeatureApi } from "./store-lifecycle/identity.js";
+import type { Path, PathValue, StoreDefinition, StoreValue, StoreKey, StoreName, StateFor } from "./store-lifecycle/types.js";
+import type { FeatureMetrics } from "../features/feature-registry.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;
@@ -7,6 +10,9 @@ export declare function getStore<Name extends string, State>(name: StoreKey<Name
 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 declare const isLazyStore: (name: string) => boolean;
+export declare const isStoreMaterialized: (name: string) => boolean;
+export declare const isLazyPending: (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;
+export declare const getMetrics: (name: string) => FeatureMetrics | null;

package/dist/types/{store-registry.d.ts → core/store-registry.d.ts}

@@ -1,36 +1,63 @@
 /**
  * @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.
+ * LAYER: Store runtime
+ * OWNS:  Module-level behavior and exports for store-registry.
  *
- * 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).
+ * Consumers: Internal imports and public API.
  */
-import type { FeatureName, StoreFeatureMeta, StoreFeatureRuntime } from "./feature-registry.js";
-import type { AsyncRegistry } from "./async-registry.js";
+import { type FeatureName, type StoreFeatureMeta, type StoreFeatureRuntime } from "../features/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;
+    source?: RegistryStoreValue | null;
+    mode?: "deep" | "shallow" | "ref";
+};
+export type StoreLifecycleEvent = {
+    type: "created";
+    name: string;
+    isGlobal: boolean;
+    isTemp: boolean;
+} | {
+    type: "deleted";
+    name: string;
 };
+export type StoreLifecycleListener = (event: StoreLifecycleEvent) => void;
 export type TransactionState = {
     depth: number;
     pending: Array<() => void>;
     stagedValues: Map<string, RegistryStoreValue>;
+    snapshotCache: Map<string, TransactionSnapshotEntry>;
     failed: boolean;
     error?: Error;
 };
+type TransactionSnapshotMode = "deep" | "shallow" | "ref";
+type TransactionSnapshotEntry = {
+    source: RegistryStoreValue | null | undefined;
+    snapshot: RegistryStoreValue | null;
+    mode: TransactionSnapshotMode;
+};
 export type ComputedEntry = {
     deps: string[];
     compute: (...args: unknown[]) => unknown;
     stale: boolean;
 };
+export type NotifyState = {
+    pendingNotifications: Set<string>;
+    pendingBuffer: string[];
+    orderedNames: string[];
+    subscriberBuffer: RegistrySubscriber[];
+    notifyScheduled: boolean;
+    batchDepth: number;
+    flushId: number;
+    isFlushing: boolean;
+};
+export type RegistryScope = "default" | "request";
 export type StoreRegistry = {
+    scope: RegistryScope;
     stores: Record<string, RegistryStoreValue>;
     subscribers: Record<string, Set<RegistrySubscriber>>;
     initialStates: Record<string, RegistryStoreValue>;
@@ -44,17 +71,23 @@ export type StoreRegistry = {
     computedCleanups: Map<string, () => void>;
     transaction: TransactionState;
     async: AsyncRegistry;
+    notify: NotifyState;
+    lifecycleListener: StoreLifecycleListener | null;
 };
+export declare const initializeRegistryFeatureRuntimes: (registry: StoreRegistry) => void;
 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 createTransactionState: () => TransactionState;
+export declare const createStoreRegistry: (scope?: RegistryScope) => 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 setLifecycleListener: (registry: StoreRegistry, listener: StoreLifecycleListener | null) => void;
+export declare const emitLifecycleEvent: (registry: StoreRegistry, event: StoreLifecycleEvent) => void;
 export declare const resetAllStoreRegistriesForTests: () => void;
 export type CarrierContext = Record<string, unknown>;
 export interface CarrierRunner {
@@ -72,3 +105,4 @@ 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;
+export {};

package/dist/types/core/store-replace-impl.d.ts

@@ -0,0 +1,11 @@
+import type { StoreDefinition, StoreKey, StoreName, StateFor, WriteResult } from "./store-lifecycle/types.js";
+import type { StoreRegistry } from "./store-registry.js";
+import type { WriteContext } from "../internals/write-context.js";
+import { type CommitAction } from "./store-write-shared.js";
+export declare function replaceStore<Name extends string, State>(name: StoreDefinition<Name, State>, value: State): WriteResult;
+export declare function replaceStore<Name extends string, State>(name: StoreKey<Name, State>, value: State): WriteResult;
+export declare function replaceStore<Name extends StoreName>(name: Name, value: StateFor<Name>): WriteResult;
+export declare const replaceStoreState: (registry: StoreRegistry, name: string, data: unknown, action?: CommitAction, context?: WriteContext | null) => {
+    ok: boolean;
+    reason?: string;
+};

package/dist/types/core/store-replace.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @module store-replace
+ *
+ * LAYER: Store runtime
+ * OWNS:  Public replaceStore exports.
+ *
+ * Consumers: store-write barrel.
+ */
+export { replaceStore } from "./store-replace-impl.js";

package/dist/types/core/store-set-impl.d.ts

@@ -0,0 +1,13 @@
+import type { PartialDeep, Path, PathValue, StoreDefinition, StoreValue, StoreKey, StoreName, StateFor, WriteResult } from "./store-lifecycle/types.js";
+import type { WriteContext } from "../internals/write-context.js";
+type KeyOrData = StoreValue | string | string[] | Record<string, unknown> | ((draft: any) => void);
+type IsStoreNameLoose = string extends StoreName ? true : false;
+type StoreUpdate<State> = State | Partial<State> | PartialDeep<State> | ((draft: State) => void);
+type StoreTarget<Name extends string = string, State = StoreValue> = StoreDefinition<Name, State> | StoreKey<Name, State> | StoreName;
+type StorePathForTarget<T> = T extends StoreDefinition<any, infer S> ? Path<S> : T extends StoreKey<any, infer S> ? Path<S> : (IsStoreNameLoose extends true ? string | string[] : (T extends StoreName ? Path<StateFor<T>> : string | string[]));
+type StorePathValueForTarget<T, P> = T extends StoreDefinition<any, infer S> ? (P extends Path<S> ? PathValue<S, P> : never) : T extends StoreKey<any, infer S> ? (P extends Path<S> ? PathValue<S, P> : never) : (IsStoreNameLoose extends true ? unknown : (T extends StoreName ? (P extends Path<StateFor<T>> ? PathValue<StateFor<T>, P> : never) : unknown));
+type StoreUpdateForTarget<T> = T extends StoreDefinition<any, infer S> ? StoreUpdate<S> : T extends StoreKey<any, infer S> ? StoreUpdate<S> : (IsStoreNameLoose extends true ? StoreUpdate<StoreValue> : (T extends StoreName ? StoreUpdate<StateFor<T>> : StoreUpdate<StoreValue>));
+export declare function setStore<T extends StoreTarget, P extends StorePathForTarget<T>>(name: T, path: P, value: StorePathValueForTarget<T, P>): WriteResult;
+export declare function setStore<T extends StoreTarget>(name: T, update: StoreUpdateForTarget<T>): WriteResult;
+export declare const setStoreWithContext: (name: string | StoreDefinition<string, StoreValue>, keyOrData: KeyOrData, value: unknown, context: WriteContext | null) => WriteResult;
+export {};

package/dist/types/core/store-set.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @module store-set
+ *
+ * LAYER: Store runtime
+ * OWNS:  Public setStore exports.
+ *
+ * Consumers: store-write barrel.
+ */
+export { setStore, setStoreWithContext } from "./store-set-impl.js";

package/dist/types/core/store-shared/core.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @module store-shared/core
+ *
+ * LAYER: Shared types
+ * OWNS:  Minimal interfaces shared across layers.
+ *
+ * Consumers: Internal modules (async-cache, adapters).
+ */
+export interface IStoreCore<T = any> {
+    get(path?: string): T | null;
+    set(path: string, value: any): void;
+    subscribe(cb: (val: T | null) => void): () => void;
+}

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

@@ -0,0 +1,12 @@
+/**
+ * @module store-shared/notify
+ *
+ * LAYER: Shared types
+ * OWNS:  Notification handler indirection for layer decoupling.
+ *
+ * Consumers: store-write, store-create, store-notify.
+ */
+type NotifyHandler = (name: string) => void;
+export declare const registerNotifyHandler: (handler: NotifyHandler | null) => (() => void);
+export declare const notifyStore: (name: string) => void;
+export {};

package/dist/types/{store-transaction.d.ts → core/store-transaction.d.ts}

@@ -1,5 +1,19 @@
+/**
+ * @module store-transaction
+ *
+ * LAYER: Store runtime
+ * OWNS:  Module-level behavior and exports for store-transaction.
+ *
+ * Consumers: Internal imports and public API.
+ */
 import type { StoreValue } from "./store-lifecycle/types.js";
-import { type StoreRegistry } from "./store-registry.js";
+import { type StoreRegistry, type TransactionState } from "./store-registry.js";
+export type TransactionRunner = {
+    run: <T>(state: TransactionState, fn: () => T) => T;
+    get: () => TransactionState | null;
+    enterWith?: (state: TransactionState) => void;
+};
+export declare const injectTransactionRunner: (runner: TransactionRunner | null) => void;
 export declare const beginTransaction: (registry?: StoreRegistry) => StoreRegistry;
 export declare const isTransactionActive: () => boolean;
 export declare const markTransactionFailed: (err?: unknown, registry?: StoreRegistry) => void;

package/dist/types/core/store-write-shared.d.ts

@@ -0,0 +1,19 @@
+import { type WriteContext } from "../internals/write-context.js";
+import type { StoreRegistry } from "./store-registry.js";
+import type { StoreValue } from "./store-lifecycle/types.js";
+export type CommitAction = "set" | "reset" | "hydrate" | "replace";
+export type CommitHookLabel = "onSet" | "onReset";
+export type CommitArgs = {
+    name: string;
+    prev: StoreValue;
+    next: StoreValue;
+    action: CommitAction;
+    hookLabel: CommitHookLabel;
+    logMessage: string;
+    context?: WriteContext | null;
+};
+export declare const clearSlowMutatorWarnings: () => void;
+export declare const forgetSlowMutatorWarning: (storeName: string) => void;
+export declare const maybeWarnSlowMutator: (storeName: string, elapsedMs: number) => void;
+export declare const resolveWriteContext: (context?: WriteContext | null) => WriteContext | null;
+export declare const stageOrCommitUpdate: (registry: StoreRegistry, args: CommitArgs) => void;

package/dist/types/core/store-write.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @module store-write
+ *
+ * LAYER: Store runtime
+ * OWNS:  Public write API surface (barrel).
+ *
+ * Consumers: Internal imports and public API.
+ */
+import "./store-notify.js";
+export { setStore, setStoreWithContext } from "./store-set.js";
+export { replaceStore } from "./store-replace.js";
+export { hydrateStores } from "./store-hydrate.js";
+export { deleteStore, resetStore, clearAllStores, _hardResetAllStoresForTest, } from "./store-admin.js";

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

@@ -0,0 +1,91 @@
+/**
+ * @module feature-registry
+ *
+ * LAYER: Module
+ * OWNS:  Module-level behavior and exports for feature-registry.
+ *
+ * Consumers: Internal imports and public API.
+ */
+import type { NormalizedOptions, StoreValue } from "../adapters/options.js";
+import type { TraceContext } from "../types/utility.js";
+export type BuiltInFeatureName = "persist" | "sync" | "devtools";
+export type FeatureName = BuiltInFeatureName | (string & {});
+export interface FeatureMetrics {
+    notifyCount: number;
+    totalNotifyMs: number;
+    lastNotifyMs: number;
+    resetCount: number;
+    totalResetMs: number;
+    lastResetMs: number;
+}
+export interface StoreFeatureMeta {
+    createdAt: string;
+    updatedAt: string;
+    updatedAtMs: number;
+    updateCount: number;
+    version: number;
+    metrics: FeatureMetrics;
+    options: NormalizedOptions;
+    readCount: number;
+    lastReadAt: string | null;
+    lastReadAtMs: number | null;
+    lastCorrelationId: string | null;
+    lastCorrelationAt: string | null;
+    lastCorrelationAtMs: number | null;
+    lastTraceContext: TraceContext | null;
+}
+export interface FeatureHookContext {
+    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;
+    warnAlways: (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;
+}
+/** @deprecated Use FeatureHookContext instead. */
+export type BaseFeatureContext = FeatureHookContext;
+export type FeatureCreateContext<Ext extends object = {}> = FeatureHookContext & Ext;
+export type FeatureWriteContext<Ext extends object = {}> = FeatureHookContext & Ext & {
+    action: string;
+    prev: StoreValue;
+    next: StoreValue;
+};
+export type FeatureDeleteContext<Ext extends object = {}> = FeatureHookContext & Ext & {
+    prev: StoreValue;
+};
+export interface DevtoolsFeatureApi {
+    getHistory?: (name: string, limit?: number) => unknown[];
+    clearHistory?: (name?: string) => void;
+    getPersistQueueDepth?: (name: string) => number;
+}
+export interface StoreFeatureRuntime<Ext extends object = {}> {
+    onStoreCreate?: (ctx: FeatureCreateContext<Ext>) => void;
+    onStoreWrite?: (ctx: FeatureWriteContext<Ext>) => void;
+    beforeStoreDelete?: (ctx: FeatureDeleteContext<Ext>) => void;
+    afterStoreDelete?: (ctx: FeatureDeleteContext<Ext>) => void;
+    resetAll?: () => void;
+    api?: DevtoolsFeatureApi;
+}
+export type StoreFeatureFactory<Ext extends object = {}> = () => StoreFeatureRuntime<Ext>;
+export declare const registerStoreFeature: <Ext extends object = {}>(name: FeatureName, factory: StoreFeatureFactory<Ext>) => void;
+export declare const hasRegisteredStoreFeature: (name: FeatureName) => boolean;
+export declare const getStoreFeatureFactory: (name: FeatureName) => StoreFeatureFactory<any> | undefined;
+export declare const getRegisteredFeatureNames: () => FeatureName[];
+export declare const setFeatureRegistrationHook: (hook: ((name: FeatureName, factory: StoreFeatureFactory<any>) => void) | null) => void;
+export declare const resetRegisteredStoreFeaturesForTests: () => void;

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

@@ -1,3 +1,11 @@
+/**
+ * @module features/lifecycle
+ *
+ * LAYER: Feature runtime
+ * OWNS:  Module-level behavior and exports for features/lifecycle.
+ *
+ * Consumers: Internal imports and public API.
+ */
 import type { StoreValue } from "../adapters/options.js";
 export declare const MIDDLEWARE_ABORT: unique symbol;
 export type LifecycleIssueReporter = (message: string, visibility?: "dev" | "always") => void;
@@ -8,6 +16,8 @@ export declare const runMiddleware: ({ name, payload, middlewares, reportIssue,
         prev: StoreValue;
         next: StoreValue;
         path: unknown;
+        correlationId?: string;
+        traceContext?: import("../types/utility.js").TraceContext;
     };
     middlewares: Array<(ctx: {
         action: string;
@@ -15,6 +25,8 @@ export declare const runMiddleware: ({ name, payload, middlewares, reportIssue,
         prev: StoreValue;
         next: StoreValue;
         path: unknown;
+        correlationId?: string;
+        traceContext?: import("../types/utility.js").TraceContext;
     }) => StoreValue | void>;
     reportIssue: LifecycleIssueReporter;
     warn: (message: string) => void;

package/dist/types/index.d.ts

@@ -1,6 +1,17 @@
+/**
+ * @module index
+ *
+ * LAYER: Public API
+ * OWNS:  Module-level behavior and exports for index.
+ *
+ * Consumers: Internal imports and public API.
+ */
 export { createStore, createStoreStrict, setStore, setStoreBatch, getStore, deleteStore, resetStore, hasStore, hydrateStores, } from "./store.js";
-export { createComputed, invalidateComputed, deleteComputed, isComputedStore, } from "./computed.js";
+export { getMetrics } from "./core/store-read.js";
+export { getAsyncMetrics } from "./async/fetch.js";
+export { getStoreHealth, findColdStores } from "./runtime-tools/index.js";
+export { createComputed, invalidateComputed, deleteComputed, isComputedStore, } from "./computed/index.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 type { Path, PathValue, PartialDeep, HydrateSnapshotFor, HydrationFailure, HydrationResult, StoreDefinition, StoreValue, StoreKey, StoreName, StateFor, StoreStateMap, StrictStoreMap, WriteResult, FeatureOptions, FeatureOptionsMap, 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

@@ -1,5 +1,5 @@
-import type { FetchInput, FetchOptions } from "../async-cache.js";
-import type { StoreDefinition, StoreKey, StoreName } from "../store-lifecycle.js";
+import type { FetchInput, FetchOptions } from "../async/cache.js";
+import type { StoreDefinition, StoreKey, StoreName } from "../core/store-lifecycle/types.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>;

package/dist/types/internals/computed-order.d.ts

@@ -0,0 +1,3 @@
+export type ComputedOrderResolver = (names: string[]) => string[];
+export declare const setComputedOrderResolver: (next: ComputedOrderResolver | null) => void;
+export declare const getComputedOrder: (names: string[]) => string[];

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

@@ -1,3 +1,11 @@
+/**
+ * @module internals/config
+ *
+ * LAYER: Internal subsystem
+ * OWNS:  Module-level behavior and exports for internals/config.
+ *
+ * Consumers: Internal imports and public API.
+ */
 import type { SnapshotMode, MiddlewareCtx, StoreValue } from "../adapters/options.js";
 export type LogSink = {
     log?: (msg: string, meta?: Record<string, unknown>) => void;
@@ -26,17 +34,55 @@ export type StroidConfig = {
     strictMutatorReturns?: boolean;
     asyncAutoCreate?: boolean;
     asyncCloneResult?: AsyncCloneMode;
+    /**
+     * Automatically generate correlation IDs for async fetch writes.
+     * Default: false.
+     */
+    autoCorrelationIds?: boolean;
+    /**
+     * Acknowledge loose store name typing and suppress dev warnings.
+     * Useful when you intentionally skip StoreStateMap augmentation.
+     */
+    acknowledgeLooseTypes?: boolean;
+    /**
+     * Max number of cached path validation verdicts per store.
+     * Default: 500.
+     */
+    pathCacheSize?: number;
     defaultSnapshotMode?: SnapshotMode;
+    /**
+     * Alias for defaultSnapshotMode.
+     */
+    snapshotStrategy?: SnapshotMode;
+    /**
+     * Throw on async usage errors instead of returning null.
+     * Default: false (usage errors return null and call onError).
+     */
+    strictAsyncUsageErrors?: boolean;
     middleware?: Array<(ctx: MiddlewareCtx) => StoreValue | void>;
     /**
-     * Allow hydrateStores to accept untrusted snapshots without explicit opt-in.
+     * Allow hydrateStores to accept trusted snapshots without explicit opt-in.
      * Default: false (hydration requires an explicit trust opt-in).
      */
+    allowTrustedHydration?: boolean;
+    /**
+     * @deprecated Use allowTrustedHydration instead.
+     */
     allowUntrustedHydration?: boolean;
+    /**
+     * Alias for allowTrustedHydration.
+     */
+    allowHydration?: boolean;
     /**
      * Optional custom mutator engine (e.g. Immer's produce) to enable structural sharing.
+     * You can pass the produce function directly or use "immer" after calling registerMutatorProduce().
      */
-    mutatorProduce?: <T>(base: T, recipe: (draft: T) => void) => T;
+    mutatorProduce?: (<T>(base: T, recipe: (draft: T) => void) => T) | "immer";
+    /**
+     * When true, createSelector clones frozen state before proxy tracking.
+     * Default: true (safer for mutation-prone selectors in dev).
+     */
+    selectorCloneFrozen?: boolean;
 };
 type ResolvedConfig = {
     logSink: LogSink;
@@ -48,12 +94,20 @@ type ResolvedConfig = {
     strictMutatorReturns: boolean;
     asyncAutoCreate: boolean;
     asyncCloneResult: AsyncCloneMode;
+    autoCorrelationIds: boolean;
+    acknowledgeLooseTypes: boolean;
+    pathCacheSize: number;
     defaultSnapshotMode: SnapshotMode;
+    strictAsyncUsageErrors: boolean;
     middleware: Array<(ctx: MiddlewareCtx) => StoreValue | void>;
     allowUntrustedHydration: boolean;
     mutatorProduce?: <T>(base: T, recipe: (draft: T) => void) => T;
+    selectorCloneFrozen: boolean;
 };
 export declare const getConfig: () => ResolvedConfig;
+export declare const registerMutatorProduce: (produce: (<T>(base: T, recipe: (draft: T) => void) => T), options?: {
+    force?: boolean;
+}) => void;
 export declare const configureStroid: (next?: StroidConfig) => void;
 export declare const resetConfig: () => void;
 export declare const _resetConfigForTests: () => void;

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

@@ -5,4 +5,5 @@ export type IssueOptions = {
     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

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

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

@@ -1,3 +1,13 @@
-export { createStore, replaceStore } from "../store-write.js";
-export { getStore, hasStore } from "../store-read.js";
-export { subscribeStore } from "../store-notify.js";
+/**
+ * @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,15 @@
+/**
+ * @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 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;