stroid 0.0.4 → 0.1.1

package/dist/_tsup-dts-rollup.d.cts

@@ -0,0 +1,2411 @@
+declare const __DEV__: boolean;
+export { __DEV__ }
+export { __DEV__ as __DEV___alias_1 }
+
+export declare const absorbSyncClock: (name: string, incomingClock: number, syncClocks: SyncClocks) => number;
+
+declare const applyFeatureState: (name: string, value: StoreValue, updatedAtMs?: number) => void;
+export { applyFeatureState }
+export { applyFeatureState as applyFeatureState_alias_1 }
+
+export declare const applyRedactor: ({ data, redactor, deepClone, }: {
+    data: StoreValue_alias_4;
+    redactor?: (state: StoreValue_alias_4) => StoreValue_alias_4;
+    deepClone: <T>(value: T) => T;
+}) => StoreValue_alias_4;
+
+export declare type AsyncCloneMode = "none" | "shallow" | "deep";
+
+export declare type AsyncDataFor<State> = State extends {
+    data: infer T;
+} ? T : unknown;
+
+export declare const asyncMetrics: {
+    cacheHits: number;
+    cacheMisses: number;
+    dedupes: number;
+    requests: number;
+    failures: number;
+    avgMs: number;
+    lastMs: number;
+};
+
+export declare type AsyncRegistry = {
+    fetchRegistry: Record<string, {
+        kind: "url";
+        url: string;
+        options: FetchOptions;
+    } | {
+        kind: "factory";
+        factory: () => string | Promise<unknown>;
+        options: FetchOptions;
+    }>;
+    inflight: Partial<Record<string, InflightEntry_2>>;
+    requestVersion: Record<string, number>;
+    cacheMeta: Record<string, {
+        timestamp: number;
+        expiresAt: number | null;
+        data: unknown;
+    }>;
+    rateWindowStart: Record<string, number>;
+    rateCount: Record<string, number>;
+    ratePruneState: {
+        lastAt: number;
+    };
+    ratePruneTimer: ReturnType<typeof setTimeout> | null;
+    noSignalWarned: Set<string>;
+    shapeWarned: Set<string>;
+    autoCreateWarned: Set<string>;
+    mutableResultWarned: Set<string>;
+    cleanupSubs: Record<string, () => void>;
+    storeCleanupFns: Record<string, Set<() => void>>;
+    revalidateKeys: Set<string>;
+    revalidateHandlers: Record<string, () => void>;
+    asyncMetrics: {
+        cacheHits: number;
+        cacheMisses: number;
+        dedupes: number;
+        requests: number;
+        failures: number;
+        avgMs: number;
+        lastMs: number;
+    };
+};
+
+declare type AsyncStateAdapter = (ctx: {
+    name: string;
+    prev: unknown;
+    next: AsyncStateSnapshot;
+    set: (value: unknown | ((draft: any) => void)) => void;
+}) => void;
+export { AsyncStateAdapter }
+export { AsyncStateAdapter as AsyncStateAdapter_alias_1 }
+export { AsyncStateAdapter as AsyncStateAdapter_alias_2 }
+
+/**
+ * @module async-registry
+ *
+ * LAYER: Module
+ * OWNS:  Module-level behavior and exports for async-registry.
+ *
+ * Consumers: Internal imports and public API.
+ */
+declare type AsyncStateSnapshot = {
+    data?: unknown;
+    loading: boolean;
+    error: string | null;
+    status: "idle" | "loading" | "success" | "error" | "aborted";
+    cached?: boolean;
+    revalidating?: boolean;
+};
+export { AsyncStateSnapshot }
+export { AsyncStateSnapshot as AsyncStateSnapshot_alias_1 }
+export { AsyncStateSnapshot as AsyncStateSnapshot_alias_2 }
+
+export declare type AsyncStoreSnapshot<T = unknown> = AsyncStoreState<T> & {
+    isEmpty: boolean;
+};
+
+export declare type AsyncStoreState<T = unknown> = {
+    data: T | null;
+    loading: boolean;
+    revalidating?: boolean;
+    error: string | null;
+    status: "idle" | "loading" | "success" | "error" | "aborted";
+};
+
+export declare const autoCreateWarned: Set<string>;
+
+declare interface BaseFeatureContext {
+    name: string;
+    options: NormalizedOptions;
+    getMeta: () => StoreFeatureMeta | undefined;
+    getStoreValue: () => StoreValue_alias_4;
+    getAllStores: () => Record<string, StoreValue_alias_4>;
+    getInitialState: () => StoreValue_alias_4;
+    hasStore: () => boolean;
+    setStoreValue: (value: StoreValue_alias_4) => void;
+    applyFeatureState: (value: StoreValue_alias_4, 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_alias_4) => {
+        ok: boolean;
+        value?: StoreValue_alias_4;
+    };
+    isDev: () => boolean;
+}
+export { BaseFeatureContext }
+export { BaseFeatureContext as BaseFeatureContext_alias_1 }
+
+declare type BaseFeatureContext_2 = {
+    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 beginTransaction: (registry?: StoreRegistry) => StoreRegistry;
+
+export declare const benchmarkStoreSet: <Name extends string, State extends Record<string, unknown>>(name: StoreDefinition<Name, State> | StoreKey<Name, State>, iterations?: number, makeUpdate?: (i: number) => PartialDeep<State>) => {
+    iterations: number;
+    totalMs: number;
+    avgMs: number;
+};
+
+declare const bindRegistry: (scopeOrRegistry?: string | StoreRegistry) => void;
+export { bindRegistry }
+export { bindRegistry as bindRegistry_alias_1 }
+
+declare type BrandedStoreName = string & {
+    readonly [storeNameBrand]: true;
+};
+
+export declare const broadcastSync: ({ name, syncOption, syncChannels, syncClocks, instanceId, updatedAt, data, hashState, reportStoreError, }: {
+    name: string;
+    syncOption?: boolean | SyncOptions;
+    syncChannels: SyncChannels;
+    syncClocks: SyncClocks;
+    instanceId: string;
+    updatedAt: string | number;
+    data: StoreValue_alias_4;
+    hashState: (value: unknown) => number;
+    reportStoreError: (name: string, message: string) => void;
+}) => void;
+
+export declare const buildFetchOptions: (options: FetchOptions) => RequestInit;
+
+declare type BuiltInFeatureName = "persist" | "sync" | "devtools";
+export { BuiltInFeatureName }
+export { BuiltInFeatureName as BuiltInFeatureName_alias_1 }
+
+export declare const bumpSyncClock: (name: string, syncClocks: SyncClocks) => number;
+
+declare const canReuseSanitized: (value: unknown) => boolean;
+export { canReuseSanitized }
+export { canReuseSanitized as canReuseSanitized_alias_1 }
+
+export declare type CarrierContext = Record<string, unknown>;
+
+export declare interface CarrierRunner {
+    run<T>(carrier: CarrierContext, fn: () => T): T;
+    get(): CarrierContext | null;
+}
+
+declare const checksumState: (value: unknown) => number;
+export { checksumState }
+export { checksumState as checksumState_alias_1 }
+
+export declare const cleanupAllRevalidateHandlers: () => void;
+
+export declare const cleanupAllSyncResources: ({ syncChannels, syncWindowCleanup, }: {
+    syncChannels: SyncChannels;
+    syncWindowCleanup: SyncWindowCleanup;
+}) => void;
+
+export declare const cleanupSubs: Record<string, () => void>;
+
+declare const clearAllRegistries: () => void;
+export { clearAllRegistries }
+export { clearAllRegistries as clearAllRegistries_alias_1 }
+
+declare const clearAllStores: () => void;
+export { clearAllStores }
+export { clearAllStores as clearAllStores_alias_2 }
+
+export declare const clearAllStores_alias_1: () => void;
+
+export declare const clearAsyncMeta: (name: string) => void;
+
+declare const clearFeatureContexts: () => void;
+export { clearFeatureContexts }
+export { clearFeatureContexts as clearFeatureContexts_alias_1 }
+
+declare const clearHistory: (name?: string) => void;
+export { clearHistory }
+export { clearHistory as clearHistory_alias_1 }
+
+export declare const clearInflightEntry: (cacheSlot: string) => void;
+
+declare const clearPathValidationCache: () => void;
+export { clearPathValidationCache }
+export { clearPathValidationCache as clearPathValidationCache_alias_1 }
+
+export declare const clearRegistryScopeOverrideForTests: () => void;
+
+export declare const clearRequestVersion: (cacheSlot: string, version: number) => void;
+
+export declare const clearStoreRegistries: (registry: StoreRegistry) => void;
+
+declare const clearStores: (pattern?: string) => void;
+export { clearStores }
+export { clearStores as clearStores_alias_1 }
+
+export declare const cloneAsyncResult: (value: unknown, mode: FetchOptions["cloneResult"]) => unknown;
+
+export declare const closeSyncResources: ({ name, syncChannels, syncWindowCleanup, syncClocks, syncVersions, }: {
+    name: string;
+    syncChannels: SyncChannels;
+    syncWindowCleanup: SyncWindowCleanup;
+    syncClocks: SyncClocks;
+    syncVersions: SyncVersions;
+}) => void;
+
+/**
+ * Collect deprecation warnings for a store options object.
+ *
+ * This function walks through the store options object and checks if any
+ * deprecated options are present. If a deprecated option is found, a
+ * warning message is added to the warnings array.
+ *
+ * The function returns an array of warning messages. If no deprecated
+ * options are found, an empty array is returned.
+ *
+ * @template State The type of the state stored in the store.
+ * @param option The store options object to check for deprecated options.
+ * @returns An array of warning messages for deprecated options. If no deprecated
+ *          options are found, an empty array is returned.
+ */
+export declare const collectLegacyOptionDeprecationWarnings: <State>(option: StoreOptions<State>) => string[];
+
+export declare type ComputedEntry = {
+    deps: string[];
+    compute: (...args: unknown[]) => unknown;
+    stale: boolean;
+};
+
+export declare type ComputedOptions = {
+    autoDispose?: boolean;
+    onError?: (err: unknown) => void;
+};
+
+export declare type ComputedOrderResolver = (names: string[]) => string[];
+
+export declare const computePersistChecksum: (mode: "hash" | "none" | "sha256", payload: string, hashFn?: (value: unknown) => number) => Promise<number | string | null>;
+
+declare const configureStroid: (next?: StroidConfig) => void;
+export { configureStroid }
+export { configureStroid as configureStroid_alias_1 }
+export { configureStroid as configureStroid_alias_2 }
+
+export declare const countInflightSlots: (name: string) => number;
+
+declare const crc32: (str: string) => number;
+export { crc32 }
+export { crc32 as crc32_alias_1 }
+
+export declare const createAsyncRegistry: () => AsyncRegistry;
+
+declare const createBaseFeatureContext: (name: string) => BaseFeatureContext_2 | null;
+export { createBaseFeatureContext }
+export { createBaseFeatureContext as createBaseFeatureContext_alias_1 }
+
+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 { createComputed }
+export { createComputed as createComputed_alias_1 }
+export { createComputed as createComputed_alias_2 }
+
+export declare const createCounterStore: (name: string, initial?: number, options?: StoreOptions) => {
+    inc: (n?: number) => WriteResult;
+    dec: (n?: number) => WriteResult;
+    set: (v: number) => WriteResult;
+    reset: () => WriteResult;
+    get: () => number | null;
+};
+
+export declare const createDevtoolsFeatureRuntime: () => StoreFeatureRuntime;
+
+export declare const createEntityStore: <T extends {
+    id?: string;
+    _id?: string;
+}>(name: string, options?: StoreOptions) => {
+    upsert: (entity: T) => WriteResult;
+    remove: (id: string) => WriteResult;
+    all: () => T[];
+    get: (id: string) => T | null;
+    clear: () => WriteResult;
+};
+
+export declare const createListStore: <T>(name: string, initial?: T[], options?: StoreOptions) => {
+    push: (item: T) => WriteResult;
+    removeAt: (index: number) => WriteResult;
+    clear: () => WriteResult;
+    replace: (items: T[]) => WriteResult;
+    all: () => T[];
+};
+
+export declare const createMockStore: <Name extends string, State extends Record<string, unknown> = Record<string, unknown>>(name?: Name, initial?: State) => {
+    set: (update: PartialDeep<State> | ((draft: State) => void)) => WriteResult;
+    reset: () => WriteResult;
+    use: () => StoreDefinition<Name, State>;
+};
+
+export declare const createPersistFeatureRuntime: () => StoreFeatureRuntime;
+
+export declare const createReactQueryFetcher: (storeName: StoreTarget, input: FetchInput, options?: FetchOptions) => () => Promise<unknown>;
+
+declare const createSelector: <TState, TResult>(storeName: string, selectorFn: (state: TState) => TResult) => () => NonNullable<TResult> | null;
+export { createSelector }
+export { createSelector as createSelector_alias_1 }
+
+declare const createStore: <Name extends string, State>(name: Name, initialData: State, option?: StoreOptions<State>) => StoreDefinition<Name, State> | undefined;
+export { createStore }
+export { createStore as createStore_alias_1 }
+export { createStore as createStore_alias_2 }
+export { createStore as createStore_alias_3 }
+export { createStore as createStore_alias_4 }
+
+export declare const createStoreAdmin: (registry: StoreRegistry) => {
+    deleteExistingStore: (name: string) => void;
+    clearAllStores: () => string[];
+    clearStores: (pattern?: string) => string[];
+    reportStoreError: (name: string, message: string) => void;
+};
+
+export declare const createStoreForRequest: <StateMap extends StoreStateMap = StoreStateMap>(initializer?: (api: RequestStoreApi<StateMap>) => void) => RequestStoreContext<StateMap>;
+
+export declare const createStoreRegistry: () => StoreRegistry;
+
+declare const createStoreStrict: <Name extends string, State>(name: Name, initialData: State, option?: StoreOptions<State>) => StoreDefinition<Name, State>;
+export { createStoreStrict }
+export { createStoreStrict as createStoreStrict_alias_1 }
+export { createStoreStrict as createStoreStrict_alias_2 }
+
+export declare const createSwrFetcher: (storeName: StoreTarget, input: FetchInput, options?: FetchOptions) => () => Promise<unknown>;
+
+export declare const createSyncFeatureRuntime: () => StoreFeatureRuntime;
+
+declare const critical: (msg: string, meta?: Record<string, unknown>) => void;
+export { critical }
+export { critical as critical_alias_1 }
+
+declare const deepClone: <T>(value: T) => T;
+export { deepClone }
+export { deepClone as deepClone_alias_1 }
+
+declare const defaultRegistryScope: string;
+export { defaultRegistryScope }
+export { defaultRegistryScope as defaultRegistryScope_alias_1 }
+export { defaultRegistryScope as defaultRegistryScope_alias_2 }
+
+export declare const delay: (ms: number, signal?: AbortSignal) => Promise<void>;
+
+declare const deleteComputed: (name: string) => void;
+export { deleteComputed }
+export { deleteComputed as deleteComputed_alias_1 }
+export { deleteComputed as deleteComputed_alias_2 }
+
+declare function deleteStore<Name extends string, State>(name: StoreDefinition<Name, State>): void;
+
+declare function deleteStore<Name extends string, State>(name: StoreKey<Name, State>): void;
+
+declare function deleteStore<Name extends StoreName>(name: Name): void;
+export { deleteStore }
+export { deleteStore as deleteStore_alias_1 }
+export { deleteStore as deleteStore_alias_2 }
+export { deleteStore as deleteStore_alias_3 }
+
+declare type DepHandle = StoreDefinition<string, StoreValue> | StoreKey<string, StoreValue>;
+
+declare 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 const detectCycle: (name: string, deps: string[]) => string | null;
+
+/**
+ * @module devfreeze
+ *
+ * LAYER: Module
+ * OWNS:  Module-level behavior and exports for devfreeze.
+ *
+ * Consumers: Internal imports and public API.
+ */
+export declare const devDeepFreeze: <T>(value: T) => T;
+
+declare interface DevtoolsFeatureApi {
+    getHistory?: (name: string, limit?: number) => unknown[];
+    clearHistory?: (name?: string) => void;
+    getPersistQueueDepth?: (name: string) => number;
+}
+export { DevtoolsFeatureApi }
+export { DevtoolsFeatureApi as DevtoolsFeatureApi_alias_1 }
+
+export declare interface DevtoolsOptions<State = StoreValue_alias_4> {
+    enabled?: boolean;
+    historyLimit?: number;
+    redactor?: (state: State) => State;
+}
+
+export declare const diffShallow: (prev: StoreValue_alias_4, next: StoreValue_alias_4) => HistoryDiff;
+
+declare function enableRevalidateOnFocus<Name extends string, State>(name: StoreDefinition<Name, State>, overrides?: Partial<FetchOptions> & {
+    debounceMs?: number;
+    maxConcurrent?: number;
+    staggerMs?: number;
+    priority?: "high" | "normal";
+}): (() => void);
+
+declare function enableRevalidateOnFocus<Name extends string, State>(name: StoreKey<Name, State>, overrides?: Partial<FetchOptions> & {
+    debounceMs?: number;
+    maxConcurrent?: number;
+    staggerMs?: number;
+    priority?: "high" | "normal";
+}): (() => void);
+
+declare function enableRevalidateOnFocus<Name extends StoreName>(name?: Name | "*", overrides?: Partial<FetchOptions> & {
+    debounceMs?: number;
+    maxConcurrent?: number;
+    staggerMs?: number;
+    priority?: "high" | "normal";
+}): (() => void);
+export { enableRevalidateOnFocus }
+export { enableRevalidateOnFocus as enableRevalidateOnFocus_alias_1 }
+
+export declare const endTransaction: (err?: unknown, registry?: StoreRegistry) => Error | null;
+
+export declare const ensureCleanupSubscription: (name: string) => void;
+
+export declare const enterRegistry: (registry: StoreRegistry) => void;
+
+declare const error: (msg: string, meta?: Record<string, unknown>) => void;
+export { error }
+export { error as error_alias_1 }
+
+declare const exists: (name: string) => boolean;
+export { exists }
+export { exists as exists_alias_1 }
+
+declare interface FeatureCreateContext extends BaseFeatureContext {
+}
+export { FeatureCreateContext }
+export { FeatureCreateContext as FeatureCreateContext_alias_1 }
+
+declare interface FeatureDeleteContext extends BaseFeatureContext {
+    prev: StoreValue_alias_4;
+}
+export { FeatureDeleteContext }
+export { FeatureDeleteContext as FeatureDeleteContext_alias_1 }
+
+declare interface FeatureMetrics {
+    notifyCount: number;
+    totalNotifyMs: number;
+    lastNotifyMs: number;
+}
+export { FeatureMetrics }
+export { FeatureMetrics as FeatureMetrics_alias_1 }
+
+declare type FeatureName = BuiltInFeatureName | (string & {});
+export { FeatureName }
+export { FeatureName as FeatureName_alias_1 }
+
+declare type FeatureOptions = Partial<FeatureOptionsMap> & Record<string, unknown>;
+export { FeatureOptions }
+export { FeatureOptions as FeatureOptions_alias_1 }
+export { FeatureOptions as FeatureOptions_alias_2 }
+
+declare interface FeatureOptionsMap {
+}
+export { FeatureOptionsMap }
+export { FeatureOptionsMap as FeatureOptionsMap_alias_1 }
+export { FeatureOptionsMap as FeatureOptionsMap_alias_2 }
+
+declare const featureRuntimes: Map<FeatureName, StoreFeatureRuntime>;
+export { featureRuntimes }
+export { featureRuntimes as featureRuntimes_alias_1 }
+
+export declare type FeatureValidation = (next: StoreValue_alias_4) => {
+    ok: boolean;
+    value?: StoreValue_alias_4;
+};
+
+declare interface FeatureWriteContext extends BaseFeatureContext {
+    action: string;
+    prev: StoreValue_alias_4;
+    next: StoreValue_alias_4;
+}
+export { FeatureWriteContext }
+export { FeatureWriteContext as FeatureWriteContext_alias_1 }
+
+declare type FetchInput = string | Promise<unknown> | (() => string | Promise<unknown>);
+export { FetchInput }
+export { FetchInput as FetchInput_alias_1 }
+
+declare interface FetchOptions {
+    transform?: (result: unknown) => unknown;
+    onSuccess?: (data: unknown) => void;
+    onError?: (message: string) => void;
+    /**
+     * Optional adapter to write async state into a custom store shape.
+     * When provided, default AsyncState writes are skipped.
+     */
+    stateAdapter?: AsyncStateAdapter;
+    method?: string;
+    headers?: Record<string, string>;
+    body?: unknown;
+    ttl?: number;
+    staleWhileRevalidate?: boolean;
+    dedupe?: boolean;
+    retry?: number;
+    retryDelay?: number;
+    retryBackoff?: number;
+    signal?: AbortSignal;
+    cacheKey?: string;
+    responseType?: "auto" | "json" | "text" | "arrayBuffer" | "blob" | "formData";
+    /**
+     * Auto-create the backing store if missing.
+     * Defaults to the global config setting (true by default).
+     */
+    autoCreate?: boolean;
+    /**
+     * Clone strategy for transformed results.
+     * - "none" (default): store by reference.
+     * - "shallow": shallow clone objects/arrays.
+     * - "deep": deep clone objects/arrays.
+     */
+    cloneResult?: "none" | "shallow" | "deep";
+}
+export { FetchOptions }
+export { FetchOptions as FetchOptions_alias_1 }
+export { FetchOptions as FetchOptions_alias_2 }
+
+declare function fetchStore<Name extends string, State>(name: StoreDefinition<Name, State>, urlOrRequest: FetchInput, options?: FetchOptions): Promise<unknown>;
+
+declare function fetchStore<Name extends string, State>(name: StoreKey<Name, State>, urlOrRequest: FetchInput, options?: FetchOptions): Promise<unknown>;
+
+declare function fetchStore<Name extends StoreName>(name: Name, urlOrRequest: FetchInput, options?: FetchOptions): Promise<unknown>;
+export { fetchStore }
+export { fetchStore as fetchStore_alias_1 }
+
+declare type FlushConfig = {
+    chunkSize?: number;
+    chunkDelayMs?: number;
+    priorityStores?: string[];
+};
+export { FlushConfig }
+export { FlushConfig as FlushConfig_alias_1 }
+
+declare const flushPersistImmediately: (name: string, args: PersistSaveArgs) => void;
+export { flushPersistImmediately }
+export { flushPersistImmediately as flushPersistImmediately_alias_1 }
+
+export declare const FORBIDDEN_OBJECT_KEYS: Set<string>;
+
+export declare const getActiveAsyncRegistry: () => AsyncRegistry;
+
+export declare const getActiveStoreRegistry: (fallback?: StoreRegistry) => StoreRegistry;
+
+export declare const getAsyncInflightCount: (name: string) => number;
+
+declare const getAsyncMetrics: () => {
+    cacheHits: number;
+    cacheMisses: number;
+    dedupes: number;
+    requests: number;
+    failures: number;
+    avgMs: number;
+    lastMs: number;
+};
+export { getAsyncMetrics }
+export { getAsyncMetrics as getAsyncMetrics_alias_1 }
+
+declare const getByPath: (obj: unknown, path: PathInput) => unknown;
+export { getByPath }
+export { getByPath as getByPath_alias_1 }
+
+export declare const getCacheMeta: () => ReturnType<typeof getActiveAsyncRegistry>["cacheMeta"];
+
+export declare const getComputedDeps: (name: string) => {
+    deps: string[];
+    dependents: string[];
+} | null;
+
+declare const getComputedDepsFor: (name: string) => {
+    deps: string[];
+    dependents: string[];
+} | null;
+export { getComputedDepsFor }
+export { getComputedDepsFor as getComputedDepsFor_alias_1 }
+
+export declare const getComputedEntry: (name: string) => ComputedEntry | undefined;
+
+export declare const getComputedGraph: () => {
+    nodes: string[];
+    edges: Array<{
+        from: string;
+        to: string;
+    }>;
+    dependencies: Record<string, string[]>;
+    dependents: Record<string, string[]>;
+};
+
+export declare const getComputedOrder: (names: string[]) => string[];
+
+export declare const getConfig: () => ResolvedConfig;
+
+export declare const getDateStoreWarningMessage: () => string;
+
+export declare const getDeepNestingWarningMessage: (depth: number, parts: string[]) => string;
+
+export declare const getDefaultStoreRegistry: () => StoreRegistry;
+
+declare const getFeatureApi: (name: FeatureName) => DevtoolsFeatureApi | undefined;
+export { getFeatureApi as _getFeatureApi }
+export { getFeatureApi as _getFeatureApi_alias_1 }
+export { getFeatureApi }
+export { getFeatureApi as getFeatureApi_alias_1 }
+
+declare const getFeatureRuntime: (name: FeatureName) => StoreFeatureRuntime | undefined;
+export { getFeatureRuntime }
+export { getFeatureRuntime as getFeatureRuntime_alias_1 }
+
+export declare const getFetchRegistry: () => ReturnType<typeof getActiveAsyncRegistry>["fetchRegistry"];
+
+export declare const getForbiddenStoreNameMessage: (name: string) => string;
+
+declare const getFullComputedGraph: () => {
+    nodes: string[];
+    edges: Array<{
+        from: string;
+        to: string;
+    }>;
+    dependencies: Record<string, string[]>;
+    dependents: Record<string, string[]>;
+};
+export { getFullComputedGraph }
+export { getFullComputedGraph as getFullComputedGraph_alias_1 }
+
+declare const getHistory: (name: string, limit?: number) => HistoryEntry[];
+export { getHistory }
+export { getHistory as getHistory_alias_1 }
+
+export declare const getInitialState: () => Record<string, unknown>;
+
+declare const getInitialState_2: () => Record<string, StoreValue>;
+export { getInitialState_2 as getInitialState_alias_1 }
+export { getInitialState_2 as getInitialState_alias_2 }
+
+export declare const getInvalidFunctionStoreValueMessage: () => string;
+
+export declare const getInvalidStoreNameMessage: (name: string) => string;
+
+export declare const getMapSetStoreWarningMessage: () => string;
+
+declare const getMetaEntry: (name: string) => StoreFeatureMeta | undefined;
+export { getMetaEntry }
+export { getMetaEntry as getMetaEntry_alias_1 }
+
+export declare const getMetrics: (name: string) => StoreFeatureMeta["metrics"] | null;
+
+declare const getMetrics_2: (name: string) => (typeof meta)[string]["metrics"] | null;
+export { getMetrics_2 as getMetrics_alias_1 }
+export { getMetrics_2 as getMetrics_alias_2 }
+
+export declare const getNamespace: () => string;
+
+export declare const getPathDepthExceededMessage: (depth: number, maxDepth: number, parts: string[]) => string;
+
+export declare const getPathNotObjectMessage: (part: string) => string;
+
+export declare const getPathReachedNullMessage: (parts: string[], part: string) => string;
+
+export declare const getPersistQueueDepth: (name: string) => number;
+
+declare const getRegisteredFeatureNames: () => FeatureName[];
+export { getRegisteredFeatureNames }
+export { getRegisteredFeatureNames as getRegisteredFeatureNames_alias_1 }
+
+declare const getRegistry: () => StoreRegistry;
+export { getRegistry }
+export { getRegistry as getRegistry_alias_1 }
+
+export declare const getRequestCarrier: () => CarrierContext | null;
+
+export declare const getSanitizeDateWarningMessage: () => string;
+
+export declare const getSanitizeMapWarningMessage: () => string;
+
+export declare const getSanitizeSetWarningMessage: () => string;
+
+export declare const getSelectorStoreValueRef: (name: string) => StoreValue | undefined;
+
+/** @deprecated Use getStoreSnapshot instead. */
+declare const getSnapshot: (name: string) => StoreValue | null;
+export { getSnapshot as _getSnapshot }
+export { getSnapshot }
+
+declare const getSsrWarningIssued: (name?: string) => boolean;
+export { getSsrWarningIssued }
+export { getSsrWarningIssued as getSsrWarningIssued_alias_1 }
+
+export declare const getStagedTransactionValue: (name: string) => {
+    has: boolean;
+    value: StoreValue | undefined;
+};
+
+declare function getStore<Name extends string, State, P extends Path<State>>(name: StoreDefinition<Name, State>, path: P): StoreSnapshot<PathValue<State, P>> | null;
+
+declare function getStore<Name extends string, State>(name: StoreDefinition<Name, State>, path?: undefined): StoreSnapshot<State> | null;
+
+declare function getStore<Name extends string, State, P extends Path<State>>(name: StoreKey<Name, State>, path: P): StoreSnapshot<PathValue<State, P>> | null;
+
+declare function getStore<Name extends string, State>(name: StoreKey<Name, State>, path?: undefined): StoreSnapshot<State> | null;
+
+declare function getStore<Name extends StoreName, P extends Path<StateFor<Name>>>(name: Name, path: P): StoreSnapshot<PathValue<StateFor<Name>, P>> | null;
+
+declare function getStore<Name extends StoreName>(name: Name, path?: undefined): StoreSnapshot<StateFor<Name>> | null;
+export { getStore }
+export { getStore as getStore_alias_1 }
+export { getStore as getStore_alias_2 }
+export { getStore as getStore_alias_3 }
+export { getStore as getStore_alias_4 }
+
+declare const getStoreAdmin: () => ReturnType<typeof createStoreAdmin>;
+export { getStoreAdmin }
+export { getStoreAdmin as getStoreAdmin_alias_1 }
+
+export declare const getStoreFeatureFactory: (name: FeatureName) => StoreFeatureFactory | undefined;
+
+export declare const getStoreMeta: (name: string) => StoreFeatureMeta | null;
+
+export declare const getStoreNameContainsSpacesMessage: (name: string) => string;
+
+export declare const getStoreRegistry: (scope: string) => StoreRegistry;
+
+declare const getStoreSnapshot: (name: string) => StoreValue | null;
+export { getStoreSnapshot }
+export { getStoreSnapshot as getStoreSnapshot_alias_1 }
+
+declare const getStoreValueRef: (name: string) => StoreValue | undefined;
+export { getStoreValueRef as _getStoreValueRef }
+export { getStoreValueRef as _getStoreValueRef_alias_1 }
+export { getStoreValueRef }
+export { getStoreValueRef as getStoreValueRef_alias_1 }
+
+export declare const getSubscriberCount: (name: string) => number;
+
+export declare const getTopoOrderedComputeds: (changedSources: string[]) => string[];
+
+declare const getType: (value: unknown) => SupportedType;
+export { getType }
+export { getType as getType_alias_1 }
+
+export declare const _hardResetAllStoresForTest: () => void;
+
+export declare const hasBroadUseStoreWarning: (name: string) => boolean;
+
+/**
+ * Non-cryptographic checksum for integrity (best-effort). Do not use for security.
+ * String inputs preserve the legacy CRC32(JSON.stringify(value)) behavior to keep
+ * persisted checksums stable across versions.
+ */
+declare const hashState: (value: unknown) => number;
+export { hashState }
+export { hashState as hashState_alias_1 }
+
+export declare const hasInflightEntry: (cacheSlot: string) => boolean;
+
+export declare const hasMissingUseStoreWarning: (name: string) => boolean;
+
+declare const hasRegisteredStoreFeature: (name: FeatureName) => boolean;
+export { hasRegisteredStoreFeature }
+export { hasRegisteredStoreFeature as hasRegisteredStoreFeature_alias_1 }
+
+export declare const hasSelectorStoreEntry: (name: string) => boolean;
+
+declare const hasStore: (name: string) => boolean;
+export { hasStore }
+export { hasStore as hasStore_alias_1 }
+export { hasStore as hasStore_alias_2 }
+export { hasStore as hasStore_alias_3 }
+
+export declare const hasStoreEntry: (registry: StoreRegistry, name: string) => boolean;
+
+declare const hasStoreEntryInternal: (name: string) => boolean;
+export { hasStoreEntryInternal as _hasStoreEntryInternal }
+export { hasStoreEntryInternal as _hasStoreEntryInternal_alias_1 }
+export { hasStoreEntryInternal }
+export { hasStoreEntryInternal as hasStoreEntryInternal_alias_1 }
+
+declare type HistoryDiff = {
+    added: string[];
+    removed: string[];
+    changed: string[];
+} | null;
+export { HistoryDiff }
+export { HistoryDiff as HistoryDiff_alias_1 }
+
+declare type HistoryEntry = {
+    ts: number;
+    action: string;
+    prev: StoreValue_alias_4;
+    next: StoreValue_alias_4;
+    diff: HistoryDiff;
+};
+export { HistoryEntry }
+export { HistoryEntry as HistoryEntry_alias_1 }
+
+declare type HydrateOptions<Snapshot extends Record<string, unknown>> = Partial<{
+    [K in keyof Snapshot]: StoreOptions<Snapshot[K]>;
+}> & {
+    default?: StoreOptions;
+};
+
+declare type HydrateSnapshot = Partial<{
+    [K in StoreName]: StateFor<K>;
+}>;
+
+declare const hydrateStores: <Snapshot extends Record<string, unknown> = HydrateSnapshot>(snapshot: Snapshot, options?: HydrateOptions<Snapshot>, trust?: HydrationTrust<Snapshot>) => {
+    hydrated: string[];
+    created: string[];
+    failed: Record<string, string>;
+};
+export { hydrateStores }
+export { hydrateStores as hydrateStores_alias_1 }
+export { hydrateStores as hydrateStores_alias_2 }
+
+declare type HydrationTrust<Snapshot extends Record<string, unknown>> = {
+    allowUntrusted?: boolean;
+    validate?: (snapshot: Snapshot) => boolean;
+};
+
+export declare const inflight: Partial<Record<string, {
+    promise: Promise<unknown>;
+    raw: Promise<unknown>;
+    transform?: FetchOptions["transform"];
+}>>;
+
+export declare type InflightEntry = {
+    promise: Promise<unknown>;
+    raw: Promise<unknown>;
+    transform?: FetchOptions["transform"];
+};
+
+declare type InflightEntry_2 = {
+    promise: Promise<unknown>;
+    raw: Promise<unknown>;
+    transform?: FetchOptions["transform"];
+};
+
+export declare const initDevtools: ({ name, useDevtools, existingDevtools, stores, warn, }: {
+    name: string;
+    useDevtools: boolean;
+    existingDevtools: any;
+    stores: Record<string, StoreValue_alias_4>;
+    warn: (message: string) => void;
+}) => any;
+
+declare const initialFactories: Record<string, (() => StoreValue) | undefined>;
+export { initialFactories }
+export { initialFactories as initialFactories_alias_1 }
+
+export declare const initializeRegisteredFeatureRuntimes: () => void;
+
+declare const initialStates: Record<string, unknown>;
+export { initialStates }
+export { initialStates as initialStates_alias_1 }
+
+export declare const injectCarrierRunner: (runner: CarrierRunner) => void;
+
+export declare const injectRegistryRunner: (runner: RegistryRunner) => void;
+
+export declare const installAllFeatures: () => void;
+
+declare const installDevtools: () => void;
+export { installDevtools }
+export { installDevtools as installDevtools_alias_1 }
+
+declare const installPersist: () => void;
+export { installPersist }
+export { installPersist as installPersist_alias_1 }
+
+declare const installSync: () => void;
+export { installSync }
+export { installSync as installSync_alias_1 }
+
+declare const invalidateComputed: (name: string) => void;
+export { invalidateComputed }
+export { invalidateComputed as invalidateComputed_alias_1 }
+export { invalidateComputed as invalidateComputed_alias_2 }
+
+declare const invalidatePathCache: (name: string) => void;
+export { invalidatePathCache }
+export { invalidatePathCache as invalidatePathCache_alias_1 }
+
+export declare const isComputed: (name: string) => boolean;
+
+declare const isComputedStore: (name: string) => boolean;
+export { isComputedStore }
+export { isComputedStore as isComputedStore_alias_1 }
+export { isComputedStore as isComputedStore_alias_2 }
+
+export declare const isCurrentRequest: (cacheSlot: string, version: number) => boolean;
+
+export declare const isDeleting: (name: string) => boolean;
+
+declare const isDev: () => boolean;
+export { isDev }
+export { isDev as isDev_alias_1 }
+
+export declare const isIdentityCrypto: (fn: (v: string) => string) => boolean;
+
+export declare const isStoreDeleting: (registry: StoreRegistry, name: string) => boolean;
+
+declare type IsStoreNameLoose = string extends StoreName ? true : false;
+
+export declare type IssueOptions = {
+    severity?: IssueSeverity;
+    visibility?: IssueVisibility;
+    onError?: (message: string) => void;
+};
+
+export declare type IssueSeverity = "warn" | "critical";
+
+export declare type IssueVisibility = "dev" | "always";
+
+export declare const isTransactionActive: () => boolean;
+
+declare const isValidData: (value: unknown) => boolean;
+export { isValidData }
+export { isValidData as isValidData_alias_1 }
+
+declare const isValidStoreName: (name: string) => boolean;
+export { isValidStoreName }
+export { isValidStoreName as isValidStoreName_alias_1 }
+
+export declare type LifecycleIssueReporter = (message: string, visibility?: "dev" | "always") => void;
+
+export declare interface LifecycleOptions<State = StoreValue_alias_4> {
+    middleware?: Array<(ctx: MiddlewareCtx) => StoreValue_alias_4 | void>;
+    onSet?: (prev: State, next: State) => void;
+    onReset?: (prev: State, next: State) => void;
+    onDelete?: (prev: State) => void;
+    onCreate?: (initial: State) => void;
+}
+
+export declare const listStores: (pattern?: string) => string[];
+
+declare const log: (msg: string, meta?: Record<string, unknown>) => void;
+export { log }
+export { log as log_alias_1 }
+
+declare 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 { LogSink }
+export { LogSink as LogSink_alias_1 }
+
+export declare const markBroadUseStoreWarning: (name: string) => void;
+
+export declare const markMissingUseStoreWarning: (name: string) => void;
+
+declare const markSsrWarningIssued: (name: string) => void;
+export { markSsrWarningIssued }
+export { markSsrWarningIssued as markSsrWarningIssued_alias_1 }
+
+export declare const markStale: (name: string) => void;
+
+export declare const markTransactionFailed: (err?: unknown, registry?: StoreRegistry) => void;
+
+export declare const markWarned: (set: Set<string>, key: string) => void;
+
+declare const materializeInitial: (name: string) => boolean;
+export { materializeInitial }
+export { materializeInitial as materializeInitial_alias_1 }
+
+export declare const MAX_CACHE_SLOTS_PER_STORE = 100;
+
+export declare const MAX_INFLIGHT_SLOTS_PER_STORE = 100;
+
+export declare const MAX_RETRY_ATTEMPTS = 10;
+
+export declare const MAX_RETRY_BACKOFF = 8;
+
+export declare const MAX_RETRY_DELAY_MS = 30000;
+
+export declare const MAX_WARNED_ENTRIES = 1000;
+
+declare const meta: Record<string, StoreFeatureMeta>;
+export { meta }
+export { meta as meta_alias_1 }
+
+export declare const MIDDLEWARE_ABORT: unique symbol;
+
+declare interface MiddlewareCtx {
+    action: string;
+    name: string;
+    prev: StoreValue_alias_4;
+    next: StoreValue_alias_4;
+    path: unknown;
+}
+export { MiddlewareCtx }
+export { MiddlewareCtx as MiddlewareCtx_alias_1 }
+
+export declare const MIN_RETRY_DELAY_MS = 10;
+
+export declare const mutableResultWarned: Set<string>;
+
+declare const nameOf: (name: string | StoreDefinition<string, unknown>) => string;
+export { nameOf }
+export { nameOf as nameOf_alias_1 }
+
+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]) => StoreDefinition<string, unknown> | undefined;
+    createStrict: <Name extends string, State>(name: Name, data: State, options?: Parameters<typeof createStore>[2]) => StoreDefinition<string, unknown>;
+    set: (name: any, ...rest: any[]) => any;
+    get: (name: any, ...rest: any[]) => any;
+    delete: (name: string) => void;
+    reset: (name: string) => WriteResult;
+};
+export { namespace }
+export { namespace as namespace_alias_1 }
+export { namespace as namespace_alias_2 }
+
+declare const normalizeCommittedState: (name: string, value: unknown, validate: ValidateOption | undefined, onError?: (message: string) => void, options?: {
+    reuseInput?: boolean;
+}) => {
+    ok: true;
+    value: StoreValue;
+} | {
+    ok: false;
+};
+export { normalizeCommittedState }
+export { normalizeCommittedState as normalizeCommittedState_alias_1 }
+
+export declare type NormalizedFeatureState = {
+    ok: true;
+    value: StoreValue_alias_4;
+} | {
+    ok: false;
+};
+
+export declare interface NormalizedOptions {
+    scope: StoreScope;
+    lazy: boolean;
+    pathCreate: boolean;
+    persist: PersistConfig | null;
+    devtools: boolean;
+    middleware: Array<(ctx: MiddlewareCtx) => StoreValue_alias_4 | void>;
+    onSet?: (prev: StoreValue_alias_4, next: StoreValue_alias_4) => void;
+    onReset?: (prev: StoreValue_alias_4, next: StoreValue_alias_4) => void;
+    onDelete?: (prev: StoreValue_alias_4) => void;
+    onCreate?: (initial: StoreValue_alias_4) => void;
+    onError?: (err: string) => void;
+    validate?: ValidateOption;
+    migrations: Record<number, (state: any) => any>;
+    version: number;
+    redactor?: (state: StoreValue_alias_4) => StoreValue_alias_4;
+    historyLimit: number;
+    allowSSRGlobalStore?: boolean;
+    sync?: boolean | SyncOptions;
+    features?: FeatureOptions;
+    snapshot: SnapshotMode;
+    explicitPersist: boolean;
+    explicitSync: boolean;
+    explicitDevtools: boolean;
+}
+
+export declare const normalizeFeatureState: ({ value, sanitize, validate, onSanitizeError, }: {
+    value: unknown;
+    sanitize?: (value: unknown) => unknown;
+    validate: FeatureValidation;
+    onSanitizeError?: (error: unknown) => void;
+}) => NormalizedFeatureState;
+
+/**
+ * Normalize persist options for a store.
+ *
+ * This function takes the raw persist options from a store and returns
+ * a normalized PersistConfig object. If the raw persist options are
+ * invalid, this function returns null.
+ *
+ * @template State
+ * @param {StoreOptions<State>["persist"]} persist - The raw persist options for the store.
+ * @param {string} name - The name of the store.
+ * @returns {PersistConfig | null} A normalized PersistConfig object, or null if the raw persist options are invalid.
+ */
+export declare const normalizePersistOptions: <State>(persist: StoreOptions<State>["persist"], name: string) => PersistConfig | null;
+
+export declare const normalizeRetryOptions: (name: string, retry: number, retryDelay: number, retryBackoff: number) => {
+    retry: number;
+    retryDelay: number;
+    retryBackoff: number;
+};
+
+/**
+ * Normalize a store options object, merging default values and performing deprecation checks.
+ * @param option The store options object to normalize.
+ * @param name The name of the store.
+ * @param defaultSnapshotMode The default snapshot mode to use if none is specified.
+ * @returns A normalized store options object.
+ */
+export declare const normalizeStoreOptions: <State>(option: StoreOptions<State> | undefined, name: string, defaultSnapshotMode?: SnapshotMode) => NormalizedOptions;
+
+export declare const normalizeStoreRegistryScope: (scope: string) => string;
+
+export declare const noSignalWarned: Set<string>;
+
+export declare const notify: (name: string) => void;
+
+export declare type NotifyState = {
+    pendingNotifications: Set<string>;
+    pendingBuffer: string[];
+    orderedNames: string[];
+    notifyScheduled: boolean;
+    batchDepth: number;
+};
+
+declare const parsePath: (path: PathInput) => string[];
+export { parsePath }
+export { parsePath as parsePath_alias_1 }
+
+export declare const parseResponseBody: (response: Response, responseType: FetchOptions["responseType"]) => Promise<unknown>;
+
+declare type PartialDeep<T> = T extends Primitive ? T : unknown extends T ? T : {
+    [K in keyof T]?: PartialDeep<T[K]>;
+};
+export { PartialDeep }
+export { PartialDeep as PartialDeep_alias_1 }
+export { PartialDeep as PartialDeep_alias_2 }
+export { PartialDeep as PartialDeep_alias_3 }
+export { PartialDeep as PartialDeep_alias_4 }
+
+declare type Path<T, Depth extends number = 10> = PathInternal<T, Depth>;
+export { Path }
+export { Path as Path_alias_1 }
+export { Path as Path_alias_2 }
+export { Path as Path_alias_3 }
+export { Path as Path_alias_4 }
+
+declare type PathDepth<T, Depth extends number> = PathInternal<T, Depth>;
+export { PathDepth }
+export { PathDepth as PathDepth_alias_1 }
+export { PathDepth as PathDepth_alias_2 }
+
+declare type PathInput = string | readonly string[] | string[];
+export { PathInput }
+export { PathInput as PathInput_alias_1 }
+
+declare 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)];
+
+declare type PathSafetyVerdict = {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};
+
+declare const pathValidationCache: Map<string, PathValidationCacheNode>;
+export { pathValidationCache }
+export { pathValidationCache as pathValidationCache_alias_1 }
+
+declare type PathValidationCacheNode = {
+    children: Map<string, PathValidationCacheNode>;
+    verdicts?: Map<SupportedType, PathSafetyVerdict>;
+};
+
+declare 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 { PathValue }
+export { PathValue as PathValue_alias_1 }
+export { PathValue as PathValue_alias_2 }
+export { PathValue as PathValue_alias_3 }
+export { PathValue as PathValue_alias_4 }
+
+declare interface PersistConfig {
+    driver: PersistDriver;
+    key: string;
+    serialize: (v: unknown) => string;
+    deserialize: (v: string) => unknown;
+    encrypt: (v: string) => string;
+    decrypt: (v: string) => string;
+    encryptAsync?: (v: string) => Promise<string>;
+    decryptAsync?: (v: string) => Promise<string>;
+    allowPlaintext?: boolean;
+    sensitiveData?: boolean;
+    checksum: "hash" | "none" | "sha256";
+    onMigrationFail?: "reset" | "keep" | ((state: unknown) => unknown);
+    onStorageCleared?: (info: {
+        name: string;
+        key: string;
+        reason: "clear" | "remove" | "missing";
+    }) => void;
+}
+export { PersistConfig }
+export { PersistConfig as PersistConfig_alias_1 }
+
+export declare interface PersistDriver {
+    getItem?: (k: string) => string | null | Promise<string | null>;
+    setItem?: (k: string, v: string) => void | Promise<void>;
+    removeItem?: (k: string) => void | Promise<void>;
+    [key: string]: unknown;
+}
+
+export declare type PersistInFlight = Record<string, Promise<void> | null>;
+
+declare const persistLoad: (args: PersistLoadArgs) => boolean | Promise<boolean>;
+export { persistLoad }
+export { persistLoad as persistLoad_alias_1 }
+
+export declare type PersistLoadArgs = {
+    name: string;
+    silent?: boolean;
+    getMeta: () => PersistMeta | undefined;
+    getInitialState: () => StoreValue_alias_4;
+    applyFeatureState: (value: StoreValue_alias_4, updatedAtMs?: number) => void;
+    shouldApply?: () => boolean;
+    reportStoreError: (name: string, message: string) => void;
+    validate: (next: StoreValue_alias_4) => {
+        ok: boolean;
+        value?: StoreValue_alias_4;
+    };
+    log: (message: string) => void;
+    hashState: (value: unknown) => number;
+    deepClone: <T>(value: T) => T;
+    sanitize: (value: unknown) => unknown;
+};
+
+export declare type PersistMeta = {
+    version: number;
+    updatedAt: string;
+    updatedAtMs?: number;
+    options: {
+        persist: PersistConfig | null;
+        migrations: Record<number, (state: any) => any>;
+        onError?: (err: string) => void;
+    };
+};
+
+declare interface PersistOptions<State = StoreValue_alias_4> {
+    driver?: PersistDriver;
+    storage?: PersistDriver;
+    key?: string;
+    serialize?: (v: unknown) => string;
+    deserialize?: (v: string) => unknown;
+    /**
+     * Optional encryption hook for persisted payloads.
+     *
+     * Default is identity (no encryption). Data is stored in plaintext.
+     */
+    encrypt?: (v: string) => string;
+    /**
+     * Optional async encryption hook for persisted payloads.
+     *
+     * When provided, persistence will encrypt in the background and hydrate asynchronously.
+     */
+    encryptAsync?: (v: string) => Promise<string>;
+    /**
+     * Optional decryption hook for persisted payloads.
+     *
+     * Default is identity (no encryption). Data is stored in plaintext.
+     */
+    decrypt?: (v: string) => string;
+    /**
+     * Optional async decryption hook for persisted payloads.
+     *
+     * When provided, persistence will hydrate asynchronously after store creation.
+     */
+    decryptAsync?: (v: string) => Promise<string>;
+    /**
+     * Explicitly allow plaintext persistence when encrypt/decrypt are identity.
+     *
+     * In production builds, plaintext persistence is blocked unless this is true.
+     */
+    allowPlaintext?: boolean;
+    /**
+     * Marks this store's persisted data as sensitive (secrets/PII).
+     *
+     * When `true`, stroid throws at store creation time unless a non-identity
+     * `encrypt` hook is provided.
+     */
+    sensitiveData?: boolean;
+    /**
+     * Integrity check mode for persisted payloads.
+     * - "hash" (default): store and validate a checksum.
+     * - "none": skip checksum generation/validation.
+     * - "sha256": store a SHA-256 hash for stronger tamper detection (may be async in browsers).
+     */
+    checksum?: "hash" | "none" | "sha256";
+    version?: number;
+    migrations?: Record<number, (state: State) => State>;
+    onMigrationFail?: "reset" | "keep" | ((state: unknown) => unknown);
+    onStorageCleared?: (info: {
+        name: string;
+        key: string;
+        reason: "clear" | "remove" | "missing";
+    }) => void;
+}
+export { PersistOptions }
+export { PersistOptions as PersistOptions_alias_1 }
+export { PersistOptions as PersistOptions_alias_2 }
+
+declare const persistSave: (args: PersistSaveArgs) => void;
+export { persistSave }
+export { persistSave as persistSave_alias_1 }
+
+export declare type PersistSaveArgs = {
+    name: string;
+    persistTimers: PersistTimers;
+    persistInFlight: PersistInFlight;
+    persistSequence: PersistSequence;
+    persistWatchState: PersistWatchState;
+    plaintextWarningsIssued: Set<string>;
+    exists: () => boolean;
+    getMeta: () => PersistMeta | undefined;
+    getStoreValue: () => StoreValue_alias_4;
+    reportStoreError: (name: string, message: string) => void;
+    hashState: (value: unknown) => number;
+};
+
+export declare type PersistSequence = Record<string, number>;
+
+declare type PersistTimers = Record<string, ReturnType<typeof setTimeout>>;
+export { PersistTimers }
+export { PersistTimers as PersistTimers_alias_1 }
+
+declare type PersistWatchEntry = {
+    lastPresent: boolean;
+    dispose: () => void;
+};
+export { PersistWatchEntry }
+export { PersistWatchEntry as PersistWatchEntry_alias_1 }
+
+declare type PersistWatchState = Record<string, PersistWatchEntry>;
+export { PersistWatchState }
+export { PersistWatchState as PersistWatchState_alias_1 }
+
+declare type PrevDepth = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+
+/**
+ * @module store-lifecycle/types
+ *
+ * LAYER: Store lifecycle
+ * OWNS:  Module-level behavior and exports for store-lifecycle/types.
+ *
+ * Consumers: Internal imports and public API.
+ */
+declare type Primitive = string | number | boolean | bigint | symbol | null | undefined;
+
+declare const produceClone: <T>(base: T, recipe: (draft: T) => void) => T;
+export { produceClone }
+export { produceClone as produceClone_alias_1 }
+
+export declare const pruneAsyncCache: (name: string) => void;
+
+export declare const pruneRateCounters: (nowTs: number) => void;
+
+export declare const pushHistory: ({ name, action, prev, next, history, historyLimit, applyRedactor, deepClone, }: {
+    name: string;
+    action: string;
+    prev: StoreValue_alias_4;
+    next: StoreValue_alias_4;
+    history: Record<string, HistoryEntry[]>;
+    historyLimit: number;
+    applyRedactor: (value: StoreValue_alias_4) => StoreValue_alias_4;
+    deepClone: <T>(value: T) => T;
+}) => void;
+
+declare const qualifyName: (raw: string) => string;
+export { qualifyName }
+export { qualifyName as qualifyName_alias_1 }
+
+export declare namespace queryIntegrations {
+    export {
+        reactQueryKey,
+        createReactQueryFetcher,
+        swrKey,
+        createSwrFetcher
+    }
+}
+
+export declare const RATE_MAX = 100;
+
+export declare const RATE_WINDOW_MS = 1000;
+
+export declare const rateCount: Record<string, number>;
+
+export declare const ratePruneState: {
+    lastAt: number;
+};
+
+export declare const rateWindowStart: Record<string, number>;
+
+export declare const reactQueryKey: (storeName: StoreTarget, cacheKey?: string | number) => (string | number)[];
+
+declare function refetchStore<Name extends string, State>(name: StoreDefinition<Name, State>): Promise<unknown>;
+
+declare function refetchStore<Name extends string, State>(name: StoreKey<Name, State>): Promise<unknown>;
+
+declare function refetchStore<Name extends StoreName>(name: Name): Promise<unknown>;
+export { refetchStore }
+export { refetchStore as refetchStore_alias_1 }
+
+export declare const registerComputed: (name: string, deps: string[], compute: (...args: unknown[]) => unknown) => boolean;
+
+export declare const registerDevtoolsFeature: () => void;
+
+declare type RegisteredStoreMap = StoreStateMap & StrictStoreMap;
+
+export declare const registerPersistFeature: () => void;
+
+export declare const registerRateHit: (cacheSlot: string, nowTs: number) => boolean;
+
+export declare const registerStoreCleanup: (name: string, fn: () => void) => void;
+
+declare const registerStoreFeature: (name: FeatureName, factory: StoreFeatureFactory) => void;
+export { registerStoreFeature }
+export { registerStoreFeature as registerStoreFeature_alias_1 }
+
+export declare const registerSyncFeature: () => void;
+
+export declare const registerTestResetHook: (name: string, fn: () => void, order?: number) => void;
+
+export declare const registerTransactionCommit: (fn: () => void) => void;
+
+export declare interface RegistryRunner {
+    run<T>(registry: StoreRegistry, fn: () => T): T;
+    get(): StoreRegistry | null;
+    enterWith?: (registry: StoreRegistry) => void;
+}
+
+export declare type RegistrySnapshotEntry = {
+    version: number;
+    snapshot: RegistryStoreValue | null;
+};
+
+export declare type RegistryStoreValue = unknown;
+
+export declare type RegistrySubscriber = (value: RegistryStoreValue | null) => void;
+
+declare function replaceStore<Name extends string, State>(name: StoreDefinition<Name, State>, value: State): WriteResult;
+
+declare function replaceStore<Name extends string, State>(name: StoreKey<Name, State>, value: State): WriteResult;
+
+declare function replaceStore<Name extends StoreName>(name: Name, value: StateFor<Name>): WriteResult;
+export { replaceStore }
+export { replaceStore as replaceStore_alias_1 }
+export { replaceStore as replaceStore_alias_2 }
+
+export declare const reportAsyncUsageError: (name: string, message: string, onError?: (message: string) => void) => null;
+
+export declare const reportIssue: (message: string, options?: IssueOptions) => void;
+
+declare const reportStoreCreationError: (message: string, onError?: (message: string) => void) => void;
+export { reportStoreCreationError }
+export { reportStoreCreationError as reportStoreCreationError_alias_1 }
+
+export declare const reportStoreCreationIssue: (message: string, onError?: (message: string) => void, options?: {
+    severity?: IssueSeverity;
+    visibility?: IssueVisibility;
+}) => void;
+
+declare const reportStoreCreationWarning: (message: string, onError?: (message: string) => void, visibility?: IssueVisibility) => void;
+export { reportStoreCreationWarning }
+export { reportStoreCreationWarning as reportStoreCreationWarning_alias_1 }
+
+declare const reportStoreError: (name: string, message: string) => void;
+export { reportStoreError }
+export { reportStoreError as reportStoreError_alias_1 }
+
+export declare const reportStoreIssue: (name: string, message: string, options?: {
+    severity?: IssueSeverity;
+    visibility?: IssueVisibility;
+}) => void;
+
+declare const reportStoreWarning: (name: string, message: string, visibility?: IssueVisibility) => void;
+export { reportStoreWarning }
+export { reportStoreWarning as reportStoreWarning_alias_1 }
+
+declare type RequestHydrateOptions<StateMap> = Partial<{
+    [K in RequestStoreName<StateMap>]: StoreOptions<RequestStoreValue<StateMap, K>>;
+}> & {
+    default?: StoreOptions;
+};
+
+declare type RequestSnapshot<StateMap> = Partial<{
+    [K in RequestStoreName<StateMap>]: RequestStoreValue<StateMap, K>;
+}>;
+
+export declare type RequestStoreApi<StateMap extends StoreStateMap = StoreStateMap> = {
+    create: <Name extends RequestStoreName<StateMap>>(name: Name, data: RequestStoreValue<StateMap, Name>, options?: StoreOptions<RequestStoreValue<StateMap, Name>>) => RequestStoreValue<StateMap, Name>;
+    set: <Name extends RequestStoreName<StateMap>>(name: Name, updater: RequestStoreValue<StateMap, Name> | ((draft: RequestStoreValue<StateMap, Name>) => void)) => RequestStoreValue<StateMap, Name>;
+    get: <Name extends RequestStoreName<StateMap>>(name: Name) => RequestStoreValue<StateMap, Name> | undefined;
+};
+
+declare type RequestStoreContext<StateMap extends StoreStateMap> = {
+    snapshot: () => RequestSnapshot<StateMap>;
+    hydrate: <T>(renderFn: () => T, options?: RequestHydrateOptions<StateMap>) => T;
+};
+
+declare type RequestStoreName<StateMap> = keyof StateMap extends never ? string : keyof StateMap & string;
+
+declare type RequestStoreValue<StateMap, Name extends RequestStoreName<StateMap>> = Name extends keyof StateMap ? StateMap[Name] : unknown;
+
+export declare const requestVersion: Record<string, number>;
+
+export declare const reserveRequestVersion: (cacheSlot: string) => number;
+
+export declare const resetAllStoreRegistriesForTests: () => void;
+
+export declare const resetAllStoresForTest: () => void;
+
+export declare const resetAsyncRegistry: (registry: AsyncRegistry) => void;
+
+export declare const resetAsyncState: () => void;
+
+declare const _resetAsyncStateForTests: () => void;
+export { _resetAsyncStateForTests }
+export { _resetAsyncStateForTests as _resetAsyncStateForTests_alias_1 }
+
+export declare const resetBroadUseStoreWarnings: () => void;
+
+declare const _resetComputedForTests: () => void;
+export { _resetComputedForTests }
+export { _resetComputedForTests as _resetComputedForTests_alias_1 }
+
+declare const resetConfig: () => void;
+export { resetConfig }
+export { resetConfig as resetConfig_alias_1 }
+
+export declare const _resetConfigForTests: () => void;
+
+declare const resetFeaturesForTests: () => void;
+export { resetFeaturesForTests }
+export { resetFeaturesForTests as resetFeaturesForTests_alias_1 }
+
+/**
+ * Resets the internal set of legacy options that have been warned
+ * about. Used for testing purposes to prevent warnings from leaking
+ * between tests.
+ */
+export declare const resetLegacyOptionDeprecationWarningsForTests: () => void;
+
+export declare const resetMissingUseStoreWarnings: () => void;
+
+export declare const resetNotifyStateForTests: () => void;
+
+export declare const resetPathValidationCache: (registry: object) => void;
+
+export declare const resetRegisteredStoreFeaturesForTests: () => void;
+
+declare const resetSsrWarningFlag: () => void;
+export { resetSsrWarningFlag }
+export { resetSsrWarningFlag as resetSsrWarningFlag_alias_1 }
+
+declare function resetStore<Name extends string, State>(name: StoreDefinition<Name, State>): WriteResult;
+
+declare function resetStore<Name extends string, State>(name: StoreKey<Name, State>): WriteResult;
+
+declare function resetStore<Name extends StoreName>(name: Name): WriteResult;
+export { resetStore }
+export { resetStore as resetStore_alias_1 }
+export { resetStore as resetStore_alias_2 }
+
+declare type ResolvedConfig = {
+    logSink: LogSink;
+    flush: Required<FlushConfig>;
+    revalidateOnFocus: Required<RevalidateOnFocusConfig>;
+    namespace: string;
+    strictMissingFeatures: boolean;
+    assertRuntime: boolean;
+    strictMutatorReturns: boolean;
+    asyncAutoCreate: boolean;
+    asyncCloneResult: AsyncCloneMode;
+    defaultSnapshotMode: SnapshotMode;
+    strictAsyncUsageErrors: boolean;
+    middleware: Array<(ctx: MiddlewareCtx) => StoreValue_alias_4 | void>;
+    allowUntrustedHydration: boolean;
+    mutatorProduce?: <T>(base: T, recipe: (draft: T) => void) => T;
+};
+
+declare const resolveFeatureAvailability: (name: string, options: NormalizedOptions) => NormalizedOptions;
+export { resolveFeatureAvailability }
+export { resolveFeatureAvailability as resolveFeatureAvailability_alias_1 }
+
+export declare const resolveScope: (scopeOrRegistry?: string | ReturnType<typeof getStoreRegistry>) => {
+    scope: string;
+    registry: StoreRegistry;
+};
+
+export declare const resolveUpdatedAtMs: ({ value, fallbackMs, onInvalid, }: {
+    value: unknown;
+    fallbackMs?: number;
+    onInvalid?: () => void;
+}) => number;
+
+export declare const revalidateHandlers: Record<string, () => void>;
+
+export declare const revalidateKeys: Set<string>;
+
+declare type RevalidateOnFocusConfig = {
+    debounceMs?: number;
+    maxConcurrent?: number;
+    staggerMs?: number;
+};
+export { RevalidateOnFocusConfig }
+export { RevalidateOnFocusConfig as RevalidateOnFocusConfig_alias_1 }
+
+export declare const runAsyncHook: (name: string, label: "onSuccess" | "onError", fn: ((value: any) => void) | undefined, value: unknown) => void;
+
+declare const runFeatureCreateHooks: (name: string, notify: (name: string) => void) => void;
+export { runFeatureCreateHooks }
+export { runFeatureCreateHooks as runFeatureCreateHooks_alias_1 }
+
+declare const runFeatureDeleteHooks: (name: string, prev: StoreValue, notify: (name: string) => void) => void;
+export { runFeatureDeleteHooks }
+export { runFeatureDeleteHooks as runFeatureDeleteHooks_alias_1 }
+
+declare const runFeatureWriteHooks: (name: string, action: string, prev: StoreValue, next: StoreValue, notify: (name: string) => void) => void;
+export { runFeatureWriteHooks }
+export { runFeatureWriteHooks as runFeatureWriteHooks_alias_1 }
+
+export declare const runMiddleware: ({ name, payload, middlewares, reportIssue, warn, }: {
+    name: string;
+    payload: {
+        action: string;
+        prev: StoreValue_alias_4;
+        next: StoreValue_alias_4;
+        path: unknown;
+    };
+    middlewares: Array<(ctx: {
+        action: string;
+        name: string;
+        prev: StoreValue_alias_4;
+        next: StoreValue_alias_4;
+        path: unknown;
+    }) => StoreValue_alias_4 | void>;
+    reportIssue: LifecycleIssueReporter;
+    warn: (message: string) => void;
+}) => StoreValue_alias_4 | typeof MIDDLEWARE_ABORT;
+
+declare const runMiddlewareForStore: (name: string, payload: {
+    action: string;
+    prev: StoreValue;
+    next: StoreValue;
+    path: unknown;
+}) => StoreValue | typeof MIDDLEWARE_ABORT;
+export { runMiddlewareForStore }
+export { runMiddlewareForStore as runMiddlewareForStore_alias_1 }
+
+declare const runSchemaValidation: (schema: unknown, value: unknown) => {
+    ok: boolean;
+    data?: unknown;
+    error?: unknown;
+};
+export { runSchemaValidation }
+export { runSchemaValidation as runSchemaValidation_alias_1 }
+
+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;
+
+declare const runStoreHookSafe: (name: string, label: "onCreate" | "onSet" | "onReset" | "onDelete", fn: ((...args: any[]) => void) | undefined, args: any[]) => void;
+export { runStoreHookSafe }
+export { runStoreHookSafe as runStoreHookSafe_alias_1 }
+
+export declare const runTestResets: () => void;
+
+declare const runValidation: (name: string, value: StoreValue, validate: ValidateOption | undefined, onError?: (message: string) => void) => {
+    ok: true;
+    value: StoreValue;
+} | {
+    ok: false;
+};
+export { runValidation }
+export { runValidation as runValidation_alias_1 }
+
+export declare const runWithRegistry: <T>(registry: StoreRegistry, fn: () => T) => T;
+
+declare const sanitize: (value: unknown) => unknown;
+export { sanitize }
+export { sanitize as sanitize_alias_1 }
+
+declare const sanitizeValue: (name: string, value: unknown, onError?: (message: string) => void, options?: {
+    reuseInput?: boolean;
+}) => {
+    ok: true;
+    value: StoreValue;
+} | {
+    ok: false;
+};
+export { sanitizeValue }
+export { sanitizeValue as sanitizeValue_alias_1 }
+
+export declare const scheduleRatePrune: (delayMs?: number) => void;
+
+export declare type SchemaValidateOption = {
+    safeParse: (value: unknown) => {
+        success: true;
+        data: unknown;
+    } | {
+        success: false;
+        error?: unknown;
+    };
+} | {
+    parse: (value: unknown) => unknown;
+} | {
+    validateSync: (value: unknown) => unknown;
+} | {
+    isValidSync: (value: unknown) => boolean;
+} | {
+    validate: (value: unknown) => unknown;
+};
+
+declare type SelectorSubscriber = (value: StoreValue | null) => void;
+
+export declare const sendDevtools: ({ name, action, force, devtools, enabled, stores, applyRedactor, }: {
+    name: string;
+    action: string;
+    force?: boolean;
+    devtools: any;
+    enabled: boolean;
+    stores: Record<string, StoreValue_alias_4>;
+    applyRedactor: (value: StoreValue_alias_4) => StoreValue_alias_4;
+}) => void;
+
+declare const setByPath: <T extends Record<string, unknown> | unknown[]>(obj: T, path: PathInput, value: unknown) => T;
+export { setByPath }
+export { setByPath as setByPath_alias_1 }
+
+export declare const setComputedOrderResolver: (next: ComputedOrderResolver | null) => void;
+
+export declare const setFeatureRegistrationHook: (hook: ((name: FeatureName, factory: StoreFeatureFactory) => void) | null) => void;
+
+export declare const setInflightEntry: (cacheSlot: string, entry: InflightEntry) => void;
+
+export declare const setNamespace: (ns: string) => void;
+
+export declare function setPathCacheInvalidator(fn: (name: string) => void): void;
+
+export declare const setPersistPresence: (persistWatchState: PersistWatchState, name: string, present: boolean) => void;
+
+export declare const setRegistryContext: (scope: string, registry: StoreRegistry) => void;
+
+export declare const setRegistryScope: (scope: string) => void;
+
+declare function setStore<Name extends string, State, P extends Path<State>>(name: StoreDefinition<Name, State>, path: P, value: PathValue<State, P>): WriteResult;
+
+declare function setStore<Name extends string, State>(name: StoreDefinition<Name, State>, mutator: (draft: State) => void): WriteResult;
+
+declare function setStore<Name extends string, State>(name: StoreDefinition<Name, State>, data: PartialDeep<State>): WriteResult;
+
+declare function setStore<Name extends string, State, P extends Path<State>>(name: StoreKey<Name, State>, path: P, value: PathValue<State, P>): WriteResult;
+
+declare function setStore<Name extends string, State>(name: StoreKey<Name, State>, mutator: (draft: State) => void): WriteResult;
+
+declare function setStore<Name extends string, State>(name: StoreKey<Name, State>, data: PartialDeep<State>): WriteResult;
+
+declare function setStore<Name extends StoreName, P extends StorePathFor<Name>>(name: Name, path: P, value: StorePathValueFor<Name, P>): WriteResult;
+
+declare function setStore<Name extends StoreName>(name: Name, mutator: (draft: StateFor<Name>) => void): WriteResult;
+
+declare function setStore<Name extends StoreName>(name: Name, data: PartialDeep<StateFor<Name>>): WriteResult;
+export { setStore }
+export { setStore as setStore_alias_1 }
+export { setStore as setStore_alias_2 }
+export { setStore as setStore_alias_3 }
+export { setStore as setStore_alias_4 }
+
+declare const setStoreBatch: (fn: () => unknown) => void;
+export { setStoreBatch }
+export { setStoreBatch as setStoreBatch_alias_1 }
+export { setStoreBatch as setStoreBatch_alias_2 }
+
+declare const setStoreValueInternal: (name: string, value: StoreValue) => void;
+export { setStoreValueInternal }
+export { setStoreValueInternal as setStoreValueInternal_alias_1 }
+
+declare const setupPersistWatch: ({ name, persistConfig, persistWatchState, }: {
+    name: string;
+    persistConfig: PersistConfig | null | undefined;
+    persistWatchState: PersistWatchState;
+}) => void;
+export { setupPersistWatch }
+export { setupPersistWatch as setupPersistWatch_alias_1 }
+
+export declare const setupSync: ({ name, syncOption, syncChannels, syncClocks, syncVersions, syncWindowCleanup, instanceId, getMeta, getAcceptedSyncVersion, getStoreValue, hasStoreEntry, notify, validate, reportStoreError, warn, setStoreValue, normalizeIncomingState, acceptIncomingSyncVersion, resolveSyncVersion, broadcastSync, }: {
+    name: string;
+    syncOption?: boolean | SyncOptions;
+    syncChannels: SyncChannels;
+    syncClocks: SyncClocks;
+    syncVersions: SyncVersions;
+    syncWindowCleanup: SyncWindowCleanup;
+    instanceId: string;
+    getMeta: (name: string) => SyncMeta | undefined;
+    getAcceptedSyncVersion: (name: string) => SyncVersion | undefined;
+    getStoreValue: (name: string) => StoreValue_alias_4;
+    hasStoreEntry: (name: string) => boolean;
+    notify: (name: string) => void;
+    validate: (name: string, next: StoreValue_alias_4) => {
+        ok: boolean;
+        value?: StoreValue_alias_4;
+    };
+    reportStoreError: (name: string, message: string) => void;
+    warn: (message: string) => void;
+    setStoreValue: (name: string, value: StoreValue_alias_4) => void;
+    normalizeIncomingState: (name: string, value: StoreValue_alias_4) => StoreValue_alias_4 | null;
+    acceptIncomingSyncVersion: (name: string, updatedAtMs: number, incomingClock: number, source: string) => void;
+    resolveSyncVersion: (name: string, updatedAtMs: number, incomingClock: number) => number;
+    broadcastSync: (name: string) => void;
+}) => void;
+
+declare const shallowClone: <T>(value: T) => T;
+export { shallowClone }
+export { shallowClone as shallowClone_alias_1 }
+
+declare const shallowEqual: (a: unknown, b: unknown) => boolean;
+export { shallowEqual }
+export { shallowEqual as shallowEqual_alias_1 }
+
+export declare const shapeWarned: Set<string>;
+
+export declare const shouldUseCache: (cacheSlot: string, ttl?: number) => boolean;
+
+declare const snapshotCache: Record<string, {
+    version: number;
+    snapshot: StoreValue | null;
+}>;
+export { snapshotCache }
+export { snapshotCache as snapshotCache_alias_1 }
+
+declare type SnapshotMode = "deep" | "shallow" | "ref";
+export { SnapshotMode }
+export { SnapshotMode as SnapshotMode_alias_1 }
+
+export declare const stageTransactionValue: (name: string, value: StoreValue) => void;
+
+declare type StateFor<Name extends string> = Name extends keyof RegisteredStoreMap ? RegisteredStoreMap[Name] : StoreValue;
+export { StateFor }
+export { StateFor as StateFor_alias_1 }
+export { StateFor as StateFor_alias_2 }
+export { StateFor as StateFor_alias_3 }
+export { StateFor as StateFor_alias_4 }
+
+/**
+ * Helper to get an auto-completable, literal-typed store handle without creating it.
+ *
+ * Example:
+ *   const user = store("user");
+ *   setStore(user, "name", "Alex");
+ */
+declare const store: <Name extends string, State = StoreValue>(name: Name) => StoreKey<Name, State>;
+export { store }
+export { store as store_alias_1 }
+export { store as store_alias_2 }
+
+declare const storeAdmin: {
+    deleteExistingStore: (name: string) => void;
+    clearAllStores: () => string[];
+    clearStores: (pattern?: string) => string[];
+    reportStoreError: (name: string, message: string) => void;
+};
+export { storeAdmin }
+export { storeAdmin as storeAdmin_alias_1 }
+
+export declare const storeCleanupFns: Record<string, Set<() => void>>;
+
+declare interface StoreDefinition<Name extends string = string, State = StoreValue> {
+    name: Name;
+    state?: State;
+}
+export { StoreDefinition }
+export { StoreDefinition as StoreDefinition_alias_1 }
+export { StoreDefinition as StoreDefinition_alias_2 }
+export { StoreDefinition as StoreDefinition_alias_3 }
+export { StoreDefinition as StoreDefinition_alias_4 }
+
+declare type StoreFeatureFactory = () => StoreFeatureRuntime;
+export { StoreFeatureFactory }
+export { StoreFeatureFactory as StoreFeatureFactory_alias_1 }
+
+declare interface StoreFeatureMeta {
+    createdAt: string;
+    updatedAt: string;
+    updatedAtMs: number;
+    updateCount: number;
+    version: number;
+    metrics: FeatureMetrics;
+    options: NormalizedOptions;
+}
+export { StoreFeatureMeta }
+export { StoreFeatureMeta as StoreFeatureMeta_alias_1 }
+
+declare interface StoreFeatureRuntime {
+    onStoreCreate?: (ctx: FeatureCreateContext) => void;
+    onStoreWrite?: (ctx: FeatureWriteContext) => void;
+    beforeStoreDelete?: (ctx: FeatureDeleteContext) => void;
+    afterStoreDelete?: (ctx: FeatureDeleteContext) => void;
+    resetAll?: () => void;
+    api?: DevtoolsFeatureApi;
+}
+export { StoreFeatureRuntime }
+export { StoreFeatureRuntime as StoreFeatureRuntime_alias_1 }
+
+declare type StoreKey<Name extends string = string, State = StoreValue> = StoreDefinition<Name, State> & {
+    __store?: true;
+};
+export { StoreKey }
+export { StoreKey as StoreKey_alias_1 }
+export { StoreKey as StoreKey_alias_2 }
+export { StoreKey as StoreKey_alias_3 }
+export { StoreKey as StoreKey_alias_4 }
+
+declare type StoreName = (keyof RegisteredStoreMap & string) | BrandedStoreName;
+export { StoreName }
+export { StoreName as StoreName_alias_1 }
+export { StoreName as StoreName_alias_2 }
+export { StoreName as StoreName_alias_3 }
+export { StoreName as StoreName_alias_4 }
+
+declare const storeNameBrand: unique symbol;
+
+declare interface StoreOptions<State = StoreValue_alias_4> {
+    scope?: StoreScope;
+    lazy?: boolean;
+    /**
+     * Allow `setStore(name, path, value)` to create missing **leaf** keys on object nodes.
+     *
+     * Default: `false` (strict path writes).
+     *
+     * Notes:
+     * - Does not expand arrays (out-of-bounds indices are still rejected).
+     * - Does not create missing intermediate objects for deep paths; define the shape up-front.
+     */
+    pathCreate?: boolean;
+    validate?: ValidateOption<State>;
+    persist?: boolean | string | PersistOptions<State>;
+    devtools?: boolean | DevtoolsOptions<State>;
+    lifecycle?: LifecycleOptions<State>;
+    middleware?: Array<(ctx: MiddlewareCtx) => StoreValue_alias_4 | void>;
+    onSet?: (prev: State, next: State) => void;
+    onReset?: (prev: State, next: State) => void;
+    onDelete?: (prev: State) => void;
+    onCreate?: (initial: State) => void;
+    onError?: (err: string) => void;
+    /** @deprecated use validate instead */
+    validator?: (next: State) => boolean;
+    /** @deprecated use validate instead */
+    schema?: unknown;
+    migrations?: Record<number, (state: State) => State>;
+    version?: number;
+    redactor?: (state: State) => State;
+    historyLimit?: number;
+    allowSSRGlobalStore?: boolean;
+    sync?: boolean | SyncOptions;
+    /**
+     * Optional feature option bag for third-party plugins.
+     * Keys are plugin names, values are plugin-specific options.
+     */
+    features?: FeatureOptions;
+    /**
+     * Snapshot cloning strategy used by subscriptions and selector snapshots.
+     *
+     * - "deep" (default): deep clone and dev-freeze snapshot values.
+     * - "shallow": shallow clone (top-level) only; nested references are shared.
+     * - "ref": return the live store reference (no cloning).
+     */
+    snapshot?: SnapshotMode;
+}
+export { StoreOptions }
+export { StoreOptions as StoreOptions_alias_1 }
+export { StoreOptions as StoreOptions_alias_2 }
+
+declare type StorePathFor<Name extends StoreName> = IsStoreNameLoose extends true ? string | string[] : Path<StateFor<Name>>;
+
+declare type StorePathValueFor<Name extends StoreName, P extends StorePathFor<Name>> = IsStoreNameLoose extends true ? unknown : (P extends Path<StateFor<Name>> ? PathValue<StateFor<Name>, P> : never);
+
+export declare 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;
+    notify: NotifyState;
+};
+
+declare const stores: Record<string, unknown>;
+export { stores }
+export { stores as stores_alias_1 }
+
+export declare type StoreScope = "request" | "global" | "temp";
+
+declare type StoreSnapshot<T> = T extends object ? Readonly<T> : T;
+
+declare type StoreSnapshot_2<T> = T extends object ? Readonly<T> : T;
+
+declare type StoreSnapshot_3<T> = T extends object ? Readonly<T> : T;
+
+declare interface StoreStateMap {
+}
+export { StoreStateMap }
+export { StoreStateMap as StoreStateMap_alias_1 }
+export { StoreStateMap as StoreStateMap_alias_2 }
+export { StoreStateMap as StoreStateMap_alias_3 }
+export { StoreStateMap as StoreStateMap_alias_4 }
+
+declare type StoreTarget = StoreDefinition<string, unknown> | StoreKey<string, unknown> | StoreName;
+
+declare type StoreValue = unknown;
+export { StoreValue as SelectorStoreValue }
+export { StoreValue }
+export { StoreValue as StoreValue_alias_1 }
+export { StoreValue as StoreValue_alias_2 }
+export { StoreValue as StoreValue_alias_3 }
+export { StoreValue as StoreValue_alias_5 }
+
+export declare type StoreValue_alias_4 = unknown;
+
+declare interface StrictStoreMap {
+}
+export { StrictStoreMap }
+export { StrictStoreMap as StrictStoreMap_alias_1 }
+export { StrictStoreMap as StrictStoreMap_alias_2 }
+export { StrictStoreMap as StrictStoreMap_alias_3 }
+export { StrictStoreMap as StrictStoreMap_alias_4 }
+
+declare type StroidConfig = {
+    logSink?: LogSink;
+    flush?: FlushConfig;
+    revalidateOnFocus?: RevalidateOnFocusConfig;
+    namespace?: string;
+    strictMissingFeatures?: boolean;
+    strictFeatures?: boolean;
+    assertRuntime?: boolean;
+    strictMutatorReturns?: boolean;
+    asyncAutoCreate?: boolean;
+    asyncCloneResult?: AsyncCloneMode;
+    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_alias_4 | 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.
+     * You can pass the produce function directly or use "immer" with a global produce shim.
+     */
+    mutatorProduce?: (<T>(base: T, recipe: (draft: T) => void) => T) | "immer";
+};
+export { StroidConfig }
+export { StroidConfig as StroidConfig_alias_1 }
+
+/** @deprecated Use subscribeStore instead. */
+declare const subscribe: (name: string, fn: Subscriber) => (() => void);
+export { subscribe }
+export { subscribe as subscribe_alias_1 }
+
+/** @deprecated Use subscribeStore instead. */
+declare const subscribeInternal: (name: string, fn: Subscriber) => (() => void);
+export { subscribeInternal as _subscribe }
+export { subscribeInternal }
+
+declare type Subscriber = (value: StoreValue | null) => void;
+export { Subscriber }
+export { Subscriber as Subscriber_alias_1 }
+
+declare const subscribers: Record<string, Set<Subscriber>>;
+export { subscribers }
+export { subscribers as subscribers_alias_1 }
+
+export declare const subscribeSelectorStore: (name: string, fn: SelectorSubscriber) => (() => void);
+
+declare const subscribeStore: (name: string, fn: Subscriber) => (() => void);
+export { subscribeStore }
+export { subscribeStore as subscribeStore_alias_1 }
+export { subscribeStore as subscribeStore_alias_2 }
+
+declare const subscribeWithSelector: <R>(name: string, selector: (state: any) => R, equality: ((a: R, b: R) => boolean) | undefined, listener: (next: R, prev: R) => void) => (() => void);
+export { subscribeWithSelector }
+export { subscribeWithSelector as subscribeWithSelector_alias_1 }
+
+declare const suggestStoreName: (name: string, existingNames: string[]) => void;
+export { suggestStoreName }
+export { suggestStoreName as suggestStoreName_alias_1 }
+
+declare const SUPPORTED_TYPES: readonly ["object", "array", "string", "number", "boolean", "null"];
+
+declare type SupportedType = typeof SUPPORTED_TYPES[number] | "function" | "map" | "set" | "date" | "undefined" | "bigint" | "symbol";
+export { SupportedType }
+export { SupportedType as SupportedType_alias_1 }
+
+export declare const swrKey: (storeName: StoreTarget, cacheKey?: string | number) => (string | number)[];
+
+export declare type SyncChannels = Record<string, BroadcastChannel>;
+
+export declare type SyncClocks = Record<string, number>;
+
+export declare type SyncMessage = {
+    v: number;
+    protocol: number;
+    type: "sync-request" | "sync-state";
+    name: string;
+    clock: number;
+    source: string;
+    updatedAt?: number;
+    data?: StoreValue_alias_4;
+    checksum?: number | null;
+    auth?: unknown;
+    token?: string;
+    requestedAt?: number;
+};
+
+declare type SyncMeta = {
+    updatedAt: string;
+    updatedAtMs?: number;
+    updateCount: number;
+    options: {
+        sync?: boolean | SyncOptions;
+    };
+};
+
+declare interface SyncOptions {
+    channel?: string;
+    maxPayloadBytes?: number;
+    /**
+     * Optional shared token for lightweight cross-tab authentication.
+     * When set, incoming sync messages without a matching token are rejected.
+     */
+    authToken?: string;
+    conflictResolver?: (args: {
+        local: StoreValue_alias_4;
+        incoming: StoreValue_alias_4;
+        localUpdated: number;
+        incomingUpdated: number;
+    }) => StoreValue_alias_4 | void;
+    /**
+     * Optional checksum mode for sync payloads.
+     * - "hash" (default): include a checksum of the payload.
+     * - "none": skip checksum generation.
+     */
+    checksum?: "hash" | "none";
+    /**
+     * Optional signer for sync payloads. The returned value is attached to the message as `auth`.
+     */
+    sign?: (payload: SyncMessage) => unknown;
+    /**
+     * Optional verifier for incoming sync payloads.
+     * Return true to accept the message, false to reject it.
+     */
+    verify?: (payload: SyncMessage) => boolean;
+    /**
+     * Optional resolver for updatedAt timestamps when conflicts are resolved.
+     */
+    resolveUpdatedAt?: (args: {
+        localUpdated: number;
+        incomingUpdated: number | undefined;
+        now: number;
+    }) => number;
+}
+export { SyncOptions }
+export { SyncOptions as SyncOptions_alias_1 }
+export { SyncOptions as SyncOptions_alias_2 }
+
+export declare type SyncVersion = {
+    clock: number;
+    updatedAt: number;
+    source: string;
+};
+
+export declare type SyncVersions = Record<string, SyncVersion>;
+
+export declare type SyncWindowCleanup = Record<string, () => void>;
+
+export declare const throwAsyncUsageError: (name: string, message: string, onError?: (message: string) => void) => never;
+
+declare type TransactionSnapshotEntry = {
+    source: RegistryStoreValue | null | undefined;
+    snapshot: RegistryStoreValue | null;
+    mode: TransactionSnapshotMode;
+};
+
+declare type TransactionSnapshotMode = "deep" | "shallow" | "ref";
+
+export declare type TransactionState = {
+    depth: number;
+    pending: Array<() => void>;
+    stagedValues: Map<string, RegistryStoreValue>;
+    snapshotCache: Map<string, TransactionSnapshotEntry>;
+    failed: boolean;
+    error?: Error;
+};
+
+export declare const tryDedupeRequest: (name: string, cacheSlot: string, transform: FetchOptions["transform"] | undefined, onError?: (message: string) => void) => Promise<unknown> | null | undefined;
+
+export declare const unregisterComputed: (name: string) => void;
+
+declare type UnregisteredStoreName<Name extends string> = never;
+export { UnregisteredStoreName }
+export { UnregisteredStoreName as UnregisteredStoreName_alias_1 }
+
+export declare const unregisterStoreCleanup: (name: string, fn: () => void) => void;
+
+declare function useAsyncStore<Name extends string, State extends AsyncStoreState>(name: StoreDefinition<Name, State> | StoreKey<Name, State>): AsyncStoreSnapshot<AsyncDataFor<State>>;
+
+declare function useAsyncStore<Name extends StoreName>(name: Name): AsyncStoreSnapshot<AsyncDataFor<StateFor<Name>>>;
+export { useAsyncStore }
+export { useAsyncStore as useAsyncStore_alias_1 }
+
+declare function useAsyncStoreSuspense<Name extends string, State extends AsyncStoreState, T = AsyncDataFor<State>>(name: StoreDefinition<Name, State> | StoreKey<Name, State>, input?: FetchInput, options?: FetchOptions): T;
+
+declare function useAsyncStoreSuspense<Name extends StoreName, T = AsyncDataFor<StateFor<Name>>>(name: Name, input?: FetchInput, options?: FetchOptions): T;
+export { useAsyncStoreSuspense }
+export { useAsyncStoreSuspense as useAsyncStoreSuspense_alias_1 }
+
+declare function useFormStore<Name extends string, State, P extends Path<State>>(storeName: StoreDefinition<Name, State> | StoreKey<Name, State>, field: P): {
+    value: StoreSnapshot_3<PathValue<State, P>> | null;
+    onChange: (eOrValue: any) => void;
+};
+
+declare function useFormStore<Name extends StoreName, P extends Path<StateFor<Name>>>(storeName: Name, field: P): {
+    value: StoreSnapshot_3<PathValue<StateFor<Name>, P>> | null;
+    onChange: (eOrValue: any) => void;
+};
+export { useFormStore }
+export { useFormStore as useFormStore_alias_1 }
+
+declare const useRegistry: (scopeId: string) => void;
+export { useRegistry }
+export { useRegistry as useRegistry_alias_1 }
+export { useRegistry as useRegistry_alias_2 }
+export { useRegistry as useRegistry_alias_3 }
+
+export declare const usesDefaultPersistCrypto: (fn: (v: string) => string) => boolean;
+
+declare function useSelector<Name extends string, State, R>(storeName: StoreDefinition<Name, State> | StoreKey<Name, State>, selectorFn: (state: StoreSnapshot_2<State>) => R, equalityFn?: (a: R, b: R) => boolean): R | null;
+
+declare function useSelector<Name extends StoreName, R>(storeName: Name, selectorFn: (state: StoreSnapshot_2<StateFor<Name>>) => R, equalityFn?: (a: R, b: R) => boolean): R | null;
+export { useSelector }
+export { useSelector as useSelector_alias_1 }
+
+declare function useStore<Name extends string, State, P extends Path<State>>(name: StoreDefinition<Name, State>, path: P): StoreSnapshot_2<PathValue<State, P>> | null;
+
+declare function useStore<Name extends string, State>(name: StoreDefinition<Name, State>, path?: undefined): StoreSnapshot_2<State> | null;
+
+declare function useStore<Name extends string, State, R>(name: StoreDefinition<Name, State>, selector: (state: StoreSnapshot_2<State>) => R, equalityFn?: (a: R, b: R) => boolean): R | null;
+
+declare function useStore<Name extends string, State, P extends Path<State>>(name: StoreKey<Name, State>, path: P): StoreSnapshot_2<PathValue<State, P>> | null;
+
+declare function useStore<Name extends string, State>(name: StoreKey<Name, State>, path?: undefined): StoreSnapshot_2<State> | null;
+
+declare function useStore<Name extends string, State, R>(name: StoreKey<Name, State>, selector: (state: StoreSnapshot_2<State>) => R, equalityFn?: (a: R, b: R) => boolean): R | null;
+
+declare function useStore<Name extends StoreName, P extends Path<StateFor<Name>>>(name: Name, path: P): StoreSnapshot_2<PathValue<StateFor<Name>, P>> | null;
+
+declare function useStore<Name extends StoreName>(name: Name, path?: undefined): StoreSnapshot_2<StateFor<Name>> | null;
+
+declare function useStore<Name extends StoreName, R>(name: Name, selector: (state: StoreSnapshot_2<StateFor<Name>>) => R, equalityFn?: (a: R, b: R) => boolean): R | null;
+export { useStore }
+export { useStore as useStore_alias_1 }
+
+declare function useStoreField<Name extends string, State, P extends Path<State>>(storeName: StoreDefinition<Name, State> | StoreKey<Name, State>, field: P): StoreSnapshot_2<PathValue<State, P>> | null;
+
+declare function useStoreField<Name extends StoreName, P extends Path<StateFor<Name>>>(storeName: Name, field: P): StoreSnapshot_2<PathValue<StateFor<Name>, P>> | null;
+export { useStoreField }
+export { useStoreField as useStoreField_alias_1 }
+
+declare function useStoreStatic<Name extends string, State, P extends Path<State>>(name: StoreDefinition<Name, State> | StoreKey<Name, State>, path: P): StoreSnapshot_2<PathValue<State, P>> | null;
+
+declare function useStoreStatic<Name extends string, State>(name: StoreDefinition<Name, State> | StoreKey<Name, State>, path?: undefined): StoreSnapshot_2<State> | null;
+
+declare function useStoreStatic<Name extends StoreName, P extends Path<StateFor<Name>>>(name: Name, path: P): StoreSnapshot_2<PathValue<StateFor<Name>, P>> | null;
+
+declare function useStoreStatic<Name extends StoreName>(name: Name, path?: undefined): StoreSnapshot_2<StateFor<Name>> | null;
+export { useStoreStatic }
+export { useStoreStatic as useStoreStatic_alias_1 }
+
+export declare const validateCryptoPair: (name: string, encrypt: (v: string) => string, decrypt: (v: string) => string) => {
+    ok: boolean;
+    reason?: string;
+};
+
+declare const validateDepth: (path: PathInput) => boolean;
+export { validateDepth }
+export { validateDepth as validateDepth_alias_1 }
+
+export declare type ValidateFn<State = StoreValue_alias_4> = (next: State) => boolean | State;
+
+export declare type ValidateOption<State = StoreValue_alias_4> = ValidateFn<State> | SchemaValidateOption;
+
+declare const validatePathSafety: (storeName: string, base: StoreValue, path: PathInput, nextValue: unknown) => {
+    ok: boolean;
+    reason?: string;
+};
+export { validatePathSafety }
+export { validatePathSafety as validatePathSafety_alias_1 }
+
+declare const warn: (msg: string, meta?: Record<string, unknown>) => void;
+export { warn }
+export { warn as warn_alias_1 }
+
+declare const warnAlways: (msg: string, meta?: Record<string, unknown>) => void;
+export { warnAlways }
+export { warnAlways as warnAlways_alias_1 }
+
+declare const warnMissingFeature: (storeName: string, featureName: FeatureName, onError?: (message: string) => void) => void;
+export { warnMissingFeature }
+export { warnMissingFeature as warnMissingFeature_alias_1 }
+
+export declare const withMockedTime: <T>(nowMs: number, fn: () => T) => T;
+
+declare type WriteResult = {
+    ok: true;
+} | {
+    ok: false;
+    reason: "not-found" | "validate" | "path" | "middleware" | "ssr" | "invalid-args";
+};
+export { WriteResult }
+export { WriteResult as WriteResult_alias_1 }
+export { WriteResult as WriteResult_alias_2 }
+export { WriteResult as WriteResult_alias_3 }
+export { WriteResult as WriteResult_alias_4 }
+
+export { }