okmodel 0.1.1 → 0.2.1

package/dist/runtime/ids/index.js

@@ -0,0 +1,193 @@
+import {
+  clientGenerator
+} from "../../shared/rwmrejjz.js";
+
+// src/runtime/ids/uuid.ts
+var HEX = "0123456789abcdef";
+var uuidv4 = clientGenerator(() => crypto.randomUUID(), "uuidv4");
+var uuidv7 = clientGenerator(mintUuidV7, "uuidv7");
+function mintUuidV7() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  const now = Date.now();
+  bytes[0] = Math.floor(now / 2 ** 40) & 255;
+  bytes[1] = Math.floor(now / 2 ** 32) & 255;
+  bytes[2] = Math.floor(now / 2 ** 24) & 255;
+  bytes[3] = Math.floor(now / 2 ** 16) & 255;
+  bytes[4] = Math.floor(now / 2 ** 8) & 255;
+  bytes[5] = now & 255;
+  const sixth = bytes[6] ?? 0;
+  const eighth = bytes[8] ?? 0;
+  bytes[6] = sixth & 15 | 112;
+  bytes[8] = eighth & 63 | 128;
+  return formatUuid(bytes);
+}
+function formatUuid(bytes) {
+  let out = "";
+  for (let index = 0;index < 16; index += 1) {
+    if (index === 4 || index === 6 || index === 8 || index === 10)
+      out += "-";
+    const byte = bytes[index] ?? 0;
+    out += HEX[byte >> 4];
+    out += HEX[byte & 15];
+  }
+  return out;
+}
+// src/runtime/ids/okid-shared.ts
+var OKID_DEFAULT_CHARS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_";
+var OKID_LOOKALIKE_CHARS = "1lI0Oouv5Ss";
+var OKID_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+var OKID_SORTABLE_ALPHABET = "-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz";
+var OKID_DEFAULT_LENGTH = 21;
+var OKID_MIN_LENGTH = 8;
+var OKID_MAX_LENGTH = 128;
+var OKID_SORTABLE_MIN_LENGTH = 16;
+var OKID_MAX_PREFIX_LENGTH = 32;
+function assertLength(length, min, label) {
+  if (!Number.isInteger(length)) {
+    throw new RangeError(`okid: ${label} must be an integer, got ${length}`);
+  }
+  if (length < min || length > OKID_MAX_LENGTH) {
+    throw new RangeError(`okid: ${label} ${length} is out of range [${min}, ${OKID_MAX_LENGTH}]`);
+  }
+}
+
+// src/runtime/ids/okid-extended.ts
+var GROUPS = {
+  numbers: "0123456789",
+  lowercase: "abcdefghijklmnopqrstuvwxyz",
+  uppercase: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+  symbols: "-_"
+};
+var ALPHABET_CACHE = new Map;
+function resolveAlphabet(numbers, lowercase, uppercase, symbols, lookAlikes) {
+  const key = (numbers ? 1 : 0) | (lowercase ? 2 : 0) | (uppercase ? 4 : 0) | (symbols ? 8 : 0) | (lookAlikes ? 0 : 16);
+  const cached = ALPHABET_CACHE.get(key);
+  if (cached)
+    return cached;
+  let chars = "";
+  if (numbers)
+    chars += GROUPS.numbers;
+  if (lowercase)
+    chars += GROUPS.lowercase;
+  if (uppercase)
+    chars += GROUPS.uppercase;
+  if (symbols)
+    chars += GROUPS.symbols;
+  if (!chars) {
+    throw new RangeError("okid: alphabet is empty — enable at least one character group");
+  }
+  if (!lookAlikes) {
+    chars = [...chars].filter((c) => !OKID_LOOKALIKE_CHARS.includes(c)).join("");
+  }
+  const rawSize = chars.length;
+  const size = 1 << Math.ceil(Math.log2(rawSize));
+  const resolved = { chars, size: rawSize, mask: size - 1 };
+  ALPHABET_CACHE.set(key, resolved);
+  return resolved;
+}
+function encodeAlphabet(alphabet, length) {
+  const { chars, size, mask } = alphabet;
+  const bytes = new Uint8Array(length + Math.ceil(length >> 2));
+  crypto.getRandomValues(bytes.subarray(0, length));
+  let out = "";
+  let i = 0;
+  while (out.length < length && i < bytes.length) {
+    const byte = bytes[i++];
+    if ((byte & mask) < size)
+      out += chars[byte & mask];
+  }
+  return out;
+}
+function encodeTimestamp(nowMs) {
+  let t = nowMs % 2 ** 48;
+  let out = "";
+  for (let i = 0;i < 8; i++) {
+    out = OKID_SORTABLE_ALPHABET[t & 63] + out;
+    t = Math.floor(t / 64);
+  }
+  return out;
+}
+function assertPrefix(prefix) {
+  if (prefix.length > OKID_MAX_PREFIX_LENGTH) {
+    throw new RangeError(`okid: prefix length ${prefix.length} exceeds max ${OKID_MAX_PREFIX_LENGTH}`);
+  }
+  for (const char of prefix) {
+    if (!OKID_ALPHABET.includes(char)) {
+      throw new RangeError(`okid: prefix contains invalid character ${JSON.stringify(char)} — use characters from OKID_ALPHABET`);
+    }
+  }
+}
+function okidWithOptions(options) {
+  const {
+    length = OKID_DEFAULT_LENGTH,
+    prefix = "",
+    sortable = false,
+    lowercase = true,
+    uppercase = true,
+    numbers = true,
+    symbols = true,
+    lookAlikes = true
+  } = options;
+  if (prefix)
+    assertPrefix(prefix);
+  let body;
+  if (sortable) {
+    assertLength(length, OKID_SORTABLE_MIN_LENGTH, "length");
+    const alphabet = resolveAlphabet(true, true, true, true, true);
+    body = encodeTimestamp(Date.now()) + encodeAlphabet(alphabet, length - 8);
+  } else {
+    assertLength(length, OKID_MIN_LENGTH, "length");
+    body = encodeAlphabet(resolveAlphabet(numbers, lowercase, uppercase, symbols, lookAlikes), length);
+  }
+  return prefix ? prefix + body : body;
+}
+
+// src/runtime/ids/okid.ts
+function okid(options = OKID_DEFAULT_LENGTH) {
+  if (typeof options === "number") {
+    assertLength(options, OKID_MIN_LENGTH, "length");
+    const bytes = new Uint8Array(options);
+    crypto.getRandomValues(bytes);
+    let out = "";
+    for (let i = 0;i < options; i++)
+      out += OKID_DEFAULT_CHARS[bytes[i] & 63];
+    return out;
+  }
+  return okidWithOptions(options);
+}
+
+// src/runtime/ids/okid-generator.ts
+function okid2(options) {
+  const stored = optionsRecord(options);
+  return clientGenerator(() => options === undefined ? okid() : okid(options), "okid", stored);
+}
+function optionsRecord(options) {
+  if (options === undefined)
+    return;
+  if (typeof options === "number")
+    return { length: options };
+  const stored = {};
+  if (options.length !== undefined)
+    stored.length = options.length;
+  if (options.prefix !== undefined)
+    stored.prefix = options.prefix;
+  if (options.sortable !== undefined)
+    stored.sortable = options.sortable;
+  if (options.lowercase !== undefined)
+    stored.lowercase = options.lowercase;
+  if (options.uppercase !== undefined)
+    stored.uppercase = options.uppercase;
+  if (options.numbers !== undefined)
+    stored.numbers = options.numbers;
+  if (options.symbols !== undefined)
+    stored.symbols = options.symbols;
+  if (options.lookAlikes !== undefined)
+    stored.lookAlikes = options.lookAlikes;
+  return stored;
+}
+export {
+  okid2 as okid,
+  uuidv4,
+  uuidv7
+};

