@rebasepro/types 0.16.0 → 0.16.1-canary.g2d1aec8

package/dist/types/backend.d.ts

@@ -1,9 +1,10 @@
-import type { CollectionConfig, FilterValues, WhereFilterOp } from "./collections";
-import type { OrderByTuple } from "./filter-operators";
-import type { LogicalCondition } from "../controllers/data";
-import type { AuthAdapter } from "./auth_adapter";
-import type { HistoryConfig } from "../controllers/client";
-import type { ChannelBusSetting } from "./channel_bus";
+import type { CollectionConfig, FilterValues, WhereFilterOp } from "./collections.js";
+import type { OrderByTuple } from "./filter-operators.js";
+import type { LogicalCondition } from "../controllers/data.js";
+import type { AuthAdapter } from "./auth_adapter.js";
+import type { HistoryConfig } from "../controllers/client.js";
+import type { ChannelBusSetting } from "./channel_bus.js";
+import type { SchemaEditingAdmin } from "./schema_editing.js";
 /**
  * Abstract database connection interface.
  * Represents a connection to any database system.
@@ -433,7 +434,19 @@ export interface BranchAdmin {
  *
  * @group Admin
  */
-export type DatabaseAdmin = Partial<SQLAdmin> & Partial<DocumentAdmin> & Partial<SchemaAdmin> & Partial<BranchAdmin>;
+export type DatabaseAdmin = Partial<SQLAdmin> & Partial<DocumentAdmin> & Partial<SchemaAdmin> & Partial<BranchAdmin> & Partial<SchemaEditingAdmin>;
+/**
+ * Type guard: can this admin plan a live schema change?
+ *
+ * Planning is engine-specific — it renders DDL, a Drizzle schema and the
+ * declarative SQL artifacts — so the implementation lives in the driver
+ * package. The server detects the capability structurally, exactly as it does
+ * for SQL, rather than importing an engine it is supposed to know nothing
+ * about.
+ *
+ * @group Admin
+ */
+export declare function isSchemaEditingAdmin(admin: DatabaseAdmin | undefined): admin is SchemaEditingAdmin;
 /**
  * Type guard: does this admin support SQL operations?
  * @group Admin
@@ -697,7 +710,7 @@ export interface BackendBootstrapper {
     /**
      * Initialize WebSocket server for realtime operations.
      */
