@prisma-next/postgres 0.5.0-dev.46 → 0.5.0-dev.47

package/README.md

@@ -2,11 +2,18 @@
 
 One-package Postgres setup for Prisma Next. Install this single package to get config, runtime, and all transitive type dependencies.
 
+Two runtime facades ship under different entrypoints:
+
+- `@prisma-next/postgres/runtime` — long-lived Node process facade with closure-cached `runtime()`, `orm`, and `transaction()`.
+- `@prisma-next/postgres/serverless` — per-request facade for serverless / edge runtimes (Cloudflare Workers + Hyperdrive, AWS Lambda, Vercel, Deno Deploy, Bun edge). Each `connect()` returns a fresh `Runtime & AsyncDisposable`.
+
+Pick the facade that matches your deployment lifecycle. The asymmetry is intentional: closure caching is unsafe across `fetch` invocations (stale connections after isolate idle, concurrent-query races, no clean shutdown), so the serverless facade deliberately omits `orm`, `runtime()`, and `transaction()`. See `docs/architecture docs/subsystems/4. Runtime & Middleware Framework.md` and the deployment guide for the rationale.
+
 ## Package Classification
 
 - **Domain**: extensions
 - **Layer**: adapters
-- **Planes**: shared (config), runtime (runtime)
+- **Planes**: shared (config), runtime (runtime, serverless)
 
 ## Quick Start
 
@@ -20,6 +27,8 @@ export default defineConfig({
 });
 ```
 
+### Node (long-lived process)
+
 ```typescript
 // db.ts
 import postgres from '@prisma-next/postgres/runtime';
@@ -29,6 +38,28 @@ import contractJson from './contract.json' with { type: 'json' };
 export const db = postgres<Contract>({ contractJson });
 ```
 
+### Serverless / per-request runtimes
+
+```typescript
+// db.ts — module scope: only the static authoring surface is built here.
+import postgresServerless from '@prisma-next/postgres/serverless';
+import type { Contract } from './contract.d';
+import contractJson from './contract.json' with { type: 'json' };
+
+export const db = postgresServerless<Contract>({ contractJson });
+
+// worker.ts — per-request: acquire a fresh Runtime, dispose with `await using`.
+export default {
+  async fetch(_req: Request, env: Env): Promise<Response> {
+    await using runtime = await db.connect({ url: env.HYPERDRIVE.connectionString });
+    const rows = await runtime.execute(db.sql.from(/* ... */).build());
+    return Response.json(rows);
+  },
+};
+```
+
+The returned client exposes `sql`, `context`, `stack`, `contract`, and `connect()` — and intentionally nothing else. Construct ORM clients (or invoke `withTransaction` from `@prisma-next/sql-runtime`) against the runtime returned by `connect()` instead of caching one on the closure.
+
 ## Exports
 
 ### `@prisma-next/postgres/config`
@@ -40,14 +71,10 @@ Simplified `defineConfig` that pre-wires all Postgres internals (family, target,
 `@prisma-next/postgres/runtime` exposes a single `postgres(...)` helper that composes the Postgres execution stack and returns query/runtime roots:
 
 - `db.sql`
-- `db.kysely` (lane-owned build-only authoring surface: `build(query)` + `whereExpr(query)`)
-- `db.schema`
 - `db.orm`
 - `db.context`
 - `db.stack`
 
-`db.kysely` is produced by `@prisma-next/sql-kysely-lane` and intentionally exposes lane behavior, not raw Kysely execution APIs. `build(query)` infers plan row type from `query.compile()`, and `whereExpr(query)` produces `ToWhereExpr` payloads for ORM `.where(...)` interop.
-
 Runtime resources are deferred until `db.runtime()` or `db.connect(...)` is called.
 Connection binding can be provided up front (`url`, `pg`, `binding`) or deferred via `db.connect(...)`.
 
@@ -56,11 +83,23 @@ When URL binding is used, pool timeouts are configurable via `poolOptions`:
 - `poolOptions.connectionTimeoutMillis` (default `20_000`)
 - `poolOptions.idleTimeoutMillis` (default `30_000`)
 
+### `@prisma-next/postgres/serverless`
+
+`@prisma-next/postgres/serverless` exposes `postgresServerless(...)` for per-request runtimes. The returned client exposes only:
+
+- `db.sql`
+- `db.context`
+- `db.stack`
+- `db.contract`
+- `db.connect({ url })` — returns `Promise<Runtime & AsyncDisposable>`
+
+Each `connect()` call constructs a fresh `pg.Client` and a fresh `Runtime`. No `pg.Pool` is allocated. `[Symbol.asyncDispose]` calls `runtime.close()`, which closes the underlying client. `pg-cursor` is enabled by default; opt out via `cursor: { disabled: true }`.
+
 ## Responsibilities
 
 - Build a static Postgres execution stack from target, adapter, and driver descriptors
-- Build typed SQL and a build-only Kysely authoring surface from the same execution context
-- Build static schema and ORM roots from the execution context
+- Build a typed SQL authoring surface from the execution context
+- Build a static ORM root from the execution context
 - Normalize runtime binding input (`binding`, `url`, `pg`)
 - Lazily instantiate runtime resources on first `db.runtime()` or `db.connect(...)` call
 - Connect the internal Postgres driver through `db.connect(...)` or from initial binding options
@@ -73,19 +112,17 @@ When URL binding is used, pool timeouts are configurable via `poolOptions`:
 - `@prisma-next/target-postgres` for target descriptor
 - `@prisma-next/adapter-postgres` for adapter descriptor
 - `@prisma-next/driver-postgres` for driver descriptor
-- `@prisma-next/sql-lane` for `sql(...)`
-- `@prisma-next/sql-kysely-lane` for contract-to-Kysely typing and build-only Kysely plan assembly
-- `@prisma-next/sql-relational-core` for `schema(...)`
+- `@prisma-next/sql-builder` for `sql(...)`
 - `@prisma-next/sql-orm-client` for `orm(...)`
 - `@prisma-next/sql-contract` for `validateContract(...)` and contract types
-- `pg` for lazy `Pool` construction when using URL binding
+- `pg` for `Pool` construction (URL / `pgPool` binding on the Node factory) and `Client` construction (`pgClient` binding on the Node factory; per-`connect()` on the serverless facade)
 
 ## Architecture
 
 ```mermaid
 flowchart TD
     App[App Code] --> Client[postgres(...)]
-    Client --> Static[Roots: sql kysely(build-only) schema orm context stack]
+    Client --> Static[Roots: sql orm context stack]
     Client --> Lazy[runtime()]
 
     Lazy --> Instantiate[instantiateExecutionStack]

