@rebasepro/types 0.11.1-canary.gfd39654 → 0.12.0

package/dist/controllers/collection_registry.d.ts

@@ -6,7 +6,7 @@ import type { EntityReference } from "../types/entities";
  */
 export type CollectionRegistryController<DB = Record<string, unknown>, EC extends CollectionConfig = CollectionConfig> = {
     /**
-     * List of the mapped collections in the CMS.
+     * List of the mapped collections in the admin.
      * Each entry relates to a collection in the root database.
      * Each of the navigation entries in this field
      * generates an entry in the main menu.

package/dist/controllers/data.d.ts

@@ -108,12 +108,12 @@ export interface FindResponse<M extends Record<string, unknown> = Record<string,
     };
 }
 /**
- * Fluent query builder for the **admin CMS** — resolves to `FindResponse<M>`
+ * Fluent query builder for the **admin admin** — resolves to `FindResponse<M>`
  * (Snapshot-wrapped rows).
  *
  * @internal App developers should use {@link SDKQueryBuilderInterface}
  * (flat rows, returned by `client.data.*` / `context.data.*`). This
- * Snapshot-flavored variant backs the admin CMS internals only.
+ * Snapshot-flavored variant backs the admin admin internals only.
  *
  * @group Data
  */
@@ -129,13 +129,13 @@ export interface QueryBuilderInterface<M extends Record<string, unknown> = Recor
     listen(onUpdate: (data: FindResponse<M>) => void, onError?: (error: Error) => void): () => void;
 }
 /**
- * A single collection's CRUD accessor for the **admin CMS** — every method
+ * A single collection's CRUD accessor for the **admin admin** — every method
  * resolves to `Snapshot`-wrapped rows (`FindResponse<M>` / `Snapshot<M>`).
  *
  * @internal App developers do **not** use this. The public, symmetric surface
  * is {@link SDKCollectionClient} (flat rows), exposed as `client.data.products`
  * in the SDK and `context.data.products` in framework callbacks. This
- * Snapshot-flavored accessor backs the admin CMS view-model only.
+ * Snapshot-flavored accessor backs the admin admin view-model only.
  *
  * @group Data
  */
@@ -222,6 +222,86 @@ export interface FindResult<M extends Record<string, unknown> = Record<string, u
     /** Pagination metadata */
     meta: PaginationMeta;
 }
