@rebasepro/server-postgres 0.17.3 → 0.18.0

package/dist/schema/generate-next-step.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The line `rebase schema generate` ends on.
+ *
+ * Its own module because `generate-drizzle-schema.ts` uses `import.meta` to
+ * decide whether it was executed directly, which the driver's jest suite cannot
+ * load at all — so the one sentence in that file with a decision in it had no
+ * test and could not have one where it stood.
+ */
+export declare const formatTerminalText: (text: string, options?: {
+    bold?: boolean;
+    backgroundColor?: "blue" | "green" | "red" | "yellow" | "cyan" | "magenta";
+    textColor?: "white" | "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan";
+}) => string;
+/**
+ * What to do with the file that was just generated.
+ *
+ * Not the same answer on the managed development database: `rebase db generate`
+ * plans with Atlas, Atlas needs a second empty database to diff against, and
+ * PGlite serves exactly one — so the CLI refuses that command outright there.
+ * This line recommended it unconditionally, which meant every stock scaffold
+ * was told, by the tool itself, to run something the same tool would refuse.
+ *
+ * The kind arrives as `REBASE_DEV_DATABASE_KIND`, set by the CLI from the
+ * ordered resolution in `dev-db/resolve.ts`. It is a pure decision — nothing is
+ * started to make it — and the driver cannot make it for itself: on the managed
+ * path `DATABASE_URL` is a perfectly ordinary connection string to a Postgres
+ * on loopback. Absent (the driver run directly, outside the CLI) keeps the
+ * original wording.
+ */
+export declare const nextStepAfterGenerate: () => string;

package/dist/schema/generate-postgres-ddl-logic.d.ts

@@ -9,6 +9,34 @@ export declare const isNumericId: (collection: CollectionConfig) => boolean;
 export declare const getPrimaryKeyName: (collection: CollectionConfig) => string;
 export declare const isIdProperty: (propName: string, prop: Property, collection: CollectionConfig) => boolean;
 type ResolveCollection = (slug: string) => CollectionConfig | undefined;
+/**
+ * The `ON DELETE` a foreign key gets when the author did not say.
+ *
+ * One rule for every property that emits one — `belongsTo` relations and
+ * `reference` properties alike. `reference` kept its own `CASCADE` default for
+ * a release after this rule was written, which is exactly the split this
+ * function exists to prevent: two spellings of the same link, two data-retention
+ * behaviours, and only one of them documented.
+ *
+ * An optional link is `SET NULL`: the column can hold NULL, so dropping the
+ * parent leaves the child row with an empty pointer, which is what "optional"
+ * already means.
+ *
+ * A required link is **`RESTRICT`**, not `CASCADE`. `NOT NULL` says the child
+ * cannot exist without a parent; it does not say deleting the parent should
+ * take the child with it. That second claim is a data-retention decision, and
+ * defaulting to it meant `onDelete` — a field nobody has to write — silently
+ * turned every `DELETE FROM authors` into a cascade through posts, comments and
+ * anything else that hung off them. `RESTRICT` fails the delete instead and
+ * names the constraint, so the author chooses `cascade` on purpose or clears
+ * the children first.
+ *
+ * Both DDL paths — the `CREATE TABLE` generator and {@link planRelationalColumns},
+ * which boot-ensure compares the live database against — call this, so a
+ * default that appears in one and not the other cannot make `db push` plan a
+ * constraint rewrite on every run.
+ */
+export declare const defaultBelongsToOnDelete: (required: boolean | undefined) => "RESTRICT" | "SET NULL";
 /**
  * The individual SQL statements a single security rule compiles to: a
  * `DROP POLICY IF EXISTS` / `CREATE POLICY` pair per operation, each a complete

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

@@ -56,3 +56,40 @@ export interface MissingGeneratedName {
 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;
+/** What `rebase schema stale` found, and what that costs. */
+export interface StaleVerdict {
+    /** The lines to print, in order. Empty only under `--fix` with nothing to fix. */
+    lines: string[];
+    /** Non-zero only when the reader must act before the server will boot. */
+    exitCode: 0 | 1;
+    /** True when `--fix` should regenerate. */
+    regenerate: boolean;
+}
+/**
+ * The whole of `schema stale`'s decision, separated from doing it.
+ *
+ * Separated because of what the command used to do on the clean path: **exit 0
+ * having written zero bytes to stdout and zero to stderr.** For a command the
+ * top-level help describes as "Report generated schema files the collections
+ * have moved past", that is indistinguishable from a no-op, a crash, and a
+ * subcommand the driver does not implement. Three of its four paths were
+ * silent, and none of them could be tested where they stood: `cli.ts` uses
+ * `import.meta`, which the driver's jest suite cannot load at all.
+ *
+ * `--fix` is the exception, and stays silent when there is nothing to fix.
+ * `rebase dev` runs `schema stale --fix` before every boot with inherited
+ * stdio, and "nothing was wrong" is not news a hundred lines into a start-up
+ * transcript. The flag is the automated caller's; its silence is the point.
+ */
+export declare function staleVerdict(input: {
+    /** `--output`, as the reader typed it. */
+    outputPath: string;
+    /** Whether the generated schema exists at all. */
+    generatedExists: boolean;
+    /** The legacy foreign-key names found in it, if it was read. */
+    stale: LegacyForeignKeyName[];
+    /** Why the comparison could not be made, when it could not. */
+    unreadable?: string;
+    /** Whether `--fix` was given. */
+    fix: boolean;
+}): StaleVerdict;

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

