okmodel 0.2.1 → 0.3.0

package/dist/shared/th14ygv2.js

@@ -0,0 +1,69 @@
+import {
+  normaliseEdges,
+  assertProvenance
+} from "./t4tbsy9h.js";
+import {
+  assertIdentifier2
+} from "./nfzc5z0w.js";
+import {
+  catalogError2
+} from "./52szzakm.js";
+
+// src/contracts/catalog/extension.ts
+function extensionObject(input) {
+  assertIdentifier2(input.name, "extension");
+  assertIdentifier2(input.schema, "extension schema");
+  assertProvenance(input.provenance);
+  assertVersion(input.version);
+  const definition = {
+    schema: input.schema,
+    relocatable: input.relocatable ?? true,
+    ...input.version !== undefined ? { version: input.version } : {}
+  };
+  return {
+    kind: "extension",
+    identity: { kind: "extension", name: input.name },
+    owner: input.owner ?? "managed",
+    definition,
+    dependencies: normaliseEdges(input.dependencies ?? []),
+    provenance: input.provenance
+  };
+}
+function isExactVersion(version) {
+  return version !== undefined && /^\d+(?:\.\d+)*$/.test(version);
+}
+function compareExtensionVersions(left, right) {
+  const a = parts(left);
+  const b = parts(right);
+  const length = Math.max(a.length, b.length);
+  for (let index = 0;index < length; index += 1) {
+    const diff = (a[index] ?? 0) - (b[index] ?? 0);
+    if (diff !== 0)
+      return diff < 0 ? -1 : 1;
+  }
+  return 0;
+}
+function sameExtensionDefinition(before, after) {
+  if (before.definition.schema !== after.definition.schema)
+    return false;
+  if (before.definition.relocatable !== after.definition.relocatable)
+    return false;
+  return sameVersion(before.definition.version, after.definition.version);
+}
+function sameVersion(before, after) {
+  if (!isExactVersion(after) || !isExactVersion(before))
+    return true;
+  return before === after;
+}
+function assertVersion(version) {
+  if (version === undefined)
+    return;
+  if (isExactVersion(version) || /^>=\d+(?:\.\d+)*$/.test(version))
+    return;
+  catalogError2("OKM1020", `Extension version ${String(version)} must be a dotted version or a >= floor.`);
+}
+function parts(version) {
+  return version.split(".").map((part) => Number(part));
+}
+
+export { extensionObject, isExactVersion, compareExtensionVersions, sameExtensionDefinition };

package/dist/shared/{xatfg0gn.js → tmbdywx0.js}

@@ -1,3 +1,6 @@
+import {
+  arrayElement
+} from "./94ez8kzh.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -16,24 +19,6 @@ function rejected(message) {
   throw new OkmError2(CODEC_VALUE_CODE, message);
 }
 
