@byearlybird/starling 0.11.1 → 0.13.0

package/dist/index.js

@@ -1,35 +1,7 @@
-import { c as makeResource, i as mapToDocument, l as mergeResources, o as mergeDocuments, s as deleteResource, u as createClock } from "./core-DI0FfUjX.js";
+import { atom, batched, computed, map } from "nanostores";
 
-//#region src/database/emitter.ts
-function createEmitter() {
-	const handlers = /* @__PURE__ */ new Map();
-	return {
-		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();
-		}
-	};
-}
-
-//#endregion
-//#region src/database/standard-schema.ts
-function standardValidate(schema, input) {
+//#region lib/store/schema.ts
+function validate(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));
@@ -37,426 +9,335 @@ function standardValidate(schema, input) {
 }
 
 //#endregion
-//#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: []
+//#region lib/core/hex.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;
+function advanceClock(current, next) {
+	if (next.ms > current.ms) return {
+		ms: next.ms,
+		seq: next.seq
 	};
-	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 = [];
-		}
+	else if (next.ms === current.ms) return {
+		ms: current.ms,
+		seq: Math.max(current.seq, next.seq) + 1
 	};
-	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);
-		}
+	else return {
+		ms: current.ms,
+		seq: current.seq + 1
 	};
 }
-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";
-	}
-};
+function makeStamp(ms, seq) {
+	return `${toHex(ms, MS_LENGTH)}${toHex(seq, SEQ_LENGTH)}${nonce(NONCE_LENGTH)}`;
+}
 
 //#endregion
-//#region src/database/query.ts
+//#region lib/core/flatten.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
+* Flattens a nested object into a flat object with dot-notation keys
+* @param obj - The object to flatten
+* @param mapper - Optional callback to transform leaf values
+* @returns A flattened object with dot-notation keys
 */
-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 flatten(obj, mapper) {
+	const result = {};
+	const addLeaf = (value, path) => {
+		if (path) result[path] = mapper ? mapper(value, path) : value;
 	};
-	const runQuery = () => {
-		return callback(createTrackingHandles());
-	};
-	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 {
-		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();
+	function traverse(current, prefix = "") {
+		if (!shouldTraverse(current)) {
+			addLeaf(current, prefix);
+			return;
 		}
-	};
+		for (const [key, value] of Object.entries(current)) traverse(value, prefix ? `${prefix}.${key}` : key);
+	}
+	traverse(obj);
+	return result;
 }
 /**
-* Create a read-only collection handle that tracks access.
+* Unflattens a flat object with dot-notation keys into a nested object
+* @param obj - The flattened object to unflatten
+* @param mapper - Optional callback to transform leaf values before placing them
+* @returns A nested object
 */
-function createTrackingHandle(name, collection, accessedCollections) {
-	const trackAccess = () => {
-		accessedCollections.add(name);
-	};
-	return {
-		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);
+function unflatten(obj, mapper) {
+	const result = {};
+	for (const [path, value] of Object.entries(obj)) {
+		const keys = path.split(".");
+		const mappedValue = mapper ? mapper(value, path) : value;
+		let current = result;
+		for (let i = 0; i < keys.length - 1; i++) {
+			const key = keys[i];
+			if (!(key in current)) current[key] = {};
+			current = current[key];
 		}
-	};
+		const finalKey = keys[keys.length - 1];
+		current[finalKey] = mappedValue;
+	}
+	return result;
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && (value.constructor === Object || Object.getPrototypeOf(value) === null);
+}
+function shouldTraverse(value) {
+	return isPlainObject(value) && Object.keys(value).length > 0;
 }
 
 //#endregion
