@byearlybird/starling 0.9.2 → 0.10.0

package/dist/index.js

@@ -1,10 +1,20 @@
-//#region src/crdt/eventstamp.ts
+//#region src/clock/errors.ts
+var InvalidEventstampError = class extends Error {
+	constructor(eventstamp) {
+		super(`Invalid eventstamp: "${eventstamp}"`);
+		this.name = "InvalidEventstampError";
+	}
+};
+
+//#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
@@ -12,10 +22,10 @@ function encodeEventstamp(timestampMs, counter, nonce) {
 * 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);
+	return EVENTSTAMP_REGEX.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`);
+	if (!isValidEventstamp(eventstamp)) throw new InvalidEventstampError(eventstamp);
 	const parts = eventstamp.split("|");
 	const isoString = parts[0];
 	const hexCounter = parts[1];
@@ -27,248 +37,261 @@ function decodeEventstamp(eventstamp) {
 	};
 }
 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);
+/**
+* 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/crdt/value.ts
-function encodeValue(value, eventstamp) {
+//#region src/clock/clock.ts
+/**
+* Create a new Clock instance.
+* @param initialState - Optional initial state for the clock
+*/
+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 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;
+		}
+	};
 	return {
-		"~value": value,
-		"~eventstamp": eventstamp
+		now,
+		latest,
+		forward
 	};
 }
-function decodeValue(value) {
-	return value["~value"];
-}
-function mergeValues(into, from) {
-	return into["~eventstamp"] > from["~eventstamp"] ? [into, into["~eventstamp"]] : [from, from["~eventstamp"]];
+/**
+* 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/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;
+//#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];
+	}
+	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]];
+	}
+	current[parts[parts.length - 1]] = value;
 }
-function encodeRecord(obj, eventstamp) {
-	const result = {};
-	const step = (input, output) => {
+/**
+* Compute the latest eventstamp for a resource from its field eventstamps and deletedAt.
+* Used internally and exported for testing/validation.
+* @internal
+*/
+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];
-			if (isObject(value)) {
-				output[key] = {};
-				step(value, output[key]);
-			} else output[key] = encodeValue(value, eventstamp);
+			const fieldPath = path ? `${path}.${key}` : key;
+			if (isObject(value)) traverse(value, fieldPath);
+			else eventstamps[fieldPath] = eventstamp;
 		}
 	};
-	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]);
-			}
+	traverse(obj);
+	return {
+		type,
+		id,
+		attributes: obj,
+		meta: {
+			eventstamps,
+			latest: computeResourceLatest(eventstamps, deletedAt, eventstamp),
+			deletedAt
 		}
 	};
-	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;
+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;
 		}
-		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;
-				}
-			}
+		else if (stamp1) {
+			setValueAtPath(resultAttributes, path, getValueAtPath(into.attributes, path));
+			resultEventstamps[path] = stamp1;
+		} else {
+			setValueAtPath(resultAttributes, path, getValueAtPath(from.attributes, path));
+			resultEventstamps[path] = stamp2;
 		}
-	};
-	step(into, from, result);
-	return [result, greatestEventstamp];
-}
-
-//#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
-	};
-}
-function decodeDoc(doc) {
-	return {
-		"~id": doc["~id"],
-		"~data": isEncodedValue(doc["~data"]) ? decodeValue(doc["~data"]) : decodeRecord(doc["~data"]),
-		"~deletedAt": doc["~deletedAt"]
-	};
-}
-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) {
+	}
+	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;
 	return {
-		"~id": doc["~id"],
-		"~data": doc["~data"],
-		"~deletedAt": eventstamp
+		type: into.type,
+		id: into.id,
+		attributes: resultAttributes,
+		meta: {
+			eventstamps: resultEventstamps,
+			latest: finalLatest,
+			deletedAt: mergedDeletedAt
+		}
 	};
 }
-/**
-* 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"])
-* }));
-* ```
-*/
-function processDocument(doc, process) {
-	const processedData = isEncodedValue(doc["~data"]) ? process(doc["~data"]) : processRecord(doc["~data"], process);
+function deleteResource(resource, eventstamp) {
+	const dataLatest = resource.meta.deletedAt ? computeResourceLatest(resource.meta.eventstamps, null) : resource.meta.latest;
+	const latest = eventstamp > dataLatest ? eventstamp : dataLatest;
 	return {
-		"~id": doc["~id"],
-		"~data": processedData,
-		"~deletedAt": doc["~deletedAt"]
+		type: resource.type,
+		id: resource.id,
+		attributes: resource.attributes,
+		meta: {
+			eventstamps: resource.meta.eventstamps,
+			latest,
+			deletedAt: eventstamp
+		}
 	};
 }
 
 //#endregion
-//#region src/crdt/collection.ts
+//#region src/document/document.ts
 /**
-* Merges two collections using field-level Last-Write-Wins semantics.
+* 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 collection
-* 2. Merges each document pair using field-level LWW (via mergeDocs)
+* 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)
 *
-* 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
+* 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 into - The base collection to merge into
-* @param from - The source collection to merge from
-* @returns Merged collection and categorized changes
+* @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 = {
-*   "~docs": [{ "~id": "doc1", "~data": {...}, "~deletedAt": null }],
-*   "~eventstamp": "2025-01-01T00:00:00.000Z|0001|a1b2"
+*   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 = {
-*   "~docs": [
-*     { "~id": "doc1", "~data": {...}, "~deletedAt": null }, // updated
-*     { "~id": "doc2", "~data": {...}, "~deletedAt": null }  // new
-*   ],
-*   "~eventstamp": "2025-01-01T00:05:00.000Z|0001|c3d4"
+*   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 = mergeCollections(into, from);
-* // result.collection.~eventstamp === "2025-01-01T00:05:00.000Z|0001|c3d4"
+* 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"
 * ```
 */
-function mergeCollections(into, from) {
+function mergeDocuments(into, from) {
 	const intoDocsById = /* @__PURE__ */ new Map();
-	for (const doc of into["~docs"]) intoDocsById.set(doc["~id"], doc);
+	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);
-	for (const fromDoc of from["~docs"]) {
-		const id = fromDoc["~id"];
+	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["~deletedAt"]) added.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] = mergeDocs(intoDoc, fromDoc);
+			const mergedDoc = mergeResources(intoDoc, fromDoc);
 			mergedDocsById.set(id, mergedDoc);
-			const wasDeleted = intoDoc["~deletedAt"] !== null;
-			const isDeleted = mergedDoc["~deletedAt"] !== null;
+			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) updated.set(id, mergedDoc);
+			else if (!isDeleted) {
+				if (intoDoc.meta.latest !== mergedDoc.meta.latest) updated.set(id, mergedDoc);
+			}
 		}
 	}
