@warp-drive-mirror/experiments 5.10.0-alpha.1 → 5.10.0-alpha.3

package/dist/data-worker.d.ts

@@ -3,7 +3,7 @@ import { n as RequestEventData, t as AbortEventData } from "./types-CRs-Qww6.js"
 import { CacheHandler as CacheHandler$1, Future } from "@warp-drive-mirror/core/request";
 import { Store } from "@warp-drive-mirror/core";
 //#region src/data-worker/worker.d.ts
-declare class DataWorker {
+export declare class DataWorker {
   store: Store;
   threads: Map<string, MessagePort>;
   pending: Map<string, Map<number, Future<unknown>>>;
@@ -29,7 +29,6 @@ declare class DataWorker {
  * with their referenced resources.
  *
  */
-declare const CacheHandler: CacheHandler$1;
+export declare const CacheHandler: CacheHandler$1;
 //#endregion
-export { CacheHandler, DataWorker };
 //# sourceMappingURL=data-worker.d.ts.map

package/dist/data-worker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"data-worker.d.ts","names":[],"sources":["../src/data-worker/worker.ts","../src/data-worker/cache-handler.ts"],"mappings":";;;;;cASa;EACX,OAAe;EACf,SAAiB,YAAY;EAC7B,SAAiB,YAAY,YAAY;EACzC;EACA;IAAmB;IAAoB;;EACvC,SAAiB;EAEjB,YAAY,kBAAkB,OAAO;IAAY;IAAoB;;EAarE;EAkCA,YAAY,gBAAgB,MAAM;EAqBlC,aAAa,OAAO;EAUpB,QAAc,OAAO,mBAAmB;;;;;;;;;cCnE7B,cAAc"}
+{"version":3,"file":"data-worker.d.ts","names":[],"sources":["../src/data-worker/worker.ts","../src/data-worker/cache-handler.ts"],"mappings":";;;;;qBASa;EACX,OAAe;EACf,SAAiB,YAAY;EAC7B,SAAiB,YAAY,YAAY;EACzC;EACA;IAAmB;IAAoB;;EACvC,SAAiB;EAEjB,YAAY,kBAAkB,OAAO;IAAY;IAAoB;;EAarE;EAkCA,YAAY,gBAAgB,MAAM;EAqBlC,aAAa,OAAO;EAUpB,QAAc,OAAO,mBAAmB;;;;;;;;;qBCnE7B,cAAc"}

package/dist/image-fetch.d.ts

@@ -21,7 +21,7 @@ type RequestEventData = {
  *
  * @public
  */
-declare class ImageFetch {
+export declare class ImageFetch {
   worker: Worker | SharedWorker;
   threadId: string;
   pending: Map<string, Deferred<string>>;
@@ -56,5 +56,4 @@ declare class ImageFetch {
   load(url: string): Promise<string>;
 }
 //#endregion
-export { ImageFetch };
 //# sourceMappingURL=image-fetch.d.ts.map

package/dist/image-fetch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image-fetch.d.ts","names":[],"sources":["../src/image-worker/types.ts","../src/image-worker/fetch.ts"],"mappings":";;;KA8BY;EACV;EACA;EACA;;;;;;;;;;;;;;;;;cCFW;EACX,QAAgB,SAAS;EACzB;EACA,SAAiB,YAAY;EAC7B,SAAiB;EACjB,OAAe;;;;;;EAOf,YAAY,QAAQ,SAAS;EA0C7B,eAAe,cAAc;EAO7B,MAAM,OAAO;;;;;;;;;;;;;;;;;;;EAuBb,KAAK,cAAc"}
+{"version":3,"file":"image-fetch.d.ts","names":[],"sources":["../src/image-worker/types.ts","../src/image-worker/fetch.ts"],"mappings":";;;KA8BY;EACV;EACA;EACA;;;;;;;;;;;;;;;;;qBCFW;EACX,QAAgB,SAAS;EACzB;EACA,SAAiB,YAAY;EAC7B,SAAiB;EACjB,OAAe;;;;;;EAOf,YAAY,QAAQ,SAAS;EA0C7B,eAAe,cAAc;EAO7B,MAAM,OAAO;;;;;;;;;;;;;;;;;;;EAuBb,KAAK,cAAc"}

package/dist/image-worker.d.ts

@@ -18,7 +18,7 @@
  *
  * @public
  */
-declare class ImageWorker {
+export declare class ImageWorker {
   private threads;
   private pendingImages;
   private options;
@@ -36,5 +36,4 @@ declare class ImageWorker {
   private request;
 }
 //#endregion
-export { ImageWorker };
 //# sourceMappingURL=image-worker.d.ts.map

package/dist/image-worker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image-worker.d.ts","names":[],"sources":["../src/image-worker/worker.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;cA+Ba;UACK;UACA;UACA;UACA;UACA;;;;EAKhB,YAAY;IAAY;;UAahB;UAsBA;UA4BA;UAiBM"}
+{"version":3,"file":"image-worker.d.ts","names":[],"sources":["../src/image-worker/worker.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;qBA+Ba;UACK;UACA;UACA;UACA;UACA;;;;EAKhB,YAAY;IAAY;;UAahB;UAsBA;UA4BA;UAiBM"}

package/dist/storage.d.ts

@@ -1,12 +1,12 @@
 //#region src/storage/cache.d.ts
-declare const DEFAULT_CACHE_ID = "reactive-cache";
-interface InternalCacheStorageEvent {
+export declare const DEFAULT_CACHE_ID = "reactive-cache";
+export interface InternalCacheStorageEvent {
   storageArea: string;
   key: string | null;
   oldValue: string | null;
   newValue: string | null;
 }
-interface CacheStorageEvent {
+export interface CacheStorageEvent {
   storageArea: CacheStorage;
   key: string | null;
   oldValue: string | null;
@@ -18,7 +18,7 @@ interface CacheStorageEvent {
  * This is a good option for larger data sets than can be efficiently stored in localStorage
  * but should not be used as a permanent DB or storage solution.
  */
-declare class CacheStorage implements Storage {
+export declare class CacheStorage implements Storage {
   #private;
   _data: Map<string, string | null>;
   _nextUpdate: number | null;
@@ -44,7 +44,7 @@ declare class CacheStorage implements Storage {
 }
 //#endregion
 //#region src/storage/storage.d.ts
-interface ReactiveStorageOptions {
+export interface ReactiveStorageOptions {
   /**
    * If true, falls back to in-memory storage when the underlying
    * storage is unavailable (e.g., private browsing mode).
@@ -66,20 +66,39 @@ interface ReactiveStorageOptions {
  *
  * If the instance does not already exist, it is created.
  */
-declare function getLocalStorage(): ReactiveStorage;
-declare function getSessionStorage(): ReactiveStorage;
-declare function getCacheStorage(namespace?: string | null): ReactiveStorage;
+export declare function getLocalStorage(): ReactiveStorage;
+export declare function getSessionStorage(): ReactiveStorage;
+export declare function getCacheStorage(namespace?: string | null): ReactiveStorage;
 /**
  * Configure options for the localStorage singleton.
  * Must be called before getLocalStorage() is first invoked.
  */
-declare function configureLocalStorage(options: ReactiveStorageOptions): void;
+export declare function configureLocalStorage(options: ReactiveStorageOptions): void;
 /**
  * Configure options for the sessionStorage singleton.
  * Must be called before getSessionStorage() is first invoked.
  */
-declare function configureSessionStorage(options: ReactiveStorageOptions): void;
-type EffectStorageEvent = CacheStorageEvent | StorageEvent;
+export declare function configureSessionStorage(options: ReactiveStorageOptions): void;
+export type EffectStorageEvent = CacheStorageEvent | StorageEvent;
+/**
+ * Subscribes to storage-change events, whether they originate from the
+ * native Storage API (a `StorageEvent`, fired cross-tab) or from
+ * {@link CacheStorage}'s own same-tab notifications (dispatched as a
+ * `CustomEvent` under the same 'storage' name — see `emitStorageEvent`
+ * in `./cache.ts`).
+ *
+ * Returns an unsubscribe function.
+ *
+ * This can't be expressed by widening the global `WindowEventMap.storage`
+ * type: that entry is inherited from `WindowEventHandlersEventMap` as
+ * `StorageEvent`, and a declaration-merged override has to stay assignable
+ * to the type it's overriding, not the other way around — deliberately
+ * reusing this event name for a wider union has no way to satisfy that.
+ *
+ * Route storage-event subscribers through this helper instead of calling
+ * `window.addEventListener('storage', ...)` directly.
+ */
+export declare function onStorageEvent(listener: (event: EffectStorageEvent) => void): () => void;
 /**
  * A reactive wrapper around the Web Storage API (localStorage/sessionStorage)
  * that provides signal-based access to storage items and length.
@@ -126,11 +145,11 @@ declare class ReactiveStorage implements Storage {
   key(index: number): string | null;
 }
 //#endregion
-//#region src/storage/-private/storage-infra.d.ts
+//#region src/storage/query-params.d.ts
 /**
  * Configuration options for fields that are also query parameters
  */
-interface ParamConfig {
+export interface ParamConfig {
   /**
    * Convert a value into a string for storage in the URL.
    * `null` indicates the value should be omitted from the URL.
@@ -152,6 +171,64 @@ interface ParamConfig {
    */
   getDefault?: (instance: any) => unknown;
 }
+/**
+ * Creates a {@link ParamConfig} for boolean fields that serialize to '1' or null.
+ *
+ * @returns ParamConfig for boolean fields
+ *
+ * @example
+ * ```ts
+ * @param(BooleanParam())
+ * @field
+ * myFlag: boolean = false;
+ * ```
+ */
+export declare function BooleanParam(): ParamConfig;
+/**
+ * Creates a {@link ParamConfig} for numeric fields with default value checking.
+ *
+ * @param precision - When given, the number of digits to serialize after the decimal point
+ * @param getDefault - Function to get the default value for comparison
+ * @returns ParamConfig for number fields
+ *
+ * @example
+ * ```ts
+ * @param(NumberParam(2, function (instance: MyClass) { return instance.defaultZoom; }))
+ * @field
+ * zoom: number = 12;
+ * ```
+ */
+export declare function NumberParam(precision?: number, getDefault?: (instance: any) => number | undefined): ParamConfig;
+/**
+ * Decorator which marks a field as a query parameter.
+ *
+ * This decorator only stores metadata - it does not change the property behavior.
+ * The field will operate as a normal `@field` until a router integration consumes it.
+ *
+ * The provided {@link ParamConfig} is used to:
+ * - Serialize values for the URL
+ * - Deserialize values from the URL
+ * - Compare URL and local values
+ * - Determine when to include/exclude params from the URL
+ *
+ * @param config - Configuration for URL serialization/deserialization
+ *
+ * @example
+ * ```ts
+ * @SessionResource('map-state')
+ * class MapState {
+ *   @param({
+ *     serialize: (value: unknown) => (value ? '1' : null),
+ *     deserialize: (urlValue: string) => urlValue === '1',
+ *   })
+ *   @field
+ *   active: boolean = false;
+ * }
+ * ```
+ */
+export declare function param(config: ParamConfig): PropertyDecorator;
+//#endregion
+//#region src/storage/-private/storage-infra.d.ts
 interface InternalParamConfig extends ParamConfig {
   initialized?: boolean;
 }
@@ -192,6 +269,7 @@ type KeyFn = (obj: any) => string;
  * @private
  */
 declare function initMeta(target: object): StorageResourceMeta;
+declare function initializeFields(instance: object, source: object): void;
 /**
  * Get or create the param companion object for a StorageResource instance.
  *
@@ -227,7 +305,7 @@ declare function getParamCompanion(instance: object, groupControlMap?: Record<st
  * The function will be called once per instance during
  * initialization to determine the unique ID for that instance.
  */
-declare function LocalResource(id: string | KeyFn): ClassDecorator;
+export declare function LocalResource(id: string | KeyFn): ClassDecorator;
 /**
  * Decorator which transforms a class into a StorageResource
  * persisted in sessionStorage.
@@ -242,7 +320,7 @@ declare function LocalResource(id: string | KeyFn): ClassDecorator;
  * The function will be called once per instance during
  * initialization to determine the unique ID for that instance.
  */
-declare function SessionResource(id: string | KeyFn): ClassDecorator;
+export declare function SessionResource(id: string | KeyFn): ClassDecorator;
 /**
  * Decorator which transforms a class into a StorageResource
  * persisted via the [Cache API](https://developer.mozilla.org/en-US/docs/Web/API/Cache).
@@ -262,7 +340,7 @@ declare function SessionResource(id: string | KeyFn): ClassDecorator;
  * so partitioning can be achieved by using different namespaces for different groups
  * of data.
  */
-declare function CacheResource(id: string | KeyFn, namespace?: string | null): ClassDecorator;
+export declare function CacheResource(id: string | KeyFn, namespace?: string | null): ClassDecorator;
 /**
  * Decorator which marks a property as a field on
  * a LocalResource or SessionResource
@@ -294,9 +372,9 @@ declare function CacheResource(id: string | KeyFn, namespace?: string | null): C
  * ```
  *
  */
-declare function field(type: "local" | "session" | "cache"): PropertyDecorator;
-declare function field(target: object, key: string, descriptor?: PropertyDescriptor): void;
-declare function input(type: "number" | "boolean" | "float"): PropertyDecorator;
+export declare function field(type: "local" | "session" | "cache"): PropertyDecorator;
+export declare function field(target: object, key: string, descriptor?: PropertyDescriptor): void;
+export declare function input(type: "number" | "boolean" | "float"): PropertyDecorator;
 /**
  * Effects are fields that run a side-effecting function.
  *
@@ -348,7 +426,7 @@ declare function input(type: "number" | "boolean" | "float"): PropertyDecorator;
  * }
  * ```
  */
-declare function effect(fn: <K>(update: ValueTransition<K>) => void, type?: "local" | "session"): PropertyDecorator;
+export declare function effect(fn: <K>(update: ValueTransition<K>) => void, type?: "local" | "session"): PropertyDecorator;
 //#endregion
-export { CacheResource, CacheStorage, CacheStorageEvent, DEFAULT_CACHE_ID, EffectStorageEvent, InternalCacheStorageEvent, LocalResource, type ReactiveStorage, ReactiveStorageOptions, SessionResource, getParamCompanion as _getParamCompanion, initMeta as _initMeta, configureLocalStorage, configureSessionStorage, effect, field, getCacheStorage, getLocalStorage, getSessionStorage, input };
+export { type KeyFn, type ReactiveStorage, type ValueTransition, getParamCompanion as _getParamCompanion, initMeta as _initMeta, initializeFields as _initializeFields };
 //# sourceMappingURL=storage.d.ts.map

package/dist/storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"storage.d.ts","names":[],"sources":["../src/storage/cache.ts","../src/storage/storage.ts","../src/storage/-private/storage-infra.ts","../src/storage/storage-resource.ts"],"mappings":";cAEa;UAKI;EACf;EACA;EACA;EACA;;UAEe;EACf,aAAa;EACb;EACA;EACA;;;;;;;;cAkEW,wBAAwB;;EAInC,OAAO;EACP;EACA,iBAAiB;EAYjB,YAAY;MAMR;EA4BJ;EAKA,QAAQ;EAIR,IAAI;EAgBJ,WAAW;EAQX,QAAQ,aAAa;;;;;SAed,IAAI,mBAAqC,QAAQ;SASjD,YAAY,mBAAqC;;;;;SAYjD;;;;UCtMQ;;;;;EAKf;;;;;EAMA;;;;;EAMA,mBAAmB,aAAa,4BAA4B;;;;;;;iBAgB9C,mBAAmB;iBAOnB,qBAAqB;iBAQrB,gBAAgB,4BAAkC;;;;;iBAelD,sBAAsB,SAAS;;;;;iBAQ/B,wBAAwB,SAAS;KA8BrC,qBAAqB,oBAAoB;;;;;;;cAQ/C,2BAA2B;UACvB;UACA;UACA;UACA;UAEQ;UACA;UAER;EACR,UAAU,aAAa,KAAK,OAAO;EAKnC,YAAY,SAAS,SAAS,UAAS;;;;MA2CnC;;;;EAOJ,SAAS;;;;EAsBT,QAAQ;;;;EAyBR,QAAQ,aAAa;;;;EA2DrB,WAAW;;;;EAsBX;;;;EAeA,IAAI;;;;;;;UC3TW;;;;;EAMf,YAAY,gBAAgB;;;;;EAM5B,cAAc,kBAAkB;;;;;;;;;;EAWhC,cAAc;;UAGN,4BAA4B;EACpC;;UAGe,gBAAgB;EAC/B;EACA,MAAM;EACN,IAAI;;;;;UAMW;EACf;EACA;EACA,MAAM;EACN;EACA,eAAe;EACf,QAAQ,qBAAqB,QAAQ;EACrC,cAAc;EACd,cAAc,YAAY;EAC1B;EACA,WAAW,gBAAgB;;;;;;;;;;;KAajB,SAAS;;;;;;;iBAaL,SAAS,iBAAiB;;;;;;;;;;;;;;;;;;;iBAkT1B,kBAAkB,kBAAkB,kBAAkB;;;;;;;;;;;;;;;;;iBCzWtD,cAAc,aAAa,QAAQ;;;;;;;;;;;;;;;iBAkBnC,gBAAgB,aAAa,QAAQ;;;;;;;;;;;;;;;;;;;;iBAuBrC,cAAc,aAAa,OAAO,4BAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmCpE,MAAM,sCAAsC;iBAC5C,MAAM,gBAAgB,aAAa,aAAa;iBAgBhD,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoF7C,OAAO,KAAK,GAAG,QAAQ,gBAAgB,aAAa,6BAA6B"}
+{"version":3,"file":"storage.d.ts","names":[],"sources":["../src/storage/cache.ts","../src/storage/storage.ts","../src/storage/query-params.ts","../src/storage/-private/storage-infra.ts","../src/storage/storage-resource.ts"],"mappings":";qBAEa;iBAKI;EACf;EACA;EACA;EACA;;iBAEe;EACf,aAAa;EACb;EACA;EACA;;;;;;;;qBAkEW,wBAAwB;;EAInC,OAAO;EACP;EACA,iBAAiB;EAYjB,YAAY;MAMR;EA4BJ;EAKA,QAAQ;EAIR,IAAI;EAgBJ,WAAW;EAQX,QAAQ,aAAa;;;;;SAed,IAAI,mBAAqC,QAAQ;SASjD,YAAY,mBAAqC;;;;;SAYjD;;;;iBCtMQ;;;;;EAKf;;;;;EAMA;;;;;EAMA,mBAAmB,aAAa,4BAA4B;;;;;;;wBAgB9C,mBAAmB;wBAOnB,qBAAqB;wBAQrB,gBAAgB,4BAAkC;;;;;wBAelD,sBAAsB,SAAS;;;;;wBAQ/B,wBAAwB,SAAS;YA8BrC,qBAAqB,oBAAoB;;;;;;;;;;;;;;;;;;;wBAoBrC,eAAe,WAAW,OAAO;;;;;;;cAe3C,2BAA2B;UACvB;UACA;UACA;UACA;UAEQ;UACA;UAER;EACR,UAAU,aAAa,KAAK,OAAO;EAKnC,YAAY,SAAS,SAAS,UAAS;;;;MAyCnC;;;;EAOJ,SAAS;;;;EAsBT,QAAQ;;;;EAyBR,QAAQ,aAAa;;;;EA2DrB,WAAW;;;;EAsBX;;;;EAeA,IAAI;;;;;;;iBCpVW;;;;;EAKf,YAAY,gBAAgB;;;;;EAK5B,cAAc,kBAAkB;;;;;;;;;;EAUhC,cAAc;;;;;;;;;;;;;;wBAeA,gBAAgB;;;;;;;;;;;;;;;wBAqBhB,YAAY,oBAAoB,cAAc,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA+CrF,MAAM,QAAQ,cAAc;;;UCzGlC,4BAA4B;EACpC;;UAGe,gBAAgB;EAC/B;EACA,MAAM;EACN,IAAI;;;;;UAMW;EACf;EACA;EACA,MAAM;EACN;EACA,eAAe;EACf,QAAQ,qBAAqB,QAAQ;EACrC,cAAc;EACd,cAAc,YAAY;EAC1B;EACA,WAAW,gBAAgB;;;;;;;;;;;KAajB,SAAS;;;;;;;iBAaL,SAAS,iBAAiB;iBAsG1B,iBAAiB,kBAAkB;;;;;;;;;;;;;;;;;;;iBAgNnC,kBAAkB,kBAAkB,kBAAkB;;;;;;;;;;;;;;;;;wBCjVtD,cAAc,aAAa,QAAQ;;;;;;;;;;;;;;;wBAkBnC,gBAAgB,aAAa,QAAQ;;;;;;;;;;;;;;;;;;;;wBAuBrC,cAAc,aAAa,OAAO,4BAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAmCpE,MAAM,sCAAsC;wBAC5C,MAAM,gBAAgB,aAAa,aAAa;wBAgBhD,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAoF7C,OAAO,KAAK,GAAG,QAAQ,gBAAgB,aAAa,6BAA6B"}

package/dist/storage.js

@@ -8,6 +8,7 @@ import { defineSignal, entangleSignal, getOrCreateInternalSignal, makeInitialize
 */
 var SignalMap = class {
 	_map = {};
+	_size = 0;
 	_signals = withSignalStore(this._map);
 	subscribe(key) {
 		macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) && ((test) => {
@@ -15,8 +16,7 @@ var SignalMap = class {
 		})(typeof key === "string");
 		const existing = this._signals.has(key);
 		entangleSignal(this._signals, this._map, key, void 0);
-		const size = this._size;
-		this._size = existing ? size : size + 1;
+		if (!existing) this._size += 1;
 		return existing;
 	}
 	notify(key) {
@@ -34,7 +34,6 @@ var SignalMap = class {
 		return this._size;
 	}
 };
-defineSignal(SignalMap.prototype, "_size", 0);
 
 //#endregion
 //#region src/storage/cache.ts
@@ -273,6 +272,31 @@ function isStorageUnavailableError(error) {
 	return false;
 }
 /**
+* Subscribes to storage-change events, whether they originate from the
+* native Storage API (a `StorageEvent`, fired cross-tab) or from
+* {@link CacheStorage}'s own same-tab notifications (dispatched as a
+* `CustomEvent` under the same 'storage' name — see `emitStorageEvent`
+* in `./cache.ts`).
+*
+* Returns an unsubscribe function.
+*
+* This can't be expressed by widening the global `WindowEventMap.storage`
+* type: that entry is inherited from `WindowEventHandlersEventMap` as
+* `StorageEvent`, and a declaration-merged override has to stay assignable
+* to the type it's overriding, not the other way around — deliberately
+* reusing this event name for a wider union has no way to satisfy that.
+*
+* Route storage-event subscribers through this helper instead of calling
+* `window.addEventListener('storage', ...)` directly.
+*/
+function onStorageEvent(listener) {
+	const handler = (event) => {
+		listener("detail" in event ? event.detail : event);
+	};
+	window.addEventListener("storage", handler);
+	return () => window.removeEventListener("storage", handler);
+}
+/**
 * A reactive wrapper around the Web Storage API (localStorage/sessionStorage)
 * that provides signal-based access to storage items and length.
 *
@@ -304,8 +328,7 @@ var ReactiveStorage = class {
 				this._length = 0;
 			} else throw error;
 		}
-		if (!this._memoryOnly) window.addEventListener("storage", (event) => {
-			const data = "detail" in event ? event.detail : event;
+		if (!this._memoryOnly) onStorageEvent((data) => {
 			if (data.storageArea === storage) {
 				this._values[data.key] = data.newValue;
 				this._signals.notify(data.key);
@@ -444,9 +467,6 @@ defineSignal(ReactiveStorage.prototype, "_signals", makeInitializer(() => new Si
 //#endregion
 //#region src/storage/-private/storage-infra.ts
 /**
-* Configuration options for fields that are also query parameters
-*/
-/**
 * Metadata attached to persisted resource classes
 */
 /**
@@ -526,10 +546,29 @@ function keyFor(meta, key) {
 	return `persisted:${meta.id}:${key}`;
 }
 function getStorage(type, namespace) {
-	if (type === "local-resource") return getLocalStorage();
-	else if (type === "session-resource") return getSessionStorage();
+	if (type === "local-resource" || type === "local-storage") return getLocalStorage();
+	else if (type === "session-resource" || type === "session-storage") return getSessionStorage();
 	else return getCacheStorage(namespace);
 }
+function peekField(meta, key, overrideType) {
+	const stored = getStorage(overrideType || meta.type, meta.namespace).peekItem(keyFor(meta, key));
+	if (stored) return JSON.parse(stored);
+	return null;
+}
+function initializeFields(instance, source) {
+	const meta = useMeta(getResourceMeta(instance), instance);
+	for (const [key] of meta.fields.entries()) if (key in source) {
+		const newValue = source[key];
+		const initializer = meta.initializers.get(key);
+		let defaultValue = null;
+		if (initializer) defaultValue = initializer.call(instance);
+		const overrideType = meta.typeOverrides?.get(key) ?? null;
+		const type = overrideType || meta.type;
+		const currentValue = peekField(meta, keyFor(meta, key), overrideType);
+		(type === "local-resource" ? localStorage : sessionStorage).setItem(keyFor(meta, key), JSON.stringify(newValue));
+		if (currentValue === defaultValue) setField(meta, keyFor(meta, key), newValue, overrideType);
+	}
+}
 /**
 * Update storage field
 */
@@ -910,5 +949,97 @@ function effect(fn, type) {
 }
 
 //#endregion
-export { CacheResource, CacheStorage, DEFAULT_CACHE_ID, LocalResource, SessionResource, getParamCompanion as _getParamCompanion, initMeta as _initMeta, configureLocalStorage, configureSessionStorage, effect, field, getCacheStorage, getLocalStorage, getSessionStorage, input };
+//#region src/storage/query-params.ts
+/**
+* Configuration options for fields that are also query parameters
+*/
+/**
+* Creates a {@link ParamConfig} for boolean fields that serialize to '1' or null.
+*
+* @returns ParamConfig for boolean fields
+*
+* @example
+* ```ts
+* @param(BooleanParam())
+* @field
+* myFlag: boolean = false;
+* ```
+*/
+function BooleanParam() {
+	return {
+		serialize: (value) => value ? "1" : null,
+		deserialize: (urlValue) => urlValue === "1"
+	};
+}
+/**
+* Creates a {@link ParamConfig} for numeric fields with default value checking.
+*
+* @param precision - When given, the number of digits to serialize after the decimal point
+* @param getDefault - Function to get the default value for comparison
+* @returns ParamConfig for number fields
+*
+* @example
+* ```ts
+* @param(NumberParam(2, function (instance: MyClass) { return instance.defaultZoom; }))
+* @field
+* zoom: number = 12;
+* ```
+*/
+function NumberParam(precision, getDefault) {
+	const isPrecise = typeof precision === "number";
+	return {
+		serialize: function(value) {
+			if (typeof value !== "number") return null;
+			return isPrecise ? value.toFixed(precision) : value.toString();
+		},
+		deserialize: (urlValue) => {
+			const num = Number(urlValue);
+			return isNaN(num) ? null : num;
+		},
+		getDefault: (instance) => {
+			return getDefault?.(instance);
+		}
+	};
+}
+/**
+* Decorator which marks a field as a query parameter.
+*
+* This decorator only stores metadata - it does not change the property behavior.
+* The field will operate as a normal `@field` until a router integration consumes it.
+*
+* The provided {@link ParamConfig} is used to:
+* - Serialize values for the URL
+* - Deserialize values from the URL
+* - Compare URL and local values
+* - Determine when to include/exclude params from the URL
+*
+* @param config - Configuration for URL serialization/deserialization
+*
+* @example
+* ```ts
+* @SessionResource('map-state')
+* class MapState {
+*   @param({
+*     serialize: (value: unknown) => (value ? '1' : null),
+*     deserialize: (urlValue: string) => urlValue === '1',
+*   })
+*   @field
+*   active: boolean = false;
+* }
+* ```
+*/
+function param(config) {
+	return function(target, key, desc) {
+		macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) && ((test) => {
+			if (!test) throw new Error("param decorator only supports string keys");
+		})(typeof key === "string");
+		const meta = initMeta(target);
+		if (!meta.paramConfigs) meta.paramConfigs = /* @__PURE__ */ new Map();
+		meta.paramConfigs.set(key, config);
+		return desc;
+	};
+}
+
+//#endregion
+export { BooleanParam, CacheResource, CacheStorage, DEFAULT_CACHE_ID, LocalResource, NumberParam, SessionResource, getParamCompanion as _getParamCompanion, initMeta as _initMeta, initializeFields as _initializeFields, configureLocalStorage, configureSessionStorage, effect, field, getCacheStorage, getLocalStorage, getSessionStorage, input, onStorageEvent, param };
 //# sourceMappingURL=storage.js.map