package/dist/runtime/ids/okid-extended.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Vendored from okengine `src/okid-extended.ts` (Apache-2.0).
+ *
+ * okengine stays the source of truth. `bun run okid-drift` fails when this
+ * copy or the sibling okengine files leave the recorded hashes. Imports use
+ * the `.js` specifier this package resolves.
+ */
+/**
+ * `okid({ … })` options path — sortable, prefix, and alphabet toggles.
+ *
+ * Kept off the kernel edge profile. `okid()` and `okid(length)` never load it.
+ */
+import { type OkidOptions } from "./okid-shared.js";
+/**
+ * Generate an id from an options object.
+ *
+ * @param options - Length, prefix, sortable, and alphabet toggles
+ */
+export declare function okidWithOptions(options: OkidOptions): string;

package/dist/runtime/ids/okid-generator.d.ts

@@ -0,0 +1,21 @@
+/**
+ * OKID as a client generator.
+ *
+ * Calling {@link okid} does not mint an id. It returns a function that mints
+ * one id per call, so `.default(okid({ prefix }))` fills each inserted row.
+ * The vendored {@link mintOkid} is what that function calls.
+ */
+import { type ClientGenerator } from "../../contracts/generator.js";
+import { type OkidOptions } from "./okid.js";
+export type { OkidOptions } from "./okid.js";
+/**
+ * Binds OKID options into a client generator.
+ *
+ * `okid()` and `okid(length)` use the default alphabet. `okid({ prefix,
+ * sortable, length })` keeps those options for every row. Sortable ids embed
+ * the creation time. An OKID column is `text` with collation `C`.
+ *
+ * @param options - Body length, or prefix, sortable, and alphabet toggles
+ * @returns A generator. Call it to mint one id
+ */
+export declare function okid(options?: number | OkidOptions): ClientGenerator<string>;