-    initializeWebsockets?(server: unknown, realtimeService: RealtimeProvider, driver: import("../controllers/data_driver").DataDriver, config?: unknown, authAdapter?: AuthAdapter): Promise<void> | void;
+    initializeWebsockets?(server: unknown, realtimeService: RealtimeProvider, driver: import("../controllers/data_driver.js").DataDriver, config?: unknown, authAdapter?: AuthAdapter): Promise<void> | void;
 }
 /**
  * Result of `BackendBootstrapper.initializeDriver()`.
@@ -705,7 +718,7 @@ export interface BackendBootstrapper {
  */
 export interface InitializedDriver {
     /** The DataDriver instance, ready for use. */
-    driver: import("../controllers/data_driver").DataDriver;
+    driver: import("../controllers/data_driver.js").DataDriver;
     /** The realtime service, if the driver created one during init. */
     realtimeProvider?: RealtimeProvider;
     /** A collection registry to register schema / tables into. */
@@ -716,7 +729,7 @@ export interface InitializedDriver {
      * Set by drivers that introspect in `baas` mode; the server serves these
      * instead of collections loaded from config files.
      */
-    collections?: import("./collections").CollectionConfig[];
+    collections?: import("./collections.js").CollectionConfig[];
     /** The underlying database connection (for lifecycle management). */
     connection?: DatabaseConnection;
     /**

package/dist/types/collection_contract.d.ts

@@ -1,4 +1,4 @@
-import type { CollectionConfig } from "./collections";
+import type { CollectionConfig } from "./collections.js";
 /**
  * Serializing collections so they survive a network hop.
  *

package/dist/types/collections.d.ts

@@ -1,9 +1,9 @@
-import type { CollectionCallbacks } from "./entity_callbacks";
-import type { Properties, PostgresProperties, FirebaseProperties, MongoProperties } from "./properties";
-import type { User } from "../users";
-import type { Relation } from "./relations";
-import type { SecurityRule } from "./security_rules";
-import type { SearchConfig } from "./search";
+import type { CollectionCallbacks } from "./entity_callbacks.js";
+import type { Properties, PostgresProperties, FirebaseProperties, MongoProperties } from "./properties.js";
+import type { User } from "../users/index.js";
+import type { Relation } from "./relations.js";
+import type { SecurityRule } from "./security_rules.js";
+import type { SearchConfig } from "./search.js";
 /**
  * Base interface containing all driver-agnostic collection properties.
  * Use {@link PostgresCollectionConfig} or {@link FirebaseCollectionConfig} for
@@ -475,7 +475,7 @@ export interface EntityChildView<M extends Record<string, unknown> = Record<stri
     collection: CollectionConfig<M>;
     source: ChildViewSource;
 }
-export type { WhereFilterOp, FilterValues, WireFilterValues, FilterPreset } from "./filter-operators";
+export type { WhereFilterOp, FilterValues, WireFilterValues, FilterPreset } from "./filter-operators.js";
 export type InferCollectionConfigType<S extends CollectionConfig> = S extends CollectionConfig<infer M> ? M : never;
 /**
  * Configuration for authentication collections.

package/dist/types/cron.d.ts

@@ -1,5 +1,5 @@
-import type { RebaseServerClient } from "../controllers/client";
-import type { RebaseSdkData } from "../controllers/data";
+import type { RebaseServerClient } from "../controllers/client.js";
+import type { RebaseSdkData } from "../controllers/data.js";
 /**
  * Cron Job type definitions for Rebase.
  *

package/dist/types/data_source.d.ts

@@ -1,4 +1,4 @@
-import { WhereFilterOp } from "./filter-operators";
+import { WhereFilterOp } from "./filter-operators.js";
 /**
  * Describes the capabilities and features supported by a data source (driver).
  *

package/dist/types/database_adapter.d.ts

@@ -19,10 +19,10 @@
  *
  * @group Backend
  */
-import type { DataDriver } from "../controllers/data_driver";
-import type { CollectionConfig } from "./collections";
-import type { CollectionRegistryInterface, DatabaseAdmin, InitializedDriver, RealtimeProvider, BootstrappedAuth } from "./backend";
-import type { HistoryConfig } from "../controllers/client";
+import type { DataDriver } from "../controllers/data_driver.js";
+import type { CollectionConfig } from "./collections.js";
+import type { CollectionRegistryInterface, DatabaseAdmin, InitializedDriver, RealtimeProvider, BootstrappedAuth } from "./backend.js";
+import type { HistoryConfig } from "../controllers/client.js";
 /**
  * A `DatabaseAdapter` provides data persistence for Rebase.
  *
@@ -74,7 +74,7 @@ export interface DatabaseAdapter {
      * here — turning an adapter-authenticated server's socket into one that
      * accepted every client as already authenticated.
      */
-    initializeWebsockets?(server: unknown, realtimeService: RealtimeProvider, driver: DataDriver, config?: unknown, adapter?: import("./auth_adapter").AuthAdapter): Promise<void> | void;
+    initializeWebsockets?(server: unknown, realtimeService: RealtimeProvider, driver: DataDriver, config?: unknown, adapter?: import("./auth_adapter.js").AuthAdapter): Promise<void> | void;
     /**
      * Bring the database's collection tables up to date, additively — the boot
      * companion to `db push`. See `BackendBootstrapper.ensureCollectionSchema`

package/dist/types/entities.d.ts

@@ -1,4 +1,4 @@
-import type { SearchMatch } from "./search";
+import type { SearchMatch } from "./search.js";
 /**
  * New or existing status
  * @group Models

package/dist/types/entity_callbacks.d.ts

@@ -1,7 +1,7 @@
-import type { CollectionConfig } from "./collections";
-import type { EntityStatus, EntityValues } from "./entities";
-import type { User } from "../users";
-import type { RebaseCallContext } from "../call_context";
+import type { CollectionConfig } from "./collections.js";
+import type { EntityStatus, EntityValues } from "./entities.js";
+import type { User } from "../users/index.js";
+import type { RebaseCallContext } from "../call_context.js";
 /**
  * Lifecycle callbacks for entity CRUD operations.
  *

package/dist/types/index.d.ts

@@ -1,29 +1,30 @@
-export * from "./entities";
-export * from "./filter-operators";
-export * from "./chips";
-export * from "./properties";
-export * from "./admin_block";
-export * from "./collections";
-export * from "./search";
-export * from "./relations";
-export * from "./policy";
-export * from "./rls-functions";
-export * from "./security_rules";
-export * from "./entity_callbacks";
-export * from "./websockets";
-export * from "./backend";
-export * from "./channel_bus";
-export * from "./data_source";
-export * from "./storage_source";
-export * from "./cron";
-export * from "./backup";
-export * from "./component_ref";
-export * from "./auth_adapter";
-export * from "./database_adapter";
-export * from "./api_keys";
-export * from "./history";
-export * from "./postgres_introspection";
-export * from "./project_manifest";
-export * from "./collection_contract";
-export * from "./schema_version";
-export * from "./storage_authorize";
+export * from "./entities.js";
+export * from "./filter-operators.js";
+export * from "./chips.js";
+export * from "./properties.js";
+export * from "./admin_block.js";
+export * from "./collections.js";
+export * from "./search.js";
+export * from "./relations.js";
+export * from "./policy.js";
+export * from "./rls-functions.js";
+export * from "./security_rules.js";
+export * from "./entity_callbacks.js";
+export * from "./websockets.js";
+export * from "./backend.js";
+export * from "./schema_editing.js";
+export * from "./channel_bus.js";
+export * from "./data_source.js";
+export * from "./storage_source.js";
+export * from "./cron.js";
+export * from "./backup.js";
+export * from "./component_ref.js";
+export * from "./auth_adapter.js";
+export * from "./database_adapter.js";
+export * from "./api_keys.js";
+export * from "./history.js";
+export * from "./postgres_introspection.js";
+export * from "./project_manifest.js";
+export * from "./collection_contract.js";
+export * from "./schema_version.js";
+export * from "./storage_authorize.js";

package/dist/types/project_manifest.d.ts

@@ -24,7 +24,7 @@
  * work: two repositories never need to know about each other, only about the
  * project.
  */
-import type { StorageSourceDefinition } from "./storage_source";
+import type { StorageSourceDefinition } from "./storage_source.js";
 /**
  * Which kind of thing an app is.
  *
@@ -313,6 +313,35 @@ export interface NativeDependency {
  * `manifest.json` — generated, and the document the runtime and control plane
  * both validate against.
  */
+/**
+ * One custom function, as recorded in a built bundle.
+ *
+ * @see RebaseBundleManifest.functions
+ */
+export interface RebaseBundleFunction {
+    /**
+     * The filename without its extension — which is also the URL segment it
+     * mounts at (`/api/functions/<name>`), the API-key permission that grants
+     * it, and the name `REBASE_FUNCTIONS_ONLY` selects by. One identity, used
+     * everywhere.
+     */
+    name: string;
+    /** Path inside the bundle, so a host can point at the file. */
+    file: string;
+    /**
+     * `false` when the function's own source imports a Node built-in or a
+     * package that needs one.
+     *
+     * Descriptive, never a gate: nothing refuses to build or deploy on this. It
+     * says where this function *could* run, not where it should.
+     */
+    portable: boolean;
+    /**
+     * Why it is not portable — one short phrase per reason, deduplicated.
+     * Absent when it is.
+     */
+    requires?: string[];
+}
 export interface RebaseBundleManifest {
     /** @see BUNDLE_FORMAT_VERSION */
     bundleFormat: number;
@@ -353,6 +382,28 @@ export interface RebaseBundleManifest {
     entry: RebaseBundleEntrypoints;
     /** Collection slugs contained in the bundle, for quick inspection. */
     collections?: string[];
+    /**
+     * Every custom function in the bundle, named and classified.
+     *
+     * Two things are recorded per function, and both are answers a host would
+     * otherwise have to get by importing user code:
+     *
+     * - **What it is called.** That name is the function's identity everywhere —
+     *   the URL segment it mounts at, the `functions/<name>` API-key
+     *   permission, the value `REBASE_FUNCTIONS_ONLY` selects by. A host that
+     *   wants to give one slow function its own replica count currently has to
+     *   boot the bundle to discover what is in it.
+     * - **Whether it needs Node.** Purely descriptive: a function that opens a
+     *   file or runs raw SQL is a fine function, and every deployment today is
+     *   a Node process. It is recorded because the question "which of these
+     *   could run somewhere else" has to be answerable from the artifact, and
+     *   because answering it per-file after the fact — across a codebase
+     *   already written — is the expensive version of the same question.
+     *
+     * Absent on a bundle built before this field existed, which is why every
+     * consumer must treat it as optional rather than as an empty list.
+     */
+    functions?: RebaseBundleFunction[];
     hooks: {
         /**
          * Whether the dependency closure contains native code.

package/dist/types/properties.d.ts

@@ -1,9 +1,9 @@
-import type { Entity, EntityReference, EntityRelation, EntityValues, GeoPoint, Vector } from "./entities";
-import type { Relation, ResolvedRelation } from "./relations";
-import type { ColorKey, ColorScheme } from "./chips";
-import type { AuthState } from "../controllers/auth_state";
-import type { AfterReadProps, BeforeSaveProps } from "./entity_callbacks";
-import type { User } from "../users";
+import type { Entity, EntityReference, EntityRelation, EntityValues, GeoPoint, Vector } from "./entities.js";
+import type { Relation, ResolvedRelation } from "./relations.js";
+import type { ColorKey, ColorScheme } from "./chips.js";
+import type { AuthState } from "../controllers/auth_state.js";
+import type { AfterReadProps, BeforeSaveProps } from "./entity_callbacks.js";
+import type { User } from "../users/index.js";
 /**
  * Callbacks/Hooks for individual property fields
  * @group Entity properties
@@ -324,6 +324,46 @@ export interface BooleanProperty extends BaseProperty {
      */
     validation?: PropertyValidationSchema;
 }
+/**
+ * Which pgvector distance a query measures with, and therefore which operator
+ * class an index has to be built for. The names match the `distance` option on
+ * `vectorSearch`, because an index built for one operator is not used by a
+ * query that asks for another.
+ *
+ * @group Entity properties
+ */
+export type VectorDistance = "cosine" | "l2" | "inner_product";
+/**
+ * How the ANN index over a vector column is built.
+ *
+ * Without an index, `vectorSearch` is an exact scan: correct at any size,
+ * and linear in the number of rows. With one, it is approximate and fast.
+ * That trade is why this is configurable rather than implied.
+ *
+ * @group Entity properties
+ */
+export interface VectorIndexConfig {
+    /**
+     * `hnsw` (the default) builds a navigable-graph index: slower to build,
+     * better recall, and it needs no training data, so it works on an empty
+     * table. `ivfflat` is cheaper to build but partitions by centroid, so an
+     * index built on an empty or tiny table has useless partitions — build it
+     * after the data is loaded, and set {@link lists}.
+     */
+    method?: "hnsw" | "ivfflat";
+    /**
+     * Which distance operators to index, defaulting to `cosine` — the default
+     * `vectorSearch` measures with. Name several to index several; each one is
+     * a separate index with its own build cost and its own storage.
+     */
+    distance?: VectorDistance | VectorDistance[];
+    /** HNSW: connections per node. Postgres defaults to 16. */
+    m?: number;
+    /** HNSW: candidate-list size while building. Postgres defaults to 64. */
+    efConstruction?: number;
+    /** IVFFlat: number of partitions. Postgres defaults to 100. */
+    lists?: number;
+}
 export interface VectorProperty extends BaseProperty {
     type: "vector";
     /**
@@ -331,6 +371,18 @@ export interface VectorProperty extends BaseProperty {
      */
     defaultValue?: Vector;
     dimensions: number;
+    /**
+     * ANN index configuration for this column.
+     *
+     * Omitted, a single HNSW index for cosine distance is created — which is
+     * what the default `vectorSearch` uses. `false` creates none, leaving
+     * `vectorSearch` an exact scan.
+     *
+     * Indexes are only created when {@link dimensions} is at most 2000:
+     * pgvector cannot index a wider `vector` column, so a 3072-dimension
+     * embedding is left unindexed rather than failing the boot.
+     */
+    index?: VectorIndexConfig | false;
     validation?: PropertyValidationSchema;
 }
 /**

package/dist/types/relations.d.ts

@@ -1,4 +1,4 @@
-import type { AnyCollectionConfig } from "./collections";
+import type { AnyCollectionConfig } from "./collections.js";
 /**
  * @group Models
  */

package/dist/types/schema_editing.d.ts

@@ -0,0 +1,127 @@
+/**
+ * The vocabulary a live schema change is described in.
+ *
+ * Declared here, and nowhere else, because two packages that must not import
+ * each other both need it: `@rebasepro/server-postgres` decides what a change
+ * means and renders the files it needs, while `@rebasepro/server` commits those
+ * files and serves the routes. Neither can reach the other — the server is
+ * engine-agnostic by design — so the shared kernel holds the shapes and the
+ * driver is detected structurally through {@link SchemaEditingAdmin}.
+ *
+ * Nothing here executes anything. These are the nouns.
+ */
+/**
+ * What a change will do to a live database.
+ *
+ * - `safe` — the boot-time ensure path expresses it, and the result matches the
+ *   configuration.
+ * - `diverges` — the ensure path applies *something*, but the database will not
+ *   match what the configuration declares, and nothing reports it. This is the
+ *   category worth having: adding a required property to a populated table
+ *   yields a nullable column, and adding a value to an existing enum yields
+ *   nothing at all. Both read as success.
+ * - `needs-migration` — the ensure path cannot express it. Dropping anything,
+ *   changing a type, moving a primary key.
+ */
+export type SchemaChangeVerdict = "safe" | "diverges" | "needs-migration";
+export type SchemaChangeKind = "add-collection" | "remove-collection" | "add-property" | "remove-property" | "change-property-type" | "rename-column" | "add-enum-value" | "remove-enum-value" | "change-required" | "change-primary-key";
+export interface SchemaChange {
+    kind: SchemaChangeKind;
+    verdict: SchemaChangeVerdict;
+    /** Collection slug. */
+    collection: string;
+    /** Property name, where the change is to one. */
+    property?: string;
+    /** One line, specific: what changed and what it will do. */
+    detail: string;
+    /** What to do instead, when the verdict is not `safe`. */
+    remedy?: string;
+}
+export interface ClassifiedSchemaChanges {
+    changes: SchemaChange[];
+    /** The worst verdict present, or `safe` for an empty diff. */
+    verdict: SchemaChangeVerdict;
+    /** True only when every change is `safe` — the one case an editor may apply. */
+    applicable: boolean;
+}
+/**
+ * Where a project's generated schema artifacts live, relative to the **project**
+ * root — which is the repository root only when the project is the whole
+ * repository.
+ *
+ * Here rather than in the Postgres package because it is a contract, not an
+ * engine detail: `@rebasepro/server` has to derive these for a project in a
+ * subdirectory, and it cannot import a driver to do it.
+ */
+export interface SchemaCommitPaths {
+    /** Drizzle schema, imported by the backend. */
+    schemaFile: string;
+    /** Declarative DDL, what `db push` applies and Atlas diffs against. */
+    ddlFile: string;
+    policiesFile: string;
+    searchFile: string;
+}
+export declare const DEFAULT_COMMIT_PATHS: SchemaCommitPaths;
+/** One file the commit writes, as content rather than as a path on a disk. */
+export interface SchemaChangeFile {
+    path: string;
+    contents: string;
+}
+/**
+ * Everything a change needs written and run.
+ *
+ * Computed without touching a disk or a network. The database is *read* — what
+ * a change means depends on what is already there, and a plan that guessed
+ * would be guessing about whether the statements it returns will be accepted.
+ */
+export interface SchemaChangePlan {
+    /** Every file the commit writes — collection source and generated artifacts. */
+    files: SchemaChangeFile[];
+    /** The additive DDL this change adds, in dependency order. */
+    statements: string[];
+    classified: ClassifiedSchemaChanges;
+    /** A commit message describing the change rather than announcing one. */
+    message: string;
+    /**
+     * Constraints the configuration asks for that these statements do not
+     * carry, and why.
+     *
+     * Almost always empty. When it is not, it is the part the person confirming
+     * needs to read: the change will apply, and the database will still not
+     * enforce something the configuration says — a required property over a
+     * table that already holds rows with no value for it. Optional so a plan
+     * from an engine that does not distinguish these cases stays valid.
+     */
+    withheldConstraints?: WithheldSchemaConstraint[];
+}
+/** A constraint a plan asks for and does not apply. */
+export interface WithheldSchemaConstraint {
+    /** `schema.table.column`. */
+    target: string;
+    kind: "not-null";
+    /** What is in the way, naming the obstacle rather than the rule. */
+    reason: string;
+    /** What would make it applicable. */
+    remedy: string;
+}
+/**
+ * An admin that can plan a schema change.
+ *
+ * Planning only. Applying is `executeSql`, which every SQL admin already has,
+ * and committing belongs to whatever holds the repository — keeping those three
+ * apart is what lets the same plan be committed locally on a developer's machine
+ * and through a GitHub App from a cloud tenant.
+ *
+ * @group Admin
+ */
+export interface SchemaEditingAdmin {
+    /**
+     * Decide what the change means and render everything it needs.
+     *
+     * Rejects when the change is not applicable, carrying the classification so
+     * a caller can say which change was the problem.
+     */
+    planSchemaChange(before: unknown[], after: unknown[], options?: {
+        paths?: Partial<SchemaCommitPaths>;
+    }): Promise<SchemaChangePlan>;
+}

package/dist/types/schema_version.d.ts

@@ -1,4 +1,4 @@
-import type { CollectionConfig } from "./collections";
+import type { CollectionConfig } from "./collections.js";
 /**
  * Compute the canonical string a schema version hashes.
  *

package/dist/types/security_rules.d.ts

@@ -15,7 +15,7 @@
  * them with `getPolicyNamesForRule`/`getEffectiveSecurityRules` rather than
  * matching on `rule.name`.
  */
-import type { PolicyExpression } from "./policy";
+import type { PolicyExpression } from "./policy.js";
 /**
  * SQL operation that a policy applies to.
  * @group Models

package/dist/users/index.d.ts

@@ -1 +1 @@
-export * from "./user";
+export * from "./user.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/types",
   "type": "module",
-  "version": "0.16.0",
+  "version": "0.16.1-canary.g2d1aec8",
   "description": "Rebase type definitions — shared interfaces and controller types",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -88,7 +88,7 @@
   },
   "scripts": {
     "watch": "vite build --watch",
-    "build": "vite build && tsc --emitDeclarationOnly -p tsconfig.prod.json && node ../../scripts/assert-build-output.mjs",
+    "build": "vite build && tsc --emitDeclarationOnly -p tsconfig.prod.json && node ../../scripts/add-dts-extensions.mjs dist && node ../../scripts/assert-build-output.mjs",
     "test:lint": "eslint \"src/**\" --quiet",
     "test": "jest --passWithNoTests",
     "clean": "rm -rf dist && find ./src -name '*.js' -type f | xargs rm -f"

package/src/controllers/client.ts

@@ -437,6 +437,19 @@ export interface RebaseServerClient<DB = unknown> extends Omit<RebaseClient<DB>,
      * Execute raw SQL against the database. Always present server-side for SQL
      * engines. Values interpolated into the query should be passed via
      * `params`, referenced as `$1`, `$2`, … placeholders in the query text.
+     *
+     * **Runtime note.** This is the one accessor on this object that is not
+     * portable. It runs on the database owner connection over a TCP socket, so
+     * it is available wherever the framework holds that connection — every Node
+     * deployment, self-hosted or managed — and not on a host that has no
+     * sockets and no business holding owner credentials.
+     *
+     * Nothing about that is a problem for a Node deployment, and it is not a
+     * reason to avoid it there. It is a reason not to build a function's *only*
+     * data path on it if that function may later move: `c.get("driver")` and
+     * `rebase.dataAsAdmin` go over the same wire wherever they run. A function
+     * that genuinely needs raw SQL can ask `runtimeKey()` and degrade, rather
+     * than discovering it at the call.
      */
     sql(query: string, options?: { database?: string; role?: string; params?: unknown[] }): Promise<Record<string, unknown>[]>;
 }

package/src/types/backend.ts

@@ -4,6 +4,7 @@ import type { LogicalCondition } from "../controllers/data";
 import type { AuthAdapter } from "./auth_adapter";
 import type { HistoryConfig } from "../controllers/client";
 import type { ChannelBusSetting } from "./channel_bus";
+import type { SchemaEditingAdmin } from "./schema_editing";
 
 // =============================================================================
 // DATABASE CONNECTION INTERFACES
@@ -564,7 +565,23 @@ export interface BranchAdmin {
  *
  * @group Admin
  */
-export type DatabaseAdmin = Partial<SQLAdmin> & Partial<DocumentAdmin> & Partial<SchemaAdmin> & Partial<BranchAdmin>;
+export type DatabaseAdmin = Partial<SQLAdmin> & Partial<DocumentAdmin> & Partial<SchemaAdmin>
+    & Partial<BranchAdmin> & Partial<SchemaEditingAdmin>;
+
+/**
+ * Type guard: can this admin plan a live schema change?
+ *
+ * Planning is engine-specific — it renders DDL, a Drizzle schema and the
+ * declarative SQL artifacts — so the implementation lives in the driver
+ * package. The server detects the capability structurally, exactly as it does
+ * for SQL, rather than importing an engine it is supposed to know nothing
+ * about.
+ *
+ * @group Admin
+ */
+export function isSchemaEditingAdmin(admin: DatabaseAdmin | undefined): admin is SchemaEditingAdmin {
+    return !!admin && typeof (admin as SchemaEditingAdmin).planSchemaChange === "function";
+}
 
 /**
  * Type guard: does this admin support SQL operations?

package/src/types/index.ts

@@ -14,6 +14,7 @@ export * from "./security_rules";
 export * from "./entity_callbacks";
 export * from "./websockets";
 export * from "./backend";
+export * from "./schema_editing";
 export * from "./channel_bus";
 export * from "./data_source";
 export * from "./storage_source";