package/dist/postgres-Cr7DL_TS.d.mts

@@ -0,0 +1,84 @@
+import { orm } from "@prisma-next/sql-orm-client";
+import { ExecutionContext, Runtime, RuntimeVerifyOptions, SqlExecutionStackWithDriver, SqlMiddleware, SqlRuntimeExtensionDescriptor, TransactionContext } from "@prisma-next/sql-runtime";
+import { Client, Pool } from "pg";
+import { Contract } from "@prisma-next/contract/types";
+import { Db } from "@prisma-next/sql-builder/types";
+import { SqlStorage } from "@prisma-next/sql-contract/types";
+
+//#region src/runtime/binding.d.ts
+type PostgresBinding = {
+  readonly kind: 'url';
+  readonly url: string;
+} | {
+  readonly kind: 'pgPool';
+  readonly pool: Pool;
+} | {
+  readonly kind: 'pgClient';
+  readonly client: Client;
+};
+type PostgresBindingInput = {
+  readonly binding: PostgresBinding;
+  readonly url?: never;
+  readonly pg?: never;
+} | {
+  readonly url: string;
+  readonly binding?: never;
+  readonly pg?: never;
+} | {
+  readonly pg: Pool | Client;
+  readonly binding?: never;
+  readonly url?: never;
+};
+//#endregion
+//#region src/runtime/postgres.d.ts
+type PostgresTargetId = 'postgres';
+type OrmClient<TContract extends Contract<SqlStorage>> = ReturnType<typeof orm<TContract>>;
+interface PostgresTransactionContext<TContract extends Contract<SqlStorage>> extends TransactionContext {
+  readonly sql: Db<TContract>;
+  readonly orm: OrmClient<TContract>;
+}
+interface PostgresClient<TContract extends Contract<SqlStorage>> {
+  readonly sql: Db<TContract>;
+  readonly orm: OrmClient<TContract>;
+  readonly context: ExecutionContext<TContract>;
+  readonly stack: SqlExecutionStackWithDriver<PostgresTargetId>;
+  connect(bindingInput?: PostgresBindingInput): Promise<Runtime>;
+  runtime(): Runtime;
+  transaction<R>(fn: (tx: PostgresTransactionContext<TContract>) => PromiseLike<R>): Promise<R>;
+}
+interface PostgresOptionsBase {
+  readonly extensions?: readonly SqlRuntimeExtensionDescriptor<PostgresTargetId>[];
+  readonly middleware?: readonly SqlMiddleware[];
+  readonly verify?: RuntimeVerifyOptions;
+  readonly poolOptions?: {
+    readonly connectionTimeoutMillis?: number;
+    readonly idleTimeoutMillis?: number;
+  };
+}
+interface PostgresBindingOptions {
+  readonly binding?: PostgresBinding;
+  readonly url?: string;
+  readonly pg?: Pool | Client;
+}
+type PostgresOptionsWithContract<TContract extends Contract<SqlStorage>> = PostgresBindingOptions & PostgresOptionsBase & {
+  readonly contract: TContract;
+  readonly contractJson?: never;
+};
+type PostgresOptionsWithContractJson<TContract extends Contract<SqlStorage>> = PostgresBindingOptions & PostgresOptionsBase & {
+  readonly contractJson: unknown;
+  readonly contract?: never;
+  readonly _contract?: TContract;
+};
+type PostgresOptions<TContract extends Contract<SqlStorage>> = PostgresOptionsWithContract<TContract> | PostgresOptionsWithContractJson<TContract>;
+/**
+ * Creates a lazy Postgres client from either `contractJson` or a TypeScript-authored `contract`.
+ * Static query surfaces are available immediately, while `runtime()` instantiates the driver/pool on first call.
+ *
+ * - No-emit: pass a TypeScript-authored contract. Example: postgres({ contract })
+ * - Emitted: pass Contract type explicitly. Example: postgres<Contract>({ contractJson, url })
+ */
+declare function postgres<TContract extends Contract<SqlStorage>>(options: PostgresOptionsWithContract<TContract>): PostgresClient<TContract>;
+declare function postgres<TContract extends Contract<SqlStorage>>(options: PostgresOptionsWithContractJson<TContract>): PostgresClient<TContract>;
+//#endregion
+export { PostgresOptionsWithContractJson as a, PostgresBinding as c, PostgresOptionsWithContract as i, PostgresOptions as n, PostgresTargetId as o, PostgresOptionsBase as r, postgres as s, PostgresClient as t };
+//# sourceMappingURL=postgres-Cr7DL_TS.d.mts.map

