silosdk 0.0.8 → 0.0.10

package/dist/settings/storage.native.mjs

@@ -0,0 +1,22 @@
+import { assertSettingValue, resolveDefault, storageKey } from "./shared.mjs";
+import Storage from "expo-sqlite/kv-store";
+
+//#region src/settings/storage.native.ts
+const settingsStorage = {
+	read,
+	write
+};
+function read(name, defaultValue) {
+	const stored = Storage.getItemSync(storageKey(name));
+	if (stored === null) return resolveDefault(defaultValue);
+	const value = JSON.parse(stored);
+	assertSettingValue(value);
+	return value;
+}
+function write(name, value) {
+	assertSettingValue(value);
+	Storage.setItemSync(storageKey(name), JSON.stringify(value));
+}
+
+//#endregion
+export { settingsStorage };

package/dist/settings/storage.web.cjs

@@ -0,0 +1,34 @@
+const require_indexed_db = require('../internal/indexed-db.cjs');
+const require_shared = require('./shared.cjs');
+
+//#region src/settings/storage.web.ts
+const settingsStorage = {
+	read,
+	write
+};
+const openSiloSettingsIndexedDb = require_indexed_db.createIndexedDbOpener("silo-settings", 1, (db) => {
+	if (!db.objectStoreNames.contains("settings")) db.createObjectStore("settings", { keyPath: "key" });
+});
+async function read(name, defaultValue) {
+	const transaction = (await openSiloSettingsIndexedDb()).transaction("settings", "readonly");
+	const done = require_indexed_db.transactionDone(transaction);
+	const row = await require_indexed_db.requestResult(transaction.objectStore("settings").get(require_shared.storageKey(name)));
+	await done;
+	if (!row) return require_shared.resolveDefault(defaultValue);
+	const value = JSON.parse(row.value);
+	require_shared.assertSettingValue(value);
+	return value;
+}
+async function write(name, value) {
+	require_shared.assertSettingValue(value);
+	const transaction = (await openSiloSettingsIndexedDb()).transaction("settings", "readwrite");
+	transaction.objectStore("settings").put({
+		key: require_shared.storageKey(name),
+		value: JSON.stringify(value),
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	await require_indexed_db.transactionDone(transaction);
+}
+
+//#endregion
+exports.settingsStorage = settingsStorage;

package/dist/settings/storage.web.mjs

@@ -0,0 +1,34 @@
+import { createIndexedDbOpener, requestResult, transactionDone } from "../internal/indexed-db.mjs";
+import { assertSettingValue, resolveDefault, storageKey } from "./shared.mjs";
+
+//#region src/settings/storage.web.ts
+const settingsStorage = {
+	read,
+	write
+};
+const openSiloSettingsIndexedDb = createIndexedDbOpener("silo-settings", 1, (db) => {
+	if (!db.objectStoreNames.contains("settings")) db.createObjectStore("settings", { keyPath: "key" });
+});
+async function read(name, defaultValue) {
+	const transaction = (await openSiloSettingsIndexedDb()).transaction("settings", "readonly");
+	const done = transactionDone(transaction);
+	const row = await requestResult(transaction.objectStore("settings").get(storageKey(name)));
+	await done;
+	if (!row) return resolveDefault(defaultValue);
+	const value = JSON.parse(row.value);
+	assertSettingValue(value);
+	return value;
+}
+async function write(name, value) {
+	assertSettingValue(value);
+	const transaction = (await openSiloSettingsIndexedDb()).transaction("settings", "readwrite");
+	transaction.objectStore("settings").put({
+		key: storageKey(name),
+		value: JSON.stringify(value),
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	await transactionDone(transaction);
+}
+
+//#endregion
+export { settingsStorage };

package/dist/settings.cjs

@@ -1,70 +1,8 @@
-const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
-let __tanstack_react_query = require("@tanstack/react-query");
-let expo_sqlite_kv_store = require("expo-sqlite/kv-store");
-expo_sqlite_kv_store = require_rolldown_runtime.__toESM(expo_sqlite_kv_store);
+const require_shared = require('./settings/shared.cjs');
+const require_storage_native = require('./settings/storage.native.cjs');
 
-//#region src/settings/index.ts
-const settingNames = /* @__PURE__ */ new Set();
-const settingNamePattern = /^[A-Za-z][A-Za-z0-9_.:-]*$/;
-function setting(name, defaultValue) {
-	assertSettingName(name);
-	assertSettingValue(resolveDefault(defaultValue));
-	if (settingNames.has(name)) throw new Error(`Setting "${name}" is already registered. Define each setting once and import the existing setting instead.`);
-	settingNames.add(name);
-	const queryKey = [
-		"silo",
-		"setting",
-		name
-	];
-	return {
-		name,
-		defaultValue,
-		queryKey,
-		queryOptions() {
-			return (0, __tanstack_react_query.queryOptions)({
-				queryKey,
-				queryFn: () => readSetting(name, defaultValue)
-			});
-		},
-		mutationOptions(options = {}) {
-			return (0, __tanstack_react_query.mutationOptions)({
-				mutationKey: queryKey,
-				mutationFn: async (valueOrUpdater) => {
-					const current = readSetting(name, defaultValue);
-					const next = typeof valueOrUpdater === "function" ? valueOrUpdater(current) : valueOrUpdater;
-					writeSetting(name, next);
-					return next;
-				},
-				onSuccess(value) {
-					options.queryClient?.setQueryData(queryKey, value);
-				}
-			});
-		}
-	};
-}
-function readSetting(name, defaultValue) {
-	const stored = expo_sqlite_kv_store.default.getItemSync(storageKey(name));
-	if (stored === null) return resolveDefault(defaultValue);
-	const value = JSON.parse(stored);
-	assertSettingValue(value);
-	return value;
-}
-function writeSetting(name, value) {
-	assertSettingValue(value);
-	expo_sqlite_kv_store.default.setItemSync(storageKey(name), JSON.stringify(value));
-}
-function storageKey(name) {
-	return `silo:setting:${name}`;
-}
-function resolveDefault(defaultValue) {
-	return typeof defaultValue === "function" ? defaultValue() : defaultValue;
-}
-function assertSettingName(name) {
-	if (!settingNamePattern.test(name)) throw new Error(`Setting names must start with a letter and contain only letters, numbers, underscores, dots, colons, or hyphens. Received "${name}".`);
-}
-function assertSettingValue(value) {
-	if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean" && value !== null) throw new Error("Settings must be strings, numbers, booleans, or null.");
-}
+//#region src/settings/index.native.ts
+const { setting } = require_shared.createSettingApi(require_storage_native.settingsStorage);
 
 //#endregion
 exports.setting = setting;

package/dist/settings.d.cts

@@ -1,20 +1,6 @@
-import { QueryClient, UseMutationOptions, UseQueryOptions } from "@tanstack/react-query";
+import { Setting, SettingDefault, SettingMutation, SettingMutationOptions, SettingQueryKey, SettingValue } from "./settings/shared.cjs";
 
-//#region src/settings/index.d.ts
-type SettingValue = string | number | boolean | null;
-type SettingDefault<T extends SettingValue> = T | (() => T);
-type SettingMutation<T extends SettingValue> = T | ((current: T) => T);
-type SettingQueryKey = readonly ['silo', 'setting', string];
-type SettingMutationOptions = {
-  queryClient?: QueryClient;
-};
-type Setting<T extends SettingValue> = {
-  readonly name: string;
-  readonly defaultValue: SettingDefault<T>;
-  readonly queryKey: SettingQueryKey;
-  queryOptions(): UseQueryOptions<T, Error, T, SettingQueryKey>;
-  mutationOptions(options?: SettingMutationOptions): UseMutationOptions<T, Error, SettingMutation<T>>;
-};
-declare function setting<T extends SettingValue>(name: string, defaultValue: SettingDefault<T>): Setting<T>;
+//#region src/settings/index.native.d.ts
+declare const setting: <T extends SettingValue>(name: string, defaultValue: SettingDefault<T>) => Setting<T>;
 //#endregion
-export { Setting, SettingDefault, SettingMutation, SettingMutationOptions, SettingQueryKey, SettingValue, setting };
+export { type Setting, type SettingDefault, type SettingMutation, type SettingMutationOptions, type SettingQueryKey, type SettingValue, setting };

package/dist/settings.d.mts

@@ -1,20 +1,6 @@
-import { QueryClient, UseMutationOptions, UseQueryOptions } from "@tanstack/react-query";
+import { Setting, SettingDefault, SettingMutation, SettingMutationOptions, SettingQueryKey, SettingValue } from "./settings/shared.mjs";
 
-//#region src/settings/index.d.ts
-type SettingValue = string | number | boolean | null;
-type SettingDefault<T extends SettingValue> = T | (() => T);
-type SettingMutation<T extends SettingValue> = T | ((current: T) => T);
-type SettingQueryKey = readonly ['silo', 'setting', string];
-type SettingMutationOptions = {
-  queryClient?: QueryClient;
-};
-type Setting<T extends SettingValue> = {
-  readonly name: string;
-  readonly defaultValue: SettingDefault<T>;
-  readonly queryKey: SettingQueryKey;
-  queryOptions(): UseQueryOptions<T, Error, T, SettingQueryKey>;
-  mutationOptions(options?: SettingMutationOptions): UseMutationOptions<T, Error, SettingMutation<T>>;
-};
-declare function setting<T extends SettingValue>(name: string, defaultValue: SettingDefault<T>): Setting<T>;
+//#region src/settings/index.native.d.ts
+declare const setting: <T extends SettingValue>(name: string, defaultValue: SettingDefault<T>) => Setting<T>;
 //#endregion
-export { Setting, SettingDefault, SettingMutation, SettingMutationOptions, SettingQueryKey, SettingValue, setting };
+export { type Setting, type SettingDefault, type SettingMutation, type SettingMutationOptions, type SettingQueryKey, type SettingValue, setting };

package/dist/settings.mjs

@@ -1,68 +1,8 @@
-import { mutationOptions, queryOptions } from "@tanstack/react-query";
-import Storage from "expo-sqlite/kv-store";
+import { createSettingApi } from "./settings/shared.mjs";
+import { settingsStorage } from "./settings/storage.native.mjs";
 
-//#region src/settings/index.ts
-const settingNames = /* @__PURE__ */ new Set();
-const settingNamePattern = /^[A-Za-z][A-Za-z0-9_.:-]*$/;
-function setting(name, defaultValue) {
-	assertSettingName(name);
-	assertSettingValue(resolveDefault(defaultValue));
-	if (settingNames.has(name)) throw new Error(`Setting "${name}" is already registered. Define each setting once and import the existing setting instead.`);
-	settingNames.add(name);
-	const queryKey = [
-		"silo",
-		"setting",
-		name
-	];
-	return {
-		name,
-		defaultValue,
-		queryKey,
-		queryOptions() {
-			return queryOptions({
-				queryKey,
-				queryFn: () => readSetting(name, defaultValue)
-			});
-		},
-		mutationOptions(options = {}) {
-			return mutationOptions({
-				mutationKey: queryKey,
-				mutationFn: async (valueOrUpdater) => {
-					const current = readSetting(name, defaultValue);
-					const next = typeof valueOrUpdater === "function" ? valueOrUpdater(current) : valueOrUpdater;
-					writeSetting(name, next);
-					return next;
-				},
-				onSuccess(value) {
-					options.queryClient?.setQueryData(queryKey, value);
-				}
-			});
-		}
-	};
-}
-function readSetting(name, defaultValue) {
-	const stored = Storage.getItemSync(storageKey(name));
-	if (stored === null) return resolveDefault(defaultValue);
-	const value = JSON.parse(stored);
-	assertSettingValue(value);
-	return value;
-}
-function writeSetting(name, value) {
-	assertSettingValue(value);
-	Storage.setItemSync(storageKey(name), JSON.stringify(value));
-}
-function storageKey(name) {
-	return `silo:setting:${name}`;
-}
-function resolveDefault(defaultValue) {
-	return typeof defaultValue === "function" ? defaultValue() : defaultValue;
-}
-function assertSettingName(name) {
-	if (!settingNamePattern.test(name)) throw new Error(`Setting names must start with a letter and contain only letters, numbers, underscores, dots, colons, or hyphens. Received "${name}".`);
-}
-function assertSettingValue(value) {
-	if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean" && value !== null) throw new Error("Settings must be strings, numbers, booleans, or null.");
-}
+//#region src/settings/index.native.ts
+const { setting } = createSettingApi(settingsStorage);
 
 //#endregion
 export { setting };

package/dist/settings.web.cjs

@@ -0,0 +1,8 @@
+const require_shared = require('./settings/shared.cjs');
+const require_storage_web = require('./settings/storage.web.cjs');
+
+//#region src/settings/index.web.ts
+const { setting } = require_shared.createSettingApi(require_storage_web.settingsStorage);
+
+//#endregion
+exports.setting = setting;

package/dist/settings.web.d.cts

@@ -0,0 +1,6 @@
+import { Setting, SettingDefault, SettingMutation, SettingMutationOptions, SettingQueryKey, SettingValue } from "./settings/shared.cjs";
+
+//#region src/settings/index.web.d.ts
+declare const setting: <T extends SettingValue>(name: string, defaultValue: SettingDefault<T>) => Setting<T>;
+//#endregion
+export { type Setting, type SettingDefault, type SettingMutation, type SettingMutationOptions, type SettingQueryKey, type SettingValue, setting };

package/dist/settings.web.d.mts

@@ -0,0 +1,6 @@
+import { Setting, SettingDefault, SettingMutation, SettingMutationOptions, SettingQueryKey, SettingValue } from "./settings/shared.mjs";
+
+//#region src/settings/index.web.d.ts
+declare const setting: <T extends SettingValue>(name: string, defaultValue: SettingDefault<T>) => Setting<T>;
+//#endregion
+export { type Setting, type SettingDefault, type SettingMutation, type SettingMutationOptions, type SettingQueryKey, type SettingValue, setting };

package/dist/settings.web.mjs

@@ -0,0 +1,8 @@
+import { createSettingApi } from "./settings/shared.mjs";
+import { settingsStorage } from "./settings/storage.web.mjs";
+
+//#region src/settings/index.web.ts
+const { setting } = createSettingApi(settingsStorage);
+
+//#endregion
+export { setting };

package/dist/store/shared.cjs

@@ -0,0 +1,338 @@
+
+//#region src/store/shared.ts
+const sourceNames = /* @__PURE__ */ new Set();
+const sourceNamePattern = /^[A-Za-z][A-Za-z0-9_-]*$/;
+const reservedDocumentFields = new Set([
+	"id",
+	"data",
+	"set"
+]);
+const deletedDocs = /* @__PURE__ */ new WeakSet();
+function createStoreApi(storage) {
+	function createStore(defaults) {
+		const names = Object.keys(defaults);
+		const nameSet = new Set(names);
+		for (const name of names) {
+			assertSourceName(name);
+			assertFlatDefaults(name, defaults[name]);
+		}
+		if (new Set(names).size !== names.length) throw new Error("Store collection names must be unique.");
+		return {
+			names,
+			collectionOptions(name, options = {}) {
+				assertStoreCollectionName(nameSet, name);
+				return createSourceCollectionOptions(storage, name, defaults[name], options);
+			},
+			linkCollectionOptions(options = {}) {
+				return createLinkCollectionOptions(storage, names, nameSet, options);
+			}
+		};
+	}
+	function source(name, defaults) {
+		assertSourceName(name);
+		assertFlatDefaults(name, defaults);
+		if (sourceNames.has(name)) throw new Error(`Source "${name}" is already registered. Define each source once and import the existing source instead.`);
+		sourceNames.add(name);
+		return {
+			name,
+			defaults,
+			schema: createSourceSchema(name, defaults),
+			collectionOptions(options = {}) {
+				return createSourceCollectionOptions(storage, name, defaults, options);
+			}
+		};
+	}
+	return {
+		createStore,
+		source
+	};
+}
+function createSourceCollectionOptions(storage, name, defaults, options = {}) {
+	return {
+		id: name,
+		getKey: (item) => item.id,
+		schema: createSourceSchema(name, defaults),
+		startSync: options.startSync,
+		sync: { sync({ begin, write, commit, markReady, truncate }) {
+			Promise.resolve(storage.loadRows(name)).then((rows) => {
+				begin();
+				truncate();
+				for (const row of rows) write({
+					type: "insert",
+					value: row
+				});
+				commit();
+				markReady();
+			}).catch((error) => {
+				reportSyncError(name, error);
+				begin();
+				truncate();
+				commit();
+				markReady();
+			});
+		} },
+		onInsert: async ({ transaction }) => {
+			await storage.insertRows(name, transaction.mutations.map((mutation) => mutation.modified));
+		},
+		onUpdate: async ({ transaction }) => {
+			await storage.updateRows(name, transaction.mutations);
+		},
+		onDelete: async ({ transaction }) => {
+			await storage.deleteRows(name, transaction.mutations);
+		}
+	};
+}
+function createLinkCollectionOptions(storage, names, nameSet, options = {}) {
+	const schema = createLinkSchema();
+	let syncBegin;
+	let syncWrite;
+	let syncCommit;
+	const writeSyncedLink = (type, row) => {
+		if (!syncBegin || !syncWrite || !syncCommit) return;
+		syncBegin();
+		syncWrite({
+			type,
+			value: row
+		});
+		syncCommit();
+	};
+	return {
+		id: "silo-links",
+		getKey: (item) => item.id,
+		schema,
+		startSync: options.startSync,
+		sync: { sync({ begin, write, commit, markReady, truncate }) {
+			syncBegin = begin;
+			syncWrite = write;
+			syncCommit = commit;
+			Promise.resolve(storage.loadLinkRows()).then((storedRows) => {
+				const rows = storedRows.map((row) => createLinkRow(names, row));
+				begin();
+				truncate();
+				for (const row of rows) write({
+					type: "insert",
+					value: row
+				});
+				commit();
+				markReady();
+			}).catch((error) => {
+				reportSyncError("silo-links", error);
+				begin();
+				truncate();
+				commit();
+				markReady();
+			});
+		} },
+		onInsert: async ({ transaction }) => {
+			for (const mutation of transaction.mutations) await storage.insertLinkRow(extractStoredLinkRow(mutation.modified));
+		},
+		onDelete: async ({ transaction }) => {
+			for (const mutation of transaction.mutations) await storage.deleteLinkRow(String(mutation.key));
+		},
+		utils: {
+			async link(collectionA, idA, collectionB, idB) {
+				const row = createStoredLinkRow(nameSet, collectionA, idA, collectionB, idB);
+				if (!await storage.insertLinkRow(row)) writeSyncedLink("insert", createLinkRow(names, row));
+			},
+			async unlink(collectionA, idA, collectionB, idB) {
+				const row = createStoredLinkRow(nameSet, collectionA, idA, collectionB, idB);
+				if (await storage.deleteLinkRow(row.id)) writeSyncedLink("delete", createLinkRow(names, row));
+			},
+			has(collectionA, idA, collectionB, idB) {
+				const row = createStoredLinkRow(nameSet, collectionA, idA, collectionB, idB);
+				return storage.hasLinkRow(row.id);
+			}
+		}
+	};
+}
+function assertSourceName(name) {
+	if (!sourceNamePattern.test(name)) throw new Error(`Source names must start with a letter and contain only letters, numbers, underscores, or hyphens. Received "${name}".`);
+}
+function assertStoreCollectionName(nameSet, name) {
+	if (!nameSet.has(name)) throw new Error(`Store collection "${name}" is not registered.`);
+}
+function assertLinkCollectionName(nameSet, name) {
+	if (!nameSet.has(name)) throw new Error(`Cannot link unknown collection "${name}".`);
+}
+function createStoredLinkRow(nameSet, collectionA, idA, collectionB, idB) {
+	assertLinkCollectionName(nameSet, collectionA);
+	assertLinkCollectionName(nameSet, collectionB);
+	if (collectionA === collectionB) throw new Error(`Links between the same collection are not supported. Received "${collectionA}".`);
+	const [firstCollection, firstId, secondCollection, secondId] = collectionA < collectionB ? [
+		collectionA,
+		idA,
+		collectionB,
+		idB
+	] : [
+		collectionB,
+		idB,
+		collectionA,
+		idA
+	];
+	const collections = encodePair(firstCollection, secondCollection);
+	const ids = encodePair(firstId, secondId);
+	return {
+		id: encodePair(collections, ids),
+		collections,
+		ids,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+}
+function createLinkRow(names, row) {
+	const [firstCollection, secondCollection] = decodePair(row.collections);
+	const [firstId, secondId] = decodePair(row.ids);
+	const result = {
+		id: row.id,
+		collections: row.collections,
+		ids: row.ids,
+		createdAt: row.createdAt
+	};
+	for (const other of names) {
+		const byCurrent = {};
+		for (const current of names) {
+			let id = null;
+			if (other !== current) {
+				if (current === firstCollection && other === secondCollection) id = firstId;
+				else if (current === secondCollection && other === firstCollection) id = secondId;
+			}
+			byCurrent[current] = { id };
+		}
+		result[other] = byCurrent;
+	}
+	return result;
+}
+function extractStoredLinkRow(row) {
+	if (!isRecord(row)) throw new Error("Expected a link row object.");
+	if (typeof row.id !== "string" || typeof row.collections !== "string" || typeof row.ids !== "string" || typeof row.createdAt !== "string") throw new Error("Link rows must include string id, collections, ids, and createdAt fields.");
+	return {
+		id: row.id,
+		collections: row.collections,
+		ids: row.ids,
+		createdAt: row.createdAt
+	};
+}
+function encodePair(first, second) {
+	return `${encodePart(first)}:${encodePart(second)}`;
+}
+function decodePair(value) {
+	const parts = value.split(":");
+	if (parts.length !== 2) throw new Error(`Invalid encoded link pair "${value}".`);
+	return [decodePart(parts[0]), decodePart(parts[1])];
+}
+function encodePart(value) {
+	return encodeURIComponent(value);
+}
+function decodePart(value) {
+	return decodeURIComponent(value);
+}
+function assertFlatDefaults(sourceName, defaults) {
+	for (const [field, defaultValue] of Object.entries(defaults)) {
+		if (reservedDocumentFields.has(field)) throw new Error(`Source "${sourceName}" field "${field}" is reserved by Silo documents.`);
+		if (!isFieldValue(resolveDefault(defaultValue))) throw new Error(`Source "${sourceName}" field "${field}" must default to a string, number, boolean, null, or a function returning one of those values.`);
+	}
+}
+function createSourceSchema(sourceName, defaults) {
+	return { "~standard": {
+		version: 1,
+		vendor: "silo",
+		validate(value) {
+			if (!isRecord(value)) return failure("Expected a flat source row object.");
+			if (typeof value.id !== "string") return failure("Expected source document field \"id\" to be a string.", ["id"]);
+			const inputData = isRecord(value.data) ? value.data : extractDocumentData(value);
+			const data = {};
+			for (const [field, fieldValue] of Object.entries(inputData)) {
+				if (reservedDocumentFields.has(field)) return failure(`Source "${sourceName}" field "${field}" is reserved by Silo documents.`, ["data", field]);
+				if (!isFieldValue(fieldValue)) return failure(`Source "${sourceName}" field "${field}" must be a string, number, boolean, or null.`, ["data", field]);
+				data[field] = fieldValue;
+			}
+			for (const [field, defaultValue] of Object.entries(defaults)) {
+				if (field in data) continue;
+				data[field] = resolveDefault(defaultValue);
+			}
+			return { value: createDoc(value.id, data) };
+		}
+	} };
+}
+function createLinkSchema() {
+	return { "~standard": {
+		version: 1,
+		vendor: "silo",
+		validate(value) {
+			try {
+				extractStoredLinkRow(value);
+				return { value };
+			} catch (error) {
+				return failure(error instanceof Error ? error.message : "Expected a link row.");
+			}
+		}
+	} };
+}
+function createDoc(id, data) {
+	const doc = {};
+	Object.defineProperty(doc, "id", {
+		value: id,
+		enumerable: true,
+		writable: false,
+		configurable: false
+	});
+	for (const [field, value] of Object.entries(data)) Object.defineProperty(doc, field, {
+		value,
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+	Object.defineProperty(doc, "data", {
+		value() {
+			return deletedDocs.has(this) ? null : extractDocumentData(this);
+		},
+		enumerable: true,
+		writable: false,
+		configurable: false
+	});
+	Object.defineProperty(doc, "set", {
+		get() {
+			return function setDocumentData(patch) {
+				Object.assign(this, patch);
+			};
+		},
+		enumerable: true,
+		configurable: false
+	});
+	return doc;
+}
+function extractDocumentData(value) {
+	if (!isRecord(value)) return {};
+	const data = {};
+	for (const [field, fieldValue] of Object.entries(value)) {
+		if (reservedDocumentFields.has(field) || field.startsWith("$") || typeof fieldValue === "function") continue;
+		if (isFieldValue(fieldValue)) data[field] = fieldValue;
+	}
+	return data;
+}
+function resolveDefault(value) {
+	const resolved = typeof value === "function" ? value() : value;
+	if (!isFieldValue(resolved)) throw new Error("Source defaults must resolve to a string, number, boolean, or null.");
+	return resolved;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFieldValue(value) {
+	return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null;
+}
+function failure(message, path) {
+	return { issues: [{
+		message,
+		path
+	}] };
+}
+function reportSyncError(collectionName, error) {
+	console.error(`Failed to sync Silo collection "${collectionName}".`, error);
+}
+
+//#endregion
+exports.createDoc = createDoc;
+exports.createStoreApi = createStoreApi;
+exports.decodePair = decodePair;
+exports.deletedDocs = deletedDocs;
+exports.extractDocumentData = extractDocumentData;