+/**
+ * Which column an iteration seeks on, for keyset ("seek") pagination.
+ *
+ * Either the column name on its own — sorted ascending — or the column plus an
+ * explicit direction. The column must be **unique** and must be the column the
+ * query is ordered by; see {@link PageWalkOptions.cursor}.
+ *
+ * @group Data
+ */
+export type CursorSpec<M extends Record<string, unknown> = Record<string, unknown>> = (Extract<keyof M, string>) | {
+    field: Extract<keyof M, string>;
+    direction?: "asc" | "desc";
+};
+/**
+ * How {@link SDKCollectionClient.iterate} / {@link SDKCollectionClient.findAll}
+ * walk a collection, layered on top of the normal `find()` parameters.
+ *
+ * @group Data
+ */
+export interface PageWalkOptions<M extends Record<string, unknown> = Record<string, unknown>> {
+    /**
+     * Rows fetched per request. Defaults to 200; values below 1 are clamped up.
+     * This is the request size, not a result cap — the iteration keeps going
+     * until the server says there is nothing left.
+     */
+    pageSize?: number;
+    /**
+     * Paginate by **seeking on a column** instead of by offset.
+     *
+     * Offset paging — the default — re-counts rows on every request, so a row
+     * inserted or deleted *while the iteration runs* shifts the window and the
+     * walk silently skips or repeats rows. Seeking is immune to that: each page
+     * asks for rows strictly after the last one seen, so concurrent writes
+     * before the cursor cannot move it.
+     *
+     * Prefer this whenever the collection has a unique, sortable column
+     * (typically its primary key). The column must be unique — a repeated value
+     * at a page boundary either skips rows or stalls, and the iterator throws
+     * rather than looping — and the query is ordered by it, so a `cursor` and a
+     * conflicting `orderBy` is an error, not a silent override.
+     *
+     * Implemented with the parameters `find()` already takes (an `orderBy` plus
+     * a `>` / `<` filter on the cursor column), so it works on every transport
+     * and needs nothing new from the server.
+     *
+     * @example
+     * for await (const job of client.data.jobs.iterate({ cursor: "id" })) { … }
+     */
+    cursor?: CursorSpec<M>;
+    /**
+     * Hard ceiling on the number of requests one walk may make, so a server
+     * that never stops saying `hasMore` cannot spin forever. Defaults to
+     * 10 000 pages; hitting it throws.
+     */
+    maxPages?: number;
+}
+/**
+ * Parameters accepted by {@link SDKCollectionClient.iterate} — everything
+ * `find()` takes except the window itself (`limit`, `offset`, `page`), which
+ * the iterator owns, plus the walk options.
+ *
+ * @group Data
+ */
+export type IterateParams<M extends Record<string, unknown> = Record<string, unknown>> = Omit<FindParams<M>, "limit" | "offset" | "page"> & PageWalkOptions<M>;
+/**
+ * Parameters accepted by {@link SDKCollectionClient.findAll}: the iteration
+ * parameters plus the ceiling that keeps a whole collection from being pulled
+ * into memory unnoticed.
+ *
+ * @group Data
+ */
+export type FindAllParams<M extends Record<string, unknown> = Record<string, unknown>> = IterateParams<M> & {
+    /**
+     * Most rows to materialise. Defaults to 10 000. Exceeding it **throws**
+     * — a truncated array returned as if it were the whole answer is the
+     * kind of quiet wrong that shows up months later in a report. Pass
+     * `Infinity` to opt out deliberately, or use `iterate()` to stream.
+     */
+    maxRows?: number;
+};
 /**
  * Fluent Query Builder Interface for the SDK client.
  * Returns `FindResult<M>` (flat rows) instead of `FindResponse<M>` (Entity-wrapped).
@@ -244,7 +324,7 @@ export interface SDKQueryBuilderInterface<M extends Record<string, unknown> = Re
  * SDK collection client — returns flat rows, no Entity wrapper.
  *
  * This is the public API surface for app developers using
- * `createRebaseClient()`. CMS internals use `CollectionAccessor` instead.
+ * `createRebaseClient()`. admin internals use `CollectionAccessor` instead.
  *
  * Type parameters:
  * - `M` — the **Row** shape returned by reads (`find`, `findById`, `listen`).
@@ -290,6 +370,65 @@ export interface SDKCollectionClient<M extends Record<string, unknown> = Record<
      * Find multiple records with optional filtering, pagination, and sorting.
      */
     find(params?: FindParams<M>): Promise<FindResult<M>>;
+    /**
+     * Walk every record matching a query, one row at a time, fetching pages as
+     * the consumer consumes them.
+     *
+     * This is the pagination primitive: `find()` returns one window, `iterate()`
+     * returns all of them without the caller hand-rolling the
+     * `limit` / `offset += ` / "am I done yet" loop. Nothing is buffered — rows
+     * are yielded as each page arrives, so a million-row walk costs one page of
+     * memory. `break` stops the walk and no further requests are made.
+     *
+     * Termination is driven by the server's `meta.hasMore`, never by comparing
+     * a page's length against the requested limit — a final page that happens
+     * to be exactly full is indistinguishable that way, and a walk that stops
+     * there drops rows. An empty page also ends the walk, and
+     * {@link PageWalkOptions.maxPages} bounds a server that never stops saying
+     * there is more.
+     *
+     * ## Consistency
+     *
+     * By default this pages by **offset**, which is only as stable as the table
+     * is still: a row inserted or deleted ahead of the cursor between two
+     * requests shifts every later window, so the walk can skip a row or hand
+     * back the same one twice. That is inherent to offset paging, not a bug
+     * here. On a collection with a unique sortable column, pass
+     * {@link PageWalkOptions.cursor} to seek on it instead — the walk then
+     * asks for rows strictly after the last one it saw, which concurrent writes
+     * cannot perturb.
+     *
+     * @example
+     * for await (const job of client.data.jobs.iterate({
+     *     where: { status: ["==", "queued"] },
+     *     cursor: "id",
+     *     pageSize: 500
+     * })) {
+     *     await handle(job);
+     * }
+     */
+    iterate(params?: IterateParams<M>): AsyncIterableIterator<M>;
+    /**
+     * {@link iterate}, collected into an array.
+     *
+     * Convenient when the result is known to be small and awkward to stream.
+     * Because "known to be small" is an assumption and not a fact, the result is
+     * capped — 10 000 rows by default — and going over the cap **throws**
+     * rather than returning a short array that reads like a complete one. Raise
+     * {@link FindAllParams.maxRows} when the data really is bigger, or switch to
+     * `iterate()` and stream it.
+     *
+     * The offset-drift caveat on {@link iterate} applies here too.
+     *
+     * @throws When more rows match than `maxRows` allows.
+     *
+     * @example
+     * const overdue = await client.data.invoices.findAll({
+     *     where: { due_at: ["<", today] },
+     *     cursor: "id"
+     * });
+     */
+    findAll(params?: FindAllParams<M>): Promise<M[]>;
     /**
      * Find a single record by its ID.
      */
