@rebasepro/server 0.23.0 → 0.24.0

package/dist/{src-pmvW7BFx.js → src-I3aG1PcY.js}

@@ -3,7 +3,7 @@ import __rebaseProcess from "process";
 globalThis.process ??= __rebaseProcess;
 __rebaseCreateRequire(import.meta.url);
 import { r as __require, t as __commonJSMin } from "./rolldown-runtime-dW7B1o5h.js";
-import { A as NULL_OPS, C as isPostgresCollectionConfig, D as ALL_WHERE_FILTER_OPS, E as getDataSourceCapabilities, F as toCanonicalOp, M as isRelationAggregateSort, O as CANONICAL_TO_REST, P as sortKeyToString, S as getDeclaredSubcollections, b as rewriteLegacyRlsFunctions, f as resolveResourceRefs, j as REST_TO_CANONICAL, k as LIST_OPS, w as isRelationalCollectionConfig } from "./src-vkcwKXbT.js";
+import { B as rewriteLegacyRlsFunctions, H as getDeclaredSubcollections, J as CANONICAL_TO_REST, K as getDataSourceCapabilities, M as resolveResourceRefs, Q as isRelationAggregateSort, U as isPostgresCollectionConfig, V as getCollectionDataPath, W as isRelationalCollectionConfig, X as NULL_OPS, Y as LIST_OPS, Z as REST_TO_CANONICAL, et as sortKeyToString, q as ALL_WHERE_FILTER_OPS, tt as toCanonicalOp } from "./src-CatHFUym.js";
 //#region ../types/src/errors.ts
 /**
 * The single error type thrown across the entire Rebase client surface —
@@ -4018,6 +4018,13 @@ var CollectionRegistry = class {
 	}
 	collectionsByTableName = /* @__PURE__ */ new Map();
 	collectionsBySlug = /* @__PURE__ */ new Map();
+	/**
+	* Root collections whose driver stores them under a `path` other than
+	* their slug, by that path. A list, because the path is only unique within
+	* a data source: two collections in different databases may both be stored
+	* at `customer`.
+	*/
+	collectionsByDataPath = /* @__PURE__ */ new Map();
 	rootCollections = [];
 	cachedCollectionsList = null;
 	rawCollectionsByTableName = /* @__PURE__ */ new Map();
