okmodel 0.6.0 → 0.7.0

package/dist/dialects/pg/ops/window.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Window helpers for `select` (spec §10, §13 tool 12).
+ *
+ * The brand is a symbol. JSON cannot create one, so a request cannot add a
+ * window. A plain object in `select` stays OKM1120. The SQL loads on the first
+ * `find` or `one` whose `select` contains one.
+ */
+declare const brand: unique symbol;
+/** `asc` is nulls last and `desc` is nulls first unless `nulls` is set. */
+type SortDir = "asc" | "desc" | {
+    readonly dir: "asc" | "desc";
+    readonly nulls?: "first" | "last";
+};
+/** Columns the window orders by. Names are checked when the call runs. */
+export type WindowOrder = {
+    readonly [field: string]: SortDir | undefined;
+};
+/** What a window helper stores. The planner reads this. */
+export type WindowCall = {
+    readonly label: "rowNumber" | "rank" | "denseRank" | "runningTotal";
+    readonly fn: "row_number" | "rank" | "dense_rank" | "sum";
+    readonly column: string | undefined;
+    readonly partitionBy: readonly string[] | undefined;
+    readonly orderBy: unknown;
+    readonly as: string;
+};
+/**
+ * A window helper.
+ *
+ * `A` is the result key. `V` is `number` for a rank, or the source column for
+ * a running total.
+ */
+export type Window<A extends string, V extends string | number> = {
+    readonly [brand]: V;
+    readonly as: A;
+};
+/**
+ * Options every window helper takes.
+ *
+ * `partitionBy` is the group. Omit it to number the whole result. `orderBy`
+ * is the order inside that group. The primary key breaks ties. `as` is the
+ * result key. `__proto__`, `constructor`, `toString`, and `hasOwnProperty`
+ * are refused when the call runs.
+ */
+type WindowOptions<A extends string> = {
+    readonly partitionBy?: readonly string[];
+    readonly orderBy: WindowOrder;
+    readonly as: A;
+};
+/**
+ * Reports whether `value` is a window helper.
+ *
+ * @param value - One `select` entry
+ * @returns `true` when a helper in this module created it
+ */
+export declare function isWindow(value: unknown): value is WindowCall;
+/**
+ * Row number inside a group, starting at 1.
+ *
+ * Ties get distinct numbers. The primary key breaks them.
+ *
+ * @typeParam A - Result key
+ * @param options - Group, order, and result key
+ * @returns A tagged window. Pass it in `select` on `find` or `one`
+ */
+export declare function rowNumber<const A extends string>(options: WindowOptions<A>): Window<A, number>;
+/**
+ * Rank inside a group, with gaps after a tie.
+ *
+ * Two rows with the same order share a rank. The next rank skips. The primary
+ * key breaks the order when you need a stable row, and it does not split the
+ * rank.
+ *
+ * @typeParam A - Result key
+ * @param options - Group, order, and result key
+ * @returns A tagged window. Pass it in `select` on `find` or `one`
+ */
+export declare function rank<const A extends string>(options: WindowOptions<A>): Window<A, number>;
+/**
+ * Rank inside a group, without gaps after a tie.
+ *
+ * Two rows with the same order share a rank. The next rank is the next number.
+ *
+ * @typeParam A - Result key
+ * @param options - Group, order, and result key
+ * @returns A tagged window. Pass it in `select` on `find` or `one`
+ */
+export declare function denseRank<const A extends string>(options: WindowOptions<A>): Window<A, number>;
+/**
+ * Running total of a number column.
+ *
+ * The total follows `orderBy` inside the group. A null number does not add.
+ * The result uses the column's value type: a number, or the exact decimal
+ * string of a `numeric` column.
+ *
+ * @typeParam C - Column
+ * @typeParam A - Result key
+ * @param column - Field to total
+ * @param options - Group, order, and result key
+ * @returns A tagged window. Pass it in `select` on `find` or `one`
+ */
+export declare function runningTotal<const C extends string, const A extends string>(column: C, options: WindowOptions<A>): Window<A, C>;
+export {};