package/dist/postgres-Cr7DL_TS.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-Cr7DL_TS.d.mts","names":[],"sources":["../src/runtime/binding.ts","../src/runtime/postgres.ts"],"sourcesContent":[],"mappings":";;;;;;;;KAGY,eAAA;;;;;iBAEkC;;EAFlC,SAAA,IAAA,EAAA,UAAe;EAKf,SAAA,MAAA,EAFsC,MAElB;CAER;AAUL,KAZP,oBAAA,GAYO;EAAO,SAAA,OAAA,EAVF,eAUE;EAAM,SAAA,GAAA,CAAA,EAAA,KAAA;;;;ECepB,SAAA,OAAA,CAAA,EAAgB,KAAA;EACvB,SAAA,EAAA,CAAS,EAAA,KAAA;CAA4B,GAAA;EAAT,SAAA,EAAA,EDhBd,ICgBc,GDhBP,MCgBO;EAAqD,SAAA,OAAA,CAAA,EAAA,KAAA;EAAX,SAAA,GAAA,CAAA,EAAA,KAAA;CAAlB;;;KAD7C,gBAAA;ADhCZ,KCiCK,SDjCO,CAAA,kBCiCqB,QD9BiB,CC8BR,UD9Bc,CAAA,CAAA,GC8BC,UD9BD,CAAA,OC8BmB,GD9BnB,CC8B8B,SD9B9B,CAAA,CAAA;AAE5C,UC8BK,0BD9Be,CAAA,kBC8B8B,QD9B9B,CC8BuC,UD9BvC,CAAA,CAAA,SC+BtB,kBD/BsB,CAAA;EAER,SAAA,GAAA,EC8BR,ED9BQ,CC8BL,SD9BK,CAAA;EAUL,SAAA,GAAA,ECqBH,SDrBG,CCqBO,SDrBP,CAAA;;AAAa,UCwBf,cDxBe,CAAA,kBCwBkB,QDxBlB,CCwB2B,UDxB3B,CAAA,CAAA,CAAA;gBCyBhB,GAAG;gBACH,UAAU;oBACN,iBAAiB;EAZzB,SAAA,KAAA,EAaM,2BAbU,CAakB,gBAblB,CAAA;EACvB,OAAA,CAAA,YAAS,CAAA,EAaW,oBAbX,CAAA,EAakC,OAblC,CAa0C,OAb1C,CAAA;EAA4B,OAAA,EAAA,EAc7B,OAd6B;EAAT,WAAA,CAAA,CAAA,CAAA,CAAA,EAAA,EAAA,CAAA,EAAA,EAeP,0BAfO,CAeoB,SAfpB,CAAA,EAAA,GAemC,WAfnC,CAe+C,CAf/C,CAAA,CAAA,EAeoD,OAfpD,CAe4D,CAf5D,CAAA;;AAA0C,UAkB1D,mBAAA,CAlB0D;EAAlB,SAAA,UAAA,CAAA,EAAA,SAmBxB,6BAnBwB,CAmBM,gBAnBN,CAAA,EAAA;EAAU,SAAA,UAAA,CAAA,EAAA,SAoBlC,aApBkC,EAAA;EAElD,SAAA,MAAA,CAAA,EAmBG,oBAnBuB;EAA4B,SAAA,WAAA,CAAA,EAAA;IAAT,SAAA,uBAAA,CAAA,EAAA,MAAA;IAE3C,SAAA,iBAAA,CAAA,EAAA,MAAA;EAAH,CAAA;;AACA,UAuBC,sBAAA,CAvBD;EAFN,SAAA,OAAA,CAAA,EA0BW,eA1BX;EAAkB,SAAA,GAAA,CAAA,EAAA,MAAA;EAKX,SAAA,EAAA,CAAA,EAuBD,IAvBe,GAuBR,MAvBQ;;AAAmB,KA0BtC,2BA1BsC,CAAA,kBA0BQ,QA1BR,CA0BiB,UA1BjB,CAAA,CAAA,GA2BhD,sBA3BgD,GA4B9C,mBA5B8C,GAAA;EAC/B,SAAA,QAAA,EA4BM,SA5BN;EAAH,SAAA,YAAA,CAAA,EAAA,KAAA;CACU;AAAV,KA+BJ,+BA/BI,CAAA,kBA+B8C,QA/B9C,CA+BuD,UA/BvD,CAAA,CAAA,GAgCd,sBAhCc,GAiCZ,mBAjCY,GAAA;EACqB,SAAA,YAAA,EAAA,OAAA;EAAjB,SAAA,QAAA,CAAA,EAAA,KAAA;EAC0B,SAAA,SAAA,CAAA,EAkCnB,SAlCmB;CAA5B;AACO,KAoCb,eApCa,CAAA,kBAoCqB,QApCrB,CAoC8B,UApC9B,CAAA,CAAA,GAqCrB,2BArCqB,CAqCO,SArCP,CAAA,GAsCrB,+BAtCqB,CAsCW,SAtCX,CAAA;;;;;;;;AAEoE,iBA4ErE,QA5EqE,CAAA,kBA4E1C,QA5E0C,CA4EjC,UA5EiC,CAAA,CAAA,CAAA,OAAA,EA6ElF,2BA7EkF,CA6EtD,SA7EsD,CAAA,CAAA,EA8E1F,cA9E0F,CA8E3E,SA9E2E,CAAA;AAAR,iBA+E7D,QA/E6D,CAAA,kBA+ElC,QA/EkC,CA+EzB,UA/EyB,CAAA,CAAA,CAAA,OAAA,EAgF1E,+BAhF0E,CAgF1C,SAhF0C,CAAA,CAAA,EAiFlF,cAjFkF,CAiFnE,SAjFmE,CAAA"}

package/dist/runtime.d.mts

@@ -1,84 +1,2 @@
-import { orm } from "@prisma-next/sql-orm-client";
-import { ExecutionContext, Runtime, RuntimeVerifyOptions, SqlExecutionStackWithDriver, SqlMiddleware, SqlRuntimeExtensionDescriptor, TransactionContext } from "@prisma-next/sql-runtime";
-import { Client, Pool } from "pg";
-import { Contract } from "@prisma-next/contract/types";
-import { Db } from "@prisma-next/sql-builder/types";
-import { SqlStorage } from "@prisma-next/sql-contract/types";
-
-//#region src/runtime/binding.d.ts
-type PostgresBinding = {
-  readonly kind: 'url';
-  readonly url: string;
-} | {
-  readonly kind: 'pgPool';
-  readonly pool: Pool;
-} | {
-  readonly kind: 'pgClient';
-  readonly client: Client;
-};
-type PostgresBindingInput = {
-  readonly binding: PostgresBinding;
-  readonly url?: never;
-  readonly pg?: never;
-} | {
-  readonly url: string;
-  readonly binding?: never;
-  readonly pg?: never;
-} | {
-  readonly pg: Pool | Client;
-  readonly binding?: never;
-  readonly url?: never;
-};
-//#endregion
-//#region src/runtime/postgres.d.ts
-type PostgresTargetId = 'postgres';
-type OrmClient<TContract extends Contract<SqlStorage>> = ReturnType<typeof orm<TContract>>;
-interface PostgresTransactionContext<TContract extends Contract<SqlStorage>> extends TransactionContext {
-  readonly sql: Db<TContract>;
-  readonly orm: OrmClient<TContract>;
-}
-interface PostgresClient<TContract extends Contract<SqlStorage>> {
-  readonly sql: Db<TContract>;
-  readonly orm: OrmClient<TContract>;
-  readonly context: ExecutionContext<TContract>;
-  readonly stack: SqlExecutionStackWithDriver<PostgresTargetId>;
-  connect(bindingInput?: PostgresBindingInput): Promise<Runtime>;
-  runtime(): Runtime;
-  transaction<R>(fn: (tx: PostgresTransactionContext<TContract>) => PromiseLike<R>): Promise<R>;
-}
-interface PostgresOptionsBase {
-  readonly extensions?: readonly SqlRuntimeExtensionDescriptor<PostgresTargetId>[];
-  readonly middleware?: readonly SqlMiddleware[];
-  readonly verify?: RuntimeVerifyOptions;
-  readonly poolOptions?: {
-    readonly connectionTimeoutMillis?: number;
-    readonly idleTimeoutMillis?: number;
-  };
-}
-interface PostgresBindingOptions {
-  readonly binding?: PostgresBinding;
-  readonly url?: string;
-  readonly pg?: Pool | Client;
-}
-type PostgresOptionsWithContract<TContract extends Contract<SqlStorage>> = PostgresBindingOptions & PostgresOptionsBase & {
-  readonly contract: TContract;
-  readonly contractJson?: never;
-};
-type PostgresOptionsWithContractJson<TContract extends Contract<SqlStorage>> = PostgresBindingOptions & PostgresOptionsBase & {
-  readonly contractJson: unknown;
-  readonly contract?: never;
-  readonly _contract?: TContract;
-};
-type PostgresOptions<TContract extends Contract<SqlStorage>> = PostgresOptionsWithContract<TContract> | PostgresOptionsWithContractJson<TContract>;
-/**
- * Creates a lazy Postgres client from either `contractJson` or a TypeScript-authored `contract`.
- * Static query surfaces are available immediately, while `runtime()` instantiates the driver/pool on first call.
- *
- * - No-emit: pass a TypeScript-authored contract. Example: postgres({ contract })
- * - Emitted: pass Contract type explicitly. Example: postgres<Contract>({ contractJson, url })
- */
-declare function postgres<TContract extends Contract<SqlStorage>>(options: PostgresOptionsWithContract<TContract>): PostgresClient<TContract>;
-declare function postgres<TContract extends Contract<SqlStorage>>(options: PostgresOptionsWithContractJson<TContract>): PostgresClient<TContract>;
-//#endregion
-export { type PostgresBinding, type PostgresClient, type PostgresOptions, type PostgresOptionsBase, type PostgresOptionsWithContract, type PostgresOptionsWithContractJson, postgres as default };
-//# sourceMappingURL=runtime.d.mts.map
+import { a as PostgresOptionsWithContractJson, c as PostgresBinding, i as PostgresOptionsWithContract, n as PostgresOptions, r as PostgresOptionsBase, s as postgres, t as PostgresClient } from "./postgres-Cr7DL_TS.mjs";
+export { type PostgresBinding, type PostgresClient, type PostgresOptions, type PostgresOptionsBase, type PostgresOptionsWithContract, type PostgresOptionsWithContractJson, postgres as default };