package/dist/runtime/ids/okid-shared.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Vendored from okengine `src/okid-shared.ts` (Apache-2.0).
+ *
+ * okengine stays the source of truth. `bun run okid-drift` fails when this
+ * copy or the sibling okengine files leave the recorded hashes.
+ */
+/**
+ * OKID constants and the options-path encoder.
+ *
+ * The default `okid()` / `okid(length)` hot path does not import the
+ * alphabet resolver — only these constants and {@link assertLength}.
+ */
+/**
+ * Default `okid()` / `okid(length)` alphabet.
+ *
+ * Same 64-character set and order as
+ * `resolveAlphabet(true, true, true, true, true)` (numbers, lowercase,
+ * uppercase, symbols). Power-of-two size, so a bitmask is unbiased.
+ */
+export declare const OKID_DEFAULT_CHARS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_";
+/**
+ * Characters removed when `lookAlikes` is disabled (human transcription).
+ */
+export declare const OKID_LOOKALIKE_CHARS = "1lI0Oouv5Ss";
+/** Default URL-safe alphabet: Base64URL charset in its conventional order. */
+export declare const OKID_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+/**
+ * Codepoint-ordered variant of {@link OKID_ALPHABET}: identical characters,
+ * sorted by code unit so plain string comparison equals value comparison.
+ * The default Base64URL order is NOT lexicographic (`_` sorts between `Z`
+ * and `a`), which would silently break time ordering — so the sortable
+ * encoder always uses this order.
+ *
+ * Kept as a literal (not `[...OKID_ALPHABET].sort().join("")`) so the public
+ * JSR API stays fast-type / explicitly typed.
+ */
+export declare const OKID_SORTABLE_ALPHABET: string;
+/** Default id length — 21 chars × 6 bits = 126 bits of entropy. */
+export declare const OKID_DEFAULT_LENGTH = 21;
+/** Shortest permitted id length (8 chars ≈ 48 bits entropy floor). */
+export declare const OKID_MIN_LENGTH = 8;
+/** Longest permitted id length. */
+export declare const OKID_MAX_LENGTH = 128;
+/** Sortable ids need ≥ 16: 8 timestamp chars alone would leave no randomness. */
+export declare const OKID_SORTABLE_MIN_LENGTH = 16;
+/** Longest permitted semantic {@link OkidOptions.prefix}. */
+export declare const OKID_MAX_PREFIX_LENGTH = 32;
+/** Options for {@link okid}. All alphabet toggles default to included. */
+export interface OkidOptions {
+    /**
+     * Generated body length (default {@link OKID_DEFAULT_LENGTH}). Does not
+     * include {@link prefix} — the returned string is `prefix + body`.
+     */
+    readonly length?: number;
+    /**
+     * Fixed semantic label prepended to the body (e.g. `"usr_"`, `"evt_"`).
+     * Characters must belong to {@link OKID_ALPHABET}; max
+     * {@link OKID_MAX_PREFIX_LENGTH}. Empty / omitted means no label.
+     */
+    readonly prefix?: string;
+    /**
+     * Prefix the body with a 48-bit epoch-ms timestamp (exactly 8 chars) so
+     * lexicographic order tracks creation time across milliseconds. Alphabet
+     * toggles are ignored under this mode — see {@link OKID_SORTABLE_ALPHABET}.
+     * Combines with {@link prefix}: `prefix + timestamp + random`.
+     */
+    readonly sortable?: boolean;
+    /** Include `a-z` (default true). */
+    readonly lowercase?: boolean;
+    /** Include `A-Z` (default true). */
+    readonly uppercase?: boolean;
+    /** Include `0-9` (default true). */
+    readonly numbers?: boolean;
+    /** Include `-` and `_` (default true). */
+    readonly symbols?: boolean;
+    /**
+     * Include visually confusable characters (`1lI0Oouv5Ss`, default true).
+     * Set `false` to drop them for human transcription.
+     */
+    readonly lookAlikes?: boolean;
+}
+/**
+ * Assert `length` is a valid integer within bounds for the requested mode.
+ *
+ * @param length - Requested length
+ * @param min - Mode-specific minimum
+ * @param label - Option name used in the error message
+ */
+export declare function assertLength(length: number, min: number, label: string): void;

