stroid 0.1.3 → 0.1.4

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

@@ -0,0 +1,117 @@
+/**
+ * @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>;
+    requestSequence: 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

@@ -0,0 +1,11 @@
+/**
+ * @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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,10 @@
+/**
+ * @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

@@ -0,0 +1,33 @@
+/**
+ * @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";
+import type { ComputedClassification, ComputedDescriptor, RuntimeGraph, RuntimeNodeId } from "./types.js";
+export declare const detectCycle: (name: string, deps: string[]) => string | null;
+export declare const registerComputed: (name: string, deps: string[], compute: (...args: unknown[]) => unknown, classification?: ComputedClassification) => 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 getComputedDescriptor: (nodeId: RuntimeNodeId) => ComputedDescriptor | null;
+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;
+export declare const getRuntimeComputedGraph: () => RuntimeGraph;
+export declare const evaluateComputedFromSnapshot: (nodeId: RuntimeNodeId, snapshot: Record<string, unknown>) => unknown;

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

@@ -0,0 +1,21 @@
+import "../core/store-notify.js";
+import type { StoreRegistry } from "../core/store-registry.js";
+import type { StoreDefinition, StoreKey, StoreName, StateFor, StoreValue } from "../core/store-lifecycle/types.js";
+import type { ComputedClassification } from "./types.js";
+export type ComputedOptions = {
+    autoDispose?: boolean;
+    onError?: (err: unknown) => void;
+    classification?: ComputedClassification;
+};
+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 shouldAutoDisposeComputed: (name: string, registry?: StoreRegistry) => boolean;
+export declare const _resetComputedForTests: () => void;
+export { getFullComputedGraph, getComputedDepsFor, getComputedDescriptor, getRuntimeComputedGraph, evaluateComputedFromSnapshot, } from "./computed-graph.js";
+export type { ComputedClassification, ComputedDescriptor, RuntimeEdgeType, RuntimeGraph, RuntimeGraphEdge, RuntimeGraphGranularity, RuntimeGraphNode, RuntimeNodeId, RuntimeNodeType, } from "./types.js";

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

@@ -0,0 +1,40 @@
+/**
+ * @module computed/types
+ *
+ * LAYER: Module
+ * OWNS:  Shared public and internal computed graph types.
+ *
+ * Consumers: Computed registry, runtime tools, and PSR surface.
+ */
+export type RuntimeNodeId = string;
+export type RuntimePathSegment = string | number;
+export type RuntimeGraphGranularity = "store";
+export type RuntimeNodeType = "leaf" | "computed" | "async-boundary";
+export type RuntimeEdgeType = "leaf-input" | "computed-input";
+export interface RuntimeGraphNode {
+    id: RuntimeNodeId;
+    storeId: string;
+    path: readonly RuntimePathSegment[];
+    type: RuntimeNodeType;
+    estimatedCost?: number;
+}
+export interface RuntimeGraphEdge {
+    from: RuntimeNodeId;
+    to: RuntimeNodeId;
+    type: RuntimeEdgeType;
+}
+export interface RuntimeGraph {
+    granularity: RuntimeGraphGranularity;
+    nodes: readonly RuntimeGraphNode[];
+    edges: readonly RuntimeGraphEdge[];
+}
+export type ComputedClassification = "deterministic" | "opaque" | "asyncBoundary";
+export interface ComputedDescriptor {
+    id: RuntimeNodeId;
+    storeId: string;
+    path: readonly RuntimePathSegment[];
+    dependencies: readonly RuntimeNodeId[];
+    nodeType: Extract<RuntimeNodeType, "computed" | "async-boundary">;
+    classification: ComputedClassification;
+    asyncBoundary?: boolean;
+}

package/dist/types/config.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @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

@@ -0,0 +1,11 @@
+/**
+ * @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";

package/dist/types/core/lifecycle-hooks.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @module core/lifecycle-hooks
+ *
+ * LAYER: Core utilities
+ * OWNS:  Cross-cutting lifecycle hooks without dependencies on other modules.
+ *
+ * Consumers: notification/*, async-cache.ts, internals/store-admin.ts
+ */
+export type LifecycleHookEvent = {
+    type: string;
+    [key: string]: unknown;
+};
+export type LifecycleHook = (storeId: string, event: LifecycleHookEvent) => void;
+export declare const registerHook: (name: string, fn: LifecycleHook) => (() => void);
+export declare const hasHook: (name: string) => boolean;
+export declare const fireHook: (name: string, storeId: string, event: LifecycleHookEvent) => void;

