@byearlybird/starling 0.13.2 → 0.14.0

package/README.md

@@ -1,15 +1,15 @@
 # Starling
 
-A mergable data store for building local-first apps that sync.
+Conflict-free replicated state for JavaScript. Bring your own reactivity.
 
-Starling lets you store data in memory with a fast, synchronous API. The merge system is fully built and ready—persistence and sync features are coming soon. When you need to sync with other devices or users, it automatically merges changes and resolves conflicts.
+Starling is a CRDT (conflict-free replicated data type) library that provides automatic conflict resolution for distributed data. It manages state with Last-Write-Wins semantics using hybrid logical clocks, giving you a solid foundation for building local-first, collaborative applications.
 
 ## Installation
 
 ```bash
 npm install @byearlybird/starling
 # or
-bun add @byearlybird/starling
+pnpm add @byearlybird/starling
 ```
 
 Requires TypeScript 5 or higher.
@@ -31,19 +31,19 @@ const store = createStore({
   },
 });
 
-store.users.add({ id: "1", name: "Alice" });
-const user = store.users.get("1"); // { id: "1", name: "Alice" }
+store.add("users", { id: "1", name: "Alice" });
+const user = store.get("users", "1"); // { id: "1", name: "Alice" }
 ```
 
 ## Features
 
-- **In-memory and fast**: All operations are synchronous for maximum performance
-- **Built for local-first**: API is ready for persistence and sync (coming soon)
-- **Works with any standard schema library**: Zod, Valibot, ArkType, and more
-- **Automatic conflict resolution**: When merging changes, conflicts are resolved automatically
-- **Reactive updates**: Data changes trigger updates automatically
+- **CRDT-based**: Automatic conflict resolution with Last-Write-Wins semantics
+- **Fast and synchronous**: All operations are in-memory and synchronous
+- **Framework agnostic**: Works with React, Vue, Svelte, or vanilla JS
 - **Type-safe**: Full TypeScript support with type inference
+- **Schema validation**: Works with Zod, Valibot, ArkType, and more
 - **Merge snapshots**: Sync data between devices or users easily
+- **Change events**: Listen to data changes and integrate with your reactive system
 
 ## Basic Usage
 
@@ -79,7 +79,7 @@ const store = createStore({
 Add new items to a collection with `add()`:
 
 ```typescript
