@prisma-next/postgres 0.0.1 → 0.3.0-dev.122

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [2026] [Prisma Data, Inc]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,23 +1,28 @@
 # @prisma-next/postgres
 
-One-liner lazy Postgres client for Prisma Next runtime composition.
+Composition-root Postgres helper that builds a Prisma Next runtime client and exposes SQL, ORM, schema, and Kysely-integrated query access.
 
 ## Package Classification
 
-- **Domain**: targets
-- **Layer**: clients
+- **Domain**: extensions
+- **Layer**: adapters
 - **Plane**: runtime
 
 ## Overview
 
-`@prisma-next/postgres/runtime` exposes a single `postgres(...)` helper that composes the SQL execution stack for Postgres and returns static query roots immediately:
+`@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`
 
-Runtime and connection resources are deferred until `await db.runtime()` is called. The getter returns `Promise<Runtime>`.
+`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(...)`.
 
 When URL binding is used, pool timeouts are configurable via `poolOptions`:
 
@@ -27,11 +32,12 @@ When URL binding is used, pool timeouts are configurable via `poolOptions`:
 ## Responsibilities
 
 - Build a static Postgres execution stack from target, adapter, and driver descriptors
-- Build static query roots from the execution context
+- 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
 - Normalize runtime binding input (`binding`, `url`, `pg`)
-- Lazily instantiate stack and driver on first `await db.runtime()` call
-- Connect driver with resolved binding before creating runtime
-- Memoize runtime so repeated `await db.runtime()` calls return one instance
+- 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
+- Memoize runtime so repeated `db.runtime()` calls return one instance
 
 ## Dependencies
 
@@ -41,23 +47,25 @@ When URL binding is used, pool timeouts are configurable via `poolOptions`:
 - `@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-orm-client` for `orm(...)`
 - `@prisma-next/sql-contract` for `validateContract(...)` and contract types
