@rebasepro/server-postgres 0.16.0 → 0.16.1-canary.g0d7af95

package/dist/schema/generate-schema-commit.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Everything a schema change has to write, as file contents.
+ *
+ * A live schema editor that only edits the collection source produces a repo
+ * that does not build: `backend/src/schema.generated.ts` is a committed
+ * artifact, and a stale one has broken every deploy at least once. So the unit
+ * of a schema change is not a file, it is a **commit** — and this module
+ * produces one, without touching a disk, a database or a network.
+ *
+ * Pure on purpose. The risky half of "commit, then apply" is generating a
+ * correct commit; keeping it a function from collections to file contents is
+ * what lets that half be tested by building a database from the result and
+ * comparing it to the one the change describes.
+ *
+ * ## Where the migration comes from, and why not from Atlas
+ *
+ * `rebase db generate` mints migrations by running Atlas over the generated
+ * `schema.sql`. Atlas is an external binary, it wants a dev database, and it
+ * maintains an `atlas.sum` integrity file whose hash this module would have to
+ * reproduce byte-for-byte to stay valid.
+ *
+ * None of that is necessary here, because of what the editor is allowed to do.
+ * `classify-change.ts` refuses anything the boot-time ensure path cannot
+ * express, which leaves only additive statements — and those are computable as
+ * a plain difference between two ensure plans:
+ *
+ *     plan(after, nothing) − plan(before, nothing)
+ *
+ * Both plans are pure functions of the collections, every statement is
+ * idempotent, and the difference is exactly what the change adds. No diff
+ * engine, no database, no binary.
+ *
+ * The statements are *returned* rather than written into a migration file. A
+ * project provisioned by boot-ensure needs no migration at all — its
+ * collections are the schema — while a project provisioned by migrations needs
+ * the file to carry an Atlas hash, which only Atlas can mint. Writing a
+ * migration this module cannot make valid would be worse than handing the
+ * statements to a caller who knows which kind of project it is.
+ */
+import { type CollectionConfig, type SchemaCommitPaths } from "@rebasepro/types";
+import { type EnsureOptions, type ExistingSchema, type WithheldConstraint } from "./ensure-collection-tables.js";
+import { type ClassifiedChanges } from "./classify-change.js";
+/**
+ * Re-exported from the shared kernel. `@rebasepro/server` derives these for a
+ * project in a subdirectory and cannot import a driver to do it, so the shape
+ * and the defaults live in `@rebasepro/types`.
+ */
+export { DEFAULT_COMMIT_PATHS, type SchemaCommitPaths } from "@rebasepro/types";
+export interface SchemaCommitFile {
+    path: string;
+    contents: string;
+}
+export interface SchemaCommitInput {
+    /** What the running database was built from. */
+    before: CollectionConfig[];
+    /** What the editor is proposing. */
+    after: CollectionConfig[];
+    /**
+     * Files the caller has already produced — in practice the rewritten
+     * collection source from the AST editor. Carried through unchanged so the
+     * commit is complete in one object.
+     */
+    sourceFiles?: SchemaCommitFile[];
+    paths?: Partial<SchemaCommitPaths>;
+    /**
+     * What the database this change is destined for actually has.
+     *
+     * Supplied by the live editor, which read it a moment ago; omitted by the
+     * pure callers, which have no database. It decides two things a plan cannot
+     * know from the collections alone — whether a table holds rows, and which
+     * values an enum type already carries — and both are the difference between
+     * a statement that applies and one that is rejected.
+     */
+    existing?: ExistingSchema;
+}
+export interface SchemaCommit {
+    /** Every file the commit writes, source and generated alike. */
+    files: SchemaCommitFile[];
+    /**
+     * The additive statements this change adds, in dependency order.
+     *
+     * Empty when the change needs no DDL. Not written to a migration file —
+     * see the module comment.
+     */
+    statements: string[];
+    classified: ClassifiedChanges;
+    /** A commit message describing the change in the terms a reader wants. */
+    message: string;
+    /**
+     * Constraints this change asks for that the statements do not carry, and
+     * why. Empty for almost every change; when it is not, it is the thing the
+     * person confirming needs to read before they confirm.
+     */
+    withheldConstraints: WithheldConstraint[];
+}
+export declare class SchemaCommitError extends Error {
+    readonly classified: ClassifiedChanges;
+    constructor(message: string, classified: ClassifiedChanges);
+}
+/**
+ * The statements that take `before` to `after`.
+ *
+ * Both sides are planned against the *same* database and the difference is
+ * taken by exact statement text. That works because the planner is
+ * deterministic: the same collections against the same schema produce the same
+ * strings, so anything in the second plan and absent from the first is what
+ * this change adds — and nothing else. Planning both sides is what keeps
+ * pre-existing drift, which belongs to neither side of the edit, out of the
+ * statements this change gets credited with.
+ *
+ * ## Why `existing` matters more than it looks
+ *
+ * Planned against `nothing()`, every table reads as one this plan is creating,
+ * and the planner is then free to attach constraints that only hold on a table
+ * with no rows: a new required property comes out as
+ * `ADD COLUMN "x" TEXT NOT NULL`, which is right for a fresh table and fails
+ * against a live one holding rows. Those statements would be generated,
+ * committed, and then rejected by the very database they were written for.
+ *
+ * So a caller holding a real database passes it, and gets statements that
+ * describe that database. `nothing()` stays the default for the pure uses —
+ * generating a commit for inspection, and the tests that compare two plans —
+ * where there is no database to describe.
+ */
+export declare function additiveStatements(before: CollectionConfig[], after: CollectionConfig[], existing?: ExistingSchema, options?: EnsureOptions): string[];
+/** A commit message that says what changed rather than that something did. */
+export declare function commitMessage(classified: ClassifiedChanges): string;
+/**
+ * Build the commit.
+ *
+ * Refuses when the change is not applicable — a commit describing a schema the
+ * ensure path will not produce is a commit that makes the repository lie about
+ * the database. The classification travels on the error so a caller can show
+ * exactly which change was the problem.
+ */
+export declare function generateSchemaCommit(input: SchemaCommitInput): Promise<SchemaCommit>;