@@ -16,6 +16,40 @@ export interface QueryableClient {
         rows: R[];
     }>;
 }
+/**
+ * A Postgres identifier, quoted so that whatever is inside it stays inside it.
+ *
+ * Introspection reads table and schema names out of `pg_class` and puts them
+ * straight back into SQL, and wrapping a name in double quotes is not the same
+ * as escaping it: a table named `x" ; DROP TABLE users; --` closes the quote
+ * and then the statement. Postgres's own escape for a quote inside a quoted
+ * identifier is to double it, which is what this does.
+ *
+ * "The catalogue is trusted" is true of your own database, and is exactly the
+ * assumption this tool cannot make. Introspection exists to be pointed at
+ * databases somebody else built, and it runs with the privileges of whoever
+ * ran it — which is usually a superuser, because that is who has a connection
+ * string to a database they are adopting.
+ */
+export declare function quoteIdentifier(name: string): string;
+/** `"schema"."table"`, both halves quoted. */
+export declare function quoteRelation(schema: string, table: string): string;
+/**
+ * Can this table's name be the name of the file describing it?
+ *
+ * Introspection writes `<collectionsDir>/<tableName>.ts`, and the table name
+ * came from a database this tool did not create. Postgres will hold a table
+ * called `../../../etc/cron.d/x`, and `path.join` resolves it — so without this
+ * the generator writes a file wherever the name points, as whoever ran the
+ * command.
+ *
+ * Deliberately narrow, and deliberately not a blocklist of `..` and `/`: the
+ * question is "is this a plain file name?", and every answer that is not
+ * obviously yes is a table better written by hand. NUL and the Windows
+ * separator are in scope because a collections directory is checked out on
+ * whatever machine the developer has.
+ */
+export declare function isUsableFileName(name: string): boolean;
 /**
  * Base tables, excluding partitions.
  *

package/dist/security/rls-enforcement.d.ts

@@ -57,8 +57,24 @@ export interface ConnectionPosture {
     role: string;
     superuser: boolean;
     bypassRLS: boolean;
-    /** Owns at least one user table — owners bypass non-FORCE RLS. */
+    /**
+     * Owns at least one user table — owners bypass non-FORCE RLS.
+     *
+     * "Owns" in Postgres's sense, not by name: a role that INHERITs the owner is
+     * the owner for every ownership test the planner makes, including the one
+     * that decides whether a policy applies at all.
+     */
     ownsTables: boolean;
+    /**
+     * May create tables somewhere the server writes — and would then own them.
+     *
+     * The reason this is part of the posture rather than a separate question:
+     * the posture is decided ONCE, at boot, and on a fresh database the
+     * catalogue has nothing to report yet. The process that asks then goes on to
+     * create every table in the schema and owns all of them for the rest of its
+     * life. Asking only what is already there answers about the wrong instant.
+     */
+    canCreateTables: boolean;
     /** True when RLS would NOT constrain this connection. */
     privileged: boolean;
 }