package/dist/serverless.d.mts

@@ -0,0 +1,62 @@
+import { o as PostgresTargetId } from "./postgres-Cr7DL_TS.mjs";
+import { PostgresDriverCreateOptions } from "@prisma-next/driver-postgres/runtime";
+import { ExecutionContext, Runtime, RuntimeVerifyOptions, SqlExecutionStackWithDriver, SqlMiddleware, SqlRuntimeExtensionDescriptor } from "@prisma-next/sql-runtime";
+import { Contract } from "@prisma-next/contract/types";
+import { Db } from "@prisma-next/sql-builder/types";
+import { SqlStorage } from "@prisma-next/sql-contract/types";
+
+//#region src/runtime/postgres-serverless.d.ts
+type PostgresServerlessCursorOptions = NonNullable<PostgresDriverCreateOptions['cursor']>;
+interface PostgresServerlessClient<TContract extends Contract<SqlStorage>> {
+  readonly sql: Db<TContract>;
+  readonly context: ExecutionContext<TContract>;
+  readonly stack: SqlExecutionStackWithDriver<PostgresTargetId>;
+  readonly contract: TContract;
+  connect(binding: {
+    readonly url: string;
+  }): Promise<Runtime & AsyncDisposable>;
+}
+interface PostgresServerlessOptionsBase {
+  readonly extensions?: readonly SqlRuntimeExtensionDescriptor<PostgresTargetId>[];
+  readonly middleware?: readonly SqlMiddleware[];
+  readonly verify?: RuntimeVerifyOptions;
+  readonly cursor?: PostgresServerlessCursorOptions;
+}
+type PostgresServerlessOptionsWithContract<TContract extends Contract<SqlStorage>> = PostgresServerlessOptionsBase & {
+  readonly contract: TContract;
+  readonly contractJson?: never;
+};
+type PostgresServerlessOptionsWithContractJson<TContract extends Contract<SqlStorage>> = PostgresServerlessOptionsBase & {
+  readonly contractJson: unknown;
+  readonly contract?: never;
+  readonly _contract?: TContract;
+};
+type PostgresServerlessOptions<TContract extends Contract<SqlStorage>> = PostgresServerlessOptionsWithContract<TContract> | PostgresServerlessOptionsWithContractJson<TContract>;
+/**
+ * Per-request Postgres facade for serverless / edge runtimes (Cloudflare Workers + Hyperdrive,
+ * AWS Lambda, Vercel, Deno Deploy, Bun edge, etc.).
+ *
+ * Construction shape mirrors the Node `postgres()` factory but the returned client deliberately
+ * omits `orm`, `runtime()`, and `transaction()`. Closure-cached convenience surfaces are unsafe
+ * across `fetch` invocations: stale connections after isolate idle, concurrent-query races on a
+ * shared `pg.Client`, no clean shutdown. Per-request callers acquire a fresh `Runtime` via
+ * `db.connect({ url })` and dispose it via `await using` on scope exit.
+ *
+ * @example
+ * ```ts
+ * const db = postgresServerless<Contract>({ contractJson });
+ *
+ * export default {
+ *   async fetch(_req: Request, env: Env): Promise<Response> {
+ *     await using runtime = await db.connect({ url: env.HYPERDRIVE.connectionString });
+ *     const rows = await runtime.execute(db.sql.from(t).select(...).build());
+ *     return Response.json(rows);
+ *   },
+ * };
+ * ```
+ */
+declare function postgresServerless<TContract extends Contract<SqlStorage>>(options: PostgresServerlessOptionsWithContract<TContract>): PostgresServerlessClient<TContract>;
+declare function postgresServerless<TContract extends Contract<SqlStorage>>(options: PostgresServerlessOptionsWithContractJson<TContract>): PostgresServerlessClient<TContract>;
+//#endregion
+export { type PostgresServerlessClient, type PostgresServerlessCursorOptions, type PostgresServerlessOptions, type PostgresServerlessOptionsBase, type PostgresServerlessOptionsWithContract, type PostgresServerlessOptionsWithContractJson, postgresServerless as default };
+//# sourceMappingURL=serverless.d.mts.map

