okmodel 0.7.0 → 0.8.0

package/dist/shared/{qq3899ht.js → 12z7aznj.js}

@@ -1,18 +1,6 @@
 import {
   policyObject
 } from "./bdk4sty6.js";
-import {
-  functionObject,
-  triggerObject
-} from "./y34a8714.js";
-import {
-  viewObject,
-  materializedViewObject,
-  materializedViewIndex
-} from "./zy8r7qvz.js";
-import {
-  extensionObject
-} from "./r3j8s5y0.js";
 import {
   dependencyOrder,
   catalog,
@@ -20,10 +8,14 @@ import {
   domainType,
   isDomain
 } from "./ywspezzx.js";
+import {
+  extensionObject
+} from "./r3j8s5y0.js";
 import {
   canonicalJson,
   staticNamespace2,
   templateNamespace2,
+  assertNamespace2,
   identityKey2,
   identityLabel2,
   sameRef2,
@@ -48,7 +40,8 @@ import {
 import {
   sha2562,
   assertIdentifier2,
-  fitIdentifier2
+  fitIdentifier2,
+  deterministicName2
 } from "./nfzc5z0w.js";
 import {
   catalogError2
@@ -164,6 +157,242 @@ function defaultPrivilegeObject(input) {
   };
 }
 
+// src/contracts/catalog/routine.ts
+var VOLATILITY = new Set(["volatile", "stable", "immutable"]);
+var SECURITY = new Set(["invoker", "definer"]);
+var TIMING = new Set(["before", "after", "instead"]);
+var LEVEL = new Set(["row", "statement"]);
+var EVENT_ORDER = ["insert", "update", "delete", "truncate"];
+var TYPE_TEXT = /^[A-Za-z][A-Za-z0-9_ ]*(\(\d+(,\s*\d+)?\))?(\[\])*$/;
+function functionObject(input) {
+  assertIdentifier2(input.name, "function");
+  const namespace = input.namespace ?? staticNamespace2("public");
+  assertNamespace2(namespace);
+  assertProvenance(input.provenance);
+  if (input.language !== "sql" && input.language !== "plpgsql") {
+    catalogError2("OKM1020", `Function ${input.name} language must be sql or plpgsql.`);
+  }
+  const volatility = input.volatility ?? "volatile";
+  if (!VOLATILITY.has(volatility)) {
+    catalogError2("OKM1020", `Function ${input.name} volatility ${volatility} is not supported.`);
+  }
+  const security = input.security ?? "invoker";
+  if (!SECURITY.has(security)) {
+    catalogError2("OKM1020", `Function ${input.name} security ${security} is not supported.`);
+  }
+  assertTypeName(input.returns, `function ${input.name} return type`);
+  const args = (input.arguments ?? []).map((argument) => readArgument(input.name, argument));
+  if (input.body.length === 0) {
+    catalogError2("OKM1020", `Function ${input.name} needs a body.`);
+  }
+  const atomic = input.atomic === true;
+  if (atomic && input.language !== "sql") {
+    catalogError2("OKM1020", `Function ${input.name} BEGIN ATOMIC needs language sql.`);
+  }
+  if (input.searchPath !== undefined && input.searchPath.trim().length === 0) {
+    catalogError2("OKM1020", `Function ${input.name} search_path is empty.`);
+  }
+  const definition = {
+    arguments: args,
+    returns: input.returns,
+    language: input.language,
+    volatility,
+    security,
+    body: input.body,
+    ...input.searchPath !== undefined ? { searchPath: input.searchPath } : {},
+    ...atomic ? { atomic: true } : {}
+  };
+  return {
+    kind: "function",
+    identity: {
+      kind: "function",
+      namespace,
+      name: input.name,
+      argTypes: args.map((arg) => arg.type)
+    },
+    owner: input.owner ?? "managed",
+    definition,
+    dependencies: normaliseEdges(input.dependencies ?? []),
+    provenance: input.provenance
+  };
+}
+function triggerObject(input) {
+  assertIdentifier2(input.name, "trigger");
+  assertNamespace2(input.parent.namespace);
+  assertIdentifier2(input.parent.name, "trigger table");
+  assertProvenance(input.provenance);
+  if (!TIMING.has(input.timing)) {
+    catalogError2("OKM1020", `Trigger ${input.name} timing ${input.timing} is not supported.`);
+  }
+  if (!LEVEL.has(input.level)) {
+    catalogError2("OKM1020", `Trigger ${input.name} level ${input.level} is not supported.`);
+  }
+  const events = EVENT_ORDER.filter((event) => input.events.includes(event));
+  if (events.length === 0) {
+    catalogError2("OKM1020", `Trigger ${input.name} needs an event.`);
+  }
+  const updateOf = input.updateOf === undefined ? undefined : [...input.updateOf];
+  if (updateOf !== undefined) {
+    if (!events.includes("update")) {
+      catalogError2("OKM1020", `Trigger ${input.name} lists UPDATE OF columns without an update event.`);
+    }
+    if (input.level !== "row") {
+      catalogError2("OKM1020", `Trigger ${input.name} UPDATE OF columns need level row.`);
+    }
+    for (const column of updateOf)
+      assertIdentifier2(column, "trigger column");
+  }
+  assertIdentifier2(input.calls.name, "trigger function");
+  assertNamespace2(input.calls.namespace);
+  for (const typeName of input.calls.argTypes)
+    assertTypeName(typeName, `trigger ${input.name}`);
+  const edges = [
+    { kind: "table", namespace: input.parent.namespace, name: input.parent.name },
+    {
+      kind: "function",
+      namespace: input.calls.namespace,
+      name: input.calls.name,
+      argTypes: input.calls.argTypes
+    },
+    ...(updateOf ?? []).map((column) => ({
+      kind: "column",
+      parent: input.parent,
+      name: column
+    })),
+    ...input.dependencies ?? []
+  ];
+  const definition = {
+    timing: input.timing,
+    events,
+    level: input.level,
+    calls: {
+      namespace: input.calls.namespace,
+      name: input.calls.name,
+      argTypes: [...input.calls.argTypes]
+    },
+    ...updateOf !== undefined && updateOf.length > 0 ? { updateOf } : {},
+    ...input.when !== undefined && input.when.length > 0 ? { when: input.when } : {}
+  };
+  return {
+    kind: "trigger",
+    identity: { kind: "trigger", parent: input.parent, name: input.name },
+    owner: input.owner ?? "managed",
+    definition,
+    dependencies: normaliseEdges(edges),
+    provenance: input.provenance
+  };
+}
+function readArgument(fn, argument) {
+  assertIdentifier2(argument.name, `function ${fn} argument`);
+  assertTypeName(argument.type, `function ${fn} argument ${argument.name}`);
+  return { name: argument.name, type: argument.type };
+}
+function assertTypeName(typeName, role) {
+  if (!TYPE_TEXT.test(typeName)) {
+    catalogError2("OKM1020", `${role} ${typeName} is not a type name.`);
+  }
+}
+
+// src/contracts/catalog/view.ts
+function normaliseViewQuery(query) {
+  return query.trim().replace(/;\s*$/, "");
+}
+function viewObject(input) {
+  const namespace = input.namespace ?? staticNamespace2("public");
+  const columns = readColumns(input.name, input.columns);
+  const query = readQuery(input.name, input.query);
+  assertNamespace2(namespace);
+  assertProvenance(input.provenance);
+  const definition = {
+    columns,
+    query,
+    ...input.securityInvoker === true ? { securityInvoker: true } : {}
+  };
+  return {
+    kind: "view",
+    identity: { kind: "view", namespace, name: input.name },
+    owner: input.owner ?? "managed",
+    definition,
+    dependencies: normaliseEdges(input.dependencies ?? []),
+    provenance: input.provenance
+  };
+}
+function materializedViewObject(input) {
+  const namespace = input.namespace ?? staticNamespace2("public");
+  const columns = readColumns(input.name, input.columns);
+  const query = readQuery(input.name, input.query);
+  assertNamespace2(namespace);
+  assertProvenance(input.provenance);
+  const definition = {
+    columns,
+    query,
+    ...input.refresh === "concurrently" ? { refresh: "concurrently" } : {}
+  };
+  return {
+    kind: "materializedView",
+    identity: { kind: "materializedView", namespace, name: input.name },
+    owner: input.owner ?? "managed",
+    definition,
+    dependencies: normaliseEdges(input.dependencies ?? []),
+    provenance: input.provenance
+  };
+}
+function materializedViewIndex(input) {
+  assertNamespace2(input.parent.namespace);
+  assertIdentifier2(input.parent.name, "index parent");
+  assertProvenance(input.provenance);
+  const columns = [...input.columns];
+  for (const name of columns)
+    assertIdentifier2(name, "index column");
+  if (columns.length === 0 && input.expression === undefined) {
+    catalogError2("OKM1020", `Index on ${input.parent.name} needs a column or an expression.`);
+  }
+  const nameKey = input.nameKey ?? (columns.length > 0 ? columns.join("_") : "expr");
+  const name = input.name === undefined ? deterministicName2({ parent: input.parent.name, purpose: "index", nameKey }) : fitIdentifier2(input.name);
+  const parentView = {
+    kind: "materializedView",
+    namespace: input.parent.namespace,
+    name: input.parent.name
+  };
+  return {
+    kind: "index",
+    identity: { kind: "index", parent: input.parent, name },
+    owner: input.owner ?? "managed",
+    definition: {
+      columns,
+      unique: input.unique === true,
+      nameKey,
+      ...input.expression !== undefined ? { expression: input.expression } : {},
+      ...input.predicate !== undefined ? { predicate: input.predicate } : {}
+    },
+    dependencies: normaliseEdges(input.dependencies ?? [parentView]),
+    provenance: input.provenance
+  };
+}
+function readColumns(view, columns) {
+  assertIdentifier2(view, "view");
+  if (columns.length === 0)
+    catalogError2("OKM1020", `View ${view} needs a column.`);
+  const seen = new Set;
+  return columns.map((column) => {
+    assertIdentifier2(column.name, `view ${view} column`);
+    if (seen.has(column.name)) {
+      catalogError2("OKM1020", `View ${view} lists column ${column.name} twice.`);
+    }
+    seen.add(column.name);
+    if (column.dataType.length === 0 || /[;'"\\]/.test(column.dataType)) {
+      catalogError2("OKM1020", `View ${view} column ${column.name} type is not a type name.`);
+    }
+    return { name: column.name, dataType: column.dataType };
+  });
+}
+function readQuery(view, query) {
+  const text = normaliseViewQuery(query);
+  if (text.length === 0)
+    catalogError2("OKM1020", `View ${view} needs a query.`);
+  return text;
+}
+
 // src/contracts/catalog/document.ts
 function creationOrder2(source) {
   return dependencyOrder(source.objects);
@@ -1565,4 +1794,4 @@ function assertNeverKind(value) {
   return catalogError2("OKM1020", `Unexpected kind ${JSON.stringify(value)}.`);
 }
 
-export { roleObject, grantObject, defaultPrivilegeObject, creationOrder2, renameColumn2, renameTable2, serializeCatalog2, catalogHash2, startupCatalog2, startupHash2, loadTrustedCatalog2, catalogFileText2, parseCatalog2 };
+export { roleObject, grantObject, defaultPrivilegeObject, functionObject, triggerObject, normaliseViewQuery, viewObject, materializedViewObject, materializedViewIndex, creationOrder2, renameColumn2, renameTable2, serializeCatalog2, catalogHash2, startupCatalog2, startupHash2, loadTrustedCatalog2, catalogFileText2, parseCatalog2 };

package/dist/shared/{w79hsckn.js → 14x60fbf.js}

@@ -1,14 +1,14 @@
 import {
   noticeBuffer,
   WireSession
-} from "./1qa0qajz.js";
+} from "./mtw6jz76.js";
 import {
   NODE_POSTGRES_CAPABILITIES,
   driverErrors,
   rejectClosed,
   mapFailure,
   runCall
-} from "./kb2sdhfb.js";
+} from "./ae4j5f42.js";
 
 // src/adapters/pg/nodepostgres.ts
 import net from "node:net";
@@ -55,7 +55,7 @@ function open4(config) {
     counters.busy = Math.max(0, counters.busy - 1);
   }, inflight);
   const held = { pool, acquireMs, counters, notices, named, isClosed };
-  const checkout = () => closed ? rejectClosed() : import("./zp9fmend.js").then((mod) => mod.checkout(held));
+  const checkout = () => closed ? rejectClosed() : import("./mfedzr74.js").then((mod) => mod.checkout(held));
   return {
     capabilities: NODE_POSTGRES_CAPABILITIES,
     execute(text, params, options) {
@@ -88,14 +88,14 @@ function open4(config) {
     reserve: () => checkout(),
     stream(text, params) {
       return async function* () {
-        const { streamRows } = await import("./zp9fmend.js");
+        const { streamRows } = await import("./mfedzr74.js");
         yield* streamRows(checkout, text, params);
       }();
     },
     listen(channel, onNotify) {
       if (closed)
         return rejectClosed();
-      return import("./zp9fmend.js").then((mod) => mod.listen(held, channel, onNotify));
+      return import("./mfedzr74.js").then((mod) => mod.listen(held, channel, onNotify));
     },
     cancel() {
       for (const pending of inflight)

package/dist/shared/{ek2wt2dz.js → 16kvjebh.js}

@@ -1,6 +1,6 @@
 import {
   catalogFileText2
-} from "./qq3899ht.js";
+} from "./12z7aznj.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -14,7 +14,7 @@ async function assertCompatible(pool, schema, recordedHash, source, options) {
   if (code.artifact !== undefined) {
     const artifact = code.artifact;
     await loadOnce(`text\x00${artifact.hash}`, async () => {
-      const { loadTrustedCatalog } = await import("./dk8v79p3.js");
+      const { loadTrustedCatalog } = await import("./d5nmj7vv.js");
       loadTrustedCatalog(artifact.text, artifact.hash);
     });
   } else if (code.fromFile) {
@@ -28,7 +28,7 @@ async function assertCompatible(pool, schema, recordedHash, source, options) {
           }
         });
       }
-      const { loadTrustedCatalog } = await import("./dk8v79p3.js");
+      const { loadTrustedCatalog } = await import("./d5nmj7vv.js");
       loadTrustedCatalog(text, code.hash);
     });
   }
