okmodel 0.8.0 → 0.9.1

package/dist/shared/ddh72ym5.js

@@ -0,0 +1,20 @@
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/runtime/param-limit.ts
+var PG_PARAM_LIMIT = 65535;
+function refuseParamLimit2(count) {
+  throw new OkmError2("OKM1126", `${String(count)} parameters (max ${String(PG_PARAM_LIMIT)}).`, {
+    kind: "invalid",
+    retryable: false,
+    fix: { summary: "Chunk the work, or use = any(array)." }
+  });
+}
+function assertParamCount2(count) {
+  if (count <= PG_PARAM_LIMIT)
+    return;
+  refuseParamLimit2(count);
+}
+
+export { refuseParamLimit2, assertParamCount2 };

package/dist/shared/e1c55v04.js

@@ -0,0 +1,10 @@
+import {
+  assertStableBackend
+} from "./bdekbvmt.js";
+
+// src/tooling/migrate/pooler-probe.ts
+async function probeStableBackend(_url, readPid, allowPooler, options) {
+  await assertStableBackend(readPid, allowPooler, options);
+}
+
+export { probeStableBackend };

package/dist/shared/{mtw6jz76.js → e275q7sd.js}

@@ -4,7 +4,7 @@ import {
   nextTransactionDepth,
   EMPTY_NOTICES,
   resultFrom
-} from "./ae4j5f42.js";
+} from "./mfvx6kjx.js";
 
 // src/adapters/pg/session.ts
 function noticeBuffer() {

package/dist/shared/{k86n8vq3.js → ekhq3ytz.js}

@@ -3,7 +3,7 @@ import {
   readHandle,
   readCall,
   attachHttp
-} from "./bah9nbg3.js";
+} from "./xbvz446k.js";
 import {
   fail2
 } from "./kgwp4jdd.js";

package/dist/shared/esy4dyxe.js

@@ -0,0 +1,17 @@
+import {
+  pullProject2,
+  pullLayout2,
+  commitPullFiles2
+} from "./c7dqd3gk.js";
+import"./mz48rs74.js";
+import"./wp7y8q3y.js";
+import"./bdekbvmt.js";
+import"./n442h54c.js";
+import"./fk9vef30.js";
+import"./12z7aznj.js";
+import"./jvxcp1qk.js";
+export {
+  commitPullFiles2 as commitPullFiles,
+  pullLayout2 as pullLayout,
+  pullProject2 as pullProject
+};

package/dist/shared/{gcefca6p.js → f9t9g54z.js}

@@ -12,19 +12,19 @@ import {
 } from "./52szzakm.js";
 
 // src/dialects/pg/filters.ts