package/dist/types/core/runtime-patch.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @module runtime-patch
+ *
+ * LAYER: Store runtime
+ * OWNS:  Canonical serializable patch model and write-lowering helpers.
+ *
+ * Consumers: store-set-impl, store-replace-impl, store-admin-impl, store-hydrate-impl.
+ */
+import { type PathInput } from "../utils.js";
+import type { WriteContext } from "../internals/write-context.js";
+import type { StoreRegistry } from "./store-registry.js";
+export type RuntimePatchOp = "set" | "merge" | "delete" | "insert";
+export type RuntimePatchSource = "setStore" | "replaceStore" | "resetStore" | "hydrateStores";
+export type RuntimePatchPath = readonly (string | number)[];
+export type RuntimePatchPathInput = PathInput | RuntimePatchPath | Array<string | number>;
+export interface RuntimePatchMeta {
+    timestamp: number;
+    source: RuntimePatchSource;
+    causedBy?: readonly string[];
+    isUnsafe?: boolean;
+    asyncBoundary?: boolean;
+}
+export interface RuntimePatch {
+    id: string;
+    store: string;
+    path: RuntimePatchPath;
+    op: RuntimePatchOp;
+    value?: unknown;
+    meta: RuntimePatchMeta;
+}
+export type SetStorePatchIntent = {
+    kind: "root";
+} | {
+    kind: "merge";
+    value: unknown;
+} | {
+    kind: "path";
+    path: RuntimePatchPathInput;
+    value: unknown;
+};
+export declare const normalizeRuntimePatchPath: (path?: RuntimePatchPathInput | null) => RuntimePatchPath;
+export declare const createRuntimePatch: (options: {
+    store: string;
+    op: RuntimePatchOp;
+    path?: RuntimePatchPathInput | null;
+    value?: unknown;
+    source: RuntimePatchSource;
+    timestamp?: number;
+    context?: WriteContext | null;
+    isUnsafe?: boolean;
+    asyncBoundary?: boolean;
+}) => RuntimePatch;
+export declare const createRootSetRuntimePatch: (options: {
+    store: string;
+    value: unknown;
+    source: RuntimePatchSource;
+    context?: WriteContext | null;
+}) => RuntimePatch;
+export declare const createCanonicalSetStorePatches: (options: {
+    store: string;
+    intent: SetStorePatchIntent;
+    committedValue: unknown;
+    preserveIntent: boolean;
+    context?: WriteContext | null;
+}) => RuntimePatch[];
+export declare const setLastRuntimePatches: (patches: readonly RuntimePatch[], registry?: StoreRegistry) => void;
+export declare const getLastRuntimePatches: (registry?: StoreRegistry) => readonly RuntimePatch[];

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

@@ -0,0 +1,9 @@
+import type { StoreDefinition, StoreKey, StoreName, WriteResult } from "./store-lifecycle/types.js";
+export declare function deleteStore<Name extends string, State>(name: StoreDefinition<Name, State>): void;
+export declare function deleteStore<Name extends string, State>(name: StoreKey<Name, State>): void;
+export declare function deleteStore<Name extends StoreName>(name: Name): void;
+export declare function resetStore<Name extends string, State>(name: StoreDefinition<Name, State>): WriteResult;
+export declare function resetStore<Name extends string, State>(name: StoreKey<Name, State>): WriteResult;
+export declare function resetStore<Name extends StoreName>(name: Name): WriteResult;
+export declare const clearAllStores: () => void;
+export declare const _hardResetAllStoresForTest: () => void;

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

@@ -0,0 +1,9 @@
+/**
+ * @module store-admin
+ *
+ * LAYER: Store runtime
+ * OWNS:  Public delete/reset/clear exports.
+ *
+ * Consumers: store-write barrel.
+ */
+export { deleteStore, resetStore, clearAllStores, _hardResetAllStoresForTest, } from "./store-admin-impl.js";

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