package/dist/runtime/ids/okid.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Vendored from okengine `src/okid.ts` (Apache-2.0).
+ *
+ * okengine stays the source of truth. `bun run okid-drift` fails when this
+ * copy or the sibling okengine files leave the recorded hashes. The only
+ * local change is a static import of the options path, so the file has no
+ * okengine dependency and stays synchronous.
+ */
+import { type OkidOptions } from "./okid-shared.js";
+export type { OkidOptions } from "./okid-shared.js";
+export { OKID_ALPHABET, OKID_DEFAULT_LENGTH, OKID_LOOKALIKE_CHARS, OKID_MAX_LENGTH, OKID_MAX_PREFIX_LENGTH, OKID_MIN_LENGTH, OKID_SORTABLE_ALPHABET, OKID_SORTABLE_MIN_LENGTH, } from "./okid-shared.js";
+/**
+ * Generate an OKE-native id.
+ *
+ * Accepts either a bare length or an options object; the bare-number form is
+ * the hot path and skips all option resolution beyond validation.
+ *
+ * @param options - Length in chars, or {@link OkidOptions}
+ * @returns A URL-safe id: the generated body, optionally preceded by
+ * {@link OkidOptions.prefix}
+ * @throws RangeError on invalid input (non-integer, out-of-range length,
+ * invalid prefix, empty alphabet)
+ */
+export declare function okid(options?: number | OkidOptions): string;

package/dist/runtime/ids/uuid.d.ts

@@ -0,0 +1,21 @@
+/**
+ * UUID client generators.
+ *
+ * `uuidv4` is `crypto.randomUUID()`. `uuidv7` is ours, so a server older than
+ * Postgres 18 can still have time-ordered ids without a database function.
+ */
+import { type ClientGenerator } from "../../contracts/generator.js";
+/**
+ * One random UUID, version 4.
+ *
+ * @returns Canonical 8-4-4-4-12 text
+ */
+export declare const uuidv4: ClientGenerator<string>;
+/**
+ * One time-ordered UUID, version 7.
+ *
+ * The first 48 bits are the Unix epoch in milliseconds. The rest is random.
+ *
+ * @returns Canonical 8-4-4-4-12 text
+ */
+export declare const uuidv7: ClientGenerator<string>;

