@lsync/server 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1346 @@
+import { n as webSocketAttachmentSchema, t as router } from "./router-C4eYfMV7.mjs";
+import { and, compileReadExpression, compileReadExpression as compileReadExpression$1, eq, field, gt, gte, inArray, lt, lte, matchesReadPredicate, matchesReadPredicate as matchesReadPredicate$1, ne, not, or, parseClientRpcRequest, readExpressionReferences, readExpressionReferences as readExpressionReferences$1, readExpressionRow, readExpressionRow as readExpressionRow$1, readRpcId, sendServerMessage, val } from "@lsync/transport";
+import sqlTag, { join, raw } from "sql-template-tag";
+import { z } from "zod";
+//#region src/access-expression.ts
+function accessRows(referenceNames) {
+	return {
+		references: readExpressionReferences$1(referenceNames),
+		row: readExpressionRow$1()
+	};
+}
+function reduceAccessExpression(expression, references) {
+	const dependencies = [];
+	const reduced = reduce(expression, references, dependencies);
+	if (isVal(reduced)) return {
+		allow: reduced.value === true,
+		dependencies
+	};
+	return {
+		allow: true,
+		dependencies,
+		predicate: compileReadExpression$1(reduced)
+	};
+}
+function reduce(expression, references, dependencies) {
+	const unwrapped = unwrap(expression);
+	if (isVal(unwrapped)) return unwrapped;
+	if (isRef(unwrapped)) return reduceRef(unwrapped, references, dependencies);
+	if (unwrapped.name === "and") return reduceAnd(unwrapped, references, dependencies);
+	if (unwrapped.name === "or") return reduceOr(unwrapped, references, dependencies);
+	if (unwrapped.name === "not") {
+		const child = reduceExpressionArg(unwrapped.args[0], references, dependencies);
+		return isVal(child) ? val$1(child.value !== true) : func("not", child);
+	}
+	const args = unwrapped.args.map((arg) => reduceExpressionArg(arg, references, dependencies));
+	if (args.every(isVal)) return val$1(evaluate(unwrapped.name, args.map((arg) => arg.value)));
+	return func(unwrapped.name, ...args);
+}
+function reduceRef(expression, references, dependencies) {
+	if (expression.source !== "reference") return expression;
+	const name = expression.name;
+	const reference = name ? references.get(name) : void 0;
+	if (!name || !reference) return val$1(void 0);
+	const field = expression.path.join(".");
+	dependencies.push({
+		collection: reference.collection,
+		field,
+		key: reference.key,
+		name
+	});
+	return val$1(valueAtPath$1(reference.value, expression.path));
+}
+function reduceAnd(expression, references, dependencies) {
+	const reduced = expression.args.map((arg) => reduceExpressionArg(arg, references, dependencies));
+	if (reduced.some((arg) => isVal(arg) && arg.value !== true)) return val$1(false);
+	const remaining = reduced.filter((arg) => !isVal(arg));
+	if (remaining.length === 0) return val$1(true);
+	return remaining.length === 1 ? remaining[0] : func("and", ...remaining);
+}
+function reduceOr(expression, references, dependencies) {
+	const reduced = expression.args.map((arg) => reduceExpressionArg(arg, references, dependencies));
+	if (reduced.some((arg) => isVal(arg) && arg.value === true)) return val$1(true);
+	const remaining = reduced.filter((arg) => !isVal(arg));
+	if (remaining.length === 0) return val$1(false);
+	return remaining.length === 1 ? remaining[0] : func("or", ...remaining);
+}
+function reduceExpressionArg(value, references, dependencies) {
+	return isExpression(value) ? reduce(value, references, dependencies) : val$1(value);
+}
+function evaluate(name, args) {
+	const [left, right] = args;
+	switch (name) {
+		case "eq": return left === right;
+		case "not_eq": return left !== right;
+		case "gt": return compare(left, right, (a, b) => a > b);
+		case "gte": return compare(left, right, (a, b) => a >= b);
+		case "lt": return compare(left, right, (a, b) => a < b);
+		case "lte": return compare(left, right, (a, b) => a <= b);
+		case "in": return Array.isArray(right) && right.includes(left);
+		default: throw new Error(`Unsupported read access operator: ${name}`);
+	}
+}
+function compare(left, right, compareValues) {
+	if (typeof left === "number" && typeof right === "number") return compareValues(left, right);
+	if (typeof left === "string" && typeof right === "string") return compareValues(left, right);
+	return false;
+}
+function func(name, ...args) {
+	return {
+		type: "func",
+		name,
+		args
+	};
+}
+function val$1(value) {
+	return {
+		type: "val",
+		value
+	};
+}
+function valueAtPath$1(value, path) {
+	return path.reduce((current, segment) => {
+		if (typeof current !== "object" || current === null) return void 0;
+		return current[String(segment)];
+	}, value);
+}
+function unwrap(expression) {
+	return "expression" in expression ? unwrap(expression.expression) : expression;
+}
+function isExpression(value) {
+	return typeof value === "object" && value !== null && ("type" in value || "expression" in value);
+}
+function isVal(value) {
+	return unwrap(value).type === "val";
+}
+function isRef(value) {
+	return unwrap(value).type === "ref";
+}
+//#endregion
+//#region src/collections.ts
+function resolveCollection(collectionName, collections = {}) {
+	const exact = collections[collectionName];
+	if (exact) return {
+		name: collectionName,
+		collection: exact,
+		params: {},
+		scope: collectionScope(collectionName)
+	};
+	const best = Object.entries(collections).flatMap(([name, collection], index) => {
+		const match = matchCollectionPattern(name, collectionName);
+		return match ? [{
+			name,
+			collection,
+			params: match.params,
+			staticSegments: match.staticSegments,
+			segments: match.segments,
+			index
+		}] : [];
+	}).sort(comparePatternMatches)[0];
+	if (!best) return;
+	return {
+		name: best.name,
+		collection: best.collection,
+		params: best.params,
+		scope: collectionScope(collectionName)
+	};
+}
+function collectionScope(collectionName) {
+	return `/${splitCollectionPath(collectionName).map(normalizeSegment).join("/")}/`;
+}
+function isCollectionPattern(collectionName) {
+	return collectionName.split("/").some((segment) => /^\{[A-Za-z_][A-Za-z0-9_]*\}$/.test(segment));
+}
+function collectionApiHandlers(collections = {}) {
+	const handlers = {};
+	for (const [collectionPath, collection] of Object.entries(collections)) for (const [name, definition] of Object.entries(collection.api ?? {})) {
+		const path = defaultCollectionApiPath(collectionPath, name);
+		if (handlers[path]) throw new Error(`Duplicate API path: ${path}`);
+		handlers[path] = (args) => definition.handler({
+			...args,
+			input: definition.input.parse(args.input)
+		});
+	}
+	return handlers;
+}
+function defaultCollectionApiPath(collectionPath, name) {
+	const prefix = splitCollectionPath(collectionPath).filter((segment) => !collectionPathParamName(segment)).join(".");
+	return prefix ? `${prefix}.${name}` : name;
+}
+function matchCollectionPattern(pattern, collectionName) {
+	if (!isCollectionPattern(pattern)) return;
+	const patternSegments = splitCollectionPath(pattern);
+	const collectionSegments = splitCollectionPath(collectionName);
+	if (patternSegments.length !== collectionSegments.length) return;
+	const params = {};
+	let staticSegments = 0;
+	for (const [index, segment] of patternSegments.entries()) {
+		const param = segment.match(/^\{([A-Za-z_][A-Za-z0-9_]*)\}$/);
+		if (param?.[1]) {
+			params[param[1]] = decodeURIComponent(collectionSegments[index] ?? "");
+			continue;
+		}
+		if (segment !== collectionSegments[index]) return;
+		staticSegments += 1;
+	}
+	return {
+		params,
+		staticSegments,
+		segments: patternSegments.length
+	};
+}
+function comparePatternMatches(left, right) {
+	return right.staticSegments - left.staticSegments || right.segments - left.segments || left.index - right.index;
+}
+function splitCollectionPath(path) {
+	const trimmed = path.trim().replace(/^\/+|\/+$/g, "");
+	if (!trimmed) return [];
+	return trimmed.split("/");
+}
+function collectionPathParamName(segment) {
+	return segment.match(/^\{([A-Za-z_][A-Za-z0-9_]*)\}$/)?.[1] ?? segment.match(/^:([A-Za-z_][A-Za-z0-9_]*)$/)?.[1];
+}
+function normalizeSegment(segment) {
+	return encodeURIComponent(decodeURIComponent(segment));
+}
+//#endregion
+//#region src/access.ts
+function authorizeReadQuery(query, collections, auth, store) {
+	const decision = readAccessDecision(query.collection, collections, auth, store);
+	if (!decision.allow) return void 0;
+	if (!decision.predicate) return query;
+	const predicate = combinePredicates$1(decision.predicate, query.predicate);
+	return predicate ? {
+		...query,
+		predicate
+	} : query;
+}
+function visibleUpdateForAuth(update, collections, auth, store) {
+	const decision = readAccessDecision(update.collection, collections, auth, store);
+	if (!decision.allow) return void 0;
+	if (!decision.predicate) return update;
+	const before = update.previousValue ? matchesReadPredicate$1(update.previousValue, decision.predicate) : false;
+	const after = update.value ? matchesReadPredicate$1(update.value, decision.predicate) : false;
+	if (!before && !after) return void 0;
+	if (before && !after) {
+		const { previousValue, value, ...base } = update;
+		return {
+			...base,
+			type: "delete"
+		};
+	}
+	return !before && after && update.type === "update" ? {
+		...update,
+		type: "insert"
+	} : update;
+}
+function authorizeWriteBatch(batch, collections, auth, store) {
+	for (const update of batch.updates) {
+		if (writeAccessDecision(update, collections, auth, store).allow) continue;
+		throw new Error(`Access denied for ${update.type} on ${update.collection}`);
+	}
+}
+function authorizeApiCall(handler, name, input, auth) {
+	if (!handler) return;
+	const row = asRecord(input) ?? {};
+	const decision = reduceAccessExpression(handler({
+		auth,
+		input: readExpressionRow$1()
+	}), /* @__PURE__ */ new Map());
+	if (!(decision.allow && (!decision.predicate || matchesReadPredicate$1(row, decision.predicate)))) throw new Error(`Access denied for API: ${name}`);
+}
+function readAccessDecision(collection, collections, auth, store) {
+	const resolved = resolveCollection(collection, collections);
+	if (!resolved) return {
+		allow: true,
+		dependencies: []
+	};
+	const access = resolved?.collection.access;
+	if (!access?.read) return {
+		allow: true,
+		dependencies: []
+	};
+	const references = accessReferences(collection, collections, auth);
+	const rows = accessRows([...references.keys()]);
+	return reduceAccessExpression(access.read({
+		auth,
+		collection: resolved.scope,
+		references: rows.references,
+		params: resolved.params,
+		pattern: resolved.name,
+		row: rows.row
+	}), new Map([...references].map(([name, reference]) => [name, {
+		...reference,
+		value: store.read(reference.collection, reference.key)
+	}])));
+}
+function writeAccessDecision(update, collections, auth, store) {
+	const resolved = resolveCollection(update.collection, collections);
+	if (!resolved) return {
+		allow: true,
+		dependencies: []
+	};
+	const access = resolved.collection.access;
+	const handler = writeAccessHandler(access, update.type);
+	if (!handler) return {
+		allow: true,
+		dependencies: []
+	};
+	const row = writeAccessRow(update, store);
+	if (!row) return {
+		allow: false,
+		dependencies: []
+	};
+	const references = accessReferences(update.collection, collections, auth);
+	const rows = accessRows([...references.keys()]);
+	const decision = reduceAccessExpression(handler({
+		auth,
+		collection: resolved.scope,
+		references: rows.references,
+		params: resolved.params,
+		pattern: resolved.name,
+		row: rows.row
+	}), new Map([...references].map(([name, reference]) => [name, {
+		...reference,
+		value: store.read(reference.collection, reference.key)
+	}])));
+	if (!decision.allow || !decision.predicate) return decision;
+	return matchesReadPredicate$1(row, decision.predicate) ? decision : {
+		...decision,
+		allow: false
+	};
+}
+function accessReferences(collection, collections, auth) {
+	const resolved = resolveCollection(collection, collections);
+	const references = resolved?.collection.access?.references;
+	if (!resolved || !references) return /* @__PURE__ */ new Map();
+	return new Map(Object.entries(references).map(([name, resolver]) => [name, normalizeAccessReference(resolver({
+		auth,
+		collection: resolved.scope,
+		params: resolved.params,
+		pattern: resolved.name
+	}))]));
+}
+function normalizeAccessReference(reference) {
+	if (typeof reference !== "string") return reference;
+	const normalized = reference.trim().replace(/^\/+|\/+$/g, "");
+	const segments = normalized ? normalized.split("/") : [];
+	const key = segments.at(-1);
+	if (!key || segments.length < 2) throw new Error(`Invalid access reference path: ${reference}`);
+	return {
+		collection: `/${segments.slice(0, -1).map(encodeURIComponent).join("/")}/`,
+		key: decodeURIComponent(key)
+	};
+}
+function combinePredicates$1(left, right) {
+	if (!left) return right;
+	if (!right) return left;
+	return {
+		type: "and",
+		predicates: [left, right]
+	};
+}
+function writeAccessHandler(access, type) {
+	if (!access) return void 0;
+	return access[type] ?? access.write ?? access.read;
+}
+function writeAccessRow(update, store) {
+	if (update.type === "insert") return asRecord(update.value);
+	const existing = asRecord(update.previousValue) ?? store.read(update.collection, update.key);
+	if (update.type === "delete") return existing;
+	const next = asRecord(update.value);
+	return existing && next ? {
+		...existing,
+		...next
+	} : next ?? existing;
+}
+function asRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+//#endregion
+//#region src/collection-normalize.ts
+function normalizeCollection(collection, collections) {
+	const configured = resolveCollection(collection, collections);
+	if (configured) return configured.scope;
+	if (collections && Object.keys(collections).length > 0) throw new Error(`Unknown collection: ${collection}`);
+	return collectionScope(collection);
+}
+//#endregion
+//#region src/sqlite-sql.ts
+function execSql(storage, statement) {
+	return storage.exec(statement.sql, ...statement.values);
+}
+function identifierSql(identifier) {
+	return raw(`"${identifier.replaceAll(`"`, `""`)}"`);
+}
+function rawSql(value) {
+	return raw(value);
+}
+//#endregion
+//#region src/sqlite-json-read.ts
+function readSQLiteJsonRows(sql, query, collections = {}) {
+	ensureSQLiteJsonTables(sql, collections);
+	const resolved = resolveCollection(query.collection, collections);
+	if (!resolved) {
+		if (Object.keys(collections).length > 0) throw new Error(`Unknown collection: ${query.collection}`);
+		throw new Error(`Cannot read unconfigured collection: ${query.collection}`);
+	}
+	const storage = sqliteJsonStorage(resolved.collection.storage);
+	if (!storage) throw new Error(`Collection is not readable with SQLite JSON storage: ${query.collection}`);
+	const table = tableName$1(resolved.name, storage);
+	const filters = query.filters ?? [];
+	const predicate = query.predicate;
+	const orderBy = query.orderBy ?? [];
+	const limit = query.limit ?? 1e3;
+	const scope = { scope: resolved.scope };
+	if (query.cursor) {
+		const currentPredicate = combinePredicates(predicate, query.cursor.whereCurrent);
+		const fromPredicate = combinePredicates(predicate, query.cursor.whereFrom);
+		const currentRows = selectRows(sql, table, {
+			filters,
+			orderBy,
+			...scope,
+			...currentPredicate ? { predicate: currentPredicate } : {}
+		});
+		const fromRows = selectRows(sql, table, {
+			filters,
+			limit,
+			orderBy,
+			...scope,
+			...fromPredicate ? { predicate: fromPredicate } : {}
+		});
+		return { rows: uniqueRows([...currentRows, ...fromRows]).map((row) => JSON.parse(row.value)) };
+	}
+	return { rows: selectRows(sql, table, {
+		filters,
+		limit,
+		offset: query.offset ?? 0,
+		orderBy,
+		...scope,
+		...predicate ? { predicate } : {}
+	}).map((row) => JSON.parse(row.value)) };
+}
+function readSQLiteJsonRow(sql, collection, key, collections = {}) {
+	ensureSQLiteJsonTables(sql, collections);
+	const resolved = resolveCollection(collection, collections);
+	if (!resolved) {
+		if (Object.keys(collections).length > 0) throw new Error(`Unknown collection: ${collection}`);
+		throw new Error(`Cannot read unconfigured collection: ${collection}`);
+	}
+	if (resolved.collection.storage?.kind !== "sqlite-json") throw new Error(`Collection is not readable with SQLite JSON storage: ${collection}`);
+	const row = execSql(sql, sqlTag`
+      SELECT value FROM ${identifierSql(tableName$1(resolved.name, resolved.collection.storage))}
+      WHERE path = ${resolved.scope} AND key = ${String(key)}
+    `).toArray()[0];
+	return row ? JSON.parse(row.value) : void 0;
+}
+function selectRows(sql, table, options) {
+	const where = [sqlTag`path = ${options.scope}`];
+	where.push(...options.filters.map((filter) => filterSql(filter)));
+	if (options.predicate) where.push(predicateSql(options.predicate));
+	const order = options.orderBy.length > 0 ? join(options.orderBy.map((item) => orderBySql(item))) : sqlTag`key`;
+	return execSql(sql, sqlTag`
+        SELECT key, value FROM ${identifierSql(table)}
+        WHERE ${join(where, " AND ")}
+        ORDER BY ${order}
+        LIMIT ${options.limit ?? 1e3} OFFSET ${options.offset ?? 0}
+      `).toArray();
+}
+function uniqueRows(rows) {
+	const seen = /* @__PURE__ */ new Set();
+	const unique = [];
+	for (const row of rows) if (!seen.has(row.key)) {
+		seen.add(row.key);
+		unique.push(row);
+	}
+	return unique;
+}
+function tableName$1(collectionName, storage) {
+	return storage.tableName ?? collectionName;
+}
+function jsonPath$1(field) {
+	if (!/^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*$/.test(field)) throw new Error(`Invalid JSON index field: ${field}`);
+	return `$.${field}`;
+}
+function orderBySql(orderBy) {
+	const direction = orderBy.direction === "desc" ? "DESC" : "ASC";
+	return sqlTag`json_extract(value, ${jsonPath$1(orderBy.field)}) ${directionSql(direction)}`;
+}
+function predicateSql(predicate) {
+	if (predicate.type === "comparison") return filterSql(predicate);
+	const joiner = predicate.type === "and" ? " AND " : " OR ";
+	return sqlTag`(${join(predicate.predicates.map((child) => predicateSql(child)), joiner)})`;
+}
+function combinePredicates(left, right) {
+	if (!left) return right;
+	if (!right) return left;
+	return {
+		type: "and",
+		predicates: [left, right]
+	};
+}
+function filterSql(filter) {
+	const field = sqlTag`json_extract(value, ${jsonPath$1(filter.field)})`;
+	if (filter.op === "in") {
+		if (!Array.isArray(filter.value) || filter.value.length === 0) throw new Error("The in filter requires a non-empty array value");
+		return sqlTag`${field} IN (${join(filter.value.map(toSqlJsonValue))})`;
+	}
+	const value = toSqlJsonValue(filter.value);
+	if (value === null) {
+		if (filter.op === "eq") return sqlTag`${field} IS ${value}`;
+		if (filter.op === "ne") return sqlTag`${field} IS NOT ${value}`;
+	}
+	switch (filter.op) {
+		case "eq": return sqlTag`${field} = ${value}`;
+		case "ne": return sqlTag`${field} != ${value}`;
+		case "gt": return sqlTag`${field} > ${value}`;
+		case "gte": return sqlTag`${field} >= ${value}`;
+		case "lt": return sqlTag`${field} < ${value}`;
+		case "lte": return sqlTag`${field} <= ${value}`;
+	}
+}
+function directionSql(direction) {
+	return rawSql(direction);
+}
+function toSqlJsonValue(value) {
+	if (typeof value === "boolean") return value ? 1 : 0;
+	if (value === null || typeof value === "string" || typeof value === "number" || value instanceof ArrayBuffer) return value;
+	throw new Error(`Unsupported SQLite JSON filter value: ${typeof value}`);
+}
+//#endregion
+//#region src/storage.ts
+function sqliteJsonTable(options = {}) {
+	return {
+		kind: "sqlite-json",
+		...options.tableName ? { tableName: options.tableName } : {},
+		indexes: (options.indexes ?? []).map((index) => Array.isArray(index) ? { fields: index } : index)
+	};
+}
+function ensureSQLiteJsonTables(sql, collections = {}) {
+	for (const [collectionName, collection] of Object.entries(collections)) {
+		const storage = sqliteJsonStorage(collection.storage);
+		if (!storage) continue;
+		const table = tableName(collectionName, storage);
+		const result = execSql(sql, sqlTag`
+      CREATE TABLE IF NOT EXISTS ${identifierSql(table)} (
+        key TEXT NOT NULL,
+        path TEXT NOT NULL,
+        value TEXT NOT NULL,
+        version INTEGER NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        PRIMARY KEY (path, key)
+      )
+    `);
+		for (const index of storage.indexes) execSql(sql, createIndexSql(table, index));
+		if (result.rowsWritten > 0) {
+			if (collection.initialData) for (const data of collection.initialData) {
+				const key = String(data.id);
+				const path = collectionScope(collectionName);
+				const value = JSON.stringify(data);
+				const version = 1;
+				const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+				const updatedAt = createdAt;
+				execSql(sql, sqlTag`
+              INSERT INTO ${identifierSql(table)} (key, path, value, version, created_at, updated_at)
+              VALUES (${key}, ${path}, ${value}, ${version}, ${createdAt}, ${updatedAt})
+            `);
+			}
+		}
+	}
+}
+function applySQLiteJsonBatch(sql, batch, collections = {}) {
+	ensureSQLiteJsonTables(sql, collections);
+	for (const update of batch.updates) {
+		const resolved = resolveCollection(update.collection, collections);
+		const storage = resolved ? sqliteJsonStorage(resolved.collection.storage) : void 0;
+		if (!resolved || !storage) continue;
+		const table = tableName(resolved.name, storage);
+		const key = String(update.key);
+		const scope = resolved.scope;
+		const updatedAt = new Date(update.createdAt).toISOString();
+		if (update.type === "delete") {
+			execSql(sql, sqlTag`DELETE FROM ${identifierSql(table)} WHERE ${whereKeySql(scope, key)}`);
+			continue;
+		}
+		if (update.type === "insert") {
+			execSql(sql, sqlTag`
+          INSERT INTO ${identifierSql(table)} (key, path, value, version, created_at, updated_at)
+          VALUES (${key}, ${scope}, ${stringifyRow(update.value)}, 1, ${updatedAt}, ${updatedAt})
+          ON CONFLICT(path, key) DO UPDATE SET
+            path = excluded.path,
+            value = excluded.value,
+            version = ${identifierSql(table)}.version + 1,
+            updated_at = excluded.updated_at
+        `);
+			continue;
+		}
+		const existing = execSql(sql, sqlTag`SELECT value FROM ${identifierSql(table)} WHERE ${whereKeySql(scope, key)}`).toArray()[0];
+		if (!existing) throw new Error(`Cannot update missing ${update.collection} row: ${key}`);
+		const merged = mergeRows(JSON.parse(existing.value), update.value);
+		execSql(sql, sqlTag`
+        UPDATE ${identifierSql(table)}
+        SET value = ${JSON.stringify(merged)}, version = version + 1, updated_at = ${updatedAt}
+        WHERE ${whereKeySql(scope, key)}
+      `);
+	}
+}
+function sqliteJsonStorage(storage) {
+	if (!storage) return sqliteJsonTable();
+	return storage.kind === "sqlite-json" ? storage : void 0;
+}
+function whereKeySql(scope, key) {
+	return sqlTag`path = ${scope} AND key = ${key}`;
+}
+function tableName(collectionName, storage) {
+	return storage.tableName ?? collectionName;
+}
+function createIndexSql(table, index) {
+	const name = index.name ?? `${table}_${index.fields.join("_")}_idx`;
+	const fields = index.fields.map((field) => rawSql(`json_extract(value, '$.${jsonPath(field)}')`));
+	return sqlTag`
+    CREATE INDEX IF NOT EXISTS ${identifierSql(name)}
+    ON ${identifierSql(table)} (${join(fields)})
+  `;
+}
+function jsonPath(field) {
+	if (!/^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*$/.test(field)) throw new Error(`Invalid JSON index field: ${field}`);
+	return field;
+}
+function stringifyRow(value) {
+	if (!isRecord(value)) throw new Error("SQLite JSON storage requires object row values");
+	return JSON.stringify(value);
+}
+function mergeRows(existing, changes) {
+	if (!isRecord(existing) || !isRecord(changes)) throw new Error("SQLite JSON storage can only merge object update values");
+	return {
+		...existing,
+		...changes
+	};
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/collection-builder.ts
+function collectionConfigsBuilder() {
+	return new CollectionConfigsBuilder({});
+}
+function collectionBuilder() {
+	return new CollectionBuilder({});
+}
+const Collections = {
+	builder: collectionConfigsBuilder,
+	collection: collectionBuilder
+};
+var CollectionConfigsBuilder = class CollectionConfigsBuilder {
+	collections;
+	constructor(collections) {
+		this.collections = Object.freeze({ ...collections });
+	}
+	collection(name, configure) {
+		const builder = configure(new CollectionBuilder({ path: rootPathForName(name) }));
+		return new CollectionConfigsBuilder({
+			...this.collections,
+			...builder.entries()
+		});
+	}
+	path(path, configure) {
+		const builder = configure(new CollectionBuilder({ path }));
+		return new CollectionConfigsBuilder({
+			...this.collections,
+			...builder.entries()
+		});
+	}
+	build() {
+		return { ...this.collections };
+	}
+};
+var CollectionBuilder = class CollectionBuilder {
+	state;
+	constructor(state) {
+		this.state = freezeState(state);
+	}
+	name(name) {
+		return this.next({ path: rootPathForName(name) });
+	}
+	path(path) {
+		return this.next({ path });
+	}
+	schema(schema) {
+		return this.next({ schema });
+	}
+	access(access) {
+		return this.next({ access });
+	}
+	storage(storage) {
+		return this.next({ storage });
+	}
+	index(fieldOrIndex, ...fields) {
+		return this.next({ indexes: [...this.state.indexes ?? [], normalizeIndex(fieldOrIndex, fields)] });
+	}
+	initialData(...initialData) {
+		return this.next({ initialData });
+	}
+	api(name, input, handler) {
+		return this.next({ api: {
+			...this.state.api,
+			[name]: freezeApiDefinition({
+				input,
+				handler
+			})
+		} });
+	}
+	child(name, configure) {
+		const path = this.requirePath("CollectionBuilder.child");
+		const builder = configure(new CollectionBuilder({ path: childPathForName(path, parentIdParamForName(path), name) }));
+		return this.next({ children: {
+			...this.state.children,
+			[name]: builder
+		} });
+	}
+	buildConfig() {
+		if (!this.state.schema) throw new Error("CollectionBuilder requires a schema");
+		const config = { schema: this.state.schema };
+		if (this.state.access) config.access = this.state.access;
+		config.storage = storageWithIndexes(this.state.storage, this.state.indexes ?? []);
+		if (this.state.initialData) config.initialData = [...this.state.initialData];
+		if (this.state.api) config.api = { ...this.state.api };
+		return config;
+	}
+	build() {
+		return this.entries();
+	}
+	entries() {
+		const entries = { [this.requirePath("CollectionBuilder.build")]: this.buildConfig() };
+		for (const child of Object.values(this.state.children ?? {})) Object.assign(entries, child.entries());
+		return entries;
+	}
+	next(updates) {
+		return new CollectionBuilder({
+			...this.state,
+			...updates
+		});
+	}
+	requirePath(caller) {
+		if (!this.state.path) throw new Error(`${caller} requires a name or path`);
+		return this.state.path;
+	}
+};
+function freezeState(state) {
+	const next = {};
+	if (state.path) next.path = state.path;
+	if (state.schema) next.schema = state.schema;
+	if (state.access) next.access = state.access;
+	if (state.storage) next.storage = state.storage;
+	if (state.indexes) next.indexes = state.indexes.map((index) => ({ ...index }));
+	if (state.initialData) next.initialData = [...state.initialData];
+	if (state.api) next.api = Object.freeze({ ...state.api });
+	if (state.children) next.children = Object.freeze({ ...state.children });
+	return Object.freeze(next);
+}
+function freezeApiDefinition(definition) {
+	return Object.freeze({ ...definition });
+}
+function normalizeIndex(fieldOrIndex, fields) {
+	if (typeof fieldOrIndex === "string") return { fields: [fieldOrIndex, ...fields] };
+	return Array.isArray(fieldOrIndex) ? { fields: fieldOrIndex } : fieldOrIndex;
+}
+function storageWithIndexes(storage, indexes) {
+	const current = storage ?? sqliteJsonTable();
+	if (current.kind !== "sqlite-json") return current;
+	return {
+		...current,
+		indexes: [...current.indexes, ...indexes]
+	};
+}
+function rootPathForName(name) {
+	return `/${encodeURIComponent(name)}/`;
+}
+function childPathForName(parentPath, parentParam, name) {
+	return `${parentPath.replace(/\/+$/g, "")}/{${parentParam}}/${encodeURIComponent(name)}/`;
+}
+function parentIdParamForName(parentPath) {
+	return `${singularize(parentPath.trim().replace(/^\/+|\/+$/g, "").split("/").filter((part) => !part.startsWith("{") && !part.startsWith(":")).at(-1) ?? "parent")}Id`;
+}
+function singularize(value) {
+	return value.endsWith("s") ? value.slice(0, -1) : value;
+}
+//#endregion
+//#region src/definition-builder.ts
+function collectionShardOptionsFrom(definitions) {
+	return new CollectionShardDefinitionBuilder(definitions.collections, {});
+}
+var CollectionShardDefinitionBuilder = class CollectionShardDefinitionBuilder {
+	definitions;
+	overrides;
+	constructor(definitions, overrides) {
+		this.definitions = definitions;
+		this.overrides = overrides;
+	}
+	collection(path, configure) {
+		const override = configure(new ServerCollectionBuilder({})).toOverride();
+		return new CollectionShardDefinitionBuilder(this.definitions, {
+			...this.overrides,
+			[path]: override
+		});
+	}
+	build() {
+		const collections = {};
+		for (const [name, definition] of Object.entries(this.definitions)) addDefinition(collections, definition, name, this.overrides);
+		return { collections };
+	}
+};
+var ServerCollectionBuilder = class ServerCollectionBuilder {
+	override;
+	constructor(override) {
+		this.override = override;
+	}
+	index(...fields) {
+		return new ServerCollectionBuilder({
+			...this.override,
+			indexes: [...this.override.indexes ?? [], fields]
+		});
+	}
+	initialData(data) {
+		return new ServerCollectionBuilder({
+			...this.override,
+			initialData: data
+		});
+	}
+	reference(name, resolver) {
+		return new ServerCollectionBuilder({
+			...this.override,
+			references: {
+				...this.override.references,
+				[name]: resolver
+			}
+		});
+	}
+	access(kind, handler) {
+		return new ServerCollectionBuilder({
+			...this.override,
+			access: {
+				...this.override.access,
+				[kind]: handler
+			}
+		});
+	}
+	api(name, handler) {
+		return new ServerCollectionBuilder({
+			...this.override,
+			api: {
+				...this.override.api,
+				[name]: handler
+			}
+		});
+	}
+	toOverride() {
+		return this.override;
+	}
+};
+function addDefinition(collections, definition, dotPath, overrides) {
+	const override = overrides[dotPath] ?? {};
+	let builder = collectionBuilder().path(definition.path).schema(definition.schema);
+	for (const fields of override.indexes ?? []) builder = builder.index(fields);
+	if (override.initialData) builder = builder.initialData(...override.initialData);
+	const access = accessConfig(override);
+	if (access) builder = builder.access(access);
+	for (const [name, handler] of Object.entries(override.api ?? {})) {
+		const apiDefinition = definition.api[name];
+		const apiAccess = override.access?.[`api.${name}`];
+		const apiPath = apiDefinition?.path ?? defaultCollectionApiPath(definition.path, name);
+		const input = apiDefinition?.input ?? z.undefined();
+		builder = builder.api(name, input, async (args) => {
+			authorizeApiCall(apiAccess, apiPath, args.input, args.auth);
+			return handler(args);
+		});
+	}
+	Object.assign(collections, builder.build());
+	for (const [name, child] of Object.entries(definition.children)) addDefinition(collections, child, `${dotPath}.${name}`, overrides);
+}
+function accessConfig(override) {
+	const access = override.access ?? {};
+	const apiAccess = Object.fromEntries(Object.entries(access).filter(([kind]) => kind.startsWith("api.")).map(([kind, handler]) => [kind.slice(4), handler]));
+	const config = {};
+	if (override.references) config.references = override.references;
+	if (access.read) config.read = access.read;
+	if (access.write) config.write = access.write;
+	if (access.insert) config.insert = access.insert;
+	if (access.update) config.update = access.update;
+	if (access.delete) config.delete = access.delete;
+	if (Object.keys(apiAccess).length > 0) config.api = apiAccess;
+	return Object.keys(config).length > 0 ? config : void 0;
+}
+//#endregion
+//#region src/durable-object-rpc.ts
+function callRouter(caller, request) {
+	if (request.method === "query" && request.params.path === "read") return caller.read(request.params.input.json);
+	if (request.method === "query" && request.params.path === "changes") return caller.changes(request.params.input.json);
+	if (request.method === "subscribe") return caller.subscribe(request.params.input.json);
+	if (request.method === "unsubscribe") return caller.unsubscribe(request.params.input.json);
+	if (request.method !== "mutation") throw new Error("Unsupported operation");
+	if (request.params.path === "push") return caller.push(request.params.input.json);
+	if (request.params.path === "api") return caller.api(request.params.input.json);
+	throw new Error("Unsupported operation");
+}
+//#endregion
+//#region src/history-watermarks.ts
+const COLLECTION_WATERMARKS_TABLE = "_lsync_collection_watermarks";
+function ensureCollectionWatermarkTable(sql) {
+	sql.exec(`
+    CREATE TABLE IF NOT EXISTS ${quoteIdentifier$1(COLLECTION_WATERMARKS_TABLE)} (
+      scope TEXT PRIMARY KEY,
+      collection TEXT NOT NULL,
+      latest_sequence INTEGER NOT NULL
+    )
+  `);
+}
+function recordCollectionWatermark(sql, collection, scope, sequence) {
+	sql.exec(`
+      INSERT INTO ${quoteIdentifier$1(COLLECTION_WATERMARKS_TABLE)}
+        (scope, collection, latest_sequence)
+      VALUES (?, ?, ?)
+      ON CONFLICT(scope) DO UPDATE SET
+        collection = excluded.collection,
+        latest_sequence = excluded.latest_sequence
+    `, scope, collection, sequence);
+}
+function readCollectionWatermark(sql, scope) {
+	return sql.exec(`
+        SELECT latest_sequence FROM ${quoteIdentifier$1(COLLECTION_WATERMARKS_TABLE)}
+        WHERE scope = ?
+      `, scope).toArray()[0]?.latest_sequence ?? 0;
+}
+function quoteIdentifier$1(identifier) {
+	return `"${identifier.replaceAll(`"`, `""`)}"`;
+}
+//#endregion
+//#region src/history.ts
+const CHANGES_TABLE = "_lsync_changes";
+function persistSQLiteJsonBatchWithHistory(sql, batch, collections = {}, options = {}) {
+	ensureSQLiteJsonTables(sql, collections);
+	ensureChangesTable(sql);
+	applySQLiteJsonBatch(sql, batch, collections);
+	const updates = batch.updates.map((update) => appendChange(sql, update, collections));
+	const watermark = updates.at(-1)?.sequence ?? readWatermark(sql);
+	pruneChanges(sql, watermark, options.maxChanges ?? 1e4);
+	return {
+		updates,
+		watermark
+	};
+}
+function readSQLiteJsonChanges(sql, query, collections = {}) {
+	ensureChangesTable(sql);
+	const requested = Object.entries(query.collections).map(([collection, sequence]) => ({
+		collection,
+		sequence,
+		scope: scopeForCollection(collection, collections)
+	}));
+	const watermark = readWatermark(sql);
+	const staleCollections = requested.flatMap((item) => isCursorStale(sql, item.scope, item.sequence) ? [item.collection] : []);
+	if (staleCollections.length > 0) return {
+		type: "resyncRequired",
+		collections: staleCollections,
+		watermark
+	};
+	if (requested.length === 0) return {
+		type: "changes",
+		updates: [],
+		watermark,
+		hasMore: false
+	};
+	const limit = query.limit ?? 1e3;
+	const rows = selectChanges(sql, requested, limit + 1);
+	return {
+		type: "changes",
+		updates: rows.slice(0, limit).map(rowToUpdate),
+		watermark,
+		hasMore: rows.length > limit
+	};
+}
+function ensureChangesTable(sql) {
+	sql.exec(`
+    CREATE TABLE IF NOT EXISTS ${quoteIdentifier(CHANGES_TABLE)} (
+      sequence INTEGER PRIMARY KEY AUTOINCREMENT,
+      update_id TEXT NOT NULL,
+      collection TEXT NOT NULL,
+      scope TEXT NOT NULL,
+      "key" TEXT NOT NULL,
+      type TEXT NOT NULL,
+      value TEXT,
+      previous_value TEXT,
+      client_id TEXT,
+      client_created_at INTEGER NOT NULL,
+      server_created_at TEXT NOT NULL
+    )
+  `);
+	sql.exec(`
+    CREATE INDEX IF NOT EXISTS ${quoteIdentifier(`${CHANGES_TABLE}_scope_sequence_idx`)}
+    ON ${quoteIdentifier(CHANGES_TABLE)} (scope, sequence)
+  `);
+	ensureCollectionWatermarkTable(sql);
+}
+function appendChange(sql, update, collections) {
+	const serverCreatedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const scope = scopeForCollection(update.collection, collections);
+	const row = sql.exec(`
+        INSERT INTO ${quoteIdentifier(CHANGES_TABLE)}
+          (update_id, collection, scope, "key", type, value, previous_value, client_id,
+           client_created_at, server_created_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        RETURNING sequence
+      `, update.id, update.collection, scope, JSON.stringify(update.key), update.type, update.value === void 0 ? null : JSON.stringify(update.value), update.previousValue === void 0 ? null : JSON.stringify(update.previousValue), update.clientId ?? null, update.createdAt, serverCreatedAt).toArray()[0];
+	if (!row) throw new Error("Unable to append sync history row");
+	recordCollectionWatermark(sql, update.collection, scope, row.sequence);
+	return {
+		...update,
+		sequence: row.sequence,
+		serverCreatedAt
+	};
+}
+function selectChanges(sql, requested, limit) {
+	const bindings = requested.flatMap((item) => [item.scope, item.sequence]);
+	bindings.push(limit);
+	return sql.exec(`
+        SELECT sequence, update_id, collection, "key", type, value, previous_value, client_id,
+               client_created_at, server_created_at
+        FROM ${quoteIdentifier(CHANGES_TABLE)}
+        WHERE ${requested.map(() => "(scope = ? AND sequence > ?)").join(" OR ")}
+        ORDER BY sequence
+        LIMIT ?
+      `, ...bindings).toArray();
+}
+function rowToUpdate(row) {
+	const update = {
+		id: row.update_id,
+		collection: row.collection,
+		key: JSON.parse(row.key),
+		type: row.type,
+		createdAt: row.client_created_at,
+		sequence: row.sequence,
+		serverCreatedAt: row.server_created_at
+	};
+	if (row.value !== null) update.value = JSON.parse(row.value);
+	if (row.previous_value !== null) update.previousValue = JSON.parse(row.previous_value);
+	if (row.client_id !== null) update.clientId = row.client_id;
+	return update;
+}
+function isCursorStale(sql, scope, sequence) {
+	const latest = readCollectionWatermark(sql, scope);
+	if (latest === 0) return false;
+	const oldest = sql.exec(`SELECT MIN(sequence) as sequence FROM ${quoteIdentifier(CHANGES_TABLE)} WHERE scope = ?`, scope).toArray()[0]?.sequence;
+	if (oldest === null || oldest === void 0) return sequence < latest;
+	return sequence < oldest - 1;
+}
+function readWatermark(sql) {
+	return sql.exec(`SELECT COALESCE(MAX(sequence), 0) as watermark FROM ${quoteIdentifier(CHANGES_TABLE)}`).toArray()[0]?.watermark ?? 0;
+}
+function pruneChanges(sql, watermark, maxChanges) {
+	if (!Number.isFinite(maxChanges) || maxChanges < 0) return;
+	sql.exec(`DELETE FROM ${quoteIdentifier(CHANGES_TABLE)} WHERE sequence <= ?`, watermark - maxChanges);
+}
+function scopeForCollection(collection, collections) {
+	const resolved = resolveCollection(collection, collections);
+	if (resolved) return resolved.scope;
+	if (Object.keys(collections).length > 0) throw new Error(`Unknown collection: ${collection}`);
+	return collectionScope(collection);
+}
+function quoteIdentifier(identifier) {
+	return `"${identifier.replaceAll(`"`, `""`)}"`;
+}
+//#endregion
+//#region src/messages.ts
+function sendRpcResult(ws, id, result) {
+	sendServerMessage(ws, {
+		id,
+		result: {
+			type: "data",
+			data: { json: result }
+		}
+	});
+}
+function sendRpcError(ws, id, error) {
+	sendServerMessage(ws, {
+		id,
+		error: { message: error instanceof Error ? error.message : "Unknown error" }
+	});
+}
+//#endregion
+//#region src/socket-attachment.ts
+function webSocketAttachment(ws) {
+	const result = webSocketAttachmentSchema.safeParse(ws.deserializeAttachment());
+	return result.success ? result.data : void 0;
+}
+function webSocketAuth(ws) {
+	const attachment = webSocketAttachment(ws);
+	if (!attachment) return {};
+	return {
+		clientId: attachment.clientId,
+		...attachment.auth
+	};
+}
+function updateSocketSubscriptions(ws, collection, normalize, update) {
+	const attachment = webSocketAttachment(ws);
+	if (!attachment) throw new Error("Missing WebSocket attachment");
+	const normalized = normalize(collection);
+	const subscriptions = new Set(attachment.subscriptions);
+	update(subscriptions, normalized);
+	const next = [...subscriptions];
+	ws.serializeAttachment({
+		...attachment,
+		subscriptions: next
+	});
+	return {
+		collection: normalized,
+		subscriptions: next
+	};
+}
+//#endregion
+//#region src/access-invalidation.ts
+function invalidatesDependency(update, dependencies) {
+	return dependencies.some((dependency) => {
+		if (collectionScope(update.collection) !== collectionScope(dependency.collection)) return false;
+		if (String(update.key) !== String(dependency.key)) return false;
+		return fieldChanged(update.previousValue, update.value, dependency.field);
+	});
+}
+function fieldChanged(previous, next, field) {
+	if (!previous || !next) return true;
+	return valueAtPath(previous, field) !== valueAtPath(next, field);
+}
+function valueAtPath(value, field) {
+	return field.split(".").reduce((current, segment) => {
+		if (typeof current !== "object" || current === null) return void 0;
+		return current[segment];
+	}, value);
+}
+//#endregion
+//#region src/subscription-invalidation.ts
+function subscribedInvalidations(subscriptions, batch, collections, auth, store) {
+	const invalidations = /* @__PURE__ */ new Set();
+	for (const collection of subscriptions) {
+		const decision = readAccessDecision(collection, collections, auth, store);
+		if (decision.dependencies.length === 0) continue;
+		if (batch.updates.some((update) => invalidatesDependency(update, decision.dependencies))) invalidations.add(collection);
+	}
+	return [...invalidations].map((collection) => ({ collection }));
+}
+//#endregion
+//#region src/validation.ts
+function validateBatch(batch, collections) {
+	for (const update of batch.updates) {
+		const schema = schemaFor(update.collection, collections);
+		if (!schema || update.type === "delete") continue;
+		if (update.type === "update" && schema instanceof z.ZodObject) {
+			schema.partial().parse(update.value);
+			continue;
+		}
+		schema.parse(update.value);
+	}
+}
+function schemaFor(collection, collections) {
+	const configured = resolveCollection(collection, collections);
+	if (!configured) {
+		if (collections && Object.keys(collections).length > 0) throw new Error(`Unknown collection: ${collection}`);
+		return;
+	}
+	return configured.collection.schema;
+}
+//#endregion
+//#region src/durable-object.ts
+var CollectionShardDurableObject = class {
+	state;
+	env;
+	options;
+	static from = collectionShardOptionsFrom;
+	apiHandlers;
+	constructor(state, env, options = {}) {
+		this.state = state;
+		this.env = env;
+		this.options = options;
+		this.apiHandlers = collectionApiHandlers(options.collections);
+	}
+	async fetch(request) {
+		if (request.headers.get("Upgrade") !== "websocket") return new Response("Expected WebSocket upgrade", { status: 426 });
+		const pair = new WebSocketPair();
+		const client = pair[0];
+		const server = pair[1];
+		const clientId = new URL(request.url).searchParams.get("clientId") ?? crypto.randomUUID();
+		const auth = await this.options.authenticate?.({
+			clientId,
+			request
+		}) ?? { clientId };
+		this.state.acceptWebSocket(server);
+		server.serializeAttachment({
+			clientId,
+			connectedAt: Date.now(),
+			auth,
+			subscriptions: []
+		});
+		return new Response(null, {
+			status: 101,
+			webSocket: client
+		});
+	}
+	async webSocketMessage(ws, message) {
+		try {
+			const request = parseClientRpcRequest(message);
+			const result = await callRouter(router.createCaller({
+				shardId: this.shardId(),
+				validate: (input) => this.validate(input),
+				persist: (input) => this.persist(input),
+				publish: (input) => this.publish(input),
+				mutate: (input) => this.mutate(input, webSocketAuth(ws)),
+				subscribe: (input) => this.subscribe(ws, input),
+				unsubscribe: (input) => this.unsubscribe(ws, input),
+				read: (input) => this.read(input, webSocketAuth(ws)),
+				changes: (input) => this.readChanges(input, webSocketAuth(ws)),
+				callApi: (input) => this.callApi(ws, input)
+			}), request);
+			sendRpcResult(ws, request.id, result);
+		} catch (error) {
+			sendRpcError(ws, readRpcId(message), error);
+		}
+	}
+	publish(batch) {
+		const payload = {
+			type: "updates",
+			shardId: this.shardId(),
+			updates: batch.updates,
+			watermark: batch.watermark
+		};
+		for (const socket of this.state.getWebSockets()) {
+			const updates = this.subscribedUpdates(socket, batch);
+			const invalidations = this.subscribedInvalidations(socket, batch);
+			if (updates.length === 0 && invalidations.length === 0) continue;
+			sendServerMessage(socket, {
+				method: "subscription",
+				params: {
+					path: "updates",
+					input: { json: {
+						...payload,
+						...invalidations.length > 0 ? { invalidations } : {},
+						updates
+					} }
+				}
+			});
+		}
+	}
+	validate(batch) {
+		validateBatch(batch, this.options.collections);
+	}
+	persist(batch) {
+		return this.state.storage.transactionSync(() => persistSQLiteJsonBatchWithHistory(this.state.storage.sql, batch, this.options.collections, this.options.history));
+	}
+	read(query, auth = {}) {
+		const authorized = authorizeReadQuery(query, this.options.collections, auth, this.accessStore());
+		return authorized ? readSQLiteJsonRows(this.state.storage.sql, authorized, this.options.collections) : { rows: [] };
+	}
+	readChanges(query, auth = {}) {
+		const result = readSQLiteJsonChanges(this.state.storage.sql, query, this.options.collections);
+		if (result.type === "resyncRequired") return result;
+		return {
+			...result,
+			updates: result.updates.flatMap((update) => {
+				const visible = visibleUpdateForAuth(update, this.options.collections, auth, this.accessStore());
+				return visible ? [{
+					...visible,
+					sequence: update.sequence,
+					serverCreatedAt: update.serverCreatedAt
+				}] : [];
+			})
+		};
+	}
+	subscribe(ws, input) {
+		return this.updateSubscriptions(ws, input.collection, (subscriptions, collection) => {
+			subscriptions.add(collection);
+		});
+	}
+	unsubscribe(ws, input) {
+		return this.updateSubscriptions(ws, input.collection, (subscriptions, collection) => {
+			subscriptions.delete(collection);
+		});
+	}
+	async callApi(ws, call) {
+		const handler = this.apiHandlers[call.path];
+		if (!handler) throw new Error(`Unknown API path: ${call.path}`);
+		const clientId = this.clientId(ws);
+		const auth = webSocketAuth(ws);
+		const args = {
+			shardId: this.shardId(),
+			input: call.input,
+			auth,
+			validate: (input) => this.validate(input),
+			persist: (input) => this.persist(input),
+			publish: (input) => this.publish(input),
+			subscribe: (input) => this.subscribe(ws, input),
+			unsubscribe: (input) => this.unsubscribe(ws, input),
+			mutate: (input) => this.mutate(input, auth),
+			read: (input) => this.read(input, auth),
+			changes: (input) => this.readChanges(input, auth)
+		};
+		if (clientId) args.clientId = clientId;
+		return handler(args);
+	}
+	mutate(batch, auth = {}) {
+		this.validate(batch);
+		authorizeWriteBatch(batch, this.options.collections, auth, this.accessStore());
+		const persisted = this.persist(batch);
+		this.publish(persisted);
+		return {
+			accepted: batch.updates.length,
+			watermark: persisted.watermark
+		};
+	}
+	clientId(ws) {
+		return webSocketAttachment(ws)?.clientId;
+	}
+	updateSubscriptions(ws, collection, update) {
+		return updateSocketSubscriptions(ws, collection, (input) => normalizeCollection(input, this.options.collections), update);
+	}
+	subscribedUpdates(ws, batch) {
+		const attachment = webSocketAttachment(ws);
+		if (!attachment || attachment.subscriptions.length === 0) return [];
+		const subscriptions = new Set(attachment.subscriptions);
+		const auth = webSocketAuth(ws);
+		return batch.updates.flatMap((update) => {
+			if (!subscriptions.has(normalizeCollection(update.collection, this.options.collections))) return [];
+			const visible = visibleUpdateForAuth(update, this.options.collections, auth, this.accessStore());
+			return visible ? [{
+				...visible,
+				sequence: update.sequence,
+				serverCreatedAt: update.serverCreatedAt
+			}] : [];
+		});
+	}
+	subscribedInvalidations(ws, batch) {
+		const attachment = webSocketAttachment(ws);
+		if (!attachment || attachment.subscriptions.length === 0) return [];
+		return subscribedInvalidations(attachment.subscriptions, batch, this.options.collections, webSocketAuth(ws), this.accessStore());
+	}
+	accessStore() {
+		return { read: (collection, key) => readSQLiteJsonRow(this.state.storage.sql, collection, key, this.options.collections) };
+	}
+	shardId() {
+		return this.state.id.toString();
+	}
+};
+//#endregion
+//#region src/worker.ts
+function createWorkerHandler(options = {}) {
+	const binding = options.binding ?? "SYNC_SHARDS";
+	const routePattern = options.routePattern ?? /^\/sync\/([^/]+)$/;
+	return { fetch(request, env) {
+		const match = new URL(request.url).pathname.match(routePattern);
+		if (!match?.[1]) return new Response("Not found", { status: 404 });
+		const namespace = env[binding];
+		if (!namespace) return new Response(`Missing Durable Object binding: ${String(binding)}`, { status: 500 });
+		const id = namespace.idFromName(decodeURIComponent(match[1]));
+		return namespace.get(id).fetch(request);
+	} };
+}
+//#endregion
+export { CollectionBuilder, CollectionConfigsBuilder, CollectionShardDefinitionBuilder, CollectionShardDurableObject, Collections, ServerCollectionBuilder, and, applySQLiteJsonBatch, authorizeApiCall, authorizeReadQuery, authorizeWriteBatch, collectionApiHandlers, collectionBuilder, collectionConfigsBuilder, collectionScope, compileReadExpression, createWorkerHandler, defaultCollectionApiPath, ensureSQLiteJsonTables, eq, field, gt, gte, inArray, isCollectionPattern, lt, lte, matchesReadPredicate, ne, not, or, persistSQLiteJsonBatchWithHistory, readAccessDecision, readExpressionReferences, readExpressionRow, readSQLiteJsonChanges, readSQLiteJsonRow, readSQLiteJsonRows, resolveCollection, router, sqliteJsonTable, val, validateBatch, visibleUpdateForAuth };
+
+//# sourceMappingURL=index.mjs.map