stroid 0.1.0 → 0.1.1

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

@@ -1,247 +0,0 @@
-export type StoreValue = 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;
-    /**
-     * 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;
-    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;
-}
-export 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;
-        incoming: StoreValue;
-        localUpdated: number;
-        incomingUpdated: number;
-    }) => StoreValue | 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 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;
-    /**
-     * 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 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;
-    snapshot: SnapshotMode;
-    explicitPersist: boolean;
-    explicitSync: boolean;
-    explicitDevtools: boolean;
-}
-export declare const resetLegacyOptionDeprecationWarningsForTests: () => void;
-export declare const normalizePersistOptions: <State>(persist: StoreOptions<State>["persist"], name: string) => PersistConfig | null;
-export declare const collectLegacyOptionDeprecationWarnings: <State>(option: StoreOptions<State>) => string[];
-export declare const normalizeStoreOptions: <State>(option: StoreOptions<State> | undefined, name: string) => NormalizedOptions;

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

@@ -1,2 +0,0 @@
-import type { FetchOptions } from "../async-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/inflight.d.ts

@@ -1,13 +0,0 @@
-import type { FetchOptions } from "../async-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/request.d.ts

@@ -1,3 +0,0 @@
-import type { FetchOptions } from "../async-cache.js";
-export declare const buildFetchOptions: (options: FetchOptions) => RequestInit;
-export declare const parseResponseBody: (response: Response, responseType: FetchOptions["responseType"]) => Promise<unknown>;

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

@@ -1,57 +0,0 @@
-import type { FetchOptions } from "./async-registry.js";
-export type { FetchOptions, AsyncStateSnapshot, AsyncStateAdapter } from "./async-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 getActiveAsyncRegistry: () => import("./async-registry.js").AsyncRegistry;
-export declare const fetchRegistry: Record<string, {
-    kind: "url";
-    url: string;
-    options: FetchOptions;
-} | {
-    kind: "factory";
-    factory: () => string | Promise<unknown>;
-    options: FetchOptions;
-}>;
-export declare const inflight: Partial<Record<string, {
-    promise: Promise<unknown>;
-    raw: Promise<unknown>;
-    transform?: FetchOptions["transform"];
-}>>;
-export declare const requestVersion: Record<string, number>;
-export declare const cacheMeta: Record<string, {
-    timestamp: number;
-    expiresAt: number | null;
-    data: unknown;
-}>;
-export declare const rateWindowStart: Record<string, number>;
-export declare const rateCount: Record<string, number>;
-export declare const ratePruneState: {
-    lastAt: number;
-};
-export declare const cleanupSubs: Record<string, () => void>;
-export declare const storeCleanupFns: Record<string, Set<() => void>>;
-export declare const revalidateHandlers: Record<string, () => void>;
-export declare const noSignalWarned: Set<string>;
-export declare const shapeWarned: Set<string>;
-export declare const autoCreateWarned: Set<string>;
-export declare const revalidateKeys: Set<string>;
-export declare const asyncMetrics: {
-    cacheHits: number;
-    cacheMisses: number;
-    dedupes: number;
-    requests: number;
-    failures: number;
-    avgMs: number;
-    lastMs: number;
-};
-export declare const markWarned: (set: Set<string>, key: string) => 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) => void;
-export declare const unregisterStoreCleanup: (name: string, fn: () => void) => void;
-export declare const ensureCleanupSubscription: (name: string) => void;

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

@@ -1,37 +0,0 @@
-import { type StoreDefinition, type StoreKey, type StoreName } from "./store-lifecycle.js";
-import { type FetchInput, type FetchOptions } from "./async-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-registry.d.ts

@@ -1,96 +0,0 @@
-export type AsyncStateSnapshot = {
-    data?: unknown;
-    loading: boolean;
-    error: string | null;
-    status: "idle" | "loading" | "success" | "error" | "aborted";
-    cached?: boolean;
-    revalidating?: boolean;
-};
-export type AsyncStateAdapter = (ctx: {
-    name: string;
-    prev: unknown;
-    next: AsyncStateSnapshot;
-    set: (value: unknown | ((draft: any) => void)) => void;
-}) => 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";
-    /**
-     * 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;
-    noSignalWarned: Set<string>;
-    shapeWarned: Set<string>;
-    autoCreateWarned: 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;
-    };
-};
-export declare const createAsyncRegistry: () => AsyncRegistry;
-export declare const resetAsyncRegistry: (registry: AsyncRegistry) => void;
-export {};

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,2 +0,0 @@
-export type { FetchOptions, FetchInput, AsyncStateSnapshot, AsyncStateAdapter } from "./async-cache.js";
-export { fetchStore, refetchStore, enableRevalidateOnFocus, getAsyncMetrics, _resetAsyncStateForTests, } from "./async-fetch.js";

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

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

package/dist/types/computed.d.ts

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

package/dist/types/config.d.ts

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

package/dist/types/core.d.ts

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

package/dist/types/devfreeze.d.ts

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

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

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

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

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

package/dist/types/index.d.ts

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

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

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