okmodel 0.7.0 → 0.9.0

package/dist/shared/n7kg8mmx.js

@@ -0,0 +1,61 @@
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/tooling/driver-test.ts
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+async function driverTest(args, stdout) {
+  const runner = driverRunnerPath(dirname(fileURLToPath(import.meta.url)));
+  if (!existsSync(runner)) {
+    throw new OkmError2("invalid", "okm driver test cannot find its runner.", {
+      fix: { summary: "Run bun run build, then retry." }
+    });
+  }
+  const command = runner.endsWith(".ts") ? "bun" : process.execPath;
+  const result = await runProcess(command, [runner, ...args]);
+  if (result.stdout.length > 0)
+    stdout(result.stdout);
+  if (result.code !== 0) {
+    const detail = result.stderr.trim();
+    throw new OkmError2("invalid", detail === "" ? "okm driver test failed." : detail, {
+      fix: { summary: "The report lists each failed case." }
+    });
+  }
+}
+function driverRunnerPath(here) {
+  const source = join(here, "..", "..", "packages", "harness", "src", "driver-run.ts");
+  if (existsSync(source))
+    return source;
+  const beside = join(here, "driver-run.js");
+  if (existsSync(beside))
+    return beside;
+  return join(here, "..", "tooling", "driver-run.js");
+}
+function runProcess(command, args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, [...args], { stdio: ["ignore", "pipe", "pipe"] });
+    const out = [];
+    const err = [];
+    child.stdout.on("data", (chunk) => {
+      out.push(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      err.push(chunk);
+    });
+    const proc = child;
+    proc.on("error", reject);
+    proc.on("close", (code) => {
+      resolve({
+        code: code ?? 1,
+        stdout: Buffer.concat(out).toString("utf8"),
+        stderr: Buffer.concat(err).toString("utf8")
+      });
+    });
+  });
+}
+export {
+  driverTest
+};

package/dist/shared/{vqrjpcqn.js → nmnsgj7x.js}

@@ -1,7 +1,7 @@
 import {
   required,
   openColumn
-} from "./ywr8hmey.js";
+} from "./606g0nbf.js";
 import {
   definition,
   rejected

package/dist/shared/{tbrvgw6z.js → npdftanb.js}

@@ -8,7 +8,7 @@ import {
   logicalIntent,
   appliedRules,
   rejectKeys
-} from "./67txcrcw.js";
+} from "./kgwp4jdd.js";
 import {
   OkmError2,
   safe2,
@@ -86,7 +86,7 @@ function openClient(session) {
     },
     close,
     connected: session.connected,
-    tx: (...args) => import("./vczs8gd4.js").then((mod) => mod.tx(session, args)),
+    tx: (...args) => import("./wvtjg5m3.js").then((mod) => mod.tx(session, args)),
     batch: (ops, options) => batchHandle(session, ops, options),
     ...session.tx?.extras
   };