@@ -367,16 +506,16 @@ export interface SDKCollectionClient<M extends Record<string, unknown> = Record<
     include(...relations: string[]): SDKQueryBuilderInterface<M>;
 }
 /**
- * The unified data access object for the **admin CMS** (Entity-shaped).
+ * The unified data access object for the **admin admin** (Entity-shaped).
  *
  * Access collections as dynamic properties: `data.products.find(...)`. Each
  * accessor returns `Entity`-wrapped records (`{ id, path, values }`) — the
- * view-model the CMS renders. This is what `useData()` / the admin
+ * view-model the admin renders. This is what `useData()` / the admin
  * `RebaseContext.data` are backed by.
  *
  * @internal App developers do **not** use this — they use
  * {@link RebaseSdkData} (flat rows), which is what the SDK client and backend
- * `context.data` expose. This Entity-shaped map backs the admin CMS only.
+ * `context.data` expose. This Entity-shaped map backs the admin admin only.
  *
  * @group Data
  */
@@ -415,7 +554,7 @@ export type RebaseData<DB = unknown> = {
  *
  * Every accessor returns flat rows (the table's columns) via
  * {@link SDKCollectionClient} — access fields directly (`row.title`), never
- * `row.values.title`. The admin CMS uses {@link RebaseData} (Entity) instead.
+ * `row.values.title`. The admin uses {@link RebaseData} (Entity) instead.
  *
  * @example
  * // Frontend SDK

package/dist/index.es.js

@@ -336,6 +336,168 @@ var ADMIN_COLLECTION_KEYS = [
 	"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 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;
+}
+/**
+* Register custom capabilities for a third-party driver.
+* @group Models
+*/
+function registerDataSourceCapabilities(capabilities) {
+	CAPABILITIES_REGISTRY[capabilities.key] = capabilities;
+}
 //#endregion
 //#region src/types/collections.ts
 /**
@@ -354,6 +516,29 @@ 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
 */
@@ -523,101 +708,6 @@ function isChannelBusInstance(setting) {
 	return typeof setting?.publish === "function";
 }
 //#endregion
-//#region 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)";
-/** @group Models */
-var POSTGRES_CAPABILITIES = {
-	key: "postgres",
-	label: "PostgreSQL",
-	supportsRelations: true,
-	supportsSubcollections: false,
-	supportsRLS: true,
-	supportsReferences: false,
-	supportsColumnTypes: true,
-	supportsRealtime: true,
-	filterOperators: ALL_WHERE_FILTER_OPS,
-	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,
-	filterOperators: ALL_WHERE_FILTER_OPS.filter((op) => op !== "like" && op !== "ilike" && op !== "not-like" && op !== "not-ilike"),
-	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,
-	filterOperators: ALL_WHERE_FILTER_OPS,
-	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,
-	filterOperators: ALL_WHERE_FILTER_OPS,
-	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;
-}
-/**
-* Register custom capabilities for a third-party driver.
-* @group Models
-*/
-function registerDataSourceCapabilities(capabilities) {
-	CAPABILITIES_REGISTRY[capabilities.key] = capabilities;
-}
-//#endregion
 //#region src/types/storage_source.ts
 /**
 * Describes a named storage backend — a place files live.
@@ -638,6 +728,98 @@ function registerDataSourceCapabilities(capabilities) {
 * @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 src/types/component_ref.ts
 /**
@@ -656,8 +838,16 @@ function isLazyComponentRef(ref) {
 * not read. A runtime accepts any bundle whose `bundleFormat` is less than or
 * equal to its own — old bundles keep booting on new runtimes, which is the
 * whole point of separating the artifact from the engine.
+*
+* - **1** — `mode: "cms" | "baas" | "static"`, `entry.static` a single directory
+*   string, `entry.admin` for a bundled admin panel.
+* - **2** — `kind: "backend" | "static"`, `entry.static` a list of
+*   {@link RebaseBundleStatic}, `entry.admin` removed. A format-1 runtime reading
+*   one of these would find no `mode` and an array where it expects a string, so
+*   the bump is what turns that into a refusal to boot instead of a bundle that
+*   starts and serves nothing.
 */
-var BUNDLE_FORMAT_VERSION = 1;
+var BUNDLE_FORMAT_VERSION = 2;
 /**
 * The runtime contract major.
 *
@@ -955,6 +1145,6 @@ function isPublicStoragePath(path) {
 	return p.startsWith("public/") || p.startsWith(`default/public/`);
 }
 //#endregion
-export { ADMIN_COLLECTION_KEYS, ALL_WHERE_FILTER_OPS, ANONYMOUS_USER_ID, BUNDLE_FORMAT_VERSION, CANONICAL_TO_REST, DEFAULT_CAPABILITIES, DEFAULT_DATA_SOURCE_KEY, DEFAULT_LIST_LIMIT, DEFAULT_STORAGE_SOURCE_KEY, DEFAULT_VECTOR_LIST_LIMIT, EntityReference, EntityRelation, FIREBASE_CAPABILITIES, GeoPoint, MAX_LIST_LIMIT, MONGODB_CAPABILITIES, NULL_OPS, POSTGRES_CAPABILITIES, PUBLIC_STORAGE_PREFIX, REST_TO_CANONICAL, RUNTIME_CONTRACT_VERSION, RebaseApiError, RebaseClientError, SCHEMA_VERSION_HEADER, Vector, canonicalSchemaPayload, computeSchemaVersion, deserializeCollections, getCollectionDataPath, getDataSourceCapabilities, getDeclaredSubcollections, hasForeignKeyOnTarget, isBranchAdmin, isChannelBusInstance, isDocumentAdmin, isFirebaseCollectionConfig, isLazyComponentRef, isManyToMany, isMongoDBCollectionConfig, isPostgresCollectionConfig, isPublicStoragePath, isSQLAdmin, isSchemaAdmin, isSerializedCollectionRef, isToMany, policy, registerDataSourceCapabilities, resolveClientListLimit, serializeCollections, toCanonicalOp };
+export { ADMIN_COLLECTION_KEYS, ADMIN_PROPERTY_KEYS, ALL_WHERE_FILTER_OPS, ANONYMOUS_USER_ID, BUNDLE_FORMAT_VERSION, CANONICAL_TO_REST, DEFAULT_CAPABILITIES, DEFAULT_DATA_SOURCE_KEY, DEFAULT_FILTERABLE_RELATION_KINDS, DEFAULT_LIST_LIMIT, DEFAULT_STORAGE_SOURCE_KEY, DEFAULT_VECTOR_LIST_LIMIT, EntityReference, EntityRelation, FIREBASE_CAPABILITIES, GeoPoint, MAX_LIST_LIMIT, MONGODB_CAPABILITIES, NULL_OPS, POSTGRES_CAPABILITIES, PUBLIC_STORAGE_PREFIX, REST_TO_CANONICAL, RUNTIME_CONTRACT_VERSION, RebaseApiError, RebaseClientError, SCHEMA_VERSION_HEADER, Vector, canonicalSchemaPayload, computeSchemaVersion, deserializeCollections, findStorageSuffixCollision, getCollectionDataPath, getDataSourceCapabilities, getDeclaredSubcollections, hasForeignKeyOnTarget, isBranchAdmin, isChannelBusInstance, isDocumentAdmin, isFirebaseCollectionConfig, isLazyComponentRef, isManyToMany, isMongoDBCollectionConfig, isPostgresCollectionConfig, isPublicStoragePath, isRelationalCollectionConfig, isSQLAdmin, isSchemaAdmin, isSerializedCollectionRef, isToMany, normalizeStorageSources, policy, registerDataSourceCapabilities, resolveClientListLimit, serializeCollections, storageEnvSuffix, toCanonicalOp };
 
 //# sourceMappingURL=index.es.js.map