stroid 0.1.4 → 0.1.5

package/dist/runtime-tools.d.ts

@@ -1,71 +1,44 @@
-import { StoreFeatureMeta } from './feature.js';
-import { getAsyncMetrics } from './async.js';
-import { RuntimeNodeId, ComputedDescriptor, RuntimeGraph } from './computed-types.js';
-export { ComputedClassification, RuntimeEdgeType, RuntimeGraphEdge, RuntimeGraphGranularity, RuntimeGraphNode, RuntimeNodeType } from './computed-types.js';
-import './options.js';
+export { C as ColdStoreReport, f as findColdStores, a as getInitialState, b as getMetrics, g as getStoreMeta, c as getSubscriberCount, l as listStores } from './core-internal.js';
+export { S as StoreHealthEntry, a as StoreHealthReport, g as getAsyncInflightCount, b as getPersistQueueDepth, c as getStoreHealth } from './async-internal.js';
+export { e as evaluateComputed, a as getComputedDeps, g as getComputedDescriptor, b as getComputedGraph, c as getRuntimeGraph } from './graph-D28.js';
+import { H as HydrationSnapshotMetadata, a as HydrationConsistencyAuthority, b as HydrationConsistencyPolicy, c as HydrationConsistencyResolution, d as HydrationConsistencySource, e as HydrationConsistencyMetrics, f as HydrationBootWindowMode, g as HydrationDriftEvent } from './types-internal-2.js';
+export { C as ComputedClassification, a as ComputedDescriptor, b as RuntimeEdgeType, R as RuntimeGraph, c as RuntimeGraphEdge, d as RuntimeGraphGranularity, e as RuntimeGraphNode, f as RuntimeNodeId, g as RuntimeNodeType } from './types-internal-3.js';
+import './feature.js';
+import './types-internal.js';
 import './utility.js';
-import './cache.js';
-import './types.js';
+import './metrics.js';
 import './registry.js';
 
