okmodel 0.7.0 → 0.8.0

package/dist/dialects/pg/view/client.d.ts

@@ -28,21 +28,29 @@ export declare function viewMentions(query: string, name: string): boolean;
 export type ViewInstall = (model: {
     [name: string]: TableModel;
 }, tenancy: ColumnTenancy | undefined, tables: readonly AnyTable[], casing: "snake" | undefined, scoped: Set<string>) => void;
+/** A value, or a function `install` calls once casing is known. */
+type ColumnSource = readonly {
+    readonly name: string;
+    readonly type: string;
+}[] | (() => readonly {
+    readonly name: string;
+    readonly type: string;
+}[]);
+/** A query string, or a function `install` calls once casing is known. */
+type QuerySource = string | (() => string);
 /**
  * Client name, read model, and the hook that moves the handle under `views`.
  *
  * @param name - SQL name of the view
- * @param columns - Declared output columns
- * @param query - Author SQL
+ * @param columns - Declared output columns, or a getter `install` calls
+ * @param query - Author SQL, or a getter `install` calls
  * @param tenancy - `global("reason")`, when the view opts out
  * @param refresh - `plain` stores no `refresh`. A materialized view is `blocking` or `concurrently`
  * @returns Methods stored on the declaration
  */
-export declare function viewClient(name: string, columns: readonly {
-    readonly name: string;
-    readonly type: string;
-}[], query: string, tenancy: unknown, refresh?: "plain" | "blocking" | "concurrently"): {
+export declare function viewClient(name: string, columns: ColumnSource, query: QuerySource, tenancy: unknown, refresh?: "plain" | "blocking" | "concurrently"): {
     readonly field: string;
     readonly install: ViewInstall;
     readonly hook: SchemaHook;
 };
+export {};

package/dist/dialects/pg/view/index.d.ts

@@ -8,7 +8,7 @@
  */
 import type { CatalogObject } from "../../../contracts/catalog/types.js";
 import type { SchemaHook } from "../model.js";
-import type { SqlText } from "../table.js";
+import { type AnyTable, type SqlText } from "../table.js";
 import { type ViewInstall } from "./client.js";
 /** One declared output column. `type` is the Postgres type name. */
 export type ViewColumnInput = {
@@ -29,6 +29,66 @@ export type ViewOptions = {
      */
     readonly tenancy?: unknown;
 };
+/** Output columns of {@link ViewFrom.from}. A tuple keeps each name. */
+type TupleColumns<K extends readonly string[]> = K extends readonly [] ? readonly [] : K extends readonly [infer H extends string, ...infer R extends readonly string[]] ? readonly [{
+    readonly name: H;
+    readonly type: string;
+}, ...TupleColumns<R>] : readonly {
+    readonly name: K[number];
+    readonly type: string;
+}[];
+/** Every column of a table, when `from` is not given a list. */
+type AllColumns<T extends AnyTable> = readonly {
+    readonly name: keyof T["columns"] & string;
+    readonly type: string;
+}[];
+/**
+ * The value `(q) => q.from(...)` returns.
+ *
+ * @typeParam C - Output columns, for `db.views`
+ */
+export type ViewBuilt<C extends readonly ViewColumnInput[] = readonly ViewColumnInput[]> = {
+    /** Declared columns. Present for the type. The catalog uses the SQL names. */
+    readonly "~columns"?: C;
+    /**
+     * Adds a WHERE clause.
+     *
+     * The text is stored as written, the same way `query` is.
+     *
+     * @param predicate - SQL after `where`
+     * @returns The same view, with the clause
+     */
+    where(predicate: SqlText | string): ViewBuilt<C>;
+    /**
+     * Opts the view out of tenancy.
+     *
+     * Pass `global("reason")` from `okmodel/tenancy`.
+     *
+     * @param mark - `global("reason")`
+     * @returns The same view, opted out
+     */
+    tenancy(mark: unknown): ViewBuilt<C>;
+};
+/**
+ * The argument of `view(name, (q) => q.from(...))`.
+ */
+export type ViewFrom = {
+    /**
+     * Selects every column of `table`.
+     *
+     * @param table - Source table
+     * @returns The view query
+     */
+    from<const T extends AnyTable>(table: T): ViewBuilt<AllColumns<T>>;
+    /**
+     * Selects `columns` from `table`, in that order.
+     *
+     * @param table - Source table
+     * @param columns - Output columns. Names are the table's fields
+     * @returns The view query
+     */
+    from<const T extends AnyTable, const K extends readonly (keyof T["columns"] & string)[]>(table: T, columns: K): ViewBuilt<TupleColumns<K>>;
+};
 /**
  * One declared view.
  *
@@ -117,6 +177,17 @@ export type MaterializedViewDeclaration<N extends string = string, C extends rea
 export declare function view<const N extends string, const C extends readonly ViewColumnInput[]>(name: N, options: ViewOptions & {
     readonly columns: C;
 }): ViewDeclaration<N, C>;
+/**
+ * Declares a view from a table.
+ *
+ * `view(name, (q) => q.from(table))` selects that table's columns. Pass a
+ * column list to project. `.where` adds a predicate. `.tenancy` opts out.
+ *
+ * @param name - View name
+ * @param build - `q.from(...)`
+ * @returns The definition object `schema({ views })` stores
+ */
+export declare function view<const N extends string, const C extends readonly ViewColumnInput[]>(name: N, build: (q: ViewFrom) => ViewBuilt<C>): ViewDeclaration<N, C>;
 /**
  * Declares a materialized view.
  *
@@ -130,3 +201,4 @@ export declare function view<const N extends string, const C extends readonly Vi
 export declare function materializedView<const N extends string, const C extends readonly ViewColumnInput[]>(name: N, options: MaterializedViewOptions & {
     readonly columns: C;
 }): MaterializedViewDeclaration<N, C>;
+export {};

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

@@ -1,11 +1,20 @@
-import {
-  viewClient
-} from "../../../shared/5e3tf63j.js";
 import {
   viewObject,
   materializedViewObject,
   materializedViewIndex
-} from "../../../shared/zy8r7qvz.js";
+} from "../../../shared/12z7aznj.js";
+import {
+  viewClient
+} from "../../../shared/760ppr76.js";
+import {
+  snakeCase
+} from "../../../shared/gcefca6p.js";
+import {
+  formatType
+} from "../../../shared/606g0nbf.js";
+import {
+  quoteIdent
+} from "../../../shared/sjk86yrx.js";
 import {
   staticNamespace2
 } from "../../../shared/358zsv4r.js";
@@ -14,7 +23,11 @@ import {
 } from "../../../shared/52szzakm.js";
 
 // src/dialects/pg/view/index.ts
-function view(name, options) {
+var BUILT = Symbol("okmodel.view.from");
+function view(name, source) {
+  if (typeof source === "function")
+    return viewFrom(name, source);
+  const options = source;
   const schema = options.schema ?? "public";
   const columns = options.columns.map((column) => ({ name: column.name, dataType: column.type }));
   const query = bodyText(options.query);
@@ -100,6 +113,144 @@ function materializedView(name, options) {
     }
   };
 }
+var viewFromApi = {
+  from(table, columns) {
+    return finish({
+      [BUILT]: true,
+      table,
+      picked: columns,
+      predicate: undefined,
+      mark: undefined
+    });
+  }
+};
+function viewFrom(name, build) {
+  const built = build(viewFromApi);
+  if (!isRecipe(built)) {
+    throw new OkmError2("OKM1121", `View ${name} must return q.from(...).`, {
+      fix: { summary: "Return q.from(table), and chain where() or tenancy() on that value." }
+    });
+  }
+  const recipe = built;
+  let casingMode;
+  let rendered;
+  const render = () => {
+    rendered ??= renderQuery(name, recipe, casingMode);
+    return rendered;
+  };
+  const bound = viewClient(name, () => render().columns, () => render().query, recipe.mark, "plain");
+  let securityInvoker = false;
+  return {
+    name,
+    schema: "public",
+    "~kind": "view",
+    install(model, tenancy, tables, casing, scoped) {
+      casingMode = casing;
+      rendered = undefined;
+      bound.install(model, tenancy, tables, casing, scoped);
+      securityInvoker = tenancy?.strategy === "rls" && scoped.has(name);
+    },
+    hook: bound.hook,
+    contribute(peers, builtObjects) {
+      assertPeers(peers);
+      assertNoTable(builtObjects, name);
+      const query = render().query;
+      const columns = render().columns.map((column) => ({
+        name: column.name,
+        dataType: column.type
+      }));
+      const provenance = { origin: "file", name };
+      return [
+        viewObject({
+          namespace: staticNamespace2("public"),
+          name,
+          columns,
+          query,
+          provenance,
+          ...securityInvoker ? { securityInvoker: true } : {}
+        })
+      ];
+    }
+  };
+}
+function isRecipe(value) {
+  return typeof value === "object" && value !== null && BUILT in value;
+}
+function finish(recipe) {
+  const built = {
+    ...recipe,
+    where(predicate) {
+      return finish({ ...recipe, predicate: bodyText(predicate) });
+    },
+    tenancy(mark) {
+      return finish({ ...recipe, mark });
+    }
+  };
+  return built;
+}
+function renderQuery(name, recipe, casing) {
+  const fields = recipe.picked ?? Object.keys(recipe.table.columns);
+  if (fields.length === 0) {
+    throw new OkmError2("OKM1120", `View ${name} selects no columns.`, {
+      fix: { summary: "Pick at least one column of the table." }
+    });
+  }
+  const columns = [];
+  const selected = [];
+  for (const field of fields) {
+    const column = recipe.table.columns[field];
+    if (column === undefined || typeof column !== "object" || column === null) {
+      throw new OkmError2("OKM1020", `View ${name} names ${field}, which ${recipe.table.name} does not have.`, { fix: { summary: "Pass a column of that table." } });
+    }
+    const sqlName = columnSql(column, field, casing);
+    columns.push({ name: sqlName, type: columnType(column, field) });
+    selected.push(quoteIdent(sqlName));
+  }
+  const tableName = tableSql(recipe.table, casing);
+  let query = `select ${selected.join(", ")} from ${quoteIdent(tableName)}`;
+  if (recipe.predicate !== undefined && recipe.predicate.trim().length > 0) {
+    query += ` where ${recipe.predicate}`;
+  }
+  return { query, columns };
+}
+function tableSql(table, casing) {
+  const options = table.options;
+  if (typeof options?.sqlName === "string" && options.sqlName.length > 0)
+    return options.sqlName;
+  return casing === "snake" ? snakeCase(table.name) : table.name;
+}
+function columnSql(column, field, casing) {
+  const state = readState(column, field);
+  if (state.sqlName !== undefined && state.sqlName.length > 0)
+    return state.sqlName;
+  return casing === "snake" ? snakeCase(field) : field;
+}
+function columnType(column, field) {
+  const state = readState(column, field);
+  return formatType(state.baseType, state.dims);
+}
+function readState(column, field) {
+  if (!("state" in column)) {
+    throw new OkmError2("OKM1020", `Column ${field} has no type.`, {
+      fix: { summary: "Pass a column built with t." }
+    });
+  }
+  const state = column.state;
+  if (typeof state !== "object" || state === null || !("baseType" in state)) {
+    throw new OkmError2("OKM1020", `Column ${field} has no type.`, {
+      fix: { summary: "Pass a column built with t." }
+    });
+  }
+  const baseType = state.baseType;
+  const dims = "dims" in state && typeof state.dims === "number" ? state.dims : 0;
+  const sqlName = "sqlName" in state && typeof state.sqlName === "string" ? state.sqlName : undefined;
+  if (typeof baseType !== "string" || baseType.length === 0) {
+    throw new OkmError2("OKM1020", `Column ${field} has no type.`, {
+      fix: { summary: "Pass a column built with t." }
+    });
+  }
+  return { baseType, dims, sqlName };
+}
 function bodyText(body) {
   return typeof body === "string" ? body : body.text;
 }

package/dist/dialects/pg/view/scratch.d.ts

@@ -4,19 +4,22 @@
  * Domain and enum types from the catalog are created there, then the tables,
  * then the functions a view may call, then each view. `pg_get_viewdef`
  * replaces the author query and `pg_depend` supplies column edges (D117).
- * The scratch schema is dropped before this returns. Plans never use it.
+ * A `BEGIN ATOMIC` body is replaced with the `pg_get_functiondef` block, so a
+ * plan from the live catalog does not treat Postgres's reprint as a change
+ * (D273). The scratch schema is dropped before this returns. Plans never use it.
  */
 import type { Catalog } from "../../../contracts/catalog/types.js";
-import type { CatalogQuery } from "../introspect.js";
+import { type CatalogQuery } from "../introspect.js";
 /**
  * Reads dependencies and reprints for every view in `source`.
  *
  * The returned catalog matches what introspection prints for those views
  * when the same query is applied. A declared column list that disagrees
- * with the database is OKM1020.
+ * with the database is OKM1020. A `BEGIN ATOMIC` function body is the
+ * server reprint, including an argument qualifier such as `by_id.n`.
  *
  * @param runner - Database connection. Statements share its session
- * @param source - Catalog whose views are still author SQL
- * @returns A catalog whose views carry the reprint and `pg_depend` edges
+ * @param source - Catalog whose views and atomic bodies are still author SQL
+ * @returns A catalog whose views and atomic bodies carry the reprint
  */
 export declare function sealViews(runner: CatalogQuery, source: Catalog): Promise<Catalog>;

package/dist/runtime/otel.d.ts

@@ -0,0 +1,105 @@
+/**
+ * OpenTelemetry observers (`okmodel/otel`).
+ *
+ * The package does not import `@opentelemetry/*`. Pass a tracer you already
+ * have. The observers are `hookm`, `onRoute`, and an `inspect()` result.
+ * Statement text is off unless `statement` is true. Parameters and tenant ids
+ * are never attributes (spec §5.5, D267).
+ */
+import type { RouteEvent } from "./topology.js";
+import type { Hookm, Inspection } from "./types.js";
+/** A scalar OpenTelemetry attribute. Arrays are not used. */
+export type OtelAttribute = string | number | boolean;
+/**
+ * Status codes from the OpenTelemetry API.
+ *
+ * `0` is unset, `1` is OK, and `2` is ERROR.
+ */
+export type OtelStatusCode = 0 | 1 | 2;
+/**
+ * The span methods this entry calls.
+ *
+ * A tracer from `@opentelemetry/api` satisfies this shape.
+ */
+export interface OtelSpan {
+    /** Sets one attribute. */
+    setAttribute(key: string, value: OtelAttribute): void;
+    /** Sets the span status. `message` is never sent. */
+    setStatus(status: {
+        readonly code: OtelStatusCode;
+    }): void;
+    /**
+     * Records an exception.
+     *
+     * `name` is the error name. `code` is an OKM code when the error has one.
+     * Message and stack are omitted.
+     */
+    recordException(exception: {
+        readonly name: string;
+        readonly code?: string;
+    }): void;
+    /** Adds a span event. */
+    addEvent(name: string, attributes?: Readonly<Record<string, OtelAttribute>>): void;
+    /** Ends the span. */
+    end(): void;
+}
+/** Options passed to `startSpan`. `kind` is `2` (client). */
+export interface OtelSpanOptions {
+    /** OpenTelemetry span kind. This entry always passes `2`. */
+    readonly kind?: number;
+    /** Attributes set when the span starts. */
+    readonly attributes?: Readonly<Record<string, OtelAttribute>>;
+}
+/**
+ * The tracer methods this entry calls.
+ *
+ * A tracer from `@opentelemetry/api` satisfies this shape.
+ */
+export interface OtelTracer {
+    /**
+     * Starts a span.
+     *
+     * @param name - Span name
+     * @param options - Kind and attributes
+     */
+    startSpan(name: string, options?: OtelSpanOptions): OtelSpan;
+}
+/** What {@link otel} accepts. */
+export interface OtelOptions {
+    /** Tracer the caller owns. This module does not construct one. */
+    readonly tracer: OtelTracer;
+    /**
+     * Record `db.query.text` from `inspect()`.
+     *
+     * Omitted or false, the text is left off. Parameters stay off either way.
+     */
+    readonly statement?: boolean;
+}
+/**
+ * Observers to pass to `connect`, plus `query` for one `inspect()` result.
+ */
+export interface OtelObservers {
+    /** Pass this in `connect({ hookm })`. */
+    readonly hookm: Hookm;
+    /** Pass this in `connect({ onRoute })`. A topology calls it. */
+    readonly onRoute: (event: RouteEvent) => void;
+    /**
+     * Records `db.query.summary` from `inspect()`.
+     *
+     * The fingerprint is that summary. `db.query.text` is included only when
+     * `statement` is true.
+     *
+     * @param inspection - The result of `inspect()`
+     */
+    readonly query: (inspection: Inspection) => void;
+}
+/**
+ * Connects the existing observers to a tracer.
+ *
+ * `onRoute` spans start and end in that call, because the hook fires once.
+ * A transaction span stays open from `start` until `commit` or `rollback`.
+ *
+ * @param options - Tracer, and whether statement text is recorded
+ * @returns `hookm`, `onRoute`, and `query`
+ */
+export declare function otel(options: OtelOptions): OtelObservers;

package/dist/runtime/otel.js

@@ -0,0 +1,97 @@
+// src/runtime/otel.ts
+var SYSTEM = "postgresql";
+var CLIENT = 2;
+var STATUS_OK = 1;
+var STATUS_ERROR = 2;
+function otel(options) {
+  const tracer = options.tracer;
+  const statement = options.statement === true;
+  const open = [];
+  const hookm = {
+    onTransaction(event) {
+      if (event.phase === "start") {
+        const name = event.depth === 0 ? "transaction" : "savepoint";
+        open.push({
+          depth: event.depth,
+          span: begin(tracer, name, {
+            "db.system.name": SYSTEM,
+            "db.operation.name": name
+          })
+        });
+        return;
+      }
+      const index = latest(open, event.depth);
+      const found = index < 0 ? undefined : open[index];
+      if (found === undefined)
+        return;
+      open.splice(index, 1);
+      if (event.phase === "rollback") {
+        found.span.setAttribute("error.type", "rollback");
+        found.span.setStatus({ code: STATUS_ERROR });
+      } else {
+        found.span.setStatus({ code: STATUS_OK });
+      }
+      found.span.end();
+    },
+    onError(error) {
+      const span = begin(tracer, "error", {
+        "db.system.name": SYSTEM,
+        "error.type": errorType(error)
+      });
+      span.recordException(recordedException(error));
+      span.setStatus({ code: STATUS_ERROR });
+      span.end();
+    }
+  };
+  return {
+    hookm,
+    onRoute(event) {
+      const span = begin(tracer, event.op, {
+        "db.system.name": SYSTEM,
+        "db.operation.name": event.op
+      });
+      span.addEvent("route", { endpoint: event.endpoint, reason: event.reason });
+      span.end();
+    },
+    query(inspection) {
+      const op = inspection.intent.op;
+      const table = inspection.intent.table;
+      const attributes = {
+        "db.system.name": SYSTEM,
+        "db.operation.name": op,
+        "db.collection.name": table,
+        "db.query.summary": inspection.plan.fingerprint
+      };
+      if (statement)
+        attributes["db.query.text"] = inspection.sql.text;
+      begin(tracer, `${op} ${table}`, attributes).end();
+    }
+  };
+}
+function begin(tracer, name, attributes) {
+  return tracer.startSpan(name, { kind: CLIENT, attributes });
+}
+function latest(open, depth) {
+  for (let index = open.length - 1;index >= 0; index -= 1) {
+    if (open[index]?.depth === depth)
+      return index;
+  }
+  return -1;
+}
+function errorType(error) {
+  return error instanceof Error && error.name.length > 0 ? error.name : "error";
+}
+function recordedException(error) {
+  const name = errorType(error);
+  const code = okmCode(error);
+  return code === undefined ? { name } : { name, code };
+}
+function okmCode(error) {
+  if (typeof error !== "object" || error === null || !("code" in error))
+    return;
+  const code = error.code;
+  return typeof code === "string" && /^OKM\d+$/.test(code) ? code : undefined;
+}
+export {
+  otel
+};

package/dist/runtime/pg/bun.js

@@ -4,20 +4,20 @@ import {
 import {
   markClientPool,
   open5
-} from "../../shared/x933k9a3.js";
+} from "../../shared/zbqbmmrp.js";
 import {
   BUNSQL_CAPABILITIES,
   readCapability2,
   hasCapability2
-} from "../../shared/kb2sdhfb.js";
+} from "../../shared/ae4j5f42.js";
 import {
   createClient
-} from "../../shared/tbrvgw6z.js";
+} from "../../shared/bah9nbg3.js";
 
 // src/runtime/pg/bun.ts
 function connect(target, options) {
   if (typeof target === "object" && !isPool(target)) {
-    return import("../../shared/mtaszv5a.js").then((mod) => mod.default(target, options, (config) => {
+    return import("../../shared/0wrea3jq.js").then((mod) => mod.default(target, options, (config) => {
       const pool = open5(config);
       markClientPool(pool);
       return pool;

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

@@ -0,0 +1,38 @@
+/**
+ * `connect` for Neon (`okmodel/pg/neon`).
+ *
+ * A string or an existing pool is one endpoint. A `{ primary, replicas }` object
+ * loads the topology module. The client is typed by the schema passed in.
+ * `mode` is `websocket` (the default) or `http`.
+ */
+import type { DriverPool } from "../../contracts/driver.js";
+import type { QuerySchema } from "../../dialects/pg/model.js";
+import { type NeonConfig } from "../../adapters/pg/neon.js";
+import type { RoutedClient, TopologyInput, TopologyOptions } from "../topology.js";
+import type { ConnectOptions, Connected } from "../types.js";
+export { open, type NeonConfig, type NeonMode } from "../../adapters/pg/neon.js";
+export { capabilities, hasCapability, httpCapabilities, readCapability, } from "../../adapters/pg/neon.js";
+export { DriverError } from "../../adapters/error.js";
+/** A connection string or a pool from {@link open}. */
+export type NeonTarget = string | DriverPool;
+/** Driver options `connect` forwards to {@link open}. */
+export type NeonConnectOptions<S extends QuerySchema> = ConnectOptions<S> & Omit<NeonConfig, "url"> & TopologyOptions;
+/**
+ * Connects one Neon endpoint, or a primary and its replicas.
+ *
+ * A string or a pool is one endpoint. A topology loads on demand and the promise
+ * resolves to the client. Reads use the first healthy replica.
+ *
+ * `mode: "websocket"` is the default. Interactive `tx()` needs it. `mode: "http"`
+ * is one-shot HTTP: `batch()` is atomic and `tx()` is refused.
+ *
+ * Named prepared statements are off unless `prepared` is `"named"`.
+ * `prepared: "named"` is not for transaction-mode poolers.
+ *
+ * @typeParam S - Schema
+ * @param target - URL, an existing pool, or `{ primary, replicas }`
+ * @param options - Schema, mode, errors, logger, and driver options
+ * @returns The client. A topology returns a promise. Await `connected` for the dialect check
+ */
+export declare function connect<const S extends QuerySchema>(target: TopologyInput, options: NeonConnectOptions<S>): Promise<RoutedClient<S>>;
+export declare function connect<const S extends QuerySchema>(target: NeonTarget, options: NeonConnectOptions<S>): Promise<Connected<S>>;

package/dist/runtime/pg/neon.js

@@ -0,0 +1,64 @@
+import {
+  DriverError2
+} from "../../shared/cm3w0ywp.js";
+import {
+  open6
+} from "../../shared/agsfb86s.js";
+import {
+  NEON_WEBSOCKET_CAPABILITIES,
+  NEON_HTTP_CAPABILITIES,
+  readCapability2,
+  hasCapability2
+} from "../../shared/ae4j5f42.js";
+import {
+  createClient
+} from "../../shared/bah9nbg3.js";
+
+// src/runtime/pg/neon.ts
+function connect(target, options) {
+  if (typeof target === "object" && !isPool(target)) {
+    return import("../../shared/0wrea3jq.js").then((mod) => mod.default(target, options, (config) => open6({
+      url: config.url,
+      ...options.mode !== undefined ? { mode: options.mode } : {},
+      ...config.max !== undefined ? { max: config.max } : {},
+      ...config.timeouts !== undefined ? { timeouts: config.timeouts } : {},
+      ...config.prepared !== undefined ? { prepared: config.prepared } : {},
+      ...config.searchPath !== undefined ? { searchPath: config.searchPath } : {}
+    })));
+  }
+  const owned = !isPool(target);
+  const opened = isPool(target) ? Promise.resolve(target) : open6({
+    url: target,
+    ...options.mode !== undefined ? { mode: options.mode } : {},
+    ...options.max !== undefined ? { max: options.max } : {},
+    ...options.timeouts !== undefined ? { timeouts: options.timeouts } : {},
+    ...options.prepared !== undefined ? { prepared: options.prepared } : {},
+    ...options.searchPath !== undefined ? { searchPath: options.searchPath } : {}
+  });
+  return opened.then((pool) => 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,
+  NEON_WEBSOCKET_CAPABILITIES as capabilities,
+  connect,
+  hasCapability2 as hasCapability,
+  NEON_HTTP_CAPABILITIES as httpCapabilities,
+  open6 as open,
+  readCapability2 as readCapability
+};