@@ -66,6 +82,21 @@ export interface AuthContext {
     uid: string;
     /** Raw roles as carried on the user (strings or `{ id }` objects). */
     roles: unknown[];
+    /**
+     * Whether this session came from anonymous sign-in rather than an account.
+     *
+     * Anonymous sign-in mints a real user row and a real uid, so a guest was
+     * indistinguishable from a registered account inside a policy: same
+     * `rebase.uid()`, same default role. Every rule meaning "a signed-in
+     * person" was therefore also a rule about anybody who had called
+     * `POST /auth/anonymous`, which asks for no email, no password and no
+     * agreement to anything.
+     *
+     * Optional, and absent reads as `false`: a caller that predates this — a
+     * realtime subscription, a custom validator — keeps the behaviour it had
+     * rather than having every one of its users reclassified as guests.
+     */
+    isAnonymous?: boolean;
 }
 /**
  * Warn when the connection role shares its name with an existing schema.
@@ -95,7 +126,37 @@ export interface AuthContext {
  * inherited would be worse than the risk.
  */
 export declare function warnOnRoleSchemaCollision(run: RawSqlRunner): Promise<void>;
-export declare function detectConnectionPosture(run: RawSqlRunner): Promise<ConnectionPosture>;
+/**
+ * Would RLS actually constrain this connection?
+ *
+ * Four ways the answer is no, and only two of them are obvious. Superuser and
+ * BYPASSRLS announce themselves in `pg_roles`. The other two are about
+ * ownership, and both used to read as "no bypass here":
+ *
+ * - **Ownership through membership.** The old query compared
+ *   `pg_tables.tableowner` to `current_user` as a string. Postgres does not: a
+ *   role that INHERITs the owner passes every ownership test the planner makes,
+ *   including the one that decides whether a policy applies. So a perfectly
+ *   ordinary "app role that is a member of the owner role" setup reported
+ *   unprivileged and bypassed every policy — permanently, since no restart
+ *   changes a string comparison's answer.
+ *
+ * - **Ownership that has not happened yet.** The posture is decided once, at
+ *   boot, and on a fresh database there is nothing in the catalogue to find. The
+ *   same process then creates every table and owns all of them. The first boot
+ *   of a new deployment therefore served every request unconstrained, the log
+ *   said RLS was fine, and the SECOND boot silently fixed it — which is the
+ *   worst possible shape for a security check, because the state that reproduces
+ *   it is gone by the time anyone looks. Asking "may this role create tables
+ *   where the server provisions?" answers about the process's whole life rather
+ *   than about one instant of it.
+ *
+ * `schemas` narrows the CREATE question to where the server actually writes.
+ * Omitted, it asks about every schema the role can see, which is the safe
+ * direction: over-reporting costs a role switch that was not strictly needed,
+ * under-reporting costs the entire authorization model.
+ */
+export declare function detectConnectionPosture(run: RawSqlRunner, schemas?: string[]): Promise<ConnectionPosture>;
 /**
  * Human-actionable instructions for when the connection cannot provision the
  * user role itself (no CREATEROLE and role not pre-created by the platform).

package/dist/services/BranchService.d.ts

@@ -8,11 +8,38 @@
  */
 import { BranchInfo } from "@rebasepro/types";
 import { DrizzleClient } from "../interfaces.js";
+import { BranchRow } from "../branch-prune.js";
 import { DatabasePoolManager } from "../databasePoolManager.js";