@@ -0,0 +1,13 @@
+/**
+ * @module store-core
+ *
+ * LAYER: Store core
+ * OWNS:  Minimal core adapters and registry accessors.
+ *
+ * Consumers: Internal async modules.
+ */
+import type { StoreRegistry } from "./store-registry.js";
+import type { IStoreCore } from "./store-shared/core.js";
+export declare const getActiveRegistry: () => StoreRegistry;
+export declare const getActiveAsyncRegistry: () => StoreRegistry["async"];
+export declare const createStoreCore: <T = any>(name: string) => IStoreCore<T>;

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

@@ -0,0 +1,16 @@
+import { type StoreOptions } from "../adapters/options.js";
+import type { NonFunction } from "../types/utility.js";
+import type { StoreDefinition } from "./store-lifecycle/types.js";
+type LazyDisallow<T> = T extends {
+    lazy: true;
+} ? never : T;
+export declare const clearSsrGlobalAllowWarned: (name?: string) => void;
+export declare function createStore<Name extends string, State>(name: Name, initialData: () => State, option: StoreOptions<State> & {
+    lazy: true;
+}): StoreDefinition<Name, State> | undefined;
+export declare function createStore<Name extends string, State, Opt extends StoreOptions<State>>(name: Name, initialData: NonFunction<State>, option?: LazyDisallow<Opt>): StoreDefinition<Name, State> | undefined;
+export declare function createStoreStrict<Name extends string, State>(name: Name, initialData: () => State, option: StoreOptions<State> & {
+    lazy: true;
+}): StoreDefinition<Name, State>;
+export declare function createStoreStrict<Name extends string, State, Opt extends StoreOptions<State>>(name: Name, initialData: NonFunction<State>, option?: LazyDisallow<Opt>): StoreDefinition<Name, State>;
+export {};

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

@@ -0,0 +1,35 @@
+import { type StoreOptions } from "../adapters/options.js";
+import type { StoreStateMap, StrictStoreMap, HydrateSnapshotFor, HydrationResult } from "./store-lifecycle/types.js";
+type HydrateSnapshot = HydrateSnapshotFor<StoreStateMap & StrictStoreMap>;
+type HydrateOptions<Snapshot extends object> = Partial<{
+    [K in keyof Snapshot]: StoreOptions<Snapshot[K]>;
+}> & {
+    default?: StoreOptions;
+};
+type HydrationTrustBase<Snapshot extends object> = {
+    /**
+     * Explicitly trust this snapshot and allow hydration.
+     */
+    allowTrusted?: boolean;
+    /**
+     * Alias for allowTrusted.
+     */
+    allowHydration?: boolean;
+    /**
+     * @deprecated Use allowTrusted instead.
+     */
+    allowUntrusted?: boolean;
+    validate?: (snapshot: Snapshot) => boolean;
+    onValidationError?: (error: unknown, snapshot: Snapshot) => boolean;
+};
+type HydrationTrust<Snapshot extends object> = (HydrationTrustBase<Snapshot> & {
+    allowTrusted: true;
+}) | (HydrationTrustBase<Snapshot> & {
+    allowHydration: true;
+}) | (HydrationTrustBase<Snapshot> & {
+    allowUntrusted: true;
+}) | (HydrationTrustBase<Snapshot> & {
+    validate: (snapshot: Snapshot) => boolean;
+});
+export declare const hydrateStores: <Snapshot extends object = HydrateSnapshot>(snapshot: Snapshot, options: HydrateOptions<Snapshot> | undefined, trust: HydrationTrust<Snapshot>) => HydrationResult;
+export {};

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

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

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

