@rebasepro/server 0.12.0 → 0.12.1-canary.gdfba2a1

package/dist/src-Ivjud8jD.js

@@ -1,957 +0,0 @@
-import { createRequire as __createRequire } from "module";
-import "process";
-__createRequire(import.meta.url);
-//#region ../types/src/errors.ts
-/**
-* The single error type thrown across the entire Rebase client surface —
-* HTTP data/control-plane calls, realtime/WebSocket operations, and
-* client-side logic errors (e.g. an unknown collection accessor). A `catch`
-* block only ever needs to check for this one class:
-*
-* ```ts
-* import { RebaseApiError } from "@rebasepro/client"; // re-exported
-*
-* try {
-*   await client.data.products.update(id, { price: 9 });
-* } catch (e) {
-*   if (e instanceof RebaseApiError) {
-*     if (e.status === 404) { ... }   // HTTP failures carry a status
-*     console.error(e.code, e.details);
-*   }
-* }
-* ```
-*
-* `status` is present for HTTP failures and `undefined` otherwise, so its
-* presence distinguishes transport-level errors from realtime/logic errors.
-*
-* @group Errors
-*/
-var RebaseApiError = class extends Error {
-	/** HTTP status code, or `undefined` for non-HTTP errors. */
-	status;
-	/** Stable machine-readable error code, when the server supplied one. */
-	code;
-	/** Structured error payload from the server, when present. */
-	details;
-	constructor(message, init = {}) {
-		super(message);
-		this.name = "RebaseApiError";
-		this.status = init.status;
-		this.code = init.code;
-		this.details = init.details;
-		if (init.cause !== void 0) this.cause = init.cause;
-	}
-};
-/**
-* Client-side logic error — raised before any request is made (e.g. accessing
-* an unknown collection accessor when a typed dictionary is configured).
-*
-* A subclass of {@link RebaseApiError} (with no `status`), so a single
-* `catch (e) { if (e instanceof RebaseApiError) ... }` handles it too.
-*
-* @group Errors
-*/
-var RebaseClientError = class extends RebaseApiError {
-	constructor(message) {
-		super(message);
-		this.name = "RebaseClientError";
-	}
-};
-//#endregion
-//#region ../types/src/types/entities.ts
-/**
-* Class used to create a reference to a entity in a different path.
-*
-* @example
-* // Simple reference (most common case - single driver, single db)
-* new EntityReference({ id: "123", path: "users" })
-*
-* // Reference to a different driver (e.g., Firestore)
-* new EntityReference({ id: "123", path: "analytics", driver: "firestore" })
-*
-* // Reference to a specific database within a driver
-* new EntityReference({ id: "123", path: "orders", driver: "postgres", databaseId: "orders_db" })
-*/
-var EntityReference = class {
-	__type = "reference";
-	/**
-	* ID of the entity
-	*/
-	id;
-	/**
-	* A string representing the path of the referenced document (relative
-	* to the root of the database).
-	*/
-	path;
-	/**
-	* Which driver (e.g., 'postgres', 'firestore').
-	* Defaults to "(default)" if not specified.
-	*/
-	driver;
-	/**
-	* Which database within the driver.
-	* Defaults to "(default)" if not specified.
-	*/
-	databaseId;
-	/**
-	* Create a reference to a entity.
-	*
-	* @example
-	* // Simple reference (most common case)
-	* new EntityReference({ id: "123", path: "users" })
-	*
-	* // With driver
-	* new EntityReference({ id: "123", path: "analytics", driver: "firestore" })
-	*/
-	constructor(props) {
-		this.id = props.id;
-		this.path = props.path;
-		this.driver = props.driver;
-		this.databaseId = props.databaseId;
-	}
-	get pathWithId() {
-		return `${this.path}/${this.id}`;
-	}
-	/**
-	* Get the full path including driver and database prefixes if specified.
-	* For the common case (single driver, single db), this just returns pathWithId.
-	*/
-	get fullPath() {
-		const parts = [];
-		if (this.driver && this.driver !== "(default)") parts.push(this.driver);
-		if (this.databaseId && this.databaseId !== "(default)") parts.push(this.databaseId);
-		if (parts.length > 0) return `${parts.join(":")}:::${this.path}/${this.id}`;
-		return this.pathWithId;
-	}
-	isEntityReference() {
-		return true;
-	}
-};
-/**
-* Class used to create a reference to a entity in a different path
-*/
-var EntityRelation = class {
-	__type = "relation";
-	/**
-	* ID of the entity
-	*/
-	id;
-	/**
-	* A string representing the path of the referenced document (relative
-	* to the root of the database).
-	*/
-	path;
-	/**
-	* Pre-fetched data payload to eliminate N+1 queries.
-	* When present, clients can use this directly instead of fetching.
-	*/
-	data;
-	constructor(id, path, data) {
-		this.id = id;
-		this.path = path;
-		this.data = data;
-	}
-	get pathWithId() {
-		return `${this.path}/${this.id}`;
-	}
-	isEntityReference() {
-		return false;
-	}
-	isEntityRelation() {
-		return true;
-	}
-};
-var GeoPoint = class {
-	/**
-	* The latitude of this GeoPoint instance.
-	*/
-	latitude;
-	/**
-	* The longitude of this GeoPoint instance.
-	*/
-	longitude;
-	constructor(latitude, longitude) {
-		this.latitude = latitude;
-		this.longitude = longitude;
-	}
-};
-var Vector = class {
-	value;
-	constructor(value) {
-		this.value = value;
-	}
-};
-//#endregion
-//#region ../types/src/types/filter-operators.ts
-/** Maps canonical operators to their REST short-code equivalents. */
-var CANONICAL_TO_REST = {
-	"==": "eq",
-	"!=": "neq",
-	">": "gt",
-	">=": "gte",
-	"<": "lt",
-	"<=": "lte",
-	"in": "in",
-	"not-in": "nin",
-	"array-contains": "cs",
-	"array-contains-any": "csa",
-	"like": "like",
-	"ilike": "ilike",
-	"not-like": "nlike",
-	"not-ilike": "nilike",
-	"is-null": "isnull",
-	"is-not-null": "notnull"
-};
-/** Maps REST short-code operators to their canonical equivalents. */
-var REST_TO_CANONICAL = {
-	"eq": "==",
-	"neq": "!=",
-	"gt": ">",
-	"gte": ">=",
-	"lt": "<",
-	"lte": "<=",
-	"in": "in",
-	"nin": "not-in",
-	"cs": "array-contains",
-	"csa": "array-contains-any",
-	"like": "like",
-	"ilike": "ilike",
-	"nlike": "not-like",
-	"nilike": "not-ilike",
-	"isnull": "is-null",
-	"notnull": "is-not-null"
-};
-/**
-* Operators that test for null/not-null and therefore ignore their value.
-* Codecs normalize the value of these conditions to `null`.
-*/
-var NULL_OPS = new Set(["is-null", "is-not-null"]);
-/**
-* Every canonical operator, in a stable order. Useful for engine capability
-* declarations ({@link DataSourceCapabilities.filterOperators}) and for
-* building operator subsets.
-* @group Models
-*/
-var ALL_WHERE_FILTER_OPS = [
-	"<",
-	"<=",
-	"==",
-	"!=",
-	">=",
-	">",
-	"in",
-	"not-in",
-	"array-contains",
-	"array-contains-any",
-	"like",
-	"ilike",
-	"not-like",
-	"not-ilike",
-	"is-null",
-	"is-not-null"
-];
-/** All canonical operator strings for runtime validation. */
-var CANONICAL_OPS = new Set(ALL_WHERE_FILTER_OPS);
-/**
-* Resolve any operator string (canonical or REST short-code) to its
-* canonical `WhereFilterOp` form. Returns `undefined` for unknown operators.
-*
-* @example
-* toCanonicalOp("==")   // "=="
-* toCanonicalOp("eq")   // "=="
-* toCanonicalOp("cs")   // "array-contains"
-* toCanonicalOp("xyz")  // undefined
-*/
-function toCanonicalOp(op) {
-	if (CANONICAL_OPS.has(op)) return op;
-	return REST_TO_CANONICAL[op];
-}
-//#endregion
-//#region ../types/src/types/admin_block.ts
-/**
-* The keys of a collection's admin block, as data.
-*
-* There is no *type* for the block in this package any more, and that is the point:
-* `admin` is not declared on `BaseCollectionConfig` or on any property here, so a
-* BaaS install cannot even write one. `@rebasepro/admin-types` adds the field back by
-* declaration merging, which is why installing it is what makes the admin surface
-* appear.
-*
-* The *list* still has to live here, because three runtime consumers need it and two
-* of them are core — see below.
-*/
-/**
-* Every key that belongs inside a collection's `admin` block, as data.
-*
-* The type that describes these fields is `AdminCollectionOptions` in
-* `@rebasepro/admin-types`, and it is erased at build time — but three runtime
-* consumers need the list, and two of them are core:
-*
-* - `serializeCollections`, to drop the block from the contract
-* - the ts-morph schema editor in `@rebasepro/server`, which rewrites collection
-*   files on disk from the admin panel and has to know where each key goes. A key
-*   missing from this list gets written to the *top level* of the file, where the
-*   backend ignores it and the panel never finds it again.
-* - the `collections-admin-block` codemod
-*
-* `@rebasepro/admin-types` re-exports this and asserts it names only real option
-* keys; the count is pinned by a test there.
-*
-* @group Models
-*/
-var ADMIN_COLLECTION_KEYS = [
-	"Actions",
-	"additionalFields",
-	"alwaysApplyDefaultValues",
-	"components",
-	"defaultEntityAction",
-	"defaultFilter",
-	"defaultSelectedView",
-	"defaultSize",
-	"defaultViewMode",
-	"disableDefaultActions",
-	"enabledViews",
-	"entityActions",
-	"entityViews",
-	"exportable",
-	"filterPresets",
-	"fixedFilter",
-	"formAutoSave",
-	"formView",
-	"group",
-	"hideFromNavigation",
-	"hideIdFromCollection",
-	"hideIdFromForm",
-	"icon",
-	"includeJsonView",
-	"inlineEditing",
-	"kanban",
-	"listProperties",
-	"localChangesBackup",
-	"openEntityMode",
-	"orderProperty",
-	"pagination",
-	"previewProperties",
-	"propertiesOrder",
-	"selectionController",
-	"selectionEnabled",
-	"sideDialogWidth",
-	"sort",
-	"titleProperty"
-];
-/**
-* Every key that belongs inside a *property's* `admin` block, as data.
-*
-* The union of `AdminPropertyOptions` and its per-type extensions
-* (`AdminStringOptions`, `AdminArrayOptions`, …) in `@rebasepro/admin-types`.
-* It lives here for the same reason {@link ADMIN_COLLECTION_KEYS} does: the
-* runtime consumers are core packages that the BaaS guard forbids from
-* importing `@rebasepro/admin-types`. Here it is the boot-time collection
-* validator in `@rebasepro/server`, which has to tell "you left `readOnly` at
-* the top of the property, where nothing reads it" apart from "you invented a
-* key we have never heard of".
-*
-* `@rebasepro/admin-types` re-exports this and asserts it names only real
-* option keys.
-*
-* @group Models
-*/
-var ADMIN_PROPERTY_KEYS = [
-	"canAddElements",
-	"clearable",
-	"columnWidth",
-	"customProps",
-	"disabled",
-	"expanded",
-	"Field",
-	"Filter",
-	"filterOperators",
-	"fixedFilter",
-	"hideFromCollection",
-	"includeEntityLink",
-	"includeId",
-	"markdown",
-	"minimalistView",
-	"multiline",
-	"Preview",
-	"previewAsTag",
-	"previewProperties",
-	"readOnly",
-	"sortable",
-	"spreadChildren",
-	"urlPreview",
-	"widget",
-	"widthPercentage"
-];
-//#endregion
-//#region ../types/src/types/data_source.ts
-/**
-* The default data-source key, used when a collection does not name a
-* `dataSource`. Shared by the frontend router and the backend driver
-* registry so both agree on "the default database".
-* @group Models
-*/
-var DEFAULT_DATA_SOURCE_KEY = "(default)";
-/**
-* Relation kinds assumed filterable when a driver does not say.
-*
-* `belongsTo` alone: its filter is a comparison on a column of the row being
-* filtered, the one shape that needs no query construction a driver might not
-* have. Everything else is a correlated subquery over another table.
-*
-* @group Models
-*/
-var DEFAULT_FILTERABLE_RELATION_KINDS = ["belongsTo"];
-/** @group Models */
-var POSTGRES_CAPABILITIES = {
-	key: "postgres",
-	label: "PostgreSQL",
-	supportsRelations: true,
-	supportsSubcollections: false,
-	supportsRLS: true,
-	supportsReferences: false,
-	supportsColumnTypes: true,
-	supportsRealtime: true,
-	supportsVectors: true,
-	filterOperators: ALL_WHERE_FILTER_OPS,
-	filterableRelationKinds: [
-		"belongsTo",
-		"manyToMany",
-		"hasMany",
-		"hasOne"
-	],
-	supportsSQLAdmin: true,
-	supportsDocumentAdmin: false,
-	supportsSchemaAdmin: true
-};
-/** @group Models */
-var FIREBASE_CAPABILITIES = {
-	key: "firestore",
-	label: "Firebase / Firestore",
-	supportsRelations: false,
-	supportsSubcollections: true,
-	supportsRLS: false,
-	supportsReferences: true,
-	supportsColumnTypes: false,
-	supportsRealtime: true,
-	supportsVectors: false,
-	filterOperators: ALL_WHERE_FILTER_OPS.filter((op) => op !== "like" && op !== "ilike" && op !== "not-like" && op !== "not-ilike"),
-	filterableRelationKinds: [],
-	supportsSQLAdmin: false,
-	supportsDocumentAdmin: false,
-	supportsSchemaAdmin: false
-};
-/** @group Models */
-var MONGODB_CAPABILITIES = {
-	key: "mongodb",
-	label: "MongoDB",
-	supportsRelations: false,
-	supportsSubcollections: true,
-	supportsRLS: false,
-	supportsReferences: true,
-	supportsColumnTypes: false,
-	supportsRealtime: false,
-	supportsVectors: false,
-	filterOperators: ALL_WHERE_FILTER_OPS,
-	filterableRelationKinds: [],
-	supportsSQLAdmin: false,
-	supportsDocumentAdmin: true,
-	supportsSchemaAdmin: true
-};
-/**
-* Fallback capabilities when the driver is unknown.
-* Enables everything so nothing is hidden unexpectedly.
-* @group Models
-*/
-var DEFAULT_CAPABILITIES = {
-	key: "(default)",
-	label: "Default",
-	supportsRelations: true,
-	supportsSubcollections: true,
-	supportsRLS: true,
-	supportsReferences: true,
-	supportsColumnTypes: true,
-	supportsRealtime: true,
-	supportsVectors: true,
-	filterOperators: ALL_WHERE_FILTER_OPS,
-	filterableRelationKinds: DEFAULT_FILTERABLE_RELATION_KINDS,
-	supportsSQLAdmin: true,
-	supportsDocumentAdmin: true,
-	supportsSchemaAdmin: true
-};
-var CAPABILITIES_REGISTRY = {
-	postgres: POSTGRES_CAPABILITIES,
-	firestore: FIREBASE_CAPABILITIES,
-	mongodb: MONGODB_CAPABILITIES,
-	"(default)": DEFAULT_CAPABILITIES
-};
-/**
-* Look up capabilities for a given engine key.
-* If `engine` is undefined or not found, returns `DEFAULT_CAPABILITIES`.
-* @group Models
-*/
-function getDataSourceCapabilities(engine) {
-	if (!engine) return POSTGRES_CAPABILITIES;
-	return CAPABILITIES_REGISTRY[engine] ?? DEFAULT_CAPABILITIES;
-}
-//#endregion
-//#region ../types/src/types/collections.ts
-/**
-* Type guard for PostgreSQL collections.
-* Returns true if the collection uses the Postgres engine (or the default engine).
-*
-* Generic over the *input* type, and narrows by intersection rather than
-* replacement. Narrowing to a bare `PostgresCollectionConfig` discarded whatever
-* the caller actually had — most visibly the admin panel's view model, whose
-* flattened presentation fields vanished the moment a collection passed through
-* one of these guards.
-*
-* @group Models
-*/
-function isPostgresCollectionConfig(collection) {
-	return !collection.engine || collection.engine === "postgres";
-}
-/**
-* Narrows to the SQL collection fields — `table`, `relations`,
-* `disableDefaultPolicies` — by asking the engine's declared capabilities
-* rather than by naming Postgres.
-*
-* The two halves of this already existed and were never joined. The engine
-* split (`PostgresCollectionConfig` / `FirebaseCollectionConfig` /
-* `MongoDBCollectionConfig`) said which fields belong to which engine at the
-* type level; {@link DataSourceCapabilities} said the same thing at runtime,
-* down to a `supportsRelations` flag. So call sites guarded on the capability
-* and then read a field the base type had to declare for them — which is why
-* those fields were on the base, and why a MongoDB collection could be written
-* with a `table`.
-*
-* Prefer this over {@link isPostgresCollectionConfig} wherever the question is
-* "does this collection live in a SQL table", so a custom SQL engine
-* registered through `registerDataSourceCapabilities` is included.
-*
-* @group Models
-*/
-function isRelationalCollectionConfig(collection) {
-	return getDataSourceCapabilities(collection.engine).supportsRelations;
-}
-/**
-* Type guard for Firebase / Firestore collections.
-* @group Models
-*/
-function isFirebaseCollectionConfig(collection) {
-	return collection.engine === "firestore";
-}
-/**
-* Type guard for MongoDB collections.
-* @group Models
-*/
-function isMongoDBCollectionConfig(collection) {
-	return collection.engine === "mongodb";
-}
-/**
-* Returns the data path for a collection.
-* For Firestore or MongoDB collections with a `path`, returns that value;
-* otherwise falls back to `slug`.
-*/
-function getCollectionDataPath(collection) {
-	if (isFirebaseCollectionConfig(collection) && collection.path) return collection.path;
-	if (isMongoDBCollectionConfig(collection) && collection.path) return collection.path;
-	return collection.slug;
-}
-/**
-* Reads a collection's driver-declared subcollections thunk (the `subcollections`
-* field) independent of engine identity, so engine-agnostic code doesn't have to
-* type-guard against a specific driver. Returns `undefined` when the collection
-* declares none.
-*
-* Pair with `getDataSourceCapabilities(engine).supportsSubcollections` to decide
-* whether the engine honours subcollections at all before reading them.
-* @group Models
-*/
-function getDeclaredSubcollections(collection) {
-	return collection.subcollections;
-}
-//#endregion
-//#region ../types/src/types/relations.ts
-/** @group Models */
-function isToMany(relation) {
-	return relation.cardinality === "many";
-}
-//#endregion
-//#region ../types/src/types/policy.ts
-/** @group Models */
-var policy = {
-	true: () => ({ kind: "true" }),
-	false: () => ({ kind: "false" }),
-	and: (...operands) => ({
-		kind: "and",
-		operands
-	}),
-	or: (...operands) => ({
-		kind: "or",
-		operands
-	}),
-	not: (operand) => ({
-		kind: "not",
-		operand
-	}),
-	compare: (left, op, right) => ({
-		kind: "compare",
-		op,
-		left,
-		right
-	}),
-	rolesOverlap: (roles) => ({
-		kind: "rolesOverlap",
-		roles
-	}),
-	rolesContain: (roles) => ({
-		kind: "rolesContain",
-		roles
-	}),
-	authenticated: () => ({ kind: "authenticated" }),
-	serverContext: () => ({ kind: "serverContext" }),
-	existsIn: (args) => ({
-		kind: "existsIn",
-		collection: args.collection,
-		where: args.where
-	}),
-	raw: (sql) => ({
-		kind: "raw",
-		sql
-	}),
-	field: (name) => ({
-		kind: "field",
-		name
-	}),
-	outerField: (name) => ({
-		kind: "outerField",
-		name
-	}),
-	literal: (value) => ({
-		kind: "literal",
-		value
-	}),
-	authUid: () => ({ kind: "authUid" }),
-	authRoles: () => ({ kind: "authRoles" })
-};
-//#endregion
-//#region ../types/src/types/backend.ts
-/**
-* Type guard: does this admin support SQL operations?
-* @group Admin
-*/
-function isSQLAdmin(admin) {
-	return !!admin && typeof admin.executeSql === "function";
-}
-//#endregion
-//#region ../types/src/types/storage_source.ts
-/**
-* Describes a named storage backend — a place files live.
-*
-* Declared once and shared front + back: the frontend uses it to decide
-* transport (HTTP proxy vs direct SDK), the backend uses the same `key`
-* to resolve a StorageController, and collection properties reference
-* a definition by its `key` via `StorageConfig.storageSource`.
-*
-* This mirrors the {@link DataSourceDefinition} pattern used for databases.
-*
-* @group Models
-*/
-/**
-* The default storage source key, used when a property does not specify
-* a `storageSource`. Shared by the frontend and backend registries so
-* both agree on "the default storage backend".
-* @group Models
-*/
-var DEFAULT_STORAGE_SOURCE_KEY = "(default)";
-/**
-* The environment-variable suffix for a storage or data source key.
-*
-* `""` for the default source — so a single-bucket project keeps configuring
-* plain `S3_BUCKET` — and `__<KEY>` for every named one, uppercased with
-* non-alphanumerics collapsed to underscores: `media-cdn` → `S3_BUCKET__MEDIA_CDN`.
-*
-* The rule derives the variable name from the declared key rather than
-* discovering keys by scanning the environment. Scanning would have to guess how
-* `S3_BUCKET__MEDIA_CDN` splits into a key; deriving cannot be ambiguous, and a
-* typo surfaces as a missing source at boot instead of a silently ignored
-* variable.
-*
-* It lives in this package, with no dependencies, because four things must agree
-* on it exactly: the CLI (validating a build), the runtime (reading its own
-* environment), the control plane (writing a tenant's Secret), and the docs. A
-* second implementation of a naming convention is a second chance to disagree.
-*
-* @group Models
-*/
-function storageEnvSuffix(key, defaultKey = DEFAULT_STORAGE_SOURCE_KEY) {
-	if (!key || key === defaultKey) return "";
-	const normalized = key.replace(/[^A-Za-z0-9]+/g, "_").replace(/^_+|_+$/g, "").toUpperCase();
-	if (!normalized) throw new Error(`Source key "${key}" cannot be turned into an environment variable name. Use a key containing at least one letter or digit.`);
-	return `__${normalized}`;
-}
-/**
-* Two distinct keys that collapse onto the same variable name, or `null`.
-*
-* `media-cdn` and `media_cdn` are different source keys but the same suffix, so
-* without this one of them silently reads the other's configuration. Returns the
-* offending pair rather than throwing, so each caller can raise it in its own
-* idiom — a `BundleError` at boot, a build failure in the CLI, a rejected deploy
-* in a control plane.
-*
-* @group Models
-*/
-function findStorageSuffixCollision(keys, defaultKey = DEFAULT_STORAGE_SOURCE_KEY) {
-	const seen = /* @__PURE__ */ new Map();
-	for (const key of keys) {
-		const suffix = storageEnvSuffix(key, defaultKey);
-		const existing = seen.get(suffix);
-		if (existing !== void 0 && existing !== key) return {
-			a: existing,
-			b: key,
-			suffix
-		};
-		seen.set(suffix, key);
-	}
-	return null;
-}
-/**
-* Merge the two places a project may declare storage sources into one list.
-*
-* `rebase.json` is authoritative for every field it states. Config code may add
-* sources it does not mention and fill in fields it left out, but may not
-* contradict it: the manifest is what a host reads to decide which buckets need
-* configuring, and a runtime that quietly disagreed with it would put the
-* console back to describing a topology the tenant does not have — the exact
-* failure this whole mechanism exists to end.
-*
-* Note what is *not* here: no default source is invented when both inputs are
-* empty. That decision belongs to the resolver, which knows whether declaring
-* nothing means "one plain bucket" (it does) or "no storage at all".
-*
-* @group Models
-*/
-function normalizeStorageSources(declared, exported) {
-	const merged = /* @__PURE__ */ new Map();
-	const declaredEntries = Array.isArray(declared) ? declared.filter((d) => d?.key).map((d) => [d.key, d]) : Object.entries(declared ?? {});
-	for (const [key, config] of declaredEntries) merged.set(key, {
-		key,
-		engine: config.engine,
-		transport: config.transport ?? "server",
-		...config.label !== void 0 ? { label: config.label } : {}
-	});
-	for (const definition of exported ?? []) {
-		if (!definition?.key) continue;
-		const existing = merged.get(definition.key);
-		if (!existing) {
-			merged.set(definition.key, {
-				key: definition.key,
-				engine: definition.engine,
-				transport: definition.transport ?? "server",
-				...definition.label !== void 0 ? { label: definition.label } : {}
-			});
-			continue;
-		}
-		if (existing.label === void 0 && definition.label !== void 0) existing.label = definition.label;
-	}
-	return Array.from(merged.values());
-}
-//#endregion
-//#region ../types/src/types/project_manifest.ts
-/** Header carrying the schema version an SDK was generated from. */
-var SCHEMA_VERSION_HEADER = "x-rebase-schema";
-//#endregion
-//#region ../types/src/types/collection_contract.ts
-/** Depth limit for the walk — deep enough for real configs, finite for cyclic ones. */
-var MAX_DEPTH = 64;
-/**
-* Resolve whatever a `target` thunk returns down to a collection.
-*
-* A target may be the collection, a module namespace (when the authoring file
-* used `import * as`), or a default-export wrapper. All three appear in real
-* projects, and the SDK generator already unwraps them the same way.
-*/
-function unwrapTarget(value) {
-	if (!value || typeof value !== "object") return void 0;
-	const candidate = value;
-	if (candidate.default || candidate.__esModule) {
-		const inner = candidate.default;
-		if (inner && typeof inner === "object") return inner;
-	}
-	if (candidate.properties) return value;
-}
-/** The identity a serialized reference uses. Slug first — it is the routing key. */
-function refFor(collection) {
-	if (!collection) return void 0;
-	const withPath = collection;
-	return collection.slug || withPath.path || collection.name;
-}
-function toSerializable(value, seen, depth, state, key) {
-	if (depth > MAX_DEPTH) {
-		state.truncations++;
-		return;
-	}
-	if (typeof value === "function") {
-		if (key === "target") try {
-			const ref = refFor(unwrapTarget(value()));
-			return ref ? { __collectionRef: ref } : void 0;
-		} catch {
-			return;
-		}
-		return;
-	}
-	if (value === null || typeof value !== "object") return value;
-	if (value instanceof Date) return value.toISOString();
-	if (value instanceof RegExp) return value.source;
-	if (seen.has(value)) {
-		state.truncations++;
-		return;
-	}
-	const cached = state.memo.get(value);
-	if (cached !== void 0) return cached;
-	seen.add(value);
-	const truncationsBefore = state.truncations;
-	const memoize = (result) => {
-		if (result !== void 0 && state.truncations === truncationsBefore) state.memo.set(value, result);
-		return result;
-	};
-	try {
-		if (Array.isArray(value)) {
-			const items = value.map((item) => toSerializable(item, seen, depth + 1, state)).filter((item) => item !== void 0);
-			return memoize(value.length > 0 && items.length === 0 ? void 0 : items);
-		}
-		if ("$$typeof" in value) return void 0;
-		const entries = Object.entries(value);
-		const out = {};
-		for (const [k, v] of entries) {
-			const converted = toSerializable(v, seen, depth + 1, state, k);
-			if (converted !== void 0) out[k] = converted;
-		}
-		if (entries.length > 0 && Object.keys(out).length === 0) return void 0;
-		return memoize(out);
-	} finally {
-		seen.delete(value);
-	}
-}
-/**
-* Serialize collections for transport over the contract endpoint.
-*
-* Sorted by slug so the output — and therefore the schema hash computed from it
-* — does not depend on filesystem ordering.
-*/
-function serializeCollections(collections) {
-	return [...collections].sort((a, b) => String(a.slug ?? "").localeCompare(String(b.slug ?? ""))).map((collection) => toSerializable(withoutAdminBlock(collection), /* @__PURE__ */ new WeakSet(), 0, {
-		memo: /* @__PURE__ */ new WeakMap(),
-		truncations: 0
-	})).filter((c) => c !== void 0);
-}
-/**
-* Drop the admin block before the walk.
-*
-* Nothing downstream of serialization is an admin panel. The contract endpoint
-* feeds remote SDK generation, and `rebase build` writes the result into a bundle
-* manifest that only the backend runtime reads. The block would survive the walk
-* as a husk anyway — its React elements and component functions are dropped
-* individually — and that husk has two costs worth avoiding: it puts every custom
-* component's *file path* on an endpoint whose job is to describe data shapes, and
-* it grows a payload that is fetched and cached per project.
-*
-* Removing it here rather than at each call site means one chokepoint, so a future
-* consumer of `serializeCollections` cannot forget.
-*
-* Child collections carry their own block, so this recurses — stripping only the
-* top level was the mistake `stripNonClientFields` in the contract routes already
-* had to fix once for security rules.
-*/
-function withoutAdminBlock(collection) {
-	const { admin: _admin, ...rest } = collection;
-	const nested = rest;
-	if (Array.isArray(nested.subcollections)) nested.subcollections = nested.subcollections.map((child) => withoutAdminBlock(child));
-	return rest;
-}
-//#endregion
-//#region ../types/src/types/schema_version.ts
-/**
-* The schema version stamp.
-*
-* One function, used in three places that must agree or the whole drift-detection
-* story is noise: `rebase build` writes it into a bundle manifest, the runtime
-* serves it from the contract endpoint, and a generated SDK records the value it
-* was built from. If any two of those computed it differently, every client would
-* look permanently out of date.
-*
-* It covers **collections only** — the client's contract is the shape of the
-* data, so editing a hook or a server function must not invalidate every SDK in
-* every repository. That is a deliberate narrowing, not an oversight.
-*/
-/** Stable stringify: object keys sorted at every level, so key order cannot alter the hash. */
-function canonicalize(value) {
-	if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
-	if (Array.isArray(value)) return `[${value.map(canonicalize).join(",")}]`;
-	return `{${Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${canonicalize(v)}`).join(",")}}`;
-}
-/**
-* Reduce a collection to the parts a generated client is actually built from.
-*
-* The version answers one question — "is this SDK stale?" — so it must change
-* exactly when the generated types could change, and never otherwise. Hashing a
-* whole collection fails both halves of that:
-*
-* - Security rules, callbacks, icons, groups and UI settings do not appear in a
-*   generated client, so including them reports perfectly current SDKs as stale.
-* - Worse, they are not stable *inputs*. The runtime applies default security
-*   rules when it loads collections, so the same source hashed before and after
-*   loading produced two different answers — a build-time stamp that could never
-*   match the server that served it.
-*
-* Codegen reads the slug (for the `Database` key and type names), the properties,
-* and the relations. That is the projection.
-*/
-function projectForCodegen(collection) {
-	const source = collection;
-	return {
-		slug: collection.slug ?? source.path,
-		properties: collection.properties,
-		relations: source.relations,
-		engine: source.engine,
-		dataSource: source.dataSource,
-		subcollections: source.subcollections?.map(projectForCodegen)
-	};
-}
-/**
-* Compute the canonical string a schema version hashes.
-*
-* Exposed separately so the hashing itself can differ by environment: Node has
-* `crypto`, and callers without it can still compare canonical forms directly.
-*/
-function canonicalSchemaPayload(collections) {
-	return canonicalize(serializeCollections(collections).map((collection) => projectForCodegen(collection)));
-}
-/**
-* A short, non-cryptographic digest of the canonical payload.
-*
-* FNV-1a style, 64 bits, as two 32-bit halves. This is an identity, not a
-* security boundary: nothing trusts a schema version to prove anything, it only
-* answers "is this the same schema as before". A hand-rolled hash keeps this
-* module free of `node:crypto`, so the identical function runs in the browser,
-* in the CLI, and in the runtime — which is the property that actually matters.
-*/
-function computeSchemaVersion(collections) {
-	const payload = canonicalSchemaPayload(collections);
-	let h1 = 2166136261;
-	let h2 = 16777619;
-	for (let i = 0; i < payload.length; i++) {
-		const code = payload.charCodeAt(i);
-		h1 ^= code;
-		h1 = h1 + ((h1 << 1) + (h1 << 4) + (h1 << 7) + (h1 << 8) + (h1 << 24)) >>> 0;
-		h2 ^= code + i;
-		h2 = h2 + ((h2 << 1) + (h2 << 5) + (h2 << 9) + (h2 << 15) + (h2 << 24)) >>> 0;
-	}
-	const hex = (n) => n.toString(16).padStart(8, "0");
-	return `v1:${hex(h1)}${hex(h2)}`;
-}
-//#endregion
-export { EntityReference as C, RebaseApiError as D, Vector as E, RebaseClientError as O, toCanonicalOp as S, GeoPoint as T, ADMIN_COLLECTION_KEYS as _, findStorageSuffixCollision as a, NULL_OPS as b, isSQLAdmin as c, getCollectionDataPath as d, getDeclaredSubcollections as f, getDataSourceCapabilities as g, DEFAULT_DATA_SOURCE_KEY as h, DEFAULT_STORAGE_SOURCE_KEY as i, policy as l, isRelationalCollectionConfig as m, serializeCollections as n, normalizeStorageSources as o, isPostgresCollectionConfig as p, SCHEMA_VERSION_HEADER as r, storageEnvSuffix as s, computeSchemaVersion as t, isToMany as u, ADMIN_PROPERTY_KEYS as v, EntityRelation as w, REST_TO_CANONICAL as x, CANONICAL_TO_REST as y };
-
-//# sourceMappingURL=src-Ivjud8jD.js.map