@@ -121,7 +121,7 @@ function tableApi(session, table, view, uses) {
   const api = {
     find(options = {}) {
       if ("lock" in options) {
-        return lazyRead(session, () => import("./sfz1ksn6.js"), table, options, base, view);
+        return lazyRead(session, () => import("./8jesqsrk.js"), table, options, base, view);
       }
       return start(session, "find", table, options, base, view);
     },
@@ -135,10 +135,10 @@ function tableApi(session, table, view, uses) {
       return start(session, "exists", table, options, base, view);
     },
     page(options) {
-      return lazyRead(session, () => import("./pt94kz7f.js"), table, options, base, view);
+      return lazyRead(session, () => import("./5kyb3tqx.js"), table, options, base, view);
     },
     aggregate(options = {}) {
-      return lazyRead(session, () => import("./1est4ezg.js"), table, options, base, view);
+      return lazyRead(session, () => import("./xtsydxjg.js"), table, options, base, view);
     },
     insert(data, options = {}) {
       return writeHandle(session, "insert", table, data, options, mods);
@@ -151,9 +151,9 @@ function tableApi(session, table, view, uses) {
     }
   };
   for (const walk of ["descendants", "ancestors"]) {
-    api[walk] = (id, options) => lazyRead(session, () => import("./7mnme5tn.js"), table, { id, walk, options }, base, view);
+    api[walk] = (id, options) => lazyRead(session, () => import("./c3mvnq7a.js"), table, { id, walk, options }, base, view);
   }
-  api.sync = (id, relation, ids, options) => lazyRead(session, () => import("./te5as7z7.js"), table, { id, relation, ids, options }, base, view, true);
+  api.sync = (id, relation, ids, options) => lazyRead(session, () => import("./aksb89mn.js"), table, { id, relation, ids, options }, base, view, true);
   const hooks = session.schema.hooks;
   if (hooks !== undefined) {
     for (const hook of hooks) {
@@ -169,16 +169,17 @@ function tableApi(session, table, view, uses) {
   for (const name in session.schema.model[table]?.presets) {
     api[name] = (...args) => tableApi(session, table, view, [uses, name, args]);
   }
+  api[Symbol.for("okm.lane")] = [session, table, mapError];
   return api;
 }
 function batchHandle(session, ops, options, replica) {
-  return queryHandle(() => import("./vb6qfyve.js").then((mod) => mod.batch(session, ops, options, replica)), {
+  return queryHandle(() => import("./ds229x4r.js").then((mod) => mod.batch(session, ops, options, replica)), {
     replica: () => batchHandle(session, ops, options, true)
   });
 }
 var writers;
 function loadWrite() {
-  writers ??= import("./5v3xf80k.js");
+  writers ??= import("./8n688yjg.js");
   return writers;
 }
 function queryHandle(run, extra) {
@@ -288,7 +289,7 @@ function lazyRead(session, load, table, options, mods, view, sync) {
   return queryHandle(() => read().then((box) => box.it), extra);
 }
 async function decodeRows(plan, rows, table) {
-  return plan.outputs.includes.length === 0 ? decodeResult(plan, rows, table) : (await import("./dkxgzaqd.js")).decodeIncluded(plan, rows, table);
+  return plan.outputs.includes.length === 0 ? decodeResult(plan, rows, table) : (await import("./hqpxf4a4.js")).decodeIncluded(plan, rows, table);
 }
 function readHandle(session, table, call, mods, decode, extra) {
   let prepared;
@@ -301,14 +302,14 @@ function readHandle(session, table, call, mods, decode, extra) {
       call = (await import("./m7n9h2a5.js")).refine(session.schema, origin, mods.uses);
     }
     if (searched) {
-      call = (await import("./jznfax0y.js")).applyTextSearch(session.schema, call);
+      call = (await import("./zq1he88x.js")).applyTextSearch(session.schema, call);
     }
     const hooks = await hooksFor(call);
     if (readNeedsOperatorSql(session.schema, call) || hooks?.needsOperator(session.schema, call)) {
       await loadOperatorSql();
     }
     if (call.build === undefined && selectHasWindow(call.select)) {
-      call = (await import("./gzaveazc.js")).attach(session.schema, call);
+      call = (await import("./1d9q9cv2.js")).attach(session.schema, call);
     }
     const bound = bindCall(session.schema, call, hooks);
     let plan = session.cache.get(bound.key);
@@ -371,7 +372,7 @@ function readHandle(session, table, call, mods, decode, extra) {
 }
 function streamLazy(session, call, mods, view, batch) {
   return async function* () {
-    const { streamRows } = await import("./cn957f8d.js");
+    const { streamRows } = await import("./tw1nvvfj.js");
     yield* streamRows(session, call, mods, view, batch, (error) => logged(session, error));
   }();
 }
@@ -404,16 +405,8 @@ function readCall(op, table, options, all, scope, model, schema, view) {
   };
 }
 async function checkServer(pool, schema, http, requireMeta, options, source) {
-  const server = await import("./ttsqgp4p.js");
-  let rows;
-  try {
-    const result = await pool.execute(server.versionQuery, undefined, options);
-    rows = result.rows;
-  } catch (error) {
-    const { mapPostgresError } = await import("./63qtkrca.js");
-    throw mapPostgresError(error, mapOptions(http, false, schema));
-  }
-  await server.acceptServer(pool, schema, rows, http, requireMeta, options, source);
+  const { acceptServer } = await import("./zdqf8k5d.js");
+  await acceptServer(pool, schema, http, requireMeta, options, source);
 }
 async function mapError(session, error) {
   if (error instanceof OkmError2) {
@@ -433,7 +426,7 @@ function errorFields(error) {
 var includeHooks;
 var operatorSql;
 function loadOperatorSql() {
-  operatorSql ??= import("./xhfsfkgk.js").then(() => {
+  operatorSql ??= import("./4vbf83xx.js").then(() => {
     return;
   });
   return operatorSql;
@@ -444,7 +437,7 @@ function selectHasWindow(select) {
 function hooksFor(call) {
   if (call.include === undefined)
     return Promise.resolve(undefined);
-  includeHooks ??= import("./dkxgzaqd.js").then((mod) => mod.includeHooks);
+  includeHooks ??= import("./hqpxf4a4.js").then((mod) => mod.includeHooks);
   return includeHooks;
 }
 function bindNow(schema, call) {
@@ -503,4 +496,4 @@ function logged(session, error) {
   return error;
 }
 
-export { createClient, openClient, queryHandle, decodeRows, readHandle, readCall, withHttp, attachHttp, settleCall };
+export { createClient, openClient, queryHandle, decodeRows, readHandle, readCall, withHttp, attachHttp, mapOptions, settleCall };

package/dist/shared/{ek2wt2dz.js → pg4ezgyf.js}

@@ -1,12 +1,16 @@
 import {
   catalogFileText2
-} from "./qq3899ht.js";
+} from "./12z7aznj.js";
+import {
+  artifactDir,
+  readText
+} from "./yybhre6n.js";
 import {
   OkmError2
 } from "./52szzakm.js";
 
 // src/runtime/drift.ts
-async function assertCompatible(pool, schema, recordedHash, source, options) {
+async function assertCompatible(pool, schema, recordedHash, source, options, namespace = "public") {
   const code = await codeHash(schema, source);
   if (code.hash === recordedHash)
     return;
@@ -14,7 +18,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,12 +32,12 @@ async function assertCompatible(pool, schema, recordedHash, source, options) {
           }
         });
       }
-      const { loadTrustedCatalog } = await import("./dk8v79p3.js");
+      const { loadTrustedCatalog } = await import("./d5nmj7vv.js");
       loadTrustedCatalog(text, code.hash);
     });
   }
-  const { assertDrift } = await import("./5mtf6cj3.js");
-  await assertDrift(pool, code.hash, recordedHash, options);
+  const { assertDrift } = await import("./mvmm3xpb.js");
+  await assertDrift(pool, code.hash, recordedHash, options, namespace);
 }
 async function codeHash(schema, source) {
   if (source.catalog !== undefined) {
@@ -42,7 +46,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) {
@@ -63,29 +67,6 @@ async function readHashFile(catalogDir) {
   const hash = catalogFileText2(text, "catalog.hash").trim();
   return hash.length === 0 ? undefined : hash;
 }
-function artifactDir(catalogDir) {
-  if (catalogDir !== undefined)
-    return catalogDir.replace(/[/\\]+$/, "");
-  const cwd = globalThis.process?.cwd?.() ?? ".";
-  return `${cwd}/.okm`;
-}
-async function readText(path) {
-  const bun = globalThis.Bun;
-  if (bun !== undefined) {
-    const file = bun.file(path);
-    if (!await file.exists())
-      return;
-    return file.text();
-  }
-  const loader = globalThis.process?.getBuiltinModule;
-  if (loader === undefined)
-    return;
-  try {
-    return await loader("node:fs/promises").readFile(path, "utf8");
-  } catch {
-    return;
-  }
-}
 export {
   assertCompatible
 };

package/dist/shared/{5fe3kbsh.js → pgsak1yw.js}

@@ -2,7 +2,7 @@ import {
   resetSession2,
   resetQueried2,
   refuseWhenLost2
-} from "./zm0ptry0.js";
+} from "./99qp9vtg.js";
 export {
   refuseWhenLost2 as refuseWhenLost,
   resetQueried2 as resetQueried,

package/dist/shared/{bm22fvzr.js → qfw14tna.js}

@@ -3,7 +3,7 @@ import {
 } from "./mss6ctgv.js";
 import {
   effectivePredicate
-} from "./n816peh1.js";
+} from "./n454kcnw.js";
 import {
   runWrite
 } from "./n4jqhpqz.js";
@@ -17,7 +17,7 @@ import {
   isRecord,
   registerFailFix,
   fail2
-} from "./67txcrcw.js";
+} from "./kgwp4jdd.js";
 import {
   safetyInstalled,
   runSafety

package/dist/shared/{wa07eas9.js → qvwwp1mp.js}

@@ -1,42 +1,50 @@
 import {
   parseCatalog2
-} from "./qq3899ht.js";
+} from "./12z7aznj.js";
+import {
+  quoteIdent2
+} from "./fk9vef30.js";
 import"./n442h54c.js";
 import"./cm3w0ywp.js";
-import"./14vx95q4.js";
+import"./dd5pmnky.js";
 import {
   watchReserved2
-} from "./bz84tkzm.js";
+} from "./bphrgwz9.js";
 import {
   ensureMigrationTables2
-} from "./p6qc5gcp.js";
+} from "./ccsmhv9r.js";
 import {
   sealViews,
   catalogQuery2,
   managedRoleOptions2
-} from "./ax7qv55k.js";
+} from "./90sg0w5a.js";
 import {
   assumeRole,
   grantSchema,
   assertSchemaUsageLanded,
   catalogsEqual,
   snapshotDifference
-} from "./m6p12kbr.js";
+} from "./3456242y.js";
 import {
   roleExists
-} from "./8skf0cam.js";
+} from "./jpybhf98.js";
 import {
   introspectSchema
-} from "./b5pftnn2.js";
+} from "./myk8fswx.js";
 import {
   projectPath,
+  loadSnapshots,
+  assertSnapshots,
+  assertLiveExternal,
   loadMigrations,
   readMigrationPlan,
+  lintReprints,
   lintMigrationDirectory,
+  formatFindings,
   hasError,
   lintRefusal,
   openProject
-} from "./gs74dbj5.js";
+} from "./2zdxkt7b.js";
 import {
   sqlStatements,
   transactionControl,
@@ -51,13 +59,10 @@ import {
   assertDirectConnection,
   assertStableBackend,
   selectTarget
-} from "./tsvww22q.js";
+} from "./6nae0spm.js";
 import {
   isConnectionLost
 } from "./cnkky55j.js";
-import {
-  quoteIdent
-} from "./9s0ypp87.js";
 import {
   catalog,
   isDomain
@@ -77,6 +82,7 @@ import { join } from "node:path";
 import postgres from "postgres";
 async function replayCheckHistory(url, scratch, config, allowPooler, history) {
   const skips = [];
+  const reprints = [];
   let stop;
   await inCheckTransaction(url, scratch, config, allowPooler, async (sql) => {
     const connection = driverOf(sql);
@@ -88,7 +94,10 @@ async function replayCheckHistory(url, scratch, config, allowPooler, history) {
       await replayMigration(sql, connection, scratch, config, migration, session, skips);
       await restoreSession(sql, session);
       const runner = catalogQuery2(sql);
-      const live = await introspectSchema(runner, scratch, "public", managedRoleOptions2(config.roles));
+      const live = await introspectSchema(runner, scratch, config.namespace ?? "public", managedRoleOptions2(config.roles));
+      for (const item of lintReprints(migration.catalog, live, migration.steps)) {
+        reprints.push({ ...item, place: `${migration.id} ${item.place}` });
+      }
       const sealed = await sealViews(runner, migration.catalog);
       const back = planMigration({ before: live, after: sealed, name: migration.id });
       if (back.steps.length === 0)
@@ -97,7 +106,7 @@ async function replayCheckHistory(url, scratch, config, allowPooler, history) {
       return;
     }
   });
-  return stop === undefined ? { skips } : { skips, stop };
+  return stop === undefined ? { skips, reprints } : { skips, reprints, stop };
 }
 async function proveCheckSnapshot(url, provided, replayed, config, allowPooler, history) {
   const head = history.at(-1);
@@ -115,10 +124,10 @@ async function proveCheckSnapshot(url, provided, replayed, config, allowPooler,
     await runSteps(sql, connection, provided, config.roles?.migration, {
       id: "snapshot",
       catalog: head.catalog,
-      steps: retargetSteps(planned.steps, provided)
+      steps: retargetSteps(planned.steps, provided, config.namespace ?? "public")
     }, session, []);
     await restoreSession(sql, session);
-    return introspectSchema(catalogQuery2(sql), provided, "public", managedRoleOptions2(config.roles));
+    return introspectSchema(catalogQuery2(sql), provided, config.namespace ?? "public", managedRoleOptions2(config.roles));
   });
   const again = await inCheckTransaction(url, replayed, config, allowPooler, async (sql) => {
     const connection = driverOf(sql);
@@ -127,17 +136,17 @@ async function proveCheckSnapshot(url, provided, replayed, config, allowPooler,
       await replayMigration(sql, connection, replayed, config, migration, session, []);
     }
     await restoreSession(sql, session);
-    return introspectSchema(catalogQuery2(sql), replayed, "public", managedRoleOptions2(config.roles));
+    return introspectSchema(catalogQuery2(sql), replayed, config.namespace ?? "public", managedRoleOptions2(config.roles));
   });
   return snapshotDifference(installed, again);
 }
-function retargetSteps(steps, schema) {
-  const from = `${quoteIdent("public")}.`;
-  const to = `${quoteIdent(schema)}.`;
-  const fromDefaults = `in schema ${quoteIdent("public")} `;
-  const toDefaults = `in schema ${quoteIdent(schema)} `;
-  const fromSchema = `on schema ${quoteIdent("public")}`;
-  const toSchema = `on schema ${quoteIdent(schema)}`;
+function retargetSteps(steps, schema, source = "public") {
+  const from = `${quoteIdent2(source)}.`;
+  const to = `${quoteIdent2(schema)}.`;
+  const fromDefaults = `in schema ${quoteIdent2(source)} `;
+  const toDefaults = `in schema ${quoteIdent2(schema)} `;
+  const fromSchema = `on schema ${quoteIdent2(source)}`;
+  const toSchema = `on schema ${quoteIdent2(schema)}`;
   return steps.map((step) => ({
     ...step,
     sql: step.sql.replaceAll(from, to).replaceAll(fromDefaults, toDefaults).replaceAll(fromSchema, toSchema),
@@ -173,9 +182,9 @@ async function inCheckTransaction(url, scratch, config, allowPooler, run) {
     await reserved.unsafe("begin");
     open = true;
     xid = await readXid(reserved);
-    await reserved.unsafe(`create schema ${quoteIdent(scratch)}`);
+    await reserved.unsafe(`create schema ${quoteIdent2(scratch)}`);
     created = true;
-    await reserved.unsafe(`set local search_path to ${quoteIdent(scratch)}`);
+    await reserved.unsafe(`set local search_path to ${quoteIdent2(scratch)}`);
     await setLocalTimeout(reserved, "lock_timeout", config.timeouts?.lock);
     await setLocalTimeout(reserved, "statement_timeout", config.timeouts?.statement);
     await ownScratch(reserved, scratch, config.roles?.migration);
@@ -271,7 +280,7 @@ async function dropScratch(url, scratch) {
     onnotice: () => {}
   });
   try {
-    await sql.unsafe(`drop schema if exists ${quoteIdent(scratch)} cascade`);
+    await sql.unsafe(`drop schema if exists ${quoteIdent2(scratch)} cascade`);
     const rows = await sql`
       select nspname from pg_namespace where nspname = ${scratch}
     `;
@@ -299,7 +308,7 @@ async function restoreSession(sql, session) {
   delete session.setRole;
 }
 async function replayMigration(sql, connection, scratch, config, migration, session, skips) {
-  await runSteps(sql, connection, scratch, config.roles?.migration, { ...migration, steps: retargetSteps(migration.steps, scratch) }, session, skips);
+  await runSteps(sql, connection, scratch, config.roles?.migration, { ...migration, steps: retargetSteps(migration.steps, scratch, config.namespace ?? "public") }, session, skips);
 }
 async function runSteps(sql, connection, scratch, migrationRole, migration, session, skips) {
   for (let index = 0;index < migration.steps.length; index += 1) {
@@ -326,7 +335,7 @@ async function runSteps(sql, connection, scratch, migrationRole, migration, sess
       if (created !== undefined && created === migrationRole) {
         if (!existed) {
           await grantSchema(connection, scratch, created);
-          await connection.execute(`grant select, insert, update on okm_meta, okm_history, okm_backfill to ${quoteIdent(created)}`);
+          await connection.execute(`grant select, insert, update on okm_meta, okm_history, okm_backfill to ${quoteIdent2(created)}`);
         }
         await assumeRole(connection, created, session);
       }
@@ -378,7 +387,7 @@ async function ownScratch(sql, scratch, role) {
   const exists = await sql.unsafe("select exists (select 1 from pg_roles where rolname = $1) as ok", [role]);
   const present = cell(exists[0], "ok");
   if (present === "t" || present === "true") {
-    await sql.unsafe(`alter schema ${quoteIdent(scratch)} owner to ${quoteIdent(role)}`);
+    await sql.unsafe(`alter schema ${quoteIdent2(scratch)} owner to ${quoteIdent2(role)}`);
   }
 }
 async function setLocalTimeout(sql, name, ms) {
@@ -476,6 +485,8 @@ async function checkMigrations(cwd, flags, options) {
       }
     });
   }
+  assertSnapshots(cwd, opened.config, opened.built.catalog);
+  await assertLiveExternal(target.url, opened.built.catalog, loadSnapshots(cwd, opened.config));
   const directory = projectPath(cwd, opened.config.migrations ?? "migrations");
   const history = readHistory(directory);
   const previous = previousFailures(history);
@@ -490,16 +501,21 @@ async function checkMigrations(cwd, flags, options) {
       throwFailure([equivalence]);
   }
   const replayed = await replayHistory(opened.config, target.url, flags, history);
+  const reprintErrors = replayed.reprints.filter((item) => item.severity === "error");
+  const reprintWarnings = replayed.reprints.filter((item) => item.severity === "warning");
   const failures = [...replayed.failures, ...previous, ...stale, ...lint];
+  if (reprintErrors.length > 0) {
+    const refusal = lintRefusal(reprintErrors);
+    failures.push({ code: refusal.code, message: refusal.message, fix: refusal.fix.summary });
+  }
   if (failures.length > 0)
-    throwFailure(failures);
+    throwFailure(failures, reprintWarnings);
   const summary = `ok ${String(history.length)} migrations
 `;
-  if (replayed.skips.length === 0)
-    return summary;
-  return `${summary}${replayed.skips.join(`
+  const skipped = replayed.skips.length === 0 ? "" : `${replayed.skips.join(`
 `)}
 `;
+  return `${summary}${skipped}${formatFindings(reprintWarnings)}`;
 }
 function previousCatalogGaps(before, after) {
   const afterBy = new Map(after.objects.map((object) => [identityKey2(object.identity), object]));
@@ -597,14 +613,16 @@ ${difference}`,
 }
 async function replayHistory(config, url, flags, history) {
   if (history.length === 0)
-    return { failures: [], skips: [] };
+    return { failures: [], skips: [], reprints: [] };
   const scratch = `${CHECK_SCHEMA_PREFIX}${crypto.randomUUID().replaceAll("-", "")}`;
   const outcome = await replayCheckHistory(url, scratch, config, flags.allowPooler || config.allowPooler === true, history);
-  if (outcome.stop === undefined)
-    return { failures: [], skips: outcome.skips };
+  if (outcome.stop === undefined) {
+    return { failures: [], skips: outcome.skips, reprints: outcome.reprints };
+  }
   return {
     failures: [historyFailure(history, outcome.stop.index, outcome.stop.back)],
-    skips: outcome.skips
+    skips: outcome.skips,
+    reprints: outcome.reprints
   };
 }
 function refuseTransactionControl(history) {
@@ -676,13 +694,16 @@ function readHistory(directory) {
     catalog: parseCatalog2(readFileSync(join(directory, `${migration.id}.catalog.json`), "utf8"))
   }));
 }
-function throwFailure(failures) {
+function throwFailure(failures, warnings = []) {
   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 } });
+  const notes = formatFindings(warnings).trim();
+  const text = notes.length === 0 ? message : `${message}
+${notes}`;
+  throw new OkmError2(first.code, text, { fix: { summary: first.fix } });
 }
 function checkedKind(kind) {
   return kind === "table" || kind === "column" || kind === "constraint" || kind === "type";