@rebasepro/server 0.22.0 → 0.24.0

package/dist/{src-1vL-I1Po.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 LIST_OPS, C as getDeclaredSubcollections, D as getDataSourceCapabilities, F as sortKeyToString, I as toCanonicalOp, M as REST_TO_CANONICAL, N as isRelationAggregateSort, O as ALL_WHERE_FILTER_OPS, T as isRelationalCollectionConfig, j as NULL_OPS, k as CANONICAL_TO_REST, p as resolveResourceRefs, w as isPostgresCollectionConfig, x as rewriteLegacyRlsFunctions } from "./src-Br6ARbs6.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 —
@@ -261,6 +261,10 @@ var Vector = class {
 */
 var JUNCTION_PIVOT_KEY = "_pivot";
 /** @group Models */
+function hasForeignKeyOnTarget(relation) {
+	return relation.kind === "hasOne" || relation.kind === "hasMany";
+}
+/** @group Models */
 function isManyToMany(relation) {
 	return relation.kind === "manyToMany";
 }
@@ -3266,6 +3270,7 @@ var REBASE_INTERNAL_TABLES = [
 	"api_keys",
 	"cron_logs",
 	"cron_claims",
+	"cron_job_state",
 	"jobs",
 	"rate_limit_hits",
 	"idempotency_keys",
@@ -4013,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();
@@ -4037,6 +4049,7 @@ var CollectionRegistry = class {
 	reset() {
 		this.collectionsByTableName.clear();
 		this.collectionsBySlug.clear();
+		this.collectionsByDataPath.clear();
 		this.rootCollections = [];
 		this.cachedCollectionsList = null;
 		this.rawCollectionsByTableName.clear();
@@ -4069,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) => {
@@ -4086,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;
@@ -4139,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("-")) {
@@ -4147,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.
@@ -4195,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,
@@ -4226,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
 /**
@@ -4317,18 +4470,36 @@ function canWriteField(property, viewer) {
 * who knows the table can send `password_hash` as readily as `passwordHash`, and
 * a rule that only knew the wire name would be one rename away from useless.
 *
+* A restricted to-one relation takes its foreign key with it. `bandId: 7` names
+* the band exactly as `band: { id: 7 }` does, and the row carries the column
+* beside the relation — so a rule on the relation that left the key alone
+* withheld the value from the row and still let `?bandId=7` ask for it.
+*
 * `kind` picks which half of the rule is read; nothing else differs.
 */
 function restrictedFieldNames(collection, viewer, kind) {
 	const declared = [];
 	const refused = /* @__PURE__ */ new Set();
 	const allowed = kind === "read" ? canReadField : canWriteField;
-	for (const [name, property] of Object.entries(collection.properties ?? {})) {
-		if (allowed(property, viewer)) continue;
-		declared.push(name);
+	const properties = collection.properties ?? {};
+	let relations;
+	const restrict = (name) => {
+		if (name in properties && !declared.includes(name)) declared.push(name);
 		refused.add(name);
+	};
+	for (const [name, property] of Object.entries(properties)) {
+		if (allowed(property, viewer)) continue;
+		restrict(name);
 		const columnName = property.columnName;
 		if (columnName) refused.add(columnName);
+		if (property.type === "relation") {
+			relations ??= resolveCollectionRelations(collection);
+			const relation = findRelation(relations, name);
+			if (relation?.kind === "belongsTo") {
+				restrict(fieldKeyForColumn(collection, relation.localKey));
+				refused.add(relation.localKey);
+			}
+		}
 	}
 	return {
 		declared,
@@ -4762,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));
@@ -5094,19 +5248,23 @@ function normalizeMaxRows(raw) {
 * @param label  the collection name, so an error says which walk failed
 */
 async function* paginateFind(find, params, label = "collection") {
-	const { pageSize, cursor, maxPages, ...rest } = params ?? {};
+	const { pageSize, cursor, maxPages, after: startAfter, offset: startOffset, page: startPage, ...rest } = params ?? {};
 	const findParams = { ...rest };
 	const size = normalizePageSize(pageSize);
 	const pageCap = normalizeMaxPages(maxPages);
-	const seekRequested = cursor !== void 0 && cursor !== null;
-	if (seekRequested) {
+	const seekRequested = cursor !== void 0 && cursor !== null || !!startAfter;
+	if (cursor !== void 0 && cursor !== null) {
 		const field = typeof cursor === "string" ? cursor : cursor.field;
 		const requested = typeof cursor === "object" && cursor !== null ? cursor.direction : void 0;
 		if (!normalizeOrderBy(findParams.orderBy)) findParams.orderBy = [field, requested ?? "asc"];
 	}
-	let offset = 0;
+	let offset = resolveFindWindow({
+		limit: size,
+		offset: startOffset,
+		page: startPage
+	}).offset;
 	let pages = 0;
-	let after;
+	let after = startAfter || void 0;
 	for (;;) {
 		if (pages >= pageCap) throw new RebasePaginationError("max-pages", `Iterating "${label}" made ${pages} requests without the server reporting the end of the collection. Stopping rather than looping forever — raise \`maxPages\` if the walk is genuinely this long, or check that the backend sets \`meta.hasMore\`.`);
 		const pageParams = {
@@ -5171,9 +5329,16 @@ async function collectAllPages(find, params, label = "collection") {
 * Relation values (`EntityRelation` instances or `{ __type: "relation", id, path }`
 * objects) are serialized as their raw id — the wire format only carries the
 * value to compare against the FK column.
+*
+* A `Date` is its ISO 8601 instant — what JSON makes of it on the socket and
+* in-process, so one filter names one instant through every door. `String()`
+* gave the viewer's local zone, no milliseconds and a parenthesised zone name
+* Postgres cannot parse. An invalid date keeps its "Invalid Date" spelling for
+* the server to refuse, rather than throwing a `RangeError` from here.
 */
 function stringifyValue(value) {
 	if (value === null) return "null";
+	if (value instanceof Date && !Number.isNaN(value.getTime())) return value.toISOString();
 	const relation = normalizeToEntityRelation(value);
 	if (relation) return String(relation.id);
 	return String(value);
@@ -5231,6 +5396,41 @@ function unescapeWireValue(value) {
 	return result;
 }
 /**
+* Whether a scalar, sent raw as a query parameter's operand, would be read
+* back as something other than itself.
+*
+* A query parameter owns its whole value, so its scalar goes out unescaped —
+* `eq.a,b`, `eq.C:\x` — and the decoder returns it verbatim. Two shapes break
+* that. A parenthesised operand is a list for every operator (so that
+* `["==", ["a","b"]]` on an array column stays a list), so raw, the scalar
+* `"(deleted)"` would arrive as `["deleted"]`: an `==` matching nothing, a
+* `!=` returning the very rows it excludes. Such a scalar is sent escaped,
+* `eq.\(deleted\)`. And that spelling has to be told apart from a raw value
+* that looks the same, so a scalar of *that* shape is escaped in turn.
+*
+* Everything else stays raw, so a value an older client sends decodes as it
+* always has — unless it is exactly the escaped spelling of such a scalar,
+* which decodes to the scalar it spells.
+*/
+function scalarNeedsEscape(value) {
+	if (value.startsWith("(") && value.endsWith(")")) return true;
+	return decodeEscapedScalar(value) !== void 0;
+}
+/**
+* The scalar an operand is the escaped spelling of, when it is one.
+*
+* Exact on purpose: only an operand that {@link escapeWireValue} produces from
+* a scalar that {@link scalarNeedsEscape} is decoded. Any other operand —
+* including a raw backslash an older client sent, like `\\server\share` — is
+* left verbatim. Terminates because an operand that matches contains an
+* escape pair, so the value is strictly shorter than it.
+*/
+function decodeEscapedScalar(operand) {
+	if (!operand.startsWith("\\")) return void 0;
+	const value = unescapeWireValue(operand);
+	return escapeWireValue(value) === operand && scalarNeedsEscape(value) ? value : void 0;
+}
+/**
 * Split a parenthesized list string on unescaped commas.
 * Input is the content between `(` and `)`.
 *
@@ -5475,6 +5675,42 @@ function readTuple(field, raw) {
 	if (isOperatorShaped(op)) throw new UnknownFilterOperatorError(field, op);
 }
 /**
+* The query-parameter names a REST listing reads as something other than a
+* field filter: pagination, sorting, includes, projection, search, the logical
+* groups, the JSON `where` dialect, an aggregate's `select`/`groupBy`, and the
+* soft-delete switches.
+*
+* One list for both ends. The server skips these names when it collects
+* `?<field>=<op>.<value>` filters, and the SDK sends a filter on a column with
+* one of these names inside `?where=` instead — a collection is free to have a
+* `page`, `select` or `hard` column, and a filter on it sent as its own
+* parameter was read as the parameter and never applied.
+*/
+var RESERVED_QUERY_KEYS = /* @__PURE__ */ new Set([
+	"limit",
+	"offset",
+	"page",
+	"after",
+	"orderBy",
+	"include",
+	"fields",
+	"distinct",
+	"searchString",
+	"searchExplain",
+	"vector_search",
+	"vector",
+	"vector_distance",
+	"vector_threshold",
+	"or",
+	"and",
+	"not",
+	"where",
+	"select",
+	"groupBy",
+	"deleted",
+	"hard"
+]);
+/**
 * Encode the `<op>.<value>` half of a wire condition.
 *
 * This is the single leaf encoder. Both wire positions that carry a condition
@@ -5502,7 +5738,7 @@ function serializeOperatorAndValue(op, value, { escapeScalar, where }) {
 		return `${restOp}.(${value.map((v) => escapeWireValue(stringifyValue(v))).join(",")})`;
 	}
 	const scalar = stringifyValue(value);
-	return `${restOp}.${escapeScalar ? escapeWireValue(scalar) : scalar}`;
+	return `${restOp}.${escapeScalar || !LIST_OPS.has(op) && scalarNeedsEscape(scalar) ? escapeWireValue(scalar) : scalar}`;
 }
 /**
 * Serialize a single canonical condition tuple to a PostgREST dot-string.
@@ -5598,7 +5834,10 @@ var NULL_OPERANDS = /* @__PURE__ */ new Set([
 *   operand: only {@link NULL_OPERANDS}. `notnull.reason` is the value
 *   `"notnull.reason"`, not "reason is not null".
 * - **Everything else** takes one scalar, and any remainder is one — including
-*   the empty string, so `eq.` really is "equals the empty string".
+*   the empty string, so `eq.` really is "equals the empty string". A
+*   parenthesised remainder is a list for these too (`eq.(a,b)` is array
+*   equality); a scalar that is itself parenthesised arrives escaped,
+*   `eq.\(none\)`, and is decoded here — see {@link scalarNeedsEscape}.
 *
 * ### The one ambiguity that remains, and how to write past it
 *
@@ -5633,7 +5872,7 @@ function deserializeSingle(raw) {
 		return [canonicalOp, inner === EMPTY_LIST_TOKEN ? [] : splitListItems(inner)];
 	}
 	if (LIST_OPS.has(canonicalOp)) return ["==", raw];
-	return [canonicalOp, rest];
+	return [canonicalOp, decodeEscapedScalar(rest) ?? rest];
 }
 /**
 * Convert a PostgREST-style querystring record to `FilterValues`.
@@ -6002,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;
@@ -6012,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,
@@ -6023,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,
@@ -6041,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
@@ -6049,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: {
@@ -6063,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"
@@ -6087,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
@@ -6095,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"
@@ -6104,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
@@ -6118,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
@@ -6135,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,
@@ -6161,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
@@ -6230,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;
@@ -6387,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.
@@ -6418,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
@@ -6437,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,
@@ -6445,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.");
@@ -6457,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.");
@@ -6575,6 +6865,6 @@ function buildRoutedRebaseData({ defaultData, sources, resolveKey }) {
 }
 new Set(REBASE_INTERNAL_TABLES);
 //#endregion
-export { ListLimitError as $, createDataSourceRegistry as A, fieldKeyForColumn as B, decodeCursor as C, restrictedFieldNames as D, effectiveAccess as E, revokeInternalTableSql as F, enumToObjectEntries as G, getTableName as H, getJunctionConfigForRelation as I, hydrateRegExp as J, buildCompositeId as K, getEffectiveSecurityRules as L, resolveDataSource as M, authSecretsMissingExclusion as N, assertBeforeQueryIsPostgresOnly as O, REBASE_USER_ROLE as P, unref as Q, getTenantConfig as R, cursorToStartAfter as S, canWriteField as T, isRelationRequired as U, findRelation as V, resolveCollectionRelations as W, suggestNearMiss as X, splitSearchTerms as Y, toSnakeCase as Z, OrderBySpecError as _, isUnsupported as _t, deserializeLogicalCondition as a, isFieldOperation as at, CursorError as b, collectAllPages as c, JUNCTION_PIVOT_KEY as ct, IncludeSpecError as d, EntityReference as dt, MAX_LIST_LIMIT as et, deserializeInclude as f, EntityRelation as ft, topLevelIncludeNames as g, RebaseClientError as gt, serializeInclude as h, RebaseApiError as ht, deserializeFilter as i, hasFieldOperation as it, isRelationalCollection as j, CollectionRegistry as k, paginateFind as l, isManyToMany as lt, normalizeInclude as m, Vector as mt, buildSdkData as n, BATCH_REF_KEY as nt, serializeFilter as o, ANONYMOUS_USER_ID as ot, mergeIncludeSpecs as p, GeoPoint as pt, resolvePrimaryKeys as q, UnknownFilterOperatorError as r, FIELD_OPERATORS as rt, serializeLogicalCondition as s, isAnonymousUid as st, buildRoutedRebaseData as t, resolveClientListLimit as tt, resolveFindWindow as u, isToMany as ut, normalizeOrderBy as v, unsupportedMethod as vt, reconcileCursorOrder as w, CursorMismatchError as x, serializeOrderBy as y, 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-1vL-I1Po.js.map
+//# sourceMappingURL=src-I3aG1PcY.js.map