@byearlybird/starling 0.9.3 → 0.11.0

package/dist/index.js

@@ -1,637 +1,462 @@
-//#region src/crdt/eventstamp.ts
-function generateNonce() {
-	return Math.random().toString(16).slice(2, 6).padStart(4, "0");
-}
-function encodeEventstamp(timestampMs, counter, nonce) {
-	return `${new Date(timestampMs).toISOString()}|${counter.toString(16).padStart(4, "0")}|${nonce}`;
-}
-/**
-* Validates whether a string is a properly formatted eventstamp.
-* Expected format: YYYY-MM-DDTHH:mm:ss.SSSZ|HHHH+|HHHH
-* where HHHH+ represents 4 or more hex characters for the counter,
-* and HHHH represents exactly 4 hex characters for the nonce.
-*/
-function isValidEventstamp(stamp) {
-	return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z\|[0-9a-f]{4,}\|[0-9a-f]{4}$/.test(stamp);
-}
-function decodeEventstamp(eventstamp) {
-	if (!isValidEventstamp(eventstamp)) throw new Error(`Invalid eventstamp format: "${eventstamp}". Expected format: YYYY-MM-DDTHH:mm:ss.SSSZ|HHHH+|HHHH`);
-	const parts = eventstamp.split("|");
-	const isoString = parts[0];
-	const hexCounter = parts[1];
-	const nonce = parts[2];
+import { c as makeResource, i as mapToDocument, l as mergeResources, o as mergeDocuments, s as deleteResource, u as createClock } from "./core-DI0FfUjX.js";
+
+//#region src/database/emitter.ts
+function createEmitter() {
+	const handlers = /* @__PURE__ */ new Map();
 	return {
-		timestampMs: new Date(isoString).getTime(),
-		counter: parseInt(hexCounter, 16),
-		nonce
+		on(type, handler) {
+			let set = handlers.get(type);
+			if (!set) {
+				set = /* @__PURE__ */ new Set();
+				handlers.set(type, set);
+			}
+			set.add(handler);
+			return () => {
+				set?.delete(handler);
+				if (!set?.size) handlers.delete(type);
+			};
+		},
+		emit(type, payload) {
+			const set = handlers.get(type);
+			if (!set) return;
+			for (const handler of Array.from(set)) handler(payload);
+		},
+		clear() {
+			handlers.clear();
+		}
 	};
 }
-const MIN_EVENTSTAMP = encodeEventstamp(0, 0, "0000");
 
 //#endregion
-//#region src/crdt/utils.ts
-function isObject(value) {
-	return !!(value != null && typeof value === "object" && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype);
-}
-function isEncodedValue(value) {
-	return !!(typeof value === "object" && value !== null && "~value" in value && "~eventstamp" in value);
-}
-
-//#endregion
-//#region src/crdt/value.ts
-function encodeValue(value, eventstamp) {
-	return {
-		"~value": value,
-		"~eventstamp": eventstamp
-	};
-}
-function decodeValue(value) {
-	return value["~value"];
-}
-function mergeValues(into, from) {
-	return into["~eventstamp"] > from["~eventstamp"] ? [into, into["~eventstamp"]] : [from, from["~eventstamp"]];
+//#region src/database/standard-schema.ts
+function standardValidate(schema, input) {
+	const result = schema["~standard"].validate(input);
+	if (result instanceof Promise) throw new TypeError("Schema validation must be synchronous");
+	if (result.issues) throw new Error(JSON.stringify(result.issues, null, 2));
+	return result.value;
 }
 
 //#endregion
-//#region src/crdt/record.ts
-function processRecord(source, process) {
-	const result = {};
-	const step = (input, output) => {
-		for (const key in input) {
-			if (!Object.hasOwn(input, key)) continue;
-			const value = input[key];
-			if (isEncodedValue(value)) output[key] = process(value);
-			else if (isObject(value)) {
-				output[key] = {};
-				step(value, output[key]);
-			}
-		}
-	};
-	step(source, result);
-	return result;
-}
-function encodeRecord(obj, eventstamp) {
-	const result = {};
-	const step = (input, output) => {
-		for (const key in input) {
-			if (!Object.hasOwn(input, key)) continue;
-			const value = input[key];
-			if (isObject(value)) {
-				output[key] = {};
-				step(value, output[key]);
-			} else output[key] = encodeValue(value, eventstamp);
-		}
+//#region src/database/collection.ts
+/**
+* Symbols for internal collection methods used by transactions.
+* These are not part of the public Collection type.
+*/
+const CollectionInternals = {
+	getPendingMutations: Symbol("getPendingMutations"),
+	emitMutations: Symbol("emitMutations"),
+	replaceData: Symbol("replaceData"),
+	data: Symbol("data")
+};
+function createCollection(name, schema, getId, getEventstamp, initialData, options) {
+	const autoFlush = options?.autoFlush ?? true;
+	const data = initialData ?? /* @__PURE__ */ new Map();
+	const emitter = createEmitter();
+	const pendingMutations = {
+		added: [],
+		updated: [],
+		removed: []
 	};
-	step(obj, result);
-	return result;
-}
-function decodeRecord(obj) {
-	const result = {};
-	const step = (input, output) => {
-		for (const key in input) {
-			if (!Object.hasOwn(input, key)) continue;
-			const value = input[key];
-			if (isEncodedValue(value)) output[key] = decodeValue(value);
-			else if (isObject(value)) {
-				output[key] = {};
-				step(value, output[key]);
-			}
+	const flushMutations = () => {
+		if (pendingMutations.added.length > 0 || pendingMutations.updated.length > 0 || pendingMutations.removed.length > 0) {
+			emitter.emit("mutation", {
+				added: [...pendingMutations.added],
+				updated: [...pendingMutations.updated],
+				removed: [...pendingMutations.removed]
+			});
+			pendingMutations.added = [];
+			pendingMutations.updated = [];
+			pendingMutations.removed = [];
 		}
 	};
-	step(obj, result);
-	return result;
-}
-function mergeRecords(into, from) {
-	const result = {};
-	let greatestEventstamp = MIN_EVENTSTAMP;
-	const step = (v1, v2, output) => {
-		for (const key in v1) {
-			if (!Object.hasOwn(v1, key)) continue;
-			const value1 = v1[key];
-			const value2 = v2[key];
-			if (isEncodedValue(value1) && isEncodedValue(value2)) {
-				const [win, eventstamp] = mergeValues(value1, value2);
-				output[key] = win;
-				if (eventstamp > greatestEventstamp) greatestEventstamp = eventstamp;
-			} else if (isEncodedValue(value1)) {
-				output[key] = value1;
-				const eventstamp = value1["~eventstamp"];
-				if (eventstamp > greatestEventstamp) greatestEventstamp = eventstamp;
-			} else if (isObject(value1) && isObject(value2)) {
-				output[key] = {};
-				step(value1, value2, output[key]);
-			} else if (value1) output[key] = value1;
-		}
-		for (const key in v2) {
-			if (!Object.hasOwn(v2, key) || Object.hasOwn(output, key)) continue;
-			const value = v2[key];
-			if (value !== void 0) {
-				output[key] = value;
-				if (isEncodedValue(value)) {
-					const eventstamp = value["~eventstamp"];
-					if (eventstamp > greatestEventstamp) greatestEventstamp = eventstamp;
+	return {
+		get(id, opts = {}) {
+			const resource = data.get(id);
+			if (!resource) return null;
+			if (!opts.includeDeleted && resource.meta.deletedAt) return null;
+			return resource.attributes;
+		},
+		getAll(opts = {}) {
+			const resources = Array.from(data.values());
+			if (opts.includeDeleted) return resources.map((resource) => resource.attributes);
+			else return resources.filter((resource) => !resource.meta.deletedAt).map((resource) => resource.attributes);
+		},
+		find(filter, opts) {
+			const results = [];
+			for (const [, resource] of data.entries()) {
+				if (resource.meta.deletedAt) continue;
+				const attributes = resource.attributes;
+				if (filter(attributes)) {
+					const value = opts?.map ? opts.map(attributes) : attributes;
+					results.push(value);
 				}
 			}
+			if (opts?.sort) results.sort(opts.sort);
+			return results;
+		},
+		add(item) {
+			const validated = standardValidate(schema, item);
+			const id = getId(validated);
+			if (data.has(id)) throw new DuplicateIdError(id);
+			const resource = makeResource(name, id, validated, getEventstamp());
+			data.set(id, resource);
+			pendingMutations.added.push({
+				id,
+				item: validated
+			});
+			if (autoFlush) flushMutations();
+			return validated;
+		},
+		update(id, updates) {
+			const existing = data.get(id);
+			if (!existing) throw new IdNotFoundError(id);
+			const before = existing.attributes;
+			const merged = mergeResources(existing, makeResource(name, id, updates, getEventstamp()));
+			standardValidate(schema, merged.attributes);
+			data.set(id, merged);
+			pendingMutations.updated.push({
+				id,
+				before,
+				after: merged.attributes
+			});
+			if (autoFlush) flushMutations();
+		},
+		remove(id) {
+			const existing = data.get(id);
+			if (!existing) throw new IdNotFoundError(id);
+			const item = existing.attributes;
+			const removed = deleteResource(existing, getEventstamp());
+			data.set(id, removed);
+			pendingMutations.removed.push({
+				id,
+				item
+			});
+			if (autoFlush) flushMutations();
+		},
+		merge(document) {
+			const beforeState = /* @__PURE__ */ new Map();
+			for (const [id, resource] of data.entries()) beforeState.set(id, resource.attributes);
+			const result = mergeDocuments(mapToDocument(data, getEventstamp()), document);
+			data.clear();
+			for (const resource of result.document.data) data.set(resource.id, resource);
+			for (const [id, resource] of result.changes.added) {
+				standardValidate(schema, resource.attributes);
+				pendingMutations.added.push({
+					id,
+					item: resource.attributes
+				});
+			}
+			for (const [id, resource] of result.changes.updated) {
+				standardValidate(schema, resource.attributes);
+				const before = beforeState.get(id);
+				pendingMutations.updated.push({
+					id,
+					before,
+					after: resource.attributes
+				});
+			}
+			for (const id of result.changes.deleted) {
+				const before = beforeState.get(id);
+				pendingMutations.removed.push({
+					id,
+					item: before
+				});
+			}
+			if (autoFlush) flushMutations();
+		},
+		toDocument() {
+			return mapToDocument(data, getEventstamp());
+		},
+		on(event, handler) {
+			return emitter.on(event, handler);
+		},
+		[CollectionInternals.data]() {
+			return new Map(data);
+		},
+		[CollectionInternals.getPendingMutations]() {
+			return {
+				added: [...pendingMutations.added],
+				updated: [...pendingMutations.updated],
+				removed: [...pendingMutations.removed]
+			};
+		},
+		[CollectionInternals.emitMutations](mutations) {
+			if (mutations.added.length > 0 || mutations.updated.length > 0 || mutations.removed.length > 0) emitter.emit("mutation", mutations);
+		},
+		[CollectionInternals.replaceData](newData) {
+			data.clear();
+			for (const [id, resource] of newData.entries()) data.set(id, resource);
 		}
 	};
-	step(into, from, result);
-	return [result, greatestEventstamp];
 }
+var IdNotFoundError = class extends Error {
+	constructor(id) {
+		super(`Resource with id ${id} not found`);
+		this.name = "IdNotFoundError";
+	}
+};
+var DuplicateIdError = class extends Error {
+	constructor(id) {
+		super(`Resource with id ${id} already exists`);
+		this.name = "DuplicateIdError";
+	}
+};
 
 //#endregion
-//#region src/crdt/document.ts
-function encodeDoc(id, obj, eventstamp, deletedAt = null) {
-	return {
-		"~id": id,
-		"~data": isObject(obj) ? encodeRecord(obj, eventstamp) : encodeValue(obj, eventstamp),
-		"~deletedAt": deletedAt
+//#region src/database/query.ts
+/**
+* Execute a reactive query with automatic re-computation on mutations.
+*
+* @param db - Database instance to query
+* @param callback - Query callback receiving read-only collection handles
+* @returns QueryHandle with result, subscribe, and dispose methods
+*/
+function executeQuery(db, callback) {
+	const accessedCollections = /* @__PURE__ */ new Set();
+	const subscribers = /* @__PURE__ */ new Set();
+	let currentResult;
+	const createTrackingHandles = () => {
+		const handles = {};
+		for (const name of db.collectionKeys()) {
+			const collection = db[name];
+			handles[name] = createTrackingHandle(name, collection, accessedCollections);
+		}
+		return handles;
 	};
-}
-function decodeDoc(doc) {
-	return {
-		"~id": doc["~id"],
-		"~data": isEncodedValue(doc["~data"]) ? decodeValue(doc["~data"]) : decodeRecord(doc["~data"]),
-		"~deletedAt": doc["~deletedAt"]
+	const runQuery = () => {
+		return callback(createTrackingHandles());
 	};
-}
-function mergeDocs(into, from) {
-	const intoIsValue = isEncodedValue(into["~data"]);
-	const fromIsValue = isEncodedValue(from["~data"]);
-	if (intoIsValue !== fromIsValue) throw new Error("Merge error: Incompatible types");
-	const [mergedData, dataEventstamp] = intoIsValue && fromIsValue ? mergeValues(into["~data"], from["~data"]) : mergeRecords(into["~data"], from["~data"]);
-	const mergedDeletedAt = into["~deletedAt"] && from["~deletedAt"] ? into["~deletedAt"] > from["~deletedAt"] ? into["~deletedAt"] : from["~deletedAt"] : into["~deletedAt"] || from["~deletedAt"] || null;
-	let greatestEventstamp = dataEventstamp;
-	if (mergedDeletedAt && mergedDeletedAt > greatestEventstamp) greatestEventstamp = mergedDeletedAt;
-	return [{
-		"~id": into["~id"],
-		"~data": mergedData,
-		"~deletedAt": mergedDeletedAt
-	}, greatestEventstamp];
-}
-function deleteDoc(doc, eventstamp) {
+	currentResult = runQuery();
+	const unsubscribeMutation = db.on("mutation", (event) => {
+		if (accessedCollections.has(event.collection)) {
+			currentResult = runQuery();
+			for (const subscriber of subscribers) subscriber(currentResult);
+		}
+	});
+	let disposed = false;
 	return {
-		"~id": doc["~id"],
-		"~data": doc["~data"],
-		"~deletedAt": eventstamp
+		get result() {
+			return currentResult;
+		},
+		subscribe(callback$1) {
+			if (disposed) throw new Error("Cannot subscribe to a disposed query");
+			subscribers.add(callback$1);
+			return () => {
+				subscribers.delete(callback$1);
+			};
+		},
+		dispose() {
+			if (disposed) return;
+			disposed = true;
+			unsubscribeMutation();
+			subscribers.clear();
+			accessedCollections.clear();
+		}
 	};
 }
 /**
-* Transform all values in a document using a provided function.
-*
-* Useful for custom serialization in plugin hooks (encryption, compression, etc.)
-*
-* @param doc - Document to transform
-* @param process - Function to apply to each leaf value
-* @returns New document with transformed values
-*
-* @example
-* ```ts
-* // Encrypt all values before persisting
-* const encrypted = processDocument(doc, (value) => ({
-*   ...value,
-*   "~value": encrypt(value["~value"])
-* }));
-* ```
+* Create a read-only collection handle that tracks access.
 */
-function processDocument(doc, process) {
-	const processedData = isEncodedValue(doc["~data"]) ? process(doc["~data"]) : processRecord(doc["~data"], process);
+function createTrackingHandle(name, collection, accessedCollections) {
+	const trackAccess = () => {
+		accessedCollections.add(name);
+	};
 	return {
-		"~id": doc["~id"],
-		"~data": processedData,
-		"~deletedAt": doc["~deletedAt"]
+		get(id, opts) {
+			trackAccess();
+			return collection.get(id, opts);
+		},
+		getAll(opts) {
+			trackAccess();
+			return collection.getAll(opts);
+		},
+		find(filter, opts) {
+			trackAccess();
+			return collection.find(filter, opts);
+		}
 	};
 }
 
 //#endregion
-//#region src/crdt/collection.ts
+//#region src/database/transaction.ts
 /**
-* Merges two collections using field-level Last-Write-Wins semantics.
-*
-* The merge operation:
-* 1. Forwards the clock to the newest eventstamp from either collection
-* 2. Merges each document pair using field-level LWW (via mergeDocs)
-* 3. Tracks what changed for hook notifications (added/updated/deleted)
-*
-* Deletion is final: once a document is deleted, updates to it are merged into
-* the document's data but don't restore visibility. Only new documents or
-* transitions into the deleted state are tracked.
+* Execute a transaction with snapshot isolation and copy-on-write optimization.
 *
-* @param into - The base collection to merge into
-* @param from - The source collection to merge from
-* @returns Merged collection and categorized changes
+* @param configs - Collection configurations for creating new instances
+* @param collections - Active collection instances (mutable reference)
+* @param getEventstamp - Function to generate eventstamps
+* @param callback - Transaction callback with tx context
+* @returns The return value from the callback
 *
-* @example
-* ```typescript
-* const into = {
-*   "~docs": [{ "~id": "doc1", "~data": {...}, "~deletedAt": null }],
-*   "~eventstamp": "2025-01-01T00:00:00.000Z|0001|a1b2"
-* };
-*
-* const from = {
-*   "~docs": [
-*     { "~id": "doc1", "~data": {...}, "~deletedAt": null }, // updated
-*     { "~id": "doc2", "~data": {...}, "~deletedAt": null }  // new
-*   ],
-*   "~eventstamp": "2025-01-01T00:05:00.000Z|0001|c3d4"
-* };
-*
-* const result = mergeCollections(into, from);
-* // result.collection.~eventstamp === "2025-01-01T00:05:00.000Z|0001|c3d4"
-* // result.changes.added has "doc2"
-* // result.changes.updated has "doc1"
-* ```
+* @remarks
+* - Collections are cloned lazily on first access (read or write)
+* - Provides snapshot isolation: tx sees consistent data from first access
+* - Explicit rollback via tx.rollback() or implicit on exception
+* - Only modified collections are committed back
 */
-function mergeCollections(into, from) {
-	const intoDocsById = /* @__PURE__ */ new Map();
-	for (const doc of into["~docs"]) intoDocsById.set(doc["~id"], doc);
-	const added = /* @__PURE__ */ new Map();
-	const updated = /* @__PURE__ */ new Map();
-	const deleted = /* @__PURE__ */ new Set();
-	const mergedDocsById = new Map(intoDocsById);
-	for (const fromDoc of from["~docs"]) {
-		const id = fromDoc["~id"];
-		const intoDoc = intoDocsById.get(id);
-		if (!intoDoc) {
-			mergedDocsById.set(id, fromDoc);
-			if (!fromDoc["~deletedAt"]) added.set(id, fromDoc);
-		} else {
-			if (intoDoc === fromDoc) continue;
-			const [mergedDoc] = mergeDocs(intoDoc, fromDoc);
-			mergedDocsById.set(id, mergedDoc);
-			const wasDeleted = intoDoc["~deletedAt"] !== null;
-			const isDeleted = mergedDoc["~deletedAt"] !== null;
-			if (!wasDeleted && isDeleted) deleted.add(id);
-			else if (!isDeleted) updated.set(id, mergedDoc);
-		}
+function executeTransaction(configs, collections, getEventstamp, callback) {
+	const clonedCollections = /* @__PURE__ */ new Map();
+	const txHandles = {};
+	for (const name of Object.keys(collections)) {
+		const originalCollection = collections[name];
+		const config = configs[name];
+		const getClonedCollection = () => {
+			if (!clonedCollections.has(name)) {
+				const cloned = createCollection(name, config.schema, config.getId, getEventstamp, originalCollection[CollectionInternals.data](), { autoFlush: false });
+				clonedCollections.set(name, cloned);
+			}
+			return clonedCollections.get(name);
+		};
+		txHandles[name] = createLazyTransactionHandle(originalCollection, getClonedCollection);
 	}
-	const newestEventstamp = into["~eventstamp"] >= from["~eventstamp"] ? into["~eventstamp"] : from["~eventstamp"];
-	return {
-		collection: {
-			"~docs": Array.from(mergedDocsById.values()),
-			"~eventstamp": newestEventstamp
-		},
-		changes: {
-			added,
-			updated,
-			deleted
+	let shouldRollback = false;
+	const tx = {
+		...txHandles,
+		rollback() {
+			shouldRollback = true;
 		}
 	};
+	let result;
+	result = callback(tx);
+	if (!shouldRollback) for (const [name, clonedCollection] of clonedCollections.entries()) {
+		const originalCollection = collections[name];
+		const pendingMutations = clonedCollection[CollectionInternals.getPendingMutations]();
+		originalCollection[CollectionInternals.replaceData](clonedCollection[CollectionInternals.data]());
+		originalCollection[CollectionInternals.emitMutations](pendingMutations);
+	}
+	return result;
 }
-
-//#endregion
-//#region src/clock.ts
 /**
-* A Hybrid Logical Clock that generates monotonically increasing eventstamps.
-* Combines wall-clock time with a counter for handling clock stalls and a
-* random nonce for tie-breaking.
+* Create a transaction handle that lazily clones on first access (copy-on-write).
+*
+* @param originalCollection - The base collection (not modified)
+* @param getClonedCollection - Lazy cloner (invoked on first access)
+* @returns A collection handle with snapshot isolation
 *
-* The clock automatically increments the counter when the wall clock doesn't
-* advance, ensuring eventstamps are always unique and monotonic.
+* @remarks
+* First read or write triggers cloning, providing snapshot isolation.
+* All subsequent operations use the cloned collection.
+* Excluded methods:
+* - on(): events are only emitted after the transaction commits
+* - toDocument(): serialization should happen outside transactions
 */
-var Clock = class {
-	#counter = 0;
-	#lastMs = Date.now();
-	#lastNonce = generateNonce();
-	/** Generates a new eventstamp, advancing the clock */
-	now() {
-		const wallMs = Date.now();
-		if (wallMs > this.#lastMs) {
-			this.#lastMs = wallMs;
-			this.#counter = 0;
-			this.#lastNonce = generateNonce();
-		} else {
-			this.#counter++;
-			this.#lastNonce = generateNonce();
-		}
-		return encodeEventstamp(this.#lastMs, this.#counter, this.#lastNonce);
-	}
-	/** Returns the most recent eventstamp without advancing the clock */
-	latest() {
-		return encodeEventstamp(this.#lastMs, this.#counter, this.#lastNonce);
-	}
-	/** Fast-forwards the clock to match a newer remote eventstamp */
-	forward(eventstamp) {
-		if (eventstamp > this.latest()) {
-			const newer = decodeEventstamp(eventstamp);
-			this.#lastMs = newer.timestampMs;
-			this.#counter = newer.counter;
-			this.#lastNonce = newer.nonce;
+function createLazyTransactionHandle(_originalCollection, getClonedCollection) {
+	let cloned = null;
+	const ensureCloned = () => {
+		if (!cloned) cloned = getClonedCollection();
+		return cloned;
+	};
+	return {
+		get(id, opts) {
+			return ensureCloned().get(id, opts);
+		},
+		getAll(opts) {
+			return ensureCloned().getAll(opts);
+		},
+		find(filter, opts) {
+			return ensureCloned().find(filter, opts);
+		},
+		add(item) {
+			return ensureCloned().add(item);
+		},
+		update(id, updates) {
+			ensureCloned().update(id, updates);
+		},
+		remove(id) {
+			ensureCloned().remove(id);
+		},
+		merge(document) {
+			ensureCloned().merge(document);
 		}
-	}
-};
+	};
+}
 
 //#endregion
-//#region src/store.ts
+//#region src/database/db.ts
 /**
-* Lightweight local-first data store with built-in sync and reactive queries.
-*
-* Stores plain JavaScript objects with automatic field-level conflict resolution
-* using Last-Write-Wins semantics powered by hybrid logical clocks.
-*
-* @template T - The type of documents stored in this collection
+* Create a typed database instance with collection access.
+* @param config - Database configuration
+* @param config.name - Database name used for persistence and routing
+* @param config.schema - Collection schema definitions
+* @param config.version - Optional database version, defaults to 1
+* @returns A database instance with typed collection properties
 *
 * @example
-* ```ts
-* const store = await new Store<{ text: string; completed: boolean }>()
-*   .use(unstoragePlugin('todos', storage))
+* ```typescript
+* const db = await createDatabase({
+*   name: "my-app",
+*   schema: {
+*     tasks: { schema: taskSchema, getId: (task) => task.id },
+*   },
+* })
+*   .use(idbPlugin())
 *   .init();
 *
-* // Add, update, delete
-* const id = store.add({ text: 'Buy milk', completed: false });
-* store.update(id, { completed: true });
-* store.del(id);
-*
-* // Reactive queries
-* const activeTodos = store.query({ where: (todo) => !todo.completed });
-* activeTodos.onChange(() => console.log('Todos changed!'));
+* const task = db.tasks.add({ title: 'Learn Starling' });
 * ```
 */
-var Store = class {
-	#readMap = /* @__PURE__ */ new Map();
-	#clock = new Clock();
-	#getId;
-	#onInitHandlers = [];
-	#onDisposeHandlers = [];
-	#onAddHandlers = [];
-	#onUpdateHandlers = [];
-	#onDeleteHandlers = [];
-	#queries = /* @__PURE__ */ new Set();
-	constructor(config = {}) {
-		this.#getId = config.getId ?? (() => crypto.randomUUID());
-	}
-	/**
-	* Get a document by ID.
-	* @returns The document, or null if not found or deleted
-	*/
-	get(key) {
-		return this.#decodeActive(this.#readMap.get(key) ?? null);
-	}
-	/**
-	* Iterate over all non-deleted documents as [id, document] tuples.
-	*/
-	entries() {
-		const self = this;
-		function* iterator() {
-			for (const [key, doc] of self.#readMap.entries()) {
-				const data = self.#decodeActive(doc);
-				if (data !== null) yield [key, data];
-			}
-		}
-		return iterator();
-	}
-	/**
-	* Get the complete store state as a Collection for persistence or sync.
-	* @returns Collection containing all documents and the latest eventstamp
-	*/
-	collection() {
-		return {
-			"~docs": Array.from(this.#readMap.values()),
-			"~eventstamp": this.#clock.latest()
-		};
-	}
-	/**
-	* Merge a collection from storage or another replica using field-level LWW.
-	* @param collection - Collection from storage or another store instance
-	*/
-	merge(collection) {
-		const result = mergeCollections(this.collection(), collection);
-		this.#clock.forward(result.collection["~eventstamp"]);
-		this.#readMap = new Map(result.collection["~docs"].map((doc) => [doc["~id"], doc]));
-		const addEntries = Array.from(result.changes.added.entries()).map(([key, doc]) => [key, decodeDoc(doc)["~data"]]);
-		const updateEntries = Array.from(result.changes.updated.entries()).map(([key, doc]) => [key, decodeDoc(doc)["~data"]]);
-		const deleteKeys = Array.from(result.changes.deleted);
-		if (addEntries.length > 0 || updateEntries.length > 0 || deleteKeys.length > 0) this.#emitMutations(addEntries, updateEntries, deleteKeys);
-	}
-	/**
-	* Run multiple operations in a transaction with rollback support.
-	*
-	* @param callback - Function receiving a transaction context
-	* @param opts - Optional config. Use `silent: true` to skip plugin hooks.
-	* @returns The callback's return value
-	*
-	* @example
-	* ```ts
-	* const id = store.begin((tx) => {
-	*   const newId = tx.add({ text: 'Buy milk' });
-	*   tx.update(newId, { priority: 'high' });
-	*   return newId; // Return value becomes begin()'s return value
-	* });
-	* ```
-	*/
-	begin(callback, opts) {
-		const silent = opts?.silent ?? false;
-		const addEntries = [];
-		const updateEntries = [];
-		const deleteKeys = [];
-		const staging = new Map(this.#readMap);
-		let rolledBack = false;
-		const result = callback({
-			add: (value, options) => {
-				const key = options?.withId ?? this.#getId();
-				staging.set(key, this.#encodeValue(key, value));
-				addEntries.push([key, value]);
-				return key;
-			},
-			update: (key, value) => {
-				const doc = encodeDoc(key, value, this.#clock.now());
-				const prev = staging.get(key);
-				const mergedDoc = prev ? mergeDocs(prev, doc)[0] : doc;
-				staging.set(key, mergedDoc);
-				const merged = this.#decodeActive(mergedDoc);
-				if (merged !== null) updateEntries.push([key, merged]);
-			},
-			merge: (doc) => {
-				const existing = staging.get(doc["~id"]);
-				const mergedDoc = existing ? mergeDocs(existing, doc)[0] : doc;
-				staging.set(doc["~id"], mergedDoc);
-				const decoded = this.#decodeActive(mergedDoc);
-				const isNew = !this.#readMap.has(doc["~id"]);
-				if (mergedDoc["~deletedAt"]) deleteKeys.push(doc["~id"]);
-				else if (decoded !== null) if (isNew) addEntries.push([doc["~id"], decoded]);
-				else updateEntries.push([doc["~id"], decoded]);
-			},
-			del: (key) => {
-				const currentDoc = staging.get(key);
-				if (!currentDoc) return;
-				staging.set(key, deleteDoc(currentDoc, this.#clock.now()));
-				deleteKeys.push(key);
-			},
-			get: (key) => this.#decodeActive(staging.get(key) ?? null),
-			rollback: () => {
-				rolledBack = true;
-			}
+function createDatabase(config) {
+	const { name, schema, version = 1 } = config;
+	const clock = createClock();
+	const getEventstamp = () => clock.now();
+	const collections = makeCollections(schema, getEventstamp);
+	const publicCollections = collections;
+	const dbEmitter = createEmitter();
+	for (const collectionName of Object.keys(collections)) collections[collectionName].on("mutation", (mutations) => {
+		if (mutations.added.length > 0 || mutations.updated.length > 0 || mutations.removed.length > 0) dbEmitter.emit("mutation", {
+			collection: collectionName,
+			added: mutations.added,
+			updated: mutations.updated,
+			removed: mutations.removed
 		});
-		if (!rolledBack) {
-			this.#readMap = staging;
-			if (!silent) this.#emitMutations(addEntries, updateEntries, deleteKeys);
-		}
-		return result;
-	}
-	/**
-	* Add a document to the store.
-	* @returns The document's ID (generated or provided via options)
-	*/
-	add(value, options) {
-		return this.begin((tx) => tx.add(value, options));
-	}
-	/**
-	* Update a document with a partial value.
-	*
-	* Uses field-level merge - only specified fields are updated.
-	*/
-	update(key, value) {
-		this.begin((tx) => tx.update(key, value));
-	}
-	/**
-	* Soft-delete a document.
-	*
-	* Deleted docs remain in snapshots for sync purposes but are
-	* excluded from queries and reads.
-	*/
-	del(key) {
-		this.begin((tx) => tx.del(key));
-	}
-	/**
-	* Register a plugin for persistence, analytics, etc.
-	* @returns This store instance for chaining
-	*/
-	use(plugin) {
-		this.#onInitHandlers.push(plugin.onInit);
-		this.#onDisposeHandlers.push(plugin.onDispose);
-		if (plugin.onAdd) this.#onAddHandlers.push(plugin.onAdd);
-		if (plugin.onUpdate) this.#onUpdateHandlers.push(plugin.onUpdate);
-		if (plugin.onDelete) this.#onDeleteHandlers.push(plugin.onDelete);
-		return this;
-	}
-	/**
-	* Initialize the store and run plugin onInit hooks.
-	*
-	* Must be called before using the store. Runs plugin setup (hydrate
-	* snapshots, start pollers, etc.) and hydrates existing queries.
-	*
-	* @returns This store instance for chaining
-	*/
-	async init() {
-		for (const hook of this.#onInitHandlers) await hook(this);
-		for (const query of this.#queries) this.#hydrateQuery(query);
-		return this;
-	}
-	/**
-	* Dispose the store and run plugin cleanup.
-	*
-	* Flushes pending operations, clears queries, and runs plugin teardown.
-	* Call when shutting down to avoid memory leaks.
-	*/
-	async dispose() {
-		for (let i = this.#onDisposeHandlers.length - 1; i >= 0; i--) await this.#onDisposeHandlers[i]?.();
-		for (const query of this.#queries) {
-			query.callbacks.clear();
-			query.results.clear();
-		}
-		this.#queries.clear();
-		this.#onInitHandlers = [];
-		this.#onDisposeHandlers = [];
-		this.#onAddHandlers = [];
-		this.#onUpdateHandlers = [];
-		this.#onDeleteHandlers = [];
-	}
-	/**
-	* Create a reactive query that auto-updates when matching docs change.
-	*
-	* @example
-	* ```ts
-	* const active = store.query({ where: (todo) => !todo.completed });
-	* active.results(); // [[id, todo], ...]
-	* active.onChange(() => console.log('Updated!'));
-	* active.dispose(); // Clean up when done
-	* ```
-	*/
-	query(config) {
-		const query = {
-			where: config.where,
-			select: config.select,
-			order: config.order,
-			results: /* @__PURE__ */ new Map(),
-			callbacks: /* @__PURE__ */ new Set()
-		};
-		this.#queries.add(query);
-		this.#hydrateQuery(query);
-		return {
-			results: () => {
-				if (query.order) return Array.from(query.results).sort(([, a], [, b]) => query.order(a, b));
-				return Array.from(query.results);
-			},
-			onChange: (callback) => {
-				query.callbacks.add(callback);
-				return () => {
-					query.callbacks.delete(callback);
-				};
-			},
-			dispose: () => {
-				this.#queries.delete(query);
-				query.callbacks.clear();
-				query.results.clear();
-			}
-		};
-	}
-	#encodeValue(key, value) {
-		return encodeDoc(key, value, this.#clock.now());
-	}
-	#decodeActive(doc) {
-		if (!doc || doc["~deletedAt"]) return null;
-		return decodeDoc(doc)["~data"];
-	}
-	#emitMutations(addEntries, updateEntries, deleteKeys) {
-		this.#notifyQueries(addEntries, updateEntries, deleteKeys);
-		if (addEntries.length > 0) for (const handler of this.#onAddHandlers) handler(addEntries);
-		if (updateEntries.length > 0) for (const handler of this.#onUpdateHandlers) handler(updateEntries);
-		if (deleteKeys.length > 0) for (const handler of this.#onDeleteHandlers) handler(deleteKeys);
-	}
-	#notifyQueries(addEntries, updateEntries, deleteKeys) {
-		if (this.#queries.size === 0) return;
-		const dirtyQueries = /* @__PURE__ */ new Set();
-		if (addEntries.length > 0) {
-			for (const [key, value] of addEntries) for (const query of this.#queries) if (query.where(value)) {
-				const selected = this.#selectValue(query, value);
-				query.results.set(key, selected);
-				dirtyQueries.add(query);
-			}
-		}
-		if (updateEntries.length > 0) for (const [key, value] of updateEntries) for (const query of this.#queries) {
-			const matches = query.where(value);
-			const inResults = query.results.has(key);
-			if (matches && !inResults) {
-				const selected = this.#selectValue(query, value);
-				query.results.set(key, selected);
-				dirtyQueries.add(query);
-			} else if (!matches && inResults) {
-				query.results.delete(key);
-				dirtyQueries.add(query);
-			} else if (matches && inResults) {
-				const selected = this.#selectValue(query, value);
-				query.results.set(key, selected);
-				dirtyQueries.add(query);
+	});
+	const plugins = [];
+	const db = {
+		...publicCollections,
+		name,
+		version,
+		begin(callback) {
+			return executeTransaction(schema, collections, getEventstamp, callback);
+		},
+		query(callback) {
+			return executeQuery(db, callback);
+		},
+		toDocuments() {
+			const documents = {};
+			for (const dbName of Object.keys(collections)) documents[dbName] = collections[dbName].toDocument();
+			return documents;
+		},
+		on(event, handler) {
+			return dbEmitter.on(event, handler);
+		},
+		use(plugin) {
+			plugins.push(plugin);
+			return db;
+		},
+		async init() {
+			for (const plugin of plugins) if (plugin.handlers.init) await plugin.handlers.init(db);
+			return db;
+		},
+		async dispose() {
+			for (let i = plugins.length - 1; i >= 0; i--) {
+				const plugin = plugins[i];
+				if (plugin?.handlers.dispose) await plugin.handlers.dispose(db);
 			}
+		},
+		collectionKeys() {
+			return Object.keys(collections);
 		}
-		if (deleteKeys.length > 0) {
-			for (const key of deleteKeys) for (const query of this.#queries) if (query.results.delete(key)) dirtyQueries.add(query);
-		}
-		if (dirtyQueries.size > 0) this.#runQueryCallbacks(dirtyQueries);
-	}
-	#runQueryCallbacks(dirtyQueries) {
-		for (const query of dirtyQueries) for (const callback of query.callbacks) callback();
-	}
-	#hydrateQuery(query) {
-		query.results.clear();
-		for (const [key, value] of this.entries()) if (query.where(value)) {
-			const selected = this.#selectValue(query, value);
-			query.results.set(key, selected);
-		}
-	}
-	#selectValue(query, value) {
-		return query.select ? query.select(value) : value;
+	};
+	return db;
+}
+function makeCollections(configs, getEventstamp) {
+	const collections = {};
+	for (const name of Object.keys(configs)) {
+		const config = configs[name];
+		collections[name] = createCollection(name, config.schema, config.getId, getEventstamp);
 	}
-};
+	return collections;
+}
 
 //#endregion
-export { Store, mergeCollections, processDocument };
+export { CollectionInternals, DuplicateIdError, IdNotFoundError, createDatabase };