@@ -42,7 +42,7 @@ async function codeHash(schema, source) {
   const listed = await readHashFile(source.catalogDir);
   if (listed !== undefined)
     return { hash: listed, fromFile: true };
-  const { catalogHash } = await import("./dk8v79p3.js");
+  const { catalogHash } = await import("./d5nmj7vv.js");
   return { hash: catalogHash(schemaCatalog(schema)), fromFile: false };
 }
 function schemaCatalog(schema) {

package/dist/shared/{svncdeh5.js → 195pzzzz.js}

@@ -1,7 +1,7 @@
 import {
   open2
-} from "./14vx95q4.js";
-import"./qq3899ht.js";
+} from "./35q0n9tz.js";
+import"./12z7aznj.js";
 import"./n442h54c.js";
 import {
   CURRENT,
@@ -14,21 +14,21 @@ import {
 import {
   expandProvisioned,
   provisionHistoryIsKnown
-} from "./m6p12kbr.js";
-import"./8skf0cam.js";
-import"./b5pftnn2.js";
+} from "./mnvjvqyp.js";
+import"./kj9d8maq.js";
+import"./p3xbdcvt.js";
 import {
   projectPath,
   loadMigrations,
   loadConfig
-} from "./gs74dbj5.js";
+} from "./f4jy1j7x.js";
 import {
   sessionFailure,
   finishQuiet,
   assertTargetPolicy,
   listTargets
-} from "./tsvww22q.js";
-import"./9s0ypp87.js";
+} from "./dpc2r7rb.js";
+import"./sjk86yrx.js";
 import {
   OkmError2
 } from "./52szzakm.js";