package/dist/runtime/lock.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Row locks on `find` (spec §15): `lock: "update" | "share"` and
+ * `wait: "nowait" | "skip"`.
+ *
+ * A lock lives as long as its transaction, so it exists inside `tx()` only
+ * (OKM1830 outside one). The lock clause is the end of the statement and names
+ * the table alone (`for update of t`), so a to-one include does not lock the
+ * related row. Loaded on the first `find` that names `lock` or `wait`.
+ */
+import { type Mods, type Session } from "./client.js";
+import { type ArchiveView } from "./plan.js";
+/**
+ * Builds the handle for one locking `find`.
+ *
+ * @param session - Client session. It must belong to a transaction
+ * @param table - Table name
+ * @param options - `find` options plus `lock` and `wait`
+ * @param mods - `.all` reason and presets
+ * @param view - Archive visibility
+ * @returns A handle that resolves to the locked rows
+ */
+export declare function build(session: Session, table: string, options: object, mods: Mods, view: ArchiveView | undefined): Promise<unknown> & Record<string, unknown>;

package/dist/runtime/operator-sql.d.ts

@@ -0,0 +1,8 @@
+/**
+ * SQL for the 0.2 operators.
+ *
+ * Loaded on the first query that uses one, so a client that only compares
+ * and filters text does not pay for it at startup. Text `contains` stays in
+ * the planner as `LIKE`.
+ */
+export {};

package/dist/runtime/page.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Keyset pages (spec sections 10 and 12).
+ *
+ * A page is a `find` with three changes: the order ends in the primary key, the
+ * limit is one more than the page size, and an `after` condition replaces
+ * offset. The tenant and active-set predicates are the planner's, so they
+ * apply to every page the same way. This module loads on the first `page()`.
+ *
+ * The cursor holds the order it was made for and the values of the last row as
+ * the database wrote them. Those are text, not decoded values, so a timestamp
+ * keeps its microseconds and no row is skipped or repeated.
+ */
+import { type Mods, type Session } from "./client.js";
+import { type ArchiveView } from "./plan.js";
+/**
+ * Builds the handle for one `page()` call.
+ *
+ * @param session - Client session
+ * @param table - Table name
+ * @param options - `where`, `select`, `orderBy`, `limit`, `include`, and `after`
+ * @param mods - Signal and timeout
+ * @param view - Archive visibility
+ * @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>;

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

@@ -0,0 +1,30 @@
+/**
+ * `connect` for Bun.sql (`okmodel/pg/bun`).
+ *
+ * One URL or an existing pool is one endpoint. The client is typed by the
+ * schema passed in. This entry runs on Bun. Node cannot load the `bun` import
+ * inside the adapter.
+ */
+import type { DriverPool } from "../../contracts/driver.js";
+import type { QuerySchema } from "../../dialects/pg/model.js";
+import { type BunSqlConfig } from "../../adapters/pg/bunsql.js";
+import type { ConnectOptions, Connected } from "../types.js";
+export { open, type BunSqlConfig, type BunSqlTls } from "../../adapters/pg/bunsql.js";
+export { capabilities, hasCapability, readCapability } from "../../adapters/pg/bunsql.js";
+export { DriverError } from "../../adapters/error.js";
+/** A connection string or a pool from {@link open}. */
+export type BunSqlTarget = string | DriverPool;
+/** Driver options `connect` forwards to {@link open}. */
+export type BunSqlConnectOptions<S extends QuerySchema> = ConnectOptions<S> & Omit<BunSqlConfig, "url">;
+/**
+ * Connects one Postgres endpoint through Bun.sql and returns a client for `schema`.
+ *
+ * Named prepared statements are off unless `prepared` is `"named"`.
+ * `prepared: "named"` is not for transaction-mode poolers.
+ *
+ * @typeParam S - Schema
+ * @param target - URL or an existing pool
+ * @param options - Schema, errors, logger, and driver options
+ * @returns The client. Await `connected` for the dialect check
+ */
+export declare function connect<const S extends QuerySchema>(target: BunSqlTarget, options: BunSqlConnectOptions<S>): Connected<S>;

