stroid 0.1.2 → 0.1.4-beta.0

package/dist/types/adapters/options.d.ts

@@ -1,335 +0,0 @@
-import type { TraceContext } from "../types/utility.js";
-export type StoreValue = unknown;
-export interface FeatureOptionsMap {
-}
-export type FeatureOptions = Partial<FeatureOptionsMap> & Record<string, unknown>;
-export 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 type StoreScope = "request" | "global" | "temp";
-export type SnapshotMode = "deep" | "shallow" | "ref";
-export type ValidateFn<State = StoreValue> = (next: State) => boolean | State;
-export 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;
-};
-export type ValidateOption<State = StoreValue> = ValidateFn<State> | SchemaValidateOption;
-export interface PersistOptions<State = StoreValue> {
-    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;
-    /**
-     * Maximum allowed persisted payload size (in characters).
-     * When exceeded, hydration is skipped and an error is reported.
-     */
-    maxSize?: number;
-    /**
-     * 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 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;
-    maxSize?: number;
-    checksum: "hash" | "none" | "sha256";
-    onMigrationFail?: "reset" | "keep" | ((state: unknown) => unknown);
-    onStorageCleared?: (info: {
-        name: string;
-        key: string;
-        reason: "clear" | "remove" | "missing";
-    }) => void;
-}
-export interface MiddlewareCtx {
-    action: string;
-    name: string;
-    prev: StoreValue;
-    next: StoreValue;
-    path: unknown;
-    correlationId?: string;
-    traceContext?: TraceContext;
-}
-export interface SyncOptions {
-    channel?: string;
-    maxPayloadBytes?: number;
-    /**
-     * Authentication policy for sync.
-     * - "strict": require authToken or verify (blocks sync if missing)
-     * - "insecure": allow unauthenticated sync (explicit opt-out)
-     */
-    policy?: "strict" | "insecure";
-    /**
-     * Optional shared token for lightweight cross-tab authentication.
-     * When set, incoming sync messages without a matching token are rejected.
-     */
-    authToken?: string;
-    /**
-     * Explicitly allow unauthenticated sync.
-     * Deprecated in favor of policy: "insecure".
-     */
-    insecure?: boolean;
-    conflictResolver?: (args: {
-        local: StoreValue;
-        incoming: StoreValue;
-        localUpdated: number;
-        incomingUpdated: number;
-    }) => StoreValue | void;
-    /**
-     * Optional guard to prevent rapid feedback loops when sync updates trigger local reactions.
-     *
-     * - true: enable with a default window (100ms)
-     * - { windowMs }: customize the guard window in milliseconds
-     * - false: disable (default is enabled when sync is truthy)
-     */
-    loopGuard?: boolean | {
-        windowMs?: number;
-    };
-    /**
-     * 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 type SyncMessage = {
-    v: number;
-    protocol: number;
-    type: "sync-request" | "sync-state";
-    name: string;
-    clock: number;
-    source: string;
-    updatedAt?: number;
-    data?: StoreValue;
-    checksum?: number | null;
-    auth?: unknown;
-    token?: string;
-    requestedAt?: number;
-};
-export interface DevtoolsOptions<State = StoreValue> {
-    enabled?: boolean;
-    historyLimit?: number;
-    redactor?: (state: State) => State;
-}
-export interface LifecycleOptions<State = StoreValue> {
-    middleware?: Array<(ctx: MiddlewareCtx) => StoreValue | void>;
-    onSet?: (prev: State, next: State) => void;
-    onReset?: (prev: State, next: State) => void;
-    onDelete?: (prev: State) => void;
-    onCreate?: (initial: State) => void;
-}
-export interface StoreOptions<State = StoreValue> {
-    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 | 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 (dev-freeze by default).
-     */
-    snapshot?: SnapshotMode;
-    /**
-     * Safety policy for snapshot deliveries when using "ref" or "shallow" modes.
-     * - "warn": (default) log a warning in dev when mutation is detected.
-     * - "throw": throw an error in dev when mutation is detected.
-     * - "auto-clone": in dev, if a subscriber mutates a frozen snapshot, deliver a cloned
-     *   snapshot to that subscriber so the mutation does not affect other subscribers or the store.
-     */
-    snapshotSafety?: 'warn' | 'throw' | 'auto-clone';
-}
-export interface NormalizedOptions {
-    scope: StoreScope;
-    lazy: boolean;
-    pathCreate: boolean;
-    persist: PersistConfig | null;
-    devtools: boolean;
-    middleware: Array<(ctx: MiddlewareCtx) => StoreValue | void>;
-    onSet?: (prev: StoreValue, next: StoreValue) => void;
-    onReset?: (prev: StoreValue, next: StoreValue) => void;
-    onDelete?: (prev: StoreValue) => void;
-    onCreate?: (initial: StoreValue) => void;
-    onError?: (err: string) => void;
-    validate?: ValidateOption;
-    migrations: Record<number, (state: any) => any>;
-    version: number;
-    redactor?: (state: StoreValue) => StoreValue;
-    historyLimit: number;
-    allowSSRGlobalStore?: boolean;
-    sync?: boolean | SyncOptions;
-    features?: FeatureOptions;
-    snapshot: SnapshotMode;
-    /** normalized snapshotSafety value */
-    snapshotSafety?: 'warn' | 'throw' | 'auto-clone';
-    explicitPersist: boolean;
-    explicitSync: boolean;
-    explicitDevtools: boolean;
-}
-/**
- * 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;
-/**
- * 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;
-/**
- * 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[];
-/**
- * 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;

package/dist/types/async/cache.d.ts

@@ -1,39 +0,0 @@
-/**
- * @module async-cache
-*
-* LAYER: Module
-* OWNS:  Module-level behavior and exports for async-cache.
-*
-* Consumers: Internal imports and public API.
-*/
-import { getActiveAsyncRegistry } from "../core/store-core.js";
-export { getActiveAsyncRegistry } from "../core/store-core.js";
-import type { WarnCategory, StoreCleanupKind } from "./registry.js";
-export type { FetchOptions, AsyncStateSnapshot, AsyncStateAdapter, StoreCleanupKind } from "./registry.js";
-export type FetchInput = string | Promise<unknown> | (() => string | Promise<unknown>);
-export declare const MAX_CACHE_SLOTS_PER_STORE = 100;
-export declare const MAX_INFLIGHT_SLOTS_PER_STORE = 100;
-export declare const MAX_WARNED_ENTRIES = 1000;
-export declare const getFetchRegistry: () => ReturnType<typeof getActiveAsyncRegistry>["fetchRegistry"];
-export declare const getInflightRegistry: () => ReturnType<typeof getActiveAsyncRegistry>["inflight"];
-export declare const getRequestVersionRegistry: () => ReturnType<typeof getActiveAsyncRegistry>["requestVersion"];
-export declare const getCacheMeta: () => ReturnType<typeof getActiveAsyncRegistry>["cacheMeta"];
-export declare const getRateWindowStartRegistry: () => ReturnType<typeof getActiveAsyncRegistry>["rateWindowStart"];
-export declare const getRateCountRegistry: () => ReturnType<typeof getActiveAsyncRegistry>["rateCount"];
-export declare const getRatePruneState: () => ReturnType<typeof getActiveAsyncRegistry>["ratePruneState"];
-export declare const getRevalidateHandlers: () => ReturnType<typeof getActiveAsyncRegistry>["revalidateHandlers"];
-export declare const getStoreCleanups: () => ReturnType<typeof getActiveAsyncRegistry>["storeCleanups"];
-export declare const getWarnedOnce: () => ReturnType<typeof getActiveAsyncRegistry>["warnedOnce"];
-export declare const getRevalidateKeys: () => ReturnType<typeof getActiveAsyncRegistry>["revalidateKeys"];
-export declare const getAsyncMetrics: () => ReturnType<typeof getActiveAsyncRegistry>["asyncMetrics"];
-export declare const markWarned: (set: Set<string>, key: string) => void;
-export declare const warnOnce: (category: WarnCategory, key: string, onWarn: () => void) => void;
-export declare const cleanupStoreCleanupsByKind: (kind: StoreCleanupKind) => void;
-export declare const resetAsyncState: () => void;
-export declare const shouldUseCache: (cacheSlot: string, ttl?: number) => boolean;
-export declare const clearAsyncMeta: (name: string) => void;
-export declare const pruneAsyncCache: (name: string) => void;
-export declare const countInflightSlots: (name: string) => number;
-export declare const registerStoreCleanup: (name: string, fn: () => void, kind?: StoreCleanupKind) => void;
-export declare const unregisterStoreCleanup: (name: string, fn: () => void, kind?: StoreCleanupKind) => void;
-export declare const ensureCleanupSubscription: (_name: string) => void;

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

