@byearlybird/starling 0.10.0 → 0.11.0

package/dist/index.js

@@ -1,423 +1,462 @@
-//#region src/clock/errors.ts
-var InvalidEventstampError = class extends Error {
-	constructor(eventstamp) {
-		super(`Invalid eventstamp: "${eventstamp}"`);
-		this.name = "InvalidEventstampError";
-	}
-};
+import { c as makeResource, i as mapToDocument, l as mergeResources, o as mergeDocuments, s as deleteResource, u as createClock } from "./core-DI0FfUjX.js";
 
-//#endregion
-//#region src/clock/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}`;
-}
-const EVENTSTAMP_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z\|[0-9a-f]{4,}\|[0-9a-f]{4}$/;
-/**
-* 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 EVENTSTAMP_REGEX.test(stamp);
-}
-function decodeEventstamp(eventstamp) {
-	if (!isValidEventstamp(eventstamp)) throw new InvalidEventstampError(eventstamp);
-	const parts = eventstamp.split("|");
-	const isoString = parts[0];
-	const hexCounter = parts[1];
-	const nonce = parts[2];
+//#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");
-/**
-* Find the maximum eventstamp from an array of eventstamps.
-* Returns MIN_EVENTSTAMP if the array is empty.
-* @param eventstamps - Array of eventstamp strings
-* @returns The maximum eventstamp
-*/
-function maxEventstamp(eventstamps) {
-	if (eventstamps.length === 0) return MIN_EVENTSTAMP;
-	return eventstamps.reduce((max, stamp) => stamp > max ? stamp : max);
+
+//#endregion
+//#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/clock/clock.ts
+//#region src/database/collection.ts
 /**
-* Create a new Clock instance.
-* @param initialState - Optional initial state for the clock
+* Symbols for internal collection methods used by transactions.
+* These are not part of the public Collection type.
 */
-function createClock(initialState) {
-	let counter = initialState?.counter ?? 0;
-	let lastMs = initialState?.lastMs ?? Date.now();
-	let lastNonce = initialState?.lastNonce ?? generateNonce();
-	const now = () => {
-		const wallMs = Date.now();
-		if (wallMs > lastMs) {
-			lastMs = wallMs;
-			counter = 0;
-			lastNonce = generateNonce();
-		} else {
-			counter++;
-			lastNonce = generateNonce();
-		}
-		return encodeEventstamp(lastMs, counter, lastNonce);
+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: []
 	};
-	const latest = () => encodeEventstamp(lastMs, counter, lastNonce);
-	const forward = (eventstamp) => {
-		if (!isValidEventstamp(eventstamp)) throw new InvalidEventstampError(eventstamp);
-		if (eventstamp > latest()) {
-			const newer = decodeEventstamp(eventstamp);
-			lastMs = newer.timestampMs;
-			counter = newer.counter;
-			lastNonce = newer.nonce;
+	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 = [];
 		}
 	};
 	return {
-		now,
-		latest,
-		forward
+		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);
+		}
 	};
 }