+/**
+ * The connected server cannot branch, so nothing was done.
+ *
+ * A refusal, not a fault: typed so the transports can forward it intact.
+ * `websocket.ts` answers it with its own code and message rather than letting
+ * it fall into the generic handler, which suppresses the text in production —
+ * and the text is the only part that says what to do instead.
+ */
+export declare class BranchingUnsupportedError extends Error {
+    /** Wire code, forwarded verbatim to the client. */
+    readonly code = "BRANCHING_UNSUPPORTED";
+    constructor(message: string);
+}
 export declare class BranchService {
     private db;
     private poolManager;
     constructor(db: DrizzleClient, poolManager: DatabasePoolManager);
+    /**
+     * Refuse a branch mutation the connected server cannot honour.
+     *
+     * The check lives here rather than in the CLI's argv parsing because the
+     * CLI is not the only caller: Studio reaches `createBranch` over the
+     * websocket, and before this it got "Branch created successfully" and a
+     * detail pane promising isolation for a database that is the parent.
+     *
+     * Reads only, and only mutations are guarded: `listBranches` on a managed
+     * database is an honest empty list, and refusing it would turn the Branches
+     * pane into a failure with a "Try again" that can never succeed.
+     */
+    private assertBranchingSupported;
     /**
      * Ensure the `rebase.branches` metadata table exists in the default database.
      * Idempotent — safe to call on every startup.
@@ -29,12 +56,70 @@ export declare class BranchService {
      */
     createBranch(name: string, options?: {
         source?: string;
+        force?: boolean;
     }): Promise<BranchInfo>;
     /**
      * Delete a branch database and remove its metadata.
      * Cannot delete the main/default database.
      */
-    deleteBranch(name: string): Promise<void>;
+    deleteBranch(name: string, options?: {
+        force?: boolean;
+    }): Promise<void>;
+    /**
+     * Who is holding the database open, in words a developer can act on.
+     *
+     * `CREATE DATABASE ... TEMPLATE` and `DROP DATABASE` both require that no
+     * other session is connected, and the one thing the old message could not
+     * say is the only thing worth knowing: *which* session. "Close other
+     * clients or connections and try again" is advice you cannot follow when
+     * you do not know there is a `rebase dev` in another terminal — and that is
+     * the common case, because wanting a branch and running the app are the
+     * same moment.
+     *
+     * `application_name` is the useful column: node-postgres sends none by
+     * default, so a Rebase process shows as `(unnamed)` while DBeaver, pgAdmin
+     * and psql all name themselves. Counting by it separates "my own dev
+     * server" from "the GUI I forgot about" without any guessing.
+     *
+     * Best-effort by construction: this runs while reporting a failure, and a
+     * diagnostic that throws would replace a real error with its own.
+     */
+    private describeBlockingConnections;
+    /**
+     * Disconnect every other session on a database, and say how many.
+     *
+     * `pg_terminate_backend` rather than `pg_cancel_backend`: cancelling a
+     * query leaves the session connected, and a connected session is exactly
+     * what blocks the operation.
+     *
+     * The current backend is excluded — terminating the connection running this
+     * statement would abort the command that asked for it.
+     */
+    private terminateConnections;
+    /**
+     * Everything prune needs to decide, in two queries.
+     *
+     * Reads the rows and the server's database list rather than joining them,
+     * so the *disagreements* between the two are visible — a row whose database
+     * is gone and a database with no row are the two things prune exists to
+     * find, and a join hides both.
+     */
+    pruneCandidates(): Promise<{
+        rows: BranchRow[];
+        databases: string[];
+    }>;
+    /** Remove a metadata row whose database is already gone. */
+    forgetBranchRow(name: string): Promise<void>;
+    /**
+     * Drop a database by name, with no metadata row required.
+     *
+     * `deleteBranch` deliberately takes its database name from the row, because
+     * the row is the only value that is true by construction. Prune has the
+     * opposite job — the cases it handles are exactly the ones where row and
+     * database disagree — so it needs to name a database directly. Guarded the
+     * same way regardless: the main database is never droppable.
+     */
+    dropDatabase(dbName: string): Promise<void>;
     /**
      * List all branches recorded in the metadata table.
      * Optionally fetches database sizes from pg_database.

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

@@ -51,7 +51,7 @@ export declare function getCollectionByPath(collectionPath: string, registry: Po
  * thing against the *config* and is skipped on four paths — `strictWrites:
  * false`, a collection declaring no properties, an auth adapter that owns the
  * body's shape, and a nested route whose target cannot be walked — and it never
- * sees an in-process `rebase.data` write at all.
+ * sees an in-process `rebase.dataAsAdmin` write at all.
  *
  * It also gives `strictWrites: false` a truthful implementation. The flag is
  * documented for "a column that really does exist which the config never

package/dist/services/realtimeService.d.ts

@@ -13,6 +13,14 @@ import type { ChannelRetentionRule } from "@rebasepro/types";
 export interface SubscriptionAuthContext {
     uid: string;
     roles: string[];
+    /**
+     * Whether this session is a guest — anonymous sign-in rather than an
+     * account. Carried so a refetch's policies see the same principal the
+     * initial fetch did; without it a rule that excludes guests would filter on
+     * the REST read and not on the frames that follow, which is the shape that
+     * makes a realtime leak invisible from the surface people test.
+     */
+    isAnonymous?: boolean;
 }
 /** What a channel frame is asking to do. */
 export type ChannelAction = "join" | "broadcast" | "presence" | "history";
@@ -225,8 +233,15 @@ export declare class RealtimeService extends EventEmitter implements RealtimePro
      * would leak rows the initial (isolated) fetch correctly hid.
      */
     rlsUserRole?: string;