-// src/dialects/pg/quote.ts
-function quoteLiteral(value) {
-  return `'${value.replaceAll("'", "''")}'`;
-}
-function arrayElement(encoded, raw) {
-  if (raw && (encoded === "true" || encoded === "false" || isBareNumber(encoded))) {
-    return encoded;
-  }
-  return `"${encoded.replaceAll("\\", "\\\\").replaceAll('"', "\\\"")}"`;
-}
-function isBareNumber(encoded) {
-  let pattern = bareNumber;
-  pattern ??= /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
-  bareNumber = pattern;
-  return pattern.test(encoded);
-}
-var bareNumber;
-
 // src/dialects/pg/array-literal.ts
 function writeArray(value, dims, encode, raw) {
   return writeLevel(value, dims, encode, raw);
@@ -190,4 +175,4 @@ function isSpace(char) {
 ` || char === "\t";
 }
 
-export { definition, unavailable, rejected, quoteLiteral, writeArray, readArray };
+export { definition, unavailable, rejected, writeArray, readArray };

package/dist/shared/{ge03bfca.js → ty3v3hfk.js}

@@ -1,7 +1,7 @@
 import {
   withHttp,
   attachHttp
-} from "./mxmcdsh5.js";
+} from "./k34e0xf2.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -31,7 +31,7 @@ async function acceptServer(pool, schema, rows, http, requireMeta, options, sour
       }));
     }
   } else {
-    const { assertCompatible } = await import("./sfh4pk75.js");
+    const { assertCompatible } = await import("./fptpmvxp.js");
     try {
       await assertCompatible(pool, schema, recorded, source, options);
     } catch (error) {

package/dist/shared/wekze34d.js

@@ -0,0 +1,246 @@
+import {
+  isDomain
+} from "./qbxzvwwc.js";
+import {
+  quoteLiteral
+} from "./94ez8kzh.js";
+import {
+  identityKey2
+} from "./t4tbsy9h.js";
+import {
+  fitIdentifier2
+} from "./nfzc5z0w.js";
+
+// src/dialects/pg/ddl.ts
+function quoteIdent(name) {
+  return `"${name.replaceAll('"', '""')}"`;
+}
+function ownedByView(object) {
+  if (object.kind !== "index")
+    return false;
+  return object.dependencies.some((edge) => edge.target.kind === "view" || edge.target.kind === "materializedView");
+}
+function dropObjectSql(object, schema) {
+  if (object.owner === "ignored")
+    return;
+  switch (object.kind) {
+    case "table":
+      return `drop table ${qualify(schema, object.identity.name)}`;
+    case "column":
+      return `alter table ${qualify(schema, object.identity.parent.name)} drop column ${quoteIdent(object.identity.name)}`;
+    case "index":
+      return `drop index ${qualify(schema, object.identity.name)}`;
+    case "constraint":
+      return `alter table ${qualify(schema, object.identity.parent.name)} drop constraint ${quoteIdent(object.identity.name)}`;
+    case "sequence":
+      return `drop sequence ${qualify(schema, object.identity.name)}`;
+    case "type":
+      return `drop type ${qualify(schema, object.identity.name)}`;
+    case "extension":
+      return `drop extension ${quoteIdent(object.identity.name)}`;
+    case "function":
+      return `drop function ${qualify(schema, object.identity.name)}(${object.identity.argTypes.join(", ")})`;
+    case "trigger":
+      return `drop trigger ${quoteIdent(object.identity.name)} on ${qualify(schema, object.identity.parent.name)}`;
+    case "view":
+      return `drop view ${qualify(schema, object.identity.name)}`;
+    case "materializedView":
+      return `drop materialized view ${qualify(schema, object.identity.name)}`;
+    default:
+      return;
+  }
+}
+function createObjectSql(object, schema) {
+  switch (object.kind) {
+    case "column":
+      return `alter table ${qualify(schema, object.identity.parent.name)} add column ${columnSql(object)}`;
+    case "index":
+      return createIndexSql(object, schema);
+    case "constraint":
+      return `alter table ${qualify(schema, object.identity.parent.name)} add constraint ${quoteIdent(object.identity.name)} ${constraintBody(object, schema)}`;
+    case "sequence":
+      return createSequenceSql(object, schema);
+    case "type":
+      return createTypeSql(object, schema);
+    case "extension":
+      return createExtensionSql(object);
+    case "function":
+      return functionSql(object, schema, false);
+    case "trigger":
+      return triggerSql(object, schema);
+    case "view":
+      return viewSql(object, schema, false);
+    case "materializedView":
+      return materializedViewSql(object, schema);
+    case "table":
+      return;
+    default:
+      return;
+  }
+}
+function functionSql(object, schema, replace) {
+  const definition = object.definition;
+  const args = definition.arguments.map((argument) => `${quoteIdent(argument.name)} ${argument.type}`).join(", ");
+  const head = `${replace ? "create or replace" : "create"} function ${qualify(schema, object.identity.name)}(${args})`;
+  const security = ` security ${definition.security}`;
+  const path = definition.searchPath === undefined ? "" : ` set search_path to ${definition.searchPath}`;
+  const tail = `returns ${definition.returns} language ${definition.language} ${definition.volatility}${security}${path}`;
+  if (definition.atomic)
+    return `${head} ${tail} ${definition.body}`;
+  return `${head} ${tail} as ${dollarQuote(definition.body)}`;
+}
+function viewSql(object, schema, replace) {
+  const verb = replace ? "create or replace view" : "create view";
+  return `${verb} ${qualify(schema, object.identity.name)} as ${object.definition.query}`;
+}
+function materializedViewSql(object, schema) {
+  return `create materialized view ${qualify(schema, object.identity.name)} as ${object.definition.query} with no data`;
+}
+function refreshMaterializedViewSql(object, schema, populated = false) {
+  const concurrently = populated && object.definition.refresh === "concurrently" ? " concurrently" : "";
+  return `refresh materialized view${concurrently} ${qualify(schema, object.identity.name)}`;
+}
+function triggerSql(object, schema) {
+  const definition = object.definition;
+  const timing = definition.timing === "instead" ? "instead of" : definition.timing;
+  const events = definition.events.map((event) => {
+    if (event !== "update" || definition.updateOf === undefined)
+      return event;
+    return `update of ${definition.updateOf.map((column) => quoteIdent(column)).join(", ")}`;
+  }).join(" or ");
+  const when = definition.when === undefined ? "" : ` when (${definition.when})`;
+  const args = definition.calls.argTypes.join(", ");
+  const fn = `${qualify(schema, definition.calls.name)}(${args})`;
+  return `create trigger ${quoteIdent(object.identity.name)} ${timing} ${events} on ${qualify(schema, object.identity.parent.name)} for each ${definition.level}${when} execute function ${fn}`;
+}
+function dollarQuote(body) {
+  let tag = "okm";
+  while (body.includes(`$${tag}$`))
+    tag = `${tag}_`;
+  return `$${tag}$${body}$${tag}$`;
+}
+function alterColumnSql(before, after, schema) {
+  const statements = [];
+  const table = qualify(schema, after.identity.parent.name);
+  const name = quoteIdent(after.identity.name);
+  const typeChanged = before.definition.dataType !== after.definition.dataType;
+  const collationChanged = before.definition.collation !== after.definition.collation;
+  if (typeChanged || collationChanged) {
+    const using = typeChanged ? ` using ${name}::${after.definition.dataType}` : "";
+    statements.push(`alter table ${table} alter column ${name} set data type ${after.definition.dataType}${collateSql(after.definition.collation)}${using}`);
+  }
+  if (before.definition.nullable !== after.definition.nullable) {
+    statements.push(`alter table ${table} alter column ${name} ${after.definition.nullable ? "drop not null" : "set not null"}`);
+  }
+  if (before.definition.defaultExpression !== after.definition.defaultExpression) {
+    statements.push(after.definition.defaultExpression === undefined ? `alter table ${table} alter column ${name} drop default` : `alter table ${table} alter column ${name} set default ${after.definition.defaultExpression}`);
+  }
+  return statements;
+}
+function identitySequence(sequence, source) {
+  const key = identityKey2(sequence.identity);
+  return source.objects.some((object) => {
+    if (object.kind !== "column" || object.definition.identity === undefined)
+      return false;
+    return object.dependencies.some((edge) => identityKey2(edge.target) === key);
+  });
+}
+function createTableSql(tableObject, source, schema) {
+  const parent = tableObject.identity.name;
+  const columns = source.objects.filter((object) => object.kind === "column" && object.identity.parent.name === parent);
+  const primary = source.objects.find((object) => object.kind === "constraint" && object.definition.constraintKind === "primaryKey" && object.identity.parent.name === parent);
+  const lines = columns.map((column) => columnSql(column));
+  if (primary !== undefined) {
+    const cols = primary.definition.columns.map((name) => quoteIdent(name)).join(", ");
+    lines.push(`constraint ${quoteIdent(primary.identity.name)} primary key (${cols})`);
+  }
+  const partition = tableObject.definition.partition;
+  const tail = partition === undefined ? "" : ` partition by ${partition.method} (${partition.columns.map((name) => quoteIdent(name)).join(", ")})`;
+  return `create table ${qualify(schema, parent)} (
+  ${lines.join(`,
+  `)}
+)${tail}`;
+}
+function collateSql(collation) {
+  if (collation === undefined)
+    return "";
+  return ` collate ${quoteIdent(collation)}`;
+}
+function createTypeSql(object, schema) {
+  if (isDomain(object.definition)) {
+    const name = object.identity.name;
+    const constraint = quoteIdent(fitIdentifier2(`${name}_check`));
+    return `create domain ${qualify(schema, name)} as ${object.definition.base} constraint ${constraint} check (${object.definition.check})`;
+  }
+  const labels = object.definition.labels.map((label) => quoteLiteral(label)).join(", ");
+  return `create type ${qualify(schema, object.identity.name)} as enum (${labels})`;
+}
+function columnSql(column) {
+  const definition = column.definition;
+  let sql = `${quoteIdent(column.identity.name)} ${definition.dataType}${collateSql(definition.collation)}`;
+  if (definition.identity !== undefined) {
+    sql += definition.identity.always ? " generated always as identity" : " generated by default as identity";
+  } else if (definition.generated !== undefined) {
+    sql += ` generated always as (${definition.generated.expression}) stored`;
+  }
+  if (!definition.nullable)
+    sql += " not null";
+  if (definition.defaultExpression !== undefined)
+    sql += ` default ${definition.defaultExpression}`;
+  return sql;
+}
+function createIndexSql(object, schema) {
+  const unique = object.definition.unique ? "unique " : "";
+  const where = object.definition.predicate === undefined ? "" : ` where ${object.definition.predicate}`;
+  const expression = object.definition.expression;
+  const name = quoteIdent(object.identity.name);
+  const on = qualify(schema, object.identity.parent.name);
+  if (expression !== undefined && expression.startsWith("using ")) {
+    return `create ${unique}index ${name} on ${on} ${expression}${where}`;
+  }
+  const target = expression !== undefined ? `(${expression})` : object.definition.columns.map((column) => quoteIdent(column)).join(", ");
+  return `create ${unique}index ${name} on ${on} (${target})${where}`;
+}
+function createExtensionSql(object) {
+  const version = object.definition.version;
+  const pinned = version !== undefined && /^\d+(?:\.\d+)*$/.test(version) ? ` version ${quoteLiteral(version)}` : "";
+  return `create extension ${quoteIdent(object.identity.name)} schema ${quoteIdent(object.definition.schema)}${pinned}`;
+}
+function createSequenceSql(object, schema) {
+  const definition = object.definition;
+  const cycle = definition.cycle ? " cycle" : "";
+  return `create sequence ${qualify(schema, object.identity.name)} as ${definition.dataType} start ${definition.start} increment ${definition.increment}${cycle}`;
+}
+function constraintBody(object, schema) {
+  const definition = object.definition;
+  const columns = definition.columns.map((name) => quoteIdent(name)).join(", ");
+  switch (definition.constraintKind) {
+    case "primaryKey":
+      return `primary key (${columns})`;
+    case "unique": {
+      const nulls = definition.nullsNotDistinct ? " nulls not distinct" : "";
+      return `unique${nulls} (${columns})${deferClause(definition)}`;
+    }
+    case "check":
+      return `check (${definition.expression ?? "true"})${deferClause(definition)}`;
+    case "foreignKey": {
+      const references = definition.references;
+      const target = references === undefined ? "" : ` references ${qualify(schema, references.parent.name)} (${references.columns.map((name) => quoteIdent(name)).join(", ")})`;
+      const onDelete = references?.onDelete === undefined ? "" : ` on delete ${references.onDelete}`;
+      const onUpdate = references?.onUpdate === undefined ? "" : ` on update ${references.onUpdate}`;
+      return `foreign key (${columns})${target}${onDelete}${onUpdate}${deferClause(definition)}`;
+    }
+    default:
+      return definition.constraintKind;
+  }
+}
+function deferClause(definition) {
+  if (!definition.deferrable)
+    return "";
+  return ` deferrable initially ${definition.initially}`;
+}
+function qualify(schema, name) {
+  return `${quoteIdent(schema)}.${quoteIdent(name)}`;
+}
+
+export { quoteIdent, ownedByView, dropObjectSql, createObjectSql, functionSql, viewSql, refreshMaterializedViewSql, alterColumnSql, identitySequence, createTableSql, qualify };

package/dist/shared/{7mht49yd.js → x6wysh83.js}

@@ -1,29 +1,33 @@
 import {
-  encodeText,
-  decodeText
-} from "./sacqha1y.js";
+  catalog
+} from "./jkc6ws1p.js";
 import {
-  catalog,
   enumType,
   sameEnumLabels
-} from "./qxa0yb9j.js";
+} from "./qbxzvwwc.js";
 import {
   snakeCase,
   emittedTypeName,
   rejectLater
-} from "./x9v1qgeb.js";
+} from "./6w5j844a.js";
 import {
   withLocation
 } from "./k7dwkhvq.js";