-	const newestEventstamp = into["~eventstamp"] >= from["~eventstamp"] ? into["~eventstamp"] : from["~eventstamp"];
 	return {
-		collection: {
-			"~docs": Array.from(mergedDocsById.values()),
-			"~eventstamp": newestEventstamp
+		document: {
+			jsonapi: { version: "1.1" },
+			meta: { latest: newestEventstamp },
+			data: Array.from(mergedDocsById.values())
 		},
 		changes: {
 			added,
@@ -277,361 +300,124 @@ function mergeCollections(into, from) {
 		}
 	};
 }
+/**
+* Creates an empty JSON:API document with the given eventstamp.
+* Useful for initializing new stores or testing.
+*
+* @param eventstamp - Initial clock value for this document
+* @returns Empty document
+*
+* @example
+* ```typescript
+* const empty = makeDocument("2025-01-01T00:00:00.000Z|0000|0000");
+* ```
+*/
+function makeDocument(eventstamp) {
+	return {
+		jsonapi: { version: "1.1" },
+		meta: { latest: eventstamp },
+		data: []
+	};
+}
 
 //#endregion
-//#region src/clock.ts
+//#region src/document/utils.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.
-*
-* The clock automatically increments the counter when the wall clock doesn't
-* advance, ensuring eventstamps are always unique and monotonic.
+* 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
 */
-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 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
+	};
+}
 
 //#endregion
-//#region src/store.ts
+//#region src/resource-map/resource-map.ts
 /**
-* Lightweight local-first data store with built-in sync and reactive queries.
+* A ResourceMap container for storing and managing ResourceObjects.
 *
-* Stores plain JavaScript objects with automatic field-level conflict resolution
-* using Last-Write-Wins semantics powered by hybrid logical clocks.
+* 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.
 *
-* @template T - The type of documents stored in this collection
+* 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.
 *
 * @example
-* ```ts
-* const store = await new Store<{ text: string; completed: boolean }>()
-*   .use(unstoragePlugin('todos', storage))
-*   .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!'));
+* ```typescript
+* const resourceMap = createMap("todos");
+* resourceMap.set("id1", { name: "Alice" });
+* const resource = resourceMap.get("id1"); // ResourceObject with metadata
 * ```
 */
-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;
-			}
-		});
-		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);
+function createMap(resourceType, initialMap = /* @__PURE__ */ new Map(), eventstamp) {
+	let internalMap = initialMap;
+	const clock = createClock();
+	if (eventstamp) clock.forward(eventstamp);
+	return {
+		has(id) {
+			return internalMap.has(id);
+		},
+		get(id) {
+			return internalMap.get(id);
+		},
+		entries() {
+			return internalMap.entries();
+		},
+		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);
+		},
+		delete(id) {
+			const current = internalMap.get(id);
+			if (current) {
+				const doc = deleteResource(current, clock.now());
+				internalMap.set(id, doc);
 			}
+		},
+		cloneMap() {
+			return new Map(internalMap);
+		},
+		toDocument() {
+			return mapToDocument(internalMap, clock.latest());
+		},
+		merge(document) {
+			const result = mergeDocuments(mapToDocument(internalMap, clock.latest()), document);
+			clock.forward(result.document.meta.latest);
+			internalMap = documentToMap(result.document);
+			return result;
 		}
-		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;
-	}
-};
+	};
+}
+/**
+* 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);
+}
 
 //#endregion
-export { Store, processDocument };
+export { InvalidEventstampError, MIN_EVENTSTAMP, createClock, createClockFromEventstamp, createMap, createMapFromDocument, deleteResource, documentToMap, isValidEventstamp, makeDocument, makeResource, mapToDocument, maxEventstamp, mergeDocuments, mergeResources };