package/dist/serverless.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serverless.d.mts","names":[],"sources":["../src/runtime/postgres-serverless.ts"],"sourcesContent":[],"mappings":";;;;;;;;KA8BY,+BAAA,GAAkC,YAAY;UAEzC,2CAA2C,SAAS;EAFzD,SAAA,GAAA,EAGI,EAHJ,CAGO,SAHP,CAAA;EAEK,SAAA,OAAA,EAEG,gBAFqB,CAEJ,SAFI,CAAA;EAA4B,SAAA,KAAA,EAGnD,2BAHmD,CAGvB,gBAHuB,CAAA;EAAT,SAAA,QAAA,EAIvC,SAJuC;EACzC,OAAA,CAAA,OAAA,EAAA;IAAH,SAAA,GAAA,EAAA,MAAA;EACqB,CAAA,CAAA,EAGS,OAHT,CAGiB,OAHjB,GAG2B,eAH3B,CAAA;;AACS,UAK7B,6BAAA,CAL6B;EAA5B,SAAA,UAAA,CAAA,EAAA,SAMe,6BANf,CAM6C,gBAN7C,CAAA,EAAA;EACG,SAAA,UAAA,CAAA,EAAA,SAMY,aANZ,EAAA;EACiC,SAAA,MAAA,CAAA,EAMlC,oBANkC;EAAU,SAAA,MAAA,CAAA,EAO5C,+BAP4C;;AAAX,KAUzC,qCAVyC,CAAA,kBAUe,QAVf,CAUwB,UAVxB,CAAA,CAAA,GAWnD,6BAXmD,GAAA;EAGpC,SAAA,QAAA,EASM,SATN;EAC8C,SAAA,YAAA,CAAA,EAAA,KAAA;CAA9B;AACA,KAWrB,yCAXqB,CAAA,kBAWuC,QAXvC,CAWgD,UAXhD,CAAA,CAAA,GAY/B,6BAZ+B,GAAA;EACb,SAAA,YAAA,EAAA,OAAA;EACA,SAAA,QAAA,CAAA,EAAA,KAAA;EAA+B,SAAA,SAAA,CAAA,EAa1B,SAb0B;AAGnD,CAAA;AAA6E,KAajE,yBAbiE,CAAA,kBAarB,QAbqB,CAaZ,UAbY,CAAA,CAAA,GAczE,qCAdyE,CAcnC,SAdmC,CAAA,GAezE,yCAfyE,CAe/B,SAf+B,CAAA;;;;;AAM7E;;;;;;AAOA;;;;;;;;AAEyD;;;;;AAgD7B,iBAFJ,kBAEI,CAAA,kBAFiC,QAEjC,CAF0C,UAE1C,CAAA,CAAA,CAAA,OAAA,EADjB,qCACiB,CADqB,SACrB,CAAA,CAAA,EAAzB,wBAAyB,CAAA,SAAA,CAAA;AAAzB,iBACqB,kBADrB,CAAA,kBAC0D,QAD1D,CACmE,UADnE,CAAA,CAAA,CAAA,OAAA,EAEQ,yCAFR,CAEkD,SAFlD,CAAA,CAAA,EAGA,wBAHA,CAGyB,SAHzB,CAAA"}

package/dist/serverless.mjs

@@ -0,0 +1,81 @@
+import { ifDefined } from "@prisma-next/utils/defined";
+import postgresAdapter from "@prisma-next/adapter-postgres/runtime";
+import postgresDriver from "@prisma-next/driver-postgres/runtime";
+import { emptyCodecLookup } from "@prisma-next/framework-components/codec";
+import { instantiateExecutionStack } from "@prisma-next/framework-components/execution";
+import { sql } from "@prisma-next/sql-builder/runtime";
+import { validateContract } from "@prisma-next/sql-contract/validate";
+import { createExecutionContext, createRuntime, createSqlExecutionStack } from "@prisma-next/sql-runtime";
+import postgresTarget from "@prisma-next/target-postgres/runtime";
+import { Client } from "pg";
+
+//#region src/runtime/postgres-serverless.ts
+function hasContractJson(options) {
+	return "contractJson" in options;
+}
+function resolveContract(options) {
+	return validateContract(hasContractJson(options) ? options.contractJson : options.contract, emptyCodecLookup);
+}
+function validateConnectionString(url) {
+	const trimmed = url.trim();
+	if (trimmed.length === 0) throw new Error("Postgres URL must be a non-empty string");
+	return trimmed;
+}
+function postgresServerless(options) {
+	const contract = resolveContract(options);
+	const stack = createSqlExecutionStack({
+		target: postgresTarget,
+		adapter: postgresAdapter,
+		driver: postgresDriver,
+		extensionPacks: options.extensions ?? []
+	});
+	const context = createExecutionContext({
+		contract,
+		stack
+	});
+	return {
+		sql: sql({ context }),
+		context,
+		stack,
+		contract,
+		async connect(binding) {
+			const url = validateConnectionString(binding.url);
+			const driverDescriptor = stack.driver;
+			if (!driverDescriptor) throw new Error("Driver descriptor missing from execution stack");
+			const stackInstance = instantiateExecutionStack(stack);
+			const driver = driverDescriptor.create({ ...ifDefined("cursor", options.cursor) });
+			const client = new Client({ connectionString: url });
+			await driver.connect({
+				kind: "pgClient",
+				client
+			});
+			let runtime;
+			try {
+				runtime = createRuntime({
+					stackInstance,
+					context,
+					driver,
+					verify: options.verify ?? {
+						mode: "onFirstUse",
+						requireMarker: false
+					},
+					...ifDefined("middleware", options.middleware)
+				});
+			} catch (err) {
+				await driver.close().catch(() => void 0);
+				throw err;
+			}
+			Object.defineProperty(runtime, Symbol.asyncDispose, {
+				value: () => runtime.close(),
+				configurable: true,
+				writable: false,
+				enumerable: false
+			});
+			return runtime;
+		}
+	};
+}
+
+//#endregion
+export { postgresServerless as default };
+//# sourceMappingURL=serverless.mjs.map

