stroid 0.1.2 → 0.1.3

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";

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

@@ -1,16 +0,0 @@
-/**
- * @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/store-admin-impl.d.ts

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

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

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

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

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

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

@@ -1,19 +0,0 @@
-import { MIDDLEWARE_ABORT } from "../../features/lifecycle.js";
-import { type FeatureHookContext } 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 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

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

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

@@ -1,67 +0,0 @@
-/**
- * @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";
-};
-export type Subscriber = (value: StoreValue | null) => void;
-export {};

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

@@ -1,53 +0,0 @@
-/**
- * @module store-lifecycle/validation
- *
- * LAYER: Store lifecycle
- * OWNS:  Module-level behavior and exports for store-lifecycle/validation.
- *
- * Consumers: Internal imports and public API.
- */
-import { type SupportedType, PathInput } from "../../utils.js";
-import { type ValidateOption } from "../../adapters/options.js";
-import type { StoreValue } from "./types.js";
-type PathSafetyVerdict = {
-    ok: true;
-} | {
-    ok: false;
-    reason: string;
-};
-type PathValidationCacheNode = {
-    children: Map<string, PathValidationCacheNode>;
-    verdicts?: Map<SupportedType, PathSafetyVerdict>;
-};
-export declare const pathValidationCache: Map<string, PathValidationCacheNode>;
-export declare const resetPathValidationCache: (registry: object) => void;
-export declare const validatePathSafety: (storeName: string, base: StoreValue, path: PathInput, nextValue: unknown) => {
-    ok: boolean;
-    reason?: string;
-};
-export declare const sanitizeValue: (name: string, value: unknown, onError?: (message: string) => void, options?: {
-    reuseInput?: boolean;
-}) => {
-    ok: true;
-    value: StoreValue;
-} | {
-    ok: false;
-};
-export declare const runValidation: (name: string, value: StoreValue, validate: ValidateOption | undefined, onError?: (message: string) => void) => {
-    ok: true;
-    value: StoreValue;
-} | {
-    ok: false;
-};
-export declare const normalizeCommittedState: (name: string, value: unknown, validate: ValidateOption | undefined, onError?: (message: string) => void, options?: {
-    reuseInput?: boolean;
-}) => {
-    ok: true;
-    value: StoreValue;
-} | {
-    ok: false;
-};
-export declare const invalidatePathCache: (name: string) => void;
-export declare const clearPathValidationCache: () => void;
-export declare const materializeInitial: (name: string, registry?: import("../store-registry.js").StoreRegistry) => boolean;
-export {};

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

@@ -1,28 +0,0 @@
-/**
- * @module store-name
- *
- * LAYER: Store runtime
- * OWNS:  Module-level behavior and exports for store-name.
- *
- * Consumers: Internal imports and public API.
- */
-import type { StoreKey, StoreValue } from "./store-lifecycle/types.js";
-import type { StoreOptions } from "../adapters/options.js";
-import type { NonFunction } from "../types/utility.js";
-/**
- * Helper to get an auto-completable, literal-typed store handle without creating it.
- *
- * Example:
- *   const user = store("user");
- *   setStore(user, "name", "Alex");
- */
-export declare const store: <Name extends string, State = StoreValue>(name: Name) => StoreKey<Name, State>;
-export declare const namespace: (ns: string) => {
-    store: <Name extends string, State = unknown>(name: Name) => StoreKey<Name, State>;
-    create: <Name extends string, State>(name: Name, data: NonFunction<State>, options?: StoreOptions<State>) => import("./store-lifecycle/types.js").StoreDefinition<string, State> | undefined;
-    createStrict: <Name extends string, State>(name: Name, data: NonFunction<State>, options?: StoreOptions<State>) => import("./store-lifecycle/types.js").StoreDefinition<string, State>;
-    set: (name: any, ...rest: any[]) => any;
-    get: (name: any, ...rest: any[]) => any;
-    delete: (name: string) => void;
-    reset: (name: string) => import("./store-lifecycle/types.js").WriteResult;
-};

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