package/dist/runtime/pg/bun.js

@@ -0,0 +1,52 @@
+import {
+  DriverError2
+} from "../../shared/kyxb62mc.js";
+import {
+  open5
+} from "../../shared/ytg3xf9p.js";
+import {
+  BUNSQL_CAPABILITIES,
+  readCapability2,
+  hasCapability2
+} from "../../shared/9k6vetvf.js";
+import {
+  createClient
+} from "../../shared/mxmcdsh5.js";
+
+// src/runtime/pg/bun.ts
+function connect(target, options) {
+  const owned = !isPool(target);
+  const pool = isPool(target) ? target : open5({
+    url: target,
+    ...options.max !== undefined ? { max: options.max } : {},
+    ...options.timeouts !== undefined ? { timeouts: options.timeouts } : {},
+    ...options.prepared !== undefined ? { prepared: options.prepared } : {},
+    ...options.searchPath !== undefined ? { searchPath: options.searchPath } : {},
+    ...options.ssl !== undefined ? { ssl: options.ssl } : {}
+  });
+  return createClient(options.schema, pool, {
+    ownsPool: owned,
+    http: options.errors?.http,
+    includeValues: options.errors?.includeValues,
+    logger: options.logger,
+    signal: options.signal,
+    timeout: options.timeout,
+    timeouts: options.timeouts,
+    hookm: options.hookm,
+    catalog: options.catalog,
+    catalogDir: options.catalogDir,
+    requireMeta: options.requireMeta,
+    generators: options.generators
+  });
+}
+function isPool(target) {
+  return typeof target === "object" && "execute" in target && "capabilities" in target;
+}
+export {
+  DriverError2 as DriverError,
+  BUNSQL_CAPABILITIES as capabilities,
+  connect,
+  hasCapability2 as hasCapability,
+  open5 as open,
+  readCapability2 as readCapability
+};

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

@@ -0,0 +1,29 @@
+/**
+ * `connect` for node-postgres (`okmodel/pg/pg`).
+ *
+ * One URL or an existing pool is one endpoint. The client is typed by the
+ * schema passed in, not by `Register`.
+ */
+import type { DriverPool } from "../../contracts/driver.js";
+import type { QuerySchema } from "../../dialects/pg/model.js";
+import { type NodePostgresConfig } from "../../adapters/pg/nodepostgres.js";
+import type { ConnectOptions, Connected } from "../types.js";
+export { open, type NodePostgresConfig } from "../../adapters/pg/nodepostgres.js";
+export { capabilities, hasCapability, readCapability } from "../../adapters/pg/nodepostgres.js";
+export { DriverError } from "../../adapters/error.js";
+/** A connection string or a pool from {@link open}. */
+export type NodePostgresTarget = string | DriverPool;
+/** Driver options `connect` forwards to {@link open}. */
+export type NodePostgresConnectOptions<S extends QuerySchema> = ConnectOptions<S> & Omit<NodePostgresConfig, "url">;
+/**
+ * Connects one Postgres endpoint through node-postgres and returns a client for `schema`.
+ *
+ * Named prepared statements are off unless `prepared` is `"named"`.
+ * `prepared: "named"` is not for transaction-mode poolers.
+ *
+ * @typeParam S - Schema
+ * @param target - URL or an existing pool
+ * @param options - Schema, errors, logger, and driver options
+ * @returns The client. Await `connected` for the dialect check
+ */
+export declare function connect<const S extends QuerySchema>(target: NodePostgresTarget, options: NodePostgresConnectOptions<S>): Connected<S>;