-declare const listStores: (pattern?: string) => string[];
-declare const getStoreMeta: (name: string) => StoreFeatureMeta | null;
-declare const getInitialState: () => Record<string, unknown>;
-declare const getMetrics: (name: string) => StoreFeatureMeta["metrics"] | null;
-declare const getSubscriberCount: (name: string) => number;
-declare const getAsyncInflightCount: (name: string) => number;
-type ColdStoreReport = {
-    name: string;
-    createdAt: string;
-    lastReadAt: string | null;
-    updateCount: number;
-    readCount: number;
-    subscriberCount: number;
-    ageMs: number;
-    verdict: "cold" | "write-only" | "stale" | "active";
+type HydrationConsistencyReport = HydrationSnapshotMetadata & {
+    store: string;
+    authority: HydrationConsistencyAuthority;
+    policy: HydrationConsistencyPolicy;
+    hydratedAt: string;
+    hydratedAtMs: number;
+    firstDivergedAt: string | null;
+    firstDivergedAtMs: number | null;
+    lastDivergedAt: string | null;
+    lastDivergedAtMs: number | null;
+    lastResolution: HydrationConsistencyResolution | null;
+    lastSource: HydrationConsistencySource | null;
+    driftCount: number;
+    queuedWrites: number;
+    replayedWrites: number;
+    invalidatedAt: string | null;
+    invalidatedAtMs: number | null;
+    baselineHash: number;
+    currentHash: number;
+    baseline: unknown;
 };
-declare const findColdStores: (options?: {
-    unreadThresholdMs?: number;
-    includeWriteOnly?: boolean;
-}) => ColdStoreReport[];
-type StoreHealthEntry = {
-    name: string;
-    meta: StoreFeatureMeta | null;
-    metrics: StoreFeatureMeta["metrics"] | null;
-    async: {
-        inflight: number;
-        lastCorrelationId: string | null;
-        traceContext: StoreFeatureMeta["lastTraceContext"] | null;
-    };
-    persist: {
-        queueDepth: number;
-    };
+type HydrationDriftMetrics = HydrationConsistencyMetrics & {
+    pendingWrites: number;
+    bootWindowActive: boolean;
+    bootWindowMode: HydrationBootWindowMode | null;
+    bootWindowEndsAtMs: number | null;
+    manualCloseAvailable: boolean;
 };
-type StoreHealthReport = {
-    stores: StoreHealthEntry[];
-    async: ReturnType<typeof getAsyncMetrics>;
-    registry: {
-        totalStores: number;
-        coldStores: ColdStoreReport[];
-    };
-};
-declare const getStoreHealth: (name?: string) => StoreHealthEntry | StoreHealthReport | null;
-declare const getPersistQueueDepth: (name: string) => number;
-declare const getComputedGraph: () => {
-    nodes: string[];
-    edges: Array<{
-        from: string;
-        to: string;
-    }>;
-    dependencies: Record<string, string[]>;
-    dependents: Record<string, string[]>;
-};
-declare const getRuntimeGraph: () => RuntimeGraph;
-declare const getComputedDeps: (name: string) => {
-    deps: string[];
-    dependents: string[];
-} | null;
-declare const getComputedDescriptor: (nodeId: RuntimeNodeId) => ComputedDescriptor | null;
-declare const evaluateComputed: (nodeId: RuntimeNodeId, snapshot: Record<string, unknown>) => unknown;
+declare const getHydrationConsistency: (name?: string) => HydrationConsistencyReport | HydrationConsistencyReport[] | null;
+declare const getHydrationDriftEvents: (limit?: number) => HydrationDriftEvent[];
+declare const getHydrationDriftMetrics: () => HydrationDriftMetrics;
 
-export { type ColdStoreReport, ComputedDescriptor, RuntimeGraph, RuntimeNodeId, type StoreHealthEntry, type StoreHealthReport, evaluateComputed, findColdStores, getAsyncInflightCount, getComputedDeps, getComputedDescriptor, getComputedGraph, getInitialState, getMetrics, getPersistQueueDepth, getRuntimeGraph, getStoreHealth, getStoreMeta, getSubscriberCount, listStores };
+export { type HydrationConsistencyReport, type HydrationDriftMetrics, getHydrationConsistency, getHydrationDriftEvents, getHydrationDriftMetrics };

package/dist/runtime-tools.js

@@ -1,2 +1,2 @@
-export{n as evaluateComputed,g as findColdStores,f as getAsyncInflightCount,l as getComputedDeps,m as getComputedDescriptor,j as getComputedGraph,c as getInitialState,d as getMetrics,i as getPersistQueueDepth,k as getRuntimeGraph,h as getStoreHealth,b as getStoreMeta,e as getSubscriberCount,a as listStores}from'./chunk-M2NJVI36.js';import'./chunk-BW32TJGE.js';import'./chunk-6ELWGQ4Q.js';import'./chunk-FOQKGHPS.js';import'./chunk-KQCSFGHJ.js';//# sourceMappingURL=runtime-tools.js.map
+export{n as evaluateComputed,f as findColdStores,g as getAsyncInflightCount,l as getComputedDeps,m as getComputedDescriptor,j as getComputedGraph,o as getHydrationConsistency,p as getHydrationDriftEvents,q as getHydrationDriftMetrics,c as getInitialState,d as getMetrics,h as getPersistQueueDepth,k as getRuntimeGraph,i as getStoreHealth,b as getStoreMeta,e as getSubscriberCount,a as listStores}from'./chunk-SF6EP56S.js';import'./chunk-LWUT37FW.js';import'./chunk-E33L4MII.js';import'./chunk-X2MKRN7O.js';import'./chunk-6IBJ7CIK.js';import'./chunk-PHE2BCFG.js';import'./chunk-4C666HHU.js';//# sourceMappingURL=runtime-tools.js.map
 //# sourceMappingURL=runtime-tools.js.map

package/dist/selectors.d.ts

@@ -1,4 +1,4 @@
 declare const createSelector: <TState, TResult>(storeName: string, selectorFn: (state: TState) => TResult) => () => NonNullable<TResult> | null;
-declare const subscribeWithSelector: <R>(name: string, selector: (state: any) => R, equality: ((a: R, b: R) => boolean) | undefined, listener: (next: R, prev: R) => void) => (() => void);
+declare const subscribeWithSelector: <TState = unknown, R = unknown>(name: string, selector: (state: TState) => R, equality: ((a: R, b: R) => boolean) | undefined, listener: (next: R, prev: R | undefined) => void) => (() => void);
 
 export { createSelector, subscribeWithSelector };

package/dist/selectors.js

@@ -1,2 +1,2 @@
-export{a as createSelector,b as subscribeWithSelector}from'./chunk-X3JR32JD.js';import'./chunk-FOQKGHPS.js';import'./chunk-KQCSFGHJ.js';//# sourceMappingURL=selectors.js.map
+export{a as createSelector,b as subscribeWithSelector}from'./chunk-BWNLQKTY.js';import'./chunk-X2MKRN7O.js';import'./chunk-6IBJ7CIK.js';import'./chunk-PHE2BCFG.js';import'./chunk-4C666HHU.js';//# sourceMappingURL=selectors.js.map
 //# sourceMappingURL=selectors.js.map

package/dist/server/portable.d.ts

@@ -0,0 +1,27 @@
+import { S as StoreRegistry } from '../store-registry.js';
+import { c as StoreStateMap } from '../types.js';
+import { e as RequestStoreName, f as RequestStoreValue, a as RequestSnapshot, b as RequestScopeCapture } from '../shared.js';
+export { c as RequestHydrateOptions, d as RequestScopeOptions } from '../shared.js';
+import { S as StoreOptions } from '../types-internal.js';
+import '../feature.js';
+import '../utility.js';
+import '../types-internal-2.js';
+import '../runtime-patch.js';
+import '../registry.js';
+import '../types-internal-3.js';
+
+type RequestScopeApi<StateMap extends StoreStateMap = StoreStateMap> = {
+    create: <Name extends RequestStoreName<StateMap>>(name: Name, data: RequestStoreValue<StateMap, Name>, options?: StoreOptions<RequestStoreValue<StateMap, Name>>) => RequestStoreValue<StateMap, Name> | null;
+    set: <Name extends RequestStoreName<StateMap>>(name: Name, updater: RequestStoreValue<StateMap, Name> | ((draft: RequestStoreValue<StateMap, Name>) => void)) => RequestStoreValue<StateMap, Name> | null;
+    get: <Name extends RequestStoreName<StateMap>>(name: Name) => RequestStoreValue<StateMap, Name> | null;
+    snapshot: () => RequestSnapshot<StateMap>;
+    capture: () => RequestScopeCapture<StateMap>;
+    bind: <Args extends unknown[], Result>(callback: (...args: Args) => Result) => (...args: Args) => Result;
+};
+type RequestScopeContext<StateMap extends StoreStateMap = StoreStateMap> = RequestScopeApi<StateMap> & {
+    registry: StoreRegistry;
+    run: <T>(fn: (api: RequestScopeApi<StateMap>) => T) => T;
+};
+declare const createRequestScope: <StateMap extends StoreStateMap = StoreStateMap>(initial?: RequestScopeCapture<StateMap>) => RequestScopeContext<StateMap>;
+
+export { type RequestScopeApi, RequestScopeCapture, type RequestScopeContext, RequestSnapshot, RequestStoreName, RequestStoreValue, createRequestScope };

package/dist/server/portable.js

@@ -0,0 +1,2 @@
+import {b,c,a}from'../chunk-WE3ZR6OG.js';import {W,n,w,l}from'../chunk-X2MKRN7O.js';import {y,H}from'../chunk-6IBJ7CIK.js';import'../chunk-PHE2BCFG.js';import'../chunk-4C666HHU.js';var d=l,u=n,g=w,f=s=>s!==null&&(typeof s=="object"||typeof s=="function")&&typeof s.then=="function",V=s=>{let a$1=y("request"),r=0;if(s){let e=b(s);H(a$1,()=>{W(e.snapshot,e.options,{allowTrusted:true});});}let S=()=>b(c(a$1)),i={create:(e,t,n={})=>H(a$1,()=>(d(e,t,a(n)),u(e))),set:(e,t)=>H(a$1,()=>(g(e,t),u(e))),get:e=>H(a$1,()=>u(e)),snapshot:()=>S().snapshot,capture:S,bind:e=>(...t)=>{if(r<=0)throw new Error("Bound request scope callback invoked outside scope.run().");return H(a$1,()=>e(...t))}};return {registry:a$1,...i,run:e=>{r+=1;let t;try{t=H(a$1,()=>e(i));}catch(n){throw r-=1,n}return f(t)?Promise.resolve(t).finally(()=>{r-=1;}):(r-=1,t)}}};export{V as createRequestScope};//# sourceMappingURL=portable.js.map
+//# sourceMappingURL=portable.js.map

package/dist/server.d.ts

@@ -1,33 +1,22 @@
-import { S as StoreOptions } from './options.js';
 import { c as StoreStateMap } from './types.js';
 import { S as StoreRegistry } from './store-registry.js';
-import './utility.js';
+import { R as RequestStoreApi, a as RequestSnapshot, b as RequestScopeCapture, c as RequestHydrateOptions } from './shared.js';
+export { d as RequestScopeOptions, e as RequestStoreName, f as RequestStoreValue } from './shared.js';
+import './types-internal-2.js';
 import './feature.js';
+import './types-internal.js';
+import './utility.js';
 import './runtime-patch.js';
 import './registry.js';
-import './computed-types.js';
+import './types-internal-3.js';
 
-type RequestStoreName<StateMap> = keyof StateMap extends never ? string : keyof StateMap & string;
-type RequestStoreValue<StateMap, Name extends RequestStoreName<StateMap>> = Name extends keyof StateMap ? StateMap[Name] : unknown;
-type RequestSnapshot<StateMap> = Partial<{
-    [K in RequestStoreName<StateMap>]: RequestStoreValue<StateMap, K>;
-}>;
-type RequestHydrateOptions<StateMap> = Partial<{
-    [K in RequestStoreName<StateMap>]: StoreOptions<RequestStoreValue<StateMap, K>>;
-}> & {
-    default?: StoreOptions;
-};
-type RequestStoreApi<StateMap extends StoreStateMap = StoreStateMap> = {
-    create: <Name extends RequestStoreName<StateMap>>(name: Name, data: RequestStoreValue<StateMap, Name>, options?: StoreOptions<RequestStoreValue<StateMap, Name>>) => RequestStoreValue<StateMap, Name>;
-    set: <Name extends RequestStoreName<StateMap>>(name: Name, updater: RequestStoreValue<StateMap, Name> | ((draft: RequestStoreValue<StateMap, Name>) => void)) => RequestStoreValue<StateMap, Name>;
-    get: <Name extends RequestStoreName<StateMap>>(name: Name) => RequestStoreValue<StateMap, Name> | undefined;
-    snapshot: () => RequestSnapshot<StateMap>;
-};
 type RequestStoreContext<StateMap extends StoreStateMap> = {
     registry: StoreRegistry;
     snapshot: () => RequestSnapshot<StateMap>;
+    capture: () => RequestScopeCapture<StateMap>;
     hydrate: <T>(renderFn: () => T, options?: RequestHydrateOptions<StateMap>) => T;
+    bind: <Args extends unknown[], Result>(callback: (...args: Args) => Result) => (...args: Args) => Result;
 };
 declare const createStoreForRequest: <StateMap extends StoreStateMap = StoreStateMap>(initializer?: (api: RequestStoreApi<StateMap>) => void) => RequestStoreContext<StateMap>;
 
-export { type RequestStoreApi, StoreRegistry, createStoreForRequest };
+export { RequestHydrateOptions, RequestScopeCapture, RequestSnapshot, RequestStoreApi, StoreRegistry, createStoreForRequest };

package/dist/server.js

@@ -1,2 +1,2 @@
-import {h,i as i$1,ia,R,e,v,x,qa}from'./chunk-FOQKGHPS.js';import'./chunk-KQCSFGHJ.js';import {AsyncLocalStorage}from'async_hooks';var i=new AsyncLocalStorage,u=new AsyncLocalStorage,c=new AsyncLocalStorage,O=new AsyncLocalStorage;h({run:(t,o)=>i.run(t,o),get:()=>i.getStore()||null});i$1({run:(t,o)=>u.run(t,o),get:()=>u.getStore()||null,enterWith:t=>u.enterWith(t)});ia({run:(t,o)=>c.run(t,o),get:()=>c.getStore()||null,enterWith:t=>c.enterWith(t)});R({run:(t,o)=>O.run(t,o),get:()=>O.getStore()||null});var C=t=>t!==null&&(typeof t=="object"||typeof t=="function")&&typeof t.then=="function",P=t=>{let o=e("request"),r={},f={},M=e=>Object.prototype.hasOwnProperty.call(r,e),R=e=>{Object.keys(r).forEach(a=>{delete r[a];}),Object.keys(o.metaEntries).forEach(a=>{let S=Object.prototype.hasOwnProperty.call(e,a)?e[a]:o.stores[a];r[a]=v(S);});};return typeof t=="function"&&t({create:(e,a,S={})=>(r[e]=v(a),f[e]={...S},r[e]),set:(e,a)=>{if(!M(e))throw new Error(`createStoreForRequest.set("${e}") requires create("${e}", initialState) first.`);return r[e]=typeof a=="function"?x(r[e],a):v(a),r[e]},get:e=>M(e)?v(r[e]):void 0,snapshot:()=>v(r)}),{registry:o,snapshot:()=>v(r),hydrate:(e,a={})=>{let S={...a,default:a.default};return Object.keys(r).forEach(p=>{let s=p,x={...a.default||{},...a[s]||{},...f[p]||{}};S[s]=x;}),u.run(o,()=>i.run(v(r),()=>{qa(r,S,{allowTrusted:true});let p=i.getStore();if(!p)return e();try{let s=e();return C(s)?Promise.resolve(s).finally(()=>{R(p);}):(R(p),s)}catch(s){throw R(p),s}}))}}};export{P as createStoreForRequest};//# sourceMappingURL=server.js.map
+import {d,c as c$1,b}from'./chunk-WE3ZR6OG.js';import {L,s,W,R,Q}from'./chunk-X2MKRN7O.js';import {E as E$1,G,y as y$1,V,J}from'./chunk-6IBJ7CIK.js';import'./chunk-PHE2BCFG.js';import'./chunk-4C666HHU.js';import {AsyncLocalStorage}from'async_hooks';var f=new AsyncLocalStorage,y=new AsyncLocalStorage,C=new AsyncLocalStorage,A=new AsyncLocalStorage,c=new WeakMap,H=e=>e!==null&&(typeof e=="object"||typeof e=="function")&&typeof e.then=="function",h=(e,t,r)=>{if(!e)return r();let s=c.has(e),a=c.get(e);c.set(e,t);let n=()=>{if(s&&a){c.set(e,a);return}c.delete(e);};try{let p=r();return H(p)?Promise.resolve(p).finally(n):(n(),p)}catch(p){throw n(),p}};E$1({run:(e,t)=>h(y.getStore()??null,e,()=>f.run(e,t)),get:()=>{let e=y.getStore();return e?c.has(e)?c.get(e)??null:null:f.getStore()||null}});G({run:(e,t)=>y.run(e,t),get:()=>y.getStore()||null,enterWith:e=>y.enterWith(e)});L({run:(e,t)=>C.run(e,t),get:()=>C.getStore()||null,enterWith:e=>C.enterWith(e)});s({run:(e,t)=>A.run(e,t),get:()=>A.getStore()||null});var E=e=>{Object.keys(e).forEach(t=>{delete e[t];});},I=(e,t)=>{let r=J().flush.chunkDelayMs,s=n=>{if(r>0&&typeof setTimeout=="function"){setTimeout(n,r);return}if(typeof queueMicrotask=="function"){queueMicrotask(n);return}Promise.resolve().then(n);},a=()=>{let n=e.notify;if(!n.isFlushing&&!n.notifyScheduled&&n.pendingNotifications.size===0){E(t);return}s(a);};s(a);},N=(e,t,r)=>{Q(e),r(t),I(e,t);},B=async(e,t,r)=>{await R(e),r(t),I(e,t);},X=e=>{let t=y$1("request"),r={},s=Object.create(null),a=0,n=i=>{Object.keys(r).forEach(o=>{delete r[o];}),Object.keys(s).forEach(o=>{delete s[o];}),Object.entries(i.snapshot).forEach(([o,u])=>{r[o]=V(u);}),Object.entries(i.options).forEach(([o,u])=>{u!==void 0&&(s[o]=u);});},p=i=>{n(c$1(t,i));},P=d({buffer:r,bufferedOptions:s});return typeof e=="function"&&e(P),{registry:t,snapshot:()=>b({snapshot:r,options:s}).snapshot,capture:()=>{let i=c.get(t)??null;return i?c$1(t,i):b({snapshot:r,options:s})},hydrate:(i,o={})=>{let u={...o,default:o.default};return Object.keys(r).forEach(S=>{let l=S,W={...o.default||{},...o[l]||{},...s[S]||{}};u[l]=W;}),y.run(t,()=>f.run(V(r),()=>{a+=1;let S=f.getStore();if(!S)try{return W(r,u,{allowTrusted:!0}),i()}finally{a-=1;}return h(t,S,()=>{W(r,u,{allowTrusted:!0});try{let l=i();if(H(l))return Promise.resolve(l).finally(async()=>{try{await B(t,S,p);}finally{a-=1;}});try{return N(t,S,p),l}finally{a-=1;}}catch(l){try{throw N(t,S,p),l}finally{a-=1;}}})}))},bind:i=>(...o)=>{if(a<=0)throw new Error("Bound request callback invoked outside request lifecycle.");return y.run(t,()=>{let u=c.get(t);if(!u)throw new Error("Bound request callback missing active request carrier.");return h(t,u,()=>f.run(u,()=>i(...o)))})}}};export{X as createStoreForRequest};//# sourceMappingURL=server.js.map
 //# sourceMappingURL=server.js.map

package/dist/shared.d.ts

@@ -0,0 +1,36 @@
+import { S as StoreOptions } from './types-internal.js';
+import { c as StoreStateMap } from './types.js';
+
+/**
+ * @module server/shared
+ *
+ * LAYER: SSR
+ * OWNS:  Shared request-scope types and capture helpers.
+ *
+ * Consumers: Node SSR and explicit portable request-scope adapters.
+ */
+
+type RequestStoreName<StateMap> = keyof StateMap extends never ? string : keyof StateMap & string;
+type RequestStoreValue<StateMap, Name extends RequestStoreName<StateMap>> = Name extends keyof StateMap ? StateMap[Name] : unknown;
+
+type RequestSnapshot<StateMap extends StoreStateMap = StoreStateMap> = Partial<{
+    [K in RequestStoreName<StateMap>]: RequestStoreValue<StateMap, K>;
+}>;
+type RequestScopeOptions<StateMap extends StoreStateMap = StoreStateMap> = Partial<{
+    [K in RequestStoreName<StateMap>]: StoreOptions<RequestStoreValue<StateMap, K>>;
+}>;
+type RequestHydrateOptions<StateMap extends StoreStateMap = StoreStateMap> = RequestScopeOptions<StateMap> & {
+    default?: StoreOptions;
+};
+type RequestScopeCapture<StateMap extends StoreStateMap = StoreStateMap> = {
+    snapshot: RequestSnapshot<StateMap>;
+    options: RequestScopeOptions<StateMap>;
+};
+type RequestStoreApi<StateMap extends StoreStateMap = StoreStateMap> = {
+    create: <Name extends RequestStoreName<StateMap>>(name: Name, data: RequestStoreValue<StateMap, Name>, options?: StoreOptions<RequestStoreValue<StateMap, Name>>) => RequestStoreValue<StateMap, Name>;
+    set: <Name extends RequestStoreName<StateMap>>(name: Name, updater: RequestStoreValue<StateMap, Name> | ((draft: RequestStoreValue<StateMap, Name>) => void)) => RequestStoreValue<StateMap, Name>;
+    get: <Name extends RequestStoreName<StateMap>>(name: Name) => RequestStoreValue<StateMap, Name> | undefined;
+    snapshot: () => RequestSnapshot<StateMap>;
+};
+
+export type { RequestStoreApi as R, RequestSnapshot as a, RequestScopeCapture as b, RequestHydrateOptions as c, RequestScopeOptions as d, RequestStoreName as e, RequestStoreValue as f };

package/dist/store-registry.d.ts

@@ -1,7 +1,8 @@
 import { StoreFeatureMeta, FeatureName, StoreFeatureRuntime } from './feature.js';
 import { R as RuntimePatch } from './runtime-patch.js';
 import { A as AsyncRegistry } from './registry.js';
-import { ComputedClassification } from './computed-types.js';
+import { C as ComputedClassification } from './types-internal-3.js';
+import { h as HydrationRuntimeState } from './types-internal-2.js';
 
 /**
  * @module store-registry
@@ -80,6 +81,7 @@ type StoreRegistry = {
     lastRuntimePatches: RuntimePatch[];
     transaction: TransactionState;
     async: AsyncRegistry;
+    hydration: HydrationRuntimeState;
     notify: NotifyState;
     lifecycleListener: StoreLifecycleListener | null;
 };

package/dist/sync.d.ts

@@ -1 +1,10 @@
-export { installSync } from './install.js';
+/**
+ * @module features/sync/runtime
+ *
+ * LAYER: Feature runtime
+ * OWNS:  Sync feature runtime integration with store lifecycle.
+ */
+
+declare const installSync: () => void;
+
+export { installSync };

package/dist/sync.js

@@ -1,2 +1,2 @@
-export{b as installSync}from'./chunk-PVATWAY4.js';import'./chunk-FOQKGHPS.js';import'./chunk-KQCSFGHJ.js';//# sourceMappingURL=sync.js.map
+export{a as installSync}from'./chunk-GZQGU64H.js';import'./chunk-4D6OA3DD.js';import'./chunk-X2MKRN7O.js';import'./chunk-6IBJ7CIK.js';import'./chunk-PHE2BCFG.js';import'./chunk-4C666HHU.js';//# sourceMappingURL=sync.js.map
 //# sourceMappingURL=sync.js.map

package/dist/testing.d.ts

@@ -1,4 +1,5 @@
 import { a as StoreDefinition, b as StoreKey, P as PartialDeep, W as WriteResult } from './types.js';
+import './types-internal-2.js';
 
 declare const createMockStore: <Name extends string, State extends Record<string, unknown> = Record<string, unknown>>(name?: Name, initial?: State) => {
     set: (update: PartialDeep<State> | ((draft: State) => void)) => WriteResult;

package/dist/testing.js

@@ -1,2 +1,2 @@
-import'./chunk-YU5GMPCC.js';import {e}from'./chunk-BW32TJGE.js';import'./chunk-6ELWGQ4Q.js';import {P,K,sa,U,ta}from'./chunk-FOQKGHPS.js';import'./chunk-KQCSFGHJ.js';var D=(o="mock",t={})=>{let e=P(o);return K(o,t),{set:r=>typeof r=="function"?U(e,r):U(e,r),reset:()=>sa(e),use:()=>e}},N=(o,t)=>{let e=Date.now;Object.defineProperty(Date,"now",{value:()=>o,configurable:true});try{return t()}finally{Object.defineProperty(Date,"now",{value:e,configurable:true});}},g=()=>{ta(),e();},x=(o,t=1e3,e=r=>({value:r}))=>{let r=typeof performance<"u"&&performance.now?performance.now():Date.now();for(let a=0;a<t;a++)U(o,e(a));let s=(typeof performance<"u"&&performance.now?performance.now():Date.now())-r;return {iterations:t,totalMs:s,avgMs:s/t}};export{x as benchmarkStoreSet,D as createMockStore,g as resetAllStoresForTest,N as withMockedTime};//# sourceMappingURL=testing.js.map
+import'./chunk-YU5GMPCC.js';import {f}from'./chunk-LWUT37FW.js';import'./chunk-E33L4MII.js';import {q,l,Y,w,_}from'./chunk-X2MKRN7O.js';import'./chunk-6IBJ7CIK.js';import'./chunk-PHE2BCFG.js';import'./chunk-4C666HHU.js';var D=(o="mock",t={})=>{let e=q(o);return l(o,t),{set:r=>typeof r=="function"?w(e,r):w(e,r),reset:()=>Y(e),use:()=>e}},N=(o,t)=>{let e=Date.now;Object.defineProperty(Date,"now",{value:()=>o,configurable:true});try{return t()}finally{Object.defineProperty(Date,"now",{value:e,configurable:true});}},g=()=>{_(),f();},x=(o,t=1e3,e=r=>({value:r}))=>{let r=typeof performance<"u"&&performance.now?performance.now():Date.now();for(let a=0;a<t;a++)w(o,e(a));let s=(typeof performance<"u"&&performance.now?performance.now():Date.now())-r;return {iterations:t,totalMs:s,avgMs:s/t}};export{x as benchmarkStoreSet,D as createMockStore,g as resetAllStoresForTest,N as withMockedTime};//# sourceMappingURL=testing.js.map
 //# sourceMappingURL=testing.js.map

package/dist/tsdoc-metadata.json

@@ -0,0 +1,11 @@
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "7.58.0"
+    }
+  ]
+}

