@byearlybird/starling 0.9.0 → 0.9.2

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { a as StoreAddOptions, i as Store, l as EncodedDocument, n as Query, o as StoreConfig, r as QueryConfig, s as StoreSetTransaction, t as Plugin, u as processDocument } from "./store-Dc-hIF56.js";
-export { type EncodedDocument, Plugin, Query, QueryConfig, Store, StoreAddOptions, StoreConfig, StoreSetTransaction, processDocument };
+import { a as StoreAddOptions, c as Collection, d as EncodedRecord, f as EncodedValue, i as Store, l as EncodedDocument, n as Query, o as StoreConfig, r as QueryConfig, s as StoreSetTransaction, t as Plugin, u as processDocument } from "./store-F8qPSj_p.js";
+export { type Collection, type EncodedDocument, type EncodedRecord, type EncodedValue, Plugin, Query, QueryConfig, Store, StoreAddOptions, StoreConfig, StoreSetTransaction, processDocument };

package/dist/index.js

@@ -175,6 +175,24 @@ function deleteDoc(doc, eventstamp) {
 		"~deletedAt": eventstamp
 	};
 }
+/**
+* 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);
 	return {
@@ -304,6 +322,30 @@ var Clock = class {
 
 //#endregion
 //#region src/store.ts
+/**
+* Lightweight local-first data store with built-in sync and reactive queries.
+*
+* Stores plain JavaScript objects with automatic field-level conflict resolution
+* using Last-Write-Wins semantics powered by hybrid logical clocks.
+*
+* @template T - The type of documents stored in this collection
+*
+* @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!'));
+* ```
+*/
 var Store = class {
 	#readMap = /* @__PURE__ */ new Map();
 	#clock = new Clock();
@@ -317,9 +359,16 @@ var Store = class {
 	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() {
@@ -330,12 +379,20 @@ var Store = class {
 		}
 		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"]);
@@ -345,6 +402,22 @@ var Store = class {
 		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 = [];
@@ -394,15 +467,34 @@ var Store = class {
 		}
 		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);
@@ -411,11 +503,25 @@ var Store = class {
 		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) {
@@ -429,6 +535,17 @@ var Store = class {
 		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,

package/dist/plugins/unstorage/plugin.d.ts

@@ -1,17 +1,54 @@
-import { c as Collection, t as Plugin } from "../../store-Dc-hIF56.js";
+import { c as Collection, t as Plugin } from "../../store-F8qPSj_p.js";
 import { Storage } from "unstorage";
 
 //#region src/plugins/unstorage/plugin.d.ts
 type MaybePromise<T> = T | Promise<T>;
 type UnstorageOnBeforeSet = (data: Collection) => MaybePromise<Collection>;
 type UnstorageOnAfterGet = (data: Collection) => MaybePromise<Collection>;
+/**
+ * Configuration options for the unstorage persistence plugin.
+ */
 type UnstorageConfig = {
+  /** Delay in ms to collapse rapid mutations into a single write. Default: 0 (immediate) */
   debounceMs?: number;
+  /** Interval in ms to poll storage for external changes. When set, enables automatic sync. */
   pollIntervalMs?: number;
+  /** Hook invoked before persisting to storage. Use for encryption, compression, etc. */
   onBeforeSet?: UnstorageOnBeforeSet;
+  /** Hook invoked after loading from storage. Use for decryption, validation, etc. */
   onAfterGet?: UnstorageOnAfterGet;
+  /** Function that returns true to skip persistence operations. Use for conditional sync. */
   skip?: () => boolean;
 };
+/**
+ * Persistence plugin for Starling using unstorage backends.
+ *
+ * Automatically persists store snapshots and optionally polls for external changes.
+ *
+ * @param key - Storage key for this dataset
+ * @param storage - Unstorage instance (localStorage, HTTP, filesystem, etc.)
+ * @param config - Optional configuration for debouncing, polling, hooks, and conditional sync
+ * @returns Plugin instance for store.use()
+ *
+ * @example
+ * ```ts
+ * import { unstoragePlugin } from "@byearlybird/starling/plugin-unstorage";
+ * import { createStorage } from "unstorage";
+ * import localStorageDriver from "unstorage/drivers/localstorage";
+ *
+ * const store = await new Store<Todo>()
+ *   .use(unstoragePlugin('todos', createStorage({
+ *     driver: localStorageDriver({ base: 'app:' })
+ *   }), {
+ *     debounceMs: 300,
+ *     pollIntervalMs: 5000,
+ *     skip: () => !navigator.onLine
+ *   }))
+ *   .init();
+ * ```
+ *
+ * @see {@link ../../../../docs/plugins/unstorage.md} for detailed configuration guide
+ */
 declare function unstoragePlugin<T>(key: string, storage: Storage<Collection>, config?: UnstorageConfig): Plugin<T>;
 //#endregion
 export { type UnstorageConfig, unstoragePlugin };

package/dist/plugins/unstorage/plugin.js

@@ -1,27 +1,63 @@
 //#region src/plugins/unstorage/plugin.ts
+/**
+* Persistence plugin for Starling using unstorage backends.
+*
+* Automatically persists store snapshots and optionally polls for external changes.
+*
+* @param key - Storage key for this dataset
+* @param storage - Unstorage instance (localStorage, HTTP, filesystem, etc.)
+* @param config - Optional configuration for debouncing, polling, hooks, and conditional sync
+* @returns Plugin instance for store.use()
+*
+* @example
+* ```ts
+* import { unstoragePlugin } from "@byearlybird/starling/plugin-unstorage";
+* import { createStorage } from "unstorage";
+* import localStorageDriver from "unstorage/drivers/localstorage";
+*
+* const store = await new Store<Todo>()
+*   .use(unstoragePlugin('todos', createStorage({
+*     driver: localStorageDriver({ base: 'app:' })
+*   }), {
+*     debounceMs: 300,
+*     pollIntervalMs: 5000,
+*     skip: () => !navigator.onLine
+*   }))
+*   .init();
+* ```
+*
+* @see {@link ../../../../docs/plugins/unstorage.md} for detailed configuration guide
+*/
 function unstoragePlugin(key, storage, config = {}) {
 	const { debounceMs = 0, pollIntervalMs, onBeforeSet, onAfterGet, skip } = config;
 	let debounceTimer = null;
 	let pollInterval = null;
 	let store = null;
+	let persistPromise = null;
 	const persistSnapshot = async () => {
 		if (!store) return;
 		const data = store.collection();
 		const persisted = onBeforeSet !== void 0 ? await onBeforeSet(data) : data;
 		await storage.set(key, persisted);
 	};
+	const runPersist = async () => {
+		debounceTimer = null;
+		persistPromise = persistSnapshot();
+		await persistPromise;
+		persistPromise = null;
+	};
 	const schedulePersist = () => {
 		if (skip?.()) return;
-		const runPersist = () => {
-			debounceTimer = null;
-			persistSnapshot();
-		};
 		if (debounceMs === 0) {
-			runPersist();
+			persistPromise = persistSnapshot().finally(() => {
+				persistPromise = null;
+			});
 			return;
 		}
 		if (debounceTimer !== null) clearTimeout(debounceTimer);
-		debounceTimer = setTimeout(runPersist, debounceMs);
+		debounceTimer = setTimeout(() => {
+			runPersist();
+		}, debounceMs);
 	};
 	const pollStorage = async () => {
 		if (!store) return;
@@ -39,15 +75,17 @@ function unstoragePlugin(key, storage, config = {}) {
 				pollStorage();
 			}, pollIntervalMs);
 		},
-		onDispose: () => {
+		onDispose: async () => {
 			if (debounceTimer !== null) {
 				clearTimeout(debounceTimer);
 				debounceTimer = null;
+				await runPersist();
 			}
 			if (pollInterval !== null) {
 				clearInterval(pollInterval);
 				pollInterval = null;
 			}
+			if (persistPromise !== null) await persistPromise;
 			store = null;
 		},
 		onAdd: () => {

package/dist/store-F8qPSj_p.d.ts

@@ -0,0 +1,306 @@
+//#region src/crdt/value.d.ts
+/**
+ * A primitive value wrapped with its eventstamp for Last-Write-Wins conflict resolution.
+ * Used as the leaf nodes in the CRDT data structure.
+ *
+ * @template T - The type of the wrapped value (primitive or complex type)
+ */
+type EncodedValue<T> = {
+  /** The actual value being stored */
+  "~value": T;
+  /** The eventstamp indicating when this value was last written (ISO|counter|nonce) */
+  "~eventstamp": string;
+};
+//#endregion
+//#region src/crdt/record.d.ts
+/**
+ * A nested object structure where each field is either an EncodedValue (leaf)
+ * or another EncodedRecord (nested object). This enables field-level
+ * Last-Write-Wins merging for complex data structures.
+ *
+ * Each field maintains its own eventstamp, allowing concurrent updates to
+ * different fields to be preserved during merge operations.
+ */
+type EncodedRecord = {
+  [key: string]: EncodedValue<unknown> | EncodedRecord;
+};
+//#endregion
+//#region src/crdt/document.d.ts
+/**
+ * Top-level document structure with system metadata for tracking identity,
+ * data, and deletion state. Documents are the primary unit of storage and
+ * synchronization in Starling.
+ *
+ * The tilde prefix (~) distinguishes system metadata from user-defined data.
+ */
+type EncodedDocument = {
+  /** Unique identifier for this document */
+  "~id": string;
+  /** The document's data, either a primitive value or nested object structure */
+  "~data": EncodedValue<unknown> | EncodedRecord;
+  /** Eventstamp when this document was soft-deleted, or null if not deleted */
+  "~deletedAt": string | null;
+};
+/**
+ * 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"])
+ * }));
+ * ```
+ */
+declare function processDocument(doc: EncodedDocument, process: (value: EncodedValue<unknown>) => EncodedValue<unknown>): EncodedDocument;
+//#endregion
+//#region src/crdt/collection.d.ts
+/**
+ * A collection represents the complete state of a store:
+ * - A set of documents (including soft-deleted ones)
+ * - The highest eventstamp observed across all operations
+ *
+ * Collections are the unit of synchronization between store replicas.
+ */
+type Collection = {
+  /** Array of encoded documents with eventstamps and metadata */
+  "~docs": EncodedDocument[];
+  /** Latest eventstamp observed by this collection for clock synchronization */
+  "~eventstamp": string;
+};
+//#endregion
+//#region src/store.d.ts
+type NotPromise<T> = T extends Promise<any> ? never : T;
+type DeepPartial<T> = T extends object ? { [P in keyof T]?: DeepPartial<T[P]> } : T;
+/**
+ * Options for adding documents to the store.
+ */
+type StoreAddOptions = {
+  /** Provide a custom ID instead of generating one */
+  withId?: string;
+};
+/**
+ * Configuration options for creating a Store instance.
+ */
+type StoreConfig = {
+  /** Custom ID generator. Defaults to crypto.randomUUID() */
+  getId?: () => string;
+};
+/**
+ * Transaction context for batching multiple operations with rollback support.
+ *
+ * Transactions allow you to group multiple mutations together and optionally
+ * abort all changes if validation fails.
+ *
+ * @example
+ * ```ts
+ * store.begin((tx) => {
+ *   const id = tx.add({ name: 'Alice' });
+ *   if (!isValid(tx.get(id))) {
+ *     tx.rollback(); // Abort all changes
+ *   }
+ * });
+ * ```
+ */
+type StoreSetTransaction<T> = {
+  /** Add a document and return its ID */
+  add: (value: T, options?: StoreAddOptions) => string;
+  /** Update a document with a partial value (field-level merge) */
+  update: (key: string, value: DeepPartial<T>) => void;
+  /** Merge an encoded document (used by sync/persistence plugins) */
+  merge: (doc: EncodedDocument) => void;
+  /** Soft-delete a document */
+  del: (key: string) => void;
+  /** Get a document within this transaction */
+  get: (key: string) => T | null;
+  /** Abort the transaction and discard all changes */
+  rollback: () => void;
+};
+/**
+ * Plugin interface for extending store behavior with persistence, analytics, etc.
+ *
+ * All hooks are optional. Mutation hooks receive batched entries after each
+ * transaction commits.
+ *
+ * @example
+ * ```ts
+ * const loggingPlugin: Plugin<Todo> = {
+ *   onInit: async () => console.log('Store initialized'),
+ *   onAdd: (entries) => console.log('Added:', entries.length),
+ *   onDispose: async () => console.log('Store disposed')
+ * };
+ * ```
+ */
+type Plugin<T> = {
+  /** Called once when store.init() runs */
+  onInit: (store: Store<T>) => Promise<void> | void;
+  /** Called once when store.dispose() runs */
+  onDispose: () => Promise<void> | void;
+  /** Called after documents are added (batched per transaction) */
+  onAdd?: (entries: ReadonlyArray<readonly [string, T]>) => void;
+  /** Called after documents are updated (batched per transaction) */
+  onUpdate?: (entries: ReadonlyArray<readonly [string, T]>) => void;
+  /** Called after documents are deleted (batched per transaction) */
+  onDelete?: (keys: ReadonlyArray<string>) => void;
+};
+/**
+ * Configuration for creating a reactive query.
+ *
+ * Queries automatically update when matching documents change.
+ *
+ * @example
+ * ```ts
+ * const config: QueryConfig<Todo> = {
+ *   where: (todo) => !todo.completed,
+ *   select: (todo) => todo.text,
+ *   order: (a, b) => a.localeCompare(b)
+ * };
+ * ```
+ */
+type QueryConfig<T, U = T> = {
+  /** Filter predicate - return true to include document in results */
+  where: (data: T) => boolean;
+  /** Optional projection - transform documents before returning */
+  select?: (data: T) => U;
+  /** Optional comparator for stable ordering of results */
+  order?: (a: U, b: U) => number;
+};
+/**
+ * A reactive query handle that tracks matching documents and notifies on changes.
+ *
+ * Call `dispose()` when done to clean up listeners and remove from the store.
+ */
+type Query<U> = {
+  /** Get current matching documents as [id, document] tuples */
+  results: () => Array<readonly [string, U]>;
+  /** Register a change listener. Returns unsubscribe function. */
+  onChange: (callback: () => void) => () => void;
+  /** Remove this query from the store and clear all listeners */
+  dispose: () => void;
+};
+/**
+ * Lightweight local-first data store with built-in sync and reactive queries.
+ *
+ * Stores plain JavaScript objects with automatic field-level conflict resolution
+ * using Last-Write-Wins semantics powered by hybrid logical clocks.
+ *
+ * @template T - The type of documents stored in this collection
+ *
+ * @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!'));
+ * ```
+ */
+declare class Store<T> {
+  #private;
+  constructor(config?: StoreConfig);
+  /**
+   * Get a document by ID.
+   * @returns The document, or null if not found or deleted
+   */
+  get(key: string): T | null;
+  /**
+   * Iterate over all non-deleted documents as [id, document] tuples.
+   */
+  entries(): IterableIterator<readonly [string, T]>;
+  /**
+   * Get the complete store state as a Collection for persistence or sync.
+   * @returns Collection containing all documents and the latest eventstamp
+   */
+  collection(): Collection;
+  /**
+   * Merge a collection from storage or another replica using field-level LWW.
+   * @param collection - Collection from storage or another store instance
+   */
+  merge(collection: Collection): void;
+  /**
+   * 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<R = void>(callback: (tx: StoreSetTransaction<T>) => NotPromise<R>, opts?: {
+    silent?: boolean;
+  }): NotPromise<R>;
+  /**
+   * Add a document to the store.
+   * @returns The document's ID (generated or provided via options)
+   */
+  add(value: T, options?: StoreAddOptions): string;
+  /**
+   * Update a document with a partial value.
+   *
+   * Uses field-level merge - only specified fields are updated.
+   */
+  update(key: string, value: DeepPartial<T>): void;
+  /**
+   * Soft-delete a document.
+   *
+   * Deleted docs remain in snapshots for sync purposes but are
+   * excluded from queries and reads.
+   */
+  del(key: string): void;
+  /**
+   * Register a plugin for persistence, analytics, etc.
+   * @returns This store instance for chaining
+   */
+  use(plugin: Plugin<T>): 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
+   */
+  init(): Promise<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.
+   */
+  dispose(): Promise<void>;
+  /**
+   * 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<U = T>(config: QueryConfig<T, U>): Query<U>;
+}
+//#endregion
+export { StoreAddOptions as a, Collection as c, EncodedRecord as d, EncodedValue as f, Store as i, EncodedDocument as l, Query as n, StoreConfig as o, QueryConfig as r, StoreSetTransaction as s, Plugin as t, processDocument as u };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@byearlybird/starling",
-	"version": "0.9.0",
+	"version": "0.9.2",
 	"type": "module",
 	"license": "MIT",
 	"main": "./dist/index.js",

package/dist/store-Dc-hIF56.d.ts

@@ -1,114 +0,0 @@
-//#region src/crdt/value.d.ts
-/**
- * A primitive value wrapped with its eventstamp for Last-Write-Wins conflict resolution.
- * Used as the leaf nodes in the CRDT data structure.
- *
- * @template T - The type of the wrapped value (primitive or complex type)
- */
-type EncodedValue<T> = {
-  /** The actual value being stored */
-  "~value": T;
-  /** The eventstamp indicating when this value was last written (ISO|counter|nonce) */
-  "~eventstamp": string;
-};
-//#endregion
-//#region src/crdt/record.d.ts
-/**
- * A nested object structure where each field is either an EncodedValue (leaf)
- * or another EncodedRecord (nested object). This enables field-level
- * Last-Write-Wins merging for complex data structures.
- *
- * Each field maintains its own eventstamp, allowing concurrent updates to
- * different fields to be preserved during merge operations.
- */
-type EncodedRecord = {
-  [key: string]: EncodedValue<unknown> | EncodedRecord;
-};
-//#endregion
-//#region src/crdt/document.d.ts
-/**
- * Top-level document structure with system metadata for tracking identity,
- * data, and deletion state. Documents are the primary unit of storage and
- * synchronization in Starling.
- *
- * The tilde prefix (~) distinguishes system metadata from user-defined data.
- */
-type EncodedDocument = {
-  /** Unique identifier for this document */
-  "~id": string;
-  /** The document's data, either a primitive value or nested object structure */
-  "~data": EncodedValue<unknown> | EncodedRecord;
-  /** Eventstamp when this document was soft-deleted, or null if not deleted */
-  "~deletedAt": string | null;
-};
-declare function processDocument(doc: EncodedDocument, process: (value: EncodedValue<unknown>) => EncodedValue<unknown>): EncodedDocument;
-//#endregion
-//#region src/crdt/collection.d.ts
-/**
- * A collection represents the complete state of a store:
- * - A set of documents (including soft-deleted ones)
- * - The highest eventstamp observed across all operations
- *
- * Collections are the unit of synchronization between store replicas.
- */
-type Collection = {
-  /** Array of encoded documents with eventstamps and metadata */
-  "~docs": EncodedDocument[];
-  /** Latest eventstamp observed by this collection for clock synchronization */
-  "~eventstamp": string;
-};
-//#endregion
-//#region src/store.d.ts
-type NotPromise<T> = T extends Promise<any> ? never : T;
-type DeepPartial<T> = T extends object ? { [P in keyof T]?: DeepPartial<T[P]> } : T;
-type StoreAddOptions = {
-  withId?: string;
-};
-type StoreConfig = {
-  getId?: () => string;
-};
-type StoreSetTransaction<T> = {
-  add: (value: T, options?: StoreAddOptions) => string;
-  update: (key: string, value: DeepPartial<T>) => void;
-  merge: (doc: EncodedDocument) => void;
-  del: (key: string) => void;
-  get: (key: string) => T | null;
-  rollback: () => void;
-};
-type Plugin<T> = {
-  onInit: (store: Store<T>) => Promise<void> | void;
-  onDispose: () => Promise<void> | void;
-  onAdd?: (entries: ReadonlyArray<readonly [string, T]>) => void;
-  onUpdate?: (entries: ReadonlyArray<readonly [string, T]>) => void;
-  onDelete?: (keys: ReadonlyArray<string>) => void;
-};
-type QueryConfig<T, U = T> = {
-  where: (data: T) => boolean;
-  select?: (data: T) => U;
-  order?: (a: U, b: U) => number;
-};
-type Query<U> = {
-  results: () => Array<readonly [string, U]>;
-  onChange: (callback: () => void) => () => void;
-  dispose: () => void;
-};
-declare class Store<T> {
-  #private;
-  constructor(config?: StoreConfig);
-  get(key: string): T | null;
-  entries(): IterableIterator<readonly [string, T]>;
-  collection(): Collection;
-  merge(collection: Collection): void;
-  begin<R = void>(callback: (tx: StoreSetTransaction<T>) => NotPromise<R>, opts?: {
-    silent?: boolean;
-  }): NotPromise<R>;
-  add(value: T, options?: StoreAddOptions): string;
-  update(key: string, value: DeepPartial<T>): void;
-  del(key: string): void;
-  use(plugin: Plugin<T>): this;
-  init(): Promise<this>;
-  dispose(): Promise<void>;
-  query<U = T>(config: QueryConfig<T, U>): Query<U>;
-}
-//#endregion
-export { StoreAddOptions as a, Collection as c, Store as i, EncodedDocument as l, Query as n, StoreConfig as o, QueryConfig as r, StoreSetTransaction as s, Plugin as t, processDocument as u };