@@ -0,0 +1,20 @@
+import { MIDDLEWARE_ABORT } from "../../features/lifecycle.js";
+import { type FeatureHookContext, type FeatureName } from "../../features/feature-registry.js";
+import type { NormalizedOptions } from "../../adapters/options.js";
+import type { StoreValue } from "./types.js";
+export declare const clearFeatureContexts: () => void;
+export declare const createBaseFeatureContext: (name: string) => FeatureHookContext | null;
+export declare const runFeatureCreateHooks: (name: string, notify: (name: string) => void) => void;
+export declare const runFeatureWriteHooks: (name: string, action: string, prev: StoreValue, next: StoreValue, notify: (name: string) => void) => void;
+export declare const runFeatureWriteHooksExcept: (name: string, action: string, prev: StoreValue, next: StoreValue, notify: (name: string) => void, excluded: FeatureName[]) => void;
+export declare const runFeatureDeleteHooks: (name: string, prev: StoreValue, notify: (name: string) => void) => void;
+export declare const runMiddlewareForStore: (name: string, payload: {
+    action: string;
+    prev: StoreValue;
+    next: StoreValue;
+    path: unknown;
+    correlationId?: string;
+    traceContext?: import("../../types/utility.js").TraceContext;
+}) => StoreValue | typeof MIDDLEWARE_ABORT;
+export declare const runStoreHookSafe: (name: string, label: "onCreate" | "onSet" | "onReset" | "onDelete", fn: ((...args: any[]) => void) | undefined, args: any[]) => void;
+export declare const resolveFeatureAvailability: (name: string, options: NormalizedOptions) => NormalizedOptions;

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

@@ -0,0 +1,23 @@
+import { type IssueSeverity, type IssueVisibility } from "../../internals/reporting.js";
+import type { FeatureName } from "../../features/feature-registry.js";
+import type { StoreDefinition } from "./types.js";
+export declare const getSsrWarningIssued: (name?: string) => boolean;
+export declare const markSsrWarningIssued: (name: string) => void;
+export declare const resetSsrWarningFlag: () => void;
+export declare const qualifyName: (raw: string) => string;
+export declare const nameOf: (name: string | StoreDefinition<string, unknown>) => string;
+export declare const exists: (name: string) => boolean;
+export declare const reportStoreIssue: (name: string, message: string, options?: {
+    severity?: IssueSeverity;
+    visibility?: IssueVisibility;
+}) => void;
+export declare const reportStoreCreationIssue: (message: string, onError?: (message: string) => void, options?: {
+    severity?: IssueSeverity;
+    visibility?: IssueVisibility;
+}) => void;
+export declare const reportStoreWarning: (name: string, message: string, visibility?: IssueVisibility) => void;
+export declare const reportStoreCreationWarning: (message: string, onError?: (message: string) => void, visibility?: IssueVisibility) => void;
+export declare const reportStoreError: (name: string, message: string) => void;
+export declare const reportStoreCreationError: (message: string, onError?: (message: string) => void) => void;
+export declare const warnMissingFeature: (storeName: string, featureName: FeatureName, onError?: (message: string) => void) => void;
+export declare const getFeatureApi: (name: FeatureName) => import("../../features/feature-registry.js").DevtoolsFeatureApi | undefined;

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

@@ -0,0 +1,54 @@
+/**
+ * @module store-lifecycle/registry
+ *
+ * LAYER: Store lifecycle
+ * OWNS:  Module-level behavior and exports for store-lifecycle/registry.
+ *
+ * Consumers: Internal imports and public API.
+ */
+import { getStoreRegistry, type StoreRegistry, type StoreLifecycleEvent, type StoreLifecycleListener } from "../store-registry.js";
+import { type FeatureName, type StoreFeatureRuntime, type StoreFeatureMeta } from "../../features/feature-registry.js";
+import { createStoreAdmin } from "../../internals/store-admin.js";
+import type { StoreValue, Subscriber } from "./types.js";
+export { defaultRegistryScope } from "../store-registry.js";
+export type { StoreLifecycleEvent } from "../store-registry.js";
+export declare const setRegistryContext: (scope: string, registry: StoreRegistry) => void;
+export declare const getRegistry: () => StoreRegistry;
+export declare const onStoreLifecycle: (fn: StoreLifecycleListener | null) => (() => void);
+export declare const emitStoreLifecycle: (registry: StoreRegistry, event: StoreLifecycleEvent) => void;
+export declare function setPathCacheInvalidator(fn: (name: string) => void): void;
+export declare const stores: Record<string, unknown>;
+export declare const subscribers: Record<string, Set<Subscriber>>;
+export declare const initialStates: Record<string, unknown>;
+export declare const initialFactories: Record<string, (() => StoreValue) | undefined>;
+export declare const meta: Record<string, StoreFeatureMeta>;
+export declare const snapshotCache: Record<string, {
+    version: number;
+    snapshot: StoreValue | null;
+    source?: StoreValue | null;
+    mode?: "deep" | "shallow" | "ref";
+}>;
+export declare const featureRuntimes: Map<FeatureName, StoreFeatureRuntime<{}>>;
+export declare const storeAdmin: {
+    deleteExistingStore: (name: string) => void;
+    clearAllStores: () => string[];
+    clearStores: (pattern?: string) => string[];
+    reportStoreError: (name: string, message: string) => void;
+};
+export declare const getStoreAdmin: () => ReturnType<typeof createStoreAdmin>;
+export declare const getFeatureRuntime: (name: FeatureName) => StoreFeatureRuntime | undefined;
+export declare const initializeRegisteredFeatureRuntimes: () => void;
+export declare const hasStoreEntryInternal: (name: string, registry?: StoreRegistry) => boolean;
+export declare const getStoreValueRef: (name: string, registry?: StoreRegistry) => StoreValue | undefined;
+export declare const getCommittedStoreValueRef: (name: string, registry?: StoreRegistry) => StoreValue | undefined;
+export declare const setStoreValueInternal: (name: string, value: StoreValue, registry?: StoreRegistry) => void;
+export declare const applyFeatureState: (name: string, value: StoreValue, updatedAtMs?: number) => void;
+export declare const recordStoreRead: (name: string, registry?: StoreRegistry) => void;
+export declare const clearAllRegistries: () => void;
+export declare const resetFeaturesForTests: () => void;
+export declare const getMetaEntry: (name: string) => StoreFeatureMeta | undefined;
+export declare const isDeleting: (name: string) => boolean;
+export declare const resolveScope: (scopeOrRegistry?: string | ReturnType<typeof getStoreRegistry>) => {
+    scope: string;
+    registry: StoreRegistry;
+};

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