-function openFilters(table, relations, spec, hiddenFields) {
+function openFilters(table, relations, spec, isHidden) {
   const allow = spec.allow ?? {};
   const sort = spec.sort ?? [];
   for (const field of Object.keys(allow))
-    deny(hiddenFields, table, field);
+    deny(isHidden, table, field);
   for (const field of sort)
-    deny(hiddenFields, table, field);
+    deny(isHidden, table, field);
   const nested = spec.relations;
   if (nested !== undefined) {
     for (const name of Object.keys(nested)) {
       const target = relationTable(relations, name);
       for (const field of nested[name] ?? [])
-        deny(hiddenFields, target, field);
+        deny(isHidden, target, field);
     }
   }
   return {
@@ -33,8 +33,8 @@ function openFilters(table, relations, spec, hiddenFields) {
     }
   };
 }
-function deny(hiddenFields, table, field) {
-  if (!hiddenFields.has(`${table}.${field}`))
+function deny(isHidden, table, field) {
+  if (!isHidden(table, field))
     return;
   throw new OkmError2("OKM1123", `Field ${table}.${field} is hidden.`, {
     fix: {
@@ -87,7 +87,8 @@ function table2(name, columns, options) {
     name,
     columns,
     filters(spec) {
-      return openFilters(name, options?.relations, spec, hiddenFields);
+      const ownHidden = hiddenColumnFields(columns);
+      return openFilters(name, options?.relations, spec, (tableName, field) => tableName === name ? ownHidden.has(field) : hiddenFields.has(`${tableName}.${field}`));
     },
     ...options !== undefined ? { options } : {},
     ...source !== undefined ? { source } : {}
@@ -190,11 +191,23 @@ function sqlValue(value) {
   definition("sql accepts a column, a string, a number, a boolean, or null.");
 }
 var hiddenFields = new Set;
-function remember(name, columns) {
+function hiddenColumnFields(columns) {
+  const fields = new Set;
   for (const field of Object.keys(columns)) {
     const column = columns[field];
     if (column?.state?.hidden === true)
-      hiddenFields.add(`${name}.${field}`);
+      fields.add(field);
+  }
+  return fields;
+}
+function remember(name, columns) {
+  const prefix = `${name}.`;
+  for (const key of hiddenFields) {
+    if (key.startsWith(prefix))
+      hiddenFields.delete(key);
+  }
+  for (const field of hiddenColumnFields(columns)) {
+    hiddenFields.add(`${name}.${field}`);
   }
 }
 

package/dist/shared/{sjk86yrx.js → fk9vef30.js}

@@ -15,49 +15,49 @@ import {
 } from "./nfzc5z0w.js";
 
 // src/dialects/pg/ddl.ts
-function quoteIdent(name) {
+function quoteIdent2(name) {
   return `"${name.replaceAll('"', '""')}"`;
 }
-function renderCatalog(source, schema) {
+function renderCatalog2(source, schema) {
   const folded = foldedKeys(source);
   const statements = [];
   const ordered = creationOrder2(source);
-  const created = uniqueBeforeForeignKey(ordered);
+  const created = uniqueBeforeForeignKey2(ordered);
   for (const object of ordered) {
     if (object.kind !== "type" || object.owner === "ignored")
       continue;
-    const sql = createObjectSql(object, schema);
+    const sql = createObjectSql2(object, schema);
     if (sql !== undefined)
       statements.push(sql);
   }
   for (const object of created) {
-    if (object.kind === "type" || object.kind === "function" || object.kind === "trigger" || object.kind === "view" || object.kind === "materializedView" || object.kind === "policy" || ownedByView(object)) {
+    if (object.kind === "type" || object.kind === "function" || object.kind === "trigger" || object.kind === "view" || object.kind === "materializedView" || object.kind === "policy" || ownedByView2(object)) {
       continue;
     }
     if (object.owner === "ignored")
       continue;
     const key = identityKey2(object.identity);
     if (object.kind === "table") {
-      statements.push(createTableSql(object, source, schema));
+      statements.push(createTableSql2(object, source, schema));
       continue;
     }
     if (folded.has(key))
       continue;
-    const sql = createObjectSql(object, schema);
+    const sql = createObjectSql2(object, schema);
     if (sql !== undefined)
       statements.push(sql);
   }
   for (const object of created) {
     if (object.kind !== "policy" || object.owner === "ignored")
       continue;
-    for (const step of policyCreatePlan(object, schema))
+    for (const step of policyCreatePlan2(object, schema))
       statements.push(step.sql);
   }
   for (const kind of ["function", "trigger"]) {
     for (const object of ordered) {
       if (object.kind !== kind || object.owner === "ignored")
         continue;
-      const sql = createObjectSql(object, schema);
+      const sql = createObjectSql2(object, schema);
       if (sql !== undefined)
         statements.push(sql);
     }
@@ -66,21 +66,21 @@ function renderCatalog(source, schema) {
     for (const object of ordered) {
       if (object.kind !== kind || object.owner === "ignored")
         continue;
-      const sql = createObjectSql(object, schema);
+      const sql = createObjectSql2(object, schema);
       if (sql !== undefined)
         statements.push(sql);
     }
   }
   for (const object of ordered) {
-    if (!ownedByView(object) || object.owner === "ignored")
+    if (!ownedByView2(object) || object.owner === "ignored")
       continue;
-    const sql = createObjectSql(object, schema);
+    const sql = createObjectSql2(object, schema);
     if (sql !== undefined)
       statements.push(sql);
   }
   return statements;
 }
-function uniqueBeforeForeignKey(objects) {
+function uniqueBeforeForeignKey2(objects) {
   const uniques = objects.filter((object) => object.kind === "constraint" && object.definition.constraintKind === "unique");
   if (uniques.length === 0)
     return objects;
@@ -122,49 +122,49 @@ function sameRef(left, right) {
   }
   return left.namespace.form === "template" && right.namespace.form === "template" ? left.namespace.pattern === right.namespace.pattern : false;
 }
-function ownedByView(object) {
+function ownedByView2(object) {
   if (object.kind !== "index")
     return false;
   return object.dependencies.some((edge) => edge.target.kind === "view" || edge.target.kind === "materializedView");
 }
-function dropObjectSql(object, schema) {
+function dropObjectSql2(object, schema) {
   if (object.owner === "ignored")
     return;
   switch (object.kind) {
     case "table":
-      return `drop table ${qualify(schema, object.identity.name)}`;
+      return `drop table ${qualify2(schema, object.identity.name)}`;
     case "column":
-      return `alter table ${qualify(schema, object.identity.parent.name)} drop column ${quoteIdent(object.identity.name)}`;
+      return `alter table ${qualify2(schema, object.identity.parent.name)} drop column ${quoteIdent2(object.identity.name)}`;
     case "index":
-      return `drop index ${qualify(schema, object.identity.name)}`;
+      return `drop index ${qualify2(schema, object.identity.name)}`;
     case "constraint":
-      return `alter table ${qualify(schema, object.identity.parent.name)} drop constraint ${quoteIdent(object.identity.name)}`;
+      return `alter table ${qualify2(schema, object.identity.parent.name)} drop constraint ${quoteIdent2(object.identity.name)}`;
     case "sequence":
-      return `drop sequence ${qualify(schema, object.identity.name)}`;
+      return `drop sequence ${qualify2(schema, object.identity.name)}`;
     case "type":
-      return `drop type ${qualify(schema, object.identity.name)}`;
+      return `drop type ${qualify2(schema, object.identity.name)}`;
     case "extension":
-      return `drop extension ${quoteIdent(object.identity.name)}`;
+      return `drop extension ${quoteIdent2(object.identity.name)}`;
     case "function":
-      return `drop function ${qualify(schema, object.identity.name)}(${object.identity.argTypes.join(", ")})`;
+      return `drop function ${qualify2(schema, object.identity.name)}(${object.identity.argTypes.join(", ")})`;
     case "trigger":
-      return `drop trigger ${quoteIdent(object.identity.name)} on ${qualify(schema, object.identity.parent.name)}`;
+      return `drop trigger ${quoteIdent2(object.identity.name)} on ${qualify2(schema, object.identity.parent.name)}`;
     case "view":
-      return `drop view ${qualify(schema, object.identity.name)}`;
+      return `drop view ${qualify2(schema, object.identity.name)}`;
     case "materializedView":
-      return `drop materialized view ${qualify(schema, object.identity.name)}`;
+      return `drop materialized view ${qualify2(schema, object.identity.name)}`;
     default:
       return;
   }
 }
-function createObjectSql(object, schema) {
+function createObjectSql2(object, schema) {
   switch (object.kind) {
     case "column":
-      return `alter table ${qualify(schema, object.identity.parent.name)} add column ${columnSql(object)}`;
+      return `alter table ${qualify2(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)}`;
+      return `alter table ${qualify2(schema, object.identity.parent.name)} add constraint ${quoteIdent2(object.identity.name)} ${constraintBody(object, schema)}`;
     case "sequence":
       return createSequenceSql(object, schema);
     case "type":
@@ -172,11 +172,11 @@ function createObjectSql(object, schema) {
     case "extension":
       return createExtensionSql(object);
     case "function":
-      return functionSql(object, schema, false);
+      return functionSql2(object, schema, false);
     case "trigger":
       return triggerSql(object, schema);
     case "view":
-      return viewSql(object, schema, false);
+      return viewSql2(object, schema, false);
     case "materializedView":
       return materializedViewSql(object, schema);
     case "table":
@@ -185,10 +185,10 @@ function createObjectSql(object, schema) {
       return;
   }
 }
-function functionSql(object, schema, replace) {
+function functionSql2(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 args = definition.arguments.map((argument) => `${quoteIdent2(argument.name)} ${argument.type}`).join(", ");
+  const head = `${replace ? "create or replace" : "create"} function ${qualify2(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}`;
@@ -196,14 +196,14 @@ function functionSql(object, schema, replace) {
     return `${head} ${tail} ${definition.body}`;
   return `${head} ${tail} as ${dollarQuote(definition.body)}`;
 }
-function viewSql(object, schema, replace) {
+function viewSql2(object, schema, replace) {
   const verb = replace ? "create or replace view" : "create view";
   const invoker = object.definition.securityInvoker === true ? " with (security_invoker = true)" : "";
-  return `${verb} ${qualify(schema, object.identity.name)}${invoker} as ${object.definition.query}`;
+  return `${verb} ${qualify2(schema, object.identity.name)}${invoker} as ${object.definition.query}`;
 }
-function policyCreatePlan(object, schema) {
-  const table = qualify(schema, object.identity.parent.name);
-  const name = quoteIdent(object.identity.name);
+function policyCreatePlan2(object, schema) {
+  const table = qualify2(schema, object.identity.parent.name);
+  const name = quoteIdent2(object.identity.name);
   const command = object.definition.command === "all" ? "all" : "select";
   const check = object.definition.command === "all" ? ` with check ${object.definition.expression}` : "";
   const create = {
@@ -218,10 +218,10 @@ function policyCreatePlan(object, schema) {
     create
   ];
 }
-function policyDropPlan(object, schema) {
-  const table = qualify(schema, object.identity.parent.name);
+function policyDropPlan2(object, schema) {
+  const table = qualify2(schema, object.identity.parent.name);
   const drop = {
-    sql: `drop policy ${quoteIdent(object.identity.name)} on ${table}`,
+    sql: `drop policy ${quoteIdent2(object.identity.name)} on ${table}`,
     kind: "drop-policy"
   };
   if (object.definition.command !== "all")
@@ -233,11 +233,11 @@ function policyDropPlan(object, schema) {
   ];
 }
 function materializedViewSql(object, schema) {
-  return `create materialized view ${qualify(schema, object.identity.name)} as ${object.definition.query} with no data`;
+  return `create materialized view ${qualify2(schema, object.identity.name)} as ${object.definition.query} with no data`;
 }
-function refreshMaterializedViewSql(object, schema, populated = false) {
+function refreshMaterializedViewSql2(object, schema, populated = false) {
   const concurrently = populated && object.definition.refresh === "concurrently" ? " concurrently" : "";
-  return `refresh materialized view${concurrently} ${qualify(schema, object.identity.name)}`;
+  return `refresh materialized view${concurrently} ${qualify2(schema, object.identity.name)}`;
 }
 function triggerSql(object, schema) {
   const definition = object.definition;
@@ -245,12 +245,12 @@ function triggerSql(object, schema) {
   const events = definition.events.map((event) => {
     if (event !== "update" || definition.updateOf === undefined)
       return event;
-    return `update of ${definition.updateOf.map((column) => quoteIdent(column)).join(", ")}`;
+    return `update of ${definition.updateOf.map((column) => quoteIdent2(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}`;
+  const fn = `${qualify2(schema, definition.calls.name)}(${args})`;
+  return `create trigger ${quoteIdent2(object.identity.name)} ${timing} ${events} on ${qualify2(schema, object.identity.parent.name)} for each ${definition.level}${when} execute function ${fn}`;
 }
 function dollarQuote(body) {
   let tag = "okm";
@@ -258,10 +258,10 @@ function dollarQuote(body) {
     tag = `${tag}_`;
   return `$${tag}$${body}$${tag}$`;
 }
-function alterColumnSql(before, after, schema) {
+function alterColumnSql2(before, after, schema) {
   const statements = [];
-  const table = qualify(schema, after.identity.parent.name);
-  const name = quoteIdent(after.identity.name);
+  const table = qualify2(schema, after.identity.parent.name);
+  const name = quoteIdent2(after.identity.name);
   const typeChanged = before.definition.dataType !== after.definition.dataType;
   const collationChanged = before.definition.collation !== after.definition.collation;
   if (typeChanged || collationChanged) {
@@ -276,7 +276,7 @@ function alterColumnSql(before, after, schema) {
   }
   return statements;
 }
-function identitySequence(sequence, source) {
+function identitySequence2(sequence, source) {
   const key = identityKey2(sequence.identity);
   return source.objects.some((object) => {
     if (object.kind !== "column" || object.definition.identity === undefined)
@@ -292,24 +292,24 @@ function foldedKeys(source) {
     if (object.kind === "constraint" && object.definition.constraintKind === "primaryKey") {
       keys.add(identityKey2(object.identity));
     }
-    if (object.kind === "sequence" && identitySequence(object, source)) {
+    if (object.kind === "sequence" && identitySequence2(object, source)) {
       keys.add(identityKey2(object.identity));
     }
   }
   return keys;
 }
-function createTableSql(tableObject, source, schema) {
+function createTableSql2(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 cols = primary.definition.columns.map((name) => quoteIdent2(name)).join(", ");
+    lines.push(`constraint ${quoteIdent2(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)} (
+  const tail = partition === undefined ? "" : ` partition by ${partition.method} (${partition.columns.map((name) => quoteIdent2(name)).join(", ")})`;
+  return `create table ${qualify2(schema, parent)} (
   ${lines.join(`,
   `)}
 )${tail}`;
@@ -317,20 +317,20 @@ function createTableSql(tableObject, source, schema) {
 function collateSql(collation) {
   if (collation === undefined)
     return "";
-  return ` collate ${quoteIdent(collation)}`;
+  return ` collate ${quoteIdent2(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 constraint = quoteIdent2(fitIdentifier2(`${name}_check`));
+    return `create domain ${qualify2(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})`;
+  return `create type ${qualify2(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)}`;
+  let sql = `${quoteIdent2(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) {
@@ -346,27 +346,38 @@ 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);
+  const name = quoteIdent2(object.identity.name);
+  const on = qualify2(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(", ");
+  const target = expression !== undefined ? `(${expression})` : object.definition.columns.map((column) => quoteIdent2(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}`;
+  return `create extension ${quoteIdent2(object.identity.name)} schema ${quoteIdent2(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}`;
+  return `create sequence ${qualify2(schema, object.identity.name)} as ${definition.dataType} start ${definition.start} increment ${definition.increment}${cycle}`;
+}
+function referenceSchema(object, schema) {
+  const references = object.definition.references;
+  if (references === undefined)
+    return schema;
+  const target = references.parent.namespace;
+  const parent = object.identity.parent.namespace;
+  if (target.form === "static" && parent.form === "static" && target.name !== parent.name) {
+    return target.name;
+  }
+  return schema;
 }
 function constraintBody(object, schema) {
   const definition = object.definition;
-  const columns = definition.columns.map((name) => quoteIdent(name)).join(", ");
+  const columns = definition.columns.map((name) => quoteIdent2(name)).join(", ");
   switch (definition.constraintKind) {
     case "primaryKey":
       return `primary key (${columns})`;
@@ -378,7 +389,7 @@ function constraintBody(object, schema) {
       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 target = references === undefined ? "" : ` references ${qualify2(referenceSchema(object, schema), references.parent.name)} (${references.columns.map((name) => quoteIdent2(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)}`;
@@ -392,8 +403,8 @@ function deferClause(definition) {
     return "";
   return ` deferrable initially ${definition.initially}`;
 }
-function qualify(schema, name) {
-  return `${quoteIdent(schema)}.${quoteIdent(name)}`;
+function qualify2(schema, name) {
+  return `${quoteIdent2(schema)}.${quoteIdent2(name)}`;
 }
 
-export { quoteIdent, renderCatalog, uniqueBeforeForeignKey, ownedByView, dropObjectSql, createObjectSql, functionSql, viewSql, policyCreatePlan, policyDropPlan, refreshMaterializedViewSql, alterColumnSql, identitySequence, createTableSql, qualify };
+export { quoteIdent2, renderCatalog2, uniqueBeforeForeignKey2, ownedByView2, dropObjectSql2, createObjectSql2, functionSql2, viewSql2, policyCreatePlan2, policyDropPlan2, refreshMaterializedViewSql2, alterColumnSql2, identitySequence2, createTableSql2, qualify2 };

package/dist/shared/fkjne6gx.js

@@ -0,0 +1,8 @@
+import {
+  refuseParamLimit2,
+  assertParamCount2
+} from "./ddh72ym5.js";
+export {
+  assertParamCount2 as assertParamCount,
+  refuseParamLimit2 as refuseParamLimit
+};

package/dist/shared/{e8zyaqvj.js → fne90dvz.js}

@@ -7,7 +7,7 @@ import {
 import {
   withHttp,
   settleCall
-} from "./bah9nbg3.js";
+} from "./xbvz446k.js";
 import {
   rejectKeys,
   isRecord,
@@ -47,6 +47,9 @@ async function batch(session, ops, options, replica) {
       if (item.checked === "parent") {
         throw new OkmError2("OKM1705", "batch does not take an update that sets a path column. The parent is checked in the statement, and a batch cannot report that after it commits. Use update({ where, set }) inside tx().", { fix: { summary: "Use update({ where, set }) inside tx()." } });
       }
+      if (item.checked === "tree") {
+        fail2("OKM1121", "batch does not take an update that sets a tree parent. The cycle is checked in the statement, and a batch cannot report that after it commits. Use update({ where, set }) inside tx().");
+      }
       if (item.checked !== undefined) {
         fail2("OKM1121", item.checked === "restore" ? "batch does not take restore: it is refused while its parent is archived, and a batch cannot report that after it commits. Use tx()." : "batch does not take a write with expect: the count is checked after the statement ran, and a batch cannot report that after it commits. Use tx().");
       }

package/dist/shared/{needfe47.js → g89fmz5s.js}

@@ -1,6 +1,6 @@
 import {
   mapFailure
-} from "./ae4j5f42.js";
+} from "./mfvx6kjx.js";
 
 // src/adapters/pg/pglite-wire.ts
 var OIDS = [

package/dist/shared/{m4xff2a6.js → ghqzdp94.js}

@@ -1,12 +1,12 @@
 import {
   open3,
   seal2
-} from "./4m6hskg8.js";
+} from "./0j6qe91y.js";
 import {
   PGLITE_CAPABILITIES,
   readCapability2,
   hasCapability2
-} from "./ae4j5f42.js";
+} from "./mfvx6kjx.js";
 export {
   PGLITE_CAPABILITIES as capabilities,
   hasCapability2 as hasCapability,

package/dist/shared/{n0jmpgj1.js → gr9sn4za.js}

@@ -3,7 +3,7 @@ import {
   readHandle,
   readCall,
   attachHttp
-} from "./bah9nbg3.js";
+} from "./xbvz446k.js";
 import {
   selectedColumns,
   parseOrder,

package/dist/shared/{5mtf6cj3.js → gzgfsspx.js}

@@ -1,3 +1,6 @@
+import {
+  historySql2
+} from "./k73e8n9d.js";
 import {
   BEHIND_EXPAND,
   BEHIND_CONTRACT,
@@ -37,10 +40,10 @@ function driftVerdict(codeHash, recordedHash, migrations) {
   const last = migrations.at(-1);
   return { state: "behind", migrationId: last?.id ?? "" };
 }
-async function assertDrift(pool, codeHash, recordedHash, options) {
+async function assertDrift(pool, codeHash, recordedHash, options, namespace = "public") {
   let rows;
   try {
-    const result = await pool.execute("select migration_id, class, catalog_hash from okm_history order by migration_id, step_index", undefined, options);
+    const result = await pool.execute(await historySql2(namespace), undefined, options);
     rows = result.rows;
   } catch (error) {
     throw gapError({ state: "behind", migrationId: "" }, error);

package/dist/shared/h9811jjm.js

@@ -0,0 +1,17 @@
+// src/dialects/pg/ext/using.ts
+function quotedIdent(name) {
+  return `"${name.replaceAll('"', '""')}"`;
+}
+function usingIndex(column, method, opclass) {
+  const call = {
+    columns: [column],
+    isUnique: false,
+    expression: `using ${method} (${quotedIdent(column)} ${opclass})`,
+    unique() {
+      return call;
+    }
+  };
+  return call;
+}
+
+export { quotedIdent, usingIndex };

package/dist/shared/{z581d7ny.js → hgt69zjf.js}

@@ -7,8 +7,8 @@ import {
   holdCheckout2,
   holdListener2,
   watchQuery2
-} from "./wcrheftc.js";
-import"./35q0n9tz.js";
+} from "./3dr444ny.js";
+import"./jvxcp1qk.js";
 import"./cm3w0ywp.js";
 export {
   checkout2 as checkout,