@@ -4042,6 +4049,7 @@ var CollectionRegistry = class {
 	reset() {
 		this.collectionsByTableName.clear();
 		this.collectionsBySlug.clear();
+		this.collectionsByDataPath.clear();
 		this.rootCollections = [];
 		this.cachedCollectionsList = null;
 		this.rawCollectionsByTableName.clear();
@@ -4074,6 +4082,7 @@ var CollectionRegistry = class {
 			this.collectionsByTableName.set(getTableName(normalized), normalized);
 			this.rawCollectionsByTableName.set(getTableName(raw), raw);
 			if (normalized.slug) this.collectionsBySlug.set(normalized.slug, normalized);
+			this.indexDataPath(normalized);
 			if (raw.slug) this.rawCollectionsBySlug.set(raw.slug, raw);
 		});
 		normalizedCollections.forEach((c) => {
@@ -4091,6 +4100,19 @@ var CollectionRegistry = class {
 		this.rootCollections.push(collection);
 		this.rawRootCollections.push(raw);
 		this._registerRecursively(collection, raw);
+		const registered = this.collectionsByTableName.get(getTableName(collection));
+		if (registered) this.indexDataPath(registered);
+	}
+	/**
+	* Index a root collection by the path its driver stores it under, when
+	* that is not its slug. Only roots: a subcollection's `path` is relative to
+	* the record it hangs off, so it names nothing on its own.
+	*/
+	indexDataPath(collection) {
+		const dataPath = getCollectionDataPath(collection);
+		if (!dataPath || dataPath === collection.slug) return;
+		const indexed = this.collectionsByDataPath.get(dataPath) ?? [];
+		if (!indexed.includes(collection)) this.collectionsByDataPath.set(dataPath, [...indexed, collection]);
 	}
 	_registerRecursively(collection, rawCollection) {
 		if (this.collectionsByTableName.has(getTableName(collection))) return;
@@ -4144,7 +4166,24 @@ var CollectionRegistry = class {
 		}
 		return newProperty;
 	}
-	get(path) {
+	/**
+	* The collection registered under `path`: by slug, by slug with hyphens
+	* for underscores, by table name, and last by the `path` a root Firestore
+	* or MongoDB collection declares for its driver.
+	*
+	* One string can name two collections. Declaring `slug: "fs_diagnosis",
+	* path: "diagnosis"` is how a Firestore collection sits beside a Postgres
+	* collection whose slug is `diagnosis` — and a reference read back from
+	* Firestore carries `diagnosis`. The order above settles it in favour of the
+	* slug unless `preferredDriver` is given: then the first collection whose
+	* data source or engine is `preferredDriver` wins. Pass a reference's
+	* `driver`, or the data source of the record the path was read from.
+	*/
+	get(path, preferredDriver) {
+		if (preferredDriver) {
+			const preferred = this.candidatesFor(path).find((collection) => collection.dataSource === preferredDriver || collection.engine === preferredDriver);
+			if (preferred) return preferred;
+		}
 		const bySlug = this.collectionsBySlug.get(path);
 		if (bySlug) return bySlug;
 		if (path.includes("-")) {
@@ -4152,7 +4191,84 @@ var CollectionRegistry = class {
 			const byNormalized = this.collectionsBySlug.get(normalized);
 			if (byNormalized) return byNormalized;
 		}
-		return this.collectionsByTableName.get(path);
+		const byTableName = this.collectionsByTableName.get(path);
+		if (byTableName) return byTableName;
+		return this.collectionsByDataPath.get(path)?.[0];
+	}
+	/** Every collection {@link get} could answer `path` with, in its order. */
+	candidatesFor(path) {
+		const candidates = [
+			this.collectionsBySlug.get(path),
+			path.includes("-") ? this.collectionsBySlug.get(path.replace(/-/g, "_")) : void 0,
+			this.collectionsByTableName.get(path),
+			...this.collectionsByDataPath.get(path) ?? []
+		];
+		return candidates.filter((collection, index) => collection !== void 0 && candidates.indexOf(collection) === index);
+	}
+	/**
+	* The path a collection's rows are stored under, for the path the admin
+	* addresses it by.
+	*
+	* The admin addresses a collection by its slug — in routes, in
+	* `data.collection(...)`, in the `path` of every entity it lists — because
+	* the slug is what is unique. A Firestore or MongoDB collection may declare
+	* a `path` of its own ({@link getCollectionDataPath}), and its driver has to
+	* be handed that one, under every record and subcollection too:
+	* `fs_diagnosis/abc/locales` is stored at `diagnosis/abc/locales`.
+	*
+	* A path that names no registered collection, or runs only through
+	* collections stored under their slugs, comes back unchanged.
+	*/
+	resolveDataPath(path) {
+		let resolved;
+		const exact = this.get(path);
+		if (exact) resolved = {
+			collections: [exact],
+			entityIds: []
+		};
+		else try {
+			resolved = this.resolvePathToCollections(path);
+		} catch {
+			return path;
+		}
+		const { collections, entityIds } = resolved;
+		if (collections.every((collection) => getCollectionDataPath(collection) === collection.slug)) return path;
+		return collections.map((collection, index) => index < entityIds.length ? `${getCollectionDataPath(collection)}/${entityIds[index]}` : getCollectionDataPath(collection)).join("/");
+	}
+	/**
+	* The path the admin addresses a collection by, for a path its rows are
+	* stored under: the inverse of {@link resolveDataPath}, for a reference
+	* read back from its driver.
+	*
+	* The root is the longest leading run of segments naming a collection, and
+	* becomes its slug when the run is where that collection is stored. Each
+	* subcollection after a record id is matched by where it is stored too. A
+	* path that already names its collections by slug comes back unchanged.
+	*
+	* `preferredDriver` decides between a collection stored at the path and one
+	* whose slug it is, as in {@link get}.
+	*/
+	resolveCollectionPath(path, preferredDriver) {
+		const segments = path.split("/").filter(Boolean);
+		for (let length = segments.length; length > 0; length--) {
+			const prefix = segments.slice(0, length).join("/");
+			const root = this.get(prefix, preferredDriver);
+			if (!root) continue;
+			const translated = [getCollectionDataPath(root) === prefix ? root.slug : prefix];
+			let current = root;
+			let rest = segments.slice(length);
+			while (rest.length >= 2) {
+				const [entityId, storedAt, ...after] = rest;
+				const child = getSubcollections(current).find((subcollection) => getCollectionDataPath(subcollection) === storedAt);
+				if (!child) break;
+				translated.push(entityId, child.slug);
+				current = child;
+				rest = after;
+			}
+			const collectionPath = [...translated, ...rest].join("/");
+			return collectionPath === segments.join("/") ? path : collectionPath;
+		}
+		return path;
 	}
 	/**
 	* Gets the pristine, un-normalized collection exactly as it was provided.
@@ -4200,29 +4316,41 @@ var CollectionRegistry = class {
 	}
 	/**
 	* Resolves a multi-segment path like "products/123/locales" and returns
-	* information about the collections and entity IDs along the path
+	* information about the collections and entity IDs along the path.
+	*
+	* A slug may contain slashes (`content/de-DE/podcasts`), so the root is
+	* the longest leading run of segments naming a registered collection, and
+	* each subcollection is matched the same way among its parent's.
+	*
+	* @param options.allowRecordPath accept a path that ends at a record
+	* (`…/{id}`) and resolve it to the collection holding that record, with the
+	* id last in `entityIds`. Without it such a path is an error. Only the
+	* registry can tell the two shapes apart, because only it knows where each
+	* slug ends.
 	*/
-	resolvePathToCollections(path) {
+	resolvePathToCollections(path, options) {
 		const pathSegments = path.split("/").filter((p) => p);
 		if (pathSegments.length === 0) throw new Error(`Invalid path: ${path}`);
-		if (pathSegments.length % 2 !== 1) throw new Error(`Invalid collection path: ${path}. It must have an odd number of segments.`);
-		const collections = [];
+		const root = splitAtLeadingCollection(pathSegments, (candidate) => this.get(candidate));
+		if (!root) throw new Error(`Unknown collection path or slug: ${path}`);
+		let currentCollection = root.collection;
+		const collections = [currentCollection];
 		const entityIds = [];
-		let currentCollection = this.get(pathSegments[0]);
-		if (!currentCollection) throw new Error(`Unknown collection path or slug: ${pathSegments[0]}`);
-		collections.push(currentCollection);
-		for (let i = 1; i < pathSegments.length; i += 2) {
-			const entityId = pathSegments[i];
+		let rest = root.rest;
+		while (rest.length > 0) {
+			const [entityId, ...afterEntity] = rest;
 			entityIds.push(entityId);
-			if (i + 1 < pathSegments.length) {
-				const subcollectionSlug = pathSegments[i + 1];
-				const subcollections = getSubcollections(currentCollection);
-				if (!subcollections || subcollections.length === 0) throw new Error(`No subcollections found for ${currentCollection.slug} in path: ${path}`);
-				const subcollection = subcollections.find((c) => c.slug === subcollectionSlug);
-				if (!subcollection) throw new Error(`Subcollection '${subcollectionSlug}' not found in ${currentCollection.slug}`);
-				currentCollection = this.normalizeCollection(subcollection);
-				collections.push(currentCollection);
+			if (afterEntity.length === 0) {
+				if (options?.allowRecordPath) break;
+				throw new Error(`Invalid collection path: ${path}. It ends at the record '${entityId}' of '${currentCollection.slug}', not at a collection.`);
 			}
+			const subcollections = getSubcollections(currentCollection);
+			if (!subcollections || subcollections.length === 0) throw new Error(`No subcollections found for ${currentCollection.slug} in path: ${path}`);
+			const child = splitAtLeadingCollection(afterEntity, (candidate) => subcollections.find((c) => c.slug === candidate));
+			if (!child) throw new Error(`Subcollection '${afterEntity[0]}' not found in ${currentCollection.slug}`);
+			currentCollection = this.normalizeCollection(child.collection);
+			collections.push(currentCollection);
+			rest = child.rest;
 		}
 		return {
 			collections,
@@ -4231,6 +4359,26 @@ var CollectionRegistry = class {
 		};
 	}
 };
+/**
+* Split path segments at the collection they start with.
+*
+* A slug may contain slashes, and several drivers need it to: a Firestore
+* collection partitioned by locale is declared as `content/de-DE/podcasts`,
+* and that string is its *name*. So the collection a path starts with is not
+* its first segment but the longest run of whole leading segments that names
+* one, and what follows it is `entityId/subcollection/…`.
+*
+* Whole segments only, so `content` never matches the start of `contents/1`.
+*/
+function splitAtLeadingCollection(segments, find) {
+	for (let length = segments.length; length > 0; length--) {
+		const collection = find(segments.slice(0, length).join("/"));
+		if (collection) return {
+			collection,
+			rest: segments.slice(length)
+		};
+	}
+}
 //#endregion
 //#region ../common/src/collections/engine-support.ts
 /**
@@ -4785,23 +4933,6 @@ function includePaths(tree, prefix = "") {
 	}
 	return out;
 }
-/**
-* The relation names an `include` asks for at the top level.
-*
-* `["author", "comments.author"]` and `{author: true, comments: {...}}` both
-* answer `["author", "comments"]` — a *hop*, not a path, because the only
-* consumer is `?fields=`, which names keys on the row being returned and a
-* nested relation is not one of those.
-*
-* Derived rather than passed: `include` has four spellings and three of them
-* are not a `string[]`, so every consumer that wants the plain names either
-* calls this or reimplements the flattening.
-*/
-function topLevelIncludeNames(spec) {
-	const normalized = normalizeInclude(spec);
-	if (!normalized) return [];
-	return Object.keys(normalized.tree);
-}
 /** Whether any node in the tree carries per-relation options. */
 function hasOptions(tree) {
 	return Object.values(tree).some((node) => node.limit !== void 0 || node.where !== void 0 || node.logical !== void 0 || node.orderBy !== void 0 || node.fields !== void 0 || hasOptions(node.children));
@@ -6110,7 +6241,7 @@ function inlineRelationRefs(row) {
 	}
 	return out ?? row;
 }
-function createDriverAccessor(driver, slug, getPks = () => [], toViewModel) {
+function createDriverAccessor(driver, slug, getPks = () => [], toViewModel, storedPath = () => slug) {
 	const accessor = {
 		async find(params) {
 			const filter = params?.where ? deserializeFilter(params.where) : void 0;
@@ -6120,7 +6251,7 @@ function createDriverAccessor(driver, slug, getPks = () => [], toViewModel) {
 			const startAfter = cursor ? cursorToStartAfter(cursor) : void 0;
 			const probeLimit = startAfter ? limit + 1 : limit;
 			const fetchService = driver.restFetchService;
-			const fetched = fetchService ? await fetchService.fetchCollectionForRest(slug, {
+			const fetched = fetchService ? await fetchService.fetchCollectionForRest(storedPath(), {
 				filter,
 				logical: params?.logical,
 				limit: probeLimit,
@@ -6131,7 +6262,7 @@ function createDriverAccessor(driver, slug, getPks = () => [], toViewModel) {
 				fields: params?.fields,
 				distinct: params?.distinct
 			}, params?.include) : await driver.fetchCollection({
-				path: slug,
+				path: storedPath(),
 				limit: probeLimit,
 				offset: startAfter ? void 0 : driverOffset,
 				startAfter,
@@ -6149,7 +6280,7 @@ function createDriverAccessor(driver, slug, getPks = () => [], toViewModel) {
 			let hasMore = seeking ? fetched.length > limit : rows.length >= limit;
 			if (driver.count) {
 				total = await driver.count({
-					path: slug,
+					path: storedPath(),
 					filter,
 					logical: params?.logical,
 					searchString: params?.searchString
@@ -6157,7 +6288,7 @@ function createDriverAccessor(driver, slug, getPks = () => [], toViewModel) {
 				if (!seeking) hasMore = offset + rows.length < total;
 			}
 			const last = rows[rows.length - 1];
-			const nextCursor = hasMore && last && driver.restFetchService?.cursorFor ? driver.restFetchService.cursorFor(slug, last, orderBy) : void 0;
+			const nextCursor = hasMore && last && driver.restFetchService?.cursorFor ? driver.restFetchService.cursorFor(storedPath(), last, orderBy) : void 0;
 			return {
 				data: rows.map((row) => rowToEntity(row, slug, getPks(), toViewModel)),
 				meta: {
@@ -6171,23 +6302,39 @@ function createDriverAccessor(driver, slug, getPks = () => [], toViewModel) {
 		},
 		async findById(id) {
 			const fetchService = driver.restFetchService;
-			const row = fetchService ? await fetchService.fetchOneForRest(slug, id) : await driver.fetchOne({
-				path: slug,
+			const row = fetchService ? await fetchService.fetchOneForRest(storedPath(), id) : await driver.fetchOne({
+				path: storedPath(),
 				id
 			});
 			return row ? rowToEntity(row, slug, getPks(), toViewModel) : void 0;
 		},
-		aggregate: driver.restFetchService?.aggregate ? async (params) => driver.restFetchService.aggregate(slug, {
-			aggregates: params.select.map(toDriverAggregate),
-			groupBy: params.groupBy,
-			filter: params.where ? deserializeFilter(params.where) : void 0,
-			logical: params.logical,
-			searchString: params.searchString,
-			limit: params.limit
-		}) : void 0,
+		aggregate: driver.restFetchService?.aggregate ? async (params) => {
+			const limit = (params.groupBy?.length ?? 0) > 0 ? params.limit : void 0;
+			const rows = await driver.restFetchService.aggregate(storedPath(), {
+				aggregates: params.select.map(toDriverAggregate),
+				groupBy: params.groupBy,
+				filter: params.where ? deserializeFilter(params.where) : void 0,
+				logical: params.logical,
+				searchString: params.searchString,
+				limit: limit !== void 0 ? limit + 1 : params.limit,
+				offset: params.offset
+			});
+			if (limit === void 0) return rows;
+			const page = rows.slice(0, limit);
+			const meta = {
+				limit,
+				offset: params.offset ?? 0,
+				hasMore: rows.length > limit
+			};
+			Object.defineProperty(page, "meta", {
+				value: meta,
+				enumerable: false
+			});
+			return page;
+		} : void 0,
 		async create(data, id) {
 			return rowToEntity(await driver.save({
-				path: slug,
+				path: storedPath(),
 				values: data,
 				id,
 				status: "new"
@@ -6195,7 +6342,7 @@ function createDriverAccessor(driver, slug, getPks = () => [], toViewModel) {
 		},
 		createMany: driver.saveMany ? async (data, options) => {
 			return (await driver.saveMany({
-				path: slug,
+				path: storedPath(),
 				rows: data,
 				upsert: options?.upsert,
 				onConflict: options?.onConflict
@@ -6203,7 +6350,7 @@ function createDriverAccessor(driver, slug, getPks = () => [], toViewModel) {
 		} : void 0,
 		async update(id, data) {
 			return rowToEntity(await driver.save({
-				path: slug,
+				path: storedPath(),
 				values: data,
 				id,
 				status: "existing"
@@ -6212,12 +6359,12 @@ function createDriverAccessor(driver, slug, getPks = () => [], toViewModel) {
 		async delete(id) {
 			return driver.delete({ row: {
 				id,
-				path: slug
+				path: storedPath()
 			} });
 		},
 		updateMany: driver.updateMany ? async (updates) => {
 			return (await driver.updateMany({
-				path: slug,
+				path: storedPath(),
 				updates: updates.map((u) => ({
 					id: u.id,
 					values: u.data
@@ -6226,14 +6373,14 @@ function createDriverAccessor(driver, slug, getPks = () => [], toViewModel) {
 		} : void 0,
 		deleteMany: driver.deleteMany ? async (ids) => {
 			await driver.deleteMany({
-				path: slug,
+				path: storedPath(),
 				ids
 			});
 		} : void 0,
 		count: driver.count ? async (params) => {
 			const filter = params?.where ? deserializeFilter(params.where) : void 0;
 			return driver.count({
-				path: slug,
+				path: storedPath(),
 				filter,
 				logical: params?.logical,
 				searchString: params?.searchString
@@ -6243,7 +6390,7 @@ function createDriverAccessor(driver, slug, getPks = () => [], toViewModel) {
 			const { limit, offset, driverOffset } = resolveFindWindow(params);
 			const normalize = driver.restFetchService ? inlineRelationRefs : (row) => row;
 			return driver.listenCollection({
-				path: slug,
+				path: storedPath(),
 				limit,
 				offset: driverOffset,
 				filter: params?.where,
@@ -6269,7 +6416,7 @@ function createDriverAccessor(driver, slug, getPks = () => [], toViewModel) {
 		listenById: driver.listenOne ? (id, onUpdate, onError) => {
 			const normalize = driver.restFetchService ? inlineRelationRefs : (row) => row;
 			return driver.listenOne({
-				path: slug,
+				path: storedPath(),
 				id,
 				onUpdate: (entity) => onUpdate(entity ? rowToEntity(normalize(entity), slug, getPks(), toViewModel) : void 0),
 				onError
@@ -6338,7 +6485,7 @@ function buildRebaseData(driver, options) {
 	function getAccessor(slug) {
 		let accessor = cache.get(slug);
 		if (!accessor) {
-			accessor = createDriverAccessor(driver, slug, () => primaryKeysFor(slug), viewModelFor(slug));
+			accessor = createDriverAccessor(driver, slug, () => primaryKeysFor(slug), viewModelFor(slug), () => options?.resolveDataPath?.(slug) ?? slug);
 			cache.set(slug, accessor);
 		}
 		return accessor;
@@ -6495,6 +6642,31 @@ var SdkQueryBuilder = class {
 	}
 };
 /**
+* Refuse a write option this door cannot honour, by name, before anything is
+* written.
+*
+* The in-process accessor implements the same `SDKCollectionClient` as the HTTP
+* client, whose `ifMatch` is "Honoured on `update` and `delete`" — and its
+* writes took no options at all, so `rebase.data.posts.update(id, data, {
+* ifMatch: staleEtag })` overwrote the row and resolved. A precondition the
+* caller wrote, dropped without a word, is the worst thing a door can do with
+* it. The driver's `save` has no precondition and no idempotency store to hand
+* these to, so they are refused rather than ignored. An `undefined` value is no
+* option, as it is over HTTP: `etagOf(row)` is `undefined` for a row that
+* carries no version, and that means "write unconditionally".
+*/
+function refuseUnhonouredWriteOptions(method, slug, options) {
+	const unsupported = ["ifMatch", "idempotencyKey"].filter((key) => options?.[key]);
+	if (unsupported.length === 0) return;
+	throw new RebaseClientError(`${method}() on "${slug}" in-process (context.data, rebase.data) cannot honour ${unsupported.join(" or ")}: this door has no ${unsupported.includes("ifMatch") ? "precondition check" : "idempotency store"}, and ignoring the option would write as though it had been checked. Drop it here, or send the write through the HTTP client, which honours it.`, {
+		code: "UNSUPPORTED_OPTION",
+		details: {
+			method,
+			options: unsupported
+		}
+	});
+}
+/**
 * Wrap a Entity-shaped {@link CollectionAccessor} into a flat
 * {@link SDKCollectionClient}. Every returned record is unwrapped to a flat row
 * so the backend SDK is byte-for-byte the same shape as the frontend client.
@@ -6526,14 +6698,19 @@ function toSdkCollectionClient(snap, slug = "collection") {
 			});
 			return entityToRow(s);
 		},
-		async create(data, id) {
+		async create(data, id, options) {
+			refuseUnhonouredWriteOptions("create", slug, options);
 			return entityToRow(await snap.create(data, id));
 		},
 		async createMany(data, options) {
+			refuseUnhonouredWriteOptions("createMany", slug, options);
 			if (!Array.isArray(data)) throw new TypeError("createMany expects an array of records.");
 			if (data.length === 0) return [];
 			if (!snap.createMany) throw new Error("Bulk writes are not supported by this collection's data source. Fall back to create() per record.");
-			return (await snap.createMany(data, options)).map(entityToRow);
+			return (await snap.createMany(data, {
+				upsert: options?.upsert,
+				onConflict: options?.onConflict
+			})).map(entityToRow);
 		},
 		/**
 		* One row through the bulk path, because the bulk path is where the
@@ -6545,6 +6722,7 @@ function toSdkCollectionClient(snap, slug = "collection") {
 		* one is exactly an upsert of one.
 		*/
 		async upsert(data, options) {
+			refuseUnhonouredWriteOptions("upsert", slug, options);
 			if (!snap.createMany) throw new Error("Upsert is not supported by this collection's data source: it needs a bulk write, which this driver does not implement. Fall back to create() or update().");
 			const row = (await snap.createMany([data], {
 				upsert: true,
@@ -6553,10 +6731,12 @@ function toSdkCollectionClient(snap, slug = "collection") {
 			if (!row) throw new Error(`Upsert into "${slug}" returned no row.`);
 			return entityToRow(row);
 		},
-		async update(id, data) {
+		async update(id, data, options) {
+			refuseUnhonouredWriteOptions("update", slug, options);
 			return entityToRow(await snap.update(id, data));
 		},
-		async updateMany(updates) {
+		async updateMany(updates, options) {
+			refuseUnhonouredWriteOptions("updateMany", slug, options);
 			if (!Array.isArray(updates)) throw new TypeError("updateMany expects an array of { id, data } entries.");
 			if (updates.length === 0) return [];
 			if (!snap.updateMany) throw new Error("Bulk updates are not supported by this collection's data source. Fall back to update() per record.");
@@ -6565,10 +6745,12 @@ function toSdkCollectionClient(snap, slug = "collection") {
 				data: u.data
 			})))).map(entityToRow);
 		},
-		delete(id) {
+		async delete(id, options) {
+			refuseUnhonouredWriteOptions("delete", slug, options);
 			return snap.delete(id);
 		},
-		async deleteMany(ids) {
+		async deleteMany(ids, options) {
+			refuseUnhonouredWriteOptions("deleteMany", slug, options);
 			if (!Array.isArray(ids)) throw new TypeError("deleteMany expects an array of ids.");
 			if (ids.length === 0) return;
 			if (!snap.deleteMany) throw new Error("Bulk deletes are not supported by this collection's data source. Fall back to delete() per record.");
@@ -6683,6 +6865,6 @@ function buildRoutedRebaseData({ defaultData, sources, resolveKey }) {
 }
 new Set(REBASE_INTERNAL_TABLES);
 //#endregion
-export { toSnakeCase as $, createDataSourceRegistry as A, fieldKeyForColumn as B, cursorToStartAfter as C, restrictedFieldNames as D, effectiveAccess as E, revokeInternalTableSql as F, resolveCollectionRelations as G, getTableName as H, getJunctionConfigForRelation as I, resolvePrimaryKeys as J, enumToObjectEntries as K, getEffectiveSecurityRules as L, resolveDataSource as M, authSecretsMissingExclusion as N, assertBeforeQueryIsPostgresOnly as O, REBASE_USER_ROLE as P, suggestNearMiss as Q, getTenantConfig as R, CursorMismatchError as S, reconcileCursorOrder as T, isRelationRequired as U, findRelation as V, relationDeclaringProperty as W, isObject as X, hydrateRegExp as Y, splitSearchTerms as Z, topLevelIncludeNames as _, Vector as _t, deserializeFilter as a, FIELD_OPERATORS as at, serializeOrderBy as b, isUnsupported as bt, serializeLogicalCondition as c, ANONYMOUS_USER_ID as ct, resolveFindWindow as d, hasForeignKeyOnTarget as dt, unref as et, IncludeSpecError as f, isManyToMany as ft, serializeInclude as g, GeoPoint as gt, normalizeInclude as h, EntityRelation as ht, UnknownFilterOperatorError as i, BATCH_REF_KEY as it, isRelationalCollection as j, CollectionRegistry as k, collectAllPages as l, isAnonymousUid as lt, mergeIncludeSpecs as m, EntityReference as mt, buildSdkData as n, MAX_LIST_LIMIT as nt, deserializeLogicalCondition as o, hasFieldOperation as ot, deserializeInclude as p, isToMany as pt, buildCompositeId as q, RESERVED_QUERY_KEYS as r, resolveClientListLimit as rt, serializeFilter as s, isFieldOperation as st, buildRoutedRebaseData as t, ListLimitError as tt, paginateFind as u, JUNCTION_PIVOT_KEY as ut, OrderBySpecError as v, RebaseApiError as vt, decodeCursor as w, CursorError as x, unsupportedMethod as xt, normalizeOrderBy as y, RebaseClientError as yt, securityRuleToConditions as z };
+export { unref as $, isRelationalCollection as A, findRelation as B, decodeCursor as C, assertBeforeQueryIsPostgresOnly as D, restrictedFieldNames as E, getJunctionConfigForRelation as F, enumToObjectEntries as G, isRelationRequired as H, getEffectiveSecurityRules as I, hydrateRegExp as J, buildCompositeId as K, getTenantConfig as L, authSecretsMissingExclusion as M, REBASE_USER_ROLE as N, CollectionRegistry as O, revokeInternalTableSql as P, toSnakeCase as Q, securityRuleToConditions as R, cursorToStartAfter as S, effectiveAccess as T, relationDeclaringProperty as U, getTableName as V, resolveCollectionRelations as W, splitSearchTerms as X, isObject as Y, suggestNearMiss as Z, OrderBySpecError as _, RebaseApiError as _t, deserializeFilter as a, hasFieldOperation as at, CursorError as b, unsupportedMethod as bt, serializeLogicalCondition as c, isAnonymousUid as ct, resolveFindWindow as d, isManyToMany as dt, ListLimitError as et, IncludeSpecError as f, isToMany as ft, serializeInclude as g, Vector as gt, normalizeInclude as h, GeoPoint as ht, UnknownFilterOperatorError as i, FIELD_OPERATORS as it, resolveDataSource as j, createDataSourceRegistry as k, collectAllPages as l, JUNCTION_PIVOT_KEY as lt, mergeIncludeSpecs as m, EntityRelation as mt, buildSdkData as n, resolveClientListLimit as nt, deserializeLogicalCondition as o, isFieldOperation as ot, deserializeInclude as p, EntityReference as pt, resolvePrimaryKeys as q, RESERVED_QUERY_KEYS as r, BATCH_REF_KEY as rt, serializeFilter as s, ANONYMOUS_USER_ID as st, buildRoutedRebaseData as t, MAX_LIST_LIMIT as tt, paginateFind as u, hasForeignKeyOnTarget as ut, normalizeOrderBy as v, RebaseClientError as vt, reconcileCursorOrder as w, CursorMismatchError as x, serializeOrderBy as y, isUnsupported as yt, fieldKeyForColumn as z };
 
-//# sourceMappingURL=src-pmvW7BFx.js.map
+//# sourceMappingURL=src-I3aG1PcY.js.map