package/dist/runtime/pg/pg.js

@@ -0,0 +1,52 @@
+import {
+  DriverError2
+} from "../../shared/kyxb62mc.js";
+import {
+  open4
+} from "../../shared/38crxbgn.js";
+import {
+  NODE_POSTGRES_CAPABILITIES,
+  readCapability2,
+  hasCapability2
+} from "../../shared/9k6vetvf.js";
+import {
+  createClient
+} from "../../shared/mxmcdsh5.js";
+
+// src/runtime/pg/pg.ts
+function connect(target, options) {
+  const owned = !isPool(target);
+  const pool = isPool(target) ? target : open4({
+    url: target,
+    ...options.max !== undefined ? { max: options.max } : {},
+    ...options.timeouts !== undefined ? { timeouts: options.timeouts } : {},
+    ...options.prepared !== undefined ? { prepared: options.prepared } : {},
+    ...options.searchPath !== undefined ? { searchPath: options.searchPath } : {},
+    ...options.ssl !== undefined ? { ssl: options.ssl } : {}
+  });
+  return createClient(options.schema, pool, {
+    ownsPool: owned,
+    http: options.errors?.http,
+    includeValues: options.errors?.includeValues,
+    logger: options.logger,
+    signal: options.signal,
+    timeout: options.timeout,
+    timeouts: options.timeouts,
+    hookm: options.hookm,
+    catalog: options.catalog,
+    catalogDir: options.catalogDir,
+    requireMeta: options.requireMeta,
+    generators: options.generators
+  });
+}
+function isPool(target) {
+  return typeof target === "object" && "execute" in target && "capabilities" in target;
+}
+export {
+  DriverError2 as DriverError,
+  NODE_POSTGRES_CAPABILITIES as capabilities,
+  connect,
+  hasCapability2 as hasCapability,
+  open4 as open,
+  readCapability2 as readCapability
+};

package/dist/runtime/pg/pglite.js

@@ -1,39 +1,38 @@
 import {
   DriverError2
-} from "../../shared/hd293j9g.js";
+} from "../../shared/kyxb62mc.js";
 import {
   open3
-} from "../../shared/fgqgsb5z.js";
-import {
-  createClient
-} from "../../shared/rgs0st28.js";
+} from "../../shared/0qkxbm1f.js";
 import {
   PGLITE_CAPABILITIES,
   readCapability2,
   hasCapability2
-} from "../../shared/xy79j5hq.js";
+} from "../../shared/9k6vetvf.js";
+import {
+  createClient
+} from "../../shared/mxmcdsh5.js";
 
 // src/runtime/pg/pglite.ts
 async function connect(target, options) {
-  const shared = {
+  const pool = isPool(target) ? target : await open3({
+    ...target !== undefined ? { dataDir: target } : {},
+    ...options.timeouts !== undefined ? { timeouts: options.timeouts } : {}
+  });
+  return createClient(options.schema, pool, {
+    ownsPool: !isPool(target),
     http: options.errors?.http,
     includeValues: options.errors?.includeValues,
     logger: options.logger,
     signal: options.signal,
     requireMeta: options.requireMeta,
     timeout: options.timeout,
+    timeouts: options.timeouts,
+    hookm: options.hookm,
     catalog: options.catalog,
-    catalogDir: options.catalogDir
-  };
-  if (isPool(target)) {
-    return createClient(options.schema, target, { ...shared, ownsPool: false });
-  }
-  const dataDir = target;
-  const pool = await open3({
-    ...dataDir !== undefined ? { dataDir } : {},
-    ...options.timeouts !== undefined ? { timeouts: options.timeouts } : {}
+    catalogDir: options.catalogDir,
+    generators: options.generators
   });
-  return createClient(options.schema, pool, { ...shared, ownsPool: true });
 }
 function isPool(target) {
   return typeof target === "object" && target !== null && "execute" in target && "capabilities" in target;