package/dist/serverless.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"serverless.mjs","names":["sqlBuilder","runtime: Runtime"],"sources":["../src/runtime/postgres-serverless.ts"],"sourcesContent":["import postgresAdapter from '@prisma-next/adapter-postgres/runtime';\nimport type { Contract } from '@prisma-next/contract/types';\nimport postgresDriver, {\n  type PostgresDriverCreateOptions,\n} from '@prisma-next/driver-postgres/runtime';\nimport { emptyCodecLookup } from '@prisma-next/framework-components/codec';\nimport { instantiateExecutionStack } from '@prisma-next/framework-components/execution';\nimport { sql as sqlBuilder } from '@prisma-next/sql-builder/runtime';\nimport type { Db } from '@prisma-next/sql-builder/types';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport { validateContract } from '@prisma-next/sql-contract/validate';\nimport type {\n  ExecutionContext,\n  Runtime,\n  RuntimeVerifyOptions,\n  SqlExecutionStackWithDriver,\n  SqlMiddleware,\n  SqlRuntimeExtensionDescriptor,\n} from '@prisma-next/sql-runtime';\nimport {\n  createExecutionContext,\n  createRuntime,\n  createSqlExecutionStack,\n} from '@prisma-next/sql-runtime';\nimport postgresTarget from '@prisma-next/target-postgres/runtime';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { Client } from 'pg';\n\nimport type { PostgresTargetId } from './postgres';\n\nexport type PostgresServerlessCursorOptions = NonNullable<PostgresDriverCreateOptions['cursor']>;\n\nexport interface PostgresServerlessClient<TContract extends Contract<SqlStorage>> {\n  readonly sql: Db<TContract>;\n  readonly context: ExecutionContext<TContract>;\n  readonly stack: SqlExecutionStackWithDriver<PostgresTargetId>;\n  readonly contract: TContract;\n  connect(binding: { readonly url: string }): Promise<Runtime & AsyncDisposable>;\n}\n\nexport interface PostgresServerlessOptionsBase {\n  readonly extensions?: readonly SqlRuntimeExtensionDescriptor<PostgresTargetId>[];\n  readonly middleware?: readonly SqlMiddleware[];\n  readonly verify?: RuntimeVerifyOptions;\n  readonly cursor?: PostgresServerlessCursorOptions;\n}\n\nexport type PostgresServerlessOptionsWithContract<TContract extends Contract<SqlStorage>> =\n  PostgresServerlessOptionsBase & {\n    readonly contract: TContract;\n    readonly contractJson?: never;\n  };\n\nexport type PostgresServerlessOptionsWithContractJson<TContract extends Contract<SqlStorage>> =\n  PostgresServerlessOptionsBase & {\n    readonly contractJson: unknown;\n    readonly contract?: never;\n    readonly _contract?: TContract;\n  };\n\nexport type PostgresServerlessOptions<TContract extends Contract<SqlStorage>> =\n  | PostgresServerlessOptionsWithContract<TContract>\n  | PostgresServerlessOptionsWithContractJson<TContract>;\n\nfunction hasContractJson<TContract extends Contract<SqlStorage>>(\n  options: PostgresServerlessOptions<TContract>,\n): options is PostgresServerlessOptionsWithContractJson<TContract> {\n  return 'contractJson' in options;\n}\n\nfunction resolveContract<TContract extends Contract<SqlStorage>>(\n  options: PostgresServerlessOptions<TContract>,\n): TContract {\n  const contractInput = hasContractJson(options) ? options.contractJson : options.contract;\n  return validateContract<TContract>(contractInput, emptyCodecLookup);\n}\n\nfunction validateConnectionString(url: string): string {\n  const trimmed = url.trim();\n  if (trimmed.length === 0) {\n    throw new Error('Postgres URL must be a non-empty string');\n  }\n  return trimmed;\n}\n\n/**\n * Per-request Postgres facade for serverless / edge runtimes (Cloudflare Workers + Hyperdrive,\n * AWS Lambda, Vercel, Deno Deploy, Bun edge, etc.).\n *\n * Construction shape mirrors the Node `postgres()` factory but the returned client deliberately\n * omits `orm`, `runtime()`, and `transaction()`. Closure-cached convenience surfaces are unsafe\n * across `fetch` invocations: stale connections after isolate idle, concurrent-query races on a\n * shared `pg.Client`, no clean shutdown. Per-request callers acquire a fresh `Runtime` via\n * `db.connect({ url })` and dispose it via `await using` on scope exit.\n *\n * @example\n * ```ts\n * const db = postgresServerless<Contract>({ contractJson });\n *\n * export default {\n *   async fetch(_req: Request, env: Env): Promise<Response> {\n *     await using runtime = await db.connect({ url: env.HYPERDRIVE.connectionString });\n *     const rows = await runtime.execute(db.sql.from(t).select(...).build());\n *     return Response.json(rows);\n *   },\n * };\n * ```\n */\nexport default function postgresServerless<TContract extends Contract<SqlStorage>>(\n  options: PostgresServerlessOptionsWithContract<TContract>,\n): PostgresServerlessClient<TContract>;\nexport default function postgresServerless<TContract extends Contract<SqlStorage>>(\n  options: PostgresServerlessOptionsWithContractJson<TContract>,\n): PostgresServerlessClient<TContract>;\nexport default function postgresServerless<TContract extends Contract<SqlStorage>>(\n  options: PostgresServerlessOptions<TContract>,\n): PostgresServerlessClient<TContract> {\n  const contract = resolveContract(options);\n  const stack = createSqlExecutionStack({\n    target: postgresTarget,\n    adapter: postgresAdapter,\n    driver: postgresDriver,\n    extensionPacks: options.extensions ?? [],\n  });\n\n  const context = createExecutionContext({\n    contract,\n    stack,\n  });\n\n  const sql: Db<TContract> = sqlBuilder<TContract>({ context });\n\n  return {\n    sql,\n    context,\n    stack,\n    contract,\n\n    async connect(binding) {\n      const url = validateConnectionString(binding.url);\n\n      const driverDescriptor = stack.driver;\n      if (!driverDescriptor) {\n        throw new Error('Driver descriptor missing from execution stack');\n      }\n\n      const stackInstance = instantiateExecutionStack(stack);\n      const driver = driverDescriptor.create({\n        ...ifDefined('cursor', options.cursor),\n      });\n\n      const client = new Client({ connectionString: url });\n      await driver.connect({ kind: 'pgClient', client });\n\n      let runtime: Runtime;\n      try {\n        runtime = createRuntime({\n          stackInstance,\n          context,\n          driver,\n          verify: options.verify ?? { mode: 'onFirstUse', requireMarker: false },\n          ...ifDefined('middleware', options.middleware),\n        });\n      } catch (err) {\n        // The driver is bound to the pg.Client at this point; without a runtime\n        // to wrap it, the caller has no handle to dispose. Close the driver so\n        // the underlying pg.Client is released even if its TCP socket has not\n        // yet opened (lazy connect): keeps cleanup symmetric with successful\n        // construction and prevents real socket leaks if pg ever changes its\n        // connect semantics.\n        await driver.close().catch(() => undefined);\n        throw err;\n      }\n\n      Object.defineProperty(runtime, Symbol.asyncDispose, {\n        value: () => runtime.close(),\n        configurable: true,\n        writable: false,\n        enumerable: false,\n      });\n\n      return runtime as Runtime & AsyncDisposable;\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;AAgEA,SAAS,gBACP,SACiE;AACjE,QAAO,kBAAkB;;AAG3B,SAAS,gBACP,SACW;AAEX,QAAO,iBADe,gBAAgB,QAAQ,GAAG,QAAQ,eAAe,QAAQ,UAC9B,iBAAiB;;AAGrE,SAAS,yBAAyB,KAAqB;CACrD,MAAM,UAAU,IAAI,MAAM;AAC1B,KAAI,QAAQ,WAAW,EACrB,OAAM,IAAI,MAAM,0CAA0C;AAE5D,QAAO;;AAgCT,SAAwB,mBACtB,SACqC;CACrC,MAAM,WAAW,gBAAgB,QAAQ;CACzC,MAAM,QAAQ,wBAAwB;EACpC,QAAQ;EACR,SAAS;EACT,QAAQ;EACR,gBAAgB,QAAQ,cAAc,EAAE;EACzC,CAAC;CAEF,MAAM,UAAU,uBAAuB;EACrC;EACA;EACD,CAAC;AAIF,QAAO;EACL,KAHyBA,IAAsB,EAAE,SAAS,CAAC;EAI3D;EACA;EACA;EAEA,MAAM,QAAQ,SAAS;GACrB,MAAM,MAAM,yBAAyB,QAAQ,IAAI;GAEjD,MAAM,mBAAmB,MAAM;AAC/B,OAAI,CAAC,iBACH,OAAM,IAAI,MAAM,iDAAiD;GAGnE,MAAM,gBAAgB,0BAA0B,MAAM;GACtD,MAAM,SAAS,iBAAiB,OAAO,EACrC,GAAG,UAAU,UAAU,QAAQ,OAAO,EACvC,CAAC;GAEF,MAAM,SAAS,IAAI,OAAO,EAAE,kBAAkB,KAAK,CAAC;AACpD,SAAM,OAAO,QAAQ;IAAE,MAAM;IAAY;IAAQ,CAAC;GAElD,IAAIC;AACJ,OAAI;AACF,cAAU,cAAc;KACtB;KACA;KACA;KACA,QAAQ,QAAQ,UAAU;MAAE,MAAM;MAAc,eAAe;MAAO;KACtE,GAAG,UAAU,cAAc,QAAQ,WAAW;KAC/C,CAAC;YACK,KAAK;AAOZ,UAAM,OAAO,OAAO,CAAC,YAAY,OAAU;AAC3C,UAAM;;AAGR,UAAO,eAAe,SAAS,OAAO,cAAc;IAClD,aAAa,QAAQ,OAAO;IAC5B,cAAc;IACd,UAAU;IACV,YAAY;IACb,CAAC;AAEF,UAAO;;EAEV"}