@@ -1,10 +0,0 @@
-/**
- * @module async/clone
- *
- * LAYER: Async subsystem
- * OWNS:  Module-level behavior and exports for async/clone.
- *
- * Consumers: Internal imports and public API.
- */
-import type { FetchOptions } from "./cache.js";
-export declare const cloneAsyncResult: (value: unknown, mode: FetchOptions["cloneResult"]) => unknown;

package/dist/types/async/errors.d.ts

@@ -1,3 +0,0 @@
-export declare const runAsyncHook: (name: string, label: "onSuccess" | "onError", fn: ((value: any) => void) | undefined, value: unknown) => void;
-export declare const reportAsyncUsageError: (name: string, message: string, onError?: (message: string) => void) => null;
-export declare const throwAsyncUsageError: (name: string, message: string, onError?: (message: string) => void) => never;

package/dist/types/async/fetch.d.ts

@@ -1,37 +0,0 @@
-import type { StoreDefinition, StoreKey, StoreName } from "../core/store-lifecycle/types.js";
-import { type FetchInput, type FetchOptions } from "./cache.js";
-export declare function fetchStore<Name extends string, State>(name: StoreDefinition<Name, State>, urlOrRequest: FetchInput, options?: FetchOptions): Promise<unknown>;
-export declare function fetchStore<Name extends string, State>(name: StoreKey<Name, State>, urlOrRequest: FetchInput, options?: FetchOptions): Promise<unknown>;
-export declare function fetchStore<Name extends StoreName>(name: Name, urlOrRequest: FetchInput, options?: FetchOptions): Promise<unknown>;
-export declare function refetchStore<Name extends string, State>(name: StoreDefinition<Name, State>): Promise<unknown>;
-export declare function refetchStore<Name extends string, State>(name: StoreKey<Name, State>): Promise<unknown>;
-export declare function refetchStore<Name extends StoreName>(name: Name): Promise<unknown>;
-export declare function enableRevalidateOnFocus<Name extends string, State>(name: StoreDefinition<Name, State>, overrides?: Partial<FetchOptions> & {
-    debounceMs?: number;
-    maxConcurrent?: number;
-    staggerMs?: number;
-    priority?: "high" | "normal";
-}): (() => void);
-export declare function enableRevalidateOnFocus<Name extends string, State>(name: StoreKey<Name, State>, overrides?: Partial<FetchOptions> & {
-    debounceMs?: number;
-    maxConcurrent?: number;
-    staggerMs?: number;
-    priority?: "high" | "normal";
-}): (() => void);
-export declare function enableRevalidateOnFocus<Name extends StoreName>(name?: Name | "*", overrides?: Partial<FetchOptions> & {
-    debounceMs?: number;
-    maxConcurrent?: number;
-    staggerMs?: number;
-    priority?: "high" | "normal";
-}): (() => void);
-export declare const getAsyncMetrics: () => {
-    cacheHits: number;
-    cacheMisses: number;
-    dedupes: number;
-    requests: number;
-    failures: number;
-    avgMs: number;
-    lastMs: number;
-};
-export declare const _resetAsyncStateForTests: () => void;
-export declare const cleanupAllRevalidateHandlers: () => void;