+import {
+  encodeText,
+  decodeText
+} from "./4m9fn52z.js";
 import {
   ColumnBuilder2,
   formatType
-} from "./dd4f8mnx.js";
+} from "./c9z5g0fm.js";
 import {
   definition,
-  unavailable,
+  unavailable
+} from "./tmbdywx0.js";
+import {
   quoteLiteral
-} from "./xatfg0gn.js";
+} from "./94ez8kzh.js";
 import {
   staticNamespace2,
   table3,
@@ -221,19 +225,18 @@ var SCHEMA_KNOWN = new Set([
   "casing",
   "codecs",
   "defaults",
+  "extensions",
+  "functions",
   "requires",
   "tables",
   "tenancy",
   "traits",
+  "triggers",
   "types",
-  "validation"
+  "validation",
+  "views"
 ]);
-var SCHEMA_LATER = {
-  extensions: "0.3",
-  functions: "0.3",
-  triggers: "0.3",
-  views: "0.3"
-};
+var SCHEMA_LATER = {};
 var BIGINT_CODECS = new Set(["string", "number", "bigint"]);
 var NUMERIC_CODECS = new Set(["string", "number"]);
 function stage(jobs, build) {
@@ -250,7 +253,7 @@ function schema2(config) {
   }
   const casing = readCasing(config.casing);
   const tables = rewritePass(config.tables, tenancy, schemaTraits, casing);
-  const hooks = collectHooks(tenancy, schemaTraits, config.tables);
+  const hooks = collectHooks(tenancy, schemaTraits, config.tables, config.views);
   const types = readTypes(config.types);
   const codecs = readCodecs(config.codecs);
   const requires = readRequires(config.requires);
@@ -281,6 +284,7 @@ function schema2(config) {
   for (const item of prepared) {
     model[item.tsName] = tableModel(item, edges, byName, accepted);
   }
+  bindViews(config.views, model, tenancy, tables, casing);
   let document;
   return {
     get catalog() {
@@ -296,6 +300,14 @@ function schema2(config) {
             provenance: note.provenance
           }));
         }
+        contributeListed(config.extensions, objects);
+        contributeListed(config.functions, objects);
+        contributeListed(schemaTraits, objects);
+        for (const item of config.tables) {
+          contributeListed(item.options?.traits, objects);
+        }
+        contributeListed(config.triggers, objects);
+        contributeListed(config.views, objects);
         document = catalog(objects);
       }
       return document;
@@ -379,7 +391,7 @@ var registeredHooks = [];
 function addSchemaHook(hook) {
   registeredHooks.push(hook);
 }
-function collectHooks(tenancy, schemaTraits, tables) {
+function collectHooks(tenancy, schemaTraits, tables, views) {
   const found = [];
   const seen = new Set;
   const add = (value) => {
@@ -391,6 +403,12 @@ function collectHooks(tenancy, schemaTraits, tables) {
     seen.add(value);
     found.push(hook.bind(value));
   };
+  if (Array.isArray(views)) {
+    for (const item of views) {
+      if (typeof item === "object" && item !== null)
+        add(item);
+    }
+  }
   if (tenancy !== undefined)
     add(tenancy);
   if (schemaTraits !== undefined) {
@@ -410,6 +428,17 @@ function collectHooks(tenancy, schemaTraits, tables) {
     found.push(hook);
   return found.length === 0 ? undefined : found;
 }
+function bindViews(views, model, tenancy, tables, casing) {
+  if (!Array.isArray(views))
+    return;
+  const scoped = new Set;
+  for (const item of views) {
+    if (typeof item !== "object" || item === null)
+      continue;
+    const install = item.install;
+    install?.call(item, model, tenancy, tables, casing, scoped);
+  }
+}
 function archiveModel(item) {
   const archive = item.archiveModel;
   return archive === undefined ? undefined : { archive };
@@ -423,6 +452,16 @@ function bareTables(tables) {
   }
   return tables;
 }
+function contributeListed(value, objects) {
+  if (!Array.isArray(value))
+    return;
+  for (const item of value) {
+    const produced = item.contribute(value, objects);
+    if (Array.isArray(produced))
+      for (const object of produced)
+        objects.push(object);
+  }
+}
 function openSchemaTraits(value) {
   if (value === undefined)
     return;
@@ -650,6 +689,7 @@ function pushCompiled(objects, column, input) {
     objects.push(compiled.check);
   if (compiled.unique !== undefined)
     objects.push(compiled.unique);
+  column.state.domain?.emit?.(input.parent.namespace, input.provenance, objects);
 }
 function compileUniques(tableName, options, parent, provenance, byField, jobs) {
   const unique = options?.unique;
@@ -695,6 +735,7 @@ function compileIndexes(tableName, options, handles, parent, provenance, jobs) {
       unique: built.isUnique === true,
       nameKey: built.columns.join("_"),
       ...built.predicate !== undefined ? { predicate: built.predicate } : {},
+      ...built.expression !== undefined ? { expression: built.expression } : {},
       provenance
     }));
   }

package/dist/shared/{4jzzghr6.js → xva8v7qk.js}

@@ -2,24 +2,24 @@ import {
   assertOperatorFits,
   textArray,
   arrayElementType
-} from "./zt8y0wzb.js";
+} from "./n7mcc1gk.js";
+import {
+  touchFields,
+  fieldSealed,
+  sealingTrait
+} from "./7m88x3e9.js";
 import {
   runWrite
 } from "./n4jqhpqz.js";
 import {
   stack
 } from "./672t5vym.js";
-import {
-  touchFields,
-  fieldSealed,
-  sealingTrait
-} from "./7m88x3e9.js";
 import {
   writeWouldValidate
-} from "./3a5ne750.js";
+} from "./9m80mkac.js";
 import {
   encodeJson
-} from "./yw5c610b.js";
+} from "./gjthds9j.js";
 import {
   withRowFilters,
   archiveRules,

package/dist/shared/{ecdzej21.js → xw1d69vd.js}

@@ -6,7 +6,7 @@ import {
   runCall,
   EMPTY_NOTICES,
   resultFrom
-} from "./9k6vetvf.js";
+} from "./rrstp3kb.js";
 
 // src/adapters/pg/postgresjs.ts
 import net from "node:net";
@@ -117,7 +117,7 @@ function open2(config) {
     },
     async batch(statements, options) {
       return sockets.occupy(async () => {
-        const { checkout } = await import("./1dp5knt7.js");
+        const { checkout } = await import("./999ade2q.js");
         const connection = await checkout(held);
         try {
           return await connection.batch(statements, options);
@@ -129,12 +129,12 @@ function open2(config) {
     reserve() {
       const gate = sockets.busyGate();
       gate.enter();
-      return import("./1dp5knt7.js").then((mod) => mod.holdCheckout(gate, () => mod.checkout(held)), (error) => {
+      return import("./999ade2q.js").then((mod) => mod.holdCheckout(gate, () => mod.checkout(held)), (error) => {
         gate.leave();
         throw error;
       });
     },
-    describe: (text, params) => sockets.occupy(() => import("./1dp5knt7.js").then((mod) => mod.describe(sql, text, params))),
+    describe: (text, params) => sockets.occupy(() => import("./999ade2q.js").then((mod) => mod.describe(sql, text, params))),
     stream(text, params) {
       const gate = sockets.busyGate();
       return async function* () {
@@ -149,7 +149,7 @@ function open2(config) {
     listen(channel, onNotify) {
       const gate = sockets.listenerGate();
       gate.enter();
-      return import("./1dp5knt7.js").then((mod) => mod.holdListener(gate, async () => {
+      return import("./999ade2q.js").then((mod) => mod.holdListener(gate, async () => {
         const listening = await sql.listen(channel, onNotify);
         return async () => {
           await listening.unlisten();
@@ -219,7 +219,7 @@ class PgSession {
       onAbort();
     else
       watch.signal.addEventListener("abort", onAbort, { once: true });
-    return import("./1dp5knt7.js").then((mod) => mod.watchQuery(pending, watch, onAbort, {
+    return import("./999ade2q.js").then((mod) => mod.watchQuery(pending, watch, onAbort, {
       start,
       text,
       notices: this.notices,
@@ -271,7 +271,7 @@ class PgSession {
   }
 }
 async function* loadStream(sql, text, params) {
-  const { stream } = await import("./1dp5knt7.js");
+  const { stream } = await import("./999ade2q.js");
   yield* stream(sql, text, params);
 }
 function send(sql, text, params, named) {