@@ -0,0 +1,67 @@
+/**
+ * @module store-lifecycle/types
+ *
+ * LAYER: Store lifecycle
+ * OWNS:  Module-level behavior and exports for store-lifecycle/types.
+ *
+ * Consumers: Internal imports and public API.
+ */
+type Primitive = string | number | boolean | bigint | symbol | null | undefined;
+type PrevDepth = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+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)];
+export type PathDepth<T, Depth extends number> = PathInternal<T, Depth>;
+export type Path<T, Depth extends number = 10> = PathInternal<T, Depth>;
+export 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 type PartialDeep<T> = T extends Primitive ? T : unknown extends T ? T : {
+    [K in keyof T]?: PartialDeep<T[K]>;
+};
+export type StoreValue = unknown;
+export type HydrateSnapshotFor<Map extends object> = Partial<{
+    [K in keyof Map & string]: Map[K];
+}>;
+export type HydrationFailureReason = "invalid-name" | "create-failed" | "merge-failed";
+export type HydrationFailure = {
+    name: string;
+    reason: HydrationFailureReason;
+    cause?: unknown;
+    received?: unknown;
+};
+export type HydrationBlockReason = "transaction" | "untrusted" | "validation-error" | "validation-failed";
+export type HydrationResult = {
+    hydrated: string[];
+    created: string[];
+    failed: HydrationFailure[];
+    blocked?: {
+        reason: HydrationBlockReason;
+        cause?: unknown;
+    };
+};
+export interface StoreStateMap {
+}
+export interface StrictStoreMap {
+}
+type RegisteredStoreMap = StoreStateMap & StrictStoreMap;
+declare const storeNameBrand: unique symbol;
+type BrandedStoreName = string & {
+    readonly [storeNameBrand]: true;
+};
+export type StoreName = (keyof RegisteredStoreMap & string) | BrandedStoreName;
+export type StateFor<Name extends string> = Name extends keyof RegisteredStoreMap ? RegisteredStoreMap[Name] : StoreValue;
+export type UnregisteredStoreName<Name extends string> = never;
+export type StoreKey<Name extends string = string, State = StoreValue> = StoreDefinition<Name, State> & {
+    __store?: true;
+};
+export interface StoreDefinition<Name extends string = string, State = StoreValue> {
+    name: Name;
+    state?: State;
+}
+export type WriteResult = {
+    ok: true;
+} | {
+    ok: false;
+    reason: "not-found" | "validate" | "path" | "middleware" | "ssr" | "invalid-args" | "lazy-uninitialized" | "unsupported-op" | "unsupported-path-shape";
+};
+export type Subscriber = (value: StoreValue | null) => void;
+export {};