package/dist/types/async/inflight.d.ts

@@ -1,13 +0,0 @@
-import type { FetchOptions } from "./cache.js";
-export type InflightEntry = {
-    promise: Promise<unknown>;
-    raw: Promise<unknown>;
-    transform?: FetchOptions["transform"];
-};
-export declare const isCurrentRequest: (cacheSlot: string, version: number) => boolean;
-export declare const reserveRequestVersion: (cacheSlot: string) => number;
-export declare const clearRequestVersion: (cacheSlot: string, version: number) => void;
-export declare const setInflightEntry: (cacheSlot: string, entry: InflightEntry) => void;
-export declare const clearInflightEntry: (cacheSlot: string) => void;
-export declare const hasInflightEntry: (cacheSlot: string) => boolean;
-export declare const tryDedupeRequest: (name: string, cacheSlot: string, transform: FetchOptions["transform"] | undefined, onError?: (message: string) => void) => Promise<unknown> | null | undefined;

package/dist/types/async/rate.d.ts

@@ -1,5 +0,0 @@
-export declare const RATE_WINDOW_MS = 1000;
-export declare const RATE_MAX = 100;
-export declare const pruneRateCounters: (nowTs: number) => void;
-export declare const scheduleRatePrune: (delayMs?: number) => void;
-export declare const registerRateHit: (cacheSlot: string, nowTs: number) => boolean;