-//#region src/database/transaction.ts
-/**
-* Execute a transaction with snapshot isolation and copy-on-write optimization.
-*
-* @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
-*
-* @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 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);
+//#region lib/core/document.ts
+function makeDocument(fields, stamp) {
+	return flatten(fields, (value) => ({
+		"~value": value,
+		"~stamp": stamp
+	}));
+}
+function parseDocument(document) {
+	return unflatten(document, (field) => field["~value"]);
+}
+function mergeDocuments(target, source) {
+	const result = {};
+	const keys = new Set([...Object.keys(target), ...Object.keys(source)]);
+	for (const key of keys) {
+		const targetValue = target[key];
+		const sourceValue = source[key];
+		if (targetValue && sourceValue) result[key] = targetValue["~stamp"] > sourceValue["~stamp"] ? targetValue : sourceValue;
+		else if (targetValue) result[key] = targetValue;
+		else if (sourceValue) result[key] = sourceValue;
+		else throw new Error(`Key ${key} not found in either document`);
 	}
-	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 lib/core/tombstone.ts
+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;
 }
-/**
-* 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
-*
-* @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
-*/
-function createLazyTransactionHandle(_originalCollection, getClonedCollection) {
-	let cloned = null;
-	const ensureCloned = () => {
-		if (!cloned) cloned = getClonedCollection();
-		return cloned;
+
+//#endregion
+//#region lib/core/collection.ts
+function mergeCollections$1(target, source) {
+	const mergedTombstones = mergeTombstones(target.tombstones, source.tombstones);
+	const mergedDocuments = {};
+	const allDocumentIds = new Set([...Object.keys(target.documents), ...Object.keys(source.documents)]);
+	for (const id of allDocumentIds) {
+		const targetDoc = target.documents[id];
+		const sourceDoc = source.documents[id];
+		if (mergedTombstones[id]) continue;
+		if (targetDoc && sourceDoc) mergedDocuments[id] = mergeDocuments(targetDoc, sourceDoc);
+		else if (targetDoc) mergedDocuments[id] = targetDoc;
+		else if (sourceDoc) mergedDocuments[id] = sourceDoc;
+	}
+	return {
+		documents: mergedDocuments,
+		tombstones: mergedTombstones
 	};
+}
+
+//#endregion
+//#region lib/store/collection.ts
+function addDocument($documents, config, tick, data) {
+	const getId = defineGetId(config);
+	const valid = validate(config.schema, data);
+	const doc = makeDocument(valid, tick());
+	const id = getId(valid);
+	$documents.setKey(id, doc);
+}
+function removeDocument($documents, $tombstones, tick, id) {
+	$tombstones.setKey(id, tick());
+	$documents.setKey(id, void 0);
+}
+function updateDocument($documents, config, tick, id, document) {
+	const current = $documents.get()[id];
+	if (!current) return;
+	const doc = mergeDocuments(current, makeDocument(document, tick()));
+	validate(config.schema, parseDocument(doc));
+	$documents.setKey(id, doc);
+}
+function mergeCollectionSnapshot($documents, $tombstones, currentSnapshot, incomingSnapshot) {
+	const merged = mergeCollections$1(currentSnapshot, incomingSnapshot);
+	$documents.set(merged.documents);
+	$tombstones.set(merged.tombstones);
+}
+function createCollection(config, clock) {
+	const { $data, $snapshot, $documents, $tombstones } = createCollectionState();
 	return {
-		get(id, opts) {
-			return ensureCloned().get(id, opts);
+		$data,
+		$snapshot,
+		get(key) {
+			return $data.get().get(key);
+		},
+		has(key) {
+			return $data.get().has(key);
+		},
+		keys() {
+			return $data.get().keys();
+		},
+		values() {
+			return $data.get().values();
 		},
-		getAll(opts) {
-			return ensureCloned().getAll(opts);
+		entries() {
+			return $data.get().entries();
 		},
-		find(filter, opts) {
-			return ensureCloned().find(filter, opts);
+		forEach(callbackfn, thisArg) {
+			return $data.get().forEach(callbackfn, thisArg);
 		},
-		add(item) {
-			return ensureCloned().add(item);
+		get size() {
+			return $data.get().size;
 		},
-		update(id, updates) {
-			ensureCloned().update(id, updates);
+		add(data) {
+			addDocument($documents, config, clock.tick, data);
 		},
 		remove(id) {
-			ensureCloned().remove(id);
+			removeDocument($documents, $tombstones, clock.tick, id);
 		},
-		merge(document) {
-			ensureCloned().merge(document);
+		update(id, document) {
+			updateDocument($documents, config, clock.tick, id, document);
+		},
+		merge(snapshot) {
+			mergeCollectionSnapshot($documents, $tombstones, $snapshot.get(), snapshot);
 		}
 	};
 }
+function createCollectionState() {
+	const $documents = map({});
+	const $tombstones = map({});
+	const $snapshot = batched([$documents, $tombstones], parseSnapshot);
+	return {
+		$data: batched([$documents, $tombstones], parseCollection),
+		$snapshot,
+		$documents,
+		$tombstones
+	};
+}
+function hasIdProperty(data) {
+	return typeof data === "object" && data !== null && "id" in data && typeof data.id === "string";
+}
+function parseCollection(documents, tombstones) {
+	const result = /* @__PURE__ */ new Map();
+	for (const [id, doc] of Object.entries(documents)) if (!tombstones[id] && doc) result.set(id, parseDocument(doc));
+	return result;
+}
+function parseSnapshot(documents, tombstones) {
+	return {
+		documents,
+		tombstones
+	};
+}
+function hasGetId(config) {
+	return "getId" in config && typeof config.getId === "function";
+}
+function defineGetId(config) {
+	return hasGetId(config) ? config.getId : defaultGetId;
+}
+function defaultGetId(data) {
+	if (hasIdProperty(data)) return data.id;
+	throw new Error("Schema must have an 'id' property when getId is not provided");
+}
 
 //#endregion
-//#region src/database/db.ts
-/**
-* 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
-* ```typescript
-* const db = await createDatabase({
-*   name: "my-app",
-*   schema: {
-*     tasks: { schema: taskSchema, getId: (task) => task.id },
-*   },
-* })
-*   .use(idbPlugin())
-*   .init();
-*
-* const task = db.tasks.add({ title: 'Learn Starling' });
-* ```
-*/
-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
+//#region lib/store/clock.ts
+function createClock() {
+	const $state = atom(nowClock());
+	const tick = () => {
+		const next = advanceClock($state.get(), nowClock());
+		$state.set(next);
+		return makeStamp(next.ms, next.seq);
+	};
+	const advance = (ms, seq) => {
+		const next = advanceClock($state.get(), {
+			ms,
+			seq
 		});
-	});
-	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);
-			}
+		$state.set(next);
+	};
+	return {
+		$state,
+		tick,
+		advance
+	};
+}
+function nowClock() {
+	return {
+		ms: Date.now(),
+		seq: 0
+	};
+}
+
+//#endregion
+//#region lib/store/store.ts
+function createStore(config) {
+	const clock = createClock();
+	const collections = initCollections(config.collections, clock);
+	const $snapshot = parseCollections(collections, clock.$state);
+	function getCollectionDataStores(collectionNames) {
+		return collectionNames.map((name) => collections[name].$data);
+	}
+	return {
+		...collections,
+		$snapshot,
+		query: (collectionNames, callback) => {
+			return computed(getCollectionDataStores(collectionNames), (...values) => {
+				const entries = collectionNames.map((name, i) => [name, values[i]]);
+				return callback(Object.fromEntries(entries));
+			});
 		},
-		collectionKeys() {
-			return Object.keys(collections);
+		merge: (snapshot) => {
+			clock.advance(snapshot.clock.ms, snapshot.clock.seq);
+			mergeCollections(collections, snapshot.collections);
 		}
 	};
-	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);
+function initCollections(collectionsConfig, clock) {
+	return Object.fromEntries(Object.entries(collectionsConfig).map(([name, config]) => [name, createCollection(config, clock)]));
+}
+function parseCollections(collections, clockState) {
+	const collectionNames = Object.keys(collections);
+	const collectionSnapshotAtoms = [];
+	for (const name of collectionNames) {
+		const collection = collections[name];
+		if (collection) collectionSnapshotAtoms.push(collection.$snapshot);
+	}
+	return batched([clockState, ...collectionSnapshotAtoms], (clock, ...snapshots) => {
+		const collectionsSnapshot = {};
+		for (let i = 0; i < collectionNames.length; i++) {
+			const name = collectionNames[i];
+			const snapshot = snapshots[i];
+			if (name && snapshot !== void 0) collectionsSnapshot[name] = snapshot;
+		}
+		return {
+			clock,
+			collections: collectionsSnapshot
+		};
+	});
+}
+function mergeCollections(target, source) {
+	for (const [collectionName, collectionSnapshot] of Object.entries(source)) {
+		const collection = target[collectionName];
+		if (collection) collection.merge(collectionSnapshot);
 	}
-	return collections;
 }
 
 //#endregion
-export { CollectionInternals, DuplicateIdError, IdNotFoundError, createDatabase };
+export { createStore };
+//# sourceMappingURL=index.js.map