package/dist/shared/{gzaveazc.js → 1d9q9cv2.js}

@@ -1,9 +1,16 @@
+import {
+  emitSqlSelect,
+  decodeSqlNumber
+} from "./3bb7wsqt.js";
 import {
   refusePrototypeKey
-} from "./q5c6ngn3.js";
+} from "./a62rb2da.js";
 import {
   isWindow
 } from "./9a4ae4p8.js";
+import {
+  readSelectFragment
+} from "./bsek72fg.js";
 import {
   emitWhere,
   emitOrder,
@@ -16,7 +23,7 @@ import {
   list,
   isRecord,
   fail2
-} from "./67txcrcw.js";
+} from "./kgwp4jdd.js";
 import {
   throwNamed2
 } from "./52szzakm.js";
@@ -46,6 +53,15 @@ function statement(spec) {
         sink.text(projectExpr(`t.${quote(item.column.sql)}`, item.column.dataType));
         sink.mark(`s:${item.column.field}`);
         outputs?.fields.push({ key: item.column.field, at: column, decode: item.column.decode });
+      } else if (item.kind === "sql") {
+        emitSqlSelect(table, item.parts, sink, "t");
+        sink.text("::text");
+        sink.mark(`s:${item.as}`);
+        outputs?.fields.push({
+          key: item.as,
+          at: column,
+          decode: item.textual === true ? AS_TEXT : decodeSqlNumber
+        });
       } else {
         emitWindow(table, item.window, sink);
         sink.text("::text");
@@ -171,6 +187,17 @@ function readSpec(table, select) {
       items.push({ kind: "column", column });
       continue;
     }
+    const sql = readSelectFragment(entry);
+    if (sql !== undefined) {
+      const as = readAs(sql.as, "fragment");
+      if (names.has(as) || table.columns.has(as)) {
+        fail2("OKM1120", `fragment as ${as} clashes with a column of ${table.model.name}.`, "Pick an as name that is not a column.");
+      }
+      names.add(as);
+      ordinals.set(as, String(items.length + 1));
+      items.push(sql.textual === true ? { kind: "sql", as, parts: sql.parts, textual: true } : { kind: "sql", as, parts: sql.parts });
+      continue;
+    }
     if (!isWindow(entry)) {
       fail2("OKM1120", "select takes field names or a window helper. A plain object is not a window.", "Pass rowNumber, rank, denseRank, or runningTotal.");
     }

package/dist/shared/{jvd0mqag.js → 3449rcae.js}

@@ -2,11 +2,11 @@ import {
   assertAuthorDrift2,
   catalogQuery2,
   managedRoleOptions2
-} from "./ax7qv55k.js";
-import"./b5pftnn2.js";
-import"./tsvww22q.js";
-import"./9s0ypp87.js";
-import"./qq3899ht.js";
+} from "./mkrn359n.js";
+import"./p3xbdcvt.js";
+import"./dpc2r7rb.js";
+import"./sjk86yrx.js";
+import"./12z7aznj.js";
 export {
   assertAuthorDrift2 as assertAuthorDrift,
   catalogQuery2 as catalogQuery,

package/dist/shared/{14vx95q4.js → 35q0n9tz.js}

@@ -6,7 +6,7 @@ import {
   runCall,
   EMPTY_NOTICES,
   resultFrom
-} from "./kb2sdhfb.js";
+} from "./ae4j5f42.js";
 
 // src/adapters/pg/postgresjs.ts
 import net from "node:net";