package/dist/schema/generated-schema-staleness.d.ts

@@ -37,3 +37,22 @@ export interface LegacyForeignKeyName {
 export declare function findLegacyForeignKeyNames(generatedSource: string, collections: CollectionConfig[]): LegacyForeignKeyName[];
 /** One-line summary for a log or a CLI notice. */
 export declare function describeLegacyForeignKeyNames(found: LegacyForeignKeyName[]): string;
+/** Something the collections derive that the generated schema does not declare. */
+export interface MissingGeneratedName {
+    /** The table it belongs to, or is. */
+    table: string;
+    /** The column, when a column is what is missing. */
+    column?: string;
+    /** `<collection>` or `<collection>.<relation>`, for the message. */
+    source: string;
+}
+/**
+ * Tables and derived foreign-key columns the collections name and the generated
+ * schema does not.
+ *
+ * @param generatedSource contents of `backend/src/schema.generated.ts`
+ * @param collections     the project's collections, as this release reads them
+ */
+export declare function findMissingGeneratedNames(generatedSource: string, collections: CollectionConfig[]): MissingGeneratedName[];
+/** One-line summary for a log or a CLI notice. */
+export declare function describeMissingGeneratedNames(missing: MissingGeneratedName[]): string;

package/dist/schema/introspect-db-constraints.d.ts

@@ -21,7 +21,7 @@
  *
  * Pure module: no I/O, no logging.
  */
-import type { CheckConstraintRow } from "./introspect-db-logic";
+import type { CheckConstraintRow } from "./introspect-db-logic.js";
 /** What a table's CHECK constraints say about one column. */
 export interface ColumnCheckFacts {
     /** Allowed values, from `IN (…)` / `= ANY (ARRAY[…])` / `= 'literal'`. */

package/dist/schema/introspect-db-logic.d.ts

@@ -1,6 +1,6 @@
-import { mapPgType } from "./introspect-db-types";
-import type { CheckFactsByTable } from "./introspect-db-constraints";
-import type { TableClassification } from "./introspect-db-structure";
+import { mapPgType } from "./introspect-db-types.js";
+import type { CheckFactsByTable } from "./introspect-db-constraints.js";
+import type { TableClassification } from "./introspect-db-structure.js";
 export interface TableRow {
     table_name: string;
     /** True for the parent of a partitioned table (`relkind = 'p'`). */

package/dist/schema/introspect-db-project.d.ts

@@ -1,4 +1,4 @@
-import { type CollectionBuilder } from "./introspect-db-logic";
+import { type CollectionBuilder } from "./introspect-db-logic.js";
 /**
  * Which `defineCollection` to generate against, for collections written to `outDir`.
  *

package/dist/schema/introspect-db-queries.d.ts

@@ -9,7 +9,7 @@
  * No side effects beyond `SELECT`. Introspection reads a database it does not
  * own — it must never `ANALYZE`, create a temp table, or otherwise write.
  */
-import type { SchemaMetadata } from "./introspect-db-logic";
+import type { SchemaMetadata } from "./introspect-db-logic.js";
 /** The subset of `pg.Client` this module needs, so tests can pass a fake. */
 export interface QueryableClient {
     query<R = Record<string, unknown>>(text: string, values?: unknown[]): Promise<{

package/dist/schema/introspect-db-structure.d.ts

@@ -33,8 +33,8 @@
  * which the caller fills from {@link ./introspect-db-queries.countRowsUpTo} for
  * the tables {@link lookupCandidates} names.
  */
-import type { ForeignKeyRow, SchemaMetadata, TableColumn, TableMeta } from "./introspect-db-logic";
-import type { CheckFactsByTable } from "./introspect-db-constraints";
+import type { ForeignKeyRow, SchemaMetadata, TableColumn, TableMeta } from "./introspect-db-logic.js";
+import type { CheckFactsByTable } from "./introspect-db-constraints.js";
 /**
  * The row count above which a referenced table is a real entity rather than a
  * code list. Deliberately low: `pagila.category` has 16 rows and `language` 6,

package/dist/schema/introspect-runtime.d.ts

@@ -12,7 +12,7 @@
  * the same way whether it was generated or introspected.
  */
 import type { PostgresCollectionConfig } from "@rebasepro/types";
-import { TableMeta } from "./introspect-db-logic";
+import { TableMeta } from "./introspect-db-logic.js";
 export interface IntrospectedSchema {
     tablesMap: Map<string, TableMeta>;
     enumMap: Map<string, string[]>;

package/dist/schema/vector-index.d.ts

@@ -0,0 +1,88 @@
+/**
+ * The one place a `{ type: "vector" }` property becomes an ANN index.
+ *
+ * Without an index, pgvector answers `ORDER BY embedding <=> $1` by computing
+ * the distance to every row and sorting — exact, and linear. That is the right
+ * answer at ten thousand rows and the wrong one at a million, which is why the
+ * default here is to build an index rather than to leave the column bare.
+ *
+ * ## The operator class is not a detail
+ *
+ * An index is built for exactly one operator class, and the planner uses it
+ * only for the operator that class implements. `vector_cosine_ops` answers
+ * `<=>` and nothing else; a query asking for `<->` against a cosine index gets
+ * a sequential scan and no error. So the default indexed distance here is
+ * `cosine`, because `cosine` is what `vectorSearch` measures with when the
+ * caller does not say — see `DrizzleConditionBuilder.buildVectorSearch`. The
+ * two defaults have to agree, and this comment is the reason they do.
+ *
+ * ## Why 2000 dimensions is a ceiling and not an error
+ *
+ * pgvector cannot index a `vector` wider than 2000 dimensions with either
+ * method. A 3072-dimension embedding (`text-embedding-3-large`) is therefore
+ * storable and searchable but not indexable. Refusing the boot over that would
+ * make a working configuration unbootable; silently indexing it is impossible.
+ * So the column is created, the index is skipped, and the reason is reported.
+ *
+ * Like `search-column.ts`, this module exists so that the DDL generator and the
+ * boot-time ensure render the *same* specification rather than describing the
+ * same index twice, differently. `contracts/derived-names.txt` records the
+ * names both produce, and CI fails if they diverge.
+ */
+import type { CollectionConfig, Property, VectorDistance } from "@rebasepro/types";
+/**
+ * The widest `vector` pgvector will build an HNSW or IVFFlat index over.
+ * Storage and exact search are unaffected by this limit.
+ */
+export declare const MAX_INDEXABLE_VECTOR_DIMENSIONS = 2000;
+/** The distance indexed when a property does not name one. */
+export declare const DEFAULT_VECTOR_DISTANCE: VectorDistance;
+/** The index method used when a property does not name one. */
+export declare const DEFAULT_VECTOR_INDEX_METHOD: "hnsw";
+export interface VectorIndexSpec {
+    schema: string;
+    table: string;
+    column: string;
+    indexName: string;
+    method: "hnsw" | "ivfflat";
+    distance: VectorDistance;
+    operatorClass: string;
+    /** Rendered into `WITH (...)`; empty when every parameter is defaulted. */
+    parameters: Array<[string, number]>;
+}
+/** A vector column that will not be indexed, and why. */
+export interface SkippedVectorIndex {
+    schema: string;
+    table: string;
+    column: string;
+    dimensions: number;
+    reason: string;
+}
+export interface VectorIndexPlan {
+    specs: VectorIndexSpec[];
+    skipped: SkippedVectorIndex[];
+}
+export declare class VectorIndexConfigError extends Error {
+    constructor(message: string);
+}
+/**
+ * Every ANN index a collection's vector properties call for.
+ *
+ * `resolveColumn` is passed in rather than imported so that this module stays
+ * free of the DDL generator, which imports *it*. Both callers hand it the same
+ * `resolveColumnName`, and a contract test asserts the names agree.
+ */
+export declare const buildVectorIndexPlan: (collection: CollectionConfig, resolveColumn: (propName: string, prop?: Property | null) => string) => VectorIndexPlan;
+/**
+ * The `CREATE INDEX` for one spec.
+ *
+ * `CONCURRENTLY` is deliberately absent, for the same reason it is absent from
+ * `searchIndexStatements`: this form is replayed as part of a migration, where
+ * a concurrent build is not allowed. The boot-time ensure rewrites it — see
+ * `ensureCollectionTables`.
+ */
+export declare const vectorIndexStatement: (spec: VectorIndexSpec) => string;
+/** Every statement for a plan, in a stable order. */
+export declare const vectorIndexStatements: (plan: VectorIndexPlan) => string[];
+/** The index names a plan creates — what the derived-names contract records. */
+export declare const vectorIndexNames: (plan: VectorIndexPlan) => string[];

package/dist/services/BranchService.d.ts

@@ -7,8 +7,8 @@
  * same `rebase` schema convention used by entity_history, auth, etc.
  */
 import { BranchInfo } from "@rebasepro/types";
-import { DrizzleClient } from "../interfaces";
-import { DatabasePoolManager } from "../databasePoolManager";
+import { DrizzleClient } from "../interfaces.js";
+import { DatabasePoolManager } from "../databasePoolManager.js";
 export declare class BranchService {
     private db;
     private poolManager;

package/dist/services/FetchService.d.ts

@@ -2,10 +2,10 @@ import { SQL } from "drizzle-orm";
 import { PgTable } from "drizzle-orm/pg-core";
 import { FilterValues, OrderByTuple, LogicalCondition } from "@rebasepro/types";
 import type { VectorSearchParams } from "@rebasepro/types";
-import { RelationService } from "./RelationService";
-import { DrizzleClient } from "../interfaces";
-import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
-import { type NestedPathHop } from "./nested-path";
+import { RelationService } from "./RelationService.js";
+import { DrizzleClient } from "../interfaces.js";
+import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry.js";
+import { type NestedPathHop } from "./nested-path.js";
 /**
  * Service for handling all row read operations.
  * Handles fetching, searching, counting, and filtering rows.

package/dist/services/PersistService.d.ts

@@ -1,8 +1,8 @@
-import { RelationService } from "./RelationService";
-import { RelationWriteService } from "./RelationWriteService";
-import { FetchService } from "./FetchService";
-import { DrizzleClient } from "../interfaces";
-import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
+import { RelationService } from "./RelationService.js";
+import { RelationWriteService } from "./RelationWriteService.js";
+import { FetchService } from "./FetchService.js";
+import { DrizzleClient } from "../interfaces.js";
+import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry.js";
 /**
  * Service for handling all row write operations.
  * Handles saving, deleting, and updating rows.

package/dist/services/RelationService.d.ts

@@ -1,7 +1,7 @@
-import { DrizzleClient } from "../interfaces";
+import { DrizzleClient } from "../interfaces.js";
 import { CollectionConfig, FilterValues, OrderByTuple, ResolvedRelation, ResolvedHasMany, ResolvedHasOne } from "@rebasepro/types";
-import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
-import type { NestedPathHop } from "./nested-path";
+import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry.js";
+import type { NestedPathHop } from "./nested-path.js";
 /**
  * Service for handling all relation-related operations.
  * Handles fetching, updating, and managing row relations.

package/dist/services/RelationWriteService.d.ts

@@ -1,7 +1,7 @@
 import { CollectionConfig, ResolvedManyToMany, ResolvedRelation, ResolvedVia } from "@rebasepro/types";
-import { DrizzleClient } from "../interfaces";
-import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
-import type { NestedPathHop } from "./nested-path";
+import { DrizzleClient } from "../interfaces.js";
+import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry.js";
+import type { NestedPathHop } from "./nested-path.js";
 /**
  * Writing relations: junction membership, foreign-key stamping, and the links a
  * nested path creates or removes.

package/dist/services/cdc/junction-tables.d.ts

@@ -1,5 +1,5 @@
 import { CollectionConfig } from "@rebasepro/types";
-import { PostgresCollectionRegistry } from "../../collections/PostgresCollectionRegistry";
+import { PostgresCollectionRegistry } from "../../collections/PostgresCollectionRegistry.js";
 /**
  * One end of a many-to-many, as seen from the junction table.
  *

package/dist/services/cdc/trigger-cdc.d.ts

@@ -1,4 +1,4 @@
-import type { RawSqlRunner } from "../../security/rls-enforcement";
+import type { RawSqlRunner } from "../../security/rls-enforcement.js";
 /**
  * Trigger-based Change Data Capture (CDC).
  *

package/dist/services/channel-bus/PostgresChannelBus.d.ts

@@ -26,7 +26,7 @@
  *    than correctness. That is what makes coalescing safe.
  */
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
-import { ChannelBus, ChannelBusFrame, ChannelBusHandler } from "./ChannelBus";
+import { ChannelBus, ChannelBusFrame, ChannelBusHandler } from "./ChannelBus.js";
 /** NOTIFY channel carrying channel-bus frames. */
 export declare const CHANNEL_BUS_NOTIFY_CHANNEL = "rebase_channel_bus";
 /**

package/dist/services/channel-bus/index.d.ts

@@ -16,8 +16,8 @@
  */
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { type ChannelBus, type ChannelBusSetting } from "@rebasepro/types";
-export * from "./ChannelBus";
-export { PostgresChannelBus, CHANNEL_BUS_NOTIFY_CHANNEL, PG_NOTIFY_MAX_PAYLOAD_BYTES, DEFAULT_BATCH_WINDOW_MS, parseChannelBusFrame, parseChannelBusPayload } from "./PostgresChannelBus";
+export * from "./ChannelBus.js";
+export { PostgresChannelBus, CHANNEL_BUS_NOTIFY_CHANNEL, PG_NOTIFY_MAX_PAYLOAD_BYTES, DEFAULT_BATCH_WINDOW_MS, parseChannelBusFrame, parseChannelBusPayload } from "./PostgresChannelBus.js";
 export interface ChannelBusDeps {
     db: NodePgDatabase<Record<string, unknown>>;
     /**

package/dist/services/collection-helpers.d.ts

@@ -1,6 +1,6 @@
 import { PgTable, AnyPgColumn } from "drizzle-orm/pg-core";
 import { CollectionConfig, ResolvedHasMany, ResolvedHasOne } from "@rebasepro/types";
-import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
+import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry.js";
 import { ApiError } from "@rebasepro/server";
 export { buildCompositeId, parseIdValues, isAddressableId, COMPOSITE_ID_SEPARATOR } from "@rebasepro/common";
 export type { PrimaryKeyInfo } from "@rebasepro/common";

package/dist/services/dataService.d.ts

@@ -1,15 +1,15 @@
 import { FilterValues, LogicalCondition, OrderByTuple } from "@rebasepro/types";
 import type { VectorSearchParams } from "@rebasepro/types";
-import { FetchService } from "./FetchService";
-import { PersistService } from "./PersistService";
-import { RelationService } from "./RelationService";
-import { DataRepository, DrizzleClient } from "../interfaces";
-import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
-export { sanitizeAndConvertDates, serializeDataToServer, parseDataFromServer } from "../data-transformer";
-export { FetchService } from "./FetchService";
-export { PersistService } from "./PersistService";
-export { RelationService } from "./RelationService";
-export * from "../interfaces";
+import { FetchService } from "./FetchService.js";
+import { PersistService } from "./PersistService.js";
+import { RelationService } from "./RelationService.js";
+import { DataRepository, DrizzleClient } from "../interfaces.js";
+import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry.js";
+export { sanitizeAndConvertDates, serializeDataToServer, parseDataFromServer } from "../data-transformer.js";
+export { FetchService } from "./FetchService.js";
+export { PersistService } from "./PersistService.js";
+export { RelationService } from "./RelationService.js";
+export * from "../interfaces.js";
 /**
  * DataService - Facade for row operations.
  *

package/dist/services/index.d.ts

@@ -1,4 +1,4 @@
-export { FetchService } from "./FetchService";
-export { PersistService } from "./PersistService";
-export { RelationService } from "./RelationService";
-export { getCollectionByPath, getTableForCollection, getPrimaryKeys, deriveRowAddress, parseIdValues, buildCompositeId } from "./collection-helpers";
+export { FetchService } from "./FetchService.js";
+export { PersistService } from "./PersistService.js";
+export { RelationService } from "./RelationService.js";
+export { getCollectionByPath, getTableForCollection, getPrimaryKeys, deriveRowAddress, parseIdValues, buildCompositeId } from "./collection-helpers.js";

package/dist/services/junction-writes.d.ts

@@ -1,7 +1,7 @@
 import { AnyPgColumn, PgTable } from "drizzle-orm/pg-core";
 import type { ResolvedVia } from "@rebasepro/types";
-import { DrizzleClient } from "../interfaces";
-import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
+import { DrizzleClient } from "../interfaces.js";
+import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry.js";
 /**
  * Writing a many-to-many means writing rows in a junction table, and doing that
  * needs three things: the table, the column naming the row being written from,

package/dist/services/nested-path.d.ts

@@ -1,5 +1,5 @@
 import { CollectionConfig, ResolvedRelation } from "@rebasepro/types";
-import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
+import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry.js";
 /**
  * The last hop of a nested collection path, e.g. `authors/1/posts`.
  *

package/dist/services/realtimeService.d.ts

@@ -2,9 +2,9 @@ import { WebSocket } from "ws";
 import { EventEmitter } from "events";
 import { DataDriver, WebSocketMessage, LogicalCondition, OrderByTuple } from "@rebasepro/types";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
-import { RealtimeProvider, CollectionSubscriptionConfig, SingleSubscriptionConfig } from "../interfaces";
-import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
-import { ChannelBus } from "./channel-bus";
+import { RealtimeProvider, CollectionSubscriptionConfig, SingleSubscriptionConfig } from "../interfaces.js";
+import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry.js";
+import { ChannelBus } from "./channel-bus/index.js";
 import type { ChannelRetentionRule } from "@rebasepro/types";
 /**
  * Auth context stored per-subscription so real-time refetches respect RLS.

package/dist/services/row-pipeline.d.ts

@@ -1,5 +1,5 @@
 import { CollectionConfig, ResolvedRelation } from "@rebasepro/types";
-import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
+import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry.js";
 /**
  * Turning a drizzle result into a row we serve.
  *

package/dist/services/write-denial.d.ts

@@ -1,7 +1,7 @@
 import { SQL } from "drizzle-orm";
 import { PgTable } from "drizzle-orm/pg-core";
 import { ApiError } from "@rebasepro/server";
-import { DrizzleClient } from "../interfaces";
+import { DrizzleClient } from "../interfaces.js";
 /**
  * Explain a write that matched no rows.
  *

package/dist/{src-BBFsDaeA.js → src-DiDgtX8P.js}

@@ -410,6 +410,102 @@ function usesLegacyRlsFunctions(sql) {
 	return /\bauth\.(uid|jwt|roles)\s*\(\s*\)/i.test(sql);
 }
 //#endregion
+//#region ../types/src/types/resources.ts
+var GLOBAL_KEY = Symbol.for("@rebasepro/types.resourceRegistry");
+function registry() {
+	const g = globalThis;
+	let existing = g[GLOBAL_KEY];
+	if (!existing) {
+		existing = {
+			kinds: /* @__PURE__ */ new Map(),
+			declarations: /* @__PURE__ */ new Map()
+		};
+		g[GLOBAL_KEY] = existing;
+	}
+	return existing;
+}
+/** Register a resource kind. Idempotent for an identical spec; throws on a conflicting one. */
+function registerResourceKind(spec) {
+	const existing = registry().kinds.get(spec.kind);
+	if (existing && JSON.stringify(existing) !== JSON.stringify(spec)) throw new Error(`Resource kind "${spec.kind}" is already registered with a different definition. Two packages cannot define the same kind.`);
+	registry().kinds.set(spec.kind, spec);
+}
+//#endregion
+//#region ../types/src/types/resource_kinds.ts
+/**
+* The kinds Rebase ships, and the constructors a project declares them with.
+*
+* Each kind is registered rather than hardcoded, so a fourth one arrives
+* without editing a manifest schema, a validator and a switch statement. That
+* cost is precisely why databases and buckets ended up declared in different
+* files with different rules — the cheapest thing to do was always to bolt the
+* new kind onto whichever home was nearest.
+*
+* A kind owns its engine list. `custom:<id>` is always accepted, so a build
+* that ships an engine this package has never heard of says so at the call site
+* instead of looking like a typo of one that exists.
+*/
+registerResourceKind({
+	kind: "database",
+	engines: [
+		"postgres",
+		"mongodb",
+		"firestore",
+		"sqlite"
+	],
+	defaultEngine: "postgres",
+	envBases: [
+		"DATABASE_URL",
+		"REBASE_DRIVER",
+		"REBASE_DB_POOL_MAX"
+	],
+	optionKeys: ["databaseId", "migrations"],
+	implicitDefault: true
+});
+registerResourceKind({
+	kind: "bucket",
+	engines: [
+		"local",
+		"s3",
+		"gcs",
+		"azure",
+		"firebase"
+	],
+	defaultEngine: "local",
+	envBases: [
+		"S3_BUCKET",
+		"GCS_BUCKET",
+		"STORAGE_BUCKET",
+		"STORAGE_PUBLIC_URL"
+	],
+	envBasesByEngine: {
+		local: ["STORAGE_BUCKET"],
+		s3: [
+			"S3_BUCKET",
+			"STORAGE_ENDPOINT",
+			"STORAGE_REGION",
+			"STORAGE_PUBLIC_URL"
+		],
+		gcs: ["GCS_BUCKET", "STORAGE_PUBLIC_URL"],
+		azure: ["STORAGE_BUCKET", "STORAGE_PUBLIC_URL"],
+		firebase: ["STORAGE_BUCKET", "STORAGE_PUBLIC_URL"]
+	},
+	optionKeys: [
+		"publicRead",
+		"prefix",
+		"account"
+	],
+	implicitDefault: false
+});
+registerResourceKind({
+	kind: "topic",
+	engines: ["jobs"],
+	defaultEngine: "jobs",
+	envBases: ["REBASE_TOPIC_URL"],
+	optionKeys: ["delivery", "maxAttempts"],
+	implicitDefault: false
+});
+//#endregion
 export { isRelationAggregateSort as _, rewriteLegacyRlsFunctions as a, toCanonicalOp as b, isPostgresCollectionConfig as c, getDataSourceCapabilities as d, ALL_WHERE_FILTER_OPS as f, encodeRelationAggregateSort as g, REST_TO_CANONICAL as h, RLS_UID_SQL as i, isRelationalCollectionConfig as l, NULL_OPS as m, REBASE_SCHEMA as n, usesLegacyRlsFunctions as o, CANONICAL_TO_REST as p, RLS_ROLES_SQL as r, getDeclaredSubcollections as s, LEGACY_RLS_SCHEMA as t, DEFAULT_DATA_SOURCE_KEY as u, parseRelationAggregateSort as v, sortKeyToString as y };
 
-//# sourceMappingURL=src-BBFsDaeA.js.map
+//# sourceMappingURL=src-DiDgtX8P.js.map