@rebasepro/common 0.9.0 → 0.9.1-canary.0fce67c

package/dist/index.umd.js

@@ -1,3311 +0,0 @@
-(function(global, factory) {
-	typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("@rebasepro/types"), require("@rebasepro/utils"), require("json-logic-js"), require("fast-equals")) : typeof define === "function" && define.amd ? define([
-		"exports",
-		"@rebasepro/types",
-		"@rebasepro/utils",
-		"json-logic-js",
-		"fast-equals"
-	], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global["Rebase Util"] = {}, global._rebasepro_types, global._rebasepro_utils, global.jsonLogic, global.fastEquals));
-})(this, function(exports, _rebasepro_types, _rebasepro_utils, json_logic_js, fast_equals) {
-	Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-	//#region \0rolldown/runtime.js
-	var __create = Object.create;
-	var __defProp = Object.defineProperty;
-	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-	var __getOwnPropNames = Object.getOwnPropertyNames;
-	var __getProtoOf = Object.getPrototypeOf;
-	var __hasOwnProp = Object.prototype.hasOwnProperty;
-	var __copyProps = (to, from, except, desc) => {
-		if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-			key = keys[i];
-			if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-				get: ((k) => from[k]).bind(null, key),
-				enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-			});
-		}
-		return to;
-	};
-	var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-		value: mod,
-		enumerable: true
-	}) : target, mod));
-	//#endregion
-	json_logic_js = __toESM(json_logic_js, 1);
-	//#region src/util/common.ts
-	var DEFAULT_ONE_OF_TYPE = "type";
-	var DEFAULT_ONE_OF_VALUE = "value";
-	//#endregion
-	//#region src/util/entities.ts
-	function isReadOnly(property) {
-		if (property.ui?.readOnly) return true;
-		if (property.type === "date") {
-			if (property.autoValue) return true;
-		}
-		if (property.type === "reference") return !property.path && !("Field" in (property.ui || {}) && property.ui?.Field);
-		return false;
-	}
-	function isHidden(property) {
-		return typeof property.ui?.disabled === "object" && Boolean(property.ui?.disabled.hidden);
-	}
-	function isPropertyBuilder(property) {
-		return typeof property?.dynamicProps === "function";
-	}
-	function getDefaultValuesFor(properties) {
-		if (!properties) return {};
-		return Object.entries(properties).map(([key, property]) => {
-			if (!property) return {};
-			const value = getDefaultValueFor(property);
-			return value === void 0 ? {} : { [key]: value };
-		}).reduce((a, b) => ({
-			...a,
-			...b
-		}), {});
-	}
-	function getDefaultValueFor(property) {
-		if (!property) return void 0;
-		if (isPropertyBuilder(property)) return void 0;
-		if (property.defaultValue || property.defaultValue === null) return property.defaultValue;
-		else if (property.type === "map" && property.properties) {
-			const defaultValuesFor = getDefaultValuesFor(property.properties);
-			if (Object.keys(defaultValuesFor).length === 0) return void 0;
-			return defaultValuesFor;
-		} else return getDefaultValueFortype(property.type);
-	}
-	function getDefaultValueFortype(type) {
-		if (type === "string") return null;
-		else if (type === "number") return null;
-		else if (type === "boolean") return false;
-		else if (type === "date") return null;
-		else if (type === "array") return [];
-		else if (type === "map") return {};
-		else if (type === "vector") return null;
-		else if (type === "binary") return null;
-		else return null;
-	}
-	/**
-	* Update the automatic values in a entity before save
-	* @group Driver
-	*/
-	function updateDateAutoValues({ inputValues, properties, status, timestampNowValue }) {
-		return traverseValuesProperties(inputValues, properties, (inputValue, property) => {
-			if (property.type === "date") if (status === "existing" && property.autoValue === "on_update") return timestampNowValue;
-			else if ((status === "new" || status === "copy") && (property.autoValue === "on_update" || property.autoValue === "on_create")) return timestampNowValue;
-			else return inputValue;
-			else return inputValue;
-		}) ?? {};
-	}
-	/**
-	* Add missing required fields, expected in the collection, to the values of a entity
-	* @param values
-	* @param properties
-	* @group Driver
-	*/
-	function sanitizeData(values, properties) {
-		const result = values;
-		Object.entries(properties).forEach(([key, property]) => {
-			if (values && values[key] !== void 0) result[key] = values[key];
-			else if (property.validation?.required) result[key] = null;
-		});
-		return result;
-	}
-	function getReferenceFrom(entity) {
-		if (typeof entity.id !== "string") throw new Error("Only string IDs are supported in references");
-		return new _rebasepro_types.EntityReference({
-			id: entity.id,
-			path: entity.path,
-			driver: entity.driver,
-			databaseId: entity.databaseId
-		});
-	}
-	function getRelationFrom(entity) {
-		return new _rebasepro_types.EntityRelation(entity.id, entity.path, entity);
-	}
-	/**
-	* Normalize a value into a proper EntityRelation instance.
-	* Handles EntityRelation class instances, and plain objects
-	* with `__type === "relation"` or an `isEntityRelation()` method.
-	*
-	* When `propertyType` is `"relation"`, also accepts plain objects that
-	* have `id` and `path` fields — these are relation-shaped objects from
-	* edge cases in the data pipeline (REST fallback, stale cache, custom data source).
-	*
-	* Returns null if the value cannot be coerced.
-	*/
-	function normalizeToEntityRelation(value, propertyType) {
-		if (value instanceof _rebasepro_types.EntityRelation) return value;
-		if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-		const obj = value;
-		if (!(obj.__type === "relation" || obj.__type === "reference" || typeof obj.isEntityRelation === "function" && obj.isEntityRelation() || typeof obj.isEntityReference === "function" && obj.isEntityReference() || propertyType === "relation" && typeof obj.id !== "undefined" && typeof obj.path === "string")) return null;
-		return new _rebasepro_types.EntityRelation(obj.id, obj.path, obj.data);
-	}
-	function traverseValuesProperties(inputValues, properties, operation) {
-		const safeInputValues = inputValues ?? {};
-		const result = (0, _rebasepro_utils.mergeDeep)(safeInputValues, Object.entries(properties).map(([key, property]) => {
-			const updatedValue = traverseValueProperty(safeInputValues && safeInputValues[key], property, operation);
-			if (updatedValue === null) return null;
-			if (updatedValue === void 0) return void 0;
-			return { [key]: updatedValue };
-		}).reduce((a, b) => ({
-			...a,
-			...b
-		}), {}));
-		if (!result || Object.keys(result).length === 0) return void 0;
-		return result;
-	}
-	function traverseValueProperty(inputValue, property, operation) {
-		let value;
-		if (property.type === "map" && property.properties) value = traverseValuesProperties(inputValue, property.properties, operation);
-		else if (property.type === "array") {
-			const of = property.of;
-			if (of && Array.isArray(inputValue) && !Array.isArray(of)) value = inputValue.map((e) => traverseValueProperty(e, of, operation));
-			else if (of && Array.isArray(inputValue) && Array.isArray(of)) value = inputValue.map((e, i) => {
-				if (i < of.length) return traverseValueProperty(e, of[i], operation);
-				return null;
-			}).filter(Boolean);
-			else if (property.oneOf && Array.isArray(inputValue)) {
-				const typeField = property.oneOf?.typeField ?? "type";
-				const valueField = property.oneOf?.valueField ?? "value";
-				value = inputValue.map((e) => {
-					if (e === null) return null;
-					if (typeof e !== "object") return e;
-					const rec = e;
-					const type = rec[typeField];
-					const childProperty = property.oneOf?.properties[type];
-					if (!type || !childProperty) return e;
-					return {
-						[typeField]: type,
-						[valueField]: traverseValueProperty(rec[valueField], childProperty, operation)
-					};
-				});
-			} else value = inputValue;
-		} else value = operation(inputValue, property);
-		return value;
-	}
-	/**
-	* Create a lightweight relation stub for CMS views.
-	* Replaces inline `{ id, path, __type: "relation" }` object literals.
-	*/
-	function createRelationRef(id, path) {
-		return {
-			id,
-			path,
-			__type: "relation"
-		};
-	}
-	/**
-	* Create a hydrated relation reference that includes the full entity data.
-	* Used when entity data has been pre-fetched (e.g., via batch loading or JOINs).
-	*/
-	function createRelationRefWithData(id, path, data) {
-		return {
-			id,
-			path,
-			__type: "relation",
-			data
-		};
-	}
-	//#endregion
-	//#region src/util/collections.ts
-	function sortProperties(properties, propertiesOrder) {
-		try {
-			const propertiesKeys = Object.keys(properties);
-			if (!propertiesOrder || propertiesOrder.length === 0) return propertiesKeys.map((key) => {
-				const property = properties[key];
-				if (!isPropertyBuilder(property) && property?.type === "map" && property.properties) return { [key]: {
-					...property,
-					properties: sortProperties(property.properties, property.propertiesOrder)
-				} };
-				else return { [key]: property };
-			}).reduce((a, b) => ({
-				...a,
-				...b
-			}), {});
-			const validOrderKeys = propertiesOrder.filter((key) => {
-				return !key.includes(".") && properties[key];
-			});
-			const processedKeys = new Set(validOrderKeys);
-			const orderedResult = validOrderKeys.map((key) => {
-				const property = properties[key];
-				if (!isPropertyBuilder(property) && property?.type === "map" && property.properties) return { [key]: {
-					...property,
-					properties: sortProperties(property.properties, property.propertiesOrder)
-				} };
-				else return { [key]: property };
-			}).reduce((a, b) => ({
-				...a,
-				...b
-			}), {});
-			const missingProperties = propertiesKeys.filter((key) => !processedKeys.has(key)).map((key) => {
-				const property = properties[key];
-				if (!isPropertyBuilder(property) && property?.type === "map" && property.properties) return { [key]: {
-					...property,
-					properties: sortProperties(property.properties, property.propertiesOrder)
-				} };
-				else return { [key]: property };
-			}).reduce((a, b) => ({
-				...a,
-				...b
-			}), {});
-			return {
-				...orderedResult,
-				...missingProperties
-			};
-		} catch (e) {
-			console.error("Error sorting properties", e);
-			return properties;
-		}
-	}
-	function resolveDefaultSelectedView(defaultSelectedView, params) {
-		if (!defaultSelectedView) return;
-		else if (typeof defaultSelectedView === "string") return defaultSelectedView;
-		else return defaultSelectedView(params);
-	}
-	function getLocalChangesBackup(collection) {
-		if (!collection.localChangesBackup) return "manual_apply";
-		return collection.localChangesBackup;
-	}
-	/**
-	* Returns the primary keys for a entity collection by inspecting the properties
-	* and finding any properties with `isId`.
-	* Fallbacks to `["id"]` if no properties are marked as `isId: true`.
-	* @param collection
-	*/
-	function getPrimaryKeys(collection) {
-		const properties = collection.properties;
-		if (!properties) return ["id"];
-		const ids = Object.entries(properties).filter(([key, prop]) => typeof prop === "object" && prop !== null && "isId" in prop && Boolean(prop.isId)).map(([key]) => key);
-		if (ids.length > 0) return ids;
-		return ["id"];
-	}
-	//#endregion
-	//#region src/util/enums.ts
-	function enumToObjectEntries(enumValues) {
-		if (Array.isArray(enumValues)) return enumValues;
-		else return Object.entries(enumValues).map(([id, value]) => {
-			if (typeof value === "string") return {
-				id,
-				label: value
-			};
-			else return {
-				...value,
-				id
-			};
-		});
-	}
-	function getLabelOrConfigFrom(enumValues, key) {
-		if (key === null || key === void 0) return void 0;
-		return enumValues.find((entry) => String(entry.id) === String(key));
-	}
-	//#endregion
-	//#region src/util/paths.ts
-	var COLLECTION_PATH_SEPARATOR = "::";
-	/**
-	* Remove the entity ids from a given path
-	* `products/B44RG6APH/locales` => `products::locales`
-	* @param path
-	*/
-	function stripCollectionPath(path) {
-		return segmentsToStrippedPath(fullPathToCollectionSegments(path));
-	}
-	function segmentsToStrippedPath(paths) {
-		if (paths.length === 1) return paths[0];
-		return paths.reduce((a, b) => `${a}::${b}`);
-	}
-	/**
-	* Extract the collection path routes
-	* `products/B44RG6APH/locales` => [`products`, `locales`]
-	* @param path
-	*/
-	function fullPathToCollectionSegments(path) {
-		return path.split("/").filter((e, i) => i % 2 === 0);
-	}
-	//#endregion
-	//#region src/util/relations.ts
-	function sanitizeRelation(relation, sourceCollection, resolveCollection) {
-		if (!relation.target) throw new Error("Relation is missing a `target` collection.");
-		const rawTarget = relation.target;
-		let targetCollection;
-		if (typeof rawTarget === "string") {
-			if (resolveCollection) targetCollection = resolveCollection(rawTarget);
-			if (!targetCollection) targetCollection = {
-				slug: rawTarget,
-				name: rawTarget
-			};
-		} else if (typeof rawTarget === "function") {
-			const evaluated = rawTarget();
-			if (typeof evaluated === "string") {
-				if (resolveCollection) targetCollection = resolveCollection(evaluated);
-				if (!targetCollection) targetCollection = {
-					slug: evaluated,
-					name: evaluated
-				};
-			} else targetCollection = evaluated;
-		} else if (rawTarget && typeof rawTarget === "object") targetCollection = rawTarget;
-		if (!targetCollection) throw new Error("Relation is missing a valid `target` collection.");
-		const newRelation = { ...relation };
-		newRelation.target = () => {
-			if (typeof rawTarget === "string") return resolveCollection && resolveCollection(rawTarget) || targetCollection;
-			else if (typeof rawTarget === "function") {
-				const evaluated = rawTarget();
-				if (typeof evaluated === "string") return resolveCollection && resolveCollection(evaluated) || targetCollection;
-				return evaluated;
-			}
-			return targetCollection;
-		};
-		if (!newRelation.relationName) newRelation.relationName = (0, _rebasepro_utils.toSnakeCase)(targetCollection.slug);
-		if (!newRelation.direction) if (newRelation.foreignKeyOnTarget) newRelation.direction = "inverse";
-		else if (newRelation.through) newRelation.direction = "owning";
-		else if (newRelation.cardinality === "many") newRelation.direction = "inverse";
-		else newRelation.direction = "owning";
-		if (!newRelation.joinPath) {
-			const sourceName = (0, _rebasepro_utils.toSnakeCase)(sourceCollection.slug ?? sourceCollection.name);
-			if (newRelation.cardinality === "one" && newRelation.direction === "owning") {
-				if (!newRelation.localKey) newRelation.localKey = (0, _rebasepro_utils.generateForeignKeyName)(newRelation.relationName);
-			} else if (newRelation.cardinality === "one" && newRelation.direction === "inverse") {
-				if (!newRelation.foreignKeyOnTarget) {
-					let foundForeignKey = false;
-					try {
-						const targetRelations = (0, _rebasepro_types.getDataSourceCapabilities)(targetCollection.engine).supportsRelations ? targetCollection.relations || [] : [];
-						for (const targetRel of targetRelations) if (targetRel.direction === "owning" && targetRel.cardinality === "one" && targetRel.localKey) try {
-							if (targetRel.target().slug === sourceCollection.slug) {
-								newRelation.foreignKeyOnTarget = targetRel.localKey;
-								foundForeignKey = true;
-								break;
-							}
-						} catch (e) {
-							continue;
-						}
-					} catch (e) {}
-					if (!foundForeignKey) newRelation.foreignKeyOnTarget = (0, _rebasepro_utils.generateForeignKeyName)(newRelation.inverseRelationName ? (0, _rebasepro_utils.toSnakeCase)(newRelation.inverseRelationName) : sourceName);
-				}
-			} else if (newRelation.cardinality === "many" && newRelation.direction === "inverse") {
-				let isManyToManyInverse = false;
-				if (newRelation.inverseRelationName && !newRelation.foreignKeyOnTarget) try {
-					const targetRelations = (0, _rebasepro_types.getDataSourceCapabilities)(targetCollection.engine).supportsRelations ? targetCollection.relations || [] : [];
-					for (const targetRel of targetRelations) if (targetRel.cardinality === "many" && (targetRel.direction === "owning" || !targetRel.direction) && targetRel.relationName === newRelation.inverseRelationName) {
-						isManyToManyInverse = true;
-						break;
-					}
-					if (!isManyToManyInverse && targetCollection.properties) for (const [propKey, prop] of Object.entries(targetCollection.properties)) {
-						if (prop.type !== "relation") continue;
-						const relProp = prop;
-						if ((relProp.relationName || propKey) === newRelation.inverseRelationName && relProp.cardinality === "many" && (relProp.direction === "owning" || !relProp.direction)) {
-							isManyToManyInverse = true;
-							break;
-						}
-					}
-				} catch (e) {}
-				if (!isManyToManyInverse && !newRelation.foreignKeyOnTarget) newRelation.foreignKeyOnTarget = (0, _rebasepro_utils.generateForeignKeyName)(sourceName);
-			} else if (newRelation.cardinality === "many" && newRelation.direction === "owning") {
-				const sourceTableName = getTableName(sourceCollection);
-				const targetTableName = getTableName(targetCollection);
-				newRelation.through = {
-					table: newRelation.through?.table ?? [sourceTableName, targetTableName].sort().join("_"),
-					sourceColumn: newRelation.through?.sourceColumn ?? (0, _rebasepro_utils.generateForeignKeyName)(sourceName),
-					targetColumn: newRelation.through?.targetColumn ?? (0, _rebasepro_utils.generateForeignKeyName)(newRelation.relationName)
-				};
-			}
-		}
-		if (newRelation.cardinality === "one" && newRelation.direction === "owning" && !newRelation.localKey && !newRelation.joinPath) throw new Error(`Configuration Error in relation from '${sourceCollection.name}': An 'owning' one-to-one relation requires a 'localKey'. Check the relation config for '${newRelation.relationName}'`);
-		if (newRelation.cardinality === "one" && newRelation.direction === "inverse" && !newRelation.foreignKeyOnTarget && !newRelation.joinPath) throw new Error(`Configuration Error in relation from '${sourceCollection.name}': An 'inverse' one-to-one relation requires a 'foreignKeyOnTarget'. Check the relation config for '${newRelation.relationName}'`);
-		if (newRelation.cardinality === "many" && newRelation.direction === "inverse" && !newRelation.foreignKeyOnTarget && !newRelation.joinPath && !newRelation.inverseRelationName) throw new Error(`Configuration Error in relation from '${sourceCollection.name}': An 'inverse' one-to-many relation requires a 'foreignKeyOnTarget'. Check the relation config for '${newRelation.relationName}'`);
-		return newRelation;
-	}
-	/** WeakMap cache — same collection instance always yields the same relation map. */
-	var _resolvedRelationsCache = /* @__PURE__ */ new WeakMap();
-	function resolveCollectionRelations(collection) {
-		const cached = _resolvedRelationsCache.get(collection);
-		if (cached) return cached;
-		if (!(0, _rebasepro_types.getDataSourceCapabilities)(collection.engine).supportsRelations) return {};
-		const relations = {};
-		const registeredRelationNames = /* @__PURE__ */ new Set();
-		if (collection.relations) collection.relations.forEach((relation) => {
-			try {
-				const normalizedRelation = sanitizeRelation(relation, collection);
-				const relationKey = normalizedRelation.relationName;
-				if (relationKey) {
-					relations[relationKey] = normalizedRelation;
-					registeredRelationNames.add(relationKey);
-				}
-			} catch (e) {}
-		});
-		if (collection.properties) Object.entries(collection.properties).forEach(([propKey, prop]) => {
-			const relation = resolvePropertyRelation({
-				propertyKey: propKey,
-				property: prop,
-				sourceCollection: collection
-			});
-			if (relation) {
-				if (relations[propKey]) return;
-				if (!relation.relationName) relation.relationName = propKey;
-				const normalizedRelation = sanitizeRelation(relation, collection);
-				relations[propKey] = normalizedRelation;
-				registeredRelationNames.add(normalizedRelation.relationName ?? propKey);
-			}
-		});
-		_resolvedRelationsCache.set(collection, relations);
-		return relations;
-	}
-	function resolvePropertyRelation({ propertyKey, property, sourceCollection }) {
-		if (property.type !== "relation") return void 0;
-		const relProp = property;
-		if (relProp.target) return {
-			relationName: relProp.relationName || propertyKey,
-			target: relProp.target,
-			cardinality: relProp.cardinality || "one",
-			direction: relProp.direction || "owning",
-			inverseRelationName: relProp.inverseRelationName,
-			localKey: relProp.localKey,
-			foreignKeyOnTarget: relProp.foreignKeyOnTarget,
-			through: relProp.through,
-			joinPath: relProp.joinPath,
-			onUpdate: relProp.onUpdate,
-			onDelete: relProp.onDelete,
-			overrides: relProp.overrides
-		};
-		console.warn(`Unrecognized or missing relation target for property '${propertyKey}' in collection '${sourceCollection.slug}'`);
-	}
-	function getTableName(collection) {
-		if ((0, _rebasepro_types.getDataSourceCapabilities)(collection.engine).supportsRelations) return collection.table ?? (0, _rebasepro_utils.toSnakeCase)(collection.slug) ?? (0, _rebasepro_utils.toSnakeCase)(collection.name);
-		return (0, _rebasepro_utils.toSnakeCase)(collection.slug) ?? (0, _rebasepro_utils.toSnakeCase)(collection.name);
-	}
-	function getTableVarName(tableName) {
-		return tableName.replace(/_([a-z])/g, (_, char) => char.toUpperCase());
-	}
-	function getEnumVarName(tableName, propName) {
-		return `${getTableVarName(tableName)}${propName.charAt(0).toUpperCase() + propName.slice(1)}`;
-	}
-	function getColumnName(fullColumn) {
-		return fullColumn.includes(".") ? fullColumn.split(".").pop() : fullColumn;
-	}
-	/**
-	* Look up a relation by key with forgiving normalization.
-	*
-	* `resolveCollectionRelations` stores each relation under a single canonical
-	* key (no aliases). This helper tries the given key as-is, then falls back to
-	* slug form (underscores → hyphens) and snake_case form (hyphens → underscores)
-	* so that callers that receive a key from external input (URL path segments,
-	* user-provided config, etc.) can still find the right entry.
-	*/
-	function findRelation(resolvedRelations, key) {
-		if (resolvedRelations[key]) return resolvedRelations[key];
-		const slugKey = key.replace(/_/g, "-");
-		if (slugKey !== key && resolvedRelations[slugKey]) return resolvedRelations[slugKey];
-		const snakeKey = key.replace(/-/g, "_");
-		if (snakeKey !== key && resolvedRelations[snakeKey]) return resolvedRelations[snakeKey];
-	}
-	//#endregion
-	//#region src/util/resolutions.ts
-	function resolveProperty(props) {
-		const { property, ignoreMissingFields = false, ...rest } = props;
-		let resultProperty;
-		if (isPropertyBuilder(property)) {
-			const path = rest.path;
-			if (!path) resultProperty = property;
-			else {
-				const usedPropertyValue = rest.propertyKey ? (0, _rebasepro_utils.getIn)(rest.values, rest.propertyKey) : void 0;
-				const dynamicProps = property.dynamicProps?.({
-					...rest,
-					path,
-					propertyValue: usedPropertyValue,
-					values: rest.values ?? {},
-					previousValues: rest.previousValues ?? rest.values ?? {}
-				});
-				resultProperty = (0, _rebasepro_utils.mergeDeep)(property, dynamicProps ?? {});
-			}
-		} else resultProperty = property;
-		if (resultProperty?.dynamicProps && rest.path) {
-			const path = rest.path;
-			const usedPropertyValue = rest.propertyKey ? (0, _rebasepro_utils.getIn)(rest.values, rest.propertyKey) : void 0;
-			const dynamicPropsResult = resultProperty.dynamicProps({
-				...rest,
-				path,
-				propertyValue: usedPropertyValue,
-				values: rest.values ?? {},
-				previousValues: rest.previousValues ?? rest.values ?? {}
-			});
-			if (dynamicPropsResult) resultProperty = (0, _rebasepro_utils.mergeDeep)(resultProperty, dynamicPropsResult);
-		}
-		let resolvedProperty;
-		if (resultProperty?.type === "map" && resultProperty.properties) {
-			const properties = resolveProperties({
-				ignoreMissingFields,
-				...rest,
-				properties: resultProperty.properties
-			});
-			resolvedProperty = {
-				...resultProperty,
-				properties
-			};
-		} else if (resultProperty?.type === "array") resolvedProperty = resultProperty;
-		else if ((resultProperty?.type === "string" || resultProperty?.type === "number") && resultProperty.enum) resolvedProperty = resolvePropertyEnum(resultProperty);
-		else resolvedProperty = resultProperty;
-		if (resolvedProperty?.propertyConfig && !(0, _rebasepro_utils.isDefaultFieldConfigId)(resolvedProperty.propertyConfig)) {
-			const cmsFields = rest.propertyConfigs;
-			if (!cmsFields && !ignoreMissingFields) throw Error(`Trying to resolve a property with key '${resolvedProperty.propertyConfig}' that inherits from a custom property config but no custom property configs were provided. Use the property 'propertyConfigs' in your app config to provide them`);
-			const customField = cmsFields?.[resolvedProperty.propertyConfig];
-			if (!customField) {
-				console.warn(`Trying to resolve a property with key '${resolvedProperty.propertyConfig}' that inherits from a custom property config but no custom property config with that key was found. Check the 'propertyConfigs' in your app config`);
-				return resolvedProperty;
-			}
-			if (customField.property) {
-				const restConfigProperty = { ...customField.property };
-				delete restConfigProperty.propertyConfig;
-				const customFieldProperty = resolveProperty({
-					property: {
-						name: "",
-						...restConfigProperty
-					},
-					ignoreMissingFields,
-					...rest
-				});
-				if (customFieldProperty) resolvedProperty = (0, _rebasepro_utils.mergeDeep)(customFieldProperty, resolvedProperty);
-			}
-		}
-		return resolvedProperty;
-	}
-	function resolveRelationProperty(property, relations, propertyKey) {
-		if (property.relation) return property;
-		const name = property.relationName || propertyKey;
-		const relation = name ? relations.find((rel) => rel.relationName === name) : void 0;
-		if (!relation) throw Error(`Relation ${name ?? "(unnamed)"} not found`);
-		return {
-			...property,
-			relation
-		};
-	}
-	/**
-	* Resolve enum aliases for a string or number property
-	* @param property
-	*/
-	function resolvePropertyEnum(property) {
-		if (typeof property.enum === "object") return {
-			...property,
-			enum: enumToObjectEntries(property.enum)?.filter((value) => value && (value.id || value.id === 0) && value.label) ?? []
-		};
-		return property;
-	}
-	/**
-	* Resolve enums and arrays for properties
-	* @param properties
-	* @param value
-	*/
-	function resolveProperties({ propertyKey, properties, ignoreMissingFields, ...props }) {
-		return Object.entries(properties).map(([key, property]) => {
-			const childResolvedProperty = resolveProperty({
-				propertyKey: propertyKey ? `${propertyKey}.${key}` : void 0,
-				property,
-				ignoreMissingFields,
-				...props
-			});
-			if (!childResolvedProperty) return {};
-			return { [key]: childResolvedProperty };
-		}).filter((a) => a !== null).reduce((a, b) => ({
-			...a,
-			...b
-		}), {});
-	}
-	function resolveArrayProperties({ propertyKey, property, ignoreMissingFields = false, ...props }) {
-		const propertyValue = propertyKey ? (0, _rebasepro_utils.getIn)(props.values, propertyKey) : void 0;
-		if (property.of) if (Array.isArray(property.of)) return property.of.map((p, index) => {
-			return resolveProperty({
-				propertyKey: `${propertyKey}.${index}`,
-				property: p,
-				ignoreMissingFields,
-				...props,
-				index
-			});
-		});
-		else {
-			const of = property.of;
-			const resolvedProperties = getArrayResolvedProperties({
-				propertyValue,
-				propertyKey,
-				property,
-				ignoreMissingFields,
-				...props
-			});
-			const { values, previousValues, ...rest } = props;
-			if (!resolveProperty({
-				property: of,
-				ignoreMissingFields,
-				...rest
-			}) && !ignoreMissingFields) throw Error("When using a property builder as the 'of' prop of an ArrayProperty, you must return a valid child property");
-			return resolvedProperties;
-		}
-		else if (property.oneOf) {
-			const typeField = property.oneOf?.typeField ?? "type";
-			return Array.isArray(propertyValue) ? propertyValue.map((v, index) => {
-				const type = v && v[typeField];
-				const childProperty = property.oneOf?.properties[type];
-				if (!type || !childProperty) return null;
-				return resolveProperty({
-					propertyKey: `${propertyKey}.${index}`,
-					property: childProperty,
-					ignoreMissingFields,
-					...props
-				});
-			}).filter((e) => Boolean(e)) : [];
-		} else if (!("Field" in (property.ui || {}) && property.ui?.Field)) throw Error(`The array property (${propertyKey}) needs to declare an 'of' or a 'oneOf' property, or provide a custom \`Field\` component`);
-		else return [];
-	}
-	function getArrayResolvedProperties({ propertyKey, propertyValue, property, ...props }) {
-		const of = property.of;
-		if (!of) throw Error(`Trying to resolve an array property (${propertyKey}) without providing an 'of' property`);
-		return Array.isArray(propertyValue) ? propertyValue.map((v, index) => {
-			return resolveProperty({
-				propertyKey: `${propertyKey}.${index}`,
-				property: Array.isArray(of) ? of[index] : of,
-				...props,
-				index
-			});
-		}).filter((e) => Boolean(e)) : [];
-	}
-	function resolveEnumValues(input) {
-		if (typeof input === "object") return Object.entries(input).map(([id, value]) => typeof value === "string" ? {
-			id,
-			label: value
-		} : value);
-		else if (Array.isArray(input)) return input;
-		else return;
-	}
-	function getSubcollections(collection) {
-		if (collection.childCollections) return collection.childCollections() ?? [];
-		const declaredSubcollections = (0, _rebasepro_types.getDeclaredSubcollections)(collection);
-		if ((0, _rebasepro_types.getDataSourceCapabilities)(collection.engine).supportsSubcollections && declaredSubcollections) return declaredSubcollections() ?? [];
-		if ((0, _rebasepro_types.getDataSourceCapabilities)(collection.engine).supportsRelations) {
-			const resolvedRelations = resolveCollectionRelations(collection);
-			return Object.values(resolvedRelations).filter((r) => r.cardinality === "many").map((r) => {
-				const target = r.target();
-				if (!target) return void 0;
-				const relationKey = r.relationName || target.slug;
-				let customName;
-				if (collection.properties) {
-					const prop = Object.entries(collection.properties).find(([_, p]) => p.type === "relation" && p.relationName === relationKey);
-					if (prop && prop[1].name) customName = prop[1].name;
-				}
-				const baseOverrides = { slug: relationKey };
-				if (customName) {
-					baseOverrides.name = customName;
-					baseOverrides.singularName = customName;
-				}
-				const targetWithOverrides = {
-					...target,
-					...baseOverrides
-				};
-				return r.overrides ? (0, _rebasepro_utils.mergeDeep)(targetWithOverrides, r.overrides) : targetWithOverrides;
-			}).filter((c) => Boolean(c));
-		}
-		return [];
-	}
-	//#endregion
-	//#region src/util/policy/sqlToPolicy.ts
-	/**
-	* A tiny, regex-based SQL "parser" for security rules.
-	*
-	* This is NOT a full SQL parser. It is designed to handle the subset of SQL
-	* commonly used in `USING` and `WITH CHECK` clauses, enough to drive the
-	* optimistic client-side UI decision.
-	*
-	* It handles:
-	* - `field = 'literal'`
-	* - `field != 'literal'`
-	* - `field = current_setting('app.user_id')`
-	* - `A AND B`
-	* - `true`
-	* - `IN (...)` (as optimistic true)
-	*
-	* For anything it doesn't understand, it returns a `raw` expression, which
-	* the evaluator treats as "unknown" (and usually optimistic true).
-	*/
-	function sqlToPolicy(sql) {
-		const trimmed = sql.trim();
-		if (trimmed.toLowerCase() === "true") return _rebasepro_types.policy.true();
-		if (trimmed.toLowerCase() === "false") return _rebasepro_types.policy.false();
-		const overlapMatch = trimmed.match(/^string_to_array\s*\(\s*auth\.roles\(\)\s*,\s*','\s*\)\s*&&\s*ARRAY\s*\[(.+)\]$/i);
-		if (overlapMatch) {
-			const roles = overlapMatch[1].split(",").map((s) => s.trim().replace(/^'|'$/g, ""));
-			return _rebasepro_types.policy.rolesOverlap(roles);
-		}
-		const containMatch = trimmed.match(/^string_to_array\s*\(\s*auth\.roles\(\)\s*,\s*','\s*\)\s*@>\s*ARRAY\s*\[(.+)\]$/i);
-		if (containMatch) {
-			const roles = containMatch[1].split(",").map((s) => s.trim().replace(/^'|'$/g, ""));
-			return _rebasepro_types.policy.rolesContain(roles);
-		}
-		if (trimmed.toUpperCase().includes(" OR ")) {
-			const parts = trimmed.split(/ OR /i);
-			return _rebasepro_types.policy.or(...parts.map(sqlToPolicy));
-		}
-		if (trimmed.toUpperCase().includes(" AND ")) {
-			const parts = trimmed.split(/ AND /i);
-			return _rebasepro_types.policy.and(...parts.map(sqlToPolicy));
-		}
-		const match = trimmed.match(/^(.+?)\s*(!?=)\s*(.+)$/);
-		if (match) {
-			const [, leftStr, op, rightStr] = match;
-			const left = parseOperand(leftStr.trim());
-			const right = parseOperand(rightStr.trim());
-			if (left && right) return _rebasepro_types.policy.compare(left, op === "=" ? "eq" : "neq", right);
-		}
-		return _rebasepro_types.policy.raw(sql);
-	}
-	function parseOperand(str) {
-		if (/current_setting\s*\(\s*'app\.user_id'\s*\)/i.test(str) || /auth\.uid\(\)/i.test(str)) return _rebasepro_types.policy.authUid();
-		const stringMatch = str.match(/^'(.+)'$/);
-		if (stringMatch) return _rebasepro_types.policy.literal(stringMatch[1]);
-		if (/^\w+$/.test(str)) return _rebasepro_types.policy.field(str);
-		return null;
-	}
-	//#endregion
-	//#region src/util/policy/securityRuleToConditions.ts
-	/**
-	* Desugars a {@link SecurityRule} — its `access`/`ownerField`/`roles` shortcuts,
-	* structured `condition`/`check`, and raw `using`/`withCheck` — into a single
-	* normalized {@link PolicyExpression} pair.
-	*
-	* **This is the linchpin against drift:** both the Postgres DDL generators and
-	* the client-side evaluator consume this one function, so there is exactly one
-	* definition of what a rule means. In particular, application `roles` are folded
-	* into the expression here (AND'd with the base condition, matching how Postgres
-	* generates the clause) rather than being handled separately by each consumer.
-	*/
-	function securityRuleToConditions(rule) {
-		return {
-			usingExpr: withRoles(baseUsing(rule), rule),
-			withCheckExpr: withRoles(baseWithCheck(rule), rule)
-		};
-	}
-	function baseUsing(rule) {
-		if (rule.condition) return rule.condition;
-		if (rule.using != null) return sqlToPolicy(rule.using);
-		if (rule.access === "public") return _rebasepro_types.policy.true();
-		if (rule.ownerField) return _rebasepro_types.policy.compare(_rebasepro_types.policy.field(rule.ownerField), "eq", _rebasepro_types.policy.authUid());
-		return null;
-	}
-	function baseWithCheck(rule) {
-		if (rule.check) return rule.check;
-		if (rule.withCheck != null) return sqlToPolicy(rule.withCheck);
-		return baseUsing(rule);
-	}
-	/**
-	* AND the base condition with an application-role check, or produce a roles-only
-	* condition when there is no base. Mirrors the Postgres generator so that a
-	* role-scoped restrictive rule denies exactly the same set of users on both
-	* sides.
-	*/
-	function withRoles(base, rule) {
-		if (!rule.roles || rule.roles.length === 0) return base;
-		const rolesExpr = _rebasepro_types.policy.rolesOverlap(rule.roles);
-		if (rule.mode === "restrictive") return base ? _rebasepro_types.policy.or(_rebasepro_types.policy.not(rolesExpr), base) : _rebasepro_types.policy.not(rolesExpr);
-		return base ? _rebasepro_types.policy.and(base, rolesExpr) : rolesExpr;
-	}
-	//#endregion
-	//#region src/util/policy/policyToPostgres.ts
-	/**
-	* Compiles a {@link PolicyExpression} to a PostgreSQL boolean SQL string,
-	* suitable for a `USING (...)` / `WITH CHECK (...)` clause.
-	*
-	* This is one of the two consumers of the shared policy model (the other being
-	* {@link evaluatePolicy}); the Postgres schema generators call it so that DDL
-	* and the admin UI derive from the exact same expression.
-	*/
-	function policyToPostgres(expr, collection, options) {
-		return compile(expr, {
-			fieldCollection: collection,
-			fieldPrefix: "",
-			outerCollection: collection,
-			outerPrefix: "",
-			resolveCollection: options?.resolveCollection,
-			alias: { n: 0 }
-		});
-	}
-	function compile(expr, scope) {
-		switch (expr.kind) {
-			case "true": return "true";
-			case "false": return "false";
-			case "and": return expr.operands.length === 0 ? "true" : expr.operands.map((o) => `(${compile(o, scope)})`).join(" AND ");
-			case "or": return expr.operands.length === 0 ? "false" : expr.operands.map((o) => `(${compile(o, scope)})`).join(" OR ");
-			case "not":
-				if (expr.operand.kind === "authenticated") return "auth.uid() IS NULL";
-				return `NOT (${compile(expr.operand, scope)})`;
-			case "compare": return `${operandToSql(expr.left, scope)} ${COMPARE_SQL[expr.op]} ${operandToSql(expr.right, scope)}`;
-			case "rolesOverlap": return `string_to_array(auth.roles(), ',') && ${rolesArraySql(expr.roles)}`;
-			case "rolesContain": return `string_to_array(auth.roles(), ',') @> ${rolesArraySql(expr.roles)}`;
-			case "authenticated": return "auth.uid() IS NOT NULL";
-			case "existsIn": return compileExistsIn(expr, scope);
-			case "raw": return expr.sql.replace(/\{(\w+)\}/g, (_, col) => col);
-		}
-	}
-	/**
-	* Compiles `existsIn` to a correlated `EXISTS (SELECT 1 FROM <join> WHERE ...)`.
-	* Inside the subquery, `field` operands bind to the aliased join table and
-	* `outerField` operands bind to the (table-qualified) outer RLS row.
-	*/
-	function compileExistsIn(expr, scope) {
-		const join = scope.resolveCollection?.(expr.collection);
-		const joinTable = join ? getTableName(join) : (0, _rebasepro_utils.toSnakeCase)(expr.collection);
-		const joinSchema = schemaOf(join) ?? schemaOf(scope.outerCollection) ?? "public";
-		const alias = `_ex${scope.alias.n++}`;
-		const outerTable = scope.outerCollection ? getTableName(scope.outerCollection) : void 0;
-		const outerSchema = schemaOf(scope.outerCollection) ?? "public";
-		const outerPrefix = outerTable ? `"${outerSchema}"."${outerTable}".` : "";
-		const innerScope = {
-			fieldCollection: join,
-			fieldPrefix: `"${alias}".`,
-			outerCollection: scope.outerCollection,
-			outerPrefix,
-			resolveCollection: scope.resolveCollection,
-			alias: scope.alias
-		};
-		return `EXISTS (SELECT 1 FROM "${joinSchema}"."${joinTable}" "${alias}" WHERE ${compile(expr.where, innerScope)})`;
-	}
-	var COMPARE_SQL = {
-		eq: "=",
-		neq: "!=",
-		lt: "<",
-		lte: "<=",
-		gt: ">",
-		gte: ">="
-	};
-	function operandToSql(operand, scope) {
-		switch (operand.kind) {
-			case "field": return `${scope.fieldPrefix}${resolveColumnName(operand.name, scope.fieldCollection)}`;
-			case "outerField": return `${scope.outerPrefix}${resolveColumnName(operand.name, scope.outerCollection)}`;
-			case "literal": return quoteLiteral(operand.value);
-			case "authUid": return "auth.uid()";
-			case "authRoles": return "string_to_array(auth.roles(), ',')";
-		}
-	}
-	function schemaOf(collection) {
-		return collection?.schema || void 0;
-	}
-	function resolveColumnName(propName, collection) {
-		const prop = collection?.properties?.[propName];
-		if (prop && "columnName" in prop && typeof prop.columnName === "string") return prop.columnName;
-		return (0, _rebasepro_utils.toSnakeCase)(propName);
-	}
-	function quoteLiteral(value) {
-		if (value === null) return "NULL";
-		if (typeof value === "boolean") return value ? "true" : "false";
-		if (typeof value === "number") return String(value);
-		return `'${value.replace(/'/g, "''")}'`;
-	}
-	/** Sorted, single-quoted `ARRAY['a','b']` — matches the generators' output. */
-	function rolesArraySql(roles) {
-		return `ARRAY[${[...roles].sort().map((r) => `'${r}'`).join(",")}]`;
-	}
-	//#endregion
-	//#region src/util/policy/evaluatePolicy.ts
-	/**
-	* Evaluates a {@link PolicyExpression} against a user + row, using three-valued
-	* (Kleene) logic so that `"unknown"` sub-results propagate soundly.
-	*
-	* This is the JavaScript twin of {@link policyToPostgres}: both derive from the
-	* same expression, so the admin UI matches database enforcement by construction
-	* for every non-raw rule.
-	*/
-	function evaluatePolicy(expr, ctx) {
-		switch (expr.kind) {
-			case "true": return true;
-			case "false": return false;
-			case "and": return kleeneAnd$1(expr.operands.map((o) => evaluatePolicy(o, ctx)));
-			case "or": return kleeneOr(expr.operands.map((o) => evaluatePolicy(o, ctx)));
-			case "not": return kleeneNot(evaluatePolicy(expr.operand, ctx));
-			case "compare": return evaluateCompare(expr.op, expr.left, expr.right, ctx);
-			case "rolesOverlap": {
-				const userRoles = ctx.roles ?? [];
-				return expr.roles.some((r) => r === "public" || userRoles.includes(r));
-			}
-			case "rolesContain": {
-				const userRoles = ctx.roles ?? [];
-				return expr.roles.every((r) => r === "public" || userRoles.includes(r));
-			}
-			case "authenticated": return ctx.uid != null;
-			case "existsIn": return "unknown";
-			case "raw": return "unknown";
-		}
-	}
-	function kleeneAnd$1(values) {
-		if (values.some((v) => v === false)) return false;
-		if (values.some((v) => v === "unknown")) return "unknown";
-		return true;
-	}
-	function kleeneOr(values) {
-		if (values.some((v) => v === true)) return true;
-		if (values.some((v) => v === "unknown")) return "unknown";
-		return false;
-	}
-	function kleeneNot(value) {
-		if (value === "unknown") return "unknown";
-		return !value;
-	}
-	function resolveOperand(operand, ctx) {
-		switch (operand.kind) {
-			case "literal": return {
-				known: true,
-				value: operand.value
-			};
-			case "authUid": return {
-				known: true,
-				value: ctx.uid ?? null
-			};
-			case "authRoles": return {
-				known: true,
-				value: ctx.roles ?? []
-			};
-			case "field":
-				if (!ctx.entity) return { known: false };
-				return {
-					known: true,
-					value: ctx.entity.values[operand.name]
-				};
-			case "outerField": return { known: false };
-		}
-	}
-	function evaluateCompare(op, left, right, ctx) {
-		const l = resolveOperand(left, ctx);
-		const r = resolveOperand(right, ctx);
-		if (!l.known || !r.known) return "unknown";
-		const a = l.value;
-		const b = r.value;
-		if (a === null || b === null) {
-			if (op === "eq") return false;
-			if (op === "neq") return true;
-			return "unknown";
-		}
-		if (op === "eq") return a === b;
-		if (op === "neq") return a !== b;
-		if (typeof a === "string" && typeof b === "string") {
-			if (op === "lt") return a < b;
-			if (op === "lte") return a <= b;
-			if (op === "gt") return a > b;
-			if (op === "gte") return a >= b;
-		}
-		if (typeof a === "number" && typeof b === "number") {
-			if (op === "lt") return a < b;
-			if (op === "lte") return a <= b;
-			if (op === "gt") return a > b;
-			if (op === "gte") return a >= b;
-		}
-		if (typeof a === "bigint" && typeof b === "bigint") {
-			if (op === "lt") return a < b;
-			if (op === "lte") return a <= b;
-			if (op === "gt") return a > b;
-			if (op === "gte") return a >= b;
-		}
-		return "unknown";
-	}
-	//#endregion
-	//#region src/util/permissions.ts
-	/** Combine clause results with AND under three-valued (Kleene) logic. */
-	function kleeneAnd(values) {
-		if (values.some((v) => v === false)) return false;
-		if (values.some((v) => v === "unknown")) return "unknown";
-		return true;
-	}
-	/** The operations a rule covers, mirroring the Postgres generator's resolution. */
-	function ruleOperations(rule) {
-		return rule.operations && rule.operations.length > 0 ? rule.operations : [rule.operation ?? "all"];
-	}
-	function ruleApplies(rule, targetOperation) {
-		const ops = ruleOperations(rule);
-		return ops.includes(targetOperation) || ops.includes("all");
-	}
-	/**
-	* Evaluate a single rule for one operation, returning a tri-state.
-	*
-	* A `null` clause (the rule contributes no condition for a required clause)
-	* denies — matching Postgres, which emits `USING (false)` / `WITH CHECK (false)`
-	* in that case. USING applies to SELECT/UPDATE/DELETE; WITH CHECK to
-	* INSERT/UPDATE; both must pass for UPDATE.
-	*/
-	function evaluateRuleForOperation(rule, ctx, targetOperation) {
-		const { usingExpr, withCheckExpr } = securityRuleToConditions(rule);
-		const clause = (expr) => expr === null ? false : evaluatePolicy(expr, ctx);
-		const needsUsing = targetOperation !== "insert";
-		const needsWithCheck = targetOperation === "insert" || targetOperation === "update";
-		const results = [];
-		if (needsUsing) results.push(clause(usingExpr));
-		if (needsWithCheck) results.push(clause(withCheckExpr));
-		return kleeneAnd(results);
-	}
-	function resolveTriState(value, onUnknown) {
-		if (value === "unknown") return onUnknown === "allow";
-		return value;
-	}
-	/**
-	* Decide whether an operation is permitted for a user on a (possibly null) row,
-	* by evaluating the collection's security rules with the shared policy model —
-	* the same model compiled to Postgres RLS DDL, so the decision matches database
-	* enforcement for every non-raw rule.
-	*
-	* @param options.onUnknown how to treat rules that cannot be decided
-	*   client-side (raw SQL, or row predicates with no row). Defaults to `"allow"`
-	*   for optimistic UI gating; enforcement callers should pass `"deny"`.
-	*/
-	function checkOperation(collection, authContext, entity, targetOperation, options) {
-		const onUnknown = options?.onUnknown ?? "allow";
-		const securityRules = (0, _rebasepro_types.getDataSourceCapabilities)(collection.engine).supportsRLS ? collection.securityRules : void 0;
-		if (!securityRules || securityRules.length === 0) return true;
-		const applicableRules = securityRules.filter((r) => ruleApplies(r, targetOperation));
-		if (applicableRules.length === 0) return false;
-		const ctx = {
-			uid: authContext.user?.uid,
-			roles: authContext.user?.roles ?? [],
-			entity
-		};
-		let grantedByPermissive = false;
-		let deniedByRestrictive = false;
-		let hasPermissive = false;
-		for (const rule of applicableRules) {
-			const mode = rule.mode || "permissive";
-			const passed = resolveTriState(evaluateRuleForOperation(rule, ctx, targetOperation), onUnknown);
-			if (mode === "restrictive") {
-				if (!passed) {
-					deniedByRestrictive = true;
-					break;
-				}
-			} else {
-				hasPermissive = true;
-				if (passed) grantedByPermissive = true;
-			}
-		}
-		if (deniedByRestrictive) return false;
-		return hasPermissive ? grantedByPermissive : false;
-	}
-	function canReadCollection(collection, authContext) {
-		return checkOperation(collection, authContext, null, "select");
-	}
-	function canEditEntity(collection, authContext, path, entity) {
-		return checkOperation(collection, authContext, entity, "update");
-	}
-	function canCreateEntity(collection, authContext, path, entity) {
-		return checkOperation(collection, authContext, entity, "insert");
-	}
-	function canDeleteEntity(collection, authContext, path, entity) {
-		return checkOperation(collection, authContext, entity, "delete");
-	}
-	//#endregion
-	//#region src/util/references.ts
-	function getEntityImagePreviewPropertyKey(collection) {
-		for (const key in collection.properties) {
-			const property = collection.properties[key];
-			if (property.type === "string" && property.storage?.acceptedFiles?.includes("image/*")) return key;
-		}
-		for (const key in collection.properties) {
-			const property = collection.properties[key];
-			if (property.type === "array" && !Array.isArray(property.of) && property.of?.type === "string" && property.of.storage?.acceptedFiles?.includes("image/*")) return key;
-		}
-		for (const key in collection.properties) {
-			const property = collection.properties[key];
-			if (property.type === "string" && property.ui?.url === "image") return key;
-		}
-		for (const key in collection.properties) {
-			const property = collection.properties[key];
-			if (property.type === "array" && property.of && !Array.isArray(property.of) && property.of.type === "string" && property.of.ui?.url === "image") return key;
-		}
-		for (const key in collection.properties) {
-			const property = collection.properties[key];
-			if (property.type === "string" && property.storage && !property.storage.acceptedFiles) return key;
-		}
-		for (const key in collection.properties) {
-			const property = collection.properties[key];
-			if (property.type === "array" && !Array.isArray(property.of) && property.of?.type === "string" && property.of.storage && !property.of.storage.acceptedFiles) return key;
-		}
-	}
-	//#endregion
-	//#region src/util/navigation_utils.ts
-	function removeInitialAndTrailingSlashes(s) {
-		return removeInitialSlash(removeTrailingSlash(s));
-	}
-	function removeInitialSlash(s) {
-		if (s.startsWith("/")) return s.slice(1);
-		else return s;
-	}
-	function removeTrailingSlash(s) {
-		if (s.endsWith("/")) return s.slice(0, -1);
-		else return s;
-	}
-	function addInitialSlash(s) {
-		if (s.startsWith("/")) return s;
-		else return `/${s}`;
-	}
-	function getLastSegment(path) {
-		const cleanPath = removeInitialAndTrailingSlashes(path);
-		if (cleanPath.includes("/")) {
-			const segments = cleanPath.split("/");
-			return segments[segments.length - 1];
-		}
-		return cleanPath;
-	}
-	function resolveCollectionPathIds(path, allCollections) {
-		let remainingPath = removeInitialAndTrailingSlashes(path);
-		if (!remainingPath) return "";
-		let currentCollections = allCollections;
-		const resolvedPathParts = [];
-		while (remainingPath.length > 0) {
-			if (!currentCollections || currentCollections.length === 0) {
-				console.warn(`resolveCollectionPathIds: Path structure implies subcollections, but none found before segment starting with "${remainingPath}" in original path "${path}". Appending remaining original path.`);
-				resolvedPathParts.push(remainingPath);
-				remainingPath = "";
-				break;
-			}
-			let foundMatch = false;
-			const potentialMatches = currentCollections.flatMap((col) => [{
-				col,
-				match: col.slug
-			}]).filter((p) => p.match && remainingPath.startsWith(p.match)).sort((a, b) => b.match.length - a.match.length);
-			if (potentialMatches.length > 0) {
-				const { col: foundCollection, match: matchString } = potentialMatches[0];
-				resolvedPathParts.push(foundCollection.slug);
-				remainingPath = removeInitialSlash(remainingPath.substring(matchString.length));
-				if (remainingPath.length === 0) {
-					foundMatch = true;
-					break;
-				}
-				const idSeparatorIndex = remainingPath.indexOf("/");
-				let entityId;
-				if (idSeparatorIndex > -1) {
-					entityId = remainingPath.substring(0, idSeparatorIndex);
-					remainingPath = remainingPath.substring(idSeparatorIndex + 1);
-				} else {
-					entityId = remainingPath;
-					remainingPath = "";
-					console.warn(`resolveCollectionPathIds: Path seems to end with a entity ID "${entityId}" instead of a collection segment in original path "${path}". This might indicate an invalid input path.`);
-				}
-				resolvedPathParts.push(entityId);
-				currentCollections = getSubcollections(foundCollection);
-				foundMatch = true;
-				if (!currentCollections && remainingPath.length > 0) {
-					console.warn(`resolveCollectionPathIds: Path continues after entity ID "${entityId}", but no subcollections are defined for the preceding collection "${foundCollection.slug}" in path "${path}". Appending remaining original path.`);
-					resolvedPathParts.push(remainingPath);
-					remainingPath = "";
-					break;
-				}
-			}
-			if (!foundMatch) {
-				console.warn(`resolveCollectionPathIds: Collection definition not found for segment starting with "${remainingPath}" in original path "${path}". Appending remaining original path.`);
-				resolvedPathParts.push(remainingPath);
-				remainingPath = "";
-				break;
-			}
-		}
-		return resolvedPathParts.join("/");
-	}
-	/**
-	* Find the corresponding view at any depth for a given path.
-	* Note that path or segments of the paths can be collection aliases.
-	* @param slugOrPath
-	* @param collections
-	*/
-	function getCollectionBySlugWithin(slugOrPath, collections) {
-		const subpaths = removeInitialAndTrailingSlashes(slugOrPath).split("/");
-		if (subpaths.length % 2 === 0) throw Error(`getCollectionBySlug: Collection paths must have an odd number of segments: ${slugOrPath}`);
-		const subpathCombinations = getCollectionPathsCombinations(subpaths);
-		let result;
-		for (let i = 0; i < subpathCombinations.length; i++) {
-			const subpathCombination = subpathCombinations[i];
-			const navigationEntry = collections && collections.sort((a, b) => (a.slug ?? "").localeCompare(b.slug ?? "")).find((entry) => entry.slug === subpathCombination);
-			if (navigationEntry) {
-				if (subpathCombination === slugOrPath) result = navigationEntry;
-				else if (getSubcollections(navigationEntry).length > 0) {
-					const newPath = slugOrPath.replace(subpathCombination, "").split("/").slice(2).join("/");
-					if (newPath.length > 0) result = getCollectionBySlugWithin(newPath, getSubcollections(navigationEntry));
-				}
-			}
-			if (result) break;
-		}
-		return result;
-	}
-	/**
-	* Get the subcollection combinations from a path:
-	* "sites/es/locales" => ["sites/es/locales", "sites"]
-	* @param subpaths
-	*/
-	function getCollectionPathsCombinations(subpaths) {
-		const entries = subpaths.length > 0 && subpaths.length % 2 === 0 ? subpaths.splice(0, subpaths.length - 1) : subpaths;
-		const length = entries.length;
-		const result = [];
-		for (let i = length; i > 0; i = i - 2) result.push(entries.slice(0, i).join("/"));
-		return result;
-	}
-	//#endregion
-	//#region src/util/navigation_from_path.ts
-	function getNavigationEntriesFromPath(props) {
-		const { path, collections = [], currentFullPath } = props;
-		const subpathCombinations = getCollectionPathsCombinations(removeInitialAndTrailingSlashes(path).split("/"));
-		const result = [];
-		for (let i = 0; i < subpathCombinations.length; i++) {
-			const subpathCombination = subpathCombinations[i];
-			const collection = collections && collections.find((entry) => entry.slug === subpathCombination);
-			if (collection) {
-				const collectionPath = currentFullPath && currentFullPath.length > 0 ? currentFullPath + "/" + collection.slug : collection.slug;
-				result.push({
-					type: "collection",
-					id: collection.slug,
-					slug: collectionPath,
-					path: collectionPath,
-					collection
-				});
-				const restOfThePath = removeInitialAndTrailingSlashes(removeInitialAndTrailingSlashes(path).replace(subpathCombination, ""));
-				const nextSegments = restOfThePath.length > 0 ? restOfThePath.split("/") : [];
-				if (nextSegments.length > 0) {
-					const entityId = nextSegments[0];
-					const path = collectionPath + "/" + entityId;
-					result.push({
-						type: "entity",
-						entityId,
-						slug: collectionPath,
-						path,
-						parentCollection: collection
-					});
-					if (nextSegments.length > 1) {
-						const newPath = nextSegments.slice(1).join("/");
-						if (!collection) throw Error("collection not found resolving path: " + collection);
-						const entityViews = collection.entityViews;
-						const customView = entityViews && entityViews.map((entry) => resolveEntityView(entry, props.contextEntityViews)).filter((v) => v != null).find((entry) => entry.key === newPath);
-						const subcollections = getSubcollections(collection);
-						if (customView) result.push({
-							type: "custom_view",
-							slug: collectionPath,
-							entityId,
-							path: path + "/" + customView.key,
-							view: customView
-						});
-						else if (subcollections) result.push(...getNavigationEntriesFromPath({
-							path: newPath,
-							collections: subcollections,
-							currentFullPath: path,
-							contextEntityViews: props.contextEntityViews
-						}));
-					}
-				}
-				break;
-			}
-		}
-		return result;
-	}
-	function resolveEntityView(entityView, contextEntityViews) {
-		if (typeof entityView === "string") return contextEntityViews?.find((entry) => entry.key === entityView);
-		else return entityView;
-	}
-	//#endregion
-	//#region src/util/parent_references_from_path.ts
-	function getParentReferencesFromPath(props) {
-		const { path, collections = [], currentFullPath } = props;
-		const subpathCombinations = getCollectionPathsCombinations(removeInitialAndTrailingSlashes(path).split("/"));
-		const result = [];
-		for (let i = 0; i < subpathCombinations.length; i++) {
-			const subpathCombination = subpathCombinations[i];
-			const collection = collections && collections.find((entry) => entry.slug === subpathCombination);
-			if (collection) {
-				const collectionPath = currentFullPath && currentFullPath.length > 0 ? currentFullPath + "/" + collection.slug : collection.slug;
-				const restOfThePath = removeInitialAndTrailingSlashes(removeInitialAndTrailingSlashes(path).replace(subpathCombination, ""));
-				const nextSegments = restOfThePath.length > 0 ? restOfThePath.split("/") : [];
-				if (nextSegments.length > 0) {
-					const entityId = nextSegments[0];
-					const path = collectionPath + "/" + entityId;
-					result.push(new _rebasepro_types.EntityReference({
-						id: entityId,
-						path: collectionPath
-					}));
-					if (nextSegments.length > 1) {
-						const newPath = nextSegments.slice(1).join("/");
-						if (!collection) throw Error("collection not found resolving path: " + collection);
-						if (getSubcollections(collection).length > 0) result.push(...getParentReferencesFromPath({
-							path: newPath,
-							collections: getSubcollections(collection),
-							currentFullPath: path
-						}));
-					}
-				}
-				break;
-			}
-		}
-		return result;
-	}
-	//#endregion
-	//#region src/util/builders.ts
-	/**
-	* @deprecated Use {@link defineCollection} instead — it infers property
-	* types automatically (autocomplete on `titleProperty`, `sort`,
-	* `propertiesOrder`, callbacks) without manual generics.
-	* `buildCollection` is kept for FireCMS migration compatibility and will
-	* be removed before 1.0.
-	*
-	* @group Builder
-	*/
-	function buildCollection(collection) {
-		return collection;
-	}
-	/**
-	* Implementation — delegates to the correct overload at the type level.
-	* At runtime this is a plain identity function.
-	*/
-	function defineCollection(collection) {
-		return collection;
-	}
-	/**
-	* @deprecated Use plain typed property objects with {@link defineCollection}
-	* instead — `defineCollection` infers property types automatically, making
-	* this wrapper unnecessary. `buildProperty` is kept for FireCMS migration
-	* compatibility and will be removed before 1.0.
-	*
-	* @group Builder
-	*/
-	function buildProperty(property) {
-		return property;
-	}
-	//#endregion
-	//#region src/util/storage.ts
-	/**
-	* Resolve the {@link StorageSource} to use for a property, given the key
-	* referenced by `StorageConfig.storageSource`.
-	*
-	* Resolution priority:
-	* 1. No `sourceKey` → the default source (backward compatible).
-	* 2. An explicit {@link StorageSourceRegistry} (e.g. `client.storageRegistry`).
-	* 3. A `sources` lookup map (e.g. the `StorageSourcesContext`).
-	* 4. Fall back to the default source.
-	*
-	* Shared by the upload hook, the markdown editor, and the read-only previews
-	* so the resolution logic lives in one place.
-	*
-	* @group Storage
-	*/
-	function resolveStorageSource(params) {
-		const { sourceKey, sources, registry, defaultSource } = params;
-		if (!sourceKey) return defaultSource;
-		if (registry) return registry.getOrDefault(sourceKey);
-		const fromSources = sources?.[sourceKey];
-		if (fromSources) return fromSources;
-		return defaultSource;
-	}
-	async function resolveStorageFilenameString({ input, storage, values, entityId, path, property, file, propertyKey }) {
-		let result;
-		if (typeof input === "function") {
-			result = await input({
-				path,
-				entityId,
-				values,
-				property,
-				file,
-				storage,
-				propertyKey
-			});
-			if (!result) console.warn("Storage callback returned empty result. Using default name value");
-		} else result = replacePlaceholders({
-			file,
-			input,
-			entityId,
-			propertyKey,
-			path
-		});
-		if (!result) result = (0, _rebasepro_utils.randomString)() + "_" + file.name;
-		return result;
-	}
-	function resolveStoragePathString({ input, storage, values, entityId, path, property, file, propertyKey }) {
-		let result;
-		if (typeof input === "function") {
-			result = input({
-				path,
-				entityId,
-				values,
-				property,
-				file,
-				storage,
-				propertyKey
-			});
-			if (!result) console.warn("Storage callback returned empty result. Using default name value");
-		} else result = replacePlaceholders({
-			file,
-			input,
-			entityId,
-			propertyKey,
-			path
-		});
-		if (!result) result = (0, _rebasepro_utils.randomString)() + "_" + file.name;
-		return result;
-	}
-	function replacePlaceholders({ file, input, entityId, propertyKey, path }) {
-		const ext = file.name.split(".").pop();
-		let result = input.replace("{propertyKey}", propertyKey).replace("{rand}", (0, _rebasepro_utils.randomString)()).replace("{file}", file.name).replace("{file.type}", file.type);
-		if (entityId) result = result.replace("{entityId}", String(entityId));
-		if (path) result = result.replace("{path}", path);
-		if (ext) {
-			result = result.replace("{file.ext}", ext);
-			const name = file.name.replace(`.${ext}`, "");
-			result = result.replace("{file.name}", name);
-		}
-		if (!result) result = (0, _rebasepro_utils.randomString)() + "_" + file.name;
-		return result;
-	}
-	//#endregion
-	//#region src/util/callbacks.ts
-	/**
-	* Helper function to recursively check if there are any callbacks in the properties.
-	*/
-	function hasPropertyCallbacks(properties, callbackName) {
-		if (!properties) return false;
-		for (const property of Object.values(properties)) {
-			if (property.callbacks?.[callbackName]) return true;
-			if (property.type === "map" && property.properties) {
-				if (hasPropertyCallbacks(property.properties, callbackName)) return true;
-			} else if (property.type === "array" && property.of) {
-				const ofs = Array.isArray(property.of) ? property.of : [property.of];
-				for (const of of ofs) {
-					if (of.callbacks?.[callbackName]) return true;
-					if (of.type === "map" && of.properties && hasPropertyCallbacks(of.properties, callbackName)) return true;
-				}
-			}
-		}
-		return false;
-	}
-	/**
-	* Recursively process properties to apply field-level hooks.
-	*/
-	async function processProperties(properties, values, previousValues, propsContext, callbackName) {
-		if (!values || typeof values !== "object") return values;
-		const result = { ...values };
-		for (const [key, property] of Object.entries(properties)) {
-			if (result[key] === void 0) continue;
-			let currentValue = result[key];
-			const previousValue = previousValues?.[key];
-			if (property.type === "array" && Array.isArray(currentValue)) {
-				if (property.of && !Array.isArray(property.of)) currentValue = await Promise.all(currentValue.map(async (item, index) => {
-					const prevItem = Array.isArray(previousValue) ? previousValue[index] : void 0;
-					return (await processProperties({ "_tmp": property.of }, { "_tmp": item }, { "_tmp": prevItem }, propsContext, callbackName))["_tmp"];
-				}));
-			} else if (property.type === "map" && property.properties && typeof currentValue === "object") currentValue = await processProperties(property.properties, currentValue, previousValue ?? {}, propsContext, callbackName);
-			if (property.callbacks?.[callbackName]) {
-				const cbRes = await Promise.resolve(property.callbacks[callbackName]({
-					...propsContext,
-					value: currentValue,
-					previousValue
-				}));
-				if (cbRes !== void 0) currentValue = cbRes;
-			}
-			result[key] = currentValue;
-		}
-		return result;
-	}
-	/**
-	* Helper function to extract field-level PropertyCallbacks from a properties schema
-	* and wrap them into an CollectionCallbacks object recursively.
-	*/
-	var buildPropertyCallbacks = (properties) => {
-		if (!properties) return void 0;
-		const propertyCallbacks = {};
-		if (hasPropertyCallbacks(properties, "afterRead")) propertyCallbacks.afterRead = async (props) => {
-			const row = props.row;
-			const processedValues = await processProperties(properties, row, row, props, "afterRead");
-			return {
-				...props.row,
-				...processedValues
-			};
-		};
-		if (hasPropertyCallbacks(properties, "beforeSave")) propertyCallbacks.beforeSave = async (props) => {
-			return await processProperties(properties, props.values, props.previousValues ?? {}, props, "beforeSave");
-		};
-		return Object.keys(propertyCallbacks).length > 0 ? propertyCallbacks : void 0;
-	};
-	//#endregion
-	//#region src/util/conditions.ts
-	/**
-	* Access a nested property from an object via dot notation.
-	*/
-	function getIn(obj, path) {
-		if (!obj || !path) return void 0;
-		return path.split(".").reduce((acc, part) => acc && acc[part], obj);
-	}
-	var operationsRegistered = false;
-	/**
-	* Register custom JSON Logic operations for Rebase.
-	* Call this once at app initialization.
-	*/
-	function registerConditionOperations() {
-		if (operationsRegistered) return;
-		json_logic_js.default.add_operation("hasRole", function(roleId) {
-			return this?.user?.roles?.includes(roleId) ?? false;
-		});
-		json_logic_js.default.add_operation("hasAnyRole", function(roleIds) {
-			if (!this?.user?.roles || !Array.isArray(roleIds)) return false;
-			return roleIds.some((role) => this.user.roles.includes(role));
-		});
-		json_logic_js.default.add_operation("isToday", (timestamp) => {
-			if (!timestamp) return false;
-			const date = new Date(timestamp);
-			const today = /* @__PURE__ */ new Date();
-			return date.getFullYear() === today.getFullYear() && date.getMonth() === today.getMonth() && date.getDate() === today.getDate();
-		});
-		json_logic_js.default.add_operation("isPast", (timestamp) => {
-			if (!timestamp) return false;
-			return timestamp < Date.now();
-		});
-		json_logic_js.default.add_operation("isFuture", (timestamp) => {
-			if (!timestamp) return false;
-			return timestamp > Date.now();
-		});
-		operationsRegistered = true;
-	}
-	/**
-	* Evaluate a JSON Logic rule against the given context.
-	*/
-	function evaluateCondition(rule, context) {
-		registerConditionOperations();
-		return json_logic_js.default.apply(rule, context);
-	}
-	/**
-	* Convert a value to a format suitable for JSON Logic evaluation.
-	* Specifically handles Date objects by converting them to Unix timestamps.
-	*/
-	function serializeValueForConditions(value) {
-		if (value === null || value === void 0) return value;
-		if (value instanceof Date) return value.getTime();
-		if (typeof value?.toMillis === "function") return value.toMillis();
-		if (typeof value?.toDate === "function") return value.toDate().getTime();
-		if (Array.isArray(value)) return value.map(serializeValueForConditions);
-		if (typeof value === "object") {
-			const result = {};
-			for (const key of Object.keys(value)) result[key] = serializeValueForConditions(value[key]);
-			return result;
-		}
-		return value;
-	}
-	/**
-	* Build a ConditionContext from the current property resolution context.
-	*/
-	function buildConditionContext(params) {
-		const { propertyKey, values, previousValues, path, entityId, index, authController } = params;
-		const user = authController.user;
-		const serializedValues = serializeValueForConditions(values ?? {});
-		return {
-			values: serializedValues,
-			previousValues: serializeValueForConditions(previousValues ?? values ?? {}),
-			propertyValue: propertyKey ? getIn(serializedValues, propertyKey) : void 0,
-			path,
-			entityId,
-			isNew: !entityId,
-			index,
-			user: {
-				uid: user?.uid ?? "",
-				email: user?.email ?? null,
-				displayName: user?.displayName ?? null,
-				photoURL: user?.photoURL ?? null,
-				roles: (user?.roles ?? []).map((r) => typeof r === "string" ? r : r.id)
-			},
-			now: Date.now()
-		};
-	}
-	/**
-	* Apply PropertyConditions to a resolved property, evaluating all JSON Logic rules.
-	*/
-	function applyPropertyConditions(property, context) {
-		const { conditions } = property;
-		if (!conditions) return property;
-		const result = { ...property };
-		if (conditions.disabled) {
-			if (evaluateCondition(conditions.disabled, context)) {
-				result.ui = result.ui || {};
-				result.ui.disabled = {
-					clearOnDisabled: conditions.clearOnDisabled ?? false,
-					disabledMessage: conditions.disabledMessage,
-					hidden: false
-				};
-			}
-		}
-		if (conditions.hidden) {
-			if (evaluateCondition(conditions.hidden, context)) {
-				result.ui = result.ui || {};
-				result.ui.disabled = {
-					...typeof result.ui?.disabled === "object" ? result.ui.disabled : {},
-					hidden: true,
-					clearOnDisabled: conditions.clearOnDisabled ?? false
-				};
-			}
-		}
-		if (conditions.readOnly) {
-			if (evaluateCondition(conditions.readOnly, context)) {
-				result.ui = result.ui || {};
-				result.ui.readOnly = true;
-			}
-		}
-		if (conditions.required !== void 0) {
-			const isRequired = evaluateCondition(conditions.required, context);
-			result.validation = {
-				...result.validation,
-				required: isRequired,
-				requiredMessage: conditions.requiredMessage
-			};
-		}
-		if (context.isNew && conditions.defaultValue !== void 0) result.defaultValue = evaluateCondition(conditions.defaultValue, context);
-		if ("enum" in result && result.enum && (conditions.enumConditions || conditions.allowedEnumValues || conditions.excludedEnumValues)) result.enum = applyEnumConditions(result.enum, conditions, context);
-		if (result.type === "reference") {
-			if (conditions.referencePath) result.path = evaluateCondition(conditions.referencePath, context);
-			if (conditions.referenceFilter) result.fixedFilter = evaluateCondition(conditions.referenceFilter, context);
-		}
-		if (result.type === "array") {
-			if (conditions.canAddElements !== void 0) result.canAddElements = evaluateCondition(conditions.canAddElements, context);
-			if (conditions.sortable !== void 0) result.sortable = evaluateCondition(conditions.sortable, context);
-		}
-		return result;
-	}
-	/**
-	* Convert an object with numeric keys back to an array.
-	* Firestore stores arrays as {"0": "a", "1": "b"} to avoid nested arrays.
-	*/
-	function objectToArray(obj) {
-		if (Array.isArray(obj)) return obj.map(String);
-		if (obj && typeof obj === "object") {
-			const keys = Object.keys(obj);
-			if (keys.length > 0 && keys.every((k) => !isNaN(Number(k)))) return keys.sort((a, b) => Number(a) - Number(b)).map((k) => obj[k]).filter((v) => typeof v === "string" || typeof v === "number").map(String);
-		}
-		return [];
-	}
-	/**
-	* Apply enum-specific conditions to filter and modify enum values.
-	*/
-	function applyEnumConditions(enumValues, conditions, context) {
-		let result = [...enumValues];
-		if (conditions.allowedEnumValues) {
-			const allowedArray = objectToArray(evaluateCondition(conditions.allowedEnumValues, context));
-			if (allowedArray.length > 0) result = result.filter((ev) => allowedArray.includes(String(ev.id)));
-		}
-		if (conditions.excludedEnumValues) {
-			const excludedArray = objectToArray(evaluateCondition(conditions.excludedEnumValues, context));
-			if (excludedArray.length > 0) result = result.filter((ev) => !excludedArray.includes(String(ev.id)));
-		}
-		if (conditions.enumConditions) result = result.map((ev) => {
-			const evConditions = conditions.enumConditions?.[ev.id];
-			if (!evConditions) return ev;
-			if (evConditions.hidden && evaluateCondition(evConditions.hidden, context)) return null;
-			if (evConditions.disabled && evaluateCondition(evConditions.disabled, context)) return {
-				...ev,
-				disabled: true
-			};
-			return ev;
-		}).filter((ev) => ev !== null);
-		return result;
-	}
-	//#endregion
-	//#region src/util/filter-operator-resolution.ts
-	/**
-	* Default operators offered per property type, before engine capabilities and
-	* per-property narrowing are applied. These mirror what the built-in filter
-	* fields can render.
-	*/
-	var COMPARISON_OPS = [
-		"==",
-		"!=",
-		">",
-		">=",
-		"<",
-		"<="
-	];
-	var NULL_CHECK_OPS = ["is-null", "is-not-null"];
-	var MEMBERSHIP_OPS = ["in", "not-in"];
-	var PATTERN_OPS = [
-		"like",
-		"ilike",
-		"not-like",
-		"not-ilike"
-	];
-	var DEFAULT_OPS_BY_TYPE = {
-		string: [
-			...COMPARISON_OPS,
-			...MEMBERSHIP_OPS,
-			...PATTERN_OPS,
-			...NULL_CHECK_OPS
-		],
-		number: [
-			...COMPARISON_OPS,
-			...MEMBERSHIP_OPS,
-			...NULL_CHECK_OPS
-		],
-		date: [...COMPARISON_OPS, ...NULL_CHECK_OPS],
-		boolean: [
-			"==",
-			"!=",
-			...NULL_CHECK_OPS
-		],
-		reference: [
-			"==",
-			"!=",
-			...MEMBERSHIP_OPS,
-			...NULL_CHECK_OPS
-		],
-		relation: [
-			"==",
-			"!=",
-			...MEMBERSHIP_OPS,
-			...NULL_CHECK_OPS
-		]
-	};
-	/** Operators offered when the property is an *array of* a filterable type. */
-	var ARRAY_OPS = ["array-contains", "array-contains-any"];
-	/**
-	* Resolve which filter operators the UI should offer for a property.
-	*
-	* The result is the **intersection** of three sets:
-	* 1. what the engine can execute — {@link DataSourceCapabilities.filterOperators}
-	*    (e.g. Firestore cannot run the LIKE family);
-	* 2. what makes sense for the property type (e.g. no `>` on booleans);
-	* 3. the developer's optional narrowing — `property.ui.filterOperators`.
-	*
-	* Returns an empty array when the property is not filterable (either by
-	* type, or because the developer disabled it with `filterOperators: []`).
-	*
-	* @group Models
-	*/
-	function resolveFilterOperators({ property, isArray, engine }) {
-		const typeDefaults = isArray ? ARRAY_OPS : DEFAULT_OPS_BY_TYPE[property.type] ?? [];
-		if (typeDefaults.length === 0) return [];
-		const engineOps = new Set((0, _rebasepro_types.getDataSourceCapabilities)(engine).filterOperators ?? _rebasepro_types.ALL_WHERE_FILTER_OPS);
-		const narrowing = property.ui?.filterOperators;
-		const narrowingSet = narrowing !== void 0 ? new Set(narrowing) : void 0;
-		return typeDefaults.filter((op) => engineOps.has(op) && (narrowingSet === void 0 || narrowingSet.has(op)));
-	}
-	//#endregion
-	//#region src/data/resolveDataSource.ts
-	/**
-	* Build a keyed registry from a list of {@link DataSourceDefinition}s.
-	* Later entries win on key collision.
-	*/
-	function createDataSourceRegistry(definitions) {
-		const registry = {};
-		for (const def of definitions ?? []) registry[def.key] = def;
-		return registry;
-	}
-	/**
-	* Resolve the effective data source for a collection — the single source of
-	* truth shared by the frontend router, the backend driver registry, and the
-	* editor's capability lookups.
-	*
-	* Resolution order:
-	* 1. The routing **key** is `collection.dataSource`, else
-	*    {@link DEFAULT_DATA_SOURCE_KEY}.
-	* 2. If a definition is registered for that key, it provides `engine`,
-	*    `transport`, and `databaseId`.
-	* 3. Otherwise values are synthesized: `engine` from `collection.engine`
-	*    (or the key, or `"postgres"`), `transport` defaults to `"server"`,
-	*    and `databaseId` from the collection.
-	*
-	* `capabilities` are always derived from the resolved `engine`, so two
-	* data sources sharing an engine share capabilities.
-	*
-	* @param collection the collection (or any object carrying the routing fields)
-	* @param registry   optional registry of declared data sources
-	*/
-	function resolveDataSource(collection, registry) {
-		const key = collection?.dataSource ?? _rebasepro_types.DEFAULT_DATA_SOURCE_KEY;
-		const def = registry?.[key];
-		const engine = def?.engine ?? collection?.engine ?? (key !== _rebasepro_types.DEFAULT_DATA_SOURCE_KEY ? key : "postgres");
-		return {
-			key,
-			engine,
-			transport: def?.transport ?? "server",
-			databaseId: collection?.databaseId ?? def?.databaseId,
-			capabilities: (0, _rebasepro_types.getDataSourceCapabilities)(engine)
-		};
-	}
-	//#endregion
-	//#region src/collections/CollectionRegistry.ts
-	var CollectionRegistry = class {
-		/**
-		* Declared data sources, used during normalization to resolve each
-		* collection's engine (so `dataSource`-only collections get the right
-		* capabilities). Empty by default.
-		*/
-		dataSources = {};
-		/**
-		* Global lifecycle callbacks applied to every collection.
-		* Runs on all data paths (REST, WebSocket, `rebase.data`).
-		* Execution order: global → collection → property callbacks.
-		*/
-		_globalCallbacks;
-		/**
-		* Set global lifecycle callbacks that apply to every collection.
-		* Typically called once during backend initialization.
-		*/
-		setGlobalCallbacks(callbacks) {
-			this._globalCallbacks = callbacks;
-		}
-		/**
-		* Get the currently registered global callbacks, if any.
-		*/
-		getGlobalCallbacks() {
-			return this._globalCallbacks;
-		}
-		collectionsByTableName = /* @__PURE__ */ new Map();
-		collectionsBySlug = /* @__PURE__ */ new Map();
-		rootCollections = [];
-		cachedCollectionsList = null;
-		rawCollectionsByTableName = /* @__PURE__ */ new Map();
-		rawCollectionsBySlug = /* @__PURE__ */ new Map();
-		rawRootCollections = [];
-		cachedRawCollectionsList = null;
-		lastRawInputEntity = null;
-		constructor(collections, dataSources) {
-			if (dataSources) this.dataSources = dataSources;
-			if (collections) this.registerMultiple(collections);
-		}
-		/**
-		* Provide the declared data sources used to resolve each collection's
-		* engine during normalization. Set this before registering collections.
-		* Returns true if the registry changed (callers may re-register).
-		*/
-		setDataSources(dataSources) {
-			if ((0, fast_equals.deepEqual)(this.dataSources, dataSources)) return false;
-			this.dataSources = dataSources ?? {};
-			return true;
-		}
-		reset() {
-			this.collectionsByTableName.clear();
-			this.collectionsBySlug.clear();
-			this.rootCollections = [];
-			this.cachedCollectionsList = null;
-			this.rawCollectionsByTableName.clear();
-			this.rawCollectionsBySlug.clear();
-			this.rawRootCollections = [];
-			this.cachedRawCollectionsList = null;
-		}
-		/**
-		* Registers a collection and its subcollections recursively.
-		* Returns true if the collections have changed, false otherwise.
-		*
-		* Idempotent: compares the raw input (before normalization) against a stored
-		* entity. Only re-normalizes and re-registers when the raw input actually changed.
-		* @param collections
-		*/
-		registerMultiple(collections) {
-			const rawEntity = collections.map((c) => (0, _rebasepro_utils.removeFunctions)(c));
-			if (this.lastRawInputEntity && (0, fast_equals.deepEqual)(this.lastRawInputEntity, rawEntity)) return false;
-			this.reset();
-			collections.forEach((c) => {
-				if (c.slug) this.collectionsBySlug.set(c.slug, c);
-				this.collectionsByTableName.set(getTableName(c), c);
-			});
-			const normalizedCollections = collections.map((c) => this.normalizeCollection({ ...c }));
-			normalizedCollections.forEach((c, index) => {
-				const raw = (0, _rebasepro_utils.deepClone)(collections[index]);
-				this.rootCollections.push(c);
-				this.rawRootCollections.push(raw);
-				const normalized = this.normalizeCollection(c);
-				this.collectionsByTableName.set(getTableName(normalized), normalized);
-				this.rawCollectionsByTableName.set(getTableName(raw), raw);
-				if (normalized.slug) this.collectionsBySlug.set(normalized.slug, normalized);
-				if (raw.slug) this.rawCollectionsBySlug.set(raw.slug, raw);
-			});
-			normalizedCollections.forEach((c) => {
-				const subcollections = getSubcollections(c);
-				if (subcollections && subcollections.length > 0) subcollections.forEach((subCollection) => {
-					if (!subCollection) return;
-					this._registerRecursively(this.normalizeCollection({ ...subCollection }), (0, _rebasepro_utils.deepClone)(subCollection));
-				});
-			});
-			this.lastRawInputEntity = rawEntity;
-			return true;
-		}
-		register(collection, rawCollection) {
-			const raw = rawCollection ? (0, _rebasepro_utils.deepClone)(rawCollection) : (0, _rebasepro_utils.deepClone)(collection);
-			this.rootCollections.push(collection);
-			this.rawRootCollections.push(raw);
-			this._registerRecursively(collection, raw);
-		}
-		_registerRecursively(collection, rawCollection) {
-			if (this.collectionsByTableName.has(getTableName(collection))) return;
-			const normalizedCollection = this.normalizeCollection(collection);
-			this.collectionsByTableName.set(getTableName(normalizedCollection), normalizedCollection);
-			this.rawCollectionsByTableName.set(getTableName(rawCollection), rawCollection);
-			if (normalizedCollection.slug) this.collectionsBySlug.set(normalizedCollection.slug, normalizedCollection);
-			if (rawCollection.slug) this.rawCollectionsBySlug.set(rawCollection.slug, rawCollection);
-			const subcollections = getSubcollections(normalizedCollection);
-			if (subcollections && subcollections.length > 0) subcollections.forEach((subCollection) => {
-				if (!subCollection) return;
-				this._registerRecursively(this.normalizeCollection({ ...subCollection }), (0, _rebasepro_utils.deepClone)(subCollection));
-			});
-		}
-		normalizeCollection(collection) {
-			const result = { ...collection };
-			{
-				const resolved = resolveDataSource(result, this.dataSources);
-				if (!result.dataSource) result.dataSource = resolved.key;
-				if (!result.engine) result.engine = resolved.engine;
-			}
-			const extractedRelations = this.extractRelationsFromProperties(result.properties);
-			const relResult = result;
-			const manualRelations = (0, _rebasepro_types.getDataSourceCapabilities)(result.engine).supportsRelations ? relResult.relations ?? [] : [];
-			const mergedRelationsRaw = [...extractedRelations];
-			for (const manual of manualRelations) {
-				const name = manual.relationName;
-				if (!name) mergedRelationsRaw.push(manual);
-				else {
-					const existingIndex = mergedRelationsRaw.findIndex((r) => r.relationName === name);
-					if (existingIndex === -1) mergedRelationsRaw.push(manual);
-					else mergedRelationsRaw[existingIndex] = {
-						...manual,
-						...mergedRelationsRaw[existingIndex]
-					};
-				}
-			}
-			let mergedRelations = mergedRelationsRaw;
-			if ((0, _rebasepro_types.getDataSourceCapabilities)(result.engine).supportsRelations) {
-				mergedRelations = mergedRelationsRaw.map((r) => {
-					try {
-						return sanitizeRelation(r, result, (slug) => this.get(slug));
-					} catch {
-						return r;
-					}
-				});
-				relResult.relations = mergedRelations;
-			}
-			result.properties = this.normalizeProperties(result.properties, mergedRelations);
-			if (!result.childCollections) {
-				const capabilities = (0, _rebasepro_types.getDataSourceCapabilities)(result.engine);
-				const declaredSubcollections = (0, _rebasepro_types.getDeclaredSubcollections)(result);
-				if (capabilities.supportsSubcollections && declaredSubcollections) result.childCollections = declaredSubcollections;
-				else if (capabilities.supportsRelations && relResult.relations) {
-					const manyRelations = relResult.relations.filter((r) => r.cardinality === "many");
-					if (manyRelations.length > 0) result.childCollections = () => manyRelations.map((r) => {
-						const target = r.target();
-						return r.overrides ? (0, _rebasepro_utils.mergeDeep)(target, r.overrides) : target;
-					});
-				}
-			}
-			return result;
-		}
-		/**
-		* Extract Relation[] from properties that have inline relation config (i.e. `target` is set).
-		* This allows developers to define relations directly on properties without a separate
-		* `relations[]` entry on the collection.
-		*/
-		extractRelationsFromProperties(properties) {
-			const relations = [];
-			for (const [key, property] of Object.entries(properties)) if (property.type === "relation") {
-				const relProp = property;
-				const target = relProp.target ?? relProp.relation?.target;
-				if (target) {
-					const relationName = relProp.relationName ?? relProp.relation?.relationName ?? key;
-					relations.push({
-						relationName,
-						target,
-						cardinality: relProp.cardinality ?? relProp.relation?.cardinality ?? "one",
-						direction: relProp.direction ?? relProp.relation?.direction ?? "owning",
-						inverseRelationName: relProp.inverseRelationName ?? relProp.relation?.inverseRelationName,
-						localKey: relProp.localKey ?? relProp.relation?.localKey,
-						foreignKeyOnTarget: relProp.foreignKeyOnTarget ?? relProp.relation?.foreignKeyOnTarget,
-						through: relProp.through ?? relProp.relation?.through,
-						joinPath: relProp.joinPath ?? relProp.relation?.joinPath,
-						onUpdate: relProp.onUpdate ?? relProp.relation?.onUpdate,
-						onDelete: relProp.onDelete ?? relProp.relation?.onDelete,
-						overrides: relProp.overrides ?? relProp.relation?.overrides
-					});
-				}
-			} else if (property.type === "map" && property.properties) relations.push(...this.extractRelationsFromProperties(property.properties));
-			return relations;
-		}
-		normalizeProperties(properties, relations) {
-			const newProperties = {};
-			for (const key in properties) newProperties[key] = this.normalizeProperty(key, properties[key], relations);
-			return newProperties;
-		}
-		normalizeProperty(key, property, relations) {
-			const newProperty = { ...property };
-			if (newProperty.type === "map" && newProperty.properties) newProperty.properties = this.normalizeProperties(newProperty.properties, relations);
-			else if (newProperty.type === "array") {
-				const arrayProp = newProperty;
-				if (arrayProp.of) if (Array.isArray(arrayProp.of)) arrayProp.of = arrayProp.of.map((p, i) => this.normalizeProperty(`${key}[${i}]`, p, relations));
-				else arrayProp.of = this.normalizeProperty(`${key}.of`, arrayProp.of, relations);
-				else if (arrayProp.oneOf && arrayProp.oneOf.properties) arrayProp.oneOf.properties = this.normalizeProperties(arrayProp.oneOf.properties, relations);
-			} else if ((newProperty.type === "string" || newProperty.type === "number") && newProperty.enum) {
-				const stringOrNumberProperty = newProperty;
-				if (typeof stringOrNumberProperty.enum === "object" && !Array.isArray(stringOrNumberProperty.enum)) stringOrNumberProperty.enum = enumToObjectEntries(stringOrNumberProperty.enum)?.filter((value) => value && (value.id || value.id === 0) && value.label) ?? [];
-			} else if (newProperty.type === "relation") {
-				const relationProperty = newProperty;
-				const name = relationProperty.relationName || key;
-				const relation = relations.find((r) => r.relationName === name);
-				if (relation) relationProperty.relation = relation;
-				else console.warn(`Could not find relation for property '${key}' with relationName: ${name}`);
-			}
-			return newProperty;
-		}
-		get(path) {
-			const bySlug = this.collectionsBySlug.get(path);
-			if (bySlug) return bySlug;
-			if (path.includes("-")) {
-				const normalized = path.replace(/-/g, "_");
-				const byNormalized = this.collectionsBySlug.get(normalized);
-				if (byNormalized) return byNormalized;
-			}
-			return this.collectionsByTableName.get(path);
-		}
-		/**
-		* Gets the pristine, un-normalized collection exactly as it was provided.
-		* Useful for the AST editor so it doesn't accidentally serialize injected metadata back to disk.
-		*/
-		getRaw(path) {
-			const bySlug = this.rawCollectionsBySlug.get(path);
-			if (bySlug) return bySlug;
-			if (path.includes("-")) {
-				const normalized = path.replace(/-/g, "_");
-				const byNormalized = this.rawCollectionsBySlug.get(normalized);
-				if (byNormalized) return byNormalized;
-			}
-			return this.rawCollectionsByTableName.get(path);
-		}
-		/**
-		* Get collection by resolving multi-segment paths through relations
-		* e.g., "authors/70/posts" resolves to the posts collection
-		*/
-		getCollectionByPath(collectionPath) {
-			if (!collectionPath.includes("/")) return this.get(collectionPath);
-			const pathSegments = collectionPath.split("/").filter((p) => p);
-			if (pathSegments.length < 3 || pathSegments.length % 2 === 0) throw new Error(`Invalid relation path: ${collectionPath}. Expected format: collection/id/relation or collection/id/relation/id/relation`);
-			const rootCollectionPath = pathSegments[0];
-			let currentCollection = this.get(rootCollectionPath);
-			if (!currentCollection) throw new Error(`Root collection not found: ${rootCollectionPath}`);
-			for (let i = 2; i < pathSegments.length; i += 2) {
-				const relationKey = pathSegments[i];
-				if (!(0, _rebasepro_types.getDataSourceCapabilities)(currentCollection.engine).supportsRelations) throw new Error(`Relation path navigation requires a collection that supports relations, but '${currentCollection.slug}' uses engine '${currentCollection.engine}'`);
-				const relation = findRelation(resolveCollectionRelations(currentCollection), relationKey);
-				if (!relation) throw new Error(`Relation '${relationKey}' not found in collection '${currentCollection.slug}'`);
-				const target = relation.target();
-				const targetRelationKey = relation.relationName || target.slug;
-				const targetSlug = relation.overrides?.slug ?? targetRelationKey;
-				currentCollection = this.get(targetSlug) || this.normalizeCollection(target);
-				if (i + 1 < pathSegments.length) {}
-			}
-			return currentCollection;
-		}
-		getCollections() {
-			if (!this.cachedCollectionsList) this.cachedCollectionsList = Array.from(this.collectionsByTableName.values());
-			return this.cachedCollectionsList;
-		}
-		getRawCollections() {
-			if (!this.cachedRawCollectionsList) this.cachedRawCollectionsList = Array.from(this.rawCollectionsByTableName.values());
-			return this.cachedRawCollectionsList;
-		}
-		/**
-		* Resolves a multi-segment path like "products/123/locales" and returns
-		* information about the collections and entity IDs along the path
-		*/
-		resolvePathToCollections(path) {
-			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 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];
-				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.get(subcollection.slug) || this.normalizeCollection(subcollection);
-					collections.push(currentCollection);
-				}
-			}
-			return {
-				collections,
-				entityIds,
-				finalCollection: currentCollection
-			};
-		}
-	};
-	//#endregion
-	//#region src/collections/default-collections.ts
-	/**
-	* Default users collection.
-	*
-	* Prepended to the developer's collections array by the admin and server.
-	* Slug-based dedup (Map keyed by slug, last-write-wins) lets developers
-	* override by defining their own collection with `slug: "users"`.
-	*/
-	var defaultUsersCollection = defineCollection({
-		name: "Users",
-		singularName: "User",
-		slug: "users",
-		auth: true,
-		table: "users",
-		schema: "rebase",
-		icon: "Users",
-		group: "Settings",
-		openEntityMode: "dialog",
-		disableDefaultActions: ["copy"],
-		securityRules: [{
-			operation: "select",
-			roles: ["admin"]
-		}, {
-			operations: [
-				"insert",
-				"update",
-				"delete"
-			],
-			roles: ["admin"]
-		}],
-		sort: ["createdAt", "desc"],
-		properties: {
-			id: {
-				name: "ID",
-				type: "string",
-				isId: "uuid",
-				ui: { readOnly: true }
-			},
-			email: {
-				name: "Email",
-				type: "string",
-				validation: {
-					required: true,
-					unique: true
-				}
-			},
-			displayName: {
-				name: "Name",
-				type: "string",
-				columnName: "display_name",
-				validation: { required: true }
-			},
-			photoURL: {
-				name: "Photo URL",
-				type: "string",
-				columnName: "photo_url",
-				ui: { url: "image" }
-			},
-			roles: {
-				name: "Roles",
-				type: "array",
-				columnType: "text[]",
-				of: {
-					name: "Role",
-					type: "string",
-					enum: {
-						admin: "Admin",
-						editor: "Editor",
-						viewer: "Viewer"
-					}
-				}
-			},
-			passwordHash: {
-				name: "Password Hash",
-				type: "string",
-				columnName: "password_hash",
-				ui: {
-					hideFromCollection: true,
-					disabled: { hidden: true }
-				}
-			},
-			emailVerified: {
-				name: "Email Verified",
-				type: "boolean",
-				columnName: "email_verified",
-				defaultValue: false,
-				ui: {
-					hideFromCollection: true,
-					disabled: { hidden: true }
-				}
-			},
-			emailVerificationToken: {
-				name: "Email Verification Token",
-				type: "string",
-				columnName: "email_verification_token",
-				ui: {
-					hideFromCollection: true,
-					disabled: { hidden: true }
-				}
-			},
-			emailVerificationSentAt: {
-				name: "Email Verification Sent At",
-				type: "date",
-				columnName: "email_verification_sent_at",
-				ui: {
-					hideFromCollection: true,
-					disabled: { hidden: true }
-				}
-			},
-			metadata: {
-				name: "Metadata",
-				type: "map",
-				keyValue: true,
-				properties: {},
-				defaultValue: {},
-				ui: {
-					hideFromCollection: true,
-					disabled: { hidden: true }
-				}
-			},
-			createdAt: {
-				name: "Created At",
-				type: "date",
-				columnName: "created_at",
-				autoValue: "on_create",
-				ui: { readOnly: true }
-			},
-			updatedAt: {
-				name: "Updated At",
-				type: "date",
-				columnName: "updated_at",
-				autoValue: "on_update",
-				ui: {
-					hideFromCollection: true,
-					disabled: { hidden: true }
-				}
-			}
-		},
-		listProperties: [
-			"displayName",
-			"email",
-			"roles",
-			"createdAt"
-		],
-		propertiesOrder: [
-			"id",
-			"email",
-			"displayName",
-			"roles",
-			"createdAt"
-		]
-	});
-	//#endregion
-	//#region src/data/query_builder.ts
-	function or(...conditions) {
-		return {
-			type: "or",
-			conditions
-		};
-	}
-	function and(...conditions) {
-		return {
-			type: "and",
-			conditions
-		};
-	}
-	function cond(column, operator, value) {
-		return {
-			column,
-			operator,
-			value
-		};
-	}
-	var QueryBuilder = class {
-		collection;
-		params = { where: {} };
-		constructor(collection) {
-			this.collection = collection;
-		}
-		where(columnOrCondition, operator, value) {
-			if (typeof columnOrCondition === "object" && columnOrCondition !== null && "type" in columnOrCondition) {
-				this.params.logical = columnOrCondition;
-				return this;
-			}
-			if (!this.params.where) this.params.where = {};
-			const column = columnOrCondition;
-			const condition = [operator, value];
-			const existing = this.params.where[column];
-			if (existing === void 0) this.params.where[column] = condition;
-			else if (Array.isArray(existing) && existing.length > 0 && Array.isArray(existing[0])) this.params.where[column].push(condition);
-			else {
-				let firstCondition;
-				if (Array.isArray(existing) && existing.length === 2 && typeof existing[0] === "string") firstCondition = existing;
-				else firstCondition = ["==", existing];
-				this.params.where[column] = [firstCondition, condition];
-			}
-			return this;
-		}
-		/**
-		* Order the results by a specific column.
-		* @example
-		* client.collection('users').orderBy('createdAt', 'desc').find()
-		*/
-		orderBy(column, direction = "asc") {
-			this.params.orderBy = [column, direction];
-			return this;
-		}
-		/**
-		* Limit the number of results returned.
-		*/
-		limit(count) {
-			this.params.limit = count;
-			return this;
-		}
-		/**
-		* Skip the first N results.
-		*/
-		offset(count) {
-			this.params.offset = count;
-			return this;
-		}
-		/**
-		* Set a free-text search string if supported by the backend.
-		*/
-		search(searchString) {
-			this.params.searchString = searchString;
-			return this;
-		}
-		/**
-		* Include related entities in the response.
-		* Relations will be populated with full entity data instead of just IDs.
-		*
-		* @param relations - Relation names to include, or "*" for all.
-		* @example
-		* // Include specific relations
-		* client.data.posts.include("tags", "author").find()
-		*
-		* // Include all relations
-		* client.data.posts.include("*").find()
-		*/
-		include(...relations) {
-			this.params.include = relations;
-			return this;
-		}
-		/**
-		* Execute the find query and return the results.
-		*/
-		async find() {
-			return this.collection.find(this.params);
-		}
-		/**
-		* Listen to realtime updates matching this query.
-		*/
-		listen(onUpdate, onError) {
-			if (!this.collection.listen) throw new Error("Listen is only available when RebaseClient is configured with a websocketUrl.");
-			return this.collection.listen(this.params, onUpdate, onError);
-		}
-	};
-	//#endregion
-	//#region src/data/filter-dialect.ts
-	/**
-	* REST wire-format adapter for the unified filter system.
-	*
-	* This module is the ONLY code in the entire codebase that knows about
-	* PostgREST-style dot-syntax strings (`eq.active`, `gt.18`, `in.(a,b)`).
-	* Everything else speaks `FilterValues` exclusively.
-	*
-	* Wire-format values are always strings — the wire format carries no type
-	* metadata, so type coercion is the responsibility of the server-side data
-	* driver which has access to the collection schema.
-	*
-	* Commas inside list values are backslash-escaped (`\,`), and literal
-	* backslashes are escaped as `\\`.
-	*
-	* @module
-	*/
-	/**
-	* Serialize a JS value to its querystring representation.
-	* `null` is serialized as the literal string `"null"`.
-	*/
-	function stringifyValue(value) {
-		if (value === null) return "null";
-		return String(value);
-	}
-	/**
-	* Escape a single list item for the wire format.
-	* `\` → `\\`, `,` → `\,`
-	*/
-	function escapeListItem(value) {
-		return value.replace(/\\/g, "\\\\").replace(/,/g, "\\,");
-	}
-	/**
-	* Unescape a single list item from the wire format.
-	* `\\` → `\`, `\,` → `,`
-	*/
-	function unescapeListItem(value) {
-		let result = "";
-		for (let i = 0; i < value.length; i++) if (value[i] === "\\" && i + 1 < value.length) {
-			result += value[i + 1];
-			i++;
-		} else result += value[i];
-		return result;
-	}
-	/**
-	* Split a parenthesized list string on unescaped commas.
-	* Input is the content between `(` and `)`.
-	*
-	* @example
-	* splitListItems("admin,editor")          // ["admin", "editor"]
-	* splitListItems("hello\\, world,foo")    // ["hello, world", "foo"]
-	*/
-	function splitListItems(inner) {
-		const items = [];
-		let current = "";
-		for (let i = 0; i < inner.length; i++) if (inner[i] === "\\" && i + 1 < inner.length) {
-			current += inner[i] + inner[i + 1];
-			i++;
-		} else if (inner[i] === ",") {
-			items.push(unescapeListItem(current));
-			current = "";
-		} else current += inner[i];
-		items.push(unescapeListItem(current));
-		return items;
-	}
-	var REST_OP_LOOKUP = _rebasepro_types.REST_TO_CANONICAL;
-	var CANONICAL_OP_LOOKUP = _rebasepro_types.CANONICAL_TO_REST;
-	/**
-	* Serialize a single canonical condition tuple to a PostgREST dot-string.
-	*
-	* Throws `TypeError` if the input is not a valid `[WhereFilterOp, unknown]` tuple.
-	*
-	* @example
-	* serializeTuple(["==", "active"])           // "eq.active"
-	* serializeTuple(["in", ["admin","editor"]]) // "in.(admin,editor)"
-	* serializeTuple([">=", 18])                 // "gte.18"
-	*/
-	function serializeTuple(tuple) {
-		if (!Array.isArray(tuple) || tuple.length !== 2) throw new TypeError(`serializeTuple: expected a [WhereFilterOp, value] tuple, got ${JSON.stringify(tuple)}`);
-		const [op, value] = tuple;
-		if (typeof op !== "string") throw new TypeError(`serializeTuple: operator must be a string, got ${typeof op}`);
-		const restOp = CANONICAL_OP_LOOKUP[op];
-		if (!restOp) throw new TypeError(`serializeTuple: unknown operator "${op}". Valid operators: ${Object.keys(_rebasepro_types.CANONICAL_TO_REST).join(", ")}`);
-		if (Array.isArray(value)) return `${restOp}.(${value.map((v) => escapeListItem(stringifyValue(v))).join(",")})`;
-		return `${restOp}.${stringifyValue(value)}`;
-	}
-	/**
-	* Convert `FilterValues` (or `WireFilterValues`) to a PostgREST-style
-	* querystring record.
-	*
-	* - Canonical `[WhereFilterOp, value]` tuples are serialized strictly.
-	* - Pre-serialized PostgREST strings (e.g. `"eq.published"`) are passed through.
-	* - Single conditions produce a string value.
-	* - Multiple conditions on the same field produce a string array (repeated params).
-	*
-	* @example
-	* serializeFilter({ status: ["==", "active"] })
-	* // → { status: "eq.active" }
-	*
-	* serializeFilter({ age: [[">=", 18], ["<", 65]] })
-	* // → { age: ["gte.18", "lt.65"] }
-	*
-	* // Pre-serialized strings pass through unchanged:
-	* serializeFilter({ status: "eq.published" })
-	* // → { status: "eq.published" }
-	*/
-	function serializeFilter(filter) {
-		const result = {};
-		for (const [field, condition] of Object.entries(filter)) {
-			if (condition === void 0) continue;
-			if (typeof condition === "string") {
-				result[field] = condition;
-				continue;
-			}
-			if (Array.isArray(condition) && condition.length > 0 && Array.isArray(condition[0])) result[field] = condition.map(serializeTuple);
-			else result[field] = serializeTuple(condition);
-		}
-		return result;
-	}
-	/**
-	* Parse a single PostgREST dot-string into a `[WhereFilterOp, unknown]` tuple.
-	*
-	* All values are returned as strings — the wire format carries no type
-	* metadata, so coercion is the data driver's responsibility.
-	*
-	* If the string doesn't match a known operator prefix, it falls back to
-	* `["==", originalString]` (treating the whole string as an equality value).
-	* This intentional defense handles values like `"user@host.com"` or
-	* `"1.2.3"` that happen to contain dots.
-	*/
-	function deserializeSingle(raw) {
-		const dotIndex = raw.indexOf(".");
-		if (dotIndex === -1) return ["==", raw];
-		const prefix = raw.substring(0, dotIndex);
-		const rest = raw.substring(dotIndex + 1);
-		const canonicalOp = REST_OP_LOOKUP[prefix];
-		if (!canonicalOp) return ["==", raw];
-		if (_rebasepro_types.NULL_OPS.has(canonicalOp)) return [canonicalOp, null];
-		if (rest.startsWith("(") && rest.endsWith(")")) return [canonicalOp, splitListItems(rest.slice(1, -1))];
-		return [canonicalOp, rest];
-	}
-	/**
-	* Convert a PostgREST-style querystring record to `FilterValues`.
-	*
-	* - String values are parsed as single conditions.
-	* - String arrays (repeated query params) become multiple conditions on the same field.
-	*
-	* @example
-	* deserializeFilter({ status: "eq.active" })
-	* // → { status: ["==", "active"] }
-	*
-	* deserializeFilter({ age: ["gte.18", "lt.65"] })
-	* // → { age: [[">=", "18"], ["<", "65"]] }
-	*/
-	function deserializeFilter(query) {
-		const result = {};
-		for (const [field, raw] of Object.entries(query)) {
-			if (raw === void 0) continue;
-			if (Array.isArray(raw) && raw.length === 2 && typeof raw[0] === "string" && (0, _rebasepro_types.toCanonicalOp)(raw[0]) === raw[0]) {
-				result[field] = raw;
-				continue;
-			}
-			if (Array.isArray(raw)) {
-				if (raw.length === 0) continue;
-				if (Array.isArray(raw[0]) && raw[0].length === 2 && typeof raw[0][0] === "string" && (0, _rebasepro_types.toCanonicalOp)(raw[0][0]) === raw[0][0]) {
-					result[field] = raw;
-					continue;
-				}
-				if (raw.length === 1) result[field] = typeof raw[0] === "string" ? deserializeSingle(raw[0]) : ["==", raw[0]];
-				else if (typeof raw[0] === "string" && raw[0].includes(".")) result[field] = raw.map((r) => typeof r === "string" ? deserializeSingle(r) : ["==", r]);
-				else result[field] = ["in", raw];
-			} else if (typeof raw === "string") result[field] = deserializeSingle(raw);
-			else result[field] = ["==", raw];
-		}
-		return result;
-	}
-	/**
-	* Serialize a `LogicalCondition` or `FilterCondition` to its wire-format string.
-	*
-	* @example
-	* serializeLogicalCondition({ column: "status", operator: "==", value: "active" })
-	* // → "status.eq.active"
-	*
-	* serializeLogicalCondition({ type: "or", conditions: [...] })
-	* // → "or(status.eq.active,status.eq.pending)"
-	*/
-	function serializeLogicalCondition(cond) {
-		if ("type" in cond) {
-			const inner = (cond.conditions ?? []).map(serializeLogicalCondition).join(",");
-			return `${cond.type}(${inner})`;
-		}
-		const restOp = CANONICAL_OP_LOOKUP[cond.operator] ?? "eq";
-		if (Array.isArray(cond.value)) {
-			const items = cond.value.map((v) => escapeListItem(stringifyValue(v))).join(",");
-			return `${cond.column}.${restOp}.(${items})`;
-		}
-		return `${cond.column}.${restOp}.${stringifyValue(cond.value)}`;
-	}
-	/**
-	* Parse a logical condition wire-format string back into a
-	* `LogicalCondition` or `FilterCondition`.
-	*
-	* @example
-	* deserializeLogicalCondition("status.eq.active")
-	* // → { column: "status", operator: "==", value: "active" }
-	*
-	* deserializeLogicalCondition("or(status.eq.active,age.gte.18)")
-	* // → { type: "or", conditions: [...] }
-	*/
-	function deserializeLogicalCondition(str) {
-		const logicalMatch = str.match(/^(and|or)\((.+)\)$/);
-		if (logicalMatch) {
-			const type = logicalMatch[1];
-			const innerStr = logicalMatch[2];
-			const conditions = [];
-			let depth = 0;
-			let start = 0;
-			for (let i = 0; i < innerStr.length; i++) if (innerStr[i] === "(") depth++;
-			else if (innerStr[i] === ")") depth--;
-			else if (innerStr[i] === "," && depth === 0) {
-				conditions.push(deserializeLogicalCondition(innerStr.slice(start, i)));
-				start = i + 1;
-			}
-			conditions.push(deserializeLogicalCondition(innerStr.slice(start)));
-			return {
-				type,
-				conditions
-			};
-		}
-		const firstDot = str.indexOf(".");
-		if (firstDot === -1) return {
-			column: str,
-			operator: "==",
-			value: true
-		};
-		const column = str.substring(0, firstDot);
-		const rest = str.substring(firstDot + 1);
-		const secondDot = rest.indexOf(".");
-		if (secondDot === -1) return {
-			column,
-			operator: "==",
-			value: rest
-		};
-		const opStr = rest.substring(0, secondDot);
-		const valueStr = rest.substring(secondDot + 1);
-		const operator = (0, _rebasepro_types.toCanonicalOp)(opStr) ?? "==";
-		if (valueStr.startsWith("(") && valueStr.endsWith(")")) return {
-			column,
-			operator,
-			value: splitListItems(valueStr.slice(1, -1))
-		};
-		return {
-			column,
-			operator,
-			value: valueStr
-		};
-	}
-	//#endregion
-	//#region src/data/buildRebaseData.ts
-	/**
-	* Convert a flat REST record (e.g. from RestFetchService) to Entity<M> format.
-	* Mirrors the client SDK's rowToEntity conversion.
-	*/
-	function rowToEntity(row, slug) {
-		return {
-			id: row.id,
-			path: slug,
-			values: row
-		};
-	}
-	function createDriverAccessor(driver, slug) {
-		const accessor = {
-			async find(params) {
-				const filter = params?.where ? deserializeFilter(params.where) : void 0;
-				const limit = params?.limit ?? 20;
-				const offset = params?.offset ?? 0;
-				const fetchService = driver.restFetchService;
-				const rows = fetchService && params?.include && params.include.length > 0 ? await fetchService.fetchCollectionForRest(slug, {
-					filter,
-					limit: params?.limit,
-					offset: params?.offset,
-					orderBy: params?.orderBy?.[0],
-					order: params?.orderBy?.[1],
-					searchString: params?.searchString
-				}, params.include) : await driver.fetchCollection({
-					path: slug,
-					limit: params?.limit,
-					offset: params?.offset,
-					filter,
-					orderBy: params?.orderBy?.[0],
-					order: params?.orderBy?.[1],
-					searchString: params?.searchString
-				});
-				let total = rows.length + offset;
-				let hasMore = rows.length >= limit;
-				if (driver.count) {
-					total = await driver.count({
-						path: slug,
-						filter
-					});
-					hasMore = offset + rows.length < total;
-				}
-				return {
-					data: rows.map((row) => rowToEntity(row, slug)),
-					meta: {
-						total,
-						limit,
-						offset,
-						hasMore
-					}
-				};
-			},
-			async findById(id) {
-				const row = await driver.fetchOne({
-					path: slug,
-					id
-				});
-				return row ? rowToEntity(row, slug) : void 0;
-			},
-			async create(data, id) {
-				return rowToEntity(await driver.save({
-					path: slug,
-					values: data,
-					id,
-					status: "new"
-				}), slug);
-			},
-			async update(id, data) {
-				return rowToEntity(await driver.save({
-					path: slug,
-					values: data,
-					id,
-					status: "existing"
-				}), slug);
-			},
-			async delete(id) {
-				return driver.delete({ row: {
-					id,
-					path: slug,
-					values: {}
-				} });
-			},
-			count: driver.count ? async (params) => {
-				const filter = params?.where ? deserializeFilter(params.where) : void 0;
-				return driver.count({
-					path: slug,
-					filter
-				});
-			} : void 0,
-			listen: driver.listenCollection ? (params, onUpdate, onError) => {
-				const limit = params?.limit ?? 20;
-				const offset = params?.offset ?? 0;
-				return driver.listenCollection({
-					path: slug,
-					limit: params?.limit,
-					offset: params?.offset,
-					filter: params?.where,
-					orderBy: params?.orderBy?.[0],
-					order: params?.orderBy?.[1],
-					searchString: params?.searchString,
-					onUpdate: (entities) => {
-						onUpdate({
-							data: entities.map((row) => rowToEntity(row, slug)),
-							meta: {
-								total: entities.length,
-								limit,
-								offset,
-								hasMore: entities.length >= limit
-							}
-						});
-					},
-					onError
-				});
-			} : void 0,
-			listenById: driver.listenOne ? (id, onUpdate, onError) => {
-				return driver.listenOne({
-					path: slug,
-					id,
-					onUpdate: (entity) => onUpdate(entity ? rowToEntity(entity, slug) : void 0),
-					onError
-				});
-			} : void 0,
-			where(columnOrCondition, operator, value) {
-				const builder = new QueryBuilder(accessor);
-				if (typeof columnOrCondition === "object") return builder.where(columnOrCondition);
-				return builder.where(columnOrCondition, operator, value);
-			},
-			orderBy(column, ascending) {
-				return new QueryBuilder(accessor).orderBy(column, ascending);
-			},
-			limit(count) {
-				return new QueryBuilder(accessor).limit(count);
-			},
-			offset(count) {
-				return new QueryBuilder(accessor).offset(count);
-			},
-			search(searchString) {
-				return new QueryBuilder(accessor).search(searchString);
-			},
-			include(...relations) {
-				return new QueryBuilder(accessor).include(...relations);
-			}
-		};
-		return accessor;
-	}
-	/**
-	* Build a `RebaseData` object from a `DataDriver` using JavaScript Proxy.
-	*
-	* This is the key bridge: any property access like `data.products` returns
-	* a `CollectionAccessor` backed by the underlying DataDriver, without
-	* needing per-collection code generation.
-	*
-	* @example
-	* const data = buildRebaseData(driver);
-	* await data.products.create({ name: "Camera", price: 299 });
-	* const { data: items } = await data.products.find({ where: { status: ["==", "published"] } });
-	*/
-	function buildRebaseData(driver) {
-		const cache = /* @__PURE__ */ new Map();
-		function getAccessor(slug) {
-			let accessor = cache.get(slug);
-			if (!accessor) {
-				accessor = createDriverAccessor(driver, slug);
-				cache.set(slug, accessor);
-			}
-			return accessor;
-		}
-		return new Proxy({ collection: getAccessor }, { get(_target, prop) {
-			if (prop === "collection") return getAccessor;
-			if (typeof prop === "symbol") return void 0;
-			if (prop === "then" || prop === "toJSON" || prop === "$$typeof") return void 0;
-			return getAccessor((0, _rebasepro_utils.toSnakeCase)(prop));
-		} });
-	}
-	/**
-	* Unwrap a Entity into a flat row. `rowToEntity` stores the whole flat row
-	* (id included) under `.values`, so this is just that payload.
-	*/
-	function entityToRow(entity) {
-		return entity.values;
-	}
-	/**
-	* Fluent query builder for the flat SDK data layer. Mirrors {@link QueryBuilder}
-	* but resolves to `FindResult<M>` (flat rows) instead of Entity-wrapped
-	* `FindResponse<M>`.
-	*/
-	var SdkQueryBuilder = class {
-		client;
-		params = { where: {} };
-		constructor(client) {
-			this.client = client;
-		}
-		where(columnOrCondition, operator, value) {
-			if (typeof columnOrCondition === "object" && columnOrCondition !== null && "type" in columnOrCondition) {
-				this.params.logical = columnOrCondition;
-				return this;
-			}
-			if (!this.params.where) this.params.where = {};
-			const column = columnOrCondition;
-			const condition = [operator, value];
-			const existing = this.params.where[column];
-			if (existing === void 0) this.params.where[column] = condition;
-			else if (Array.isArray(existing) && existing.length > 0 && Array.isArray(existing[0])) this.params.where[column].push(condition);
-			else {
-				let firstCondition;
-				if (Array.isArray(existing) && existing.length === 2 && typeof existing[0] === "string") firstCondition = existing;
-				else firstCondition = ["==", existing];
-				this.params.where[column] = [firstCondition, condition];
-			}
-			return this;
-		}
-		orderBy(column, direction = "asc") {
-			this.params.orderBy = [column, direction];
-			return this;
-		}
-		limit(count) {
-			this.params.limit = count;
-			return this;
-		}
-		offset(count) {
-			this.params.offset = count;
-			return this;
-		}
-		search(searchString) {
-			this.params.searchString = searchString;
-			return this;
-		}
-		include(...relations) {
-			this.params.include = relations;
-			return this;
-		}
-		async find() {
-			return this.client.find(this.params);
-		}
-		async count() {
-			return this.client.count ? this.client.count(this.params) : 0;
-		}
-		listen(onUpdate, onError) {
-			if (!this.client.listen) throw new Error("Listen is only available when the driver supports realtime.");
-			return this.client.listen(this.params, onUpdate, onError);
-		}
-	};
-	/**
-	* 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.
-	*/
-	function toSdkCollectionClient(snap) {
-		const client = {
-			async find(params) {
-				const res = await snap.find(params);
-				return {
-					data: res.data.map(entityToRow),
-					meta: res.meta
-				};
-			},
-			async findById(id) {
-				const s = await snap.findById(id);
-				return s ? entityToRow(s) : void 0;
-			},
-			async create(data, id) {
-				return entityToRow(await snap.create(data, id));
-			},
-			async update(id, data) {
-				return entityToRow(await snap.update(id, data));
-			},
-			delete(id) {
-				return snap.delete(id);
-			},
-			count: snap.count ? (params) => snap.count(params) : void 0,
-			listen: snap.listen ? (params, onUpdate, onError) => snap.listen(params, (res) => onUpdate({
-				data: res.data.map(entityToRow),
-				meta: res.meta
-			}), onError) : void 0,
-			listenById: snap.listenById ? (id, onUpdate, onError) => snap.listenById(id, (s) => onUpdate(s ? entityToRow(s) : void 0), onError) : void 0,
-			where(columnOrCondition, operator, value) {
-				const builder = new SdkQueryBuilder(client);
-				if (typeof columnOrCondition === "object") return builder.where(columnOrCondition);
-				return builder.where(columnOrCondition, operator, value);
-			},
-			orderBy: (column, direction) => new SdkQueryBuilder(client).orderBy(column, direction),
-			limit: (count) => new SdkQueryBuilder(client).limit(count),
-			offset: (count) => new SdkQueryBuilder(client).offset(count),
-			search: (searchString) => new SdkQueryBuilder(client).search(searchString),
-			include: (...relations) => new SdkQueryBuilder(client).include(...relations)
-		};
-		return client;
-	}
-	/**
-	* Wrap a flat {@link SDKCollectionClient} into a Entity-shaped
-	* {@link CollectionAccessor}. Every returned row is re-wrapped into the
-	* `{ id, path, values }` view-model the admin CMS renders.
-	*/
-	function toEntityAccessor(sdk, slug) {
-		const accessor = {
-			async find(params) {
-				const res = await sdk.find(params);
-				return {
-					data: res.data.map((row) => rowToEntity(row, slug)),
-					meta: res.meta
-				};
-			},
-			async findById(id) {
-				const row = await sdk.findById(id);
-				return row ? rowToEntity(row, slug) : void 0;
-			},
-			async create(data, id) {
-				return rowToEntity(await sdk.create(data, id), slug);
-			},
-			async update(id, data) {
-				const row = await sdk.update(id, data);
-				if (!row) throw new Error(`Update returned no data for id ${id}`);
-				return rowToEntity(row, slug);
-			},
-			delete(id) {
-				return sdk.delete(id);
-			},
-			count: sdk.count ? (params) => sdk.count(params) : void 0,
-			listen: sdk.listen ? (params, onUpdate, onError) => sdk.listen(params, (res) => onUpdate({
-				data: res.data.map((row) => rowToEntity(row, slug)),
-				meta: res.meta
-			}), onError) : void 0,
-			listenById: sdk.listenById ? (id, onUpdate, onError) => sdk.listenById(id, (row) => onUpdate(row ? rowToEntity(row, slug) : void 0), onError) : void 0,
-			where(columnOrCondition, operator, value) {
-				const builder = new QueryBuilder(accessor);
-				if (typeof columnOrCondition === "object") return builder.where(columnOrCondition);
-				return builder.where(columnOrCondition, operator, value);
-			},
-			orderBy: (column, direction) => new QueryBuilder(accessor).orderBy(column, direction),
-			limit: (count) => new QueryBuilder(accessor).limit(count),
-			offset: (count) => new QueryBuilder(accessor).offset(count),
-			search: (searchString) => new QueryBuilder(accessor).search(searchString),
-			include: (...relations) => new QueryBuilder(accessor).include(...relations)
-		};
-		return accessor;
-	}
-	/**
-	* Wrap a flat {@link RebaseSdkData} into a Entity-shaped {@link RebaseData}.
-	*
-	* This is the **CMS boundary**: the SDK client (`client.data`) returns flat
-	* rows, but the admin renders the `Entity` view-model (`entity.values.*`).
-	* `core/Rebase.tsx` wraps `client.data` through this before handing it to the
-	* CMS `RebaseDataContext` — without it the admin renders rows with only their
-	* `id`.
-	*/
-	function wrapAsEntityData(sdkData) {
-		const cache = /* @__PURE__ */ new Map();
-		function getAccessor(slug) {
-			let accessor = cache.get(slug);
-			if (!accessor) {
-				accessor = toEntityAccessor(sdkData.collection(slug), slug);
-				cache.set(slug, accessor);
-			}
-			return accessor;
-		}
-		return new Proxy({ collection: getAccessor }, { get(_target, prop) {
-			if (prop === "collection") return getAccessor;
-			if (typeof prop === "symbol") return void 0;
-			if (prop === "then" || prop === "toJSON" || prop === "$$typeof") return void 0;
-			return getAccessor((0, _rebasepro_utils.toSnakeCase)(prop));
-		} });
-	}
-	/**
-	* Wrap a Entity-shaped {@link RebaseData} into a flat {@link RebaseSdkData}.
-	*
-	* Every collection accessor is adapted to return flat rows. Use this to derive
-	* the flat SDK data layer (`context.data`) from an existing Entity data layer
-	* — e.g. the admin routes its Entity data via `useData()` and exposes the
-	* same routing as flat `context.data` for callbacks by wrapping it here.
-	*/
-	function wrapAsSdkData(entityData) {
-		const cache = /* @__PURE__ */ new Map();
-		function getAccessor(slug) {
-			let accessor = cache.get(slug);
-			if (!accessor) {
-				accessor = toSdkCollectionClient(entityData.collection(slug));
-				cache.set(slug, accessor);
-			}
-			return accessor;
-		}
-		return new Proxy({ collection: getAccessor }, { get(_target, prop) {
-			if (prop === "collection") return getAccessor;
-			if (typeof prop === "symbol") return void 0;
-			if (prop === "then" || prop === "toJSON" || prop === "$$typeof") return void 0;
-			return getAccessor((0, _rebasepro_utils.toSnakeCase)(prop));
-		} });
-	}
-	/**
-	* Build a flat {@link RebaseSdkData} from a `DataDriver`.
-	*
-	* This is the developer-facing SDK data layer used by backend framework
-	* callbacks & scripts (`context.data` / `rebase.data`). It returns flat rows —
-	* identical in shape to the frontend SDK client — so the API is symmetric
-	* across front and back. The admin CMS uses {@link buildRebaseData} (Entity).
-	*/
-	function buildSdkData(driver) {
-		return wrapAsSdkData(buildRebaseData(driver));
-	}
-	//#endregion
-	//#region src/data/buildRoutedRebaseData.ts
-	/**
-	* Build a {@link RebaseData} that routes each collection to the right
-	* backend based on its resolved data source.
-	*
-	* `.collection(path)` (and dynamic `data.products`-style access) resolves the
-	* collection's data-source key via `resolveKey` and delegates to the matching
-	* entry in `sources`, falling back to `defaultData` when there is no match.
-	* Because routing keys off the *path being accessed*, a reference widget
-	* inside a Firestore form that points at a Postgres collection is still
-	* served by Postgres — routing follows the target, not the ancestor.
-	*
-	* When `sources` is empty this returns `defaultData` untouched, so the
-	* single-driver setup keeps identical behaviour and identity (important for
-	* effect dependencies that key off the data instance).
-	*
-	* @example
-	* const data = buildRoutedRebaseData({
-	*     defaultData: client.data,
-	*     sources: { analytics: buildRebaseData(firestoreDriver) },
-	*     resolveKey: (path) => resolveDataSource(registry.getCollection(path), defs).key
-	* });
-	* await data.products.find();        // → default (server / Postgres)
-	* await data.events.find();          // → Firestore, if `events.dataSource === "analytics"`
-	*/
-	function buildRoutedRebaseData({ defaultData, sources, resolveKey }) {
-		if (!sources || Object.keys(sources).length === 0) return defaultData;
-		function resolve(slugOrPath) {
-			const key = resolveKey(slugOrPath);
-			if (key && sources[key]) return sources[key];
-			return defaultData;
-		}
-		function getAccessor(slugOrPath) {
-			return resolve(slugOrPath).collection(slugOrPath);
-		}
-		return new Proxy({ collection: getAccessor }, { get(_target, prop) {
-			if (prop === "collection") return getAccessor;
-			if (typeof prop === "symbol") return void 0;
-			if (prop === "then" || prop === "toJSON" || prop === "$$typeof") return void 0;
-			return getAccessor((0, _rebasepro_utils.toSnakeCase)(prop));
-		} });
-	}
-	//#endregion
-	//#region src/data/sort-dialect.ts
-	/**
-	* Sort-order wire codec.
-	*
-	* This is the ONLY module that knows about the colon-delimited wire format
-	* (`"field:direction"`) used in HTTP query parameters.
-	* Everything else speaks {@link OrderByTuple} exclusively.
-	*
-	* Mirrors the filter architecture in `filter-dialect.ts`.
-	*
-	* @module
-	*/
-	/**
-	* Serialize an {@link OrderByTuple} to the wire format `"field:direction"`.
-	*
-	* **Runtime tolerance:** if the input is already a well-formed wire string
-	* (from an untyped JS caller), it is returned unchanged.
-	* This is undocumented tolerance, not public API — don't rely on it.
-	*
-	* @param orderBy - A canonical `[field, direction]` tuple, or at runtime
-	*   possibly a pre-serialized string (undocumented tolerance).
-	* @returns The wire-format string, or `undefined` if the input is falsy.
-	*
-	* @remarks
-	* Field names containing `:` are representable in the tuple form but
-	* **not** on the wire — this is an inherent limitation of the colon-delimited
-	* encoding and is not resolved here.
-	*/
-	function serializeOrderBy(orderBy) {
-		if (!orderBy) return void 0;
-		if (typeof orderBy === "string") return orderBy;
-		return `${orderBy[0]}:${orderBy[1]}`;
-	}
-	/**
-	* Deserialize a wire-format `"field:direction"` string into an {@link OrderByTuple}.
-	*
-	* Lenient parsing (matches existing server behaviour):
-	* - Bare field name (no colon): `"name"` → `["name", "asc"]`
-	* - Unknown direction: `"name:foo"` → `["name", "asc"]`
-	* - Empty / falsy input: → `undefined`
-	*
-	* @param raw - The wire-format string from an HTTP query parameter.
-	* @returns The canonical tuple, or `undefined` if the input is empty/falsy.
-	*/
-	function deserializeOrderBy(raw) {
-		if (!raw) return void 0;
-		const idx = raw.indexOf(":");
-		if (idx === -1) return [raw, "asc"];
-		return [raw.slice(0, idx), raw.slice(idx + 1) === "desc" ? "desc" : "asc"];
-	}
-	//#endregion
-	//#region src/table-classification.ts
-	/** Schemas that are always considered Rebase-internal. */
-	var REBASE_INTERNAL_SCHEMAS = ["rebase", "auth"];
-	/** Table-name prefixes that mark a table as Rebase-internal regardless of schema. */
-	var REBASE_INTERNAL_PREFIXES = [
-		"_rebase_",
-		"_auth_",
-		"drizzle_"
-	];
-	/**
-	* Synchronously classify a table based on naming conventions.
-	*
-	* @param tableName  - The unqualified name of the table.
-	* @param schemaName - The schema the table belongs to (e.g. `"public"`, `"rebase"`).
-	* @returns `"rebase-internal"` when the table belongs to a reserved schema or
-	*          carries a reserved prefix; `"user"` otherwise.
-	*
-	* @remarks
-	* Junction-table detection requires an async database query and is therefore
-	* **not** handled by this function. Use {@link detectJunctionTables} to obtain
-	* the set of junction tables, then reclassify as needed.
-	*/
-	function classifyTable(tableName, schemaName) {
-		if (REBASE_INTERNAL_SCHEMAS.includes(schemaName) || REBASE_INTERNAL_PREFIXES.some((prefix) => tableName.startsWith(prefix))) return "rebase-internal";
-		return "user";
-	}
-	/**
-	* Convenience predicate that checks whether a table is Rebase-internal.
-	*
-	* @param tableName  - The unqualified name of the table.
-	* @param schemaName - The schema the table belongs to.
-	* @returns `true` if the table is classified as `"rebase-internal"`.
-	*/
-	function isRebaseInternalTable(tableName, schemaName) {
-		return classifyTable(tableName, schemaName) === "rebase-internal";
-	}
-	/** SQL query that detects junction tables in the `public` schema. */
-	var JUNCTION_TABLES_SQL = `
-  SELECT t.table_name
-  FROM information_schema.tables t
-  WHERE t.table_schema = 'public'
-    AND t.table_type = 'BASE TABLE'
-    AND NOT EXISTS (
-      SELECT 1
-      FROM information_schema.columns c
-      WHERE c.table_schema = t.table_schema
-        AND c.table_name = t.table_name
-        AND c.column_name NOT IN (
-          SELECT kcu.column_name
-          FROM information_schema.key_column_usage kcu
-          JOIN information_schema.table_constraints tc
-            ON tc.constraint_name = kcu.constraint_name
-            AND tc.table_schema = kcu.table_schema
-          WHERE tc.constraint_type = 'FOREIGN KEY'
-            AND kcu.table_schema = t.table_schema
-            AND kcu.table_name = t.table_name
-        )
-    )
-`;
-	/**
-	* Asynchronously detect junction (link) tables in the `public` schema.
-	*
-	* A junction table is defined as a table where **every** column participates in
-	* at least one foreign-key constraint.
-	*
-	* @param executeSql - A callback that executes a raw SQL string and returns the
-	*                     resulting rows.
-	* @returns A `Set` containing the names of all detected junction tables.
-	*/
-	async function detectJunctionTables(executeSql) {
-		const rows = await executeSql(JUNCTION_TABLES_SQL);
-		const junctionTables = /* @__PURE__ */ new Set();
-		for (const row of rows) if (typeof row.table_name === "string") junctionTables.add(row.table_name);
-		return junctionTables;
-	}
-	//#endregion
-	exports.COLLECTION_PATH_SEPARATOR = COLLECTION_PATH_SEPARATOR;
-	exports.CollectionRegistry = CollectionRegistry;
-	exports.DEFAULT_ONE_OF_TYPE = DEFAULT_ONE_OF_TYPE;
-	exports.DEFAULT_ONE_OF_VALUE = DEFAULT_ONE_OF_VALUE;
-	exports.JUNCTION_TABLES_SQL = JUNCTION_TABLES_SQL;
-	exports.QueryBuilder = QueryBuilder;
-	exports.REBASE_INTERNAL_PREFIXES = REBASE_INTERNAL_PREFIXES;
-	exports.REBASE_INTERNAL_SCHEMAS = REBASE_INTERNAL_SCHEMAS;
-	exports.addInitialSlash = addInitialSlash;
-	exports.and = and;
-	exports.applyPropertyConditions = applyPropertyConditions;
-	exports.buildCollection = buildCollection;
-	exports.buildConditionContext = buildConditionContext;
-	exports.buildProperty = buildProperty;
-	exports.buildPropertyCallbacks = buildPropertyCallbacks;
-	exports.buildRebaseData = buildRebaseData;
-	exports.buildRoutedRebaseData = buildRoutedRebaseData;
-	exports.buildSdkData = buildSdkData;
-	exports.canCreateEntity = canCreateEntity;
-	exports.canDeleteEntity = canDeleteEntity;
-	exports.canEditEntity = canEditEntity;
-	exports.canReadCollection = canReadCollection;
-	exports.checkOperation = checkOperation;
-	exports.classifyTable = classifyTable;
-	exports.cond = cond;
-	exports.createDataSourceRegistry = createDataSourceRegistry;
-	exports.createRelationRef = createRelationRef;
-	exports.createRelationRefWithData = createRelationRefWithData;
-	exports.defaultUsersCollection = defaultUsersCollection;
-	exports.defineCollection = defineCollection;
-	exports.deserializeFilter = deserializeFilter;
-	exports.deserializeLogicalCondition = deserializeLogicalCondition;
-	exports.deserializeOrderBy = deserializeOrderBy;
-	exports.detectJunctionTables = detectJunctionTables;
-	exports.enumToObjectEntries = enumToObjectEntries;
-	exports.evaluateCondition = evaluateCondition;
-	exports.evaluatePolicy = evaluatePolicy;
-	exports.findRelation = findRelation;
-	exports.fullPathToCollectionSegments = fullPathToCollectionSegments;
-	exports.getArrayResolvedProperties = getArrayResolvedProperties;
-	exports.getCollectionBySlugWithin = getCollectionBySlugWithin;
-	exports.getCollectionPathsCombinations = getCollectionPathsCombinations;
-	exports.getColumnName = getColumnName;
-	exports.getDefaultValueFor = getDefaultValueFor;
-	exports.getDefaultValueFortype = getDefaultValueFortype;
-	exports.getDefaultValuesFor = getDefaultValuesFor;
-	exports.getEntityImagePreviewPropertyKey = getEntityImagePreviewPropertyKey;
-	exports.getEnumVarName = getEnumVarName;
-	exports.getLabelOrConfigFrom = getLabelOrConfigFrom;
-	exports.getLastSegment = getLastSegment;
-	exports.getLocalChangesBackup = getLocalChangesBackup;
-	exports.getNavigationEntriesFromPath = getNavigationEntriesFromPath;
-	exports.getParentReferencesFromPath = getParentReferencesFromPath;
-	exports.getPrimaryKeys = getPrimaryKeys;
-	exports.getReferenceFrom = getReferenceFrom;
-	exports.getRelationFrom = getRelationFrom;
-	exports.getSubcollections = getSubcollections;
-	exports.getTableName = getTableName;
-	exports.getTableVarName = getTableVarName;
-	exports.isHidden = isHidden;
-	exports.isPropertyBuilder = isPropertyBuilder;
-	exports.isReadOnly = isReadOnly;
-	exports.isRebaseInternalTable = isRebaseInternalTable;
-	exports.normalizeToEntityRelation = normalizeToEntityRelation;
-	exports.or = or;
-	exports.policyToPostgres = policyToPostgres;
-	exports.registerConditionOperations = registerConditionOperations;
-	exports.removeInitialAndTrailingSlashes = removeInitialAndTrailingSlashes;
-	exports.removeInitialSlash = removeInitialSlash;
-	exports.removeTrailingSlash = removeTrailingSlash;
-	exports.resolveArrayProperties = resolveArrayProperties;
-	exports.resolveCollectionPathIds = resolveCollectionPathIds;
-	exports.resolveCollectionRelations = resolveCollectionRelations;
-	exports.resolveDataSource = resolveDataSource;
-	exports.resolveDefaultSelectedView = resolveDefaultSelectedView;
-	exports.resolveEnumValues = resolveEnumValues;
-	exports.resolveFilterOperators = resolveFilterOperators;
-	exports.resolveProperties = resolveProperties;
-	exports.resolveProperty = resolveProperty;
-	exports.resolvePropertyEnum = resolvePropertyEnum;
-	exports.resolvePropertyRelation = resolvePropertyRelation;
-	exports.resolveRelationProperty = resolveRelationProperty;
-	exports.resolveStorageFilenameString = resolveStorageFilenameString;
-	exports.resolveStoragePathString = resolveStoragePathString;
-	exports.resolveStorageSource = resolveStorageSource;
-	exports.sanitizeData = sanitizeData;
-	exports.sanitizeRelation = sanitizeRelation;
-	exports.securityRuleToConditions = securityRuleToConditions;
-	exports.segmentsToStrippedPath = segmentsToStrippedPath;
-	exports.serializeFilter = serializeFilter;
-	exports.serializeLogicalCondition = serializeLogicalCondition;
-	exports.serializeOrderBy = serializeOrderBy;
-	exports.sortProperties = sortProperties;
-	exports.stripCollectionPath = stripCollectionPath;
-	exports.traverseValueProperty = traverseValueProperty;
-	exports.traverseValuesProperties = traverseValuesProperties;
-	exports.updateDateAutoValues = updateDateAutoValues;
-	exports.wrapAsEntityData = wrapAsEntityData;
-	exports.wrapAsSdkData = wrapAsSdkData;
-});
-
-//# sourceMappingURL=index.umd.js.map