package/dist/types-internal-2.d.ts

@@ -0,0 +1,168 @@
+/**
+ * @module hydration-consistency/types
+ *
+ * LAYER: Store runtime
+ * OWNS:  Public and internal types for post-hydration consistency handling.
+ *
+ * Consumers: hydration-consistency runtime modules and public barrels.
+ */
+type HydrationConsistencySource = "effect" | "storage" | "network" | "sync" | "hydrate" | "unknown";
+type HydrationConsistencyAuthority = "server-authoritative" | "client-authoritative" | "mergeable";
+/**
+ * How the post-hydration boot window is controlled.
+ * - `timer`: closes automatically after a configured duration.
+ * - `manual`: stays open until `close()` is called, optionally with a fallback timer.
+ */
+type HydrationBootWindowMode = "timer" | "manual";
+/**
+ * Boot-window configuration for post-hydration write deferral.
+ *
+ * `timer` mode uses `ms` to guess when hydration should be considered settled.
+ * `manual` mode returns a `HydrationBootWindowControl` so the app can close the window explicitly.
+ * `fallbackMs` can be used as a safety timer while still preferring manual close.
+ */
+type HydrationBootWindowOptions = HydrationBootWindowMode | {
+    mode: HydrationBootWindowMode;
+    ms?: number;
+    fallbackMs?: number;
+};
+/**
+ * Runtime control returned from `hydrateStores(...)` when a boot window is active.
+ */
+type HydrationBootWindowControl = {
+    mode: HydrationBootWindowMode;
+    startedAtMs: number | null;
+    endsAtMs: number | null;
+    close: () => void;
+    isActive: () => boolean;
+};
+type HydrationConsistencyPolicy = "server_wins" | "client_wins" | "merge" | "invalidate_and_refetch";
+type HydrationConsistencyResolution = "stable" | "server_reverted" | "client_kept" | "merged" | "invalidated";
+type HydrationSnapshotMetadata = {
+    snapshotVersion?: string | number;
+    timestamp?: number;
+    checksum?: string | number;
+    schemaSignature?: string;
+};
+type HydrationConsistencyStoreContract = HydrationSnapshotMetadata & {
+    authority?: HydrationConsistencyAuthority;
+};
+type HydrationConsistencyContract<Snapshot extends object = Record<string, unknown>> = HydrationSnapshotMetadata & {
+    authority?: HydrationConsistencyAuthority;
+    stores?: Partial<{
+        [K in keyof Snapshot & string]: HydrationConsistencyStoreContract;
+    }>;
+};
+type HydrationInvalidateArgs<State = unknown> = {
+    store: string;
+    baseline: State;
+    live: State;
+    source: HydrationConsistencySource;
+};
+type HydrationMergeArgs<State = unknown> = {
+    store: string;
+    baseline: State;
+    live: State;
+    source: HydrationConsistencySource;
+};
+type HydrationConsistencyStorePolicy<State = unknown> = HydrationConsistencyPolicy | {
+    policy: HydrationConsistencyPolicy;
+    merge?: (args: HydrationMergeArgs<State>) => State;
+    onInvalidate?: (args: HydrationInvalidateArgs<State>) => void;
+};
+type HydrationDriftEvent<Snapshot extends object = Record<string, unknown>> = {
+    id: string;
+    store: keyof Snapshot & string | string;
+    source: HydrationConsistencySource;
+    authority: HydrationConsistencyAuthority;
+    policy: HydrationConsistencyPolicy;
+    resolution: HydrationConsistencyResolution;
+    detectedAt: string;
+    detectedAtMs: number;
+    firstDivergedAt: string;
+    firstDivergedAtMs: number;
+    hydratedAt: string;
+    hydratedAtMs: number;
+    baselineHash: number;
+    liveHash: number;
+    resolvedHash: number;
+    invalidated: boolean;
+    metadata: HydrationSnapshotMetadata;
+    baseline: unknown;
+    live: unknown;
+    resolved: unknown;
+};
+type HydrationConsistencyOptions<Snapshot extends object = Record<string, unknown>> = {
+    contract?: HydrationConsistencyContract<Snapshot>;
+    policyMap?: Partial<{
+        [K in keyof Snapshot & string]: HydrationConsistencyStorePolicy<Snapshot[K]>;
+    }>;
+    onDrift?: (event: HydrationDriftEvent<Snapshot>) => void;
+    /**
+     * Legacy timer shorthand for the hydration boot window.
+     * Prefer `bootWindow` for explicit timer or manual mode.
+     */
+    bootWindowMs?: number;
+    /**
+     * Preferred boot-window configuration for post-hydration write deferral.
+     */
+    bootWindow?: HydrationBootWindowOptions;
+    deferSources?: readonly HydrationConsistencySource[];
+    maxEvents?: number;
+};
+type HydrationConsistencyStoreState = HydrationSnapshotMetadata & {
+    store: string;
+    authority: HydrationConsistencyAuthority;
+    policy: HydrationConsistencyPolicy;
+    baseline: unknown;
+    baselineHash: number;
+    hydratedAt: string;
+    hydratedAtMs: number;
+    firstDivergedAt: string | null;
+    firstDivergedAtMs: number | null;
+    lastDivergedAt: string | null;
+    lastDivergedAtMs: number | null;
+    lastResolution: HydrationConsistencyResolution | null;
+    lastSource: HydrationConsistencySource | null;
+    driftCount: number;
+    queuedWrites: number;
+    replayedWrites: number;
+    invalidatedAt: string | null;
+    invalidatedAtMs: number | null;
+    currentHash: number;
+    merge?: (args: HydrationMergeArgs) => unknown;
+    onInvalidate?: (args: HydrationInvalidateArgs) => void;
+};
+type HydrationConsistencyMetrics = {
+    driftEvents: number;
+    queuedWrites: number;
+    replayedWrites: number;
+    reconciliations: number;
+    invalidations: number;
+};
+type HydrationDeferredWrite = {
+    id: number;
+    store: string;
+    source: HydrationConsistencySource;
+    enqueuedAtMs: number;
+    apply: () => void;
+};
+type HydrationRuntimeState = {
+    stores: Record<string, HydrationConsistencyStoreState>;
+    events: HydrationDriftEvent[];
+    metrics: HydrationConsistencyMetrics;
+    queue: HydrationDeferredWrite[];
+    onDrift: ((event: HydrationDriftEvent) => void) | null;
+    maxEvents: number;
+    deferSources: Set<HydrationConsistencySource>;
+    bootWindowMode: HydrationBootWindowMode | null;
+    bootWindowActive: boolean;
+    bootWindowStartedAtMs: number | null;
+    bootWindowEndsAtMs: number | null;
+    bootWindowTimer: ReturnType<typeof setTimeout> | null;
+    bootWindowToken: number | null;
+    replaying: boolean;
+    sequence: number;
+};
+
+export type { HydrationSnapshotMetadata as H, HydrationConsistencyAuthority as a, HydrationConsistencyPolicy as b, HydrationConsistencyResolution as c, HydrationConsistencySource as d, HydrationConsistencyMetrics as e, HydrationBootWindowMode as f, HydrationDriftEvent as g, HydrationRuntimeState as h, HydrationBootWindowControl as i, HydrationConsistencyOptions as j, HydrationBootWindowOptions as k, HydrationConsistencyContract as l, HydrationConsistencyStoreContract as m, HydrationConsistencyStorePolicy as n, HydrationInvalidateArgs as o, HydrationMergeArgs as p };

