okmodel 0.3.0 → 0.4.0

package/dist/runtime/types.d.ts

@@ -672,6 +672,8 @@ export type ConnectOptions<S extends QuerySchema> = {
      * Directory of `catalog.hash` and `catalog.json`.
      *
      * When omitted, `connect` reads `.okm` under the process cwd if that hash file exists.
+     * The hash file is the fast path. A mismatch then reads `catalog.json` once
+     * per process and does not rebuild the catalog from the schema.
      */
     readonly catalogDir?: string;
     readonly logger?: {

package/dist/runtime/validate/index.js

@@ -3,10 +3,10 @@ import {
 } from "../../shared/9m80mkac.js";
 import {
   addSchemaHook
-} from "../../shared/x6wysh83.js";
+} from "../../shared/3p4b1fg0.js";
 import {
   queryHandle
-} from "../../shared/k34e0xf2.js";
+} from "../../shared/kkzwp3d2.js";
 import {
   OkmError2
 } from "../../shared/52szzakm.js";

package/dist/shared/2321avmn.js

@@ -0,0 +1,418 @@
+import {
+  parseCatalog2
+} from "./8jb4ymh2.js";
+import"./wqem4jed.js";
+import"./n442h54c.js";
+import {
+  applyTarget2,
+  backfillTiming2
+} from "./s4mb6a4b.js";
+import {
+  introspectSchema,
+  sealViews,
+  catalogQuery2,
+  managedRoleOptions2
+} from "./xghkt7a9.js";
+import {
+  loadMigrations,
+  catalogsEqual,
+  snapshotDifference
+} from "./7nk68fj8.js";
+import {
+  lintMigrationDirectory,
+  hasError,
+  lintRefusal,
+  selectTarget,
+  openProject
+} from "./q6zsyh31.js";
+import {
+  canonicalTypeName,
+  classOf,
+  strictestClass,
+  planMigration,
+  parsePlan
+} from "./n5y9zyj1.js";
+import {
+  quoteIdent
+} from "./41kv2xdm.js";
+import {
+  catalog,
+  isDomain
+} from "./g7ez901n.js";
+import {
+  identityKey2
+} from "./t4tbsy9h.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/tooling/migrate/check.ts
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import postgres from "postgres";
+var CHECK_SCHEMA_PREFIX = "okm_check_";
+var HISTORY_CODE = "OKM1547";
+var PREVIOUS_CODE = "OKM1548";
+var STALE_CODE = "OKM1549";
+var HISTORY_FIX = "Regenerate the migration so the stored catalog matches the schema the SQL applies.";
+var FORK_FIX = "Generate the later migration from the previous migration's catalog, not from an older parent.";
+var PREVIOUS_FIX = "Keep every table, column, constraint, and type the previous catalog relies on, or classify the migration as contract.";
+var STALE_FIX = "Run okm generate.";
+async function checkMigrations(cwd, flags, options) {
+  const opened = await openProject(cwd);
+  const target = selectTarget(opened.config, flags.target);
+  if (target.protected) {
+    throw new OkmError2("OKM1850", `okm migrate check writes a scratch schema and refuses protected target ${target.name}. Point it at a throwaway Postgres.`, {
+      kind: "forbidden",
+      fix: {
+        summary: "Point okm migrate check at a throwaway Postgres. --allow-protected does not apply."
+      }
+    });
+  }
+  const directory = join(cwd, opened.config.migrations ?? "migrations");
+  const history = readHistory(directory);
+  if (options?.provision === true) {
+    const equivalence = await proveSnapshot(opened.config, target.url, target.name, flags, history);
+    if (equivalence !== undefined)
+      throwFailure([equivalence]);
+  }
+  const previous = previousFailures(history);
+  const stale = staleFailure(history, opened.built.catalog);
+  const lint = lintFailure(directory, history, opened.config.lintFrom);
+  const replayed = await replayHistory(opened.config, target.url, target.name, flags, history);
+  const failures = [...replayed, ...previous, ...stale, ...lint];
+  if (failures.length > 0)
+    throwFailure(failures);
+  return `ok ${String(history.length)} migrations
+`;
+}
+function previousCatalogGaps(before, after) {
+  const afterBy = new Map(after.objects.map((object) => [identityKey2(object.identity), object]));
+  const gaps = [];
+  for (const object of before.objects) {
+    if (!checkedKind(object.kind))
+      continue;
+    const next = afterBy.get(identityKey2(object.identity));
+    if (next === undefined || next.kind !== object.kind) {
+      gaps.push(`${objectLabel(object)} is missing`);
+      continue;
+    }
+    if (object.kind === "column" && next.kind === "column") {
+      gaps.push(...columnGaps(object, next));
+    }
+    if (object.kind === "type" && next.kind === "type" && !sameType(object.definition, next.definition)) {
+      gaps.push(`${objectLabel(object)} changed`);
+    }
+  }
+  return gaps;
+}
+function recomputedMigrationClass(plan, before, after) {
+  if (plan.steps.length === 0)
+    return "expand";
+  if (plan.steps.some((step) => step.kind === undefined)) {
+    return planMigration({ before, after, name: plan.name }).class;
+  }
+  return strictestClass(plan.steps.map((step) => classOf(step.kind ?? "raw-sql")));
+}
+function migrationAllowsPreviousGaps(plan, before, after) {
+  return recomputedMigrationClass(plan, before, after) === "contract" && plan.class !== "expand";
+}
+function previousFailures(history) {
+  const failures = [];
+  let before = catalog([]);
+  for (const migration of history) {
+    const gaps = previousCatalogGaps(before, migration.catalog);
+    if (gaps.length > 0 && !migrationAllowsPreviousGaps(migration.plan, before, migration.catalog)) {
+      const stated = migration.plan.class === "expand" ? "expand" : recomputedMigrationClass(migration.plan, before, migration.catalog);
+      failures.push({
+        code: PREVIOUS_CODE,
+        message: `${migration.id}: previous catalog is not satisfied (${gaps.join("; ")}). The migration is classified ${stated}.`,
+        fix: PREVIOUS_FIX
+      });
+    }
+    before = migration.catalog;
+  }
+  return failures;
+}
+function staleFailure(history, head) {
+  const last = history.at(-1)?.catalog ?? catalog([]);
+  if (catalogsEqual(last, head))
+    return [];
+  return [
+    {
+      code: STALE_CODE,
+      message: "The last migration's catalog does not match the schema.",
+      fix: STALE_FIX
+    }
+  ];
+}
+function lintFailure(directory, history, lintFrom) {
+  const findings = lintMigrationDirectory(directory, lintIds(history, lintFrom));
+  if (!hasError(findings))
+    return [];
+  const refusal = lintRefusal(findings);
+  return [{ code: refusal.code, message: refusal.message, fix: refusal.fix.summary }];
+}
+function lintIds(history, lintFrom) {
+  if (lintFrom === undefined)
+    return;
+  const ids = history.map((migration) => migration.id);
+  const start = ids.indexOf(lintFrom);
+  if (start < 0) {
+    throw new OkmError2("invalid", `lintFrom ${lintFrom} is not a migration id.`, {
+      fix: {
+        summary: "Set lintFrom to a migration id. Files before that id are the adoption baseline and are not linted."
+      }
+    });
+  }
+  return new Set(ids.slice(start));
+}
+async function proveSnapshot(config, url, target, flags, history) {
+  const head = history.at(-1);
+  if (head === undefined)
+    return;
+  const sql = postgres(url, {
+    max: 1,
+    connect_timeout: 5,
+    idle_timeout: 1,
+    onnotice: () => {}
+  });
+  const provided = `${CHECK_SCHEMA_PREFIX}p${crypto.randomUUID().replaceAll("-", "")}`;
+  const replayed = `${CHECK_SCHEMA_PREFIX}r${crypto.randomUUID().replaceAll("-", "")}`;
+  const timing = {
+    ...flags.lockTimeoutMs !== undefined ? { lockTimeoutMs: flags.lockTimeoutMs } : config.timeouts?.lock !== undefined ? { lockTimeoutMs: config.timeouts.lock } : {},
+    ...flags.statementTimeoutMs !== undefined ? { statementTimeoutMs: flags.statementTimeoutMs } : config.timeouts?.statement !== undefined ? { statementTimeoutMs: config.timeouts.statement } : {},
+    ...backfillTiming2(config.backfill)
+  };
+  try {
+    await sql.unsafe(`create schema ${quoteIdent(provided)}`);
+    await sql.unsafe(`create schema ${quoteIdent(replayed)}`);
+    const role = config.roles === undefined ? {} : { migrationRole: config.roles.migration, schema: provided };
+    await applyTarget2({
+      url,
+      target,
+      protected: false,
+      allowProtected: false,
+      allowPooler: flags.allowPooler || config.allowPooler === true,
+      searchPath: provided,
+      ...timing,
+      migrations: history.map((migration) => ({
+        id: migration.id,
+        catalogHash: migration.catalogHash,
+        steps: migration.steps
+      })),
+      snapshot: {
+        catalog: head.catalog,
+        migrationId: head.id,
+        catalogHash: head.catalogHash,
+        reference: [],
+        only: true
+      },
+      ...role
+    });
+    await applyTarget2({
+      url,
+      target,
+      protected: false,
+      allowProtected: false,
+      allowPooler: flags.allowPooler || config.allowPooler === true,
+      searchPath: replayed,
+      ...timing,
+      migrations: history.map((migration) => ({
+        id: migration.id,
+        catalogHash: migration.catalogHash,
+        steps: retargetSteps(migration.steps, replayed)
+      })),
+      ...config.roles !== undefined ? { migrationRole: config.roles.migration, schema: replayed } : {}
+    });
+    const runner = catalogQuery2(sql);
+    const liveProvided = await introspectSchema(runner, provided, "public", managedRoleOptions2(config.roles));
+    const liveReplayed = await introspectSchema(runner, replayed, "public", managedRoleOptions2(config.roles));
+    const difference = snapshotDifference(liveProvided, liveReplayed);
+    if (difference === undefined)
+      return;
+    return {
+      code: "OKM1521",
+      message: `Provisioning from the snapshot does not match the replayed history.
+${difference}`,
+      fix: "Regenerate the snapshot from the history. okm migrate check --provision is the command that reports this."
+    };
+  } finally {
+    await sql.unsafe(`drop schema if exists ${quoteIdent(provided)} cascade`).catch(() => {
+      return;
+    });
+    await sql.unsafe(`drop schema if exists ${quoteIdent(replayed)} cascade`).catch(() => {
+      return;
+    });
+    await sql.end({ timeout: 5 });
+  }
+}
+async function replayHistory(config, url, target, flags, history) {
+  if (history.length === 0)
+    return [];
+  const sql = postgres(url, {
+    max: 1,
+    connect_timeout: 5,
+    idle_timeout: 1,
+    onnotice: () => {}
+  });
+  const scratch = `${CHECK_SCHEMA_PREFIX}${crypto.randomUUID().replaceAll("-", "")}`;
+  const failures = [];
+  try {
+    await sql.unsafe(`create schema ${quoteIdent(scratch)}`);
+    const runner = catalogQuery2(sql);
+    for (let index = 0;index < history.length; index += 1) {
+      const migration = history[index];
+      if (migration === undefined)
+        continue;
+      await applyTarget2({
+        url,
+        target,
+        protected: false,
+        allowProtected: false,
+        allowPooler: flags.allowPooler || config.allowPooler === true,
+        searchPath: scratch,
+        ...flags.lockTimeoutMs !== undefined ? { lockTimeoutMs: flags.lockTimeoutMs } : config.timeouts?.lock !== undefined ? { lockTimeoutMs: config.timeouts.lock } : {},
+        ...flags.statementTimeoutMs !== undefined ? { statementTimeoutMs: flags.statementTimeoutMs } : config.timeouts?.statement !== undefined ? { statementTimeoutMs: config.timeouts.statement } : {},
+        ...backfillTiming2(config.backfill),
+        migrations: [
+          {
+            id: migration.id,
+            catalogHash: migration.catalogHash,
+            steps: retargetSteps(migration.steps, scratch)
+          }
+        ],
+        ...config.roles !== undefined ? { migrationRole: config.roles.migration, schema: scratch } : {}
+      });
+      const live = await introspectSchema(runner, scratch, "public", managedRoleOptions2(config.roles));
+      const sealed = await sealViews(runner, migration.catalog);
+      const back = planMigration({ before: live, after: sealed, name: migration.id });
+      if (back.steps.length === 0)
+        continue;
+      failures.push(historyFailure(history, index, back));
+      break;
+    }
+  } finally {
+    await sql.unsafe(`drop schema if exists ${quoteIdent(scratch)} cascade`).catch(() => {
+      return;
+    });
+    await sql.end({ timeout: 5 });
+  }
+  return failures;
+}
+function historyFailure(history, index, back) {
+  const migration = history[index];
+  const id = migration?.id ?? "migration";
+  const fork = migration === undefined ? undefined : forkMessage(history, index);
+  if (fork !== undefined)
+    return { code: HISTORY_CODE, message: fork, fix: FORK_FIX };
+  const steps = back.steps.map((step) => step.sql).join(`
+`);
+  return {
+    code: HISTORY_CODE,
+    message: `${id}: history differs from the stored catalog
+${steps}`,
+    fix: HISTORY_FIX
+  };
+}
+function forkMessage(history, index) {
+  const current = history[index];
+  const previous = history[index - 1];
+  if (current === undefined || previous === undefined)
+    return;
+  if (samePlan(previous.catalog, current.catalog, current.plan))
+    return;
+  for (let parentIndex = 0;parentIndex < index; parentIndex += 1) {
+    const parent = parentIndex === 0 ? catalog([]) : history[parentIndex - 1]?.catalog;
+    if (parent === undefined)
+      continue;
+    if (!samePlan(parent, current.catalog, current.plan))
+      continue;
+    return `migration ${current.id} was generated from a different parent than ${previous.id}`;
+  }
+  return;
+}
+function samePlan(before, after, file) {
+  try {
+    return sameSql(planMigration({ before, after, name: "parent" }), file);
+  } catch (error) {
+    if (error instanceof OkmError2 && error.code === "OKM1530")
+      return false;
+    throw error;
+  }
+}
+function sameSql(planned, file) {
+  if (planned.steps.length !== file.steps.length)
+    return false;
+  return planned.steps.every((step, index) => step.sql === file.steps[index]?.sql);
+}
+function retargetSteps(steps, schema) {
+  const from = `${quoteIdent("public")}.`;
+  const to = `${quoteIdent(schema)}.`;
+  return steps.map((step) => ({
+    ...step,
+    sql: step.sql.replaceAll(from, to),
+    ...step.backfill === undefined ? {} : { backfill: { ...step.backfill, table: step.backfill.table.replaceAll(from, to) } }
+  }));
+}
+function readHistory(directory) {
+  return loadMigrations(directory).map((migration) => ({
+    id: migration.id,
+    catalogHash: migration.catalogHash,
+    steps: migration.steps,
+    plan: parsePlan(readFileSync(join(directory, `${migration.id}.sql`), "utf8")),
+    catalog: parseCatalog2(readFileSync(join(directory, `${migration.id}.catalog.json`), "utf8"))
+  }));
+}
+function throwFailure(failures) {
+  const first = failures[0];
+  if (first === undefined)
+    throw new Error("okm migrate check has no failure to report.");
+  const message = failures.length === 1 ? first.message : failures.map((failure) => `${failure.code} ${failure.message}`).join(`
+`);
+  throw new OkmError2(first.code, message, { fix: { summary: first.fix } });
+}
+function checkedKind(kind) {
+  return kind === "table" || kind === "column" || kind === "constraint" || kind === "type";
+}
+function columnGaps(before, after) {
+  const gaps = [];
+  const place = objectLabel(before);
+  if (canonicalTypeName(before.definition.dataType) !== canonicalTypeName(after.definition.dataType)) {
+    gaps.push(`${place} changed type from ${before.definition.dataType} to ${after.definition.dataType}`);
+  }
+  if (before.definition.nullable && !after.definition.nullable && !columnHasDefault(after)) {
+    gaps.push(`${place} nullability tightened without a default`);
+  }
+  return gaps;
+}
+function columnHasDefault(column) {
+  return column.definition.defaultExpression !== undefined || column.definition.identity !== undefined || column.definition.generated !== undefined;
+}
+function sameType(before, after) {
+  const beforeDomain = isDomain(before);
+  const afterDomain = isDomain(after);
+  if (beforeDomain !== afterDomain)
+    return false;
+  if (beforeDomain && afterDomain) {
+    return canonicalTypeName(before.base) === canonicalTypeName(after.base) && before.check === after.check;
+  }
+  if (!beforeDomain && !afterDomain) {
+    if (before.labels.length !== after.labels.length)
+      return false;
+    return before.labels.every((label, index) => label === after.labels[index]);
+  }
+  return false;
+}
+function objectLabel(object) {
+  if (object.kind === "column" || object.kind === "constraint") {
+    return `${object.kind} ${object.identity.parent.name}.${object.identity.name}`;
+  }
+  if (object.kind === "table" || object.kind === "type") {
+    return `${object.kind} ${object.identity.name}`;
+  }
+  return object.kind;
+}
+export {
+  checkMigrations
+};

