okmodel 0.8.0 → 0.9.0

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/{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/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/{kj9d8maq.js → jpybhf98.js}

@@ -1,6 +1,6 @@
 import {
   FUNCTION_ARG_TYPES
-} from "./p3xbdcvt.js";
+} from "./myk8fswx.js";
 import {
   OkmError2
 } from "./52szzakm.js";

package/dist/shared/kzgrnckd.js

@@ -0,0 +1,29 @@
+import {
+  isExactVersion,
+  compareExtensionVersions
+} from "./r3j8s5y0.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/dialects/pg/ext/feature.ts
+function assertExtFeature(declared, feature, need) {
+  if (declared === undefined)
+    return;
+  if (pinAllows(declared, need.extension))
+    return;
+  throw new OkmError2("OKM1812", `${feature} needs ${need.name} ${need.extension} or higher and PostgreSQL ${String(need.postgres)}. minPostgres: ${String(need.postgres)}. The declaration allows ${declared}.`, {
+    fix: {
+      summary: `Raise the ${need.name} pin to ${need.extension} or higher, and set minPostgres to ${String(need.postgres)}.`
+    }
+  });
+}
+function pinAllows(declared, minimum) {
+  const floor = /^>=(\d+(?:\.\d+)*)$/.exec(declared);
+  const pinned = floor?.[1] ?? declared;
+  if (!isExactVersion(pinned))
+    return false;
+  return compareExtensionVersions(pinned, minimum) >= 0;
+}
+
+export { assertExtFeature };

package/dist/shared/{agsfb86s.js → mazpbcdj.js}

@@ -3,11 +3,11 @@ import {
 } from "./cm3w0ywp.js";
 import {
   noTimeout
-} from "./q0cqt2sp.js";
+} from "./tr64w5p0.js";
 import {
   noticeBuffer,
   WireSession
-} from "./mtw6jz76.js";
+} from "./e275q7sd.js";
 import {
   NEON_WEBSOCKET_CAPABILITIES,
   NEON_HTTP_CAPABILITIES,
@@ -17,7 +17,7 @@ import {
   runCall,
   EMPTY_NOTICES,
   resultFrom
-} from "./ae4j5f42.js";
+} from "./mfvx6kjx.js";
 
 // src/adapters/pg/neon.ts
 import {
@@ -117,7 +117,7 @@ async function openWebSocket(config) {
     counters.busy = Math.max(0, counters.busy - 1);
   });
   const held = { pool, acquireMs, counters, notices, named, isClosed };
-  const checkout = () => closed ? rejectClosed() : import("./jx2m62cs.js").then((mod) => mod.checkout(held));
+  const checkout = () => closed ? rejectClosed() : import("./xv8qj97g.js").then((mod) => mod.checkout(held));
   return {
     capabilities: NEON_WEBSOCKET_CAPABILITIES,
     execute(text, params, options) {

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

@@ -1,7 +1,8 @@
 import {
   open2
-} from "./35q0n9tz.js";
+} from "./dd5pmnky.js";
 import"./12z7aznj.js";
+import"./fk9vef30.js";
 import"./n442h54c.js";
 import {
   CURRENT,
@@ -14,21 +15,21 @@ import {
 import {
   expandProvisioned,
   provisionHistoryIsKnown
-} from "./mnvjvqyp.js";
-import"./kj9d8maq.js";
-import"./p3xbdcvt.js";
+} from "./3456242y.js";
+import"./jpybhf98.js";
+import"./myk8fswx.js";
 import {
   projectPath,
+  catalogNamespace,
   loadMigrations,
   loadConfig
-} from "./f4jy1j7x.js";
+} from "./2zdxkt7b.js";
 import {
   sessionFailure,
   finishQuiet,
   assertTargetPolicy,
   listTargets
-} from "./dpc2r7rb.js";
-import"./sjk86yrx.js";
+} from "./6nae0spm.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -109,6 +110,7 @@ async function readTargetStatus(input) {
 }
 async function statusProject(cwd, flags) {
   const config = await loadConfig(cwd);
+  const namespace = catalogNamespace(config);
   const targets = chosen(listTargets(config), flags.target);
   const migrations = loadMigrations(projectPath(cwd, config.migrations ?? "migrations"));
   const rows = [];
@@ -117,6 +119,7 @@ async function statusProject(cwd, flags) {
       url: target.url,
       target: target.name,
       protected: target.protected,
+      ...namespace === "public" ? {} : { searchPath: namespace },
       migrations
     }));
   }

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

@@ -1,3 +1,6 @@
+import {
+  historySql2
+} from "./yybhre6n.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);