@byearlybird/starling 0.17.3 → 0.19.0

package/dist/index.js

@@ -1,20 +1,9 @@
-//#region lib/core/hex.ts
+//#region lib/clock.ts
 function toHex(value, padLength) {
 	return value.toString(16).padStart(padLength, "0");
 }
-function nonce(length) {
-	const bytes = new Uint8Array(length / 2);
-	crypto.getRandomValues(bytes);
-	return Array.from(bytes).map((b) => toHex(b, 2)).join("");
-}
-
-//#endregion
-//#region lib/core/clock.ts
 const MS_LENGTH = 12;
 const SEQ_LENGTH = 6;
-const NONCE_LENGTH = 6;
-const STAMP_LENGTH = MS_LENGTH + SEQ_LENGTH + NONCE_LENGTH;
-const HEX_PATTERN = /^[0-9a-f]+$/i;
 function advanceClock(current, next) {
 	if (next.ms > current.ms) return {
 		ms: next.ms,
@@ -29,569 +18,398 @@ function advanceClock(current, next) {
 		seq: current.seq + 1
 	};
 }
-function makeStamp(ms, seq) {
-	return `${toHex(ms, MS_LENGTH)}${toHex(seq, SEQ_LENGTH)}${nonce(NONCE_LENGTH)}`;
-}
-/**
-* Parse and validate a string as a Stamp. Use when deserializing stored state.
-* Throws if the value is not a valid 24-character hex string.
-*/
-function asStamp(value) {
-	if (value.length !== STAMP_LENGTH || !HEX_PATTERN.test(value)) throw new Error(`Invalid stamp: expected ${STAMP_LENGTH} hex characters, got "${value}"`);
-	return value;
+function makeStamp(ms, seq, deviceId) {
+	return `${toHex(ms, MS_LENGTH)}@${toHex(seq, SEQ_LENGTH)}@${deviceId}`;
 }
 
 //#endregion
-//#region lib/core/tombstone.ts
-function isDeleted(id, tombstones) {
-	return tombstones[id] !== void 0;
-}
-function mergeTombstones(target, source) {
-	const result = {};
-	const keys = new Set([...Object.keys(target), ...Object.keys(source)]);
-	for (const key of keys) {
-		const targetStamp = target[key];
-		const sourceStamp = source[key];
-		if (targetStamp && sourceStamp) result[key] = targetStamp > sourceStamp ? targetStamp : sourceStamp;
-		else if (targetStamp) result[key] = targetStamp;
-		else if (sourceStamp) result[key] = sourceStamp;
-	}
-	return result;
+//#region lib/emitter.ts
+function createEmitter() {
+	const listeners = /* @__PURE__ */ new Set();
+	return {
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		emit(event) {
+			for (const listener of Array.from(listeners)) listener(event);
+		}
+	};
 }
 
 //#endregion
-//#region lib/core/atomizer.ts
-function pack(value, timestamp) {
+//#region lib/query.ts
+function createQuery(store, predicate, dependencies) {
+	const emitter = createEmitter();
+	const disposers = /* @__PURE__ */ new Set();
+	let result = predicate(store);
+	const unsub = store.subscribe((e) => {
+		if (dependencies.some((dep) => !!e[dep])) {
+			result = predicate(store);
+			emitter.emit(result);
+		}
+	});
 	return {
-		[KEYS.VAL]: value,
-		[KEYS.TS]: timestamp
+		get result() {
+			return result;
+		},
+		subscribe(cb) {
+			const disposer = emitter.subscribe(cb);
+			disposers.add(disposer);
+			return () => {
+				disposer();
+				disposers.delete(disposer);
+			};
+		},
+		dispose() {
+			for (const disposer of disposers) disposer();
+			disposers.clear();
+			unsub();
+		}
 	};
 }
-function unpack(node) {
-	return isAtom(node) ? node[KEYS.VAL] : void 0;
-}
-function isAtom(node) {
-	return node !== null && typeof node === "object" && KEYS.VAL in node;
-}
-function atomize(data, timestamp) {
-	const document = {};
-	for (const key of Object.keys(data)) document[key] = pack(data[key], timestamp);
-	return document;
-}
 
 //#endregion
-//#region lib/core/types.ts
-const KEYS = {
-	VAL: "~val",
-	TS: "~ts"
-};
-/**
-* Type guard to check if a value is an AtomizedDocument.
-* An AtomizedDocument is an object where all values are Atoms.
-*/
-function isAtomizedDocument(value) {
-	if (value === null || typeof value !== "object") return false;
-	const obj = value;
-	for (const key in obj) if (Object.prototype.hasOwnProperty.call(obj, key)) {
-		if (!isAtom(obj[key])) return false;
-	}
-	return true;
+//#region lib/flat.ts
+function isPlainObject(value) {
+	return Object.prototype.toString.call(value) === "[object Object]";
 }
-/**
-* Type guard to check if a value is a Collection.
-* A Collection is a Record where all values are AtomizedDocuments.
-*/
-function isCollection(value) {
-	if (value === null || typeof value !== "object") return false;
-	const obj = value;
-	for (const key in obj) if (Object.prototype.hasOwnProperty.call(obj, key)) {
-		if (!isAtomizedDocument(obj[key])) return false;
+function flatten(obj, transform) {
+	const result = {};
+	function recurse(current, prefix) {
+		const keys = Object.keys(current);
+		if (keys.length === 0) {
+			result[prefix] = transform ? transform(current) : current;
+			return;
+		}
+		for (const key of keys) {
+			const path = prefix ? `${prefix}.${key}` : key;
+			const value = current[key];
+			if (isPlainObject(value) && !Array.isArray(value)) recurse(value, path);
+			else result[path] = transform ? transform(value) : value;
+		}
 	}
-	return true;
+	recurse(obj, "");
+	return result;
 }
-/**
-* Type guard to check if a value is a CollectionState.
-* A CollectionState has documents (Collection) and tombstones (Record<string, string>).
-*/
-function isCollectionState(value) {
-	if (value === null || typeof value !== "object") return false;
-	const obj = value;
-	if (!("documents" in obj) || !("tombstones" in obj)) return false;
-	return isCollection(obj["documents"]) && obj["tombstones"] !== null && typeof obj["tombstones"] === "object" && !Array.isArray(obj["tombstones"]);
+function unflatten(obj) {
+	const result = {};
+	for (const key of Object.keys(obj)) {
+		const parts = key.split(".");
+		let current = result;
+		for (let i = 0; i < parts.length; i++) {
+			const part = parts[i];
+			if (part === "__proto__") break;
+			if (i === parts.length - 1) current[part] = obj[key];
+			else {
+				const next = parts[i + 1];
+				const useArray = /^\d+$/.test(next);
+				if (current[part] === void 0) current[part] = useArray ? [] : {};
+				current = current[part];
+			}
+		}
+	}
+	return result;
 }
 
 //#endregion
-//#region lib/core/lens.ts
-function createReadLens(doc) {
-	return new Proxy(doc, {
-		get(target, prop, receiver) {
-			if (typeof prop === "symbol" || !Object.prototype.hasOwnProperty.call(target, prop)) return;
-			const value = Reflect.get(target, prop, receiver);
-			if (value === void 0) return void 0;
-			if (isAtom(value)) return unpack(value);
-			throw new Error(`createReadLens: field "${String(prop)}" is not an atom. Expected AtomizedDocument<T> with atomized fields only.`);
-		},
-		set() {
-			console.warn("Mutations must use the update API.");
-			return false;
+//#region lib/crdt.ts
+function atomize(data, timestamp) {
+	return flatten(data, (value) => ({
+		"~v": value,
+		"~ts": timestamp
+	}));
+}
+function mergeTombstones(target, source) {
+	let result;
+	for (const [key, stamp] of Object.entries(source)) {
+		const existing = target[key];
+		if (!existing || stamp > existing) {
+			if (!result) result = { ...target };
+			result[key] = stamp;
 		}
-	});
+	}
+	return result ?? target;
 }
-
-//#endregion
-//#region lib/core/merge.ts
-/** Merges incoming doc fields into local. Adds new keys from incoming; LWW on conflicts. */
 function mergeDocs(local, incoming) {
-	const merged = { ...local };
-	let hasChanges = false;
-	for (const key of Object.keys(incoming)) {
-		const localAtom = local[key];
+	let merged;
+	for (const key of Object.keys(local)) {
 		const incomingAtom = incoming[key];
-		if (incomingAtom === void 0) continue;
-		if (!localAtom) {
-			if (isAtom(incomingAtom)) {
-				merged[key] = incomingAtom;
-				hasChanges = true;
-			}
-			continue;
-		}
-		if (isAtom(localAtom) && isAtom(incomingAtom)) {
-			if (incomingAtom[KEYS.TS] > localAtom[KEYS.TS]) {
-				merged[key] = incomingAtom;
-				hasChanges = true;
-			}
+		if (!incomingAtom) continue;
+		if (incomingAtom["~ts"] > local[key]["~ts"]) {
+			if (!merged) merged = { ...local };
+			merged[key] = incomingAtom;
 		}
 	}
-	return hasChanges ? merged : local;
+	return merged ?? local;
 }
-/**
-* Merges two collection states, respecting tombstones.
-* Documents that are tombstoned are excluded from the result.
-* For documents that exist in both collections, fields are merged using LWW semantics.
-*/
 function mergeCollections(local, incoming) {
 	const mergedTombstones = mergeTombstones(local.tombstones, incoming.tombstones);
-	const mergedCollection = {};
+	let mergedDocuments;
+	let puts;
+	let patches;
+	let removes;
 	const allDocumentIds = new Set([...Object.keys(local.documents), ...Object.keys(incoming.documents)]);
 	for (const id of allDocumentIds) {
-		if (mergedTombstones[id]) continue;
+		if (mergedTombstones[id]) {
+			if (local.documents[id]) {
+				if (!mergedDocuments) mergedDocuments = { ...local.documents };
+				delete mergedDocuments[id];
+				(removes ??= []).push(id);
+			}
+			continue;
+		}
 		const localDoc = local.documents[id];
 		const incomingDoc = incoming.documents[id];
-		if (localDoc && incomingDoc) mergedCollection[id] = mergeDocs(localDoc, incomingDoc);
-		else if (localDoc) mergedCollection[id] = localDoc;
-		else if (incomingDoc) mergedCollection[id] = incomingDoc;
+		if (localDoc && incomingDoc) {
+			const merged = mergeDocs(localDoc, incomingDoc);
+			if (merged !== localDoc) {
+				if (!mergedDocuments) mergedDocuments = { ...local.documents };
+				mergedDocuments[id] = merged;
+				(patches ??= []).push(id);
+			}
+		} else if (incomingDoc) {
+			if (!mergedDocuments) mergedDocuments = { ...local.documents };
+			mergedDocuments[id] = incomingDoc;
+			(puts ??= []).push(id);
+		}
 	}
+	if (mergedTombstones === local.tombstones && mergedDocuments === void 0) return {
+		state: local,
+		changes: void 0
+	};
+	const changes = {
+		put: puts ?? [],
+		patch: patches ?? [],
+		remove: removes ?? []
+	};
 	return {
-		documents: mergedCollection,
-		tombstones: mergedTombstones
+		state: {
+			documents: mergedDocuments ?? local.documents,
+			tombstones: mergedTombstones
+		},
+		changes
 	};
 }
+function readDoc(doc) {
+	const flat = {};
+	for (const key of Object.keys(doc)) flat[key] = doc[key]["~v"];
+	return unflatten(flat);
+}
 
 //#endregion
-//#region lib/emitter/emitter.ts
-var Emitter = class {
-	#listeners = /* @__PURE__ */ new Set();
-	subscribe(listener) {
-		this.#listeners.add(listener);
-		return () => this.#listeners.delete(listener);
-	}
-	emit(event) {
-		const listeners = Array.from(this.#listeners);
-		for (const listener of listeners) listener(event);
-	}
-};
-
-//#endregion
-//#region lib/store/schema.ts
-/**
-* Validates input data against a schema.
-* Accepts `unknown` input to allow safe validation of untyped data.
-* The schema's runtime validation will ensure type safety.
-*/
-function validate(schema, input) {
-	const result = schema["~standard"].validate(input);
+//#region lib/collection.ts
+function validateSchema(schema, data) {
+	const result = schema["~standard"].validate(data);
 	if (result instanceof Promise) throw new TypeError("Schema validation must be synchronous");
-	if (result.issues) throw new Error(JSON.stringify(result.issues, null, 2));
+	if (result.issues) throw new Error(result.issues.map((i) => i.message).join("; "));
 	return result.value;
 }
-/**
-* Helper function to create a collection definition with proper type inference.
-* This captures the schema output type directly as the document type.
-*
-* @example
-* ```ts
-* const store = createStore({
-*   users: define(userSchema, (data) => data.id),
-* });
-* ```
-*/
-function define(schema, getId) {
+function createCollection(def, getStamp) {
+	let state = {
+		documents: {},
+		tombstones: {}
+	};
 	return {
-		"~docType": void 0,
-		"~idType": void 0,
-		"~schemaType": void 0,
-		schema,
-		getId
+		get(id) {
+			if (state.tombstones[id]) return void 0;
+			const current = state.documents[id];
+			if (!current) return void 0;
+			return readDoc(current);
+		},
+		list(where) {
+			const results = [];
+			for (const [id, document] of Object.entries(state.documents)) if (!state.tombstones[id]) {
+				const doc = readDoc(document);
+				if (!where || where(doc)) results.push(doc);
+			}
+			return results;
+		},
+		put(data) {
+			const toPut = def.schema ? validateSchema(def.schema, data) : data;
+			const id = toPut[def.keyPath];
+			if (state.tombstones[id]) delete state.tombstones[id];
+			const stamp = getStamp();
+			state.documents[id] = atomize(toPut, stamp);
+			return {
+				id,
+				doc: readDoc(state.documents[id])
+			};
+		},
+		patch(id, data) {
+			const prev = state.documents[id];
+			if (!prev) throw new Error(`Cannot patch non-existent document "${id}"`);
+			const changes = atomize(data, getStamp());
+			const merged = {
+				...prev,
+				...changes
+			};
+			state.documents[id] = merged;
+			const result = readDoc(merged);
+			if (def.schema) try {
+				validateSchema(def.schema, result);
+			} catch (e) {
+				state.documents[id] = prev;
+				throw e;
+			}
+			return {
+				id,
+				doc: result
+			};
+		},
+		remove(id) {
+			state.tombstones[id] = getStamp();
+			delete state.documents[id];
+		},
+		getState() {
+			return state;
+		},
+		setState(newState) {
+			state = newState;
+		},
+		snapshot() {
+			return structuredClone(state);
+		},
+		restore(snap) {
+			state = snap;
+		}
 	};
 }
 
 //#endregion
-//#region lib/store/operations.ts
-function doGet(docs, tombstones, id) {
-	if (isDeleted(id, tombstones)) return void 0;
-	const current = docs[id];
-	if (!current) return void 0;
-	return createReadLens(current);
-}
-function doList(docs, tombstones) {
-	const results = [];
-	for (const [id, document] of Object.entries(docs)) if (!isDeleted(id, tombstones)) results.push(createReadLens(document));
-	return results;
-}
-function doPut(docs, tombstones, data, stamp, validateFn, getId) {
-	const validated = validateFn(data);
-	const id = getId(validated);
-	if (tombstones[id]) delete tombstones[id];
-	docs[id] = atomize(validated, stamp);
-	return createReadLens(docs[id]);
-}
-function doPatch(docs, id, data, stamp, validateFn) {
-	const current = docs[id];
-	if (!current) throw new Error(`Cannot patch non-existent document "${id}"`);
-	const merged = mergeDocs(current, atomize(data, stamp));
-	const plain = createReadLens(merged);
-	validateFn(plain);
-	docs[id] = merged;
-	return plain;
-}
-function doRemove(docs, tombstones, id, stamp) {
-	tombstones[id] = stamp;
-	delete docs[id];
-}
-function mergeState(currentState, snapshot, config) {
-	const diff = {};
-	currentState.clock = advanceClock(currentState.clock, snapshot.clock);
-	for (const [name, incomingCollectionState] of Object.entries(snapshot.collections)) {
-		const localCollectionState = currentState.collections[name] ?? {
-			documents: {},
-			tombstones: {}
-		};
-		currentState.collections[name] = mergeCollections(localCollectionState, incomingCollectionState);
-		if (name in config) diff[name] = true;
-	}
-	return diff;
-}
-
-//#endregion
-//#region lib/store/store.ts
-var Store = class {
-	#config;
-	#emitter;
-	#state;
-	constructor(config) {
-		this.#config = config;
-		this.#emitter = new Emitter();
-		this.#state = {
-			clock: {
-				ms: Date.now(),
-				seq: 0
-			},
-			collections: {}
-		};
-		for (const collectionName of Object.keys(config)) this.#state.collections[collectionName] = {
-			documents: {},
-			tombstones: {}
-		};
-	}
-	#getNextStamp() {
-		this.#state.clock = advanceClock(this.#state.clock, {
+//#region lib/store.ts
+const RESERVED_NAMES = new Set([
+	"subscribe",
+	"getState",
+	"merge",
+	"transact"
+]);
+function createStore(config) {
+	const { deviceId, collections } = config;
+	for (const name of Object.keys(collections)) if (RESERVED_NAMES.has(name)) throw new Error(`Collection name "${name}" conflicts with a store method`);
+	const emitter = createEmitter();
+	let clock = {
+		ms: Date.now(),
+		seq: 0
+	};
+	function getNextStamp() {
+		clock = advanceClock(clock, {
 			ms: Date.now(),
 			seq: 0
 		});
-		return makeStamp(this.#state.clock.ms, this.#state.clock.seq);
-	}
-	#getCollection(collection) {
-		if (!(collection in this.#config)) throw new Error(`Collection "${collection}" not found`);
-		return this.#state.collections[collection];
-	}
-	get(collection, id) {
-		const col = this.#getCollection(collection);
-		return doGet(col.documents, col.tombstones, id);
-	}
-	list(collection) {
-		const col = this.#getCollection(collection);
-		return doList(col.documents, col.tombstones);
-	}
-	put(collection, data) {
-		const col = this.#getCollection(collection);
-		const collectionConfig = this.#config[collection];
-		const result = doPut(col.documents, col.tombstones, data, this.#getNextStamp(), (d) => validate(collectionConfig.schema, d), (d) => collectionConfig.getId(d));
-		this.#emitter.emit({ [collection]: true });
-		return result;
-	}
-	patch(collection, id, data) {
-		const col = this.#getCollection(collection);
-		const collectionConfig = this.#config[collection];
-		const result = doPatch(col.documents, id, data, this.#getNextStamp(), (d) => validate(collectionConfig.schema, d));
-		this.#emitter.emit({ [collection]: true });
-		return result;
-	}
-	remove(collection, id) {
-		const col = this.#getCollection(collection);
-		doRemove(col.documents, col.tombstones, id, this.#getNextStamp());
-		this.#emitter.emit({ [collection]: true });
-	}
-	subscribe(callback) {
-		return this.#emitter.subscribe(callback);
-	}
-	getState() {
-		return { ...this.#state };
-	}
-	merge(snapshot) {
-		const diff = mergeState(this.#state, snapshot, this.#config);
-		this.#emitter.emit(diff);
-		return diff;
-	}
-	transact(callback) {
-		const event = {};
-		const clonedStates = {};
-		const ensureCloned = (name) => {
-			if (!(name in this.#config)) throw new Error(`Collection "${name}" not found`);
-			if (!clonedStates[name]) {
-				const original = this.#state.collections[name];
-				clonedStates[name] = {
-					documents: structuredClone(original.documents),
-					tombstones: structuredClone(original.tombstones)
-				};
-			}
-			return clonedStates[name];
-		};
-		const result = callback({
-			get: (collection, id) => {
-				const cloned = ensureCloned(collection);
-				return doGet(cloned.documents, cloned.tombstones, id);
+		return makeStamp(clock.ms, clock.seq, deviceId);
+	}
+	const cols = {};
+	for (const name of Object.keys(collections)) cols[name] = createCollection(collections[name], getNextStamp);
+	let transacting = false;
+	let pendingEvent = null;
+	let txSnapshots = null;
+	function getPendingChanges(name) {
+		let entry = pendingEvent[name];
+		if (!entry) {
+			entry = {
+				put: [],
+				patch: [],
+				remove: []
+			};
+			pendingEvent[name] = entry;
+		}
+		return entry;
+	}
+	function recordChange(name, type, id) {
+		if (transacting) getPendingChanges(name)[type].push(id);
+		else emitter.emit({ [name]: {
+			put: [],
+			patch: [],
+			remove: [],
+			[type]: [id]
+		} });
+	}
+	function ensureSnapshot(name) {
+		if (transacting && txSnapshots && !txSnapshots.has(name)) txSnapshots.set(name, cols[name].snapshot());
+	}
+	function buildCollectionAPI(name) {
+		const col = cols[name];
+		return {
+			get(id) {
+				return col.get(id);
 			},
-			list: (collection) => {
-				const cloned = ensureCloned(collection);
-				return doList(cloned.documents, cloned.tombstones);
+			list(options) {
+				return col.list(options?.where);
 			},
-			put: (collection, data) => {
-				const cloned = ensureCloned(collection);
-				const collectionConfig = this.#config[collection];
-				event[collection] = true;
-				return doPut(cloned.documents, cloned.tombstones, data, this.#getNextStamp(), (d) => validate(collectionConfig.schema, d), (d) => collectionConfig.getId(d));
+			put(data) {
+				ensureSnapshot(name);
+				const { id, doc } = col.put(data);
+				recordChange(name, "put", id);
+				return doc;
 			},
-			patch: (collection, id, data) => {
-				const cloned = ensureCloned(collection);
-				const collectionConfig = this.#config[collection];
-				event[collection] = true;
-				return doPatch(cloned.documents, id, data, this.#getNextStamp(), (d) => validate(collectionConfig.schema, d));
+			patch(id, data) {
+				ensureSnapshot(name);
+				const { doc } = col.patch(id, data);
+				recordChange(name, "patch", id);
+				return doc;
 			},
-			remove: (collection, id) => {
-				const cloned = ensureCloned(collection);
-				event[collection] = true;
-				doRemove(cloned.documents, cloned.tombstones, id, this.#getNextStamp());
+			remove(id) {
+				ensureSnapshot(name);
+				col.remove(id);
+				recordChange(name, "remove", id);
 			}
-		});
-		for (const name of Object.keys(clonedStates)) this.#state.collections[name] = clonedStates[name];
-		if (Object.keys(event).length > 0) this.#emitter.emit(event);
-		return result;
-	}
-};
-function createStore(config) {
-	return new Store(config);
-}
-
-//#endregion
-//#region lib/persisters/broadcast-sync.ts
-/**
-* Cross-tab synchronization via BroadcastChannel.
-* Handles environments where BroadcastChannel is unavailable.
-*/
-var BroadcastSync = class {
-	#channel = null;
-	#onMessage;
-	constructor(options) {
-		this.#onMessage = options.onMessage;
-		try {
-			this.#channel = new globalThis.BroadcastChannel(options.channelName);
-			this.#channel.onmessage = (event) => {
-				if (event.data?.type === "state-update" && event.data?.state) try {
-					const incomingState = event.data.state;
-					this.#onMessage(incomingState);
-				} catch (error) {
-					console.warn("[BroadcastSync] Failed to process message:", error);
-				}
-			};
-		} catch (error) {
-			console.warn("[BroadcastSync] BroadcastChannel not available:", error);
-		}
-	}
-	/**
-	* Broadcast state to other tabs. Does nothing if BroadcastChannel is unavailable.
-	*/
-	broadcast(state) {
-		if (!this.#channel) return;
-		try {
-			this.#channel.postMessage({
-				type: "state-update",
-				state
-			});
-		} catch (error) {
-			console.warn("[BroadcastSync] Failed to broadcast:", error);
-		}
-	}
-	/**
-	* Close the BroadcastChannel and clean up resources.
-	*/
-	close() {
-		if (this.#channel) {
-			this.#channel.close();
-			this.#channel = null;
-		}
-	}
-	/**
-	* Check if BroadcastChannel is available and connected.
-	*/
-	get available() {
-		return this.#channel !== null;
-	}
-};
-
-//#endregion
-//#region lib/persisters/idb-persister.ts
-const DEFAULT_DEBOUNCE_MS = 300;
-const DB_VERSION = 1;
-const DEFAULT_STORE_NAME = "state";
-const STORE_KEY = "store";
-var IdbPersister = class {
-	#store;
-	#config;
-	#debounceTimer = null;
-	#sync;
-	#emitter;
-	#unsubscribe = null;
-	#db = null;
-	constructor(store, options) {
-		this.#store = store;
-		this.#config = {
-			key: options.key,
-			debounceMs: options.debounceMs ?? DEFAULT_DEBOUNCE_MS,
-			storeName: options.storeName ?? DEFAULT_STORE_NAME,
-			serialize: options.serialize ?? ((s) => JSON.stringify(s)),
-			deserialize: options.deserialize ?? ((s) => JSON.parse(s)),
-			channelName: options.channelName ?? `starling:${options.key}`
 		};
-		this.#emitter = new Emitter();
-		this.#sync = new BroadcastSync({
-			channelName: this.#config.channelName,
-			onMessage: (state) => this.#store.merge(state)
-		});
 	}
-	async #load() {
-		const db = this.#db;
-		if (!db) return null;
-		try {
-			return new Promise((resolve, reject) => {
-				const request = db.transaction([this.#config.storeName], "readonly").objectStore(this.#config.storeName).get(STORE_KEY);
-				request.onerror = () => {
-					reject(/* @__PURE__ */ new Error(`Failed to load state: ${request.error?.message ?? "Unknown error"}`));
-				};
-				request.onsuccess = () => {
-					const result = request.result;
-					if (result) try {
-						resolve(this.#config.deserialize(result));
-					} catch (error) {
-						console.warn("[Starling Persistence] Failed to deserialize state:", error);
-						resolve(null);
-					}
-					else resolve(null);
-				};
+	const collectionAPIs = {};
+	for (const name of Object.keys(collections)) collectionAPIs[name] = buildCollectionAPI(name);
+	return Object.assign(collectionAPIs, {
+		subscribe(callback) {
+			return emitter.subscribe(callback);
+		},
+		getState() {
+			const colStates = {};
+			for (const name of Object.keys(cols)) colStates[name] = cols[name].getState();
+			return structuredClone({
+				clock,
+				collections: colStates
 			});
-		} catch {
-			return null;
-		}
-	}
-	async #save(serialized) {
-		const db = this.#db;
-		if (!db) throw new Error("IndexedDB not initialized. Call init() first.");
-		return new Promise((resolve, reject) => {
-			const request = db.transaction([this.#config.storeName], "readwrite").objectStore(this.#config.storeName).put(serialized, STORE_KEY);
-			request.onerror = () => {
-				reject(/* @__PURE__ */ new Error(`Failed to save state: ${request.error?.message ?? "Unknown error"}`));
-			};
-			request.onsuccess = () => {
-				resolve();
-			};
-		});
-	}
-	async #persist() {
-		try {
-			const state = this.#store.getState();
-			const serialized = this.#config.serialize(state);
-			await this.#save(serialized);
-			this.#sync.broadcast(state);
-			this.#emitter.emit(serialized);
-		} catch (error) {
-			console.warn("[Starling Persistence] Failed to save state:", error);
-		}
-	}
-	#openDB() {
-		return new Promise((resolve, reject) => {
-			const request = indexedDB.open(this.#config.key, DB_VERSION);
-			request.onerror = () => {
-				reject(/* @__PURE__ */ new Error(`Failed to open IndexedDB: ${request.error?.message ?? "Unknown error"}`));
-			};
-			request.onsuccess = () => {
-				resolve(request.result);
-			};
-			request.onupgradeneeded = (event) => {
-				const db = event.target.result;
-				if (!db.objectStoreNames.contains(this.#config.storeName)) db.createObjectStore(this.#config.storeName);
-			};
-		});
-	}
-	async init() {
-		try {
-			this.#db = await this.#openDB();
-		} catch (error) {
-			console.warn("[Starling Persistence] Failed to open IndexedDB:", error);
-		}
-		try {
-			const savedState = await this.#load();
-			if (savedState) this.#store.merge(savedState);
-		} catch (error) {
-			console.warn("[Starling Persistence] Failed to load state:", error);
-		}
-		this.#unsubscribe = this.#store.subscribe(() => {
-			if (this.#debounceTimer) clearTimeout(this.#debounceTimer);
-			this.#debounceTimer = setTimeout(() => {
-				this.#debounceTimer = null;
-				this.#persist();
-			}, this.#config.debounceMs);
-		});
-	}
-	async dispose() {
-		if (this.#unsubscribe) {
-			this.#unsubscribe();
-			this.#unsubscribe = null;
-		}
-		if (this.#debounceTimer) {
-			clearTimeout(this.#debounceTimer);
-			this.#debounceTimer = null;
-		}
-		if (this.#db) await this.#persist();
-		if (this.#db) {
-			this.#db.close();
-			this.#db = null;
+		},
+		merge(snapshot) {
+			const diff = {};
+			clock = advanceClock(clock, snapshot.clock);
+			for (const [name, incomingCollectionState] of Object.entries(snapshot.collections)) {
+				const col = cols[name];
+				const { state: mergedState, changes } = mergeCollections(col ? col.getState() : {
+					documents: {},
+					tombstones: {}
+				}, incomingCollectionState);
+				if (changes) {
+					if (col) col.setState(mergedState);
+					if (name in collections) diff[name] = changes;
+				}
+			}
+			if (Object.keys(diff).length > 0) emitter.emit(diff);
+			return diff;
+		},
+		transact(callback) {
+			txSnapshots = /* @__PURE__ */ new Map();
+			transacting = true;
+			pendingEvent = {};
+			try {
+				const result = callback(collectionAPIs);
+				const event = pendingEvent;
+				transacting = false;
+				pendingEvent = null;
+				txSnapshots = null;
+				if (Object.keys(event).length > 0) emitter.emit(event);
+				return result;
+			} catch (e) {
+				for (const [name, snap] of txSnapshots) cols[name].restore(snap);
+				transacting = false;
+				pendingEvent = null;
+				txSnapshots = null;
+				throw e;
+			}
 		}
-		this.#sync.close();
-	}
-	subscribe(listener) {
-		return this.#emitter.subscribe(listener);
-	}
-};
+	});
+}
 
 //#endregion
-export { IdbPersister, KEYS, Store, advanceClock, asStamp, atomize, createReadLens, createStore, define, doGet, doList, doPatch, doPut, doRemove, isAtom, isAtomizedDocument, isCollection, isCollectionState, isDeleted, makeStamp, mergeCollections, mergeDocs, mergeState, mergeTombstones, pack, unpack, validate };
+export { advanceClock, createQuery, createStore, makeStamp };
 //# sourceMappingURL=index.js.map