@@ -118,17 +118,17 @@ function open2(config) {
       return sockets.occupy(() => runCall(closed, options, (watch) => root.query(text, params, watch)));
     },
     batch(statements, options) {
-      return sockets.occupy(() => import("./je4axnm8.js").then((mod) => mod.runBatch(held, statements, options)));
+      return sockets.occupy(() => import("./z581d7ny.js").then((mod) => mod.runBatch(held, statements, options)));
     },
     reserve() {
       const gate = sockets.busyGate();
       gate.enter();
-      return import("./je4axnm8.js").then((mod) => mod.holdCheckout(gate, () => mod.checkout(held)), (error) => {
+      return import("./z581d7ny.js").then((mod) => mod.holdCheckout(gate, () => mod.checkout(held)), (error) => {
         gate.leave();
         throw error;
       });
     },
-    describe: (text, params) => sockets.occupy(() => import("./je4axnm8.js").then((mod) => mod.describe(sql, text, params))),
+    describe: (text, params) => sockets.occupy(() => import("./z581d7ny.js").then((mod) => mod.describe(sql, text, params))),
     stream(text, params) {
       const gate = sockets.busyGate();
       return async function* () {
@@ -143,7 +143,7 @@ function open2(config) {
     listen(channel, onNotify) {
       const gate = sockets.listenerGate();
       gate.enter();
-      return import("./je4axnm8.js").then((mod) => mod.holdListener(gate, async () => {
+      return import("./z581d7ny.js").then((mod) => mod.holdListener(gate, async () => {
         const listening = await sql.listen(channel, onNotify);
         return async () => {
           await listening.unlisten();
@@ -213,7 +213,7 @@ class PgSession {
       onAbort();
     else
       watch.signal.addEventListener("abort", onAbort, { once: true });
-    return import("./je4axnm8.js").then((mod) => mod.watchQuery(pending, watch, onAbort, {
+    return import("./z581d7ny.js").then((mod) => mod.watchQuery(pending, watch, onAbort, {
       start,
       text,
       notices: this.notices,
@@ -265,7 +265,7 @@ class PgSession {
   }
 }
 async function* loadStream(sql, text, params) {
-  const { stream } = await import("./je4axnm8.js");
+  const { stream } = await import("./z581d7ny.js");
   yield* stream(sql, text, params);
 }
 function send(sql, text, params, named) {

package/dist/shared/3bb7wsqt.js

@@ -0,0 +1,99 @@
+import {
+  isFragmentParts
+} from "./bsek72fg.js";
+import {
+  refuseHidden,
+  quote,
+  list,
+  fail2
+} from "./kgwp4jdd.js";
+import {
+  OkmError2,
+  throwNamed2
+} from "./52szzakm.js";
+
+// src/runtime/sql-fragment.ts
+function emitSqlValue(table, ref, value, sink) {
+  const dot = ref.indexOf(".");
+  const alias = dot < 0 ? ref : ref.slice(0, dot);
+  writeFragment(requireParts(value), sink, alias, ref, table, "where");
+}
+function emitSqlSelect(table, parts, sink, alias) {
+  writeFragment(parts, sink, alias, undefined, table, "select");
+}
+function decodeSqlNumber(wire) {
+  const parsed = Number(wire);
+  if (!Number.isFinite(parsed)) {
+    throw new OkmError2("OKM1125", "A select fragment must be a number.", {
+      fix: { summary: "Use a numeric expression, such as length(title). Text stays in where." }
+    });
+  }
+  return parsed;
+}
+function requireParts(value) {
+  if (!isFragmentParts(value)) {
+    throw new OkmError2("OKM1125", "A fragment was not created by fragment``.", {
+      fix: { summary: "Call fragment`...`." }
+    });
+  }
+  return value;
+}
+function writeFragment(parts, sink, alias, ref, table, place) {
+  sink.mark(":g");
+  sink.text("(");
+  for (const part of parts)
+    writePart(part, sink, alias, ref, table, place);
+  sink.mark(":g");
+  sink.text(")");
+}
+function writePart(part, sink, alias, ref, table, place) {
+  if (part.k === "t") {
+    sink.mark(`:t:${String(part.s.length)}:${part.s}`);
+    sink.text(part.s);
+    return;
+  }
+  if (part.k === "p") {
+    sink.mark(":p");
+    sink.param(part.v);
+    return;
+  }
+  if (part.k === "n") {
+    sink.mark(":n");
+    sink.text("null");
+    return;
+  }
+  if (part.k === "i") {
+    writeIdent(part.n, table, sink, alias, place);
+    return;
+  }
+  if (part.k === "c") {
+    if (ref === undefined) {
+      throw new OkmError2("OKM1125", "fragment.column belongs on a where field.", {
+        fix: { summary: "Use ident(name) in select, or put fragment.column on a where field." }
+      });
+    }
+    sink.mark(":c");
+    sink.text(ref);
+    return;
+  }
+  writeFragment(part.parts, sink, alias, ref, table, place);
+}
+function writeIdent(name, table, sink, alias, place) {
+  const column = table.columns.get(name);
+  if (column === undefined) {
+    throwNamed2("OKM1120", name, table.names, `Field ${name} is not on ${table.model.name}. Accepted names: ${list(table.names)}.`);
+  }
+  if (place === "select") {
+    if (column.hidden) {
+      fail2("OKM1120", `Field ${column.field} is hidden.`, "A select fragment cannot name a hidden field.");
+    }
+  } else {
+    refuseHidden(column);
+  }
+  sink.mark(`:i:${String(column.field.length)}:${column.field}`);
+  sink.text(alias);
+  sink.text(".");
+  sink.text(quote(column.sql));
+}
+
+export { emitSqlValue, emitSqlSelect, decodeSqlNumber };

package/dist/shared/{y6njgyda.js → 3t6kw83m.js}

@@ -15,14 +15,14 @@ import {
   expectOf2,
   allowSet2,
   noteGuarded2
-} from "./1w508jbr.js";
+} from "./bxas03mq.js";
 import {
   emitWhere,
   projectExpr,
   quote,
   isRecord,
   fail2
-} from "./67txcrcw.js";
+} from "./kgwp4jdd.js";
 
 // src/runtime/version.ts
 function planVersioned(schema, table, input, options, mods) {

package/dist/shared/{81ebdx9p.js → 4m6hskg8.js}

@@ -1,6 +1,6 @@
 import {
   noTimeout
-} from "./79dt02vc.js";
+} from "./q0cqt2sp.js";
 import {
   PGLITE_CAPABILITIES,
   driverErrors,
@@ -11,12 +11,12 @@ import {
   runCall,
   EMPTY_NOTICES,
   resultFrom
-} from "./kb2sdhfb.js";
+} from "./ae4j5f42.js";
 
 // src/adapters/pg/pglite.ts
 import { PGlite } from "@electric-sql/pglite";
 async function open3(config = {}) {
-  const wire = await import("./g6evj1j3.js");
+  const wire = await import("./needfe47.js");
   const db = new PGlite({
     dataDir: config.dataDir ?? "memory://",
     parsers: wire.parsers,
@@ -67,7 +67,7 @@ async function open3(config = {}) {
           return;
         released = true;
         try {
-          const { resetQueried } = await import("./5fe3kbsh.js");
+          const { resetQueried } = await import("./bnby0esn.js");
           await resetQueried(session);
         } finally {
           slot.release();