-    /** Whether to emit verbose debug logs (disabled in production). */
-    private static readonly DEBUG;
+    /**
+     * Verbose subscription tracing.
+     *
+     * Through the logger at `debug`, behind the same switch that lifts the
+     * `Failed query:` redaction: these lines quote paths, filters and refetch
+     * SQL, and a `console.debug` gated on `NODE_ENV` alone wrote them to stdout
+     * whatever `LOG_LEVEL` said, without passing through the one function where
+     * redaction lives.
+     */
     private debugLog;
     setDataDriver(driver: DataDriver): void;
     get subscriptions(): Map<string, Subscription>;
@@ -366,6 +381,19 @@ export declare class RealtimeService extends EventEmitter implements RealtimePro
      */
     /** The key columns of the collection at `path`, if they can be resolved. */
     private primaryKeysForPath;
+    /**
+     * `channel` addresses the error to the channel frame it is about.
+     *
+     * Without it the client had nowhere to deliver a channel error: channel
+     * frames are fire-and-forget, so there is no pending request to reject and
+     * no subscription id to match, and `CHANNEL_FORBIDDEN`, `RATE_LIMITED` and
+     * the two history failures fell through every branch of the client's
+     * message handler into a console warning. The client already routes
+     * channel-addressed frames by name — `onChannelMessage(channel, …)` — so
+     * naming the channel is all that was missing.
+     *
+     * Additive on the wire: a client that does not read it behaves as before.
+     */
     private sendError;
     private sendMessage;
     /**

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

@@ -12,7 +12,7 @@ import { PostgresCollectionRegistry } from "../collections/PostgresCollectionReg
  *   target's values. This is what the admin renders.
  * - `"inline"` — the target's own columns, flat. This is what REST serves, and
  *   — since the in-process SDK reads through the same pipeline — what
- *   `rebase.data` / `context.data` serve too. A developer never sees a ref.
+ *   `rebase.dataAsAdmin` / `context.data` serve too. A developer never sees a ref.
  *
  * They used to be two functions that happened to agree, and the agreement was
  * not enforced by anything: the row-identity bug had to be fixed five times
@@ -29,6 +29,17 @@ export type RelationStyle = "ref" | "inline";
  * to unwrap that same level back out.
  */
 export declare function isJunctionRelation(relation: ResolvedRelation): boolean;
+/** Render one target row in the requested style. */
+/**
+ * Drop every column the collection marked `excludeFromApi`.
+ *
+ * Password hashes and verification tokens have to be readable server-side but
+ * must never reach a client — and "never" has to mean every exit from this
+ * pipeline, including relation targets, or a secret leaks through whichever
+ * path was overlooked. Keyed by both the property name and its column name,
+ * since a row can arrive keyed either way depending on the caller.
+ */
+export declare function stripExcluded(row: Record<string, unknown>, collection: CollectionConfig): Record<string, unknown>;
 /**
  * The address a relation ref points at.
  *

package/dist/utils/pg-error-utils.d.ts

@@ -107,7 +107,9 @@ export declare function isRowLevelSecurityDenial(error: unknown): boolean;
  * @param context  - A human-readable context string (e.g. collection slug or path)
  * @returns An object with a `message` safe for the client and the PG `code`.
  */
