okmodel 0.9.0 → 0.9.1

package/dist/shared/{9dtgn1z2.js → 63qjmhnp.js}

@@ -1,3 +1,6 @@
+import {
+  assertParamCount2
+} from "./ddh72ym5.js";
 import {
   stack2
 } from "./mss6ctgv.js";
@@ -29,6 +32,7 @@ import {
   decodeRow,
   indexes,
   quote,
+  list,
   isRecord,
   registerFailFix,
   fail2
@@ -163,7 +167,7 @@ async function prepareWrite(host, op, table, input, options, mods, scope) {
     return {
       statements: planned.statements,
       options: callOptions(options),
-      ...planned.parentGuard === true ? { checked: "parent" } : planned.expect !== undefined ? { checked: "expect" } : {},
+      ...planned.parentGuard === true ? { checked: "parent" } : planned.treeGuard === true ? { checked: "tree" } : planned.expect !== undefined ? { checked: "expect" } : {},
       ...planned.recover === undefined ? {} : {
         follow: (results) => planned.recover?.(decodePlanned(withoutQuiet(results, planned.quiet), planned.outputs)) ?? []
       },
@@ -198,7 +202,7 @@ async function planWrite(schema, generators, op, tableName, input, options, mods
   }
   if (op === "update") {
     if (traitNamed(table, "versioned")) {
-      const { planVersioned } = await import("./3t6kw83m.js");
+      const { planVersioned } = await import("./zm2rzqba.js");
       return withRowFilters(scope, mods.archive, () => {
         noteArchive(table, mods.archive);
         const planned = planVersioned(schema, table, input, record, mods);
@@ -244,7 +248,7 @@ async function planInsert(table, input, options, mods, generators, scope, tenanc
       keyColumns: undefined
     };
   }
-  const conflictMod = options.onConflict === undefined || options.onConflict === "error" ? undefined : await import("./xwhdcrm4.js");
+  const conflictMod = options.onConflict === undefined || options.onConflict === "error" ? undefined : await import("./60y4ahmw.js");
   const conflict = conflictMod?.readConflict(table, options.onConflict, allow, tenantKeyList(tenancy));
   if (conflict?.kind === "update" && traitNamed(table, "versioned")) {
     fail2("OKM1120", `onConflict update on ${table.model.name} does not check the version you read.`, "Read the row and update. ignore and return do not change the existing row.");
@@ -308,7 +312,7 @@ function planUpdate(schema, table, input, options, mods, scope) {
     rejectDuplicateTargets2(table, rows);
     rejectMixedSets2(rows);
     for (const row of rows)
-      refuseTreeCycle(table, row.where, row.set, schema.tenancy?.key);
+      refuseTreeCycle(table, row.where, row.set, tenantKeys(schema.tenancy));
     const moves = rows.some((row) => pathField(schema.tenancy, table.model.name, row.set) !== undefined);
     if (moves) {
       return {
@@ -338,7 +342,8 @@ function planUpdate(schema, table, input, options, mods, scope) {
   requireFilter2(table, input.where, mods, "update");
   if (Object.keys(set).length === 0)
     fail2("OKM1120", "update set is empty.");
-  refuseTreeCycle(table, input.where, set, schema.tenancy?.key);
+  const keys = tenantKeys(schema.tenancy);
+  const cycle = refuseTreeCycle(table, input.where, set, keys);
   const where = stack2(input.where, mods.presets);
   const moved = pathAssignment(schema.tenancy, table.model.name, set, scope);
   if (moved !== undefined && claim !== undefined) {
@@ -365,6 +370,17 @@ function planUpdate(schema, table, input, options, mods, scope) {
       keyColumns: undefined
     };
   }
+  if (cycle !== undefined) {
+    return {
+      statements: [treeSetUpdate(schema, table, where, set, cycle, returning)],
+      outputs: parentOutputs(returning),
+      shape: returning === undefined ? "count" : "rows",
+      expect,
+      keys: undefined,
+      keyColumns: undefined,
+      treeGuard: true
+    };
+  }
   const sql = new Sql2;
   sql.text("update ");
   sql.text(quote(table.model.sql));
@@ -411,6 +427,8 @@ function finish(results, planned, table) {
     return finishVersioned(results, planned, table);
   if (planned.parentGuard === true)
     return finishParent(results, planned, table);
+  if (planned.treeGuard === true)
+    return finishTree(results, planned, table);
   if (planned.shape === "count") {
     let count = 0;
     for (const result of results)
@@ -439,6 +457,18 @@ function finishParent(results, planned, table) {
       fix: { summary: "Point the foreign key at a parent in this tenant." }
     });
   }
+  return finishGuarded(results, planned, table, updated);
+}
+function finishTree(results, planned, table) {
+  const row = results[0]?.rows[0];
+  const matched = countCell(row?.[0]);
+  const updated = countCell(row?.[1]);
+  if (updated < matched) {
+    fail2("OKM1120", `update on ${table} cannot point a tree row at itself or its descendant.`, "Set the parent to another row that is not under this one. A filter that is not the primary key is not checked.");
+  }
+  return finishGuarded(results, planned, table, updated);
+}
+function finishGuarded(results, planned, table, updated) {
   if (planned.shape === "count") {
     checkExpect(updated, planned.expect, table, "write");
     return { count: updated };
@@ -1074,6 +1104,7 @@ class Sql2 {
     };
   }
   statement() {
+    assertParamCount2(this.params.length);
     return this.params.length === 0 ? { text: this.parts.join("") } : { text: this.parts.join(""), params: this.params };
   }
 }
@@ -1084,7 +1115,7 @@ function insertRow(table, value, allow, tenancy) {
   for (const key of Object.keys(value)) {
     const column = table.columns.get(key);
     if (column === undefined)
-      continue;
+      refuseUnknownField(table, key);
     tenancy?.guard(table.model.name, key, "insert");
     if (!writable(table, column, allow, "insert"))
       refuse(table, column);
@@ -1094,6 +1125,9 @@ function insertRow(table, value, allow, tenancy) {
   refuseHalfMorph(table, row);
   return row;
 }
+function refuseUnknownField(table, key) {
+  throwNamed2("OKM1120", key, table.names, `Field ${key} is not on ${table.model.name}. Accepted names: ${list(table.names)}.`);
+}
 function cellsFor(columns, row) {
   return columns.map((column) => {
     if (!Object.hasOwn(row, column.field))
@@ -1200,10 +1234,10 @@ function writeSet2(table, value, allow, tenancy) {
   }
   const set = {};
   for (const key of Object.keys(value)) {
-    if (value[key] === undefined)
-      continue;
     const column = table.columns.get(key);
     if (column === undefined)
+      refuseUnknownField(table, key);
+    if (value[key] === undefined)
       continue;
     tenancy?.guard(table.model.name, key, "update");
     if (column.guardUpdate || !writable(table, column, allow, "update"))
@@ -1213,10 +1247,11 @@ function writeSet2(table, value, allow, tenancy) {
   refuseHalfMorph(table, set);
   return set;
 }
-function refuseTreeCycle(table, where, set, scopeKey) {
-  const own = keyedId(table, where, scopeKey);
-  if (own === undefined)
+function refuseTreeCycle(table, where, set, scopeKeys) {
+  const keyed = keyedId(table, where, scopeKeys);
+  if (keyed === undefined)
     return;
+  let found;
   for (const relation of table.model.relations) {
     if (relation.kind !== "many" || relation.through !== undefined || relation.morph !== undefined) {
       continue;
@@ -1231,17 +1266,20 @@ function refuseTreeCycle(table, where, set, scopeKey) {
       if (typeof value !== "string" && typeof value !== "number" && typeof value !== "bigint") {
         continue;
       }
-      if ((typeof value === "string" ? value : value.toString()) !== own)
-        continue;
-      fail2("OKM1120", `update on ${table.model.name}.${column.field} cannot point a tree row at itself.`, "Set the parent to another row. A filter that is not the primary key is not checked.");
+      const parent = typeof value === "string" ? value : value.toString();
+      if (parent === keyed.own) {
+        fail2("OKM1120", `update on ${table.model.name}.${column.field} cannot point a tree row at itself.`, "Set the parent to another row. A filter that is not the primary key is not checked.");
+      }
+      found = { own: keyed.own, parent, column, identity: keyed.identity };
     }
   }
+  return found;
 }
-function keyedId(table, where, scopeKey) {
+function keyedId(table, where, scopeKeys) {
   if (!isRecord(where))
     return;
   const primary = table.model.primary;
-  const required = primary.filter((field) => field !== scopeKey);
+  const required = primary.filter((field) => !scopeKeys.includes(field));
   const field = required.length === 1 ? required[0] : undefined;
   if (field === undefined || !Object.hasOwn(where, field))
     return;
@@ -1253,7 +1291,51 @@ function keyedId(table, where, scopeKey) {
   if (typeof value !== "string" && typeof value !== "number" && typeof value !== "bigint") {
     return;
   }
-  return String(value);
+  const identity = table.columns.get(field);
+  if (identity === undefined)
+    return;
+  return { own: String(value), identity };
+}
+function tenantKeys(tenancy) {
+  if (tenancy === undefined)
+    return [];
+  if (tenancy.keys !== undefined && tenancy.keys.length > 0)
+    return tenancy.keys;
+  return [tenancy.key];
+}
+function treeSetUpdate(schema, table, where, set, cycle, returning) {
+  const sql = new Sql2;
+  sql.text("with matched as (select ");
+  sql.text(rowId("t"));
+  sql.text(" from ");
+  sql.text(quote(table.model.sql));
+  sql.text(" as t");
+  emitFilter(schema, table, where, sql, "t");
+  sql.text("), updated as (update ");
+  sql.text(quote(table.model.sql));
+  sql.text(" as t set ");
+  emitSet2(sql, table, set, "t");
+  sql.text(" where (");
+  sql.text(rowId("t"));
+  sql.text(") in (select tableoid, ctid from matched) and not exists (with recursive d as (select ");
+  sql.text(quote(cycle.identity.sql));
+  sql.text(" as k from ");
+  sql.text(quote(table.model.sql));
+  sql.text(" where ");
+  sql.text(quote(cycle.column.sql));
+  sql.text(" = ");
+  sql.param(cycle.own, cycle.identity.dataType);
+  sql.text(" union all select c.");
+  sql.text(quote(cycle.identity.sql));
+  sql.text(" from ");
+  sql.text(quote(table.model.sql));
+  sql.text(" c join d on c.");
+  sql.text(quote(cycle.column.sql));
+  sql.text(" = d.k) select 1 from d where d.k = ");
+  sql.param(cycle.parent, cycle.identity.dataType);
+  sql.text(")");
+  endParent(sql, returning);
+  return sql.statement();
 }
 function columnBySql(table, sql) {
   for (const column of table.model.columns) {
@@ -1362,6 +1444,7 @@ function chunkRows(rows) {
 function withParams(text, params) {
   if (params === undefined || params.length === 0)
     return { text };
+  assertParamCount2(params.length);
   return { text, params };
 }
 function keyWire(columns, row) {

package/dist/shared/{s7he5e5d.js → 67w3kn71.js}

@@ -2,7 +2,7 @@ import {
   readHandle,
   readCall,
   attachHttp
-} from "./npdftanb.js";
+} from "./xbvz446k.js";
 import {
   decodeResult,
   emitWhere,

package/dist/shared/{n306gqkd.js → 6vfvsdkt.js}

@@ -4,16 +4,18 @@ import {
   applyProject2,
   pushProject2,
   backfillTiming2
-} from "./ccsmhv9r.js";
-import"./3456242y.js";
-import"./jpybhf98.js";
-import"./myk8fswx.js";
-import"./2zdxkt7b.js";
-import"./6nae0spm.js";
+} from "./8ma6drzr.js";
+import"./8p2bgye0.js";
+import"./6xqvesa5.js";
+import"./4pkz5nvw.js";
+import"./e1c55v04.js";
+import"./mz48rs74.js";
+import"./wp7y8q3y.js";
+import"./bdekbvmt.js";
 import"./n442h54c.js";
 import"./fk9vef30.js";
 import"./12z7aznj.js";
-import"./dd5pmnky.js";
+import"./jvxcp1qk.js";
 export {
   applyProject2 as applyProject,
   applyTarget2 as applyTarget,

package/dist/shared/{jpybhf98.js → 6xqvesa5.js}

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

package/dist/shared/{n5whk3mt.js → 8gdbty5v.js}

@@ -1,18 +1,18 @@
 import"./12z7aznj.js";
 import"./fk9vef30.js";
 import"./n442h54c.js";
-import"./dd5pmnky.js";
+import"./jvxcp1qk.js";
 import {
   emitPull,
   formatPullReport,
   pullLayout2,
   commitPullFiles2
-} from "./rbxt795q.js";
-import"./myk8fswx.js";
+} from "./c7dqd3gk.js";
+import"./mz48rs74.js";
 import {
   loadConfig
-} from "./2zdxkt7b.js";
-import"./6nae0spm.js";
+} from "./wp7y8q3y.js";
+import"./bdekbvmt.js";
 import {
   catalog,
   enumType
@@ -452,14 +452,14 @@ function columnOf(parent, property, value, primaryColumns, enums, objects, names
     }));
   }
   const defaultExpression = serial || identity !== undefined || generated !== undefined ? undefined : readDefault(value, extras, `${tableName}.${sqlName}`);
-  const nullable = flag(value, "notNull") ? false : true;
   const dataType = note !== undefined ? note.name : mapped.dataType;
-  const solePrimary = identity?.always === true && dataType === "bigint" && !nullable && primaryColumns.length === 1 && primaryColumns[0] === sqlName;
+  const inPrimary = primaryColumns.includes(sqlName);
+  const nullable = inPrimary || flag(value, "notNull") ? false : true;
   return column2({
     parent,
     name: sqlName,
     dataType,
-    nullable: solePrimary ? false : nullable,
+    nullable,
     provenance: provenanceOf(`field:${property}`),
     ...defaultExpression !== undefined ? { defaultExpression } : {},
     ...identity !== undefined ? { identity } : {},

package/dist/shared/{ccsmhv9r.js → 8ma6drzr.js}

@@ -1,12 +1,18 @@
 import {
   open2
-} from "./dd5pmnky.js";
+} from "./jvxcp1qk.js";
 import {
   startupHash2
 } from "./12z7aznj.js";
 import {
   quoteIdent2
 } from "./fk9vef30.js";
+import {
+  sealViews,
+  sealDomainChecks2,
+  catalogQuery2,
+  managedRoleOptions2
+} from "./4pkz5nvw.js";
 import {
   runTarget,
   assumeRole,
@@ -17,14 +23,21 @@ import {
   provisionMark,
   expandProvisioned,
   installSnapshot
-} from "./3456242y.js";
+} from "./8p2bgye0.js";
 import {
   assertCreateRole,
   currentUser,
   roleExists
-} from "./jpybhf98.js";
+} from "./6xqvesa5.js";
+import {
+  probeStableBackend
+} from "./e1c55v04.js";
+import {
+  introspectSchema
+} from "./mz48rs74.js";
 import {
   projectPath,
+  assertSnapshots,
   loadMigrations,
   loadHeadSnapshot,
   lintMigrationDirectory,
@@ -33,8 +46,9 @@ import {
   projectHead,
   loadBuiltSchema,
   loadConfig
-} from "./2zdxkt7b.js";
+} from "./wp7y8q3y.js";
 import {
+  driverUrl,
   changesRole,
   batchSizeField,
   assertExtensionsAvailable,
@@ -42,9 +56,8 @@ import {
   finishQuiet,
   assertTargetPolicy,
   assertDirectConnection,
-  assertStableBackend,
   selectTarget
-} from "./6nae0spm.js";
+} from "./bdekbvmt.js";
 import {
   UUIDV7_POSTGRES,
   uuidv7NeedsPostgres
@@ -99,6 +112,7 @@ function unquote(name) {
 }
 
 // src/tooling/migrate/apply.ts
+import postgres from "postgres";
 var DEFAULT_LOCK_MS = 5000;
 var DEFAULT_STATEMENT_MS = 30000;
 var DEFAULT_RETRIES = 3;
@@ -173,8 +187,9 @@ function applyUnits(migration, done) {
 }
 async function applyTarget2(request) {
   assertDirectConnection(request.url, request.allowPooler === true);
+  const url = driverUrl(request.url);
   const pool = open2({
-    url: request.url,
+    url,
     max: 1,
     ...request.searchPath !== undefined ? { searchPath: request.searchPath } : {}
   });
@@ -188,7 +203,7 @@ async function applyTarget2(request) {
   const connection = reserved;
   let locked = false;
   try {
-    await assertStableBackend(() => backendPid(connection), request.allowPooler === true);
+    await probeStableBackend(request.url, () => backendPid(connection), request.allowPooler === true);
     await assertStandardStrings(connection);
     await setTimeouts(connection, request);
     await lockTarget(connection, request.target);
@@ -234,8 +249,11 @@ async function applyTarget2(request) {
     if (request.snapshot !== undefined) {
       await insertReference(connection, request);
     }
+    const desiredHash = request.headHash;
+    const headStamp = desiredHash === undefined || request.restampHead !== true ? [] : await restampHeadHash(connection, request, nextSequenceId("restamp", history.ids), desiredHash);
     await grantAppMeta(connection, request.appRole, session);
-    return restamped.length === 0 ? report : { ...report, restamped };
+    const stamped = [...restamped, ...headStamp];
+    return stamped.length === 0 ? report : { ...report, restamped: stamped };
   } finally {
     if (locked) {
       await finishQuiet(() => connection.execute("select pg_advisory_unlock(hashtext($1))", [lockKey(request.target)]));
@@ -259,7 +277,10 @@ nothing to apply
       return;
     throw error;
   });
+  if (built !== undefined)
+    assertSnapshots(cwd, config, built.catalog);
   const progress = [];
+  const externalConfigured = (config.external ?? []).length > 0;
   const report = await applyTarget2({
     url: target.url,
     target: target.name,
@@ -276,6 +297,8 @@ nothing to apply
       catalogHash: head.catalogHash,
       reference: built === undefined ? [] : readReference(built.tables, built.casing, head.catalog)
     },
+    ...built !== undefined ? { headHash: startupHash2(built.catalog) } : {},
+    ...externalConfigured ? { restampHead: true } : {},
     ...config.roles !== undefined ? { migrationRole: config.roles.migration, appRole: config.roles.app } : {},
     ...catalogSchema(config.namespace),
     lintDirectory: directory,
@@ -299,37 +322,176 @@ async function pushProject2(cwd, flags) {
   const target = selectTarget(config, flags.target);
   assertTargetPolicy(target, "push", flags.allowProtected);
   const head = await projectHead(cwd);
-  const plan = planMigration({
-    before: head.previous,
+  assertSnapshots(cwd, config, head.catalog);
+  const catalogHash = startupHash2(head.catalog);
+  const report = await pushTarget({
+    url: target.url,
+    target: target.name,
+    protected: target.protected,
+    allowProtected: flags.allowProtected,
+    allowPooler: flags.allowPooler || config.allowPooler === true,
+    ...backfillTiming2(config.backfill),
     after: head.catalog,
     renames: head.renames,
-    name: "push",
+    catalogHash,
+    ...config.roles !== undefined ? { migrationRole: config.roles.migration, appRole: config.roles.app, roles: config.roles } : {},
     ...catalogSchema(config.namespace),
     ...batchSizeField(config.backfill?.batchSize)
   });
-  if (plan.steps.length === 0)
+  if (report.applied.length === 0 && (report.restamped ?? []).length === 0) {
     return `target ${target.name}
 no changes
 `;
-  const report = await applyTarget2({
-    url: target.url,
-    target: target.name,
-    protected: target.protected,
-    allowProtected: flags.allowProtected,
-    allowPooler: flags.allowPooler || config.allowPooler === true,
-    ...backfillTiming2(config.backfill),
-    migrations: [
-      {
-        id: "push",
-        catalogHash: startupHash2(head.catalog),
-        steps: plan.steps
-      }
-    ],
-    ...config.roles !== undefined ? { migrationRole: config.roles.migration, appRole: config.roles.app } : {},
-    ...catalogSchema(config.namespace)
-  });
+  }
   return formatReport(report);
 }
+async function pushTarget(request) {
+  assertDirectConnection(request.url, request.allowPooler === true);
+  const url = driverUrl(request.url);
+  const pool = open2({
+    url,
+    max: 1,
+    ...request.searchPath !== undefined ? { searchPath: request.searchPath } : {}
+  });
+  if (pool.reserve === undefined) {
+    await pool.close();
+    throw new OkmError2("invalid", "The driver cannot reserve a connection.", {
+      fix: { summary: "Push needs a driver with interactive transactions." }
+    });
+  }
+  const connection = await pool.reserve();
+  let locked = false;
+  try {
+    await probeStableBackend(request.url, () => backendPid(connection), request.allowPooler === true);
+    await assertStandardStrings(connection);
+    await setTimeouts(connection, {
+      url: request.url,
+      target: request.target,
+      protected: request.protected,
+      migrations: []
+    });
+    await lockTarget(connection, request.target);
+    locked = true;
+    const session = {};
+    const schema = request.schema ?? "public";
+    await enterCatalogSchema(connection, schema);
+    await ensureMigrationTables2((sql) => connection.execute(sql));
+    const history = await readHistory(connection);
+    const pushId = nextSequenceId("push", history.ids);
+    const sql = postgres(url, {
+      max: 1,
+      connect_timeout: 5,
+      idle_timeout: 1,
+      onnotice: () => {},
+      ...schema !== "public" ? { connection: { search_path: schema } } : {}
+    });
+    let planSteps = [];
+    try {
+      const runner = catalogQuery2(sql);
+      if (schema !== "public") {
+        await sql.unsafe(`create schema if not exists ${quoteIdent2(schema)}`);
+        await sql.unsafe(`set search_path to ${quoteIdent2(schema)}`);
+      }
+      const authorViews = await sealViews(runner, request.after);
+      const author = await sealDomainChecks2(runner, authorViews);
+      const live = await introspectSchema(runner, schema, schema, managedRoleOptions2(request.roles));
+      const plan = planMigration({
+        before: live,
+        after: author,
+        renames: request.renames,
+        name: pushId,
+        ...request.schema !== undefined ? { schema: request.schema } : {},
+        ...request.batchSize !== undefined ? { batchSize: request.batchSize } : {}
+      });
+      planSteps = plan.steps;
+    } finally {
+      await finishQuiet(() => sql.end({ timeout: 5 }));
+    }
+    if (planSteps.length === 0) {
+      const stamped = await restampHeadHash(connection, request, pushId, request.catalogHash);
+      await grantAppMeta(connection, request.appRole, session);
+      if (stamped.length === 0) {
+        return { target: request.target, applied: [] };
+      }
+      return { target: request.target, applied: [], restamped: stamped };
+    }
+    const migration = {
+      id: pushId,
+      catalogHash: request.catalogHash,
+      steps: planSteps
+    };
+    await prepareMigrationRole(connection, {
+      url: request.url,
+      target: request.target,
+      protected: request.protected,
+      migrations: [migration],
+      ...request.migrationRole !== undefined ? { migrationRole: request.migrationRole } : {},
+      ...request.schema !== undefined ? { schema: request.schema } : {}
+    }, session);
+    await assertExtensionsAvailable(connection, [migration]);
+    await assertUuidV7Available(connection, [migration]);
+    const units = applyUnits(migration, new Set);
+    const report = await runTarget(connection, {
+      policy: {
+        target: request.target,
+        protected: request.protected,
+        allowProtected: request.allowProtected === true
+      },
+      units,
+      retries: DEFAULT_RETRIES,
+      lockTimeoutMs: DEFAULT_LOCK_MS,
+      statementTimeoutMs: DEFAULT_STATEMENT_MS,
+      backfillStatementTimeoutMs: request.backfillStatementTimeoutMs ?? DEFAULT_STATEMENT_MS,
+      ...request.backfillPauseMs !== undefined ? { backfillPauseMs: request.backfillPauseMs } : {},
+      ...request.migrationRole !== undefined ? { migrationRole: request.migrationRole } : {},
+      ...request.schema !== undefined ? { schema: request.schema } : {}
+    }, session);
+    await grantAppMeta(connection, request.appRole, session);
+    return report;
+  } finally {
+    if (locked) {
+      await finishQuiet(() => connection.execute("select pg_advisory_unlock(hashtext($1))", [lockKey(request.target)]));
+    }
+    await finishQuiet(() => connection.release());
+    await finishQuiet(() => pool.close());
+  }
+}
+async function restampHeadHash(connection, request, migrationId, catalogHash) {
+  const present = await connection.execute("select to_regclass('okm_meta') is not null");
+  if (!wireTrue(present.rows[0]?.[0]))
+    return [];
+  const current = await connection.execute("select catalog_hash from okm_meta where id = 'head'");
+  const stored = current.rows[0]?.[0];
+  if (typeof stored === "string" && stored === catalogHash)
+    return [];
+  assertTargetPolicy({ name: request.target, protected: request.protected }, "history-repair", request.allowProtected === true);
+  await connection.execute("begin");
+  try {
+    await connection.execute("insert into okm_history (migration_id, step_index, class, catalog_hash) values ($1, 0, 'expand', $2)", [migrationId, catalogHash]);
+    await connection.execute(`insert into okm_meta (id, catalog_hash, migration_id) values ('head', $1, $2)
+       on conflict (id) do update set catalog_hash = excluded.catalog_hash, migration_id = excluded.migration_id`, [catalogHash, migrationId]);
+    await connection.execute("commit");
+  } catch (error) {
+    await connection.execute("rollback").catch(() => {
+      return;
+    });
+    throw error;
+  }
+  return [migrationId];
+}
+function nextSequenceId(prefix, ids) {
+  const pattern = new RegExp(`^${prefix}-(\\d+)$`);
+  let max = 0;
+  for (const id of ids) {
+    const match = pattern.exec(id);
+    if (match === null)
+      continue;
+    const value = Number(match[1]);
+    if (Number.isFinite(value) && value > max)
+      max = value;
+  }
+  return `${prefix}-${String(max + 1)}`;
+}
 function backfillTiming2(backfill) {
   return {
     ...backfill?.pauseMs !== undefined ? { backfillPauseMs: backfill.pauseMs } : {},
@@ -341,10 +503,11 @@ function formatReport(report) {
 ` : "";
   const restamped = (report.restamped ?? []).map((id) => `restamped ${id}
 `).join("");
-  if (report.applied.length === 0)
+  if (report.applied.length === 0) {
     return `target ${report.target}
 ${role}${restamped}nothing to apply
 `;
+  }
   return `target ${report.target}
 ${role}${restamped}${report.applied.map((id) => `applied ${id}`).join(`
 `)}