@@ -1,12 +0,0 @@
-import type { StoreValue, Subscriber } from "./store-lifecycle/types.js";
-export declare const notify: (name: string) => void;
-export declare const setStoreBatch: (fn: () => unknown) => void;
-export declare const subscribeStore: (name: string, fn: Subscriber) => (() => void);
-/** @deprecated Use subscribeStore instead. */
-export declare const subscribeInternal: (name: string, fn: Subscriber) => (() => void);
-/** @deprecated Use subscribeStore instead. */
-export declare const subscribe: (name: string, fn: Subscriber) => (() => void);
-export declare const getStoreSnapshot: (name: string) => StoreValue | null;
-/** @deprecated Use getStoreSnapshot instead. */
-export declare const getSnapshot: (name: string) => StoreValue | null;
-export declare const resetNotifyStateForTests: () => void;

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

@@ -1,18 +0,0 @@
-import { hasStoreEntryInternal, getStoreValueRef } from "./store-lifecycle/registry.js";
-import { getFeatureApi } from "./store-lifecycle/identity.js";
-import type { Path, PathValue, StoreDefinition, StoreValue, StoreKey, StoreName, StateFor } from "./store-lifecycle/types.js";
-import type { FeatureMetrics } from "../features/feature-registry.js";
-type StoreSnapshot<T> = T extends object ? Readonly<T> : T;
-export declare function getStore<Name extends string, State, P extends Path<State>>(name: StoreDefinition<Name, State>, path: P): StoreSnapshot<PathValue<State, P>> | null;
-export declare function getStore<Name extends string, State>(name: StoreDefinition<Name, State>, path?: undefined): StoreSnapshot<State> | null;
-export declare function getStore<Name extends string, State, P extends Path<State>>(name: StoreKey<Name, State>, path: P): StoreSnapshot<PathValue<State, P>> | null;
-export declare function getStore<Name extends string, State>(name: StoreKey<Name, State>, path?: undefined): StoreSnapshot<State> | null;
-export declare function getStore<Name extends StoreName, P extends Path<StateFor<Name>>>(name: Name, path: P): StoreSnapshot<PathValue<StateFor<Name>, P>> | null;
-export declare function getStore<Name extends StoreName>(name: Name, path?: undefined): StoreSnapshot<StateFor<Name>> | null;
-export declare const hasStore: (name: string) => boolean;
-export declare const isLazyStore: (name: string) => boolean;
-export declare const isStoreMaterialized: (name: string) => boolean;
-export declare const isLazyPending: (name: string) => boolean;
-export { hasStoreEntryInternal as _hasStoreEntryInternal, getStoreValueRef as _getStoreValueRef, getFeatureApi as _getFeatureApi };
-export declare const getInitialState: () => Record<string, StoreValue>;
-export declare const getMetrics: (name: string) => FeatureMetrics | null;

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