package/dist/{computed-types.d.ts → types-internal-3.d.ts}

@@ -39,4 +39,4 @@ interface ComputedDescriptor {
     asyncBoundary?: boolean;
 }
 
-export type { ComputedClassification, ComputedDescriptor, RuntimeEdgeType, RuntimeGraph, RuntimeGraphEdge, RuntimeGraphGranularity, RuntimeGraphNode, RuntimeNodeId, RuntimeNodeType, RuntimePathSegment };
+export type { ComputedClassification as C, RuntimeGraph as R, ComputedDescriptor as a, RuntimeEdgeType as b, RuntimeGraphEdge as c, RuntimeGraphGranularity as d, RuntimeGraphNode as e, RuntimeNodeId as f, RuntimeNodeType as g };

package/dist/{options.d.ts → types-internal.d.ts}

@@ -1,5 +1,12 @@
 import { T as TraceContext } from './utility.js';
 
+/**
+ * @module adapters/options/types
+ *
+ * LAYER: Module
+ * OWNS:  Shared option and config types for store adapters.
+ */
+
 type StoreValue = unknown;
 interface FeatureOptionsMap {
 }
@@ -12,6 +19,7 @@ interface PersistDriver {
 }
 type StoreScope = "request" | "global" | "temp";
 type SnapshotMode = "deep" | "shallow" | "ref";