package/dist/dialects/pg/preset.d.ts

@@ -44,7 +44,7 @@ export type Preset<Row> = (q: PresetQuery<Row>, ...args: never[]) => PresetQuery
  * The first group are client methods. The second is reserved for later
  * releases. `then` would make a table handle look like a promise.
  */
-export type ReservedPreset = "find" | "one" | "page" | "aggregate" | "count" | "exists" | "insert" | "update" | "delete" | "archive" | "restore" | "withArchived" | "onlyArchived" | "then" | "lock" | "watch" | "subscribe" | "stream" | "inspect" | "explain" | "with" | "for" | "as";
+export type ReservedPreset = "find" | "one" | "page" | "aggregate" | "count" | "exists" | "insert" | "update" | "delete" | "descendants" | "ancestors" | "sync" | "archive" | "restore" | "withArchived" | "onlyArchived" | "then" | "lock" | "watch" | "subscribe" | "stream" | "inspect" | "explain" | "with" | "for" | "as";
 /**
  * The `presets` option. A reserved name is a type error here, and OKM1040 when
  * the schema is used.

package/dist/dialects/pg/relations.d.ts

@@ -1,9 +1,9 @@
 /**
- * `one`, `many`, and `manyThrough` relations.
+ * `one`, `many`, `manyThrough`, and `morph` relations.
  *
  * They name a table. `schema()` resolves the foreign key. An ambiguous key
- * is OKM1021. `manyThrough` names the join table as well and carries its own
- * resolver, so a schema without one does not pay for it. `morph` stays reserved.
+ * is OKM1021. `manyThrough` and `morph` carry their own resolvers, so a schema
+ * that never calls one does not pay for it.
  */
 import type { RelationModel } from "./model.js";
 /** A to-one relation. `field` is the local foreign key when the table has several. */
@@ -28,6 +28,26 @@ export type RelationEdge = {
     /** Referenced SQL names, in the same order. */
     readonly remote: readonly string[];
 };
