@rebasepro/common 0.5.0 → 0.6.1

package/dist/index.es.js

@@ -1,2536 +1,2174 @@
 import { EntityReference, EntityRelation, getDataSourceCapabilities } from "@rebasepro/types";
-import { mergeDeep, toSnakeCase, generateForeignKeyName, getIn as getIn$1, isDefaultFieldConfigId, randomString, removeFunctions, deepClone } from "@rebasepro/utils";
+import { deepClone, generateForeignKeyName, getIn, isDefaultFieldConfigId, mergeDeep, randomString, removeFunctions, toSnakeCase } from "@rebasepro/utils";
 import jsonLogic from "json-logic-js";
 import { deepEqual } from "fast-equals";
-const DEFAULT_ONE_OF_TYPE = "type";
-const DEFAULT_ONE_OF_VALUE = "value";
+//#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;
+	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);
+	return typeof property.ui?.disabled === "object" && Boolean(property.ui?.disabled.hidden);
 }
 function isPropertyBuilder(property) {
-  return typeof property?.dynamicProps === "function";
+	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
-  }), {});
+	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);
-  }
+	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;
-  }
-}
-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;
-    }
-  }) ?? {};
-}
+	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 an 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 an 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;
+	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 EntityReference({
-    id: entity.id,
-    path: entity.path,
-    driver: entity.driver,
-    databaseId: entity.databaseId
-  });
+	if (typeof entity.id !== "string") throw new Error("Only string IDs are supported in references");
+	return new EntityReference({
+		id: entity.id,
+		path: entity.path,
+		driver: entity.driver,
+		databaseId: entity.databaseId
+	});
 }
 function getRelationFrom(entity) {
-  return new EntityRelation(entity.id, entity.path, entity);
-}
-function normalizeToEntityRelation(value) {
-  if (value instanceof EntityRelation) return value;
-  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  const obj = value;
-  const isRelationLike = obj.__type === "relation" || obj.__type === "reference" || typeof obj.isEntityRelation === "function" && obj.isEntityRelation() || typeof obj.isEntityReference === "function" && obj.isEntityReference();
-  if (!isRelationLike) return null;
-  return new EntityRelation(obj.id, obj.path, obj.data);
+	return new 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 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 EntityRelation(obj.id, obj.path, obj.data);
 }
 function traverseValuesProperties(inputValues, properties, operation) {
-  const safeInputValues = inputValues ?? {};
-  const updatedValues = Object.entries(properties).map(([key, property]) => {
-    const inputValue = safeInputValues && safeInputValues[key];
-    const updatedValue = traverseValueProperty(inputValue, property, operation);
-    if (updatedValue === null) return null;
-    if (updatedValue === void 0) return void 0;
-    return {
-      [key]: updatedValue
-    };
-  }).reduce((a, b) => ({
-    ...a,
-    ...b
-  }), {});
-  const result = mergeDeep(safeInputValues, updatedValues);
-  if (!result || Object.keys(result).length === 0) return void 0;
-  return result;
+	const safeInputValues = inputValues ?? {};
+	const result = 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 ?? DEFAULT_ONE_OF_TYPE;
-      const valueField = property.oneOf?.valueField ?? DEFAULT_ONE_OF_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;
-}
+	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"
-  };
-}
+	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
-  };
-}
+	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;
-  }
+	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 void 0;
-  } else if (typeof defaultSelectedView === "string") {
-    return defaultSelectedView;
-  } else {
-    return 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;
-}
+	if (!collection.localChangesBackup) return "manual_apply";
+	return collection.localChangesBackup;
+}
+/**
+* Returns the primary keys for an 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"];
-}
+	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
-        };
-      }
-    });
-  }
+	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));
-}
-const COLLECTION_PATH_SEPARATOR = "::";
+	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));
+	return segmentsToStrippedPath(fullPathToCollectionSegments(path));
 }
 function segmentsToStrippedPath(paths) {
-  if (paths.length === 1) return paths[0];
-  return paths.reduce((a, b) => `${a}${COLLECTION_PATH_SEPARATOR}${b}`);
-}
+	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);
+	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 = 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 = toSnakeCase(sourceCollection.slug ?? sourceCollection.name);
-    if (newRelation.cardinality === "one" && newRelation.direction === "owning") {
-      if (!newRelation.localKey) {
-        newRelation.localKey = generateForeignKeyName(newRelation.relationName);
-      }
-    } else if (newRelation.cardinality === "one" && newRelation.direction === "inverse") {
-      if (!newRelation.foreignKeyOnTarget) {
-        let foundForeignKey = false;
-        try {
-          const targetRelations = getDataSourceCapabilities(targetCollection.driver).supportsRelations ? targetCollection.relations || [] : [];
-          for (const targetRel of targetRelations) {
-            if (targetRel.direction === "owning" && targetRel.cardinality === "one" && targetRel.localKey) {
-              try {
-                const targetRelTarget = targetRel.target();
-                if (targetRelTarget.slug === sourceCollection.slug) {
-                  newRelation.foreignKeyOnTarget = targetRel.localKey;
-                  foundForeignKey = true;
-                  break;
-                }
-              } catch (e) {
-                continue;
-              }
-            }
-          }
-        } catch (e) {
-        }
-        if (!foundForeignKey) {
-          const keyPrefix = newRelation.inverseRelationName ? toSnakeCase(newRelation.inverseRelationName) : sourceName;
-          newRelation.foreignKeyOnTarget = generateForeignKeyName(keyPrefix);
-        }
-      }
-    } else if (newRelation.cardinality === "many" && newRelation.direction === "inverse") {
-      let isManyToManyInverse = false;
-      if (newRelation.inverseRelationName && !newRelation.foreignKeyOnTarget) {
-        try {
-          const targetRelations = getDataSourceCapabilities(targetCollection.driver).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;
-              const relName = relProp.relationName || propKey;
-              if (relName === newRelation.inverseRelationName && relProp.cardinality === "many" && (relProp.direction === "owning" || !relProp.direction)) {
-                isManyToManyInverse = true;
-                break;
-              }
-            }
-          }
-        } catch (e) {
-        }
-      }
-      if (!isManyToManyInverse && !newRelation.foreignKeyOnTarget) {
-        newRelation.foreignKeyOnTarget = 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 ?? generateForeignKeyName(sourceName),
-        targetColumn: newRelation.through?.targetColumn ?? 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;
-}
-const _resolvedRelationsCache = /* @__PURE__ */ new WeakMap();
+	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 = 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 = toSnakeCase(sourceCollection.slug ?? sourceCollection.name);
+		if (newRelation.cardinality === "one" && newRelation.direction === "owning") {
+			if (!newRelation.localKey) newRelation.localKey = generateForeignKeyName(newRelation.relationName);
+		} else if (newRelation.cardinality === "one" && newRelation.direction === "inverse") {
+			if (!newRelation.foreignKeyOnTarget) {
+				let foundForeignKey = false;
+				try {
+					const targetRelations = getDataSourceCapabilities(targetCollection.driver).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 = generateForeignKeyName(newRelation.inverseRelationName ? toSnakeCase(newRelation.inverseRelationName) : sourceName);
+			}
+		} else if (newRelation.cardinality === "many" && newRelation.direction === "inverse") {
+			let isManyToManyInverse = false;
+			if (newRelation.inverseRelationName && !newRelation.foreignKeyOnTarget) try {
+				const targetRelations = getDataSourceCapabilities(targetCollection.driver).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 = 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 ?? generateForeignKeyName(sourceName),
+				targetColumn: newRelation.through?.targetColumn ?? 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 (!getDataSourceCapabilities(collection.driver).supportsRelations) return {};
-  const relCollection = collection;
-  const relations = {};
-  const registeredRelationNames = /* @__PURE__ */ new Set();
-  if (relCollection.relations) {
-    relCollection.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}'`);
-  return void 0;
+	const cached = _resolvedRelationsCache.get(collection);
+	if (cached) return cached;
+	if (!getDataSourceCapabilities(collection.driver).supportsRelations) return {};
+	const relCollection = collection;
+	const relations = {};
+	const registeredRelationNames = /* @__PURE__ */ new Set();
+	if (relCollection.relations) relCollection.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 (getDataSourceCapabilities(collection.driver).supportsRelations) {
-    return collection.table ?? toSnakeCase(collection.slug) ?? toSnakeCase(collection.name);
-  }
-  return toSnakeCase(collection.slug) ?? toSnakeCase(collection.name);
+	if (getDataSourceCapabilities(collection.driver).supportsRelations) return collection.table ?? toSnakeCase(collection.slug) ?? toSnakeCase(collection.name);
+	return toSnakeCase(collection.slug) ?? toSnakeCase(collection.name);
 }
 function getTableVarName(tableName) {
-  return tableName.replace(/_([a-z])/g, (_, char) => char.toUpperCase());
+	return tableName.replace(/_([a-z])/g, (_, char) => char.toUpperCase());
 }
 function getEnumVarName(tableName, propName) {
-  const tableVar = getTableVarName(tableName);
-  const propVar = propName.charAt(0).toUpperCase() + propName.slice(1);
-  return `${tableVar}${propVar}`;
+	return `${getTableVarName(tableName)}${propName.charAt(0).toUpperCase() + propName.slice(1)}`;
 }
 function getColumnName(fullColumn) {
-  return fullColumn.includes(".") ? fullColumn.split(".").pop() : 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];
-  return void 0;
-}
+	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 ? getIn$1(rest.values, rest.propertyKey) : void 0;
-      const dynamicProps = property.dynamicProps?.({
-        ...rest,
-        path,
-        propertyValue: usedPropertyValue,
-        values: rest.values ?? {},
-        previousValues: rest.previousValues ?? rest.values ?? {}
-      });
-      resultProperty = mergeDeep(property, dynamicProps ?? {});
-    }
-  } else {
-    resultProperty = property;
-  }
-  if (resultProperty?.dynamicProps && rest.path) {
-    const path = rest.path;
-    const usedPropertyValue = rest.propertyKey ? getIn$1(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 = 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 && !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 = mergeDeep(customFieldProperty, resolvedProperty);
-      }
-    }
-  }
-  return resolvedProperty;
+	const { property, ignoreMissingFields = false, ...rest } = props;
+	let resultProperty;
+	if (isPropertyBuilder(property)) {
+		const path = rest.path;
+		if (!path) resultProperty = property;
+		else {
+			const usedPropertyValue = rest.propertyKey ? getIn(rest.values, rest.propertyKey) : void 0;
+			const dynamicProps = property.dynamicProps?.({
+				...rest,
+				path,
+				propertyValue: usedPropertyValue,
+				values: rest.values ?? {},
+				previousValues: rest.previousValues ?? rest.values ?? {}
+			});
+			resultProperty = mergeDeep(property, dynamicProps ?? {});
+		}
+	} else resultProperty = property;
+	if (resultProperty?.dynamicProps && rest.path) {
+		const path = rest.path;
+		const usedPropertyValue = rest.propertyKey ? 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 = 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 && !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 = 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
-  };
-}
+	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;
-}
-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 ? getIn$1(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;
-      const ofProperty = resolveProperty({
-        // we don't want to pass the values of the parent entity
-        property: of,
-        ignoreMissingFields,
-        ...rest
-      });
-      if (!ofProperty && !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 ?? DEFAULT_ONE_OF_TYPE;
-    const resolvedProperties = 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)) : [];
-    return resolvedProperties;
-  } 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)) : [];
+	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 ? 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 void 0;
-  }
+	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() ?? [];
-  }
-  if (getDataSourceCapabilities(collection.driver).supportsSubcollections && collection.subcollections) {
-    return collection.subcollections() ?? [];
-  }
-  if (getDataSourceCapabilities(collection.driver).supportsRelations) {
-    const resolvedRelations = resolveCollectionRelations(collection);
-    const manyRelations = Object.values(resolvedRelations).filter((r) => r.cardinality === "many");
-    return manyRelations.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 ? mergeDeep(targetWithOverrides, r.overrides) : targetWithOverrides;
-    }).filter((c) => Boolean(c));
-  }
-  return [];
-}
+	if (collection.childCollections) return collection.childCollections() ?? [];
+	if (getDataSourceCapabilities(collection.driver).supportsSubcollections && collection.subcollections) return collection.subcollections() ?? [];
+	if (getDataSourceCapabilities(collection.driver).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 ? mergeDeep(targetWithOverrides, r.overrides) : targetWithOverrides;
+		}).filter((c) => Boolean(c));
+	}
+	return [];
+}
+//#endregion
+//#region src/util/permissions.ts
 function evaluateAST(sqlString, auth, entity) {
-  if (!entity) return true;
-  let cleanedSQL = sqlString.trim();
-  while (cleanedSQL.startsWith("(") && cleanedSQL.endsWith(")")) {
-    let openCount = 0;
-    let isEnclosing = true;
-    for (let i = 0; i < cleanedSQL.length - 1; i++) {
-      if (cleanedSQL[i] === "(") openCount++;
-      else if (cleanedSQL[i] === ")") openCount--;
-      if (openCount === 0) {
-        isEnclosing = false;
-        break;
-      }
-    }
-    if (isEnclosing) {
-      cleanedSQL = cleanedSQL.substring(1, cleanedSQL.length - 1).trim();
-    } else {
-      break;
-    }
-  }
-  const splitByTopLevel = (str, delimiter) => {
-    const parts = [];
-    let current = "";
-    let openCount = 0;
-    let i = 0;
-    while (i < str.length) {
-      if (str[i] === "(") openCount++;
-      else if (str[i] === ")") openCount--;
-      if (openCount === 0 && str.substring(i).toUpperCase().startsWith(delimiter)) {
-        parts.push(current);
-        current = "";
-        i += delimiter.length;
-      } else {
-        current += str[i];
-        i++;
-      }
-    }
-    parts.push(current);
-    return parts;
-  };
-  const orParts = splitByTopLevel(cleanedSQL, " OR ");
-  if (orParts.length > 1) {
-    return orParts.some((part) => evaluateAST(part, auth, entity));
-  }
-  const andParts = splitByTopLevel(cleanedSQL, " AND ");
-  if (andParts.length > 1) {
-    return andParts.every((part) => evaluateAST(part, auth, entity));
-  }
-  const upperSQL = cleanedSQL.toUpperCase();
-  if (upperSQL.includes(" IN ") || upperSQL.includes(" EXISTS ")) {
-    return true;
-  }
-  const roleIntersectMatch = cleanedSQL.match(/string_to_array\s*\(\s*auth\.roles\(\)\s*,\s*','\s*\)\s*&&\s*ARRAY\[(.*?)\]/i);
-  if (roleIntersectMatch && roleIntersectMatch[1]) {
-    const requiredRoles = roleIntersectMatch[1].split(",").map((r) => r.trim().replace(/'/g, ""));
-    const userRoles = auth.user?.roles || [];
-    return requiredRoles.some((r) => userRoles.includes(r));
-  }
-  const roleContainMatch = cleanedSQL.match(/string_to_array\s*\(\s*auth\.roles\(\)\s*,\s*','\s*\)\s*@>\s*ARRAY\[(.*?)\]/i);
-  if (roleContainMatch && roleContainMatch[1]) {
-    const requiredRoles = roleContainMatch[1].split(",").map((r) => r.trim().replace(/'/g, ""));
-    const userRoles = auth.user?.roles || [];
-    return requiredRoles.every((r) => userRoles.includes(r));
-  }
-  const pattern1 = new RegExp("^\\{?([a-zA-Z0-9_]+)\\}?\\s*=\\s*(?:current_setting\\s*\\(\\s*'app\\.user_id'\\s*\\)|auth\\.uid\\(\\))");
-  const pattern2 = new RegExp("^(?:current_setting\\s*\\(\\s*'app\\.user_id'\\s*\\)|auth\\.uid\\(\\))\\s*=\\s*\\{?([a-zA-Z0-9_]+)\\}?");
-  const match1 = cleanedSQL.match(pattern1);
-  if (match1 && match1[1]) {
-    return entity.values[match1[1]] === auth.user?.uid;
-  }
-  const match2 = cleanedSQL.match(pattern2);
-  if (match2 && match2[1]) {
-    return entity.values[match2[1]] === auth.user?.uid;
-  }
-  const simpleEqualityMatch = cleanedSQL.match(/^\{?([\w_]+)\}?\s*(=|!=)\s*'([^']+)'$/i);
-  if (simpleEqualityMatch) {
-    const field = simpleEqualityMatch[1];
-    const operator = simpleEqualityMatch[2];
-    const value = simpleEqualityMatch[3];
-    const entityValue = entity.values[field];
-    if (operator === "=") return entityValue === value;
-    if (operator === "!=") return entityValue !== value;
-  }
-  return true;
+	if (!entity) return true;
+	let cleanedSQL = sqlString.trim();
+	while (cleanedSQL.startsWith("(") && cleanedSQL.endsWith(")")) {
+		let openCount = 0;
+		let isEnclosing = true;
+		for (let i = 0; i < cleanedSQL.length - 1; i++) {
+			if (cleanedSQL[i] === "(") openCount++;
+			else if (cleanedSQL[i] === ")") openCount--;
+			if (openCount === 0) {
+				isEnclosing = false;
+				break;
+			}
+		}
+		if (isEnclosing) cleanedSQL = cleanedSQL.substring(1, cleanedSQL.length - 1).trim();
+		else break;
+	}
+	const splitByTopLevel = (str, delimiter) => {
+		const parts = [];
+		let current = "";
+		let openCount = 0;
+		let i = 0;
+		while (i < str.length) {
+			if (str[i] === "(") openCount++;
+			else if (str[i] === ")") openCount--;
+			if (openCount === 0 && str.substring(i).toUpperCase().startsWith(delimiter)) {
+				parts.push(current);
+				current = "";
+				i += delimiter.length;
+			} else {
+				current += str[i];
+				i++;
+			}
+		}
+		parts.push(current);
+		return parts;
+	};
+	const orParts = splitByTopLevel(cleanedSQL, " OR ");
+	if (orParts.length > 1) return orParts.some((part) => evaluateAST(part, auth, entity));
+	const andParts = splitByTopLevel(cleanedSQL, " AND ");
+	if (andParts.length > 1) return andParts.every((part) => evaluateAST(part, auth, entity));
+	const upperSQL = cleanedSQL.toUpperCase();
+	if (upperSQL.includes(" IN ") || upperSQL.includes(" EXISTS ")) return true;
+	const roleIntersectMatch = cleanedSQL.match(/string_to_array\s*\(\s*auth\.roles\(\)\s*,\s*','\s*\)\s*&&\s*ARRAY\[(.*?)\]/i);
+	if (roleIntersectMatch && roleIntersectMatch[1]) {
+		const requiredRoles = roleIntersectMatch[1].split(",").map((r) => r.trim().replace(/'/g, ""));
+		const userRoles = auth.user?.roles || [];
+		return requiredRoles.some((r) => userRoles.includes(r));
+	}
+	const roleContainMatch = cleanedSQL.match(/string_to_array\s*\(\s*auth\.roles\(\)\s*,\s*','\s*\)\s*@>\s*ARRAY\[(.*?)\]/i);
+	if (roleContainMatch && roleContainMatch[1]) {
+		const requiredRoles = roleContainMatch[1].split(",").map((r) => r.trim().replace(/'/g, ""));
+		const userRoles = auth.user?.roles || [];
+		return requiredRoles.every((r) => userRoles.includes(r));
+	}
+	const pattern1 = /* @__PURE__ */ new RegExp("^\\{?([a-zA-Z0-9_]+)\\}?\\s*=\\s*(?:current_setting\\s*\\(\\s*'app\\.user_id'\\s*\\)|auth\\.uid\\(\\))");
+	const pattern2 = /* @__PURE__ */ new RegExp("^(?:current_setting\\s*\\(\\s*'app\\.user_id'\\s*\\)|auth\\.uid\\(\\))\\s*=\\s*\\{?([a-zA-Z0-9_]+)\\}?");
+	const match1 = cleanedSQL.match(pattern1);
+	if (match1 && match1[1]) return entity.values[match1[1]] === auth.user?.uid;
+	const match2 = cleanedSQL.match(pattern2);
+	if (match2 && match2[1]) return entity.values[match2[1]] === auth.user?.uid;
+	const simpleEqualityMatch = cleanedSQL.match(/^\{?([\w_]+)\}?\s*(=|!=)\s*'([^']+)'$/i);
+	if (simpleEqualityMatch) {
+		const field = simpleEqualityMatch[1];
+		const operator = simpleEqualityMatch[2];
+		const value = simpleEqualityMatch[3];
+		const entityValue = entity.values[field];
+		if (operator === "=") return entityValue === value;
+		if (operator === "!=") return entityValue !== value;
+	}
+	return true;
 }
 function evaluateRule(rule, auth, entity) {
-  if (rule.access === "public") return true;
-  if (rule.ownerField) {
-    if (!entity) ;
-    else {
-      if (entity.values[rule.ownerField] !== auth.user?.uid) return false;
-    }
-  }
-  if (rule.using && !evaluateAST(rule.using, auth, entity)) return false;
-  if (rule.withCheck && !evaluateAST(rule.withCheck, auth, entity)) return false;
-  return true;
+	if (rule.access === "public") return true;
+	if (rule.ownerField) {
+		if (!entity) {} else if (entity.values[rule.ownerField] !== auth.user?.uid) return false;
+	}
+	if (rule.using && !evaluateAST(rule.using, auth, entity)) return false;
+	if (rule.withCheck && !evaluateAST(rule.withCheck, auth, entity)) return false;
+	return true;
 }
 function checkOperation(collection, authContext, entity, targetOperation) {
-  const securityRules = getDataSourceCapabilities(collection.driver).supportsRLS ? collection.securityRules : void 0;
-  if (!securityRules || securityRules.length === 0) {
-    return true;
-  }
-  const applicableRules = securityRules.filter((r) => r.operation === targetOperation || r.operation === "all" || r.operations?.includes(targetOperation) || r.operations?.includes("all"));
-  if (applicableRules.length === 0) return false;
-  const userRoleIds = authContext.user?.roles ?? [];
-  const userRoles = [...userRoleIds, "public"];
-  const roleApplicableRules = applicableRules.filter((rule) => {
-    if (!rule.roles || rule.roles.length === 0) return true;
-    return rule.roles.some((r) => userRoles.includes(r));
-  });
-  if (roleApplicableRules.length === 0) return false;
-  let grantedByPermissive = false;
-  let deniedByRestrictive = false;
-  for (const rule of roleApplicableRules) {
-    const mode = rule.mode || "permissive";
-    const passed = evaluateRule(rule, authContext, entity);
-    if (mode === "restrictive" && !passed) {
-      deniedByRestrictive = true;
-      break;
-    }
-    if (mode === "permissive" && passed) {
-      grantedByPermissive = true;
-    }
-  }
-  if (deniedByRestrictive) return false;
-  const hasPermissive = roleApplicableRules.some((r) => (r.mode || "permissive") === "permissive");
-  if (hasPermissive) {
-    return grantedByPermissive;
-  } else {
-    return false;
-  }
+	const securityRules = getDataSourceCapabilities(collection.driver).supportsRLS ? collection.securityRules : void 0;
+	if (!securityRules || securityRules.length === 0) return true;
+	const applicableRules = securityRules.filter((r) => r.operation === targetOperation || r.operation === "all" || r.operations?.includes(targetOperation) || r.operations?.includes("all"));
+	if (applicableRules.length === 0) return false;
+	const userRoles = [...authContext.user?.roles ?? [], "public"];
+	const roleApplicableRules = applicableRules.filter((rule) => {
+		if (!rule.roles || rule.roles.length === 0) return true;
+		return rule.roles.some((r) => userRoles.includes(r));
+	});
+	if (roleApplicableRules.length === 0) return false;
+	let grantedByPermissive = false;
+	let deniedByRestrictive = false;
+	for (const rule of roleApplicableRules) {
+		const mode = rule.mode || "permissive";
+		const passed = evaluateRule(rule, authContext, entity);
+		if (mode === "restrictive" && !passed) {
+			deniedByRestrictive = true;
+			break;
+		}
+		if (mode === "permissive" && passed) grantedByPermissive = true;
+	}
+	if (deniedByRestrictive) return false;
+	if (roleApplicableRules.some((r) => (r.mode || "permissive") === "permissive")) return grantedByPermissive;
+	else return false;
 }
 function canReadCollection(collection, authContext) {
-  return checkOperation(collection, authContext, null, "select");
+	return checkOperation(collection, authContext, null, "select");
 }
 function canEditEntity(collection, authContext, path, entity) {
-  return checkOperation(collection, authContext, entity, "update");
+	return checkOperation(collection, authContext, entity, "update");
 }
 function canCreateEntity(collection, authContext, path, entity) {
-  return checkOperation(collection, authContext, entity, "insert");
+	return checkOperation(collection, authContext, entity, "insert");
 }
 function canDeleteEntity(collection, authContext, path, entity) {
-  return checkOperation(collection, authContext, entity, "delete");
+	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.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;
-    }
-  }
-  return void 0;
-}
+	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.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));
+	return removeInitialSlash(removeTrailingSlash(s));
 }
 function removeInitialSlash(s) {
-  if (s.startsWith("/")) return s.slice(1);
-  else return 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;
+	if (s.endsWith("/")) return s.slice(0, -1);
+	else return s;
 }
 function addInitialSlash(s) {
-  if (s.startsWith("/")) return s;
-  else return `/${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;
+	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 an 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("/");
-}
+	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 an 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;
-}
+	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;
-}
+	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 subpaths = removeInitialAndTrailingSlashes(path).split("/");
-  const subpathCombinations = getCollectionPathsCombinations(subpaths);
-  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 path2 = collectionPath + "/" + entityId;
-        result.push({
-          type: "entity",
-          entityId,
-          slug: collectionPath,
-          path: path2,
-          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: path2 + "/" + customView.key,
-              view: customView
-            });
-          } else if (subcollections) {
-            result.push(...getNavigationEntriesFromPath({
-              path: newPath,
-              collections: subcollections,
-              currentFullPath: path2,
-              contextEntityViews: props.contextEntityViews
-            }));
-          }
-        }
-      }
-      break;
-    }
-  }
-  return result;
+	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;
-  }
+	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 subpaths = removeInitialAndTrailingSlashes(path).split("/");
-  const subpathCombinations = getCollectionPathsCombinations(subpaths);
-  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 path2 = collectionPath + "/" + entityId;
-        result.push(new 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: path2
-            }));
-          }
-        }
-      }
-      break;
-    }
-  }
-  return result;
-}
+	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 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
+/**
+* Identity function we use to defeat the type system of Typescript and build
+* collection views with all its properties
+* @param collection
+* @group Builder
+*/
 function buildCollection(collection) {
-  return collection;
-}
+	return collection;
+}
+/**
+* Identity function we use to defeat the type system of Typescript and preserve
+* the property keys.
+* @param property
+* @group Builder
+*/
 function buildProperty(property) {
-  return property;
-}
+	return property;
+}
+/**
+* Identity function we use to defeat the type system of Typescript and preserve
+* the properties keys.
+* @param properties
+* @group Builder
+*/
 function buildProperties(properties) {
-  return properties;
-}
+	return properties;
+}
+/**
+* Identity function we use to defeat the type system of Typescript and preserve
+* the properties keys.
+* @param propertiesOrBuilder
+* @group Builder
+*/
 function buildPropertiesOrBuilder(propertiesOrBuilder) {
-  return propertiesOrBuilder;
-}
+	return propertiesOrBuilder;
+}
+/**
+* Identity function we use to defeat the type system of Typescript and preserve
+* the properties keys.
+* @param enumValues
+* @group Builder
+*/
 function buildEnum(enumValues) {
-  return enumValues;
-}
+	return enumValues;
+}
+/**
+* Identity function we use to defeat the type system of Typescript and preserve
+* the properties keys.
+* @param enumValueConfig
+* @group Builder
+*/
 function buildEnumValueConfig(enumValueConfig) {
-  return enumValueConfig;
-}
+	return enumValueConfig;
+}
+/**
+* Identity function we use to defeat the type system of Typescript and preserve
+* the properties keys.
+* @param callbacks
+* @group Builder
+*/
 function buildEntityCallbacks(callbacks) {
-  return callbacks;
-}
+	return callbacks;
+}
+/**
+* Identity function we use to defeat the type system of Typescript and build
+* additional field delegates views with all its properties
+* @param additionalFieldDelegate
+* @group Builder
+*/
 function buildAdditionalFieldDelegate(additionalFieldDelegate) {
-  return additionalFieldDelegate;
-}
-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 = 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 = 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}", 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 = randomString() + "_" + file.name;
-  return result;
-}
+	return additionalFieldDelegate;
+}
+//#endregion
+//#region src/util/storage.ts
+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 = 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 = 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}", 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 = 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;
-}
+	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;
-          const singlePropData = {
-            "_tmp": property.of
-          };
-          const res = await processProperties(singlePropData, {
-            "_tmp": item
-          }, {
-            "_tmp": prevItem
-          }, propsContext, callbackName);
-          return res["_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;
-}
-const buildPropertyCallbacks = (properties) => {
-  if (!properties) return void 0;
-  const propertyCallbacks = {};
-  if (hasPropertyCallbacks(properties, "afterRead")) {
-    propertyCallbacks.afterRead = async (props) => {
-      const processedValues = await processProperties(properties, props.entity.values, props.entity.values, props, "afterRead");
-      return {
-        ...props.entity,
-        values: 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;
+	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 EntityCallbacks object recursively.
+*/
+var buildPropertyCallbacks = (properties) => {
+	if (!properties) return void 0;
+	const propertyCallbacks = {};
+	if (hasPropertyCallbacks(properties, "afterRead")) propertyCallbacks.afterRead = async (props) => {
+		const processedValues = await processProperties(properties, props.entity.values, props.entity.values, props, "afterRead");
+		return {
+			...props.entity,
+			values: 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;
 };
-function getIn(obj, path) {
-  if (!obj || !path) return void 0;
-  return path.split(".").reduce((acc, part) => acc && acc[part], obj);
-}
-let operationsRegistered = false;
+//#endregion
+//#region src/util/conditions.ts
+/**
+* Access a nested property from an object via dot notation.
+*/
+function getIn$1(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;
-  jsonLogic.add_operation("hasRole", function(roleId) {
-    return this?.user?.roles?.includes(roleId) ?? false;
-  });
-  jsonLogic.add_operation("hasAnyRole", function(roleIds) {
-    if (!this?.user?.roles || !Array.isArray(roleIds)) return false;
-    return roleIds.some((role) => this.user.roles.includes(role));
-  });
-  jsonLogic.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();
-  });
-  jsonLogic.add_operation("isPast", (timestamp) => {
-    if (!timestamp) return false;
-    return timestamp < Date.now();
-  });
-  jsonLogic.add_operation("isFuture", (timestamp) => {
-    if (!timestamp) return false;
-    return timestamp > Date.now();
-  });
-  operationsRegistered = true;
-}
+	if (operationsRegistered) return;
+	jsonLogic.add_operation("hasRole", function(roleId) {
+		return this?.user?.roles?.includes(roleId) ?? false;
+	});
+	jsonLogic.add_operation("hasAnyRole", function(roleIds) {
+		if (!this?.user?.roles || !Array.isArray(roleIds)) return false;
+		return roleIds.some((role) => this.user.roles.includes(role));
+	});
+	jsonLogic.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();
+	});
+	jsonLogic.add_operation("isPast", (timestamp) => {
+		if (!timestamp) return false;
+		return timestamp < Date.now();
+	});
+	jsonLogic.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 jsonLogic.apply(rule, context);
+	registerConditionOperations();
+	return jsonLogic.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;
-}
+	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 ?? {});
-  const serializedPreviousValues = serializeValueForConditions(previousValues ?? values ?? {});
-  return {
-    values: serializedValues,
-    previousValues: serializedPreviousValues,
-    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()
-  };
-}
+	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$1(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) {
-    const isDisabled = evaluateCondition(conditions.disabled, context);
-    if (isDisabled) {
-      result.ui = result.ui || {};
-      result.ui.disabled = {
-        clearOnDisabled: conditions.clearOnDisabled ?? false,
-        disabledMessage: conditions.disabledMessage,
-        hidden: false
-      };
-    }
-  }
-  if (conditions.hidden) {
-    const isHidden2 = evaluateCondition(conditions.hidden, context);
-    if (isHidden2) {
-      result.ui = result.ui || {};
-      result.ui.disabled = {
-        ...typeof result.ui?.disabled === "object" ? result.ui.disabled : {},
-        hidden: true,
-        clearOnDisabled: conditions.clearOnDisabled ?? false
-      };
-    }
-  }
-  if (conditions.readOnly) {
-    const isReadOnly2 = evaluateCondition(conditions.readOnly, context);
-    if (isReadOnly2) {
-      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;
-}
+	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 [];
-}
+	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 allowed = evaluateCondition(conditions.allowedEnumValues, context);
-    const allowedArray = objectToArray(allowed);
-    if (allowedArray.length > 0) {
-      result = result.filter((ev) => allowedArray.includes(String(ev.id)));
-    }
-  }
-  if (conditions.excludedEnumValues) {
-    const excluded = evaluateCondition(conditions.excludedEnumValues, context);
-    const excludedArray = objectToArray(excluded);
-    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;
-}
-class CollectionRegistry {
-  // Normalized runtime layer (used by Data Grid / UI)
-  collectionsByTableName = /* @__PURE__ */ new Map();
-  collectionsBySlug = /* @__PURE__ */ new Map();
-  rootCollections = [];
-  cachedCollectionsList = null;
-  // Raw configuration layer (used by Collection Editor AST generator)
-  rawCollectionsByTableName = /* @__PURE__ */ new Map();
-  rawCollectionsBySlug = /* @__PURE__ */ new Map();
-  rawRootCollections = [];
-  cachedRawCollectionsList = null;
-  // Snapshot of raw input for idempotency check — compared BEFORE normalization
-  // to avoid the issue where normalization creates new objects that always fail equality.
-  lastRawInputSnapshot = null;
-  constructor(collections) {
-    if (collections) {
-      this.registerMultiple(collections);
-    }
-  }
-  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
-   * snapshot. Only re-normalizes and re-registers when the raw input actually changed.
-   * @param collections
-   */
-  registerMultiple(collections) {
-    const rawSnapshot = collections.map((c) => removeFunctions(c));
-    if (this.lastRawInputSnapshot && deepEqual(this.lastRawInputSnapshot, rawSnapshot)) {
-      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 = 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
-          }), deepClone(subCollection));
-        });
-      }
-    });
-    this.lastRawInputSnapshot = rawSnapshot;
-    return true;
-  }
-  register(collection, rawCollection) {
-    const raw = rawCollection ? deepClone(rawCollection) : 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
-        }), deepClone(subCollection));
-      });
-    }
-  }
-  normalizeCollection(collection) {
-    const result = {
-      ...collection
-    };
-    const extractedRelations = this.extractRelationsFromProperties(result.properties);
-    const relResult = result;
-    const manualRelations = getDataSourceCapabilities(result.driver).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 (getDataSourceCapabilities(result.driver).supportsRelations) {
-      mergedRelations = mergedRelationsRaw.map((r) => {
-        try {
-          return sanitizeRelation(r, result, (slug) => this.get(slug));
-        } catch {
-          return r;
-        }
-      });
-      relResult.relations = mergedRelations;
-    }
-    const properties = this.normalizeProperties(result.properties, mergedRelations);
-    result.properties = properties;
-    if (!result.childCollections) {
-      if (getDataSourceCapabilities(result.driver).supportsSubcollections && result.subcollections) {
-        result.childCollections = result.subcollections;
-      } else if (getDataSourceCapabilities(result.driver).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 ? 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 (!getDataSourceCapabilities(currentCollection.driver).supportsRelations) {
-        throw new Error(`Relation path navigation requires a collection that supports relations, but '${currentCollection.slug}' uses driver '${currentCollection.driver}'`);
-      }
-      const resolvedRelations = resolveCollectionRelations(currentCollection);
-      const relation = findRelation(resolvedRelations, 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
-    };
-  }
-}
-const defaultUsersCollection = {
-  name: "Users",
-  singularName: "User",
-  slug: "users",
-  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",
-      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",
-      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"]
+	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/collections/CollectionRegistry.ts
+var CollectionRegistry = class {
+	collectionsByTableName = /* @__PURE__ */ new Map();
+	collectionsBySlug = /* @__PURE__ */ new Map();
+	rootCollections = [];
+	cachedCollectionsList = null;
+	rawCollectionsByTableName = /* @__PURE__ */ new Map();
+	rawCollectionsBySlug = /* @__PURE__ */ new Map();
+	rawRootCollections = [];
+	cachedRawCollectionsList = null;
+	lastRawInputSnapshot = null;
+	constructor(collections) {
+		if (collections) this.registerMultiple(collections);
+	}
+	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
+	* snapshot. Only re-normalizes and re-registers when the raw input actually changed.
+	* @param collections
+	*/
+	registerMultiple(collections) {
+		const rawSnapshot = collections.map((c) => removeFunctions(c));
+		if (this.lastRawInputSnapshot && deepEqual(this.lastRawInputSnapshot, rawSnapshot)) 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 = 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 }), deepClone(subCollection));
+			});
+		});
+		this.lastRawInputSnapshot = rawSnapshot;
+		return true;
+	}
+	register(collection, rawCollection) {
+		const raw = rawCollection ? deepClone(rawCollection) : 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 }), deepClone(subCollection));
+		});
+	}
+	normalizeCollection(collection) {
+		const result = { ...collection };
+		const extractedRelations = this.extractRelationsFromProperties(result.properties);
+		const relResult = result;
+		const manualRelations = getDataSourceCapabilities(result.driver).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 (getDataSourceCapabilities(result.driver).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) {
+			if (getDataSourceCapabilities(result.driver).supportsSubcollections && result.subcollections) result.childCollections = result.subcollections;
+			else if (getDataSourceCapabilities(result.driver).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 ? 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 (!getDataSourceCapabilities(currentCollection.driver).supportsRelations) throw new Error(`Relation path navigation requires a collection that supports relations, but '${currentCollection.slug}' uses driver '${currentCollection.driver}'`);
+			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 = {
+	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",
+			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
-  };
+	return {
+		type: "or",
+		conditions
+	};
 }
 function and(...conditions) {
-  return {
-    type: "and",
-    conditions
-  };
+	return {
+		type: "and",
+		conditions
+	};
 }
 function cond(column, operator, value) {
-  return {
-    column,
-    operator,
-    value
-  };
-}
-class QueryBuilder {
-  constructor(collection) {
-    this.collection = collection;
-  }
-  params = {
-    where: {}
-  };
-  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, ascending = "asc") {
-    this.params.orderBy = `${column}:${ascending}`;
-    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);
-  }
-}
+	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, ascending = "asc") {
+		this.params.orderBy = `${column}:${ascending}`;
+		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/buildRebaseData.ts
+/**
+* Convert where-clause filter object to the internal DataDriver FilterValues format.
+*
+* Supports multiple value formats:
+* - PostgREST string: { status: "eq.published", age: "gte.18" }
+* - Equality shorthand: { company_profile_id: null, status: "active", age: 18 }
+* - Tuple syntax: { age: [">=", 18], role: ["in", ["admin", "editor"]] }
+*
+* Internal:  { status: ["==", "published"], age: [">=", 18] }
+*/
 function convertWhereToFilter(where) {
-  if (!where) return void 0;
-  const operatorMap = {
-    "eq": "==",
-    "neq": "!=",
-    "gt": ">",
-    "gte": ">=",
-    "lt": "<",
-    "lte": "<=",
-    "in": "in",
-    "nin": "not-in",
-    "not-in": "not-in",
-    "cs": "array-contains",
-    "csa": "array-contains-any",
-    "==": "==",
-    "!=": "!=",
-    ">": ">",
-    ">=": ">=",
-    "<": "<",
-    "<=": "<=",
-    "array-contains": "array-contains",
-    "array-contains-any": "array-contains-any"
-  };
-  const filter = {};
-  for (const [field, rawValue] of Object.entries(where)) {
-    if (rawValue === null) {
-      filter[field] = ["==", null];
-      continue;
-    }
-    if (typeof rawValue === "boolean") {
-      filter[field] = ["==", rawValue];
-      continue;
-    }
-    if (typeof rawValue === "number") {
-      filter[field] = ["==", rawValue];
-      continue;
-    }
-    if (Array.isArray(rawValue)) {
-      const conditions = Array.isArray(rawValue[0]) ? rawValue : [rawValue];
-      const mappedConditions = conditions.map(([rawOp, val]) => {
-        const mappedOp = operatorMap[rawOp] ?? "==";
-        return [mappedOp, val];
-      });
-      filter[field] = Array.isArray(rawValue[0]) ? mappedConditions : mappedConditions[0];
-      continue;
-    }
-    if (typeof rawValue === "string") {
-      const dotIndex = rawValue.indexOf(".");
-      if (dotIndex === -1) {
-        filter[field] = ["==", rawValue];
-        continue;
-      }
-      const op = rawValue.substring(0, dotIndex);
-      let value = rawValue.substring(dotIndex + 1);
-      if (typeof value === "string" && value.startsWith("(") && value.endsWith(")")) {
-        value = value.slice(1, -1).split(",").map((v) => v.trim());
-      }
-      if (value === "null") {
-        value = null;
-      } else if (value === "true") {
-        value = true;
-      } else if (value === "false") {
-        value = false;
-      } else if (typeof value === "string" && !isNaN(Number(value)) && value.trim() !== "") {
-        value = Number(value);
-      }
-      const mappedOp = operatorMap[op];
-      if (mappedOp) {
-        filter[field] = [mappedOp, value];
-      }
-    }
-  }
-  return Object.keys(filter).length > 0 ? filter : void 0;
-}
+	if (!where) return void 0;
+	const operatorMap = {
+		"eq": "==",
+		"neq": "!=",
+		"gt": ">",
+		"gte": ">=",
+		"lt": "<",
+		"lte": "<=",
+		"in": "in",
+		"nin": "not-in",
+		"not-in": "not-in",
+		"cs": "array-contains",
+		"csa": "array-contains-any",
+		"==": "==",
+		"!=": "!=",
+		">": ">",
+		">=": ">=",
+		"<": "<",
+		"<=": "<=",
+		"array-contains": "array-contains",
+		"array-contains-any": "array-contains-any"
+	};
+	const filter = {};
+	for (const [field, rawValue] of Object.entries(where)) {
+		if (rawValue === null) {
+			filter[field] = ["==", null];
+			continue;
+		}
+		if (typeof rawValue === "boolean") {
+			filter[field] = ["==", rawValue];
+			continue;
+		}
+		if (typeof rawValue === "number") {
+			filter[field] = ["==", rawValue];
+			continue;
+		}
+		if (Array.isArray(rawValue)) {
+			const mappedConditions = (Array.isArray(rawValue[0]) ? rawValue : [rawValue]).map(([rawOp, val]) => {
+				return [operatorMap[rawOp] ?? "==", val];
+			});
+			filter[field] = Array.isArray(rawValue[0]) ? mappedConditions : mappedConditions[0];
+			continue;
+		}
+		if (typeof rawValue === "string") {
+			const dotIndex = rawValue.indexOf(".");
+			if (dotIndex === -1) {
+				filter[field] = ["==", rawValue];
+				continue;
+			}
+			const op = rawValue.substring(0, dotIndex);
+			let value = rawValue.substring(dotIndex + 1);
+			if (typeof value === "string" && value.startsWith("(") && value.endsWith(")")) value = value.slice(1, -1).split(",").map((v) => v.trim());
+			if (value === "null") value = null;
+			else if (value === "true") value = true;
+			else if (value === "false") value = false;
+			else if (typeof value === "string" && !isNaN(Number(value)) && value.trim() !== "") value = Number(value);
+			const mappedOp = operatorMap[op];
+			if (mappedOp) filter[field] = [mappedOp, value];
+		}
+	}
+	return Object.keys(filter).length > 0 ? filter : void 0;
+}
+/**
+* Parse an orderBy string like "created_at:desc" into [field, direction].
+*/
 function parseOrderBy(orderBy) {
-  if (!orderBy) return void 0;
-  const parts = orderBy.split(":");
-  const field = parts[0];
-  const direction = parts[1] || "asc";
-  return [field, direction];
+	if (!orderBy) return void 0;
+	const parts = orderBy.split(":");
+	return [parts[0], parts[1] || "asc"];
 }
 function createDriverAccessor(driver, slug) {
-  const accessor = {
-    async find(params) {
-      const orderParsed = parseOrderBy(params?.orderBy);
-      const entities = await driver.fetchCollection({
-        path: slug,
-        limit: params?.limit,
-        offset: params?.offset,
-        filter: convertWhereToFilter(params?.where),
-        orderBy: orderParsed?.[0],
-        order: orderParsed?.[1],
-        searchString: params?.searchString
-      });
-      const limit = params?.limit ?? 20;
-      const offset = params?.offset ?? 0;
-      return {
-        data: entities,
-        meta: {
-          total: entities.length,
-          limit,
-          offset,
-          hasMore: entities.length >= limit
-        }
-      };
-    },
-    async findById(id) {
-      return driver.fetchEntity({
-        path: slug,
-        entityId: id
-      });
-    },
-    async create(data, id) {
-      return driver.saveEntity({
-        path: slug,
-        values: data,
-        entityId: id,
-        status: "new"
-      });
-    },
-    async update(id, data) {
-      return driver.saveEntity({
-        path: slug,
-        values: data,
-        entityId: id,
-        status: "existing"
-      });
-    },
-    async delete(id) {
-      return driver.deleteEntity({
-        entity: {
-          id,
-          path: slug,
-          values: {}
-        }
-      });
-    },
-    deleteAll: driver.deleteAll ? async () => {
-      return driver.deleteAll(slug);
-    } : void 0,
-    count: driver.countEntities ? async (params) => {
-      return driver.countEntities({
-        path: slug,
-        filter: convertWhereToFilter(params?.where)
-      });
-    } : void 0,
-    listen: driver.listenCollection ? (params, onUpdate, onError) => {
-      const orderParsed = parseOrderBy(params?.orderBy);
-      const limit = params?.limit ?? 20;
-      const offset = params?.offset ?? 0;
-      return driver.listenCollection({
-        path: slug,
-        limit: params?.limit,
-        offset: params?.offset,
-        filter: convertWhereToFilter(params?.where),
-        orderBy: orderParsed?.[0],
-        order: orderParsed?.[1],
-        searchString: params?.searchString,
-        onUpdate: (entities) => {
-          onUpdate({
-            data: entities,
-            meta: {
-              total: entities.length,
-              limit,
-              offset,
-              hasMore: entities.length >= limit
-            }
-          });
-        },
-        onError
-      });
-    } : void 0,
-    listenById: driver.listenEntity ? (id, onUpdate, onError) => {
-      return driver.listenEntity({
-        path: slug,
-        entityId: id,
-        onUpdate: (entity) => onUpdate(entity ?? void 0),
-        onError
-      });
-    } : void 0,
-    // Fluent Query Builder
-    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;
-}
+	const accessor = {
+		async find(params) {
+			const orderParsed = parseOrderBy(params?.orderBy);
+			const entities = await driver.fetchCollection({
+				path: slug,
+				limit: params?.limit,
+				offset: params?.offset,
+				filter: convertWhereToFilter(params?.where),
+				orderBy: orderParsed?.[0],
+				order: orderParsed?.[1],
+				searchString: params?.searchString
+			});
+			const limit = params?.limit ?? 20;
+			const offset = params?.offset ?? 0;
+			return {
+				data: entities,
+				meta: {
+					total: entities.length,
+					limit,
+					offset,
+					hasMore: entities.length >= limit
+				}
+			};
+		},
+		async findById(id) {
+			return driver.fetchEntity({
+				path: slug,
+				entityId: id
+			});
+		},
+		async create(data, id) {
+			return driver.saveEntity({
+				path: slug,
+				values: data,
+				entityId: id,
+				status: "new"
+			});
+		},
+		async update(id, data) {
+			return driver.saveEntity({
+				path: slug,
+				values: data,
+				entityId: id,
+				status: "existing"
+			});
+		},
+		async delete(id) {
+			return driver.deleteEntity({ entity: {
+				id,
+				path: slug,
+				values: {}
+			} });
+		},
+		deleteAll: driver.deleteAll ? async () => {
+			return driver.deleteAll(slug);
+		} : void 0,
+		count: driver.countEntities ? async (params) => {
+			return driver.countEntities({
+				path: slug,
+				filter: convertWhereToFilter(params?.where)
+			});
+		} : void 0,
+		listen: driver.listenCollection ? (params, onUpdate, onError) => {
+			const orderParsed = parseOrderBy(params?.orderBy);
+			const limit = params?.limit ?? 20;
+			const offset = params?.offset ?? 0;
+			return driver.listenCollection({
+				path: slug,
+				limit: params?.limit,
+				offset: params?.offset,
+				filter: convertWhereToFilter(params?.where),
+				orderBy: orderParsed?.[0],
+				order: orderParsed?.[1],
+				searchString: params?.searchString,
+				onUpdate: (entities) => {
+					onUpdate({
+						data: entities,
+						meta: {
+							total: entities.length,
+							limit,
+							offset,
+							hasMore: entities.length >= limit
+						}
+					});
+				},
+				onError
+			});
+		} : void 0,
+		listenById: driver.listenEntity ? (id, onUpdate, onError) => {
+			return driver.listenEntity({
+				path: slug,
+				entityId: id,
+				onUpdate: (entity) => onUpdate(entity ?? 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: "eq.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;
-  }
-  const target = {
-    collection: getAccessor
-  };
-  return new Proxy(target, {
-    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;
-      const slug = toSnakeCase(prop);
-      return getAccessor(slug);
-    }
-  });
-}
-export {
-  COLLECTION_PATH_SEPARATOR,
-  CollectionRegistry,
-  DEFAULT_ONE_OF_TYPE,
-  DEFAULT_ONE_OF_VALUE,
-  QueryBuilder,
-  addInitialSlash,
-  and,
-  applyPropertyConditions,
-  buildAdditionalFieldDelegate,
-  buildCollection,
-  buildConditionContext,
-  buildEntityCallbacks,
-  buildEnum,
-  buildEnumValueConfig,
-  buildProperties,
-  buildPropertiesOrBuilder,
-  buildProperty,
-  buildPropertyCallbacks,
-  buildRebaseData,
-  canCreateEntity,
-  canDeleteEntity,
-  canEditEntity,
-  canReadCollection,
-  checkOperation,
-  cond,
-  createRelationRef,
-  createRelationRefWithData,
-  defaultUsersCollection,
-  enumToObjectEntries,
-  evaluateCondition,
-  findRelation,
-  fullPathToCollectionSegments,
-  getArrayResolvedProperties,
-  getCollectionBySlugWithin,
-  getCollectionPathsCombinations,
-  getColumnName,
-  getDefaultValueFor,
-  getDefaultValueFortype,
-  getDefaultValuesFor,
-  getEntityImagePreviewPropertyKey,
-  getEnumVarName,
-  getLabelOrConfigFrom,
-  getLastSegment,
-  getLocalChangesBackup,
-  getNavigationEntriesFromPath,
-  getParentReferencesFromPath,
-  getPrimaryKeys,
-  getReferenceFrom,
-  getRelationFrom,
-  getSubcollections,
-  getTableName,
-  getTableVarName,
-  isHidden,
-  isPropertyBuilder,
-  isReadOnly,
-  normalizeToEntityRelation,
-  or,
-  registerConditionOperations,
-  removeInitialAndTrailingSlashes,
-  removeInitialSlash,
-  removeTrailingSlash,
-  resolveArrayProperties,
-  resolveCollectionPathIds,
-  resolveCollectionRelations,
-  resolveDefaultSelectedView,
-  resolveEnumValues,
-  resolveProperties,
-  resolveProperty,
-  resolvePropertyEnum,
-  resolvePropertyRelation,
-  resolveRelationProperty,
-  resolveStorageFilenameString,
-  resolveStoragePathString,
-  sanitizeData,
-  sanitizeRelation,
-  segmentsToStrippedPath,
-  sortProperties,
-  stripCollectionPath,
-  traverseValueProperty,
-  traverseValuesProperties,
-  updateDateAutoValues
-};
-//# sourceMappingURL=index.es.js.map
+	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(toSnakeCase(prop));
+	} });
+}
+//#endregion
+export { COLLECTION_PATH_SEPARATOR, CollectionRegistry, DEFAULT_ONE_OF_TYPE, DEFAULT_ONE_OF_VALUE, QueryBuilder, addInitialSlash, and, applyPropertyConditions, buildAdditionalFieldDelegate, buildCollection, buildConditionContext, buildEntityCallbacks, buildEnum, buildEnumValueConfig, buildProperties, buildPropertiesOrBuilder, buildProperty, buildPropertyCallbacks, buildRebaseData, canCreateEntity, canDeleteEntity, canEditEntity, canReadCollection, checkOperation, cond, createRelationRef, createRelationRefWithData, defaultUsersCollection, enumToObjectEntries, evaluateCondition, findRelation, fullPathToCollectionSegments, getArrayResolvedProperties, getCollectionBySlugWithin, getCollectionPathsCombinations, getColumnName, getDefaultValueFor, getDefaultValueFortype, getDefaultValuesFor, getEntityImagePreviewPropertyKey, getEnumVarName, getLabelOrConfigFrom, getLastSegment, getLocalChangesBackup, getNavigationEntriesFromPath, getParentReferencesFromPath, getPrimaryKeys, getReferenceFrom, getRelationFrom, getSubcollections, getTableName, getTableVarName, isHidden, isPropertyBuilder, isReadOnly, normalizeToEntityRelation, or, registerConditionOperations, removeInitialAndTrailingSlashes, removeInitialSlash, removeTrailingSlash, resolveArrayProperties, resolveCollectionPathIds, resolveCollectionRelations, resolveDefaultSelectedView, resolveEnumValues, resolveProperties, resolveProperty, resolvePropertyEnum, resolvePropertyRelation, resolveRelationProperty, resolveStorageFilenameString, resolveStoragePathString, sanitizeData, sanitizeRelation, segmentsToStrippedPath, sortProperties, stripCollectionPath, traverseValueProperty, traverseValuesProperties, updateDateAutoValues };
+
+//# sourceMappingURL=index.es.js.map