+type ResetCloneMode = "deep" | "shallow" | "none";
 type ValidateFn<State = StoreValue> = (next: State) => boolean | State;
 type SchemaValidateOption = {
     safeParse: (value: unknown) => {
@@ -251,18 +259,25 @@ interface StoreOptions<State = StoreValue> {
      * 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).
+     * - "shallow": shallow clone (top-level) only, then shallow-freeze the snapshot envelope.
+     * - "ref": return the live store reference with a shallow-frozen snapshot envelope.
      */
     snapshot?: SnapshotMode;
+    /**
+     * Clone strategy used by resetStore(...) when restoring the initial snapshot.
+     * - "deep" (default): deep clone initial snapshot (safest).
+     * - "shallow": clone top-level container only.
+     * - "none": reuse initial snapshot reference.
+     */
+    resetClone?: ResetCloneMode;
     /**
      * 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
+     * - "warn": (default) log a warning when mutation is detected.
+     * - "throw": throw an error when mutation is detected.
+     * - "auto-clone": 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';
+    snapshotSafety?: "warn" | "throw" | "auto-clone";
 }
 interface NormalizedOptions {
     scope: StoreScope;
@@ -277,7 +292,7 @@ interface NormalizedOptions {
     onCreate?: (initial: StoreValue) => void;
     onError?: (err: string) => void;
     validate?: ValidateOption;
-    migrations: Record<number, (state: any) => any>;
+    migrations: Record<number, (state: StoreValue) => StoreValue>;
     version: number;
     redactor?: (state: StoreValue) => StoreValue;
     historyLimit: number;
@@ -285,11 +300,12 @@ interface NormalizedOptions {
     sync?: boolean | SyncOptions;
     features?: FeatureOptions;
     snapshot: SnapshotMode;
+    resetClone: ResetCloneMode;
     /** normalized snapshotSafety value */
-    snapshotSafety?: 'warn' | 'throw' | 'auto-clone';
+    snapshotSafety?: "warn" | "throw" | "auto-clone";
     explicitPersist: boolean;
     explicitSync: boolean;
     explicitDevtools: boolean;
 }
 
-export type { FeatureOptions as F, MiddlewareCtx as M, NormalizedOptions as N, PersistOptions as P, StoreOptions as S, StoreValue as a, SnapshotMode as b, FeatureOptionsMap as c, SyncOptions as d };
+export type { DevtoolsOptions as D, FeatureOptions as F, LifecycleOptions as L, MiddlewareCtx as M, NormalizedOptions as N, PersistConfig as P, ResetCloneMode as R, StoreOptions as S, ValidateFn as V, StoreValue as a, SnapshotMode as b, FeatureOptionsMap as c, PersistDriver as d, PersistOptions as e, SchemaValidateOption as f, StoreScope as g, SyncMessage as h, SyncOptions as i, ValidateOption as j };

package/dist/types.d.ts

@@ -1,3 +1,5 @@
+import { i as HydrationBootWindowControl } from './types-internal-2.js';
+
 /**
  * @module store-lifecycle/types
  *
@@ -6,11 +8,13 @@
  *
  * 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)];
+type PathDepth<T, Depth extends number> = PathInternal<T, Depth>;
 type Path<T, Depth extends number = 10> = PathInternal<T, Depth>;
 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;
 type PartialDeep<T> = T extends Primitive ? T : unknown extends T ? T : {
@@ -36,7 +40,13 @@ type HydrationResult = {
         reason: HydrationBlockReason;
         cause?: unknown;
     };
+    /**
+     * Present when post-hydration consistency enabled an active boot window.
+     * Use it to inspect or close timer/manual deferral after `hydrateStores(...)`.
+     */
+    bootWindow?: HydrationBootWindowControl;
 };
