@byearlybird/starling 0.10.0 → 0.11.0

package/dist/core-DI0FfUjX.js

@@ -0,0 +1,423 @@
+//#region src/core/clock/errors.ts
+var InvalidEventstampError = class extends Error {
+	constructor(eventstamp) {
+		super(`Invalid eventstamp: "${eventstamp}"`);
+		this.name = "InvalidEventstampError";
+	}
+};
+
+//#endregion
+//#region src/core/clock/eventstamp.ts
+function generateNonce() {
+	return Math.random().toString(16).slice(2, 6).padStart(4, "0");
+}
+function encodeEventstamp(timestampMs, counter, nonce) {
+	return `${new Date(timestampMs).toISOString()}|${counter.toString(16).padStart(4, "0")}|${nonce}`;
+}
+const EVENTSTAMP_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z\|[0-9a-f]{4,}\|[0-9a-f]{4}$/;
+/**
+* Validates whether a string is a properly formatted eventstamp.
+* Expected format: YYYY-MM-DDTHH:mm:ss.SSSZ|HHHH+|HHHH
+* where HHHH+ represents 4 or more hex characters for the counter,
+* and HHHH represents exactly 4 hex characters for the nonce.
+*/
+function isValidEventstamp(stamp) {
+	return EVENTSTAMP_REGEX.test(stamp);
+}
+function decodeEventstamp(eventstamp) {
+	if (!isValidEventstamp(eventstamp)) throw new InvalidEventstampError(eventstamp);
+	const parts = eventstamp.split("|");
+	const isoString = parts[0];
+	const hexCounter = parts[1];
+	const nonce = parts[2];
+	return {
+		timestampMs: new Date(isoString).getTime(),
+		counter: parseInt(hexCounter, 16),
+		nonce
+	};
+}
+const MIN_EVENTSTAMP = encodeEventstamp(0, 0, "0000");
+/**
+* Find the maximum eventstamp from an array of eventstamps.
+* Returns MIN_EVENTSTAMP if the array is empty.
+* @param eventstamps - Array of eventstamp strings
+* @returns The maximum eventstamp
+*/
+function maxEventstamp(eventstamps) {
+	if (eventstamps.length === 0) return MIN_EVENTSTAMP;
+	return eventstamps.reduce((max, stamp) => stamp > max ? stamp : max);
+}
+
+//#endregion
+//#region src/core/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 {
+		now,
+		latest,
+		forward
+	};
+}
+/**
+* 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/core/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;
+}
+/**
+* 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];
+			const fieldPath = path ? `${path}.${key}` : key;
+			if (isObject(value)) traverse(value, fieldPath);
+			else eventstamps[fieldPath] = eventstamp;
+		}
+	};
+	traverse(obj);
+	return {
+		type,
+		id,
+		attributes: obj,
+		meta: {
+			eventstamps,
+			latest: computeResourceLatest(eventstamps, deletedAt, eventstamp),
+			deletedAt
+		}
+	};
+}
+function mergeResources(into, from) {
+	const resultAttributes = {};
+	const resultEventstamps = {};
+	const allPaths = new Set([...Object.keys(into.meta.eventstamps), ...Object.keys(from.meta.eventstamps)]);
+	for (const path of allPaths) {
+		const stamp1 = into.meta.eventstamps[path];
+		const stamp2 = from.meta.eventstamps[path];
+		if (stamp1 && stamp2) if (stamp1 > stamp2) {
+			setValueAtPath(resultAttributes, path, getValueAtPath(into.attributes, path));
+			resultEventstamps[path] = stamp1;
+		} else {
+			setValueAtPath(resultAttributes, path, getValueAtPath(from.attributes, path));
+			resultEventstamps[path] = stamp2;
+		}
+		else if (stamp1) {
+			setValueAtPath(resultAttributes, path, getValueAtPath(into.attributes, path));
+			resultEventstamps[path] = stamp1;
+		} else {
+			setValueAtPath(resultAttributes, path, getValueAtPath(from.attributes, path));
+			resultEventstamps[path] = stamp2;
+		}
+	}
+	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 {
+		type: into.type,
+		id: into.id,
+		attributes: resultAttributes,
+		meta: {
+			eventstamps: resultEventstamps,
+			latest: finalLatest,
+			deletedAt: mergedDeletedAt
+		}
+	};
+}
+function deleteResource(resource, eventstamp) {
+	const dataLatest = resource.meta.deletedAt ? computeResourceLatest(resource.meta.eventstamps, null) : resource.meta.latest;
+	const latest = eventstamp > dataLatest ? eventstamp : dataLatest;
+	return {
+		type: resource.type,
+		id: resource.id,
+		attributes: resource.attributes,
+		meta: {
+			eventstamps: resource.meta.eventstamps,
+			latest,
+			deletedAt: eventstamp
+		}
+	};
+}
+
+//#endregion
+//#region src/core/document/document.ts
+/**
+* Merges two JSON:API documents using field-level Last-Write-Wins semantics.
+*
+* The merge operation:
+* 1. Forwards the clock to the newest eventstamp from either document
+* 2. Merges each resource pair using field-level LWW (via mergeResources)
+* 3. Tracks what changed for hook notifications (added/updated/deleted)
+*
+* 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 document to merge into
+* @param from - The source document to merge from
+* @returns Merged document and categorized changes
+*
+* @example
+* ```typescript
+* const into = {
+*   jsonapi: { version: "1.1" },
+*   meta: { latest: "2025-01-01T00:00:00.000Z|0001|a1b2" },
+*   data: [{ type: "items", id: "doc1", attributes: {...}, meta: { deletedAt: null, latest: "..." } }]
+* };
+*
+* const from = {
+*   jsonapi: { version: "1.1" },
+*   meta: { latest: "2025-01-01T00:05:00.000Z|0001|c3d4" },
+*   data: [
+*     { type: "items", id: "doc1", attributes: {...}, meta: { deletedAt: null, latest: "..." } }, // updated
+*     { type: "items", id: "doc2", attributes: {...}, meta: { deletedAt: null, latest: "..." } }  // new
+*   ]
+* };
+*
+* const result = mergeDocuments(into, from);
+* // result.document.meta.latest === "2025-01-01T00:05:00.000Z|0001|c3d4"
+* // result.changes.added has "doc2"
+* // result.changes.updated has "doc1"
+* ```
+*/
+function mergeDocuments(into, from) {
+	const intoDocsById = /* @__PURE__ */ new Map();
+	for (const doc of into.data) intoDocsById.set(doc.id, doc);
+	const added = /* @__PURE__ */ new Map();
+	const updated = /* @__PURE__ */ new Map();
+	const deleted = /* @__PURE__ */ new Set();
+	const mergedDocsById = new Map(intoDocsById);
+	let newestEventstamp = into.meta.latest >= from.meta.latest ? into.meta.latest : from.meta.latest;
+	for (const fromDoc of from.data) {
+		const id = fromDoc.id;
+		const intoDoc = intoDocsById.get(id);
+		if (!intoDoc) {
+			mergedDocsById.set(id, fromDoc);
+			if (!fromDoc.meta.deletedAt) added.set(id, fromDoc);
+			if (fromDoc.meta.latest > newestEventstamp) newestEventstamp = fromDoc.meta.latest;
+		} else {
+			if (intoDoc === fromDoc) continue;
+			const mergedDoc = mergeResources(intoDoc, fromDoc);
+			mergedDocsById.set(id, mergedDoc);
+			if (mergedDoc.meta.latest > newestEventstamp) newestEventstamp = mergedDoc.meta.latest;
+			const wasDeleted = intoDoc.meta.deletedAt !== null;
+			const isDeleted = mergedDoc.meta.deletedAt !== null;
+			if (!wasDeleted && isDeleted) deleted.add(id);
+			else if (!isDeleted) {
+				if (intoDoc.meta.latest !== mergedDoc.meta.latest) updated.set(id, mergedDoc);
+			}
+		}
+	}
+	return {
+		document: {
+			jsonapi: { version: "1.1" },
+			meta: { latest: newestEventstamp },
+			data: Array.from(mergedDocsById.values())
+		},
+		changes: {
+			added,
+			updated,
+			deleted
+		}
+	};
+}
+/**
+* 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/core/document/utils.ts
+/**
+* Convert a JsonDocument's data array into a Map keyed by resource ID.
+* @param document - JsonDocument containing resource data
+* @returns Map of resource ID to ResourceObject
+*/
+function documentToMap(document) {
+	return new Map(document.data.map((doc) => [doc.id, doc]));
+}
+/**
+* Convert a Map of resources into a JsonDocument.
+* @param resources - Map of resource ID to ResourceObject
+* @param fallbackEventstamp - Eventstamp to include when computing the max (optional)
+* @returns JsonDocument representation of the resources
+*/
+function mapToDocument(resources, fallbackEventstamp) {
+	const resourceArray = Array.from(resources.values());
+	const eventstamps = resourceArray.map((r) => r.meta.latest);
+	if (fallbackEventstamp) eventstamps.push(fallbackEventstamp);
+	return {
+		jsonapi: { version: "1.1" },
+		meta: { latest: maxEventstamp(eventstamps) },
+		data: resourceArray
+	};
+}
+
+//#endregion
+//#region src/core/resource-map/resource-map.ts
+/**
+* A ResourceMap container for storing and managing ResourceObjects.
+*
+* This factory function creates a ResourceMap with state-based replication
+* and automatic convergence via Last-Write-Wins conflict resolution.
+* It stores complete resource snapshots with encoded metadata, including deletion markers.
+*
+* ResourceMap does NOT filter based on deletion status—it stores and returns
+* all ResourceObjects including deleted ones. The Store class is responsible
+* for filtering what's visible to users.
+*
+* @example
+* ```typescript
+* const resourceMap = createMap("todos");
+* resourceMap.set("id1", { name: "Alice" });
+* const resource = resourceMap.get("id1"); // ResourceObject with metadata
+* ```
+*/
+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;
+		}
+	};
+}
+/**
+* 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 { makeDocument as a, makeResource as c, createClockFromEventstamp as d, MIN_EVENTSTAMP as f, InvalidEventstampError as h, mapToDocument as i, mergeResources as l, maxEventstamp as m, createMapFromDocument as n, mergeDocuments as o, isValidEventstamp as p, documentToMap as r, deleteResource as s, createMap as t, createClock as u };

package/dist/core.d.ts

@@ -0,0 +1,2 @@
+import { _ as maxEventstamp, a as AnyObject, b as createClock, c as MergeDocumentsResult, d as ResourceObject, f as deleteResource, g as isValidEventstamp, h as MIN_EVENTSTAMP, i as mapToDocument, l as makeDocument, m as mergeResources, n as createMapFromDocument, o as DocumentChanges, p as makeResource, r as documentToMap, s as JsonDocument, t as createMap, u as mergeDocuments, v as InvalidEventstampError, x as createClockFromEventstamp, y as Clock } from "./index-D7bXWDg6.js";
+export { AnyObject, Clock, DocumentChanges, InvalidEventstampError, JsonDocument, MIN_EVENTSTAMP, MergeDocumentsResult, ResourceObject, createClock, createClockFromEventstamp, createMap, createMapFromDocument, deleteResource, documentToMap, isValidEventstamp, makeDocument, makeResource, mapToDocument, maxEventstamp, mergeDocuments, mergeResources };

package/dist/core.js

@@ -0,0 +1,3 @@
+import { a as makeDocument, c as makeResource, d as createClockFromEventstamp, f as MIN_EVENTSTAMP, h as InvalidEventstampError, i as mapToDocument, l as mergeResources, m as maxEventstamp, n as createMapFromDocument, o as mergeDocuments, p as isValidEventstamp, r as documentToMap, s as deleteResource, t as createMap, u as createClock } from "./core-DI0FfUjX.js";
+
+export { InvalidEventstampError, MIN_EVENTSTAMP, createClock, createClockFromEventstamp, createMap, createMapFromDocument, deleteResource, documentToMap, isValidEventstamp, makeDocument, makeResource, mapToDocument, maxEventstamp, mergeDocuments, mergeResources };

package/dist/db-qQgPYE41.d.ts

@@ -0,0 +1,199 @@
+import { a as AnyObject, s as JsonDocument } from "./index-D7bXWDg6.js";
+
+//#region src/database/standard-schema.d.ts
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The result interface of the validate function. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** The non-existent issues. */
+    readonly issues?: undefined;
+  }
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard Schema types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Schema. */
+  type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /** Infers the output type of a Standard Schema. */
+  type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+//#endregion
+//#region src/database/types.d.ts
+type AnyObjectSchema<T extends AnyObject = AnyObject> = StandardSchemaV1<T>;
+type SchemasMap = Record<string, AnyObjectSchema>;
+//#endregion
+//#region src/database/collection.d.ts
+/**
+ * Symbols for internal collection methods used by transactions.
+ * These are not part of the public Collection type.
+ */
+declare const CollectionInternals: {
+  readonly getPendingMutations: symbol;
+  readonly emitMutations: symbol;
+  readonly replaceData: symbol;
+  readonly data: symbol;
+};
+/** Shorthand for extracting the data type from a schema */
+type InferData<T extends AnyObjectSchema> = StandardSchemaV1.InferOutput<T>;
+type MutationBatch<T> = {
+  added: Array<{
+    id: string;
+    item: T;
+  }>;
+  updated: Array<{
+    id: string;
+    before: T;
+    after: T;
+  }>;
+  removed: Array<{
+    id: string;
+    item: T;
+  }>;
+};
+type CollectionMutationEvent<T> = MutationBatch<T>;
+type Collection<T extends AnyObjectSchema> = {
+  get(id: string, opts?: {
+    includeDeleted?: boolean;
+  }): InferData<T> | null;
+  getAll(opts?: {
+    includeDeleted?: boolean;
+  }): InferData<T>[];
+  find<U = InferData<T>>(filter: (item: InferData<T>) => boolean, opts?: {
+    map?: (item: InferData<T>) => U;
+    sort?: (a: U, b: U) => number;
+  }): U[];
+  add(item: StandardSchemaV1.InferInput<T>): InferData<T>;
+  update(id: string, updates: Partial<StandardSchemaV1.InferInput<T>>): void;
+  remove(id: string): void;
+  merge(document: JsonDocument<InferData<T>>): void;
+  toDocument(): JsonDocument<InferData<T>>;
+  on(event: "mutation", handler: (payload: CollectionMutationEvent<InferData<T>>) => void): () => void;
+};
+declare class IdNotFoundError extends Error {
+  constructor(id: string);
+}
+declare class DuplicateIdError extends Error {
+  constructor(id: string);
+}
+//#endregion
+//#region src/database/query.d.ts
+/** Read-only collection handle for queries */
+type QueryCollectionHandle<T extends AnyObjectSchema> = Pick<Collection<T>, "get" | "getAll" | "find">;
+/** Query context with read-only collection handles */
+type QueryContext<Schemas extends SchemasMap> = { [K in keyof Schemas]: QueryCollectionHandle<Schemas[K]> };
+/** Handle returned by db.query() for managing the reactive query */
+type QueryHandle<R> = {
+  /** Current query result */
+  readonly result: R;
+  /** Subscribe to result changes. Returns unsubscribe function. */
+  subscribe(callback: (result: R) => void): () => void;
+  /** Stop tracking and clean up subscriptions */
+  dispose(): void;
+};
+//#endregion
+//#region src/database/transaction.d.ts
+/** Transaction-safe collection handle that excludes event subscription and serialization */
+type TransactionCollectionHandle<T extends AnyObjectSchema> = Omit<Collection<T>, "on" | "toDocument">;
+type TransactionCollectionHandles<Schemas extends SchemasMap> = { [K in keyof Schemas]: TransactionCollectionHandle<Schemas[K]> };
+type TransactionContext<Schemas extends SchemasMap> = TransactionCollectionHandles<Schemas> & {
+  rollback(): void;
+};
+//#endregion
+//#region src/database/db.d.ts
+type Collections<Schemas extends SchemasMap> = { [K in keyof Schemas]: Collection<Schemas[K]> };
+type CollectionConfigMap<Schemas extends SchemasMap> = { [K in keyof Schemas]: CollectionConfig<Schemas[K]> };
+type MutationEnvelope<Schemas extends SchemasMap> = { [K in keyof Schemas]: {
+  collection: K;
+} & MutationBatch<StandardSchemaV1.InferOutput<Schemas[K]>> }[keyof Schemas];
+type DatabaseMutationEvent<Schemas extends SchemasMap> = MutationEnvelope<Schemas>;
+type CollectionConfig<T extends AnyObjectSchema> = {
+  schema: T;
+  getId: (item: StandardSchemaV1.InferOutput<T>) => string;
+};
+type DatabasePlugin<Schemas extends SchemasMap> = {
+  handlers: {
+    init?: (db: Database<Schemas>) => Promise<unknown> | unknown;
+    dispose?: (db: Database<Schemas>) => Promise<unknown> | unknown;
+  };
+};
+type DbConfig<Schemas extends SchemasMap> = {
+  name: string;
+  schema: CollectionConfigMap<Schemas>;
+  version?: number;
+};
+type Database<Schemas extends SchemasMap> = Collections<Schemas> & {
+  name: string;
+  version: number;
+  begin<R>(callback: (tx: TransactionContext<Schemas>) => R): R;
+  query<R>(callback: (ctx: QueryContext<Schemas>) => R): QueryHandle<R>;
+  toDocuments(): { [K in keyof Schemas]: JsonDocument<StandardSchemaV1.InferOutput<Schemas[K]>> };
+  on(event: "mutation", handler: (payload: DatabaseMutationEvent<Schemas>) => unknown): () => void;
+  use(plugin: DatabasePlugin<Schemas>): Database<Schemas>;
+  init(): Promise<Database<Schemas>>;
+  dispose(): Promise<void>;
+  collectionKeys(): (keyof Schemas)[];
+};
+/**
+ * Create a typed database instance with collection access.
+ * @param config - Database configuration
+ * @param config.name - Database name used for persistence and routing
+ * @param config.schema - Collection schema definitions
+ * @param config.version - Optional database version, defaults to 1
+ * @returns A database instance with typed collection properties
+ *
+ * @example
+ * ```typescript
+ * const db = await createDatabase({
+ *   name: "my-app",
+ *   schema: {
+ *     tasks: { schema: taskSchema, getId: (task) => task.id },
+ *   },
+ * })
+ *   .use(idbPlugin())
+ *   .init();
+ *
+ * const task = db.tasks.add({ title: 'Learn Starling' });
+ * ```
+ */
+declare function createDatabase<Schemas extends SchemasMap>(config: DbConfig<Schemas>): Database<Schemas>;
+//#endregion
+export { createDatabase as a, QueryCollectionHandle as c, Collection as d, CollectionInternals as f, StandardSchemaV1 as g, SchemasMap as h, DbConfig as i, QueryContext as l, IdNotFoundError as m, Database as n, TransactionCollectionHandle as o, DuplicateIdError as p, DatabasePlugin as r, TransactionContext as s, CollectionConfig as t, QueryHandle as u };