-/**
-* Create a Clock from an eventstamp string.
-* @param eventstamp - Eventstamp string to decode and initialize clock from
-* @throws Error if eventstamp is invalid
-*/
-function createClockFromEventstamp(eventstamp) {
-	if (!isValidEventstamp(eventstamp)) throw new Error(`Invalid eventstamp: "${eventstamp}"`);
-	const decoded = decodeEventstamp(eventstamp);
-	return createClock({
-		counter: decoded.counter,
-		lastMs: decoded.timestampMs,
-		lastNonce: decoded.nonce
-	});
-}
-
-//#endregion
-//#region src/document/resource.ts
-function isObject(value) {
-	return value != null && typeof value === "object" && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
-}
-/**
-* Get a value from a nested object using a dot-separated path.
-* @internal
-*/
-function getValueAtPath(obj, path) {
-	const parts = path.split(".");
-	let current = obj;
-	for (const part of parts) {
-		if (current == null) return void 0;
-		current = current[part];
+var IdNotFoundError = class extends Error {
+	constructor(id) {
+		super(`Resource with id ${id} not found`);
+		this.name = "IdNotFoundError";
 	}
-	return current;
-}
-/**
-* Set a value in a nested object using a dot-separated path.
-* Creates intermediate objects as needed.
-* @internal
-*/
-function setValueAtPath(obj, path, value) {
-	const parts = path.split(".");
-	let current = obj;
-	for (let i = 0; i < parts.length - 1; i++) {
-		if (!current[parts[i]] || typeof current[parts[i]] !== "object") current[parts[i]] = {};
-		current = current[parts[i]];
+};
+var DuplicateIdError = class extends Error {
+	constructor(id) {
+		super(`Resource with id ${id} already exists`);
+		this.name = "DuplicateIdError";
 	}
-	current[parts[parts.length - 1]] = value;
-}
+};
+
+//#endregion
+//#region src/database/query.ts
 /**
-* Compute the latest eventstamp for a resource from its field eventstamps and deletedAt.
-* Used internally and exported for testing/validation.
-* @internal
+* 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 computeResourceLatest(eventstamps, deletedAt, fallback) {
-	let max = fallback ?? MIN_EVENTSTAMP;
-	for (const stamp of Object.values(eventstamps)) if (stamp > max) max = stamp;
-	if (deletedAt && deletedAt > max) return deletedAt;
-	return max;
-}
-function makeResource(type, id, obj, eventstamp, deletedAt = null) {
-	const eventstamps = {};
-	const traverse = (input, path = "") => {
-		for (const key in input) {
-			if (!Object.hasOwn(input, key)) continue;
-			const value = input[key];
-			const fieldPath = path ? `${path}.${key}` : key;
-			if (isObject(value)) traverse(value, fieldPath);
-			else eventstamps[fieldPath] = eventstamp;
+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;
 	};
-	traverse(obj);
-	return {
-		type,
-		id,
-		attributes: obj,
-		meta: {
-			eventstamps,
-			latest: computeResourceLatest(eventstamps, deletedAt, eventstamp),
-			deletedAt
-		}
+	const runQuery = () => {
+		return callback(createTrackingHandles());
 	};
-}
-function mergeResources(into, from) {
-	const resultAttributes = {};
-	const resultEventstamps = {};
-	const allPaths = new Set([...Object.keys(into.meta.eventstamps), ...Object.keys(from.meta.eventstamps)]);
-	for (const path of allPaths) {
-		const stamp1 = into.meta.eventstamps[path];
-		const stamp2 = from.meta.eventstamps[path];
-		if (stamp1 && stamp2) if (stamp1 > stamp2) {
-			setValueAtPath(resultAttributes, path, getValueAtPath(into.attributes, path));
-			resultEventstamps[path] = stamp1;
-		} else {
-			setValueAtPath(resultAttributes, path, getValueAtPath(from.attributes, path));
-			resultEventstamps[path] = stamp2;
-		}
-		else if (stamp1) {
-			setValueAtPath(resultAttributes, path, getValueAtPath(into.attributes, path));
-			resultEventstamps[path] = stamp1;
-		} else {
-			setValueAtPath(resultAttributes, path, getValueAtPath(from.attributes, path));
-			resultEventstamps[path] = stamp2;
+	currentResult = runQuery();
+	const unsubscribeMutation = db.on("mutation", (event) => {
+		if (accessedCollections.has(event.collection)) {
+			currentResult = runQuery();
+			for (const subscriber of subscribers) subscriber(currentResult);
 		}
-	}
-	const dataLatest = computeResourceLatest(resultEventstamps, null, into.meta.latest > from.meta.latest ? into.meta.latest : from.meta.latest);
-	const mergedDeletedAt = into.meta.deletedAt && from.meta.deletedAt ? into.meta.deletedAt > from.meta.deletedAt ? into.meta.deletedAt : from.meta.deletedAt : into.meta.deletedAt || from.meta.deletedAt || null;
-	const finalLatest = mergedDeletedAt && mergedDeletedAt > dataLatest ? mergedDeletedAt : dataLatest;
+	});
+	let disposed = false;
 	return {
-		type: into.type,
-		id: into.id,
-		attributes: resultAttributes,
-		meta: {
-			eventstamps: resultEventstamps,
-			latest: finalLatest,
-			deletedAt: mergedDeletedAt
+		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 deleteResource(resource, eventstamp) {
-	const dataLatest = resource.meta.deletedAt ? computeResourceLatest(resource.meta.eventstamps, null) : resource.meta.latest;
-	const latest = eventstamp > dataLatest ? eventstamp : dataLatest;
+/**
+* Create a read-only collection handle that tracks access.
+*/
+function createTrackingHandle(name, collection, accessedCollections) {
+	const trackAccess = () => {
+		accessedCollections.add(name);
+	};
 	return {
-		type: resource.type,
-		id: resource.id,
-		attributes: resource.attributes,
-		meta: {
-			eventstamps: resource.meta.eventstamps,
-			latest,
-			deletedAt: eventstamp
+		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/document/document.ts
+//#region src/database/transaction.ts
 /**
-* Merges two JSON:API documents using field-level Last-Write-Wins semantics.
-*
-* The merge operation:
-* 1. Forwards the clock to the newest eventstamp from either document
-* 2. Merges each resource pair using field-level LWW (via mergeResources)
-* 3. Tracks what changed for hook notifications (added/updated/deleted)
+* Execute a transaction with snapshot isolation and copy-on-write optimization.
 *
-* Deletion is final: once a resource is deleted, updates to it are merged into
-* the resource's attributes but don't restore visibility. Only new resources or
-* transitions into the deleted state are tracked.
+* @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
 *
-* @param into - The base document to merge into
-* @param from - The source document to merge from
-* @returns Merged document and categorized changes
-*
-* @example
-* ```typescript
-* const into = {
-*   jsonapi: { version: "1.1" },
-*   meta: { latest: "2025-01-01T00:00:00.000Z|0001|a1b2" },
-*   data: [{ type: "items", id: "doc1", attributes: {...}, meta: { deletedAt: null, latest: "..." } }]
-* };
-*
-* const from = {
-*   jsonapi: { version: "1.1" },
-*   meta: { latest: "2025-01-01T00:05:00.000Z|0001|c3d4" },
-*   data: [
-*     { type: "items", id: "doc1", attributes: {...}, meta: { deletedAt: null, latest: "..." } }, // updated
-*     { type: "items", id: "doc2", attributes: {...}, meta: { deletedAt: null, latest: "..." } }  // new
-*   ]
-* };
-*
-* const result = mergeDocuments(into, from);
-* // result.document.meta.latest === "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 mergeDocuments(into, from) {
-	const intoDocsById = /* @__PURE__ */ new Map();
-	for (const doc of into.data) 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);
-	let newestEventstamp = into.meta.latest >= from.meta.latest ? into.meta.latest : from.meta.latest;
-	for (const fromDoc of from.data) {
-		const id = fromDoc.id;
-		const intoDoc = intoDocsById.get(id);
-		if (!intoDoc) {
-			mergedDocsById.set(id, fromDoc);
-			if (!fromDoc.meta.deletedAt) added.set(id, fromDoc);
-			if (fromDoc.meta.latest > newestEventstamp) newestEventstamp = fromDoc.meta.latest;
-		} else {
-			if (intoDoc === fromDoc) continue;
-			const mergedDoc = mergeResources(intoDoc, fromDoc);
-			mergedDocsById.set(id, mergedDoc);
-			if (mergedDoc.meta.latest > newestEventstamp) newestEventstamp = mergedDoc.meta.latest;
-			const wasDeleted = intoDoc.meta.deletedAt !== null;
-			const isDeleted = mergedDoc.meta.deletedAt !== null;
-			if (!wasDeleted && isDeleted) deleted.add(id);
-			else if (!isDeleted) {
-				if (intoDoc.meta.latest !== mergedDoc.meta.latest) 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);
 	}
-	return {
-		document: {
-			jsonapi: { version: "1.1" },
-			meta: { latest: newestEventstamp },
-			data: Array.from(mergedDocsById.values())
-		},
-		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;
 }
 /**
-* Creates an empty JSON:API document with the given eventstamp.
-* Useful for initializing new stores or testing.
+* Create a transaction handle that lazily clones on first access (copy-on-write).
 *
-* @param eventstamp - Initial clock value for this document
-* @returns Empty document
+* @param originalCollection - The base collection (not modified)
+* @param getClonedCollection - Lazy cloner (invoked on first access)
+* @returns A collection handle with snapshot isolation
 *
-* @example
-* ```typescript
-* const empty = makeDocument("2025-01-01T00:00:00.000Z|0000|0000");
-* ```
+* @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 makeDocument(eventstamp) {
-	return {
-		jsonapi: { version: "1.1" },
-		meta: { latest: eventstamp },
-		data: []
+function createLazyTransactionHandle(_originalCollection, getClonedCollection) {
+	let cloned = null;
+	const ensureCloned = () => {
+		if (!cloned) cloned = getClonedCollection();
+		return cloned;
 	};
-}
-
-//#endregion
-//#region src/document/utils.ts
-/**
-* Convert a JsonDocument's data array into a Map keyed by resource ID.
-* @param document - JsonDocument containing resource data
-* @returns Map of resource ID to ResourceObject
-*/
-function documentToMap(document) {
-	return new Map(document.data.map((doc) => [doc.id, doc]));
-}
-/**
-* Convert a Map of resources into a JsonDocument.
-* @param resources - Map of resource ID to ResourceObject
-* @param fallbackEventstamp - Eventstamp to include when computing the max (optional)
-* @returns JsonDocument representation of the resources
-*/
-function mapToDocument(resources, fallbackEventstamp) {
-	const resourceArray = Array.from(resources.values());
-	const eventstamps = resourceArray.map((r) => r.meta.latest);
-	if (fallbackEventstamp) eventstamps.push(fallbackEventstamp);
 	return {
-		jsonapi: { version: "1.1" },
-		meta: { latest: maxEventstamp(eventstamps) },
-		data: resourceArray
+		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/resource-map/resource-map.ts
+//#region src/database/db.ts
 /**
-* A ResourceMap container for storing and managing ResourceObjects.
-*
-* This factory function creates a ResourceMap with state-based replication
-* and automatic convergence via Last-Write-Wins conflict resolution.
-* It stores complete resource snapshots with encoded metadata, including deletion markers.
-*
-* ResourceMap does NOT filter based on deletion status—it stores and returns
-* all ResourceObjects including deleted ones. The Store class is responsible
-* for filtering what's visible to users.
+* 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 resourceMap = createMap("todos");
-* resourceMap.set("id1", { name: "Alice" });
-* const resource = resourceMap.get("id1"); // ResourceObject with metadata
+* 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 createMap(resourceType, initialMap = /* @__PURE__ */ new Map(), eventstamp) {
-	let internalMap = initialMap;
+function createDatabase(config) {
+	const { name, schema, version = 1 } = config;
 	const clock = createClock();
-	if (eventstamp) clock.forward(eventstamp);
-	return {
-		has(id) {
-			return internalMap.has(id);
+	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
+		});
+	});
+	const plugins = [];
+	const db = {
+		...publicCollections,
+		name,
+		version,
+		begin(callback) {
+			return executeTransaction(schema, collections, getEventstamp, callback);
 		},
-		get(id) {
-			return internalMap.get(id);
+		query(callback) {
+			return executeQuery(db, callback);
 		},
-		entries() {
-			return internalMap.entries();
+		toDocuments() {
+			const documents = {};
+			for (const dbName of Object.keys(collections)) documents[dbName] = collections[dbName].toDocument();
+			return documents;
 		},
-		set(id, object) {
-			const encoded = makeResource(resourceType, id, object, clock.now());
-			const current = internalMap.get(id);
-			if (current) {
-				const merged = mergeResources(current, encoded);
-				internalMap.set(id, merged);
-			} else internalMap.set(id, encoded);
+		on(event, handler) {
+			return dbEmitter.on(event, handler);
 		},
-		delete(id) {
-			const current = internalMap.get(id);
-			if (current) {
-				const doc = deleteResource(current, clock.now());
-				internalMap.set(id, doc);
-			}
+		use(plugin) {
+			plugins.push(plugin);
+			return db;
 		},
-		cloneMap() {
-			return new Map(internalMap);
+		async init() {
+			for (const plugin of plugins) if (plugin.handlers.init) await plugin.handlers.init(db);
+			return db;
 		},
-		toDocument() {
-			return mapToDocument(internalMap, clock.latest());
+		async dispose() {
+			for (let i = plugins.length - 1; i >= 0; i--) {
+				const plugin = plugins[i];
+				if (plugin?.handlers.dispose) await plugin.handlers.dispose(db);
+			}
 		},
-		merge(document) {
-			const result = mergeDocuments(mapToDocument(internalMap, clock.latest()), document);
-			clock.forward(result.document.meta.latest);
-			internalMap = documentToMap(result.document);
-			return result;
+		collectionKeys() {
+			return Object.keys(collections);
 		}
 	};
+	return db;
 }
-/**
-* Create a ResourceMap from a JsonDocument snapshot.
-* @param type - Resource type identifier (defaults to "default")
-* @param document - JsonDocument containing resource data
-*/
-function createMapFromDocument(type, document) {
-	return createMap(document.data[0]?.type ?? type, documentToMap(document), document.meta.latest);
+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 { InvalidEventstampError, MIN_EVENTSTAMP, createClock, createClockFromEventstamp, createMap, createMapFromDocument, deleteResource, documentToMap, isValidEventstamp, makeDocument, makeResource, mapToDocument, maxEventstamp, mergeDocuments, mergeResources };
+export { CollectionInternals, DuplicateIdError, IdNotFoundError, createDatabase };