-export declare function pgErrorToFriendlyMessage(pgError: PostgresError, context: string): {
+export declare function pgErrorToFriendlyMessage(pgError: PostgresError, context: string, options?: {
+    verbose?: boolean;
+}): {
     message: string;
     code: string;
 };

package/dist/utils/pg-numeric-number-patch.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Serve NUMERIC columns as JavaScript numbers.
+ *
+ * A property declared `type: "number"` without `validation.integer` becomes a
+ * Postgres `numeric` column (see `generate-drizzle-schema-logic`). Postgres
+ * sends `numeric` as text, node-postgres registers no parser for OID 1700, and
+ * drizzle's `PgNumeric.mapFromDriverValue` keeps the string — so a price
+ * written as `2.5` reads back as `"2.5"`. The generated SDK types that field
+ * `number`, the OpenAPI document this server publishes says `type: number`, and
+ * the admin's view model parses it as a number, so the string is the one shape
+ * nothing in the system claims. It also breaks *asymmetrically*: the create
+ * response carries the number and the read that follows carries the string, so
+ * a client that multiplies a price works until the first refresh.
+ *
+ * Cast here — in the driver's row mapping — rather than in one of the read
+ * paths, because there are several of them (the relational query builder, the
+ * `select` fallback, the realtime frame, the admin's view model) and only the
+ * REST renderer used to coerce. Every one of them goes through the column's
+ * `mapFromDriverValue`, so this is the single place that cannot be bypassed.
+ *
+ * The cast is safe for what a `number` property can hold: declaring a property
+ * `number` already promises double precision — that is what the admin has
+ * always parsed it to and what the generated `Row` type says. A column wider
+ * than a double (a hand-written `numeric(38, 0)` reached through an
+ * introspected collection) loses precision, which is the trade the declared
+ * type already made.
+ *
+ * `null` stays `null`; an unparseable value stays whatever the driver sent,
+ * because inventing `NaN` for it would be worse than passing it through.
+ */
+export declare function patchPgNumericToNumber(tables: Record<string, unknown>): void;

package/package.json

@@ -1,57 +1,61 @@
 {
   "name": "@rebasepro/server-postgres",
-  "type": "module",
-  "version": "0.17.3",
+  "version": "0.18.0",
   "description": "PostgreSQL data source backend implementation for Rebase with Drizzle ORM",
-  "funding": {
-    "url": "https://github.com/sponsors/rebaseco"
+  "keywords": [
+    "cms",
+    "admin",
+    "postgresql",
+    "database",
+    "drizzle",
+    "backend",
+    "rebase"
+  ],
+  "homepage": "https://rebase.pro",
+  "bugs": {
+    "url": "https://github.com/rebasepro/rebase/issues"
   },
-  "author": "Rebase",
-  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/rebasepro/rebase.git",
     "directory": "packages/server-postgres"
   },
+  "funding": {
+    "url": "https://github.com/sponsors/rebasepro"
+  },
+  "license": "MIT",
+  "author": "Rebase",
+  "type": "module",
   "main": "./dist/index.es.js",
   "module": "./dist/index.es.js",
   "types": "./dist/index.d.ts",
-  "source": "src/index.ts",
   "engines": {
-    "node": ">=20"
+    "node": ">=22.22.0"
   },
-  "keywords": [
-    "cms",
-    "admin",
-    "postgresql",
-    "database",
-    "drizzle",
-    "backend",
-    "rebase"
-  ],
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "development": "./dist/index.es.js",
-      "import": "./dist/index.es.js"
+      "import": "./dist/index.es.js",
+      "default": "./dist/index.es.js"
     },
     "./package.json": "./package.json"
   },
   "dependencies": {
     "@ariga/atlas": "^1.2.3",
     "arg": "^5.0.2",
-    "chalk": "^4.1.2",
+    "chalk": "^5.6.2",
     "chokidar": "5.0.0",
     "dotenv": "^17.4.2",
     "drizzle-orm": "^0.45.2",
     "execa": "^9.6.1",
     "pg": "^8.22.0",
     "ws": "^8.21.1",
-    "@rebasepro/codegen": "0.17.3",
-    "@rebasepro/common": "0.17.3",
-    "@rebasepro/server": "0.17.3",
-    "@rebasepro/types": "0.17.3",
-    "@rebasepro/utils": "0.17.3"
+    "@rebasepro/codegen": "0.18.0",
+    "@rebasepro/common": "0.18.0",
+    "@rebasepro/server": "0.18.0",
+    "@rebasepro/types": "0.18.0",
+    "@rebasepro/utils": "0.18.0"
   },
   "devDependencies": {
     "@hono/node-server": "^2.0.12",
@@ -65,21 +69,22 @@
     "ts-jest": "^29.4.12",
     "typescript": "^6.0.3",
     "vite": "^8.1.5",
-    "vitest": "^4.1.10"
+    "vitest": "^4.1.10",
+    "@rebasepro/client": "0.18.0"
   },
   "gitHead": "d935eefa5aa8d1009a2398cfac2c1e4ee9aeb6b6",
   "publishConfig": {
     "access": "public"
   },
   "files": [
-    "dist",
-    "src"
+    "dist"
   ],
   "scripts": {
     "watch": "vite build --watch",
     "build": "vite build && tsc --emitDeclarationOnly -p tsconfig.prod.json && node ../../tooling/scripts/add-dts-extensions.mjs dist && node ../../tooling/scripts/assert-build-output.mjs",
     "test:lint": "eslint \"src/**\" --quiet",
     "test": "jest",
+    "test:watch": "jest --watch",
     "test:e2e": "vitest run --config vitest.e2e.config.ts",
     "clean": "rm -rf dist && find ./src -name '*.js' -type f | xargs rm -f",
     "smoke:baas": "tsx scripts/smoke-baas.ts",