package/dist/shared/{x6wysh83.js → 3p4b1fg0.js}

@@ -1,15 +1,13 @@
 import {
-  catalog
-} from "./jkc6ws1p.js";
-import {
+  catalog,
   enumType,
   sameEnumLabels
-} from "./qbxzvwwc.js";
+} from "./g7ez901n.js";
 import {
   snakeCase,
   emittedTypeName,
   rejectLater
-} from "./6w5j844a.js";
+} from "./jsd07prz.js";
 import {
   withLocation
 } from "./k7dwkhvq.js";

package/dist/shared/{wekze34d.js → 41kv2xdm.js}

@@ -1,6 +1,9 @@
+import {
+  creationOrder2
+} from "./8jb4ymh2.js";
 import {
   isDomain
-} from "./qbxzvwwc.js";
+} from "./g7ez901n.js";
 import {
   quoteLiteral
 } from "./94ez8kzh.js";
@@ -15,6 +18,61 @@ import {
 function quoteIdent(name) {
   return `"${name.replaceAll('"', '""')}"`;
 }
+function renderCatalog(source, schema) {
+  const folded = foldedKeys(source);
+  const statements = [];
+  const ordered = creationOrder2(source);
+  for (const object of ordered) {
+    if (object.kind !== "type" || object.owner === "ignored")
+      continue;
+    const sql = createObjectSql(object, schema);
+    if (sql !== undefined)
+      statements.push(sql);
+  }
+  for (const object of ordered) {
+    if (object.kind === "type" || object.kind === "function" || object.kind === "trigger" || object.kind === "view" || object.kind === "materializedView" || ownedByView(object)) {
+      continue;
+    }
+    if (object.owner === "ignored")
+      continue;
+    const key = identityKey2(object.identity);
+    if (object.kind === "table") {
+      statements.push(createTableSql(object, source, schema));
+      continue;
+    }
+    if (folded.has(key))
+      continue;
+    const sql = createObjectSql(object, schema);
+    if (sql !== undefined)
+      statements.push(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);
+      if (sql !== undefined)
+        statements.push(sql);
+    }
+  }
+  for (const kind of ["view", "materializedView"]) {
+    for (const object of ordered) {
+      if (object.kind !== kind || object.owner === "ignored")
+        continue;
+      const sql = createObjectSql(object, schema);
+      if (sql !== undefined)
+        statements.push(sql);
+    }
+  }
+  for (const object of ordered) {
+    if (!ownedByView(object) || object.owner === "ignored")
+      continue;
+    const sql = createObjectSql(object, schema);
+    if (sql !== undefined)
+      statements.push(sql);
+  }
+  return statements;
+}
 function ownedByView(object) {
   if (object.kind !== "index")
     return false;
@@ -145,6 +203,20 @@ function identitySequence(sequence, source) {
     return object.dependencies.some((edge) => identityKey2(edge.target) === key);
   });
 }