package/dist/types/async/registry.d.ts

@@ -1,116 +0,0 @@
-/**
- * @module async-registry
- *
- * LAYER: Module
- * OWNS:  Module-level behavior and exports for async-registry.
- *
- * Consumers: Internal imports and public API.
- */
-import type { TraceContext } from "../types/utility.js";
-export type AsyncStateSnapshot = {
-    data?: unknown;
-    loading: boolean;
-    error: string | null;
-    status: "idle" | "loading" | "success" | "error" | "aborted";
-    cached?: boolean;
-    revalidating?: boolean;
-    correlationId?: string;
-    traceContext?: TraceContext;
-};
-export type AsyncStateAdapter = (ctx: {
-    name: string;
-    prev: unknown;
-    next: AsyncStateSnapshot;
-    set: (value: unknown | ((draft: any) => void)) => void;
-}) => void;
-export type WarnCategory = "noSignal" | "shape" | "autoCreate" | "mutableResult";
-export type StoreCleanupKind = "store" | "revalidate";
-export type StoreCleanupBucket = Partial<Record<StoreCleanupKind, Set<() => void>>>;
-export 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";
-    /**
-     * Optional correlation ID for tracing async writes.
-     * When provided, it is propagated into store metadata and middleware context.
-     */
-    correlationId?: string;
-    /**
-     * Optional trace context (e.g. OpenTelemetry).
-     */
-    traceContext?: TraceContext;
-    /**
-     * 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";
-}
-type InflightEntry = {
-    promise: Promise<unknown>;
-    raw: Promise<unknown>;
-    transform?: FetchOptions["transform"];
-};
-export type AsyncRegistry = {
-    fetchRegistry: Record<string, {
-        kind: "url";
-        url: string;
-        options: FetchOptions;
-    } | {
-        kind: "factory";
-        factory: () => string | Promise<unknown>;
-        options: FetchOptions;
-    }>;
-    inflight: Partial<Record<string, InflightEntry>>;
-    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;
-    warnedOnce: Map<WarnCategory, Set<string>>;
-    storeCleanups: Record<string, StoreCleanupBucket>;
-    revalidateKeys: Set<string>;
-    revalidateHandlers: Record<string, () => void>;
-    asyncMetrics: {
-        cacheHits: number;
-        cacheMisses: number;
-        dedupes: number;
-        requests: number;
-        failures: number;
-        avgMs: number;
-        lastMs: number;
-    };
-};
-export declare const createAsyncRegistry: () => AsyncRegistry;
-export declare const resetAsyncRegistry: (registry: AsyncRegistry) => void;
-export {};

package/dist/types/async/request.d.ts

@@ -1,11 +0,0 @@
-/**
- * @module async/request
- *
- * LAYER: Async subsystem
- * OWNS:  Module-level behavior and exports for async/request.
- *
- * Consumers: Internal imports and public API.
- */
-import type { FetchOptions } from "./cache.js";
-export declare const buildFetchOptions: (options: FetchOptions) => RequestInit;
-export declare const parseResponseBody: (response: Response, responseType: FetchOptions["responseType"]) => Promise<unknown>;

