stroid 0.1.3 → 0.1.4

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

@@ -0,0 +1,53 @@
+/**
+ * @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;
+} | {
+    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, 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/core/store-notify.d.ts

@@ -0,0 +1,13 @@
+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);
+/** @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;
+export declare const getStoreSnapshotNoTrack: (name: string) => StoreValue | null;
+/** @deprecated Use getStoreSnapshot instead. */
+export declare const getSnapshot: (name: string) => StoreValue | null;
+export declare const resetNotifyStateForTests: () => void;

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

@@ -0,0 +1,18 @@
+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;
+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 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) => FeatureMetrics | null;

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

@@ -0,0 +1,115 @@
+/**
+ * @module store-registry
+ *
+ * LAYER: Store runtime
+ * OWNS:  Module-level behavior and exports for store-registry.
+ *
+ * Consumers: Internal imports and public API.
+ */
+import { type FeatureName, type StoreFeatureMeta, type StoreFeatureRuntime } from "../features/feature-registry.js";
+import type { RuntimePatch } from "./runtime-patch.js";
+import type { AsyncRegistry } from "../async/registry.js";
+import type { ComputedClassification } from "../computed/types.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>;
+    runtimePatches: RuntimePatch[];
+    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;
+    classification: ComputedClassification;
+    hasLastOutput: boolean;
+    lastOutput: unknown;
+};
+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>;
+    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>;
+    lastRuntimePatches: RuntimePatch[];
+    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 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 {
+    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;
+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/core/store-transaction.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @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 { RuntimePatch } from "./runtime-patch.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;
+export declare const registerTransactionCommit: (fn: () => void) => void;
+export declare const stageTransactionValue: (name: string, value: StoreValue) => void;
+export declare const stageTransactionPatches: (patches: readonly RuntimePatch[]) => void;
+export declare const getStagedTransactionValue: (name: string) => {
+    has: boolean;
+    value: StoreValue | undefined;
+};
+export declare const endTransaction: (err?: unknown, registry?: StoreRegistry) => Error | null;

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

@@ -0,0 +1,25 @@
+import { type WriteContext } from "../internals/write-context.js";
+import type { StoreRegistry } from "./store-registry.js";
+import type { StoreValue } from "./store-lifecycle/types.js";
+import { type RuntimePatch } from "./runtime-patch.js";
+export type CommitAction = "set" | "reset" | "hydrate" | "replace";
+export type CommitHookLabel = "onSet" | "onReset";
+export type CommitMetricsUpdate = {
+    resetElapsedMs?: number;
+};
+export type CommitArgs = {
+    name: string;
+    prev: StoreValue;
+    next: StoreValue;
+    action: CommitAction;
+    hookLabel: CommitHookLabel;
+    logMessage: string;
+    context?: WriteContext | null;
+    runtimePatches?: readonly RuntimePatch[];
+    metricsUpdate?: CommitMetricsUpdate;
+};
+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

@@ -0,0 +1,40 @@
+/**
+ * @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;
+export declare const runMiddleware: ({ name, payload, middlewares, reportIssue, warn, }: {
+    name: string;
+    payload: {
+        action: string;
+        prev: StoreValue;
+        next: StoreValue;
+        path: unknown;
+        correlationId?: string;
+        traceContext?: import("../types/utility.js").TraceContext;
+    };
+    middlewares: Array<(ctx: {
+        action: string;
+        name: string;
+        prev: StoreValue;
+        next: StoreValue;
+        path: unknown;
+        correlationId?: string;
+        traceContext?: import("../types/utility.js").TraceContext;
+    }) => 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,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 { 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, 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

@@ -0,0 +1,8 @@
+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>;
+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/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

@@ -0,0 +1,116 @@
+/**
+ * @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;
+    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;
+    /**
+     * 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 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) | "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;
+    flush: Required<FlushConfig>;
+    revalidateOnFocus: Required<RevalidateOnFocusConfig>;
+    namespace: string;
+    strictMissingFeatures: boolean;
+    assertRuntime: boolean;
+    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;
+export declare const getNamespace: () => string;
+export declare const setNamespace: (ns: string) => void;
+export {};