@@ -1,108 +0,0 @@
-/**
- * @module store-registry
- *
- * LAYER: Store runtime
- * OWNS:  Module-level behavior and exports for store-registry.
- *
- * Consumers: Internal imports and public API.
- */
-import { type FeatureName, type StoreFeatureMeta, type StoreFeatureRuntime } from "../features/feature-registry.js";
-import type { AsyncRegistry } from "../async/registry.js";
-export type RegistryStoreValue = unknown;
-export type RegistrySubscriber = (value: RegistryStoreValue | null) => void;
-export type RegistrySnapshotEntry = {
-    version: number;
-    snapshot: RegistryStoreValue | null;
-    source?: RegistryStoreValue | null;
-    mode?: "deep" | "shallow" | "ref";
-};
-export type StoreLifecycleEvent = {
-    type: "created";
-    name: string;
-    isGlobal: boolean;
-    isTemp: boolean;
-} | {
-    type: "deleted";
-    name: string;
-};
-export type StoreLifecycleListener = (event: StoreLifecycleEvent) => void;
-export type TransactionState = {
-    depth: number;
-    pending: Array<() => void>;
-    stagedValues: Map<string, RegistryStoreValue>;
-    snapshotCache: Map<string, TransactionSnapshotEntry>;
-    failed: boolean;
-    error?: Error;
-};
-type TransactionSnapshotMode = "deep" | "shallow" | "ref";
-type TransactionSnapshotEntry = {
-    source: RegistryStoreValue | null | undefined;
-    snapshot: RegistryStoreValue | null;
-    mode: TransactionSnapshotMode;
-};
-export type ComputedEntry = {
-    deps: string[];
-    compute: (...args: unknown[]) => unknown;
-    stale: boolean;
-};
-export type NotifyState = {
-    pendingNotifications: Set<string>;
-    pendingBuffer: string[];
-    orderedNames: string[];
-    subscriberBuffer: RegistrySubscriber[];
-    notifyScheduled: boolean;
-    batchDepth: number;
-    flushId: number;
-    isFlushing: boolean;
-};
-export type RegistryScope = "default" | "request";
-export type StoreRegistry = {
-    scope: RegistryScope;
-    stores: Record<string, RegistryStoreValue>;
-    subscribers: Record<string, Set<RegistrySubscriber>>;
-    initialStates: Record<string, RegistryStoreValue>;
-    initialFactories: Record<string, (() => RegistryStoreValue) | undefined>;
-    metaEntries: Record<string, StoreFeatureMeta>;
-    snapshotCache: Record<string, RegistrySnapshotEntry>;
-    featureRuntimes: Map<FeatureName, StoreFeatureRuntime>;
-    deletingStores: Set<string>;
-    computedEntries: Record<string, ComputedEntry>;
-    computedDependents: Record<string, Set<string>>;
-    computedCleanups: Map<string, () => void>;
-    transaction: TransactionState;
-    async: AsyncRegistry;
-    notify: NotifyState;
-    lifecycleListener: StoreLifecycleListener | null;
-};
-export declare const initializeRegistryFeatureRuntimes: (registry: StoreRegistry) => void;
-export declare const normalizeStoreRegistryScope: (scope: string) => string;
-export declare const defaultRegistryScope: string;
-export declare const getDefaultStoreRegistry: () => StoreRegistry;
-export declare const setRegistryScope: (scope: string) => void;
-export declare const clearRegistryScopeOverrideForTests: () => void;
-export declare const createTransactionState: () => TransactionState;
-export declare const createStoreRegistry: (scope?: RegistryScope) => StoreRegistry;
-export declare const getStoreRegistry: (scope: string) => StoreRegistry;
-export declare const hasStoreEntry: (registry: StoreRegistry, name: string) => boolean;
-export declare const isStoreDeleting: (registry: StoreRegistry, name: string) => boolean;
-export declare const clearStoreRegistries: (registry: StoreRegistry) => void;
-export declare const setLifecycleListener: (registry: StoreRegistry, listener: StoreLifecycleListener | null) => void;
-export declare const emitLifecycleEvent: (registry: StoreRegistry, event: StoreLifecycleEvent) => void;
-export declare const resetAllStoreRegistriesForTests: () => void;
-export type CarrierContext = Record<string, unknown>;
-export interface CarrierRunner {
-    run<T>(carrier: CarrierContext, fn: () => T): T;
-    get(): CarrierContext | null;
-}
-export declare const injectCarrierRunner: (runner: CarrierRunner) => void;
-export declare const getRequestCarrier: () => CarrierContext | null;
-export interface RegistryRunner {
-    run<T>(registry: StoreRegistry, fn: () => T): T;
-    get(): StoreRegistry | null;
-    enterWith?: (registry: StoreRegistry) => void;
-}
-export declare const injectRegistryRunner: (runner: RegistryRunner) => void;
-export declare const runWithRegistry: <T>(registry: StoreRegistry, fn: () => T) => T;
-export declare const getActiveStoreRegistry: (fallback?: StoreRegistry) => StoreRegistry;
-export declare const enterRegistry: (registry: StoreRegistry) => void;
-export {};

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

@@ -1,11 +0,0 @@
-import type { StoreDefinition, StoreKey, StoreName, StateFor, WriteResult } from "./store-lifecycle/types.js";
-import type { StoreRegistry } from "./store-registry.js";
-import type { WriteContext } from "../internals/write-context.js";
-import { type CommitAction } from "./store-write-shared.js";
-export declare function replaceStore<Name extends string, State>(name: StoreDefinition<Name, State>, value: State): WriteResult;
-export declare function replaceStore<Name extends string, State>(name: StoreKey<Name, State>, value: State): WriteResult;
-export declare function replaceStore<Name extends StoreName>(name: Name, value: StateFor<Name>): WriteResult;
-export declare const replaceStoreState: (registry: StoreRegistry, name: string, data: unknown, action?: CommitAction, context?: WriteContext | null) => {
-    ok: boolean;
-    reason?: string;
-};

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

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

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