package/package.json

@@ -1,27 +1,27 @@
 {
   "name": "@prisma-next/postgres",
-  "version": "0.5.0-dev.46",
+  "version": "0.5.0-dev.47",
   "type": "module",
   "sideEffects": false,
   "description": "One-liner lazy Postgres client composition for Prisma Next",
   "dependencies": {
     "pathe": "^2.0.3",
     "pg": "8.16.3",
-    "@prisma-next/adapter-postgres": "0.5.0-dev.46",
-    "@prisma-next/config": "0.5.0-dev.46",
-    "@prisma-next/contract": "0.5.0-dev.46",
-    "@prisma-next/family-sql": "0.5.0-dev.46",
-    "@prisma-next/framework-components": "0.5.0-dev.46",
-    "@prisma-next/sql-contract": "0.5.0-dev.46",
-    "@prisma-next/driver-postgres": "0.5.0-dev.46",
-    "@prisma-next/sql-contract-psl": "0.5.0-dev.46",
-    "@prisma-next/sql-contract-ts": "0.5.0-dev.46",
-    "@prisma-next/sql-builder": "0.5.0-dev.46",
-    "@prisma-next/sql-orm-client": "0.5.0-dev.46",
-    "@prisma-next/target-postgres": "0.5.0-dev.46",
-    "@prisma-next/sql-runtime": "0.5.0-dev.46",
-    "@prisma-next/sql-relational-core": "0.5.0-dev.46",
-    "@prisma-next/utils": "0.5.0-dev.46"
+    "@prisma-next/adapter-postgres": "0.5.0-dev.47",
+    "@prisma-next/config": "0.5.0-dev.47",
+    "@prisma-next/contract": "0.5.0-dev.47",
+    "@prisma-next/family-sql": "0.5.0-dev.47",
+    "@prisma-next/sql-contract": "0.5.0-dev.47",
+    "@prisma-next/driver-postgres": "0.5.0-dev.47",
+    "@prisma-next/framework-components": "0.5.0-dev.47",
+    "@prisma-next/sql-contract-psl": "0.5.0-dev.47",
+    "@prisma-next/sql-builder": "0.5.0-dev.47",
+    "@prisma-next/sql-contract-ts": "0.5.0-dev.47",
+    "@prisma-next/sql-relational-core": "0.5.0-dev.47",
+    "@prisma-next/target-postgres": "0.5.0-dev.47",
+    "@prisma-next/sql-runtime": "0.5.0-dev.47",
+    "@prisma-next/utils": "0.5.0-dev.47",
+    "@prisma-next/sql-orm-client": "0.5.0-dev.47"
   },
   "devDependencies": {
     "@types/pg": "8.16.0",
@@ -47,6 +47,7 @@
   "exports": {
     "./config": "./dist/config.mjs",
     "./runtime": "./dist/runtime.mjs",
+    "./serverless": "./dist/serverless.mjs",
     "./package.json": "./package.json"
   },
   "main": "./dist/runtime.mjs",

package/src/exports/serverless.ts

@@ -0,0 +1,9 @@
+export type {
+  PostgresServerlessClient,
+  PostgresServerlessCursorOptions,
+  PostgresServerlessOptions,
+  PostgresServerlessOptionsBase,
+  PostgresServerlessOptionsWithContract,
+  PostgresServerlessOptionsWithContractJson,
+} from '../runtime/postgres-serverless';
+export { default } from '../runtime/postgres-serverless';

package/src/runtime/postgres-serverless.ts

@@ -0,0 +1,185 @@
+import postgresAdapter from '@prisma-next/adapter-postgres/runtime';
+import type { Contract } from '@prisma-next/contract/types';
+import postgresDriver, {
+  type PostgresDriverCreateOptions,
+} from '@prisma-next/driver-postgres/runtime';
+import { emptyCodecLookup } from '@prisma-next/framework-components/codec';
+import { instantiateExecutionStack } from '@prisma-next/framework-components/execution';
+import { sql as sqlBuilder } from '@prisma-next/sql-builder/runtime';
+import type { Db } from '@prisma-next/sql-builder/types';
+import type { SqlStorage } from '@prisma-next/sql-contract/types';
+import { validateContract } from '@prisma-next/sql-contract/validate';
+import type {
+  ExecutionContext,
+  Runtime,
+  RuntimeVerifyOptions,
+  SqlExecutionStackWithDriver,
+  SqlMiddleware,
+  SqlRuntimeExtensionDescriptor,
+} from '@prisma-next/sql-runtime';
+import {
+  createExecutionContext,
+  createRuntime,
+  createSqlExecutionStack,
+} from '@prisma-next/sql-runtime';
+import postgresTarget from '@prisma-next/target-postgres/runtime';
+import { ifDefined } from '@prisma-next/utils/defined';
+import { Client } from 'pg';
+
+import type { PostgresTargetId } from './postgres';
+
+export type PostgresServerlessCursorOptions = NonNullable<PostgresDriverCreateOptions['cursor']>;
+
+export interface PostgresServerlessClient<TContract extends Contract<SqlStorage>> {
+  readonly sql: Db<TContract>;
+  readonly context: ExecutionContext<TContract>;
+  readonly stack: SqlExecutionStackWithDriver<PostgresTargetId>;
+  readonly contract: TContract;
+  connect(binding: { readonly url: string }): Promise<Runtime & AsyncDisposable>;
+}
+
+export interface PostgresServerlessOptionsBase {
+  readonly extensions?: readonly SqlRuntimeExtensionDescriptor<PostgresTargetId>[];
+  readonly middleware?: readonly SqlMiddleware[];
+  readonly verify?: RuntimeVerifyOptions;
+  readonly cursor?: PostgresServerlessCursorOptions;
+}
+
+export type PostgresServerlessOptionsWithContract<TContract extends Contract<SqlStorage>> =
+  PostgresServerlessOptionsBase & {
+    readonly contract: TContract;
+    readonly contractJson?: never;
+  };
+
+export type PostgresServerlessOptionsWithContractJson<TContract extends Contract<SqlStorage>> =
+  PostgresServerlessOptionsBase & {
+    readonly contractJson: unknown;
+    readonly contract?: never;
+    readonly _contract?: TContract;
+  };
+
+export type PostgresServerlessOptions<TContract extends Contract<SqlStorage>> =
+  | PostgresServerlessOptionsWithContract<TContract>
+  | PostgresServerlessOptionsWithContractJson<TContract>;
+
+function hasContractJson<TContract extends Contract<SqlStorage>>(
+  options: PostgresServerlessOptions<TContract>,
+): options is PostgresServerlessOptionsWithContractJson<TContract> {
+  return 'contractJson' in options;
+}
+
+function resolveContract<TContract extends Contract<SqlStorage>>(
+  options: PostgresServerlessOptions<TContract>,
+): TContract {
+  const contractInput = hasContractJson(options) ? options.contractJson : options.contract;
+  return validateContract<TContract>(contractInput, emptyCodecLookup);
+}
+
+function validateConnectionString(url: string): string {
+  const trimmed = url.trim();
+  if (trimmed.length === 0) {
+    throw new Error('Postgres URL must be a non-empty string');
+  }
+  return trimmed;
+}
+
+/**
+ * Per-request Postgres facade for serverless / edge runtimes (Cloudflare Workers + Hyperdrive,
+ * AWS Lambda, Vercel, Deno Deploy, Bun edge, etc.).
+ *
+ * Construction shape mirrors the Node `postgres()` factory but the returned client deliberately
+ * omits `orm`, `runtime()`, and `transaction()`. Closure-cached convenience surfaces are unsafe
+ * across `fetch` invocations: stale connections after isolate idle, concurrent-query races on a
+ * shared `pg.Client`, no clean shutdown. Per-request callers acquire a fresh `Runtime` via
+ * `db.connect({ url })` and dispose it via `await using` on scope exit.
+ *
+ * @example
+ * ```ts
+ * const db = postgresServerless<Contract>({ contractJson });
+ *
+ * export default {
+ *   async fetch(_req: Request, env: Env): Promise<Response> {
+ *     await using runtime = await db.connect({ url: env.HYPERDRIVE.connectionString });
+ *     const rows = await runtime.execute(db.sql.from(t).select(...).build());
+ *     return Response.json(rows);
+ *   },
+ * };
+ * ```
+ */
+export default function postgresServerless<TContract extends Contract<SqlStorage>>(
+  options: PostgresServerlessOptionsWithContract<TContract>,
+): PostgresServerlessClient<TContract>;
+export default function postgresServerless<TContract extends Contract<SqlStorage>>(
+  options: PostgresServerlessOptionsWithContractJson<TContract>,
+): PostgresServerlessClient<TContract>;
+export default function postgresServerless<TContract extends Contract<SqlStorage>>(
+  options: PostgresServerlessOptions<TContract>,
+): PostgresServerlessClient<TContract> {
+  const contract = resolveContract(options);
+  const stack = createSqlExecutionStack({
+    target: postgresTarget,
+    adapter: postgresAdapter,
+    driver: postgresDriver,
+    extensionPacks: options.extensions ?? [],
+  });
+
+  const context = createExecutionContext({
+    contract,
+    stack,
+  });
+
+  const sql: Db<TContract> = sqlBuilder<TContract>({ context });
+
+  return {
+    sql,
+    context,
+    stack,
+    contract,
+
+    async connect(binding) {
+      const url = validateConnectionString(binding.url);
+
+      const driverDescriptor = stack.driver;
+      if (!driverDescriptor) {
+        throw new Error('Driver descriptor missing from execution stack');
+      }
+
+      const stackInstance = instantiateExecutionStack(stack);
+      const driver = driverDescriptor.create({
+        ...ifDefined('cursor', options.cursor),
+      });
+
+      const client = new Client({ connectionString: url });
+      await driver.connect({ kind: 'pgClient', client });
+
+      let runtime: Runtime;
+      try {
+        runtime = createRuntime({
+          stackInstance,
+          context,
+          driver,
+          verify: options.verify ?? { mode: 'onFirstUse', requireMarker: false },
+          ...ifDefined('middleware', options.middleware),
+        });
+      } catch (err) {
+        // The driver is bound to the pg.Client at this point; without a runtime
+        // to wrap it, the caller has no handle to dispose. Close the driver so
+        // the underlying pg.Client is released even if its TCP socket has not
+        // yet opened (lazy connect): keeps cleanup symmetric with successful
+        // construction and prevents real socket leaks if pg ever changes its
+        // connect semantics.
+        await driver.close().catch(() => undefined);
+        throw err;
+      }
+
+      Object.defineProperty(runtime, Symbol.asyncDispose, {
+        value: () => runtime.close(),
+        configurable: true,
+        writable: false,
+        enumerable: false,
+      });
+
+      return runtime as Runtime & AsyncDisposable;
+    },
+  };
+}

package/dist/runtime.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/runtime/binding.ts","../src/runtime/postgres.ts"],"sourcesContent":[],"mappings":"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"}