+/** A table as a morph resolver reads it. Foreign-key resolvers ignore this. */
+export type RelationDescribed = {
+    readonly tsName: string;
+    readonly sqlName: string;
+    /** Primary-key SQL names, in catalog order. */
+    readonly primary: readonly string[];
+    readonly byField: ReadonlyMap<string, {
+        readonly field: string;
+        readonly sqlName: string;
+        readonly dataType: string;
+        readonly nullable: boolean;
+    }>;
+    readonly bySql: ReadonlyMap<string, {
+        readonly field: string;
+        readonly sqlName: string;
+        readonly dataType: string;
+    }>;
+    /** Relation calls stored on the table, before they are resolved. */
+    readonly relationOptions: unknown;
+};
 /** What a relation's own resolver reads from `schema()`. */
 export type RelationScope = {
     /** The table that declares the relation. */
@@ -37,6 +57,19 @@ export type RelationScope = {
     readonly edges: readonly RelationEdge[];
     /** Every table name in the schema, sorted. */
     readonly tables: readonly string[];
+    /**
+     * Looks up a table's columns.
+     *
+     * Present when `schema()` resolves relations. A resolver that only needs
+     * foreign keys ignores it. The value is the prepared table; morph narrows it.
+     */
+    readonly describe?: (table: string) => unknown;
+    /**
+     * Tenant fields tenancy added to a primary key.
+     *
+     * A morph id matches the key that remains. Absent when the schema has no tenancy.
+     */
+    readonly scopeFields?: readonly string[];
 };
 /**
  * A to-many relation through a join table.
@@ -100,3 +133,67 @@ export declare function isRelationCall(value: unknown): value is RelationCall;
 export declare function manyThrough<const TTable extends string>(table: TTable, options: {
     readonly through: string;
 } & ThroughKeys): ManyThroughRelation<TTable>;
+/**
+ * A polymorphic to-one relation.
+ *
+ * `name` is the column stem: the table declares `${name}Type` and `${name}Id`.
+ * The type column stores a target table name. The id column stores that
+ * table's primary key. Include returns one row of the matching target, or
+ * null, as a flat union discriminated by the type field.
+ *
+ * @typeParam TName - Column stem
+ * @typeParam TTargets - Closed list of target tables
+ * @param name - Column stem
+ * @param targets - Target table names, each with one primary-key column
+ * @returns The relation `schema()` resolves
+ */
+export declare function morph<const TName extends string, const TTargets extends readonly [string, ...string[]]>(name: TName, targets: TTargets): MorphRelation<TName, TTargets>;
+/**
+ * The reverse of {@link morph}: many owner rows that point at this table.
+ *
+ * Declare it on each target. `table` is the table that holds the type and id
+ * columns, and `name` is the stem passed to `morph`.
+ *
+ * @typeParam TTable - Table that holds the type and id columns
+ * @param table - That table
+ * @param name - Column stem
+ * @returns The relation `schema()` resolves
+ */
+export declare function morphMany<const TTable extends string>(table: TTable, name: string): MorphManyRelation<TTable>;
+/**
+ * A polymorphic relation declared with {@link morph}.
+ *
+ * It is a {@link OneRelation} so the relation map stays assignable. `morph`
+ * is what include reads to build the union.
+ */
+export type MorphRelation<TName extends string = string, TTargets extends readonly string[] = readonly string[]> = OneRelation<TTargets[number]> & {
+    readonly morph: {
+        readonly name: TName;
+        readonly targets: TTargets;
+        readonly typeField: `${TName}Type`;
+    };
+    readonly resolve: (scope: RelationScope) => RelationModel;
+};
+/**
+ * The reverse many declared with {@link morphMany}.
+ *
+ * It is a {@link ManyRelation}, so include, `has`, `none`, and `every` read it as one.
+ */
+export type MorphManyRelation<TTable extends string = string> = ManyRelation<TTable> & {
+    readonly resolve: (scope: RelationScope) => RelationModel;
+};
+/**
+ * Sets a morph's type and id columns together.
+ *
+ * @typeParam TName - Column stem
+ * @typeParam TType - Target table name
+ * @param name - Column stem passed to `morph`
+ * @param type - Target table name
+ * @param id - That table's primary key
+ * @returns The two fields an insert or update spreads in
+ */
+export declare function morphTo<const TName extends string, const TType extends string>(name: TName, type: TType, id: string): {
+    readonly [K in `${TName}Type`]: TType;
+} & {
+    readonly [K in `${TName}Id`]: string;
+};

package/dist/dialects/pg/schema.d.ts

@@ -5,6 +5,7 @@
  */
 import type { Catalog } from "../../contracts/catalog/types.js";
 import { type ClientGenerator } from "../../contracts/generator.js";
+import { type PostgresMajor } from "./floor.js";
 import { type SchemaHook, type TableModel } from "./model.js";
 import type { FieldsOfList, HasArchive, PresetsOfList, Trait } from "./trait.js";
 import { type ColumnTenancy, type TenantFields } from "./tenancy.js";
@@ -15,8 +16,16 @@ export type SchemaCodecs = {
     readonly numeric: "string" | "number";
     readonly timestamps: "temporal";
 };
-/** Engine requirement recorded for connect. */
+/**
+ * Engine requirement recorded for connect.
+ *
+ * The stored value is `>=` and a major. `minPostgres` and the deprecated
+ * string form normalise to the same object.
+ */
 export type SchemaRequires = {
+    /**
+     * @deprecated Use `minPostgres`. `">=17"` is the same floor as `minPostgres: 17`.
+     */
     readonly postgres?: string;
 };
 /**
@@ -28,6 +37,15 @@ export type SchemaRequires = {
  */
 export type SchemaInput<TTables extends readonly AnyTable[]> = {
     readonly tables: TTables;
+    /**
+     * Oldest Postgres major this schema runs on.
+     *
+     * Omitted means 15. A feature that needs a newer major is refused here.
+     */
+    readonly minPostgres?: PostgresMajor;
+    /**
+     * @deprecated Use {@link SchemaInput.minPostgres}. `">=17"` is the same floor as `minPostgres: 17`.
+     */
     readonly requires?: SchemaRequires;
     readonly casing?: "snake";
     readonly codecs?: {
@@ -39,8 +57,13 @@ export type SchemaInput<TTables extends readonly AnyTable[]> = {
     /**
      * What a bare `t.id()` means.
      *
-     * `"uuidv7"` and `"uuidv4"` are database defaults. A client generator is
-     * filled on insert and stays out of the catalog. A column option wins.
+     * Omitted, the database default is `gen_random_uuid()`. `"uuidv4"` stores
+     * the same function. `"uuidv7"` stores `uuidv7()` and needs Postgres 18
+     * (`minPostgres: 18`).
+     * Pick `uuidv7` for a large write-heavy table: the ids are time-ordered
+     * and the index stays local. Random ids are fine elsewhere. A client
+     * generator is filled on insert and stays out of the catalog. A column
+     * option wins.
      */
     readonly defaults?: {
         readonly id?: "uuidv7" | "uuidv4" | ClientGenerator<string>;
@@ -80,6 +103,11 @@ export type BuiltSchema<TTables extends readonly AnyTable[]> = {
     readonly types: "emitted" | "inferred";
     readonly casing: "snake" | undefined;
     readonly codecs: SchemaCodecs;
+    /**
+     * Declared floor, normalised to `>=` and a major.
+     *
+     * Absent when the schema names no floor. Connect then uses 15.
+     */
     readonly requires: SchemaRequires | undefined;
     readonly tables: TTables;
     /**

package/dist/dialects/pg/view/index.js

@@ -1,6 +1,6 @@
 import {
   viewClient
-} from "../../../shared/x3jc53kg.js";
+} from "../../../shared/5e3tf63j.js";
 import {
   viewObject,
   materializedViewObject,

package/dist/runtime/aggregate.d.ts

@@ -7,8 +7,14 @@
  * every aggregate exactly as they apply to a `find`. This module loads on the
  * first `aggregate()`.
  *
- * Not here: `having`, `bucket`, and ordering by an aggregate. A hidden column
- * cannot be grouped or aggregated, so an aggregate never shows what a read hides.
+ * Not here: `having`, ordering by an aggregate, and the time-zone date helpers
+ * (tool 5). A hidden column cannot be grouped or aggregated, so an aggregate
+ * never shows what a read hides.
+ *
+ * `bucket()` is a tagged helper. Its validation and SQL load in their own
+ * chunk, and only when `groupBy` contains one. A request object cannot create
+ * one. A NULL timestamp is one group: the result key is present and the value
+ * is null.
  */
 import { type Mods, type Session } from "./client.js";
 import { type ArchiveView } from "./plan.js";

package/dist/runtime/bucket-group.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Time buckets inside `aggregate` `groupBy` (spec §10, §13 tool 4).
+ *
+ * This module loads on the first `aggregate()` whose `groupBy` contains a
+ * `bucket()`. A plain aggregate does not import it. A NULL timestamp is one
+ * group: the `as` key is present and the value is null.
+ */
+import type { ColumnModel } from "../dialects/pg/model.js";
+import { type BucketUnit } from "../dialects/pg/ops/bucket.js";
+import { type Built, type Indexed, type Sink } from "./plan.js";
+/** One bucket in a group list. */
+export type BucketGroup = {
+    readonly kind: "bucket";
+    readonly column: ColumnModel;
+    readonly unit: BucketUnit;
+    readonly tz: string | undefined;
+    readonly as: string;
+    readonly shift: 0 | 1 | 2;
+    readonly clock: boolean;
+};
+/**
+ * What the aggregate chunk calls after this module loads.
+ *
+ * The aggregate chunk does not import this file. It receives the functions
+ * from `import()`.
+ */
+export type BucketChunk = {
+    readBucket(table: Indexed, value: unknown, fields: ReadonlySet<string>, aliases: Set<string>): BucketGroup;
+    writeBucket(sink: Sink, outputs: Built | undefined, wrote: {
+        at: number;
+    }, group: BucketGroup): void;
+    writeGrouped(sink: Sink, names: readonly string[], orderBy: unknown): void;
+};
+/**
+ * Reads one `bucket()` group.
+ *
+ * Refuses a bad unit, zone, week start, or result name before any SQL.
+ * `__proto__`, `constructor`, `toString`, and `hasOwnProperty` are refused.
+ * `timestamptz` needs an IANA `tz`. `date` refuses `tz`. `timestamp` without
+ * a zone is refused.
+ *
+ * @param table - The grouped table
+ * @param value - One `groupBy` entry
+ * @param fields - Plain group fields already seen
+ * @param aliases - Bucket result names already seen
+ * @returns The group the statement writes
+ */
+export declare function readBucket(table: Indexed, value: unknown, fields: ReadonlySet<string>, aliases: Set<string>): BucketGroup;
+/**
+ * Writes one bucket expression into the select list.
+ *
+ * @param sink - Statement buffer
+ * @param outputs - Decode plan, absent while only marking
+ * @param wrote - How many select items are already written
+ * @param group - The bucket
+ */
+export declare function writeBucket(sink: Sink, outputs: Built | undefined, wrote: {
+    at: number;
+}, group: BucketGroup): void;
+/**
+ * Groups and orders by select-list ordinals.
+ *
+ * The bucket expression is written once, in the select list. A second copy
+ * would bind a new `$n`, and Postgres treats that as a different expression.
+ *
+ * @param sink - Statement buffer
+ * @param names - Group names, in select order
+ * @param orderBy - Caller order, or the default group order
+ */
+export declare function writeGrouped(sink: Sink, names: readonly string[], orderBy: unknown): void;

package/dist/runtime/conflict.d.ts

@@ -23,18 +23,36 @@ export type ConflictPlan = {
  */
 export declare function readConflict(table: Indexed, value: unknown, allow?: ReadonlySet<string>, tenantKey?: string | readonly string[]): ConflictPlan | undefined;
 /**
- * Appends the conflict clause, or wraps a first-or-create insert.
+ * Appends the conflict clause.
+ *
+ * First-or-create is `on conflict do nothing`. It does not read the existing
+ * row here: that lookup is a later statement, so it sees a row another
+ * transaction committed while this insert waited (D246).
  *
  * @param head - `insert into … values …` without `returning`
  * @param returning - ` returning …`, including the leading space
  * @param params - Insert parameters
  * @param plan - Conflict plan
  * @param table - Target table
- * @param returningColumns - Columns in `returning`
- * @param keys - Encoded conflict-key tuples, one per inserted row. Used by `return`
  * @returns Statement text and parameters
  */
-export declare function finishInsert(head: string, returning: string, params: readonly (string | null)[], plan: ConflictPlan, table: Indexed, returningColumns: readonly ColumnModel[], keys: readonly (readonly (string | null)[])[]): {
+export declare function finishInsert(head: string, returning: string, params: readonly (string | null)[], plan: ConflictPlan, table: Indexed): {
+    readonly text: string;
+    readonly params: (string | null)[];
+};
+/**
+ * Reads rows a first-or-create insert did not return.
+ *
+ * The conflict target is the same unique, including the tenant key. A partial
+ * unique on an archivable table only matches the active row.
+ *
+ * @param table - Target table
+ * @param keys - Conflict columns, in constraint order
+ * @param returningColumns - Columns the insert returns, in that order
+ * @param keyRows - Encoded conflict-key tuples that the insert did not return
+ * @returns One select
+ */
+export declare function lookupExisting(table: Indexed, keys: readonly ColumnModel[], returningColumns: readonly ColumnModel[], keyRows: readonly (readonly (string | null)[])[]): {
     readonly text: string;
     readonly params: (string | null)[];
 };

package/dist/runtime/include.d.ts

@@ -2,14 +2,6 @@
  * LATERAL include planner. Loaded on the first include.
  */
 import { type IncludeHooks, type Plan } from "./plan.js";
-/**
- * Decodes a result that has includes.
- *
- * @param plan - Compiled plan
- * @param rows - Wire rows
- * @param table - Table the call named
- * @returns The call's value
- */
 export declare function decodeIncluded(plan: Plan, rows: readonly (readonly (string | null)[])[], table: string): unknown;
 /** Hooks the read planner calls after this module has loaded. */
 export declare const includeHooks: IncludeHooks;

package/dist/runtime/inflight.d.ts

@@ -2,7 +2,7 @@
  * Refuses a positive timeout on a driver that cannot cancel.
  *
  * `tx({ timeout })` and `batch({ timeout })` load this with the call. The
- * connect graph does not. The message stays the one {@link noTimeout} throws.
+ * connect graph does not. The OKM1120 text loads with the lazy error module.
  */
 import type { DriverPool } from "../contracts/driver.js";
 /**

package/dist/runtime/page.d.ts

@@ -20,6 +20,9 @@ import { type ArchiveView } from "./plan.js";
  * @param options - `where`, `select`, `orderBy`, `limit`, `include`, and `after`
  * @param mods - Signal and timeout
  * @param view - Archive visibility
+ * @param pin - Endpoint a stream already chose. Absent for `page()`
  * @returns A handle that resolves to `{ items, next }`
  */
-export declare function build(session: Session, table: string, options: object, mods: Mods, view: ArchiveView | undefined): Promise<unknown> & Record<string, unknown>;
+export declare function build(session: Session, table: string, options: object, mods: Mods, view: ArchiveView | undefined, pin?: {
+    name?: string;
+}): Promise<unknown> & Record<string, unknown>;

package/dist/runtime/pg/bun.js

@@ -1,23 +1,27 @@
-import"../../shared/8dqhth8c.js";
 import {
   DriverError2
-} from "../../shared/31vm914h.js";
+} from "../../shared/cm3w0ywp.js";
 import {
+  markClientPool,
   open5
-} from "../../shared/32cnm7kn.js";
+} from "../../shared/x933k9a3.js";
 import {
   BUNSQL_CAPABILITIES,
   readCapability2,
   hasCapability2
-} from "../../shared/cgbamx3e.js";
+} from "../../shared/kb2sdhfb.js";
 import {
   createClient
-} from "../../shared/j60w0dvr.js";
+} from "../../shared/tbrvgw6z.js";
 
 // src/runtime/pg/bun.ts
 function connect(target, options) {
   if (typeof target === "object" && !isPool(target)) {
-    return import("../../shared/929h19xp.js").then((mod) => mod.default(target, options, open5));
+    return import("../../shared/mtaszv5a.js").then((mod) => mod.default(target, options, (config) => {
+      const pool = open5(config);
+      markClientPool(pool);
+      return pool;
+    }));
   }
   const owned = !isPool(target);
   const pool = isPool(target) ? target : open5({
@@ -28,6 +32,8 @@ function connect(target, options) {
     ...options.searchPath !== undefined ? { searchPath: options.searchPath } : {},
     ...options.ssl !== undefined ? { ssl: options.ssl } : {}
   });
+  if (!isPool(target))
+    markClientPool(pool);
   return createClient(options.schema, pool, {
     ownsPool: owned,
     http: options.errors?.http,

package/dist/runtime/pg/pg.js

@@ -1,22 +1,22 @@
 import {
   DriverError2
-} from "../../shared/31vm914h.js";
+} from "../../shared/cm3w0ywp.js";
 import {
   open4
-} from "../../shared/1z04fa85.js";
+} from "../../shared/w79hsckn.js";
 import {
   NODE_POSTGRES_CAPABILITIES,
   readCapability2,
   hasCapability2
-} from "../../shared/cgbamx3e.js";
+} from "../../shared/kb2sdhfb.js";
 import {
   createClient
-} from "../../shared/j60w0dvr.js";
+} from "../../shared/tbrvgw6z.js";
 
 // src/runtime/pg/pg.ts
 function connect(target, options) {
   if (typeof target === "object" && !isPool(target)) {
-    return import("../../shared/929h19xp.js").then((mod) => mod.default(target, options, open4));
+    return import("../../shared/mtaszv5a.js").then((mod) => mod.default(target, options, open4));
   }
   const owned = !isPool(target);
   const pool = isPool(target) ? target : open4({

package/dist/runtime/pg/pglite.d.ts

@@ -2,6 +2,7 @@
  * `connect` for PGlite (`okmodel/pg/pglite`).
  *
  * Opening a database is async. An existing pool is reused and not closed.
+ * Closing that client marks the client closed.
  * A `{ primary, replicas }` object loads the topology module. A replica URL is
  * that endpoint's data directory.
  */

package/dist/runtime/pg/pglite.js

@@ -1,30 +1,30 @@
-import"../../shared/8dqhth8c.js";
 import {
   DriverError2
-} from "../../shared/31vm914h.js";
+} from "../../shared/cm3w0ywp.js";
 import {
-  open3
-} from "../../shared/5j36z8dn.js";
+  open3,
+  seal2
+} from "../../shared/81ebdx9p.js";
 import {
   PGLITE_CAPABILITIES,
   readCapability2,
   hasCapability2
-} from "../../shared/cgbamx3e.js";
+} from "../../shared/kb2sdhfb.js";
 import {
   createClient
-} from "../../shared/j60w0dvr.js";
+} from "../../shared/tbrvgw6z.js";
 
 // src/runtime/pg/pglite.ts
 async function connect(target, options) {
   if (typeof target === "object" && !isPool(target)) {
-    return import("../../shared/929h19xp.js").then((mod) => mod.default(target, options, open3));
+    return import("../../shared/mtaszv5a.js").then((mod) => mod.default(target, options, open3));
   }
-  const pool = isPool(target) ? target : await open3({
+  const pool = isPool(target) ? seal2(target) : await open3({
     ...target !== undefined ? { dataDir: target } : {},
     ...options.timeouts !== undefined ? { timeouts: options.timeouts } : {}
   });
   return createClient(options.schema, pool, {
-    ownsPool: !isPool(target),
+    ownsPool: true,
     http: options.errors?.http,
     includeValues: options.errors?.includeValues,
     logger: options.logger,

package/dist/runtime/pg/postgresjs.js

@@ -1,22 +1,22 @@
 import {
   DriverError2
-} from "../../shared/31vm914h.js";
+} from "../../shared/cm3w0ywp.js";
 import {
   open2
-} from "../../shared/wkme6tep.js";
+} from "../../shared/14vx95q4.js";
 import {
   POSTGRESJS_CAPABILITIES,
   readCapability2,
   hasCapability2
-} from "../../shared/cgbamx3e.js";
+} from "../../shared/kb2sdhfb.js";
 import {
   createClient
-} from "../../shared/j60w0dvr.js";
+} from "../../shared/tbrvgw6z.js";
 
 // src/runtime/pg/postgresjs.ts
 function connect(target, options) {
   if (typeof target === "object" && !isPool(target)) {
-    return import("../../shared/929h19xp.js").then((mod) => mod.default(target, options, open2));
+    return import("../../shared/mtaszv5a.js").then((mod) => mod.default(target, options, open2));
   }
   const owned = !isPool(target);
   const pool = isPool(target) ? target : open2({