@@ -1,13 +0,0 @@
-import type { PartialDeep, Path, PathValue, StoreDefinition, StoreValue, StoreKey, StoreName, StateFor, WriteResult } from "./store-lifecycle/types.js";
-import type { WriteContext } from "../internals/write-context.js";
-type KeyOrData = StoreValue | string | string[] | Record<string, unknown> | ((draft: any) => void);
-type IsStoreNameLoose = string extends StoreName ? true : false;
-type StoreUpdate<State> = State | Partial<State> | PartialDeep<State> | ((draft: State) => void);
-type StoreTarget<Name extends string = string, State = StoreValue> = StoreDefinition<Name, State> | StoreKey<Name, State> | StoreName;
-type StorePathForTarget<T> = T extends StoreDefinition<any, infer S> ? Path<S> : T extends StoreKey<any, infer S> ? Path<S> : (IsStoreNameLoose extends true ? string | string[] : (T extends StoreName ? Path<StateFor<T>> : string | string[]));
-type StorePathValueForTarget<T, P> = T extends StoreDefinition<any, infer S> ? (P extends Path<S> ? PathValue<S, P> : never) : T extends StoreKey<any, infer S> ? (P extends Path<S> ? PathValue<S, P> : never) : (IsStoreNameLoose extends true ? unknown : (T extends StoreName ? (P extends Path<StateFor<T>> ? PathValue<StateFor<T>, P> : never) : unknown));
-type StoreUpdateForTarget<T> = T extends StoreDefinition<any, infer S> ? StoreUpdate<S> : T extends StoreKey<any, infer S> ? StoreUpdate<S> : (IsStoreNameLoose extends true ? StoreUpdate<StoreValue> : (T extends StoreName ? StoreUpdate<StateFor<T>> : StoreUpdate<StoreValue>));
-export declare function setStore<T extends StoreTarget, P extends StorePathForTarget<T>>(name: T, path: P, value: StorePathValueForTarget<T, P>): WriteResult;
-export declare function setStore<T extends StoreTarget>(name: T, update: StoreUpdateForTarget<T>): WriteResult;
-export declare const setStoreWithContext: (name: string | StoreDefinition<string, StoreValue>, keyOrData: KeyOrData, value: unknown, context: WriteContext | null) => WriteResult;
-export {};

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

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

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

@@ -1,13 +0,0 @@
-/**
- * @module store-shared/core
- *
- * LAYER: Shared types
- * OWNS:  Minimal interfaces shared across layers.
- *
- * Consumers: Internal modules (async-cache, adapters).
- */
-export interface IStoreCore<T = any> {
-    get(path?: string): T | null;
-    set(path: string, value: any): void;
-    subscribe(cb: (val: T | null) => void): () => void;
-}

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

@@ -1,12 +0,0 @@
-/**
- * @module store-shared/notify
- *
- * LAYER: Shared types
- * OWNS:  Notification handler indirection for layer decoupling.
- *
- * Consumers: store-write, store-create, store-notify.
- */
-type NotifyHandler = (name: string) => void;
-export declare const registerNotifyHandler: (handler: NotifyHandler | null) => (() => void);
-export declare const notifyStore: (name: string) => void;
-export {};

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

@@ -1,26 +0,0 @@
-/**
- * @module store-transaction
- *
- * LAYER: Store runtime
- * OWNS:  Module-level behavior and exports for store-transaction.
- *
- * Consumers: Internal imports and public API.
- */
-import type { StoreValue } from "./store-lifecycle/types.js";
-import { type StoreRegistry, type TransactionState } from "./store-registry.js";
-export type TransactionRunner = {
-    run: <T>(state: TransactionState, fn: () => T) => T;
-    get: () => TransactionState | null;
-    enterWith?: (state: TransactionState) => void;
-};
-export declare const injectTransactionRunner: (runner: TransactionRunner | null) => void;
-export declare const beginTransaction: (registry?: StoreRegistry) => StoreRegistry;
-export declare const isTransactionActive: () => boolean;
-export declare const markTransactionFailed: (err?: unknown, registry?: StoreRegistry) => void;
-export declare const registerTransactionCommit: (fn: () => void) => void;
-export declare const stageTransactionValue: (name: string, value: StoreValue) => void;
-export declare const getStagedTransactionValue: (name: string) => {
-    has: boolean;
-    value: StoreValue | undefined;
-};
-export declare const endTransaction: (err?: unknown, registry?: StoreRegistry) => Error | null;