-- `pg` for binding validation when using `pg` (Pool or Client) input
+- `pg` for lazy `Pool` construction when using URL binding
 
 ## Architecture
 
 ```mermaid
 flowchart TD
     App[App Code] --> Client[postgres(...)]
-    Client --> Static[Static roots: sql schema context stack]
+    Client --> Static[Roots: sql kysely(build-only) schema orm context stack]
     Client --> Lazy[runtime()]
 
     Lazy --> Instantiate[instantiateExecutionStack]
     Lazy --> Bind[Resolve binding: url or pg]
-    Bind --> Assert[Assert stackInstance.driver]
-    Assert --> Connect[driver.connect binding]
-    Connect --> Runtime[createRuntime]
+    Bind --> Pool[pg.Pool for url binding]
+    Bind --> Reuse[Reuse Pool or Client for pg binding]
+    Lazy --> Runtime[createRuntime]
 
     Runtime --> Target[@prisma-next/target-postgres]
     Runtime --> Adapter[@prisma-next/adapter-postgres]
@@ -68,6 +76,6 @@ flowchart TD
 
 ## Related Docs
 
-- Spec: `agent-os/specs/2026-02-10-postgres-one-liner-lazy-client/spec.md`
 - Architecture: `docs/Architecture Overview.md`
 - Subsystem: `docs/architecture docs/subsystems/4. Runtime & Plugin Framework.md`
+- Subsystem: `docs/architecture docs/subsystems/5. Adapters & Targets.md`

package/dist/runtime.d.mts

@@ -1,14 +1,25 @@
-import { PostgresBinding, PostgresBinding as PostgresBinding$1, PostgresDriverCreateOptions } from "@prisma-next/driver-postgres/runtime";
+import { KyselyQueryLane, KyselyQueryLane as KyselyQueryLane$1 } from "@prisma-next/sql-kysely-lane";
 import { SelectBuilder } from "@prisma-next/sql-lane";
+import { orm } from "@prisma-next/sql-orm-client";
 import { SchemaHandle } from "@prisma-next/sql-relational-core/schema";
 import { ExecutionContext, Plugin, Runtime, RuntimeVerifyOptions, SqlExecutionStackWithDriver, SqlRuntimeExtensionDescriptor } from "@prisma-next/sql-runtime";
 import { Client, Pool } from "pg";
-import { ExtractCodecTypes, ExtractOperationTypes, SqlContract, SqlStorage } from "@prisma-next/sql-contract/types";
+import { ExtractTypeMapsFromContract, ResolveCodecTypes, ResolveOperationTypes, SqlContract, SqlStorage } from "@prisma-next/sql-contract/types";
 import { OperationTypeSignature, OperationTypes } from "@prisma-next/sql-relational-core/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$1;
+  readonly binding: PostgresBinding;
   readonly url?: never;
   readonly pg?: never;
 } | {
@@ -25,24 +36,36 @@ type PostgresBindingInput = {
 type NormalizeOperationTypes<T> = { [TypeId in keyof T]: { [Method in keyof T[TypeId]]: T[TypeId][Method] extends OperationTypeSignature ? T[TypeId][Method] : OperationTypeSignature } };
 type ToSchemaOperationTypes<T> = T extends OperationTypes ? T : NormalizeOperationTypes<T>;
 type PostgresTargetId = 'postgres';
-interface PostgresClient<TContract extends SqlContract<SqlStorage>> {
-  readonly sql: SelectBuilder<TContract, unknown, ExtractCodecTypes<TContract>, ExtractOperationTypes<TContract>>;
-  readonly schema: SchemaHandle<TContract, ExtractCodecTypes<TContract>, ToSchemaOperationTypes<ExtractOperationTypes<TContract>>>;
+type OrmClient<TContract extends SqlContract<SqlStorage>> = ReturnType<typeof orm<TContract>>;
+interface PostgresClient<TContract extends SqlContract<SqlStorage>, TTypeMaps = ExtractTypeMapsFromContract<TContract>> {
+  readonly sql: SelectBuilder<TContract, unknown, ResolveCodecTypes<TContract, TTypeMaps>, ResolveOperationTypes<TContract, TTypeMaps>>;
+  readonly kysely: KyselyQueryLane$1<TContract>;
+  readonly schema: SchemaHandle<TContract, ResolveCodecTypes<TContract, TTypeMaps>, ToSchemaOperationTypes<ResolveOperationTypes<TContract, TTypeMaps>>>;
+  readonly orm: OrmClient<TContract>;
   readonly context: ExecutionContext<TContract>;
   readonly stack: SqlExecutionStackWithDriver<PostgresTargetId>;
-  runtime(): Promise<Runtime>;
+  connect(bindingInput?: PostgresBindingInput): Promise<Runtime>;
+  runtime(): Runtime;
 }
 interface PostgresOptionsBase<TContract extends SqlContract<SqlStorage>> {
   readonly extensions?: readonly SqlRuntimeExtensionDescriptor<PostgresTargetId>[];
   readonly plugins?: readonly Plugin<TContract>[];
   readonly verify?: RuntimeVerifyOptions;
-  readonly cursor?: PostgresDriverCreateOptions['cursor'];
+  readonly poolOptions?: {
+    readonly connectionTimeoutMillis?: number;
+    readonly idleTimeoutMillis?: number;
+  };
+}
+interface PostgresBindingOptions {
+  readonly binding?: PostgresBinding;
+  readonly url?: string;
+  readonly pg?: Pool | Client;
 }
-type PostgresOptionsWithContract<TContract extends SqlContract<SqlStorage>> = PostgresBindingInput & PostgresOptionsBase<TContract> & {
+type PostgresOptionsWithContract<TContract extends SqlContract<SqlStorage>> = PostgresBindingOptions & PostgresOptionsBase<TContract> & {
   readonly contract: TContract;
   readonly contractJson?: never;
 };
-type PostgresOptionsWithContractJson<TContract extends SqlContract<SqlStorage>> = PostgresBindingInput & PostgresOptionsBase<TContract> & {
+type PostgresOptionsWithContractJson<TContract extends SqlContract<SqlStorage>> = PostgresBindingOptions & PostgresOptionsBase<TContract> & {
   readonly contractJson: unknown;
   readonly contract?: never;
 };
@@ -50,9 +73,12 @@ type PostgresOptions<TContract extends SqlContract<SqlStorage>> = PostgresOption
 /**
  * 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: infers TypeMaps from ContractWithTypeMaps. Example: postgres({ contract })
+ * - Emitted: pass TypeMaps explicitly. Example: postgres<Contract, TypeMaps>({ contractJson, url })
  */
-declare function postgres<TContract extends SqlContract<SqlStorage>>(options: PostgresOptionsWithContract<TContract>): PostgresClient<TContract>;
-declare function postgres<TContract extends SqlContract<SqlStorage>>(options: PostgresOptionsWithContractJson<TContract>): PostgresClient<TContract>;
+declare function postgres<TContract extends SqlContract<SqlStorage>, TTypeMaps = ExtractTypeMapsFromContract<TContract>>(options: PostgresOptionsWithContract<TContract>): PostgresClient<TContract, TTypeMaps>;
+declare function postgres<TContract extends SqlContract<SqlStorage>, TTypeMaps = ExtractTypeMapsFromContract<TContract>>(options: PostgresOptionsWithContractJson<TContract>): PostgresClient<TContract, TTypeMaps>;
 //#endregion
-export { type PostgresBinding, type PostgresClient, type PostgresOptions, type PostgresOptionsBase, type PostgresOptionsWithContract, type PostgresOptionsWithContractJson, postgres as default };
+export { type KyselyQueryLane, type PostgresBinding, type PostgresClient, type PostgresOptions, type PostgresOptionsBase, type PostgresOptionsWithContract, type PostgresOptionsWithContractJson, postgres as default };
 //# sourceMappingURL=runtime.d.mts.map

package/dist/runtime.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/runtime/binding.ts","../src/runtime/postgres.ts"],"sourcesContent":[],"mappings":";;;;;;;;;KAIY,oBAAA;oBAEY;;;;;;EAFZ,SAAA,EAAA,CAAA,EAAA,KAAA;CAEY,GAAA;EAUL,SAAA,EAAA,EAAA,IAAA,GAAO,MAAP;EAAO,SAAA,OAAA,CAAA,EAAA,KAAA;EAAM,SAAA,GAAA,CAAA,EAAA,KAAA;;;;KCoB3B,gDACc,iBDjCP,MCkCS,CDlCT,CCkCW,MDlCS,CAAA,GCkCC,CDlCD,CCkCG,MDlCH,CAAA,CCkCW,MDlCX,CAAA,SCkC2B,sBDlC3B,GCmCxB,CDnCwB,CCmCtB,MDnCsB,CAAA,CCmCd,MDnCc,CAAA,GCoCxB,sBDpCwB,EAER,EAUL;KC4Bd,sBD5BqB,CAAA,CAAA,CAAA,GC4BO,CD5BP,SC4BiB,cD5BjB,GC4BkC,CD5BlC,GC4BsC,uBD5BtC,CC4B8D,CD5B9D,CAAA;AAAM,KC8BpB,gBAAA,GD9BoB,UAAA;UCgCf,iCAAiC,YAAY;gBAC9C,cACZ,oBAEA,kBAAkB,YAClB,sBAAsB;mBAEP,aACf,WACA,kBAAkB,YAClB,uBAAuB,sBAAsB;EAtB5C,SAAA,OAAA,EAwBe,gBAxBQ,CAwBS,SAxBT,CAAA;EACT,SAAA,KAAA,EAwBD,2BAxBC,CAwB2B,gBAxB3B,CAAA;EACE,OAAA,EAAA,EAwBR,OAxBQ,CAwBA,OAxBA,CAAA;;AAAY,UA2BhB,mBA3BgB,CAAA,kBA2BsB,WA3BtB,CA2BkC,UA3BlC,CAAA,CAAA,CAAA;EAAE,SAAA,UAAA,CAAA,EAAA,SA4BF,6BA5BE,CA4B4B,gBA5B5B,CAAA,EAAA;EAAQ,SAAA,OAAA,CAAA,EAAA,SA6Bb,MA7Ba,CA6BN,SA7BM,CAAA,EAAA;EAAgB,SAAA,MAAA,CAAA,EA8BvC,oBA9BuC;EACnD,SAAA,MAAA,CAAA,EA8BY,2BA9BZ,CAAA,QAAA,CAAA;;AAAU,KAiCN,2BAjCM,CAAA,kBAiCwC,WAjCxC,CAiCoD,UAjCpD,CAAA,CAAA,GAkChB,oBAlCgB,GAmCd,mBAnCc,CAmCM,SAnCN,CAAA,GAAA;EACV,SAAA,QAAA,EAmCiB,SAnCjB;EAAsB,SAAA,YAAA,CAAA,EAAA,KAAA;AAAA,CAAA;AAIG,KAmCrB,+BAnCqB,CAAA,kBAmC6B,WAnC7B,CAmCyC,UAnCzC,CAAA,CAAA,GAoC/B,oBApC+B,GAqC7B,mBArC6B,CAqCT,SArCS,CAAA,GAAA;EAAU,SAAA,YAAA,EAAA,OAAA;EAAiB,SAAA,QAAA,CAAA,EAAA,KAAA;CAA4B;AAAxB,KA0CpD,eA1CoD,CAAA,kBA0ClB,WA1CkB,CA0CN,UA1CM,CAAA,CAAA,GA2C5D,2BA3C4D,CA2ChC,SA3CgC,CAAA,GA4C5D,+BA5C4D,CA4C5B,SA5C4B,CAAA;;AAEhE;AAEA;;AAAkD,iBA2D1B,QA3D0B,CAAA,kBA2DC,WA3DD,CA2Da,UA3Db,CAAA,CAAA,CAAA,OAAA,EA4DvC,2BA5DuC,CA4DX,SA5DW,CAAA,CAAA,EA6D/C,cA7D+C,CA6DhC,SA7DgC,CAAA;AAE9C,iBA4DoB,QA5DpB,CAAA,kBA4D+C,WA5D/C,CA4D2D,UA5D3D,CAAA,CAAA,CAAA,OAAA,EA6DO,+BA7DP,CA6DuC,SA7DvC,CAAA,CAAA,EA8DD,cA9DC,CA8Dc,SA9Dd,CAAA"}
+{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/runtime/binding.ts","../src/runtime/postgres.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/runtime.mjs

@@ -2,60 +2,36 @@ import postgresAdapter from "@prisma-next/adapter-postgres/runtime";
 import { instantiateExecutionStack } from "@prisma-next/core-execution-plane/stack";
 import postgresDriver from "@prisma-next/driver-postgres/runtime";
 import { validateContract } from "@prisma-next/sql-contract/validate";
+import { createKyselyLane } from "@prisma-next/sql-kysely-lane";
 import { sql } from "@prisma-next/sql-lane";
+import { orm } from "@prisma-next/sql-orm-client";
 import { schema } from "@prisma-next/sql-relational-core/schema";
 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, Pool } from "pg";
 
 //#region src/runtime/binding.ts
-function bindingError(message, details) {
-	const error = new Error(message);
-	Object.defineProperty(error, "name", {
-		value: "RuntimeError",
-		configurable: true
-	});
-	return Object.assign(error, {
-		code: "DRIVER.BINDING_INVALID",
-		category: "RUNTIME",
-		severity: "error",
-		message,
-		details
-	});
-}
 function validatePostgresUrl(url) {
 	const trimmed = url.trim();
-	if (trimmed.length === 0) throw bindingError("Postgres URL must be a non-empty string", {
-		field: "url",
-		reason: "empty"
-	});
+	if (trimmed.length === 0) throw new Error("Postgres URL must be a non-empty string");
 	let parsed;
 	try {
 		parsed = new URL(trimmed);
 	} catch {
-		throw bindingError("Postgres URL must be a valid URL", {
-			field: "url",
-			reason: "invalid-url"
-		});
+		throw new Error("Postgres URL must be a valid URL");
 	}
-	if (parsed.protocol !== "postgres:" && parsed.protocol !== "postgresql:") throw bindingError("Postgres URL must use postgres:// or postgresql://", {
-		field: "url",
-		reason: "invalid-protocol",
-		protocol: parsed.protocol
-	});
+	if (parsed.protocol !== "postgres:" && parsed.protocol !== "postgresql:") throw new Error("Postgres URL must use postgres:// or postgresql://");
 	return trimmed;
 }
 function resolvePostgresBinding(options) {
-	const providedCount = Number(options.binding !== void 0) + Number(options.url !== void 0) + Number(options.pg !== void 0);
-	if (providedCount !== 1) throw bindingError("Provide one binding input: binding, url, or pg", { providedCount });
+	if (Number(options.binding !== void 0) + Number(options.url !== void 0) + Number(options.pg !== void 0) !== 1) throw new Error("Provide one binding input: binding, url, or pg");
 	if (options.binding !== void 0) return options.binding;
 	if (options.url !== void 0) return {
 		kind: "url",
 		url: validatePostgresUrl(options.url)
 	};
 	const pgBinding = options.pg;
-	if (pgBinding === void 0) throw bindingError("Invariant violation: expected pg binding after validation", { reason: "missing-pg-binding" });
+	if (pgBinding === void 0) throw new Error("Invariant violation: expected pg binding after validation");
 	if (pgBinding instanceof Pool) return {
 		kind: "pgPool",
 		pool: pgBinding
@@ -64,7 +40,11 @@ function resolvePostgresBinding(options) {
 		kind: "pgClient",
 		client: pgBinding
 	};
-	throw bindingError("Unable to determine pg binding type from pg input; use binding with explicit kind", { reason: "unknown-pg-instance" });
+	throw new Error("Unable to determine pg binding type from pg input; use binding with explicit kind");
+}
+function resolveOptionalPostgresBinding(options) {
+	if (Number(options.binding !== void 0) + Number(options.url !== void 0) + Number(options.pg !== void 0) === 0) return;
+	return resolvePostgresBinding(options);
 }
 
 //#endregion
@@ -75,18 +55,24 @@ function hasContractJson(options) {
 function resolveContract(options) {
 	return validateContract(hasContractJson(options) ? options.contractJson : options.contract);
 }
+function toRuntimeBinding(binding, options) {
+	if (binding.kind !== "url") return binding;
+	return {
+		kind: "pgPool",
+		pool: new Pool({
+			connectionString: binding.url,
+			connectionTimeoutMillis: options.poolOptions?.connectionTimeoutMillis ?? 2e4,
+			idleTimeoutMillis: options.poolOptions?.idleTimeoutMillis ?? 3e4
+		})
+	};
+}
 function postgres(options) {
 	const contract = resolveContract(options);
-	const binding = resolvePostgresBinding(options);
+	let binding = resolveOptionalPostgresBinding(options);
 	const stack = createSqlExecutionStack({
 		target: postgresTarget,
 		adapter: postgresAdapter,
-		driver: options.cursor === void 0 ? postgresDriver : {
-			...postgresDriver,
-			create() {
-				return postgresDriver.create({ cursor: options.cursor });
-			}
-		},
+		driver: postgresDriver,
 		extensionPacks: options.extensions ?? []
 	});
 	const context = createExecutionContext({
@@ -95,39 +81,76 @@ function postgres(options) {
 	});
 	const schema$1 = schema(context);
 	const sql$1 = sql({ context });
-	let runtimePromise;
+	let runtimeInstance;
+	let runtimeDriver;
+	let driverConnected = false;
+	let connectPromise;
+	let backgroundConnectError;
+	const connectDriver = async (resolvedBinding) => {
+		if (driverConnected) return;
+		if (!runtimeDriver) throw new Error("Postgres runtime driver missing");
+		if (connectPromise) return connectPromise;
+		const runtimeBinding = toRuntimeBinding(resolvedBinding, options);
+		connectPromise = runtimeDriver.connect(runtimeBinding).then(() => {
+			driverConnected = true;
+		}).catch(async (err) => {
+			backgroundConnectError = err;
+			connectPromise = void 0;
+			if (resolvedBinding.kind === "url" && runtimeBinding.kind === "pgPool") await runtimeBinding.pool.end().catch(() => void 0);
+			throw err;
+		});
+		return connectPromise;
+	};
+	const getRuntime = () => {
+		if (backgroundConnectError !== void 0) throw backgroundConnectError;
+		if (runtimeInstance) return runtimeInstance;
+		const stackInstance = instantiateExecutionStack(stack);
+		const driverDescriptor = stack.driver;
+		if (!driverDescriptor) throw new Error("Driver descriptor missing from execution stack");
+		const driver = driverDescriptor.create({ cursor: { disabled: true } });
+		runtimeDriver = driver;
+		if (binding !== void 0) connectDriver(binding).catch(() => void 0);
+		runtimeInstance = createRuntime({
+			stackInstance,
+			context,
+			driver,
+			verify: options.verify ?? {
+				mode: "onFirstUse",
+				requireMarker: false
+			},
+			...options.plugins ? { plugins: options.plugins } : {}
+		});
+		return runtimeInstance;
+	};
+	const orm$1 = orm({
+		runtime: {
+			execute(plan) {
+				return getRuntime().execute(plan);
+			},
+			connection() {
+				return getRuntime().connection();
+			}
+		},
+		context
+	});
 	return {
 		sql: sql$1,
+		kysely: createKyselyLane(contract),
 		schema: schema$1,
+		orm: orm$1,
 		context,
 		stack,
-		async runtime() {
-			if (runtimePromise) return runtimePromise;
-			runtimePromise = (async () => {
-				const stackInstance = instantiateExecutionStack(stack);
-				const driver = stackInstance.driver;
-				if (driver === void 0) throw new Error("Relational runtime requires a driver descriptor on the execution stack");
-				try {
-					await driver.connect(binding);
-					return createRuntime({
-						stackInstance,
-						context,
-						driver,
-						verify: options.verify ?? {
-							mode: "onFirstUse",
-							requireMarker: false
-						},
-						...ifDefined("plugins", options.plugins)
-					});
-				} catch (error) {
-					await driver.close().catch(() => void 0);
-					throw error;
-				}
-			})();
-			runtimePromise.catch(() => {
-				runtimePromise = void 0;
-			});
-			return runtimePromise;
+		async connect(bindingInput) {
+			if (driverConnected || connectPromise) throw new Error("Postgres client already connected");
+			if (bindingInput !== void 0) binding = resolvePostgresBinding(bindingInput);
+			if (binding === void 0) throw new Error("Postgres binding not configured. Pass url/pg/binding to postgres(...) or call db.connect({ ... }).");
+			const runtime = getRuntime();
+			if (driverConnected) return runtime;
+			await connectDriver(binding);
+			return runtime;
+		},
+		runtime() {
+			return getRuntime();
 		}
 	};
 }

package/dist/runtime.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.mjs","names":["parsed: URL","PgPool","PgClient","schema: PostgresClient<TContract>['schema']","schemaBuilder","sql","sqlBuilder","runtimePromise: Promise<Runtime> | undefined"],"sources":["../src/runtime/binding.ts","../src/runtime/postgres.ts"],"sourcesContent":["import type { PostgresBinding } from '@prisma-next/driver-postgres/runtime';\nimport type { Client, Pool } from 'pg';\nimport { Client as PgClient, Pool as PgPool } from 'pg';\n\nexport type PostgresBindingInput =\n  | {\n      readonly binding: PostgresBinding;\n      readonly url?: never;\n      readonly pg?: never;\n    }\n  | {\n      readonly url: string;\n      readonly binding?: never;\n      readonly pg?: never;\n    }\n  | {\n      readonly pg: Pool | Client;\n      readonly binding?: never;\n      readonly url?: never;\n    };\n\ninterface PostgresBindingError extends Error {\n  readonly code: 'DRIVER.BINDING_INVALID';\n  readonly category: 'RUNTIME';\n  readonly severity: 'error';\n  readonly details?: Record<string, unknown>;\n}\n\nfunction bindingError(message: string, details?: Record<string, unknown>): PostgresBindingError {\n  const error = new Error(message) as PostgresBindingError;\n  Object.defineProperty(error, 'name', {\n    value: 'RuntimeError',\n    configurable: true,\n  });\n  return Object.assign(error, {\n    code: 'DRIVER.BINDING_INVALID' as const,\n    category: 'RUNTIME' as const,\n    severity: 'error' as const,\n    message,\n    details,\n  });\n}\n\nfunction validatePostgresUrl(url: string): string {\n  const trimmed = url.trim();\n  if (trimmed.length === 0) {\n    throw bindingError('Postgres URL must be a non-empty string', {\n      field: 'url',\n      reason: 'empty',\n    });\n  }\n\n  let parsed: URL;\n  try {\n    parsed = new URL(trimmed);\n  } catch {\n    throw bindingError('Postgres URL must be a valid URL', {\n      field: 'url',\n      reason: 'invalid-url',\n    });\n  }\n\n  if (parsed.protocol !== 'postgres:' && parsed.protocol !== 'postgresql:') {\n    throw bindingError('Postgres URL must use postgres:// or postgresql://', {\n      field: 'url',\n      reason: 'invalid-protocol',\n      protocol: parsed.protocol,\n    });\n  }\n\n  return trimmed;\n}\n\nexport function resolvePostgresBinding(options: PostgresBindingInput): PostgresBinding {\n  const providedCount =\n    Number(options.binding !== undefined) +\n    Number(options.url !== undefined) +\n    Number(options.pg !== undefined);\n\n  if (providedCount !== 1) {\n    throw bindingError('Provide one binding input: binding, url, or pg', {\n      providedCount,\n    });\n  }\n\n  if (options.binding !== undefined) {\n    return options.binding;\n  }\n\n  if (options.url !== undefined) {\n    return { kind: 'url', url: validatePostgresUrl(options.url) };\n  }\n\n  const pgBinding = options.pg;\n  if (pgBinding === undefined) {\n    throw bindingError('Invariant violation: expected pg binding after validation', {\n      reason: 'missing-pg-binding',\n    });\n  }\n\n  if (pgBinding instanceof PgPool) {\n    return { kind: 'pgPool', pool: pgBinding };\n  }\n\n  if (pgBinding instanceof PgClient) {\n    return { kind: 'pgClient', client: pgBinding };\n  }\n\n  throw bindingError(\n    'Unable to determine pg binding type from pg input; use binding with explicit kind',\n    {\n      reason: 'unknown-pg-instance',\n    },\n  );\n}\n","import postgresAdapter from '@prisma-next/adapter-postgres/runtime';\nimport { instantiateExecutionStack } from '@prisma-next/core-execution-plane/stack';\nimport type { PostgresDriverCreateOptions } from '@prisma-next/driver-postgres/runtime';\nimport postgresDriver from '@prisma-next/driver-postgres/runtime';\nimport type {\n  ExtractCodecTypes,\n  ExtractOperationTypes,\n  SqlContract,\n  SqlStorage,\n} from '@prisma-next/sql-contract/types';\nimport { validateContract } from '@prisma-next/sql-contract/validate';\nimport type { SelectBuilder } from '@prisma-next/sql-lane';\nimport { sql as sqlBuilder } from '@prisma-next/sql-lane';\nimport type { SchemaHandle } from '@prisma-next/sql-relational-core/schema';\nimport { schema as schemaBuilder } from '@prisma-next/sql-relational-core/schema';\nimport type {\n  OperationTypeSignature,\n  OperationTypes,\n} from '@prisma-next/sql-relational-core/types';\nimport type {\n  ExecutionContext,\n  Plugin,\n  Runtime,\n  RuntimeVerifyOptions,\n  SqlExecutionStackWithDriver,\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 { type PostgresBindingInput, resolvePostgresBinding } from './binding';\n\ntype NormalizeOperationTypes<T> = {\n  [TypeId in keyof T]: {\n    [Method in keyof T[TypeId]]: T[TypeId][Method] extends OperationTypeSignature\n      ? T[TypeId][Method]\n      : OperationTypeSignature;\n  };\n};\n\ntype ToSchemaOperationTypes<T> = T extends OperationTypes ? T : NormalizeOperationTypes<T>;\n\nexport type PostgresTargetId = 'postgres';\n\nexport interface PostgresClient<TContract extends SqlContract<SqlStorage>> {\n  readonly sql: SelectBuilder<\n    TContract,\n    unknown,\n    ExtractCodecTypes<TContract>,\n    ExtractOperationTypes<TContract>\n  >;\n  readonly schema: SchemaHandle<\n    TContract,\n    ExtractCodecTypes<TContract>,\n    ToSchemaOperationTypes<ExtractOperationTypes<TContract>>\n  >;\n  readonly context: ExecutionContext<TContract>;\n  readonly stack: SqlExecutionStackWithDriver<PostgresTargetId>;\n  runtime(): Promise<Runtime>;\n}\n\nexport interface PostgresOptionsBase<TContract extends SqlContract<SqlStorage>> {\n  readonly extensions?: readonly SqlRuntimeExtensionDescriptor<PostgresTargetId>[];\n  readonly plugins?: readonly Plugin<TContract>[];\n  readonly verify?: RuntimeVerifyOptions;\n  readonly cursor?: PostgresDriverCreateOptions['cursor'];\n}\n\nexport type PostgresOptionsWithContract<TContract extends SqlContract<SqlStorage>> =\n  PostgresBindingInput &\n    PostgresOptionsBase<TContract> & {\n      readonly contract: TContract;\n      readonly contractJson?: never;\n    };\n\nexport type PostgresOptionsWithContractJson<TContract extends SqlContract<SqlStorage>> =\n  PostgresBindingInput &\n    PostgresOptionsBase<TContract> & {\n      readonly contractJson: unknown;\n      readonly contract?: never;\n    };\n\nexport type PostgresOptions<TContract extends SqlContract<SqlStorage>> =\n  | PostgresOptionsWithContract<TContract>\n  | PostgresOptionsWithContractJson<TContract>;\n\nfunction hasContractJson<TContract extends SqlContract<SqlStorage>>(\n  options: PostgresOptions<TContract>,\n): options is PostgresOptionsWithContractJson<TContract> {\n  return 'contractJson' in options;\n}\n\nfunction resolveContract<TContract extends SqlContract<SqlStorage>>(\n  options: PostgresOptions<TContract>,\n): TContract {\n  const contractInput = hasContractJson(options) ? options.contractJson : options.contract;\n  return validateContract<TContract>(contractInput);\n}\n\n/**\n * Creates a lazy Postgres client from either `contractJson` or a TypeScript-authored `contract`.\n * Static query surfaces are available immediately, while `runtime()` instantiates the driver/pool on first call.\n */\nexport default function postgres<TContract extends SqlContract<SqlStorage>>(\n  options: PostgresOptionsWithContract<TContract>,\n): PostgresClient<TContract>;\nexport default function postgres<TContract extends SqlContract<SqlStorage>>(\n  options: PostgresOptionsWithContractJson<TContract>,\n): PostgresClient<TContract>;\nexport default function postgres<TContract extends SqlContract<SqlStorage>>(\n  options: PostgresOptions<TContract>,\n): PostgresClient<TContract> {\n  const contract = resolveContract(options);\n  const binding = resolvePostgresBinding(options);\n  const stack = createSqlExecutionStack({\n    target: postgresTarget,\n    adapter: postgresAdapter,\n    driver:\n      options.cursor === undefined\n        ? postgresDriver\n        : {\n            ...postgresDriver,\n            create() {\n              return postgresDriver.create({ cursor: options.cursor });\n            },\n          },\n    extensionPacks: options.extensions ?? [],\n  });\n\n  const context = createExecutionContext({\n    contract,\n    stack,\n  });\n\n  const schema: PostgresClient<TContract>['schema'] = schemaBuilder(context);\n  const sql = sqlBuilder({ context });\n\n  let runtimePromise: Promise<Runtime> | undefined;\n\n  return {\n    sql,\n    schema,\n    context,\n    stack,\n    async runtime() {\n      if (runtimePromise) {\n        return runtimePromise;\n      }\n\n      runtimePromise = (async () => {\n        const stackInstance = instantiateExecutionStack(stack);\n        const driver = stackInstance.driver;\n        if (driver === undefined) {\n          throw new Error('Relational runtime requires a driver descriptor on the execution stack');\n        }\n\n        try {\n          // `binding` is normalized by resolvePostgresBinding(), so this call site remains\n          // type-safe in practice while SqlRuntimeDriverInstance currently uses SqlDriver<unknown>.\n          await driver.connect(binding);\n\n          return createRuntime({\n            stackInstance,\n            context,\n            driver,\n            verify: options.verify ?? { mode: 'onFirstUse', requireMarker: false },\n            ...ifDefined('plugins', options.plugins),\n          });\n        } catch (error) {\n          await driver.close().catch(() => undefined);\n          throw error;\n        }\n      })();\n\n      runtimePromise.catch(() => {\n        runtimePromise = undefined;\n      });\n\n      return runtimePromise;\n    },\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"runtime.mjs","names":["parsed: URL","PgPool","PgClient","schema","schemaBuilder","sql","sqlBuilder","runtimeInstance: Runtime | undefined","runtimeDriver: { connect(binding: unknown): Promise<void> } | undefined","connectPromise: Promise<void> | undefined","backgroundConnectError: unknown","orm: OrmClient<TContract>","ormBuilder"],"sources":["../src/runtime/binding.ts","../src/runtime/postgres.ts"],"sourcesContent":["import type { Client, Pool } from 'pg';\nimport { Client as PgClient, Pool as PgPool } from 'pg';\n\nexport type PostgresBinding =\n  | { readonly kind: 'url'; readonly url: string }\n  | { readonly kind: 'pgPool'; readonly pool: Pool }\n  | { readonly kind: 'pgClient'; readonly client: Client };\n\nexport type PostgresBindingInput =\n  | {\n      readonly binding: PostgresBinding;\n      readonly url?: never;\n      readonly pg?: never;\n    }\n  | {\n      readonly url: string;\n      readonly binding?: never;\n      readonly pg?: never;\n    }\n  | {\n      readonly pg: Pool | Client;\n      readonly binding?: never;\n      readonly url?: never;\n    };\n\ntype PostgresBindingFields = {\n  readonly binding?: PostgresBinding;\n  readonly url?: string;\n  readonly pg?: Pool | Client;\n};\n\nfunction validatePostgresUrl(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\n  let parsed: URL;\n  try {\n    parsed = new URL(trimmed);\n  } catch {\n    throw new Error('Postgres URL must be a valid URL');\n  }\n\n  if (parsed.protocol !== 'postgres:' && parsed.protocol !== 'postgresql:') {\n    throw new Error('Postgres URL must use postgres:// or postgresql://');\n  }\n\n  return trimmed;\n}\n\nexport function resolvePostgresBinding(options: PostgresBindingInput): PostgresBinding {\n  const providedCount =\n    Number(options.binding !== undefined) +\n    Number(options.url !== undefined) +\n    Number(options.pg !== undefined);\n\n  if (providedCount !== 1) {\n    throw new Error('Provide one binding input: binding, url, or pg');\n  }\n\n  if (options.binding !== undefined) {\n    return options.binding;\n  }\n\n  if (options.url !== undefined) {\n    return { kind: 'url', url: validatePostgresUrl(options.url) };\n  }\n\n  const pgBinding = options.pg;\n  if (pgBinding === undefined) {\n    throw new Error('Invariant violation: expected pg binding after validation');\n  }\n\n  if (pgBinding instanceof PgPool) {\n    return { kind: 'pgPool', pool: pgBinding };\n  }\n\n  if (pgBinding instanceof PgClient) {\n    return { kind: 'pgClient', client: pgBinding };\n  }\n\n  throw new Error(\n    'Unable to determine pg binding type from pg input; use binding with explicit kind',\n  );\n}\n\nexport function resolveOptionalPostgresBinding(\n  options: PostgresBindingFields,\n): PostgresBinding | undefined {\n  const providedCount =\n    Number(options.binding !== undefined) +\n    Number(options.url !== undefined) +\n    Number(options.pg !== undefined);\n\n  if (providedCount === 0) {\n    return undefined;\n  }\n\n  return resolvePostgresBinding(options as PostgresBindingInput);\n}\n","import postgresAdapter from '@prisma-next/adapter-postgres/runtime';\nimport { instantiateExecutionStack } from '@prisma-next/core-execution-plane/stack';\nimport postgresDriver from '@prisma-next/driver-postgres/runtime';\nimport type {\n  ExtractTypeMapsFromContract,\n  ResolveCodecTypes,\n  ResolveOperationTypes,\n  SqlContract,\n  SqlStorage,\n} from '@prisma-next/sql-contract/types';\nimport { validateContract } from '@prisma-next/sql-contract/validate';\nimport { createKyselyLane, type KyselyQueryLane } from '@prisma-next/sql-kysely-lane';\nimport type { SelectBuilder } from '@prisma-next/sql-lane';\nimport { sql as sqlBuilder } from '@prisma-next/sql-lane';\nimport { orm as ormBuilder } from '@prisma-next/sql-orm-client';\nimport type { SchemaHandle } from '@prisma-next/sql-relational-core/schema';\nimport { schema as schemaBuilder } from '@prisma-next/sql-relational-core/schema';\nimport type {\n  OperationTypeSignature,\n  OperationTypes,\n} from '@prisma-next/sql-relational-core/types';\nimport type {\n  ExecutionContext,\n  Plugin,\n  Runtime,\n  RuntimeVerifyOptions,\n  SqlExecutionStackWithDriver,\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 { type Client, Pool } from 'pg';\nimport {\n  type PostgresBinding,\n  type PostgresBindingInput,\n  resolveOptionalPostgresBinding,\n  resolvePostgresBinding,\n} from './binding';\n\ntype NormalizeOperationTypes<T> = {\n  [TypeId in keyof T]: {\n    [Method in keyof T[TypeId]]: T[TypeId][Method] extends OperationTypeSignature\n      ? T[TypeId][Method]\n      : OperationTypeSignature;\n  };\n};\n\ntype ToSchemaOperationTypes<T> = T extends OperationTypes ? T : NormalizeOperationTypes<T>;\n\nexport type PostgresTargetId = 'postgres';\ntype OrmClient<TContract extends SqlContract<SqlStorage>> = ReturnType<\n  typeof ormBuilder<TContract>\n>;\n\nexport interface PostgresClient<\n  TContract extends SqlContract<SqlStorage>,\n  TTypeMaps = ExtractTypeMapsFromContract<TContract>,\n> {\n  readonly sql: SelectBuilder<\n    TContract,\n    unknown,\n    ResolveCodecTypes<TContract, TTypeMaps>,\n    ResolveOperationTypes<TContract, TTypeMaps>\n  >;\n  readonly kysely: KyselyQueryLane<TContract>;\n  readonly schema: SchemaHandle<\n    TContract,\n    ResolveCodecTypes<TContract, TTypeMaps>,\n    ToSchemaOperationTypes<ResolveOperationTypes<TContract, TTypeMaps>>\n  >;\n  readonly orm: OrmClient<TContract>;\n  readonly context: ExecutionContext<TContract>;\n  readonly stack: SqlExecutionStackWithDriver<PostgresTargetId>;\n  connect(bindingInput?: PostgresBindingInput): Promise<Runtime>;\n  runtime(): Runtime;\n}\n\nexport interface PostgresOptionsBase<TContract extends SqlContract<SqlStorage>> {\n  readonly extensions?: readonly SqlRuntimeExtensionDescriptor<PostgresTargetId>[];\n  readonly plugins?: readonly Plugin<TContract>[];\n  readonly verify?: RuntimeVerifyOptions;\n  readonly poolOptions?: {\n    readonly connectionTimeoutMillis?: number;\n    readonly idleTimeoutMillis?: number;\n  };\n}\n\nexport interface PostgresBindingOptions {\n  readonly binding?: PostgresBinding;\n  readonly url?: string;\n  readonly pg?: Pool | Client;\n}\n\nexport type PostgresOptionsWithContract<TContract extends SqlContract<SqlStorage>> =\n  PostgresBindingOptions &\n    PostgresOptionsBase<TContract> & {\n      readonly contract: TContract;\n      readonly contractJson?: never;\n    };\n\nexport type PostgresOptionsWithContractJson<TContract extends SqlContract<SqlStorage>> =\n  PostgresBindingOptions &\n    PostgresOptionsBase<TContract> & {\n      readonly contractJson: unknown;\n      readonly contract?: never;\n    };\n\nexport type PostgresOptions<TContract extends SqlContract<SqlStorage>> =\n  | PostgresOptionsWithContract<TContract>\n  | PostgresOptionsWithContractJson<TContract>;\n\nfunction hasContractJson<TContract extends SqlContract<SqlStorage>>(\n  options: PostgresOptions<TContract>,\n): options is PostgresOptionsWithContractJson<TContract> {\n  return 'contractJson' in options;\n}\n\nfunction resolveContract<TContract extends SqlContract<SqlStorage>>(\n  options: PostgresOptions<TContract>,\n): TContract {\n  const contractInput = hasContractJson(options) ? options.contractJson : options.contract;\n  return validateContract<TContract>(contractInput);\n}\n\nfunction toRuntimeBinding<TContract extends SqlContract<SqlStorage>>(\n  binding: PostgresBinding,\n  options: PostgresOptions<TContract>,\n) {\n  if (binding.kind !== 'url') {\n    return binding;\n  }\n\n  return {\n    kind: 'pgPool',\n    pool: new Pool({\n      connectionString: binding.url,\n      connectionTimeoutMillis: options.poolOptions?.connectionTimeoutMillis ?? 20_000,\n      idleTimeoutMillis: options.poolOptions?.idleTimeoutMillis ?? 30_000,\n    }),\n  } as const;\n}\n\n/**\n * Creates a lazy Postgres client from either `contractJson` or a TypeScript-authored `contract`.\n * Static query surfaces are available immediately, while `runtime()` instantiates the driver/pool on first call.\n *\n * - No-emit: infers TypeMaps from ContractWithTypeMaps. Example: postgres({ contract })\n * - Emitted: pass TypeMaps explicitly. Example: postgres<Contract, TypeMaps>({ contractJson, url })\n */\nexport default function postgres<\n  TContract extends SqlContract<SqlStorage>,\n  TTypeMaps = ExtractTypeMapsFromContract<TContract>,\n>(options: PostgresOptionsWithContract<TContract>): PostgresClient<TContract, TTypeMaps>;\nexport default function postgres<\n  TContract extends SqlContract<SqlStorage>,\n  TTypeMaps = ExtractTypeMapsFromContract<TContract>,\n>(options: PostgresOptionsWithContractJson<TContract>): PostgresClient<TContract, TTypeMaps>;\nexport default function postgres<\n  TContract extends SqlContract<SqlStorage>,\n  TTypeMaps = ExtractTypeMapsFromContract<TContract>,\n>(options: PostgresOptions<TContract>): PostgresClient<TContract, TTypeMaps> {\n  const contract = resolveContract(options);\n  let binding = resolveOptionalPostgresBinding(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 schema = schemaBuilder<TContract, TTypeMaps>(context);\n  const sql = sqlBuilder<TContract, TTypeMaps>({ context });\n  let runtimeInstance: Runtime | undefined;\n  let runtimeDriver: { connect(binding: unknown): Promise<void> } | undefined;\n  let driverConnected = false;\n  let connectPromise: Promise<void> | undefined;\n  let backgroundConnectError: unknown;\n  const connectDriver = async (resolvedBinding: PostgresBinding): Promise<void> => {\n    if (driverConnected) return;\n    if (!runtimeDriver) throw new Error('Postgres runtime driver missing');\n    if (connectPromise) return connectPromise;\n    const runtimeBinding = toRuntimeBinding(resolvedBinding, options);\n    connectPromise = runtimeDriver\n      .connect(runtimeBinding)\n      .then(() => {\n        driverConnected = true;\n      })\n      .catch(async (err) => {\n        backgroundConnectError = err;\n        connectPromise = undefined;\n        if (resolvedBinding.kind === 'url' && runtimeBinding.kind === 'pgPool') {\n          await runtimeBinding.pool.end().catch(() => undefined);\n        }\n        throw err;\n      });\n    return connectPromise;\n  };\n  const getRuntime = (): Runtime => {\n    if (backgroundConnectError !== undefined) {\n      throw backgroundConnectError;\n    }\n\n    if (runtimeInstance) {\n      return runtimeInstance;\n    }\n\n    const stackInstance = instantiateExecutionStack(stack);\n    const driverDescriptor = stack.driver;\n    if (!driverDescriptor) {\n      throw new Error('Driver descriptor missing from execution stack');\n    }\n\n    const driver = driverDescriptor.create({\n      cursor: { disabled: true },\n    });\n    runtimeDriver = driver;\n    if (binding !== undefined) {\n      void connectDriver(binding).catch(() => undefined);\n    }\n\n    runtimeInstance = createRuntime({\n      stackInstance,\n      context,\n      driver,\n      verify: options.verify ?? { mode: 'onFirstUse', requireMarker: false },\n      ...(options.plugins ? { plugins: options.plugins } : {}),\n    });\n\n    return runtimeInstance;\n  };\n  const orm: OrmClient<TContract> = ormBuilder({\n    runtime: {\n      execute(plan) {\n        return getRuntime().execute(plan);\n      },\n      connection() {\n        return getRuntime().connection();\n      },\n    },\n    context,\n  });\n\n  return {\n    sql,\n    kysely: createKyselyLane(contract),\n    schema: schema as PostgresClient<TContract, TTypeMaps>['schema'],\n    orm,\n    context,\n    stack,\n    async connect(bindingInput) {\n      if (driverConnected || connectPromise) {\n        throw new Error('Postgres client already connected');\n      }\n\n      if (bindingInput !== undefined) {\n        binding = resolvePostgresBinding(bindingInput);\n      }\n\n      if (binding === undefined) {\n        throw new Error(\n          'Postgres binding not configured. Pass url/pg/binding to postgres(...) or call db.connect({ ... }).',\n        );\n      }\n\n      const runtime = getRuntime();\n      if (driverConnected) {\n        return runtime;\n      }\n\n      await connectDriver(binding);\n      return runtime;\n    },\n    runtime() {\n      return getRuntime();\n    },\n  };\n}\n"],"mappings":"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"}

package/package.json

@@ -1,20 +1,21 @@
 {
   "name": "@prisma-next/postgres",
-  "version": "0.0.1",
+  "version": "0.3.0-dev.122",
   "type": "module",
   "sideEffects": false,
   "description": "One-liner lazy Postgres client composition for Prisma Next",
   "dependencies": {
     "pg": "8.16.3",
-    "@prisma-next/adapter-postgres": "0.0.1",
-    "@prisma-next/core-execution-plane": "0.0.1",
-    "@prisma-next/sql-contract": "0.0.1",
-    "@prisma-next/driver-postgres": "0.0.1",
-    "@prisma-next/sql-relational-core": "0.0.1",
-    "@prisma-next/target-postgres": "0.0.1",
-    "@prisma-next/sql-runtime": "0.0.1",
-    "@prisma-next/sql-lane": "0.0.1",
-    "@prisma-next/utils": "0.0.1"
+    "@prisma-next/adapter-postgres": "0.3.0-dev.122",
+    "@prisma-next/core-execution-plane": "0.3.0-dev.122",
+    "@prisma-next/sql-contract": "0.3.0-dev.122",
+    "@prisma-next/driver-postgres": "0.3.0-dev.122",
+    "@prisma-next/sql-kysely-lane": "0.3.0-dev.122",
+    "@prisma-next/sql-orm-client": "0.3.0-dev.122",
+    "@prisma-next/sql-lane": "0.3.0-dev.122",
+    "@prisma-next/sql-relational-core": "0.3.0-dev.122",
+    "@prisma-next/sql-runtime": "0.3.0-dev.122",
+    "@prisma-next/target-postgres": "0.3.0-dev.122"
   },
   "devDependencies": {
     "@types/pg": "8.16.0",
@@ -22,35 +23,28 @@
     "typescript": "5.9.3",
     "vitest": "4.0.17",
     "@prisma-next/tsconfig": "0.0.0",
-    "@prisma-next/test-utils": "0.0.1",
-    "@prisma-next/tsdown": "0.0.0"
+    "@prisma-next/tsdown": "0.0.0",
+    "@prisma-next/test-utils": "0.0.1"
   },
   "files": [
     "dist",
     "src"
   ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/prisma/prisma-next.git",
+    "directory": "packages/3-extensions/postgres"
+  },
   "engines": {
     "node": ">=20"
   },
   "exports": {
-    ".": {
-      "types": "./dist/runtime.d.mts",
-      "import": "./dist/runtime.mjs"
-    },
-    "./runtime": {
-      "types": "./dist/runtime.d.mts",
-      "import": "./dist/runtime.mjs"
-    },
+    ".": "./dist/runtime.mjs",
     "./package.json": "./package.json"
   },
   "main": "./dist/runtime.mjs",
   "module": "./dist/runtime.mjs",
   "types": "./dist/runtime.d.mts",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/prisma/prisma-next.git",
-    "directory": "packages/3-targets/8-clients/postgres"
-  },
   "scripts": {
     "build": "tsdown",
     "test": "vitest run",

package/src/exports/runtime.ts

@@ -1,4 +1,5 @@
-export type { PostgresBinding } from '@prisma-next/driver-postgres/runtime';
+export type { KyselyQueryLane } from '@prisma-next/sql-kysely-lane';
+export type { PostgresBinding } from '../runtime/binding';
 export type {
   PostgresClient,
   PostgresOptions,

package/src/runtime/binding.ts

@@ -1,7 +1,11 @@
-import type { PostgresBinding } from '@prisma-next/driver-postgres/runtime';
 import type { Client, Pool } from 'pg';
 import { Client as PgClient, Pool as PgPool } from 'pg';
 
+export type PostgresBinding =
+  | { readonly kind: 'url'; readonly url: string }
+  | { readonly kind: 'pgPool'; readonly pool: Pool }
+  | { readonly kind: 'pgClient'; readonly client: Client };
+
 export type PostgresBindingInput =
   | {
       readonly binding: PostgresBinding;
@@ -19,53 +23,27 @@ export type PostgresBindingInput =
       readonly url?: never;
     };
 
-interface PostgresBindingError extends Error {
-  readonly code: 'DRIVER.BINDING_INVALID';
-  readonly category: 'RUNTIME';
-  readonly severity: 'error';
-  readonly details?: Record<string, unknown>;
-}
-
-function bindingError(message: string, details?: Record<string, unknown>): PostgresBindingError {
-  const error = new Error(message) as PostgresBindingError;
-  Object.defineProperty(error, 'name', {
-    value: 'RuntimeError',
-    configurable: true,
-  });
-  return Object.assign(error, {
-    code: 'DRIVER.BINDING_INVALID' as const,
-    category: 'RUNTIME' as const,
-    severity: 'error' as const,
-    message,
-    details,
-  });
-}
+type PostgresBindingFields = {
+  readonly binding?: PostgresBinding;
+  readonly url?: string;
+  readonly pg?: Pool | Client;
+};
 
 function validatePostgresUrl(url: string): string {
   const trimmed = url.trim();
   if (trimmed.length === 0) {
-    throw bindingError('Postgres URL must be a non-empty string', {
-      field: 'url',
-      reason: 'empty',
-    });
+    throw new Error('Postgres URL must be a non-empty string');
   }
 
   let parsed: URL;
   try {
     parsed = new URL(trimmed);
   } catch {
-    throw bindingError('Postgres URL must be a valid URL', {
-      field: 'url',
-      reason: 'invalid-url',
-    });
+    throw new Error('Postgres URL must be a valid URL');
   }
 
   if (parsed.protocol !== 'postgres:' && parsed.protocol !== 'postgresql:') {
-    throw bindingError('Postgres URL must use postgres:// or postgresql://', {
-      field: 'url',
-      reason: 'invalid-protocol',
-      protocol: parsed.protocol,
-    });
+    throw new Error('Postgres URL must use postgres:// or postgresql://');
   }
 
   return trimmed;
@@ -78,9 +56,7 @@ export function resolvePostgresBinding(options: PostgresBindingInput): PostgresB
     Number(options.pg !== undefined);
 
   if (providedCount !== 1) {
-    throw bindingError('Provide one binding input: binding, url, or pg', {
-      providedCount,
-    });
+    throw new Error('Provide one binding input: binding, url, or pg');
   }
 
   if (options.binding !== undefined) {
@@ -93,9 +69,7 @@ export function resolvePostgresBinding(options: PostgresBindingInput): PostgresB
 
   const pgBinding = options.pg;
   if (pgBinding === undefined) {
-    throw bindingError('Invariant violation: expected pg binding after validation', {
-      reason: 'missing-pg-binding',
-    });
+    throw new Error('Invariant violation: expected pg binding after validation');
   }
 
   if (pgBinding instanceof PgPool) {
@@ -106,10 +80,22 @@ export function resolvePostgresBinding(options: PostgresBindingInput): PostgresB
     return { kind: 'pgClient', client: pgBinding };
   }
 
-  throw bindingError(
+  throw new Error(
     'Unable to determine pg binding type from pg input; use binding with explicit kind',
-    {
-      reason: 'unknown-pg-instance',
-    },
   );
 }
+
+export function resolveOptionalPostgresBinding(
+  options: PostgresBindingFields,
+): PostgresBinding | undefined {
+  const providedCount =
+    Number(options.binding !== undefined) +
+    Number(options.url !== undefined) +
+    Number(options.pg !== undefined);
+
+  if (providedCount === 0) {
+    return undefined;
+  }
+
+  return resolvePostgresBinding(options as PostgresBindingInput);
+}

package/src/runtime/postgres.ts

@@ -1,16 +1,18 @@
 import postgresAdapter from '@prisma-next/adapter-postgres/runtime';
 import { instantiateExecutionStack } from '@prisma-next/core-execution-plane/stack';
-import type { PostgresDriverCreateOptions } from '@prisma-next/driver-postgres/runtime';
 import postgresDriver from '@prisma-next/driver-postgres/runtime';
 import type {
-  ExtractCodecTypes,
-  ExtractOperationTypes,
+  ExtractTypeMapsFromContract,
+  ResolveCodecTypes,
+  ResolveOperationTypes,
   SqlContract,
   SqlStorage,
 } from '@prisma-next/sql-contract/types';
 import { validateContract } from '@prisma-next/sql-contract/validate';
+import { createKyselyLane, type KyselyQueryLane } from '@prisma-next/sql-kysely-lane';
 import type { SelectBuilder } from '@prisma-next/sql-lane';
 import { sql as sqlBuilder } from '@prisma-next/sql-lane';
+import { orm as ormBuilder } from '@prisma-next/sql-orm-client';
 import type { SchemaHandle } from '@prisma-next/sql-relational-core/schema';
 import { schema as schemaBuilder } from '@prisma-next/sql-relational-core/schema';
 import type {
@@ -31,8 +33,13 @@ import {
   createSqlExecutionStack,
 } from '@prisma-next/sql-runtime';
 import postgresTarget from '@prisma-next/target-postgres/runtime';
-import { ifDefined } from '@prisma-next/utils/defined';
-import { type PostgresBindingInput, resolvePostgresBinding } from './binding';
+import { type Client, Pool } from 'pg';
+import {
+  type PostgresBinding,
+  type PostgresBindingInput,
+  resolveOptionalPostgresBinding,
+  resolvePostgresBinding,
+} from './binding';
 
 type NormalizeOperationTypes<T> = {
   [TypeId in keyof T]: {
@@ -45,40 +52,58 @@ type NormalizeOperationTypes<T> = {
 type ToSchemaOperationTypes<T> = T extends OperationTypes ? T : NormalizeOperationTypes<T>;
 
 export type PostgresTargetId = 'postgres';
+type OrmClient<TContract extends SqlContract<SqlStorage>> = ReturnType<
+  typeof ormBuilder<TContract>
+>;
 
-export interface PostgresClient<TContract extends SqlContract<SqlStorage>> {
+export interface PostgresClient<
+  TContract extends SqlContract<SqlStorage>,
+  TTypeMaps = ExtractTypeMapsFromContract<TContract>,
+> {
   readonly sql: SelectBuilder<
     TContract,
     unknown,
-    ExtractCodecTypes<TContract>,
-    ExtractOperationTypes<TContract>
+    ResolveCodecTypes<TContract, TTypeMaps>,
+    ResolveOperationTypes<TContract, TTypeMaps>
   >;
+  readonly kysely: KyselyQueryLane<TContract>;
   readonly schema: SchemaHandle<
     TContract,
-    ExtractCodecTypes<TContract>,
-    ToSchemaOperationTypes<ExtractOperationTypes<TContract>>
+    ResolveCodecTypes<TContract, TTypeMaps>,
+    ToSchemaOperationTypes<ResolveOperationTypes<TContract, TTypeMaps>>
   >;
+  readonly orm: OrmClient<TContract>;
   readonly context: ExecutionContext<TContract>;
   readonly stack: SqlExecutionStackWithDriver<PostgresTargetId>;
-  runtime(): Promise<Runtime>;
+  connect(bindingInput?: PostgresBindingInput): Promise<Runtime>;
+  runtime(): Runtime;
 }
 
 export interface PostgresOptionsBase<TContract extends SqlContract<SqlStorage>> {
   readonly extensions?: readonly SqlRuntimeExtensionDescriptor<PostgresTargetId>[];
   readonly plugins?: readonly Plugin<TContract>[];
   readonly verify?: RuntimeVerifyOptions;
-  readonly cursor?: PostgresDriverCreateOptions['cursor'];
+  readonly poolOptions?: {
+    readonly connectionTimeoutMillis?: number;
+    readonly idleTimeoutMillis?: number;
+  };
+}
+
+export interface PostgresBindingOptions {
+  readonly binding?: PostgresBinding;
+  readonly url?: string;
+  readonly pg?: Pool | Client;
 }
 
 export type PostgresOptionsWithContract<TContract extends SqlContract<SqlStorage>> =
-  PostgresBindingInput &
+  PostgresBindingOptions &
     PostgresOptionsBase<TContract> & {
       readonly contract: TContract;
       readonly contractJson?: never;
     };
 
 export type PostgresOptionsWithContractJson<TContract extends SqlContract<SqlStorage>> =
-  PostgresBindingInput &
+  PostgresBindingOptions &
     PostgresOptionsBase<TContract> & {
       readonly contractJson: unknown;
       readonly contract?: never;
@@ -101,33 +126,49 @@ function resolveContract<TContract extends SqlContract<SqlStorage>>(
   return validateContract<TContract>(contractInput);
 }
 
+function toRuntimeBinding<TContract extends SqlContract<SqlStorage>>(
+  binding: PostgresBinding,
+  options: PostgresOptions<TContract>,
+) {
+  if (binding.kind !== 'url') {
+    return binding;
+  }
+
+  return {
+    kind: 'pgPool',
+    pool: new Pool({
+      connectionString: binding.url,
+      connectionTimeoutMillis: options.poolOptions?.connectionTimeoutMillis ?? 20_000,
+      idleTimeoutMillis: options.poolOptions?.idleTimeoutMillis ?? 30_000,
+    }),
+  } as const;
+}
+
 /**
  * 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: infers TypeMaps from ContractWithTypeMaps. Example: postgres({ contract })
+ * - Emitted: pass TypeMaps explicitly. Example: postgres<Contract, TypeMaps>({ contractJson, url })
  */
-export default function postgres<TContract extends SqlContract<SqlStorage>>(
-  options: PostgresOptionsWithContract<TContract>,
-): PostgresClient<TContract>;
-export default function postgres<TContract extends SqlContract<SqlStorage>>(
-  options: PostgresOptionsWithContractJson<TContract>,
-): PostgresClient<TContract>;
-export default function postgres<TContract extends SqlContract<SqlStorage>>(
-  options: PostgresOptions<TContract>,
-): PostgresClient<TContract> {
+export default function postgres<
+  TContract extends SqlContract<SqlStorage>,
+  TTypeMaps = ExtractTypeMapsFromContract<TContract>,
+>(options: PostgresOptionsWithContract<TContract>): PostgresClient<TContract, TTypeMaps>;
+export default function postgres<
+  TContract extends SqlContract<SqlStorage>,
+  TTypeMaps = ExtractTypeMapsFromContract<TContract>,
+>(options: PostgresOptionsWithContractJson<TContract>): PostgresClient<TContract, TTypeMaps>;
+export default function postgres<
+  TContract extends SqlContract<SqlStorage>,
+  TTypeMaps = ExtractTypeMapsFromContract<TContract>,
+>(options: PostgresOptions<TContract>): PostgresClient<TContract, TTypeMaps> {
   const contract = resolveContract(options);
-  const binding = resolvePostgresBinding(options);
+  let binding = resolveOptionalPostgresBinding(options);
   const stack = createSqlExecutionStack({
     target: postgresTarget,
     adapter: postgresAdapter,
-    driver:
-      options.cursor === undefined
-        ? postgresDriver
-        : {
-            ...postgresDriver,
-            create() {
-              return postgresDriver.create({ cursor: options.cursor });
-            },
-          },
+    driver: postgresDriver,
     extensionPacks: options.extensions ?? [],
   });
 
@@ -136,51 +177,110 @@ export default function postgres<TContract extends SqlContract<SqlStorage>>(
     stack,
   });
 
-  const schema: PostgresClient<TContract>['schema'] = schemaBuilder(context);
-  const sql = sqlBuilder({ context });
+  const schema = schemaBuilder<TContract, TTypeMaps>(context);
+  const sql = sqlBuilder<TContract, TTypeMaps>({ context });
+  let runtimeInstance: Runtime | undefined;
+  let runtimeDriver: { connect(binding: unknown): Promise<void> } | undefined;
+  let driverConnected = false;
+  let connectPromise: Promise<void> | undefined;
+  let backgroundConnectError: unknown;
+  const connectDriver = async (resolvedBinding: PostgresBinding): Promise<void> => {
+    if (driverConnected) return;
+    if (!runtimeDriver) throw new Error('Postgres runtime driver missing');
+    if (connectPromise) return connectPromise;
+    const runtimeBinding = toRuntimeBinding(resolvedBinding, options);
+    connectPromise = runtimeDriver
+      .connect(runtimeBinding)
+      .then(() => {
+        driverConnected = true;
+      })
+      .catch(async (err) => {
+        backgroundConnectError = err;
+        connectPromise = undefined;
+        if (resolvedBinding.kind === 'url' && runtimeBinding.kind === 'pgPool') {
+          await runtimeBinding.pool.end().catch(() => undefined);
+        }
+        throw err;
+      });
+    return connectPromise;
+  };
+  const getRuntime = (): Runtime => {
+    if (backgroundConnectError !== undefined) {
+      throw backgroundConnectError;
+    }
+
+    if (runtimeInstance) {
+      return runtimeInstance;
+    }
 
-  let runtimePromise: Promise<Runtime> | undefined;
+    const stackInstance = instantiateExecutionStack(stack);
+    const driverDescriptor = stack.driver;
+    if (!driverDescriptor) {
+      throw new Error('Driver descriptor missing from execution stack');
+    }
+
+    const driver = driverDescriptor.create({
+      cursor: { disabled: true },
+    });
+    runtimeDriver = driver;
+    if (binding !== undefined) {
+      void connectDriver(binding).catch(() => undefined);
+    }
+
+    runtimeInstance = createRuntime({
+      stackInstance,
+      context,
+      driver,
+      verify: options.verify ?? { mode: 'onFirstUse', requireMarker: false },
+      ...(options.plugins ? { plugins: options.plugins } : {}),
+    });
+
+    return runtimeInstance;
+  };
+  const orm: OrmClient<TContract> = ormBuilder({
+    runtime: {
+      execute(plan) {
+        return getRuntime().execute(plan);
+      },
+      connection() {
+        return getRuntime().connection();
+      },
+    },
+    context,
+  });
 
   return {
     sql,
-    schema,
+    kysely: createKyselyLane(contract),
+    schema: schema as PostgresClient<TContract, TTypeMaps>['schema'],
+    orm,
     context,
     stack,
-    async runtime() {
-      if (runtimePromise) {
-        return runtimePromise;
+    async connect(bindingInput) {
+      if (driverConnected || connectPromise) {
+        throw new Error('Postgres client already connected');
       }
 
-      runtimePromise = (async () => {
-        const stackInstance = instantiateExecutionStack(stack);
-        const driver = stackInstance.driver;
-        if (driver === undefined) {
-          throw new Error('Relational runtime requires a driver descriptor on the execution stack');
-        }
+      if (bindingInput !== undefined) {
+        binding = resolvePostgresBinding(bindingInput);
+      }
 
-        try {
-          // `binding` is normalized by resolvePostgresBinding(), so this call site remains
-          // type-safe in practice while SqlRuntimeDriverInstance currently uses SqlDriver<unknown>.
-          await driver.connect(binding);
-
-          return createRuntime({
-            stackInstance,
-            context,
-            driver,
-            verify: options.verify ?? { mode: 'onFirstUse', requireMarker: false },
-            ...ifDefined('plugins', options.plugins),
-          });
-        } catch (error) {
-          await driver.close().catch(() => undefined);
-          throw error;
-        }
-      })();
+      if (binding === undefined) {
+        throw new Error(
+          'Postgres binding not configured. Pass url/pg/binding to postgres(...) or call db.connect({ ... }).',
+        );
+      }
 
-      runtimePromise.catch(() => {
-        runtimePromise = undefined;
-      });
+      const runtime = getRuntime();
+      if (driverConnected) {
+        return runtime;
+      }
 
-      return runtimePromise;
+      await connectDriver(binding);
+      return runtime;
+    },
+    runtime() {
+      return getRuntime();
     },
   };
 }