-store.users.add({
+store.add("users", {
   id: "1",
   name: "Alice",
   email: "alice@example.com",
@@ -91,7 +91,7 @@ store.users.add({
 Update existing items with `update()`:
 
 ```typescript
-store.users.update("1", {
+store.update("users", "1", {
   email: "newemail@example.com",
 });
 ```
@@ -101,71 +101,57 @@ store.users.update("1", {
 Remove items with `remove()`:
 
 ```typescript
-store.users.remove("1");
+store.remove("users", "1");
 ```
 
 ### Reading Data
 
-Collections work like maps. You can read data in several ways:
+The store provides simple getter methods:
 
 ```typescript
 // Get a single item
-const user = store.users.get("1");
+const user = store.get("users", "1");
 
-// Check if an item exists
-if (store.users.has("1")) {
-  // ...
-}
-
-// Get all items
-for (const [id, user] of store.users.entries()) {
-  console.log(id, user);
-}
-
-// Query data reactively (recommended)
-const $userCount = store.query(["users"], (collections) => {
-  return collections.users.size;
-});
+// Get all items as an array
+const allUsers = store.getAll("users");
 
-// Get current value
-console.log($userCount.get()); // 5
-
-// Subscribe to updates
-$userCount.subscribe((count) => {
-  console.log("User count:", count);
-});
+// You can easily derive other operations:
+const userIds = allUsers.map((u) => u.id);
+const hasUser = allUsers.some((u) => u.id === "1");
 ```
 
-### Reactive Queries
+### Listening to Changes
 
-For reactive updates, use the `query()` method. It lets you combine data from multiple collections and automatically updates when any of them change:
+Subscribe to changes with `onChange()`:
 
 ```typescript
-// Query multiple collections
-const $stats = store.query(["users", "notes"], (collections) => {
-  return {
-    totalUsers: collections.users.size,
-    totalNotes: collections.notes.size,
-    firstUser: collections.users.get("1"),
-  };
+// Listen to all store changes
+store.onChange((event) => {
+  console.log(`${event.collection} changed:`, event.event.type);
+  // Invalidate queries, update UI, etc.
 });
 
-// Subscribe to changes
-$stats.subscribe((stats) => {
-  console.log("Stats updated:", stats);
+// Filter for specific collection changes
+store.onChange((event) => {
+  if (event.collection === "users") {
+    console.log("User change:", event.event.type, event.event.id);
+    if (event.event.type === "add") {
+      console.log("New user:", event.event.data);
+    }
+  }
 });
 ```
 
 ## Merging Data
 
-Starling's merge system is fully built and ready to use. When you add persistence and sync (coming soon), you'll use snapshots to sync data. A snapshot is a copy of all your data at a point in time.
+Starling's core feature is conflict-free merging. When data changes in multiple places, Starling automatically resolves conflicts using timestamps.
 
 ### Getting a Snapshot
 
 Get the current state of your store:
 
 ```typescript
-const snapshot = store.$snapshot.get();
+const snapshot = store.getSnapshot();
 // { clock: { ms: ..., seq: ... }, collections: { ... } }
 ```
 
@@ -174,14 +160,14 @@ const snapshot = store.$snapshot.get();
 Merge a snapshot from another device or user:
 
 ```typescript
-// Get snapshot from another device (when you add sync)
-const otherSnapshot = getSnapshotFromServer();
+// Get snapshot from another device
+const otherSnapshot = await fetchFromServer();
 
 // Merge it into your store
 store.merge(otherSnapshot);
 ```
 
-Starling automatically resolves conflicts. If the same item was changed in both places, it keeps the change with the newer timestamp. The merge API is ready now—just add your persistence and sync layer on top.
+Starling automatically resolves conflicts. If the same field was changed in both places, it keeps the change with the newer timestamp (Last-Write-Wins).
 
 ### Syncing Between Two Stores
 
@@ -192,14 +178,83 @@ const store1 = createStore({ collections: { users: { schema: userSchema } } });
 const store2 = createStore({ collections: { users: { schema: userSchema } } });
 
 // Add data to store1
-store1.users.add({ id: "1", name: "Alice" });
+store1.add("users", { id: "1", name: "Alice" });
 
 // Sync to store2
-const snapshot = store1.$snapshot.get();
+const snapshot = store1.getSnapshot();
 store2.merge(snapshot);
 
 // Now store2 has the same data
-console.log(store2.users.get("1")); // { id: "1", name: "Alice" }
+console.log(store2.get("users", "1")); // { id: "1", name: "Alice" }
+```
+
+## Reactivity Integration
+
+Starling is framework-agnostic. Use `onChange()` to integrate with your reactive system:
+
+### React with TanStack Query
+
+```typescript
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+
+function useUsers() {
+  const queryClient = useQueryClient();
+
+  useEffect(() => {
+    return store.onChange((event) => {
+      if (event.collection === "users") {
+        queryClient.invalidateQueries({ queryKey: ["users"] });
+      }
+    });
+  }, []);
+
+  return useQuery({
+    queryKey: ["users"],
+    queryFn: () => store.getAll("users"),
+  });
+}
+```
+
+### React with useSyncExternalStore
+
+```typescript
+import { useSyncExternalStore } from "react";
+
+function useUsers() {
+  return useSyncExternalStore(
+    (callback) =>
+      store.onChange((event) => {
+        if (event.collection === "users") callback();
+      }),
+    () => store.getAll("users"),
+  );
+}
+```
+
+### Svelte
+
+```typescript
+import { writable } from "svelte/store";
+
+const users = writable(store.getAll("users"));
+store.onChange((event) => {
+  if (event.collection === "users") {
+    users.set(store.getAll("users"));
+  }
+});
+```
+
+### Vue
+
+```typescript
+import { ref } from "vue";
+
+const users = ref(store.getAll("users"));
+store.onChange((event) => {
+  if (event.collection === "users") {
+    users.value = store.getAll("users");
+  }
+});
 ```
 
 ## Schema Support
@@ -233,27 +288,16 @@ const schema = type({ id: "string", name: "string" });
 
 - `createStore(config)` - Creates a new store with collections
 
-### Collection Methods
-
-Each collection in your store has these methods:
-
-- `add(data)` - Add a new document
-- `update(id, data)` - Update an existing document
-- `remove(id)` - Remove a document
-- `merge(snapshot)` - Merge a collection snapshot
-- `get(id)` - Get a document by ID
-- `has(id)` - Check if a document exists
-- `keys()` - Get all document IDs
-- `values()` - Get all documents
-- `entries()` - Get all [id, document] pairs
-- `forEach(callback)` - Iterate over documents
-- `size` - Number of documents
-
 ### Store Methods
 
-- `$snapshot` - Reactive atom containing the full store snapshot
+- `add(collection, data)` - Add a new document to a collection
+- `get(collection, id)` - Get a document by ID from a collection
+- `getAll(collection)` - Get all documents from a collection as an array
+- `update(collection, id, data)` - Update an existing document in a collection
+- `remove(collection, id)` - Remove a document from a collection
+- `getSnapshot()` - Get the full store snapshot for syncing
 - `merge(snapshot)` - Merge a store snapshot
-- `query(collections, callback)` - Query multiple collections reactively (recommended for reactive code)
+- `onChange(listener)` - Subscribe to all collection changes
 
 For full type definitions, see the TypeScript types exported from the package.
 
@@ -261,14 +305,14 @@ For full type definitions, see the TypeScript types exported from the package.
 
 ```bash
 # Install dependencies
-bun install
+pnpm install
 
 # Build the library
-bun run build
+pnpm run build
 
 # Run tests
-bun test
+pnpm test
 
 # Watch mode for development
-bun run dev
+pnpm run dev
 ```

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-import { ReadableAtom, atom } from "nanostores";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 
 //#region lib/core/clock.d.ts
@@ -21,7 +20,6 @@ type Tombstones = Record<string, string>;
 type DocumentId = string;
 type Collection = {
   documents: Record<DocumentId, Document>;
-  tombstones: Tombstones;
 };
 //#endregion
 //#region lib/store/schema.d.ts
@@ -29,45 +27,52 @@ type Collection = {
  * Base type constraint for any standard schema object
  */
 type AnyObject = StandardSchemaV1<Record<string, any>>;
-type SchemaWithId<T extends AnyObject> = StandardSchemaV1.InferOutput<T> extends {
-  id: any;
-} ? T : never;
 type Output<T extends AnyObject> = StandardSchemaV1.InferOutput<T>;
 type Input<T extends AnyObject> = StandardSchemaV1.InferInput<T>;
 //#endregion
-//#region lib/store/collection.d.ts
+//#region lib/store/store.d.ts
 type CollectionConfig<T extends AnyObject> = {
   schema: T;
-  getId: (data: Output<T>) => DocumentId;
-} | {
-  schema: SchemaWithId<T>;
+  keyPath: keyof Output<T> & string;
 };
-type CollectionApi<T extends AnyObject> = {
-  $data: ReadableAtom<ReadonlyMap<DocumentId, Output<T>>>;
-  $snapshot: ReadableAtom<Collection>;
-  add(data: Input<T>): void;
-  remove(id: DocumentId): void;
-  update(id: DocumentId, document: Partial<Input<T>>): void;
-  merge(snapshot: Collection): void;
-} & Pick<ReadonlyMap<DocumentId, Output<T>>, "get" | "has" | "keys" | "values" | "entries" | "forEach" | "size">;
-//#endregion
-//#region lib/store/store.d.ts
 type StoreSnapshot = {
   clock: Clock;
   collections: Record<string, Collection>;
+  tombstones: Tombstones;
 };
-type StoreCollections<T extends Record<string, CollectionConfig<any>>> = { [K in keyof T]: T[K] extends CollectionConfig<infer S> ? CollectionApi<S> : never };
-type QueryCollections<TCollections extends StoreCollections<any>, TKeys extends readonly (keyof TCollections)[]> = { [K in TKeys[number]]: TCollections[K] extends {
-  $data: ReadableAtom<infer D>;
-} ? D : never };
-type StoreAPI<T extends Record<string, CollectionConfig<any>>> = StoreCollections<T> & {
-  $snapshot: ReadableAtom<StoreSnapshot>;
-  query<TKeys extends readonly (keyof StoreCollections<T>)[], TResult>(collections: TKeys, callback: (collections: QueryCollections<StoreCollections<T>, TKeys>) => TResult): ReadableAtom<TResult>;
+type StoreChangeEvent<T extends Record<string, CollectionConfig<AnyObject>>> = { [K in keyof T]: {
+  type: "add";
+  collection: K;
+  id: DocumentId;
+  data: Output<T[K]["schema"]>;
+} | {
+  type: "update";
+  collection: K;
+  id: DocumentId;
+  data: Output<T[K]["schema"]>;
+} | {
+  type: "remove";
+  collection: K;
+  id: DocumentId;
+} | {
+  type: "merge";
+  collection: K;
+} }[keyof T];
+type StoreAPI<T extends Record<string, CollectionConfig<AnyObject>>> = {
+  add<K$1 extends keyof T & string>(collection: K$1, data: Input<T[K$1]["schema"]>): void;
+  get<K$1 extends keyof T & string>(collection: K$1, id: DocumentId): Output<T[K$1]["schema"]> | undefined;
+  getAll<K$1 extends keyof T & string>(collection: K$1, options?: {
+    where?: (item: Output<T[K$1]["schema"]>) => boolean;
+  }): Output<T[K$1]["schema"]>[];
+  update<K$1 extends keyof T & string>(collection: K$1, id: DocumentId, data: Partial<Input<T[K$1]["schema"]>>): void;
+  remove<K$1 extends keyof T & string>(collection: K$1, id: DocumentId): void;
+  getSnapshot(): StoreSnapshot;
   merge(snapshot: StoreSnapshot): void;
+  onChange(listener: (event: StoreChangeEvent<T>) => void): () => void;
 };
-declare function createStore<T extends Record<string, CollectionConfig<any>>>(config: {
+declare function createStore<T extends Record<string, CollectionConfig<AnyObject>>>(config: {
   collections: T;
 }): StoreAPI<T>;
 //#endregion
-export { type AnyObject, QueryCollections, StoreAPI, StoreCollections, StoreSnapshot, createStore };
+export { type AnyObject, type CollectionConfig, type StoreAPI, type StoreChangeEvent, type StoreSnapshot, createStore };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,5 +1,3 @@
-import { atom, computed } from "nanostores";
-
 //#region lib/store/schema.ts
 function validate(schema, input) {
 	const result = schema["~standard"].validate(input);
@@ -119,253 +117,166 @@ function mergeDocuments(target, source) {
 	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;
-}
-
 //#endregion
 //#region lib/core/collection.ts
-function mergeCollections$1(target, source) {
-	const mergedTombstones = mergeTombstones(target.tombstones, source.tombstones);
+function mergeCollections(target, 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 (tombstones[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
-	};
+	return { documents: mergedDocuments };
 }
 
 //#endregion
-//#region lib/store/collection.ts
-function addDocument($state, config, tick, data) {
-	const getId = defineGetId(config);
-	const valid = validate(config.schema, data);
-	const doc = makeDocument(valid, tick());
-	const id = getId(valid);
-	const current = $state.get();
-	$state.set({
-		...current,
-		documents: {
-			...current.documents,
-			[id]: doc
-		}
-	});
-}
-function removeDocument($state, tick, id) {
-	const current = $state.get();
-	const { [id]: _removed, ...remainingDocs } = current.documents;
-	$state.set({
-		documents: remainingDocs,
-		tombstones: {
-			...current.tombstones,
-			[id]: tick()
-		}
-	});
-}
-function updateDocument($state, config, tick, id, document) {
-	const current = $state.get();
-	const currentDoc = current.documents[id];
-	if (!currentDoc) return;
-	const doc = mergeDocuments(currentDoc, makeDocument(document, tick()));
-	validate(config.schema, parseDocument(doc));
-	$state.set({
-		...current,
-		documents: {
-			...current.documents,
-			[id]: doc
-		}
-	});
-}
-function mergeCollectionSnapshot($state, currentSnapshot, incomingSnapshot) {
-	const merged = mergeCollections$1(currentSnapshot, incomingSnapshot);
-	$state.set({
-		documents: merged.documents,
-		tombstones: merged.tombstones
-	});
-}
-function createCollection(config, clock) {
-	const { $data, $snapshot, $state } = createCollectionState();
-	return {
-		$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();
-		},
-		entries() {
-			return $data.get().entries();
-		},
-		forEach(callbackfn, thisArg) {
-			return $data.get().forEach(callbackfn, thisArg);
-		},
-		get size() {
-			return $data.get().size;
-		},
-		add(data) {
-			addDocument($state, config, clock.tick, data);
-		},
-		remove(id) {
-			removeDocument($state, clock.tick, id);
-		},
-		update(id, document) {
-			updateDocument($state, config, clock.tick, id, document);
-		},
-		merge(snapshot) {
-			mergeCollectionSnapshot($state, $snapshot.get(), snapshot);
-		}
-	};
-}
-function createCollectionState() {
-	const $state = atom({
-		documents: {},
-		tombstones: {}
-	});
-	const $snapshot = computed($state, (state) => {
-		return parseSnapshot(state.documents, state.tombstones);
-	});
-	return {
-		$data: computed($state, (state) => {
-			return parseCollection(state.documents, state.tombstones);
-		}),
-		$snapshot,
-		$state
-	};
-}
-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));
+//#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;
 }
-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 lib/store/clock.ts
-function createClock() {
-	const $state = atom(nowClock());
+//#region lib/store/store.ts
+function createStore(config) {
+	let clock = {
+		ms: Date.now(),
+		seq: 0
+	};
+	let tombstones = {};
+	const documents = {};
+	const configs = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Set();
 	const tick = () => {
-		const next = advanceClock($state.get(), nowClock());
-		$state.set(next);
-		return makeStamp(next.ms, next.seq);
+		advance(Date.now(), 0);
+		return makeStamp(clock.ms, clock.seq);
 	};
 	const advance = (ms, seq) => {
-		const next = advanceClock($state.get(), {
+		clock = advanceClock(clock, {
 			ms,
 			seq
 		});
-		$state.set(next);
 	};
-	return {
-		$state,
-		tick,
-		advance
+	const notify = (collectionName, event) => {
+		listeners.forEach((listener) => listener({
+			collection: collectionName,
+			...event
+		}));
 	};
-}
-function nowClock() {
-	return {
-		ms: Date.now(),
-		seq: 0
+	const getConfig = (collectionName) => {
+		const config$1 = configs.get(collectionName);
+		if (!config$1) throw new Error(`Collection "${collectionName}" not found`);
+		return config$1;
 	};
-}
-
-//#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);
+	const getDocs = (collectionName) => {
+		const docs = documents[collectionName];
+		if (!docs) throw new Error(`Collection "${collectionName}" not found`);
+		return docs;
+	};
+	for (const [name, collectionConfig] of Object.entries(config.collections)) {
+		configs.set(name, collectionConfig);
+		documents[name] = {};
 	}
 	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));
+		add(collectionName, data) {
+			const collectionConfig = getConfig(collectionName);
+			const valid = validate(collectionConfig.schema, data);
+			const id = valid[collectionConfig.keyPath];
+			const doc = makeDocument(valid, tick());
+			documents[collectionName] = {
+				...documents[collectionName],
+				[id]: doc
+			};
+			notify(collectionName, {
+				type: "add",
+				id,
+				data: valid
+			});
+		},
+		get(collectionName, id) {
+			if (tombstones[id]) return void 0;
+			const doc = getDocs(collectionName)[id];
+			if (!doc) return void 0;
+			return parseDocument(doc);
+		},
+		getAll(collectionName, options) {
+			const collectionDocs = getDocs(collectionName);
+			const resultDocs = [];
+			for (const [id, doc] of Object.entries(collectionDocs)) if (doc && !tombstones[id]) {
+				const parsed = parseDocument(doc);
+				if (!options?.where || options?.where(parsed)) resultDocs.push(parsed);
+			}
+			return resultDocs;
+		},
+		update(collectionName, id, data) {
+			const collectionDocs = getDocs(collectionName);
+			const currentDoc = collectionDocs[id];
+			if (!currentDoc) return;
+			const collectionConfig = getConfig(collectionName);
+			const mergedDoc = mergeDocuments(currentDoc, makeDocument(data, tick()));
+			const parsed = parseDocument(mergedDoc);
+			validate(collectionConfig.schema, parsed);
+			documents[collectionName] = {
+				...collectionDocs,
+				[id]: mergedDoc
+			};
+			notify(collectionName, {
+				type: "update",
+				id,
+				data: parsed
 			});
 		},
-		merge: (snapshot) => {
-			clock.advance(snapshot.clock.ms, snapshot.clock.seq);
-			mergeCollections(collections, snapshot.collections);
+		remove(collectionName, id) {
+			const collectionDocs = getDocs(collectionName);
+			tombstones = {
+				...tombstones,
+				[id]: tick()
+			};
+			const { [id]: _removed, ...remainingDocs } = collectionDocs;
+			documents[collectionName] = remainingDocs;
+			notify(collectionName, {
+				type: "remove",
+				id
+			});
+		},
+		getSnapshot() {
+			const collectionsSnapshot = {};
+			for (const [name, collectionDocs] of Object.entries(documents)) collectionsSnapshot[name] = { documents: collectionDocs };
+			return {
+				clock,
+				collections: collectionsSnapshot,
+				tombstones
+			};
+		},
+		merge(snapshot) {
+			advance(snapshot.clock.ms, snapshot.clock.seq);
+			tombstones = mergeTombstones(tombstones, snapshot.tombstones);
+			for (const [name, collectionData] of Object.entries(snapshot.collections)) {
+				if (!documents[name]) documents[name] = {};
+				const filteredDocs = {};
+				for (const [id, doc] of Object.entries(collectionData.documents)) if (!tombstones[id]) filteredDocs[id] = doc;
+				documents[name] = mergeCollections({ documents: documents[name] }, { documents: filteredDocs }, tombstones).documents;
+				notify(name, { type: "merge" });
+			}
+		},
+		onChange(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
 		}
 	};
 }
-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 computed(collectionSnapshotAtoms, (...snapshots) => {
-		const clock = clockState.get();
-		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);
-	}
-}
 
 //#endregion
 export { createStore };

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["result: Record<string, R>","result: Record<string, unknown>","current: any","result: Document","result: Tombstones","mergeCollections","mergedDocuments: Record<DocumentId, Document>","mergeCollections","$state: ClockAtom","collectionSnapshotAtoms: ReadableAtom<Collection>[]","collectionsSnapshot: Record<string, Collection>"],"sources":["../lib/store/schema.ts","../lib/core/hex.ts","../lib/core/clock.ts","../lib/core/flatten.ts","../lib/core/document.ts","../lib/core/tombstone.ts","../lib/core/collection.ts","../lib/store/collection.ts","../lib/store/clock.ts","../lib/store/store.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\n\nexport function validate<T extends StandardSchemaV1>(\n  schema: T,\n  input: StandardSchemaV1.InferInput<T>,\n): StandardSchemaV1.InferOutput<T> {\n  const result = schema[\"~standard\"].validate(input);\n  if (result instanceof Promise) {\n    throw new TypeError(\"Schema validation must be synchronous\");\n  }\n\n  if (result.issues) {\n    throw new Error(JSON.stringify(result.issues, null, 2));\n  }\n\n  return result.value;\n}\n\n/**\n * Base type constraint for any standard schema object\n */\nexport type AnyObject = StandardSchemaV1<Record<string, any>>;\n\nexport type SchemaWithId<T extends AnyObject> =\n  StandardSchemaV1.InferOutput<T> extends {\n    id: any;\n  }\n    ? T\n    : never;\n\nexport type Output<T extends AnyObject> = StandardSchemaV1.InferOutput<T>;\n\nexport type Input<T extends AnyObject> = StandardSchemaV1.InferInput<T>;\n","export function toHex(value: number, padLength: number): string {\n  return value.toString(16).padStart(padLength, \"0\");\n}\n\nexport function nonce(length: number): string {\n  const bytes = new Uint8Array(length / 2);\n  crypto.getRandomValues(bytes);\n  return Array.from(bytes)\n    .map((b) => toHex(b, 2))\n    .join(\"\");\n}\n","import { nonce, toHex } from \"./hex\";\n\nconst MS_LENGTH = 12;\nconst SEQ_LENGTH = 6;\nconst NONCE_LENGTH = 6;\n\nexport type Clock = {\n  ms: number;\n  seq: number;\n};\n\nexport function advanceClock(current: Clock, next: Clock): Clock {\n  if (next.ms > current.ms) {\n    return { ms: next.ms, seq: next.seq };\n  } else if (next.ms === current.ms) {\n    return { ms: current.ms, seq: Math.max(current.seq, next.seq) + 1 };\n  } else {\n    return { ms: current.ms, seq: current.seq + 1 };\n  }\n}\n\nexport function makeStamp(ms: number, seq: number): string {\n  return `${toHex(ms, MS_LENGTH)}${toHex(seq, SEQ_LENGTH)}${nonce(NONCE_LENGTH)}`;\n}\n\nexport function parseStamp(stamp: string): { ms: number; seq: number } {\n  return {\n    ms: parseInt(stamp.slice(0, MS_LENGTH), 16),\n    seq: parseInt(stamp.slice(MS_LENGTH, MS_LENGTH + SEQ_LENGTH), 16),\n  };\n}\n","/**\n * Flattens a nested object into a flat object with dot-notation keys\n * @param obj - The object to flatten\n * @param mapper - Optional callback to transform leaf values\n * @returns A flattened object with dot-notation keys\n */\nexport function flatten<T, R = unknown>(\n  obj: T,\n  mapper?: (value: unknown, path: string) => R,\n): Record<string, R> {\n  const result: Record<string, R> = {};\n\n  const addLeaf = (value: unknown, path: string) => {\n    if (path) {\n      result[path] = mapper ? mapper(value, path) : (value as R);\n    }\n  };\n\n  function traverse(current: unknown, prefix: string = \"\"): void {\n    if (!shouldTraverse(current)) {\n      addLeaf(current, prefix);\n      return;\n    }\n\n    for (const [key, value] of Object.entries(current)) {\n      const newPath = prefix ? `${prefix}.${key}` : key;\n      traverse(value, newPath);\n    }\n  }\n\n  traverse(obj);\n  return result;\n}\n\n/**\n * Unflattens a flat object with dot-notation keys into a nested object\n * @param obj - The flattened object to unflatten\n * @param mapper - Optional callback to transform leaf values before placing them\n * @returns A nested object\n */\nexport function unflatten<T = unknown, R = unknown>(\n  obj: Record<string, T>,\n  mapper?: (value: T, path: string) => R,\n): Record<string, unknown> {\n  const result: Record<string, unknown> = {};\n\n  for (const [path, value] of Object.entries(obj)) {\n    const keys = path.split(\".\");\n    const mappedValue = mapper ? mapper(value, path) : value;\n\n    let current: any = result;\n    for (let i = 0; i < keys.length - 1; i++) {\n      const key = keys[i]!;\n      if (!(key in current)) {\n        current[key] = {};\n      }\n      current = current[key];\n    }\n\n    const finalKey = keys[keys.length - 1]!;\n    current[finalKey] = mappedValue;\n  }\n\n  return result;\n}\n\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    !Array.isArray(value) &&\n    (value.constructor === Object || Object.getPrototypeOf(value) === null)\n  );\n}\n\nfunction shouldTraverse(value: unknown): value is Record<string, unknown> {\n  return isPlainObject(value) && Object.keys(value).length > 0;\n}\n","import { flatten, unflatten } from \"./flatten\";\n\ntype Field<T = unknown> = {\n  \"~value\": T;\n  \"~stamp\": string;\n};\n\nexport type Document = Record<string, Field>;\n\nexport function makeDocument(\n  fields: Record<string, any>,\n  stamp: string,\n): Document {\n  return flatten(fields, (value) => ({ \"~value\": value, \"~stamp\": stamp }));\n}\n\nexport function parseDocument(document: Document): Record<string, any> {\n  return unflatten(document, (field) => field[\"~value\"]);\n}\n\nexport function mergeDocuments(target: Document, source: Document): Document {\n  const result: Document = {};\n  const keys = new Set([...Object.keys(target), ...Object.keys(source)]);\n\n  for (const key of keys) {\n    const targetValue = target[key];\n    const sourceValue = source[key];\n\n    if (targetValue && sourceValue) {\n      result[key] =\n        targetValue[\"~stamp\"] > sourceValue[\"~stamp\"]\n          ? targetValue\n          : sourceValue;\n    } else if (targetValue) {\n      result[key] = targetValue;\n    } else if (sourceValue) {\n      result[key] = sourceValue;\n    } else {\n      throw new Error(`Key ${key} not found in either document`);\n    }\n  }\n\n  return result;\n}\n","export type Tombstones = Record<string, string>;\n\nexport function mergeTombstones(\n  target: Tombstones,\n  source: Tombstones,\n): Tombstones {\n  const result: Tombstones = {};\n  const keys = new Set([...Object.keys(target), ...Object.keys(source)]);\n\n  for (const key of keys) {\n    const targetStamp = target[key];\n    const sourceStamp = source[key];\n\n    if (targetStamp && sourceStamp) {\n      result[key] = targetStamp > sourceStamp ? targetStamp : sourceStamp;\n    } else if (targetStamp) {\n      result[key] = targetStamp;\n    } else if (sourceStamp) {\n      result[key] = sourceStamp;\n    }\n  }\n\n  return result;\n}\n","import type { Document } from \"./document\";\nimport type { Tombstones } from \"./tombstone\";\nimport { mergeDocuments } from \"./document\";\nimport { mergeTombstones } from \"./tombstone\";\n\nexport type DocumentId = string;\n\nexport type Collection = {\n  documents: Record<DocumentId, Document>;\n  tombstones: Tombstones;\n};\n\nexport function mergeCollections(\n  target: Collection,\n  source: Collection,\n): Collection {\n  const mergedTombstones = mergeTombstones(\n    target.tombstones,\n    source.tombstones,\n  );\n\n  const mergedDocuments: Record<DocumentId, Document> = {};\n  const allDocumentIds = new Set([\n    ...Object.keys(target.documents),\n    ...Object.keys(source.documents),\n  ]);\n\n  for (const id of allDocumentIds) {\n    const targetDoc = target.documents[id];\n    const sourceDoc = source.documents[id];\n\n    if (mergedTombstones[id]) {\n      continue;\n    }\n\n    if (targetDoc && sourceDoc) {\n      mergedDocuments[id] = mergeDocuments(targetDoc, sourceDoc);\n    } else if (targetDoc) {\n      mergedDocuments[id] = targetDoc;\n    } else if (sourceDoc) {\n      mergedDocuments[id] = sourceDoc;\n    }\n  }\n\n  return {\n    documents: mergedDocuments,\n    tombstones: mergedTombstones,\n  };\n}\nexport function mergeCollectionRecords(\n  target: Record<string, Collection>,\n  source: Record<string, Collection>,\n): Record<string, Collection> {\n  const result: Record<string, Collection> = { ...target };\n\n  for (const [collectionName, sourceCollection] of Object.entries(source)) {\n    const targetCollection = result[collectionName];\n    if (targetCollection) {\n      result[collectionName] = mergeCollections(\n        targetCollection,\n        sourceCollection,\n      );\n    } else {\n      result[collectionName] = sourceCollection;\n    }\n  }\n\n  return result;\n}\n","import { atom, computed, type ReadableAtom } from \"nanostores\";\nimport { validate } from \"./schema\";\nimport {\n  makeDocument,\n  parseDocument,\n  mergeDocuments,\n  mergeCollections,\n  type Collection,\n  type DocumentId,\n} from \"../core\";\nimport type { AnyObject, SchemaWithId, Output, Input } from \"./schema\";\nimport type { ClockAPI } from \"./clock\";\n\nexport type CollectionConfig<T extends AnyObject> =\n  | {\n      schema: T;\n      getId: (data: Output<T>) => DocumentId;\n    }\n  | {\n      schema: SchemaWithId<T>;\n    };\n\nexport type CollectionApi<T extends AnyObject> = {\n  $data: ReadableAtom<ReadonlyMap<DocumentId, Output<T>>>;\n  $snapshot: ReadableAtom<Collection>;\n  add(data: Input<T>): void;\n  remove(id: DocumentId): void;\n  update(id: DocumentId, document: Partial<Input<T>>): void;\n  merge(snapshot: Collection): void;\n} & Pick<\n  ReadonlyMap<DocumentId, Output<T>>,\n  \"get\" | \"has\" | \"keys\" | \"values\" | \"entries\" | \"forEach\" | \"size\"\n>;\n\ntype TickFunction = () => string;\n\n// Internal state atom that holds both documents and tombstones\n// This allows us to update both atomically with a single notification\ntype CollectionState = {\n  documents: Collection[\"documents\"];\n  tombstones: Collection[\"tombstones\"];\n};\n\nexport function addDocument<T extends AnyObject>(\n  $state: ReturnType<typeof atom<CollectionState>>,\n  config: CollectionConfig<T>,\n  tick: TickFunction,\n  data: Input<T>,\n): void {\n  const getId = defineGetId(config);\n  const valid = validate(config.schema, data);\n  const doc = makeDocument(valid, tick());\n  const id = getId(valid);\n  const current = $state.get();\n  $state.set({\n    ...current,\n    documents: { ...current.documents, [id]: doc },\n  });\n}\n\nexport function removeDocument(\n  $state: ReturnType<typeof atom<CollectionState>>,\n  tick: TickFunction,\n  id: DocumentId,\n): void {\n  const current = $state.get();\n  const { [id]: _removed, ...remainingDocs } = current.documents;\n  $state.set({\n    documents: remainingDocs,\n    tombstones: { ...current.tombstones, [id]: tick() },\n  });\n}\n\nexport function updateDocument<T extends AnyObject>(\n  $state: ReturnType<typeof atom<CollectionState>>,\n  config: CollectionConfig<T>,\n  tick: TickFunction,\n  id: DocumentId,\n  document: Partial<Input<T>>,\n): void {\n  const current = $state.get();\n  const currentDoc = current.documents[id];\n  if (!currentDoc) return;\n\n  const newAttrs = makeDocument(document, tick());\n  const doc = mergeDocuments(currentDoc, newAttrs);\n\n  validate(config.schema, parseDocument(doc));\n\n  $state.set({\n    ...current,\n    documents: { ...current.documents, [id]: doc },\n  });\n}\n\nexport function mergeCollectionSnapshot(\n  $state: ReturnType<typeof atom<CollectionState>>,\n  currentSnapshot: Collection,\n  incomingSnapshot: Collection,\n): void {\n  const merged = mergeCollections(currentSnapshot, incomingSnapshot);\n  $state.set({\n    documents: merged.documents,\n    tombstones: merged.tombstones,\n  });\n}\n\nexport function createCollection<T extends AnyObject>(\n  config: CollectionConfig<T>,\n  clock: ClockAPI,\n): CollectionApi<T> {\n  const { $data, $snapshot, $state } = createCollectionState<T>();\n\n  return {\n    $data,\n    $snapshot,\n    get(key: DocumentId) {\n      return $data.get().get(key);\n    },\n    has(key: DocumentId) {\n      return $data.get().has(key);\n    },\n    keys() {\n      return $data.get().keys();\n    },\n    values() {\n      return $data.get().values();\n    },\n    entries() {\n      return $data.get().entries();\n    },\n    forEach(\n      callbackfn: (\n        value: Output<T>,\n        key: DocumentId,\n        map: ReadonlyMap<DocumentId, Output<T>>,\n      ) => void,\n      thisArg?: any,\n    ) {\n      return $data.get().forEach(callbackfn, thisArg);\n    },\n    get size() {\n      return $data.get().size;\n    },\n    add(data: Input<T>) {\n      addDocument($state, config, clock.tick, data);\n    },\n    remove(id: DocumentId) {\n      removeDocument($state, clock.tick, id);\n    },\n    update(id: DocumentId, document: Partial<Input<T>>) {\n      updateDocument($state, config, clock.tick, id, document);\n    },\n    merge(snapshot: Collection) {\n      const currentSnapshot = $snapshot.get();\n      mergeCollectionSnapshot($state, currentSnapshot, snapshot);\n    },\n  };\n}\n\nfunction createCollectionState<T extends AnyObject>(): {\n  $data: ReadableAtom<ReadonlyMap<DocumentId, Output<T>>>;\n  $snapshot: ReadableAtom<Collection>;\n  $state: ReturnType<typeof atom<CollectionState>>;\n} {\n  // Single atom holding both documents and tombstones for atomic updates\n  const $state = atom<CollectionState>({\n    documents: {},\n    tombstones: {},\n  });\n\n  const $snapshot = computed($state, (state) => {\n    return parseSnapshot(state.documents, state.tombstones);\n  });\n\n  const $data = computed($state, (state) => {\n    return parseCollection<T>(state.documents, state.tombstones);\n  });\n\n  return {\n    $data,\n    $snapshot,\n    $state,\n  };\n}\n\nfunction hasIdProperty<T extends AnyObject>(\n  data: Output<T>,\n): data is { id: DocumentId } {\n  return (\n    typeof data === \"object\" &&\n    data !== null &&\n    \"id\" in data &&\n    typeof (data as any).id === \"string\"\n  );\n}\n\nfunction parseCollection<T extends AnyObject>(\n  documents: Collection[\"documents\"],\n  tombstones: Collection[\"tombstones\"],\n): ReadonlyMap<DocumentId, Output<T>> {\n  const result = new Map<DocumentId, Output<T>>();\n  for (const [id, doc] of Object.entries(documents)) {\n    if (!tombstones[id] && doc) {\n      result.set(id, parseDocument(doc));\n    }\n  }\n  return result;\n}\n\nfunction parseSnapshot(\n  documents: Collection[\"documents\"],\n  tombstones: Collection[\"tombstones\"],\n): Collection {\n  return {\n    documents,\n    tombstones,\n  };\n}\n\nfunction hasGetId<T extends AnyObject>(\n  config: CollectionConfig<T>,\n): config is {\n  schema: T;\n  getId: (data: Output<T>) => DocumentId;\n} {\n  return \"getId\" in config && typeof config.getId === \"function\";\n}\n\nfunction defineGetId<T extends AnyObject>(\n  config: CollectionConfig<T>,\n): (data: Output<T>) => DocumentId {\n  return hasGetId(config) ? config.getId : defaultGetId;\n}\n\nfunction defaultGetId<T extends AnyObject>(data: Output<T>): DocumentId {\n  if (hasIdProperty(data)) {\n    return data.id;\n  }\n  throw new Error(\n    \"Schema must have an 'id' property when getId is not provided\",\n  );\n}\n","import { atom } from \"nanostores\";\nimport type { Clock } from \"../core/clock\";\nimport { advanceClock, makeStamp } from \"../core/clock\";\n\ntype ClockAtom = ReturnType<typeof atom<Clock>>;\n\nexport type ClockAPI = {\n  $state: ClockAtom;\n  tick: () => string;\n  advance: (ms: number, seq: number) => void;\n};\n\nexport function createClock(): ClockAPI {\n  const $state: ClockAtom = atom<Clock>(nowClock());\n\n  const tick = () => {\n    const next = advanceClock($state.get(), nowClock());\n    $state.set(next);\n    return makeStamp(next.ms, next.seq);\n  };\n\n  const advance = (ms: number, seq: number) => {\n    const next = advanceClock($state.get(), { ms, seq });\n    $state.set(next);\n  };\n\n  return {\n    $state,\n    tick,\n    advance,\n  };\n}\n\nfunction nowClock(): Clock {\n  return { ms: Date.now(), seq: 0 };\n}\n","import { computed, type ReadableAtom } from \"nanostores\";\nimport { createCollection } from \"./collection\";\nimport { createClock, type ClockAPI } from \"./clock\";\nimport type { CollectionConfig, CollectionApi } from \"./collection\";\nimport type { Clock } from \"../core/clock\";\nimport type { Collection } from \"../core/collection\";\n\nexport type StoreSnapshot = {\n  clock: Clock;\n  collections: Record<string, Collection>;\n};\n\nexport type StoreCollections<T extends Record<string, CollectionConfig<any>>> =\n  {\n    [K in keyof T]: T[K] extends CollectionConfig<infer S>\n      ? CollectionApi<S>\n      : never;\n  };\n\nexport type QueryCollections<\n  TCollections extends StoreCollections<any>,\n  TKeys extends readonly (keyof TCollections)[],\n> = {\n  [K in TKeys[number]]: TCollections[K] extends { $data: ReadableAtom<infer D> }\n    ? D\n    : never;\n};\n\nexport type StoreAPI<T extends Record<string, CollectionConfig<any>>> =\n  StoreCollections<T> & {\n    $snapshot: ReadableAtom<StoreSnapshot>;\n    query<TKeys extends readonly (keyof StoreCollections<T>)[], TResult>(\n      collections: TKeys,\n      callback: (\n        collections: QueryCollections<StoreCollections<T>, TKeys>,\n      ) => TResult,\n    ): ReadableAtom<TResult>;\n    merge(snapshot: StoreSnapshot): void;\n  };\n\nexport function createStore<\n  T extends Record<string, CollectionConfig<any>>,\n>(config: { collections: T }): StoreAPI<T> {\n  const clock = createClock();\n  const collections = initCollections(config.collections, clock);\n  const $snapshot = parseCollections(collections, clock.$state);\n\n  function getCollectionDataStores(\n    collectionNames: readonly (keyof StoreCollections<T>)[],\n  ): ReadableAtom<any>[] {\n    return collectionNames.map((name) => collections[name]!.$data);\n  }\n\n  return {\n    ...collections,\n    $snapshot,\n    query: <TKeys extends readonly (keyof StoreCollections<T>)[], TResult>(\n      collectionNames: TKeys,\n      callback: (\n        collections: QueryCollections<StoreCollections<T>, TKeys>,\n      ) => TResult,\n    ) => {\n      const atoms = getCollectionDataStores(collectionNames);\n\n      return computed(atoms, (...values) => {\n        const entries = collectionNames.map((name, i) => [name, values[i]]);\n        return callback(\n          Object.fromEntries(entries) as QueryCollections<\n            StoreCollections<T>,\n            TKeys\n          >,\n        );\n      });\n    },\n    merge: (snapshot) => {\n      clock.advance(snapshot.clock.ms, snapshot.clock.seq);\n      mergeCollections(collections, snapshot.collections);\n    },\n  };\n}\n\nfunction initCollections<T extends Record<string, CollectionConfig<any>>>(\n  collectionsConfig: T,\n  clock: ClockAPI,\n): StoreCollections<T> {\n  return Object.fromEntries(\n    Object.entries(collectionsConfig).map(([name, config]) => [\n      name,\n      createCollection(config, clock),\n    ]),\n  ) as StoreCollections<T>;\n}\n\nfunction parseCollections<T extends Record<string, CollectionConfig<any>>>(\n  collections: StoreCollections<T>,\n  clockState: ReadableAtom<Clock>,\n): ReadableAtom<StoreSnapshot> {\n  const collectionNames = Object.keys(collections);\n  const collectionSnapshotAtoms: ReadableAtom<Collection>[] = [];\n\n  for (const name of collectionNames) {\n    const collection = collections[name];\n    if (collection) {\n      collectionSnapshotAtoms.push(collection.$snapshot);\n    }\n  }\n\n  // Note: We don't include clockState in the dependency array because the clock\n  // is always updated together with collection changes (via tick()). Including it\n  // would cause double notifications. Instead, we read it synchronously inside.\n  return computed(collectionSnapshotAtoms, (...snapshots) => {\n    const clock = clockState.get();\n    const collectionsSnapshot: Record<string, Collection> = {};\n    for (let i = 0; i < collectionNames.length; i++) {\n      const name = collectionNames[i];\n      const snapshot = snapshots[i];\n      if (name && snapshot !== undefined) {\n        collectionsSnapshot[name] = snapshot;\n      }\n    }\n\n    return {\n      clock,\n      collections: collectionsSnapshot,\n    };\n  });\n}\n\nfunction mergeCollections(\n  target: Record<string, CollectionApi<any>>,\n  source: Record<string, Collection>,\n) {\n  for (const [collectionName, collectionSnapshot] of Object.entries(source)) {\n    const collection = target[collectionName];\n    if (collection) {\n      collection.merge(collectionSnapshot);\n    }\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":["result: Record<string, R>","result: Record<string, unknown>","current: any","result: Document","mergedDocuments: Record<DocumentId, Document>","result: Tombstones","clock: Clock","tombstones: Tombstones","documents: Record<string, Record<DocumentId, Document>>","config","resultDocs: Output<T[typeof collectionName][\"schema\"]>[]","collectionsSnapshot: Record<string, Collection>","filteredDocs: Record<DocumentId, Document>"],"sources":["../lib/store/schema.ts","../lib/core/hex.ts","../lib/core/clock.ts","../lib/core/flatten.ts","../lib/core/document.ts","../lib/core/collection.ts","../lib/core/tombstone.ts","../lib/store/store.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\n\nexport function validate<T extends StandardSchemaV1>(\n  schema: T,\n  input: StandardSchemaV1.InferInput<T>,\n): StandardSchemaV1.InferOutput<T> {\n  const result = schema[\"~standard\"].validate(input);\n  if (result instanceof Promise) {\n    throw new TypeError(\"Schema validation must be synchronous\");\n  }\n\n  if (result.issues) {\n    throw new Error(JSON.stringify(result.issues, null, 2));\n  }\n\n  return result.value;\n}\n\n/**\n * Base type constraint for any standard schema object\n */\nexport type AnyObject = StandardSchemaV1<Record<string, any>>;\n\nexport type SchemaWithId<T extends AnyObject> =\n  StandardSchemaV1.InferOutput<T> extends {\n    id: any;\n  }\n    ? T\n    : never;\n\nexport type Output<T extends AnyObject> = StandardSchemaV1.InferOutput<T>;\n\nexport type Input<T extends AnyObject> = StandardSchemaV1.InferInput<T>;\n","export function toHex(value: number, padLength: number): string {\n  return value.toString(16).padStart(padLength, \"0\");\n}\n\nexport function nonce(length: number): string {\n  const bytes = new Uint8Array(length / 2);\n  crypto.getRandomValues(bytes);\n  return Array.from(bytes)\n    .map((b) => toHex(b, 2))\n    .join(\"\");\n}\n","import { nonce, toHex } from \"./hex\";\n\nconst MS_LENGTH = 12;\nconst SEQ_LENGTH = 6;\nconst NONCE_LENGTH = 6;\n\nexport type Clock = {\n  ms: number;\n  seq: number;\n};\n\nexport function advanceClock(current: Clock, next: Clock): Clock {\n  if (next.ms > current.ms) {\n    return { ms: next.ms, seq: next.seq };\n  } else if (next.ms === current.ms) {\n    return { ms: current.ms, seq: Math.max(current.seq, next.seq) + 1 };\n  } else {\n    return { ms: current.ms, seq: current.seq + 1 };\n  }\n}\n\nexport function makeStamp(ms: number, seq: number): string {\n  return `${toHex(ms, MS_LENGTH)}${toHex(seq, SEQ_LENGTH)}${nonce(NONCE_LENGTH)}`;\n}\n\nexport function parseStamp(stamp: string): { ms: number; seq: number } {\n  return {\n    ms: parseInt(stamp.slice(0, MS_LENGTH), 16),\n    seq: parseInt(stamp.slice(MS_LENGTH, MS_LENGTH + SEQ_LENGTH), 16),\n  };\n}\n","/**\n * Flattens a nested object into a flat object with dot-notation keys\n * @param obj - The object to flatten\n * @param mapper - Optional callback to transform leaf values\n * @returns A flattened object with dot-notation keys\n */\nexport function flatten<T, R = unknown>(\n  obj: T,\n  mapper?: (value: unknown, path: string) => R,\n): Record<string, R> {\n  const result: Record<string, R> = {};\n\n  const addLeaf = (value: unknown, path: string) => {\n    if (path) {\n      result[path] = mapper ? mapper(value, path) : (value as R);\n    }\n  };\n\n  function traverse(current: unknown, prefix: string = \"\"): void {\n    if (!shouldTraverse(current)) {\n      addLeaf(current, prefix);\n      return;\n    }\n\n    for (const [key, value] of Object.entries(current)) {\n      const newPath = prefix ? `${prefix}.${key}` : key;\n      traverse(value, newPath);\n    }\n  }\n\n  traverse(obj);\n  return result;\n}\n\n/**\n * Unflattens a flat object with dot-notation keys into a nested object\n * @param obj - The flattened object to unflatten\n * @param mapper - Optional callback to transform leaf values before placing them\n * @returns A nested object\n */\nexport function unflatten<T = unknown, R = unknown>(\n  obj: Record<string, T>,\n  mapper?: (value: T, path: string) => R,\n): Record<string, unknown> {\n  const result: Record<string, unknown> = {};\n\n  for (const [path, value] of Object.entries(obj)) {\n    const keys = path.split(\".\");\n    const mappedValue = mapper ? mapper(value, path) : value;\n\n    let current: any = result;\n    for (let i = 0; i < keys.length - 1; i++) {\n      const key = keys[i]!;\n      if (!(key in current)) {\n        current[key] = {};\n      }\n      current = current[key];\n    }\n\n    const finalKey = keys[keys.length - 1]!;\n    current[finalKey] = mappedValue;\n  }\n\n  return result;\n}\n\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    !Array.isArray(value) &&\n    (value.constructor === Object || Object.getPrototypeOf(value) === null)\n  );\n}\n\nfunction shouldTraverse(value: unknown): value is Record<string, unknown> {\n  return isPlainObject(value) && Object.keys(value).length > 0;\n}\n","import { flatten, unflatten } from \"./flatten\";\n\ntype Field<T = unknown> = {\n  \"~value\": T;\n  \"~stamp\": string;\n};\n\nexport type Document = Record<string, Field>;\n\nexport function makeDocument(fields: Record<string, any>, stamp: string): Document {\n  return flatten(fields, (value) => ({ \"~value\": value, \"~stamp\": stamp }));\n}\n\nexport function parseDocument(document: Document): Record<string, any> {\n  return unflatten(document, (field) => field[\"~value\"]);\n}\n\nexport function mergeDocuments(target: Document, source: Document): Document {\n  const result: Document = {};\n  const keys = new Set([...Object.keys(target), ...Object.keys(source)]);\n\n  for (const key of keys) {\n    const targetValue = target[key];\n    const sourceValue = source[key];\n\n    if (targetValue && sourceValue) {\n      result[key] = targetValue[\"~stamp\"] > sourceValue[\"~stamp\"] ? targetValue : sourceValue;\n    } else if (targetValue) {\n      result[key] = targetValue;\n    } else if (sourceValue) {\n      result[key] = sourceValue;\n    } else {\n      throw new Error(`Key ${key} not found in either document`);\n    }\n  }\n\n  return result;\n}\n","import type { Document } from \"./document\";\nimport type { Tombstones } from \"./tombstone\";\nimport { mergeDocuments } from \"./document\";\n\nexport type DocumentId = string;\n\nexport type Collection = {\n  documents: Record<DocumentId, Document>;\n};\n\nexport function mergeCollections(\n  target: Collection,\n  source: Collection,\n  tombstones: Tombstones,\n): Collection {\n  const mergedDocuments: Record<DocumentId, Document> = {};\n  const allDocumentIds = new Set([\n    ...Object.keys(target.documents),\n    ...Object.keys(source.documents),\n  ]);\n\n  for (const id of allDocumentIds) {\n    const targetDoc = target.documents[id];\n    const sourceDoc = source.documents[id];\n\n    if (tombstones[id]) {\n      continue;\n    }\n\n    if (targetDoc && sourceDoc) {\n      mergedDocuments[id] = mergeDocuments(targetDoc, sourceDoc);\n    } else if (targetDoc) {\n      mergedDocuments[id] = targetDoc;\n    } else if (sourceDoc) {\n      mergedDocuments[id] = sourceDoc;\n    }\n  }\n\n  return {\n    documents: mergedDocuments,\n  };\n}\nexport function mergeCollectionRecords(\n  target: Record<string, Collection>,\n  source: Record<string, Collection>,\n  tombstones: Tombstones,\n): Record<string, Collection> {\n  const result: Record<string, Collection> = { ...target };\n\n  for (const [collectionName, sourceCollection] of Object.entries(source)) {\n    const targetCollection = result[collectionName];\n    if (targetCollection) {\n      result[collectionName] = mergeCollections(targetCollection, sourceCollection, tombstones);\n    } else {\n      result[collectionName] = sourceCollection;\n    }\n  }\n\n  return result;\n}\n","export type Tombstones = Record<string, string>;\n\nexport function mergeTombstones(target: Tombstones, source: Tombstones): Tombstones {\n  const result: Tombstones = {};\n  const keys = new Set([...Object.keys(target), ...Object.keys(source)]);\n\n  for (const key of keys) {\n    const targetStamp = target[key];\n    const sourceStamp = source[key];\n\n    if (targetStamp && sourceStamp) {\n      result[key] = targetStamp > sourceStamp ? targetStamp : sourceStamp;\n    } else if (targetStamp) {\n      result[key] = targetStamp;\n    } else if (sourceStamp) {\n      result[key] = sourceStamp;\n    }\n  }\n\n  return result;\n}\n","import { validate } from \"./schema\";\nimport {\n  makeDocument,\n  parseDocument,\n  mergeDocuments,\n  mergeCollections,\n  type Collection,\n  type DocumentId,\n} from \"../core\";\nimport type { Clock } from \"../core/clock\";\nimport { advanceClock, makeStamp } from \"../core/clock\";\nimport type { Input, Output, AnyObject } from \"./schema\";\nimport type { Tombstones } from \"../core/tombstone\";\nimport { mergeTombstones } from \"../core/tombstone\";\nimport type { Document } from \"../core/document\";\n\nexport type CollectionConfig<T extends AnyObject> = {\n  schema: T;\n  keyPath: keyof Output<T> & string;\n};\n\nexport type StoreSnapshot = {\n  clock: Clock;\n  collections: Record<string, Collection>;\n  tombstones: Tombstones;\n};\n\nexport type StoreChangeEvent<T extends Record<string, CollectionConfig<AnyObject>>> = {\n  [K in keyof T]:\n    | { type: \"add\"; collection: K; id: DocumentId; data: Output<T[K][\"schema\"]> }\n    | { type: \"update\"; collection: K; id: DocumentId; data: Output<T[K][\"schema\"]> }\n    | { type: \"remove\"; collection: K; id: DocumentId }\n    | { type: \"merge\"; collection: K };\n}[keyof T];\n\nexport type StoreAPI<T extends Record<string, CollectionConfig<AnyObject>>> = {\n  add<K extends keyof T & string>(collection: K, data: Input<T[K][\"schema\"]>): void;\n\n  get<K extends keyof T & string>(\n    collection: K,\n    id: DocumentId,\n  ): Output<T[K][\"schema\"]> | undefined;\n\n  getAll<K extends keyof T & string>(\n    collection: K,\n    options?: { where?: (item: Output<T[K][\"schema\"]>) => boolean },\n  ): Output<T[K][\"schema\"]>[];\n\n  update<K extends keyof T & string>(\n    collection: K,\n    id: DocumentId,\n    data: Partial<Input<T[K][\"schema\"]>>,\n  ): void;\n\n  remove<K extends keyof T & string>(collection: K, id: DocumentId): void;\n\n  getSnapshot(): StoreSnapshot;\n  merge(snapshot: StoreSnapshot): void;\n  onChange(listener: (event: StoreChangeEvent<T>) => void): () => void;\n};\n\nexport function createStore<T extends Record<string, CollectionConfig<AnyObject>>>(config: {\n  collections: T;\n}): StoreAPI<T> {\n  let clock: Clock = { ms: Date.now(), seq: 0 };\n  let tombstones: Tombstones = {};\n  const documents: Record<string, Record<DocumentId, Document>> = {};\n  const configs = new Map<string, CollectionConfig<AnyObject>>();\n  const listeners = new Set<(event: StoreChangeEvent<T>) => void>();\n\n  const tick = (): string => {\n    advance(Date.now(), 0);\n    return makeStamp(clock.ms, clock.seq);\n  };\n\n  const advance = (ms: number, seq: number): void => {\n    clock = advanceClock(clock, { ms, seq });\n  };\n\n  const notify = (collectionName: string, event: { type: string; id?: DocumentId; data?: any }) => {\n    listeners.forEach((listener) =>\n      listener({ collection: collectionName, ...event } as StoreChangeEvent<T>),\n    );\n  };\n\n  const getConfig = <K extends keyof T & string>(\n    collectionName: K,\n  ): CollectionConfig<AnyObject> => {\n    const config = configs.get(collectionName);\n\n    if (!config) {\n      throw new Error(`Collection \"${collectionName}\" not found`);\n    }\n\n    return config;\n  };\n\n  const getDocs = <K extends keyof T & string>(collectionName: K): Record<DocumentId, Document> => {\n    const docs = documents[collectionName];\n    if (!docs) {\n      throw new Error(`Collection \"${collectionName}\" not found`);\n    }\n    return docs;\n  };\n\n  // Initialize collections\n  for (const [name, collectionConfig] of Object.entries(config.collections)) {\n    configs.set(name, collectionConfig);\n    documents[name] = {};\n  }\n\n  return {\n    add(collectionName, data) {\n      const collectionConfig = getConfig(collectionName);\n      const valid = validate(collectionConfig.schema, data);\n      const id = valid[collectionConfig.keyPath] as DocumentId;\n      const doc = makeDocument(valid, tick());\n\n      documents[collectionName] = {\n        ...documents[collectionName],\n        [id]: doc,\n      };\n\n      notify(collectionName, { type: \"add\", id, data: valid });\n    },\n\n    get(collectionName, id) {\n      if (tombstones[id]) return undefined;\n      const collectionDocs = getDocs(collectionName);\n      const doc = collectionDocs[id];\n\n      if (!doc) return undefined;\n\n      return parseDocument(doc) as Output<T[typeof collectionName][\"schema\"]>;\n    },\n\n    getAll(collectionName, options) {\n      const collectionDocs = getDocs(collectionName);\n      const resultDocs: Output<T[typeof collectionName][\"schema\"]>[] = [];\n\n      for (const [id, doc] of Object.entries(collectionDocs)) {\n        if (doc && !tombstones[id]) {\n          const parsed = parseDocument(doc) as Output<T[typeof collectionName][\"schema\"]>;\n          if (!options?.where || options?.where(parsed)) {\n            resultDocs.push(parsed);\n          }\n        }\n      }\n\n      return resultDocs;\n    },\n\n    update(collectionName, id, data) {\n      const collectionDocs = getDocs(collectionName);\n      const currentDoc = collectionDocs[id];\n\n      if (!currentDoc) return;\n\n      const collectionConfig = getConfig(collectionName);\n      const newAttrs = makeDocument(data, tick());\n      const mergedDoc = mergeDocuments(currentDoc, newAttrs);\n\n      const parsed = parseDocument(mergedDoc);\n      validate(collectionConfig.schema, parsed);\n\n      documents[collectionName] = { ...collectionDocs, [id]: mergedDoc };\n\n      notify(collectionName, { type: \"update\", id, data: parsed });\n    },\n\n    remove(collectionName, id) {\n      const collectionDocs = getDocs(collectionName);\n      tombstones = { ...tombstones, [id]: tick() };\n      const { [id]: _removed, ...remainingDocs } = collectionDocs;\n      documents[collectionName] = remainingDocs;\n      notify(collectionName, { type: \"remove\", id });\n    },\n\n    getSnapshot(): StoreSnapshot {\n      const collectionsSnapshot: Record<string, Collection> = {};\n      for (const [name, collectionDocs] of Object.entries(documents)) {\n        collectionsSnapshot[name] = { documents: collectionDocs };\n      }\n      return {\n        clock,\n        collections: collectionsSnapshot,\n        tombstones,\n      };\n    },\n\n    merge(snapshot: StoreSnapshot): void {\n      advance(snapshot.clock.ms, snapshot.clock.seq);\n\n      tombstones = mergeTombstones(tombstones, snapshot.tombstones);\n\n      for (const [name, collectionData] of Object.entries(snapshot.collections)) {\n        // Initialize collection if it doesn't exist\n        if (!documents[name]) {\n          documents[name] = {};\n        }\n\n        // Filter out tombstoned documents before merging\n        const filteredDocs: Record<DocumentId, Document> = {};\n        for (const [id, doc] of Object.entries(collectionData.documents)) {\n          if (!tombstones[id]) {\n            filteredDocs[id] = doc;\n          }\n        }\n\n        // Merge collections using core mergeCollections function\n        const currentCollection: Collection = {\n          documents: documents[name],\n        };\n\n        const sourceCollection: Collection = {\n          documents: filteredDocs,\n        };\n\n        const merged = mergeCollections(currentCollection, sourceCollection, tombstones);\n        documents[name] = merged.documents;\n\n        // Notify merge event\n        notify(name, { type: \"merge\" });\n      }\n    },\n\n    onChange(listener: (event: StoreChangeEvent<T>) => void): () => void {\n      listeners.add(listener);\n      return () => listeners.delete(listener);\n    },\n  };\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,9 @@
 {
   "name": "@byearlybird/starling",
-  "version": "0.13.2",
+  "version": "0.14.0",
+  "files": [
+    "dist"
+  ],
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -11,28 +14,31 @@
       "import": "./dist/index.js"
     }
   },
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "tsdown",
-    "dev": "tsdown --watch",
-    "format": "prettier . --write",
-    "format:check": "prettier . --check",
-    "typecheck": "tsc --noEmit",
-    "prepublishOnly": "bun run build"
+  "dependencies": {
+    "@standard-schema/spec": "^1.1.0"
   },
   "devDependencies": {
-    "@types/bun": "latest",
-    "prettier": "3.7.4",
+    "@types/node": "^22.10.5",
+    "@vitest/coverage-v8": "^4.0.17",
+    "oxfmt": "^0.24.0",
+    "oxlint": "^1.39.0",
     "tsdown": "^0.18.3",
+    "typescript": "^5.7.3",
+    "vitest": "^4.0.17",
     "zod": "^4.2.1"
   },
   "peerDependencies": {
     "typescript": "^5"
   },
-  "dependencies": {
-    "@standard-schema/spec": "^1.1.0",
-    "nanostores": "^1.1.0"
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "fmt": "oxfmt",
+    "fmt:check": "oxfmt --check",
+    "lint": "oxlint",
+    "lint:fix": "oxlint --fix",
+    "typecheck": "tsc --noEmit"
   }
-}
+}