+function foldedKeys(source) {
+  const keys = new Set;
+  for (const object of source.objects) {
+    if (object.kind === "column")
+      keys.add(identityKey2(object.identity));
+    if (object.kind === "constraint" && object.definition.constraintKind === "primaryKey") {
+      keys.add(identityKey2(object.identity));
+    }
+    if (object.kind === "sequence" && identitySequence(object, source)) {
+      keys.add(identityKey2(object.identity));
+    }
+  }
+  return keys;
+}
 function createTableSql(tableObject, source, schema) {
   const parent = tableObject.identity.name;
   const columns = source.objects.filter((object) => object.kind === "column" && object.identity.parent.name === parent);
@@ -243,4 +315,4 @@ function qualify(schema, name) {
   return `${quoteIdent(schema)}.${quoteIdent(name)}`;
 }
 
-export { quoteIdent, ownedByView, dropObjectSql, createObjectSql, functionSql, viewSql, refreshMaterializedViewSql, alterColumnSql, identitySequence, createTableSql, qualify };
+export { quoteIdent, renderCatalog, ownedByView, dropObjectSql, createObjectSql, functionSql, viewSql, refreshMaterializedViewSql, alterColumnSql, identitySequence, createTableSql, qualify };

package/dist/shared/{fs0ex00p.js → 4ef7mmqf.js}

@@ -2,13 +2,13 @@ import {
   send2,
   reserve,
   park
-} from "./01yr20s5.js";
+} from "./sf8m6tfy.js";
 import {
   isConnectionLost
 } from "./tbszx8mz.js";
 import {
   WireSession
-} from "./0jc3ffzf.js";
+} from "./zvbjc949.js";
 import {
   rejectClosed,
   runCall

package/dist/shared/5mtf6cj3.js

@@ -0,0 +1,94 @@
+import {
+  BEHIND_EXPAND,
+  BEHIND_CONTRACT,
+  AHEAD_CONTRACT
+} from "./9yn6a2vd.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/runtime/drift-detail.ts
+function driftVerdict(codeHash, recordedHash, migrations) {
+  const codeAt = indexOfHash(migrations, codeHash);
+  const recordedAt = indexOfHash(migrations, recordedHash);
+  if (codeAt >= 0 && recordedAt >= codeAt) {
+    for (let index = codeAt + 1;index <= recordedAt; index += 1) {
+      const migration = migrations[index];
+      if (migration !== undefined && migration.expand !== true) {
+        return { state: "ahead by contract", migrationId: migration.id };
+      }
+    }
+    return { state: "ok" };
+  }
+  if (codeAt >= 0 && recordedAt >= 0 && recordedAt < codeAt) {
+    const next = migrations[recordedAt + 1];
+    if (next !== undefined) {
+      return {
+        state: next.expand ? "behind by expand" : "behind by contract",
+        migrationId: next.id
+      };
+    }
+  }
+  if (recordedAt >= 0) {
+    const at = migrations[recordedAt];
+    if (at !== undefined)
+      return { state: "behind", migrationId: at.id };
+  }
+  const last = migrations.at(-1);
+  return { state: "behind", migrationId: last?.id ?? "" };
+}
+async function assertDrift(pool, codeHash, recordedHash, options) {
+  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);
+    rows = result.rows;
+  } catch (error) {
+    throw gapError({ state: "behind", migrationId: "" }, error);
+  }
+  const verdict = driftVerdict(codeHash, recordedHash, groupMigrations(rows));
+  if (verdict.state === "ok")
+    return;
+  throw gapError(verdict);
+}
+function indexOfHash(migrations, hash) {
+  let found = -1;
+  for (let index = 0;index < migrations.length; index += 1) {
+    if (migrations[index]?.catalogHash === hash)
+      found = index;
+  }
+  return found;
+}
+function groupMigrations(rows) {
+  const grouped = [];
+  for (const row of rows) {
+    const id = row[0];
+    const stepClass = row[1];
+    const hash = row[2];
+    if (id == null || stepClass == null || hash == null)
+      continue;
+    const expand = stepClass === "expand";
+    const last = grouped.at(-1);
+    if (last !== undefined && last.id === id) {
+      grouped[grouped.length - 1] = {
+        id,
+        catalogHash: hash,
+        expand: last.expand && expand
+      };
+      continue;
+    }
+    grouped.push({ id, catalogHash: hash, expand });
+  }
+  return grouped;
+}
+function gapError(verdict, cause) {
+  const named = verdict.migrationId;
+  const phrase = verdict.state === "ahead by contract" ? `${AHEAD_CONTRACT} migration ${named}` : verdict.state === "behind by expand" ? `${BEHIND_EXPAND} migration ${named}` : verdict.state === "behind by contract" ? `${BEHIND_CONTRACT} migration ${named}` : named.length > 0 ? `behind the app at migration ${named}` : "behind the app";
+  const fix = named.length > 0 ? `Apply ${named}, or change the deploy order.` : "Apply migrations, or change the deploy order.";
+  return new OkmError2("OKM1520", `The database is ${phrase}.`, {
+    ...cause === undefined ? {} : { cause },
+    fix: { summary: fix }
+  });
+}
+export {
+  assertDrift
+};

package/dist/shared/{999ade2q.js → 5vdm4sgp.js}

@@ -1,6 +1,6 @@
 import {
   PgSession
-} from "./xw1d69vd.js";
+} from "./wqem4jed.js";
 import {
   isConnectionLost
 } from "./tbszx8mz.js";

package/dist/shared/{qybh48nd.js → 6693j9rs.js}

@@ -6,7 +6,7 @@ import {
   catalogHash2,
   loadTrustedCatalog2,
   parseCatalog2
-} from "./t616ynfn.js";
+} from "./8jb4ymh2.js";
 export {
   catalogHash2 as catalogHash,
   creationOrder2 as creationOrder,