package/dist/types/async/retry.d.ts

@@ -1,10 +0,0 @@
-export declare const MAX_RETRY_ATTEMPTS = 10;
-export declare const MIN_RETRY_DELAY_MS = 10;
-export declare const MAX_RETRY_DELAY_MS = 30000;
-export declare const MAX_RETRY_BACKOFF = 8;
-export declare const delay: (ms: number, signal?: AbortSignal) => Promise<void>;
-export declare const normalizeRetryOptions: (name: string, retry: number, retryDelay: number, retryBackoff: number) => {
-    retry: number;
-    retryDelay: number;
-    retryBackoff: number;
-};

package/dist/types/async.d.ts

@@ -1,10 +0,0 @@
-/**
- * @module async
- *
- * LAYER: Async subsystem
- * OWNS:  Module-level behavior and exports for async.
- *
- * Consumers: Internal imports and public API.
- */
-export type { FetchOptions, FetchInput, AsyncStateSnapshot, AsyncStateAdapter } from "./async/cache.js";
-export { fetchStore, refetchStore, enableRevalidateOnFocus, getAsyncMetrics, _resetAsyncStateForTests, } from "./async/fetch.js";

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

@@ -1,29 +0,0 @@
-/**
- * @module computed-graph
- *
- * LAYER: Module
- * OWNS:  Module-level behavior and exports for computed-graph.
- *
- * Consumers: Internal imports and public API.
- */
-import { type ComputedEntry } from "../core/store-registry.js";
-export declare const detectCycle: (name: string, deps: string[]) => string | null;
-export declare const registerComputed: (name: string, deps: string[], compute: (...args: unknown[]) => unknown) => boolean;
-export declare const unregisterComputed: (name: string) => void;
-export declare const markStale: (name: string) => void;
-export declare const isComputed: (name: string) => boolean;
-export declare const getComputedEntry: (name: string) => ComputedEntry | undefined;
-export declare const getTopoOrderedComputeds: (changedSources: string[]) => string[];
-export declare const getFullComputedGraph: () => {
-    nodes: string[];
-    edges: Array<{
-        from: string;
-        to: string;
-    }>;
-    dependencies: Record<string, string[]>;
-    dependents: Record<string, string[]>;
-};
-export declare const getComputedDepsFor: (name: string) => {
-    deps: string[];
-    dependents: string[];
-} | null;

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

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

package/dist/types/config.d.ts

@@ -1,10 +0,0 @@
-/**
- * @module config
- *
- * LAYER: Public API
- * OWNS:  Module-level behavior and exports for config.
- *
- * Consumers: Internal imports and public API.
- */
-export { configureStroid, resetConfig, registerMutatorProduce } from "./internals/config.js";
-export type { LogSink, StroidConfig, FlushConfig, RevalidateOnFocusConfig, } from "./internals/config.js";

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

@@ -1,11 +0,0 @@
-/**
- * @module core
- *
- * LAYER: Public API (minimal runtime)
- * OWNS:  Core store primitives only.
- *
- * Consumers: Bundle-size-sensitive consumers and explicit core usage.
- */
-export { createStore } from "./store-create.js";
-export { setStore, resetStore, deleteStore } from "./store-write.js";
-export { getStore, hasStore } from "./store-read.js";