+
 interface StoreStateMap {
 }
 interface StrictStoreMap {
@@ -59,7 +69,7 @@ type WriteResult = {
     ok: true;
 } | {
     ok: false;
-    reason: "not-found" | "validate" | "path" | "middleware" | "ssr" | "invalid-args" | "lazy-uninitialized" | "unsupported-op" | "unsupported-path-shape";
+    reason: "not-found" | "no-initial-state" | "validate" | "path" | "middleware" | "ssr" | "invalid-args" | "lazy-uninitialized" | "unsupported-op" | "unsupported-path-shape";
 };
 
-export type { HydrateSnapshotFor as H, PartialDeep as P, StoreValue as S, WriteResult as W, StoreDefinition as a, StoreKey as b, StoreStateMap as c, StoreName as d, StateFor as e, StrictStoreMap as f, HydrationResult as g, HydrationFailure as h, Path as i, PathValue as j };
+export type { BrandedStoreName as B, HydrateSnapshotFor as H, PartialDeep as P, RegisteredStoreMap as R, StoreValue as S, WriteResult as W, StoreDefinition as a, StoreKey as b, StoreStateMap as c, StoreName as d, StateFor as e, StrictStoreMap as f, HydrationResult as g, HydrationBlockReason as h, HydrationFailure as i, HydrationFailureReason as j, Path as k, PathDepth as l, PathInternal as m, PathValue as n, PrevDepth as o, Primitive as p };