okmodel 0.5.0 → 0.5.1

package/dist/shared/{wxn4b7pp.js → sycnx8gt.js}

@@ -6,8 +6,10 @@ import {
   introspectSchema
 } from "./fancm5pt.js";
 import {
-  planMigration
-} from "./ayz64vzj.js";
+  planMigration,
+  assertDirectConnection,
+  assertStableBackend
+} from "./ga3sfy93.js";
 import {
   quoteIdent,
   createObjectSql
@@ -49,8 +51,11 @@ async function sealViews(runner, source) {
     return source;
   await dropScratch(runner);
   await runner.query(`create schema ${quoteIdent(SCRATCH)}`);
+  const previous = await runner.query(`select current_setting('search_path') as path`);
+  const saved = cellText(previous[0]?.path);
+  const path = await scratchSearchPath(runner, source);
   try {
-    await runner.query(`set search_path to ${quoteIdent(SCRATCH)}`);
+    await runner.query(`select set_config('search_path', $1, false)`, [path]);
     await createObjects(runner, source, "type");
     for (const object of source.objects) {
       if (object.kind !== "table")
@@ -99,10 +104,37 @@ async function sealViews(runner, source) {
     });
     return catalog(next);
   } finally {
-    await runner.query("set search_path to public");
+    await runner.query(`select set_config('search_path', $1, false)`, [saved]).catch(() => {
+      return;
+    });
     await dropScratch(runner);
   }
 }
+async function scratchSearchPath(runner, source) {
+  const names = new Set;
+  for (const object of source.objects) {
+    if (object.kind !== "column")
+      continue;
+    const bare = object.definition.dataType.split(".").pop()?.replace(/\(.*$/, "").replace(/\[\]$/, "").trim().toLowerCase();
+    if (bare !== undefined && bare.length > 0)
+      names.add(bare);
+  }
+  const extra = [];
+  if (names.size > 0) {
+    const rows = await runner.query(`select distinct n.nspname as schema
+       from pg_type t
+       join pg_namespace n on n.oid = t.typnamespace
+       where t.typname = any(string_to_array($1, E'\\x1f'))
+         and n.nspname not in ('pg_catalog', 'information_schema', 'pg_toast')`, [[...names].join("\x1F")]);
+    for (const row of rows) {
+      const schema = cellText(row.schema);
+      if (schema.length > 0 && schema !== "public" && schema !== SCRATCH)
+        extra.push(schema);
+    }
+  }
+  extra.sort();
+  return [SCRATCH, ...extra, "public"].map((name) => quoteIdent(name)).join(", ");
+}
 async function createObjects(runner, source, kind) {
   for (const object of source.objects) {
     if (object.kind !== kind)
@@ -193,7 +225,8 @@ async function dropScratch(runner) {
 }
 
 // src/tooling/migrate/drift.ts
-async function assertAuthorDrift2(url, author, roles) {
+async function assertAuthorDrift2(url, author, roles, allowPooler = false) {
+  assertDirectConnection(url, allowPooler);
   const sql = postgres(url, {
     max: 1,
     connect_timeout: 5,
@@ -201,6 +234,10 @@ async function assertAuthorDrift2(url, author, roles) {
     onnotice: () => {}
   });
   try {
+    await assertStableBackend(async () => {
+      const rows = await sql`select pg_backend_pid()::text as pid`;
+      return rows[0]?.pid ?? "";
+    }, allowPooler);
     const present = await sql`
       select to_regclass('public.okm_meta')::text as reg
     `;

package/dist/shared/{dxjp14rk.js → tm5ab8we.js}

@@ -3,10 +3,10 @@ import {
   readHandle,
   readCall,
   attachHttp
-} from "./bt9sfq0z.js";
+} from "./hf22e0wt.js";
 import {
   fail
-} from "./qgvt8nx1.js";
+} from "./gbtcc2d7.js";
 import {
   OkmError2,
   throwNamed2

package/dist/shared/{g516zdsb.js → v36c5g6p.js}

@@ -3,7 +3,7 @@ import {
 } from "./8xsbagad.js";
 import {
   createClient
-} from "./bt9sfq0z.js";
+} from "./hf22e0wt.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -463,6 +463,9 @@ function fieldOf(facts, sql) {
 function cacheKey(table, tenant) {
   return `${tenant ?? "*"}:${table}`;
 }
+function forgetCached(host, table, tenant) {
+  host.cache.delete(cacheKey(table, tenant));
+}
 function refOf(value) {
   if (typeof value !== "object" || value === null || !(REF in value))
     return;
@@ -502,14 +505,14 @@ function isRow(value) {
 }
 
 // src/tooling/testing/isolation.ts
-var TENANT_A = "00000000-0000-4000-8000-00000000000a";
-var TENANT_B = "00000000-0000-4000-8000-00000000000b";
 async function isolation(host) {
   const saved = host.cache;
   host.cache = new Map;
   try {
     const checked = [];
     const skipped = [];
+    const tenantA = crypto.randomUUID();
+    const tenantB = crypto.randomUUID();
     for (const facts of host.facts.values()) {
       if (facts.globalReason !== undefined) {
         skipped.push({ table: facts.name, reason: facts.globalReason });
@@ -517,7 +520,7 @@ async function isolation(host) {
       }
       if (!facts.tenant)
         continue;
-      await checkTable(host, facts);
+      await checkTable(host, facts, tenantA, tenantB);
       checked.push(facts.name);
     }
     return { checked, skipped };
@@ -525,25 +528,68 @@ async function isolation(host) {
     host.cache = saved;
   }
 }
-async function checkTable(host, facts) {
+async function checkTable(host, facts, tenantA, tenantB) {
   const key = host.schema.tenancy?.key;
   if (key === undefined)
     return;
-  const row = await insertRow(host, facts.name, { [key]: TENANT_B }, undefined, TENANT_B);
+  if (host.definitions.size > 0 && !host.definitions.has(facts.name)) {
+    throw new OkmError2("invalid", `Factory ${facts.name} is missing.`, {
+      fix: { summary: `Add ${facts.name} to factories().` }
+    });
+  }
+  const row = await insertRow(host, facts.name, { [key]: tenantB }, undefined, tenantB);
   const where = primaryWhere(facts, row, key);
-  const client = openTenant(host, TENANT_A);
+  const client = openTenant(host, tenantA);
   const handle = tableHandle2(client, facts.name);
-  const found = await handle.find({ where, limit: 1 });
-  const rows = asRows(found);
+  try {
+    await readTenant(facts, handle, where);
+    const set = updateSet(host, facts, row);
+    if (set !== undefined) {
+      const updated = asCount(await handle.update({ where, set }));
+      if (updated > 0)
+        leak(facts.name, "update", { count: updated });
+      if (typeof client.batch === "function") {
+        const batched = await client.batch([handle.update({ where, set })]);
+        if (Array.isArray(batched) && batched.some((item) => asCount(item) > 0)) {
+          leak(facts.name, "batch", batched);
+        }
+      }
+    }
+    const removed = asCount(await handle.delete({ where }));
+    if (removed > 0)
+      leak(facts.name, "delete", { count: removed });
+  } finally {
+    const owner = tableHandle2(openTenant(host, tenantB), facts.name);
+    await owner.delete({ where }).catch(() => {
+      return;
+    });
+    forgetCached(host, facts.name, tenantB);
+  }
+}
+async function readTenant(facts, handle, where) {
+  const query = handle.find({ where, limit: 1 });
+  const rows = asRows(await query);
   if (rows.length > 0)
     leak(facts.name, "find", rows[0]);
+  const streamed = handle.find({ where, limit: 1 });
+  if (typeof streamed.stream === "function") {
+    try {
+      for await (const item of streamed.stream()) {
+        if (isRow2(item))
+          leak(facts.name, "stream", item);
+      }
+    } catch (error) {
+      if (!(error instanceof OkmError2) || error.code !== "OKM1111")
+        throw error;
+    }
+  }
   const one = await handle.one({ where });
   if (isRow2(one))
     leak(facts.name, "one", one);
-  const counted = asCount(await handle.count());
+  const counted = asCount(await handle.count({ where }));
   if (counted > 0)
     leak(facts.name, "count", { count: counted });
-  const exists = await handle.exists();
+  const exists = await handle.exists({ where });
   if (exists === true)
     leak(facts.name, "exists", { exists: true });
   const relation = facts.relations[0];
@@ -552,15 +598,28 @@ async function checkTable(host, facts) {
     if (isRow2(included))
       leak(facts.name, "include", included);
   }
-  const set = updateSet(host, facts, row);
-  if (set !== undefined) {
-    const updated = asCount(await handle.update({ where, set }));
-    if (updated > 0)
-      leak(facts.name, "update", { count: updated });
+  if (typeof handle.aggregate === "function") {
+    const aggregated = await handle.aggregate({ where, count: true });
+    if (Array.isArray(aggregated)) {
+      for (const item of aggregated) {
+        if (isRow2(item) && asCount(item) > 0)
+          leak(facts.name, "aggregate", item);
+      }
+    }
+  }
+  if (typeof handle.page === "function") {
+    const orderField = Object.keys(where)[0];
+    if (orderField !== undefined) {
+      const paged = await handle.page({
+        where,
+        orderBy: { [orderField]: "asc" },
+        limit: 5
+      });
+      if (isRow2(paged) && Array.isArray(paged.items) && paged.items.length > 0) {
+        leak(facts.name, "page", paged.items[0]);
+      }
+    }
   }
-  const deleted = asCount(await handle.delete({ where }));
-  if (deleted > 0)
-    leak(facts.name, "delete", { count: deleted });
 }
 function includeOf(relation) {
   if (relation.kind === "many")

package/dist/shared/wq9n6pwr.js

@@ -0,0 +1,139 @@
+import {
+  tag
+} from "./cn0n68ft.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/dialects/pg/filter-parse.ts
+var PARSED_OPS = ",eq,in,inList,notIn,lt,lte,gt,gte,between,startsWith,endsWith,contains,like,ilike,";
+var PARSED_FIX = "Use eq, in, notIn, lt, lte, gt, gte, between, startsWith, endsWith, contains, like, or ilike.";
+function parseQuery(allow, sort, query) {
+  if (typeof query !== "object" || query === null || Array.isArray(query)) {
+    throw new OkmError2("OKM1121", "filters parse expects an object of fields.");
+  }
+  for (const field of Object.keys(allow)) {
+    for (const op of allow[field] ?? []) {
+      if (PARSED_OPS.includes(`,${op},`))
+        continue;
+      throw new OkmError2("OKM1120", `filters() cannot apply ${op} on ${field}.`, {
+        fix: { summary: PARSED_FIX }
+      });
+    }
+  }
+  const whereParts = [];
+  let orderBy;
+  for (const key of Object.keys(query)) {
+    const value = query[key];
+    if (key === "sort" && typeof value === "string" && sort.includes(value)) {
+      orderBy = { [value]: "asc" };
+      continue;
+    }
+    if (!Object.hasOwn(allow, key)) {
+      throw new OkmError2("OKM1123", `Field ${key} is not in the allow list.`, {
+        fix: { summary: "Remove the field, or add it to filters({ allow })." }
+      });
+    }
+    const ops = allow[key] ?? [];
+    whereParts.push(...clauses(key, ops, value));
+  }
+  const where = combine(whereParts);
+  return orderBy === undefined ? { where } : { where, orderBy };
+}
+function clauses(field, ops, value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    if (!ops.includes("eq")) {
+      throw new OkmError2("OKM1120", `filters() cannot apply eq on ${field}.`, {
+        fix: { summary: "Add eq to that field, or send an object of allowed operators." }
+      });
+    }
+    return [{ [field]: value }];
+  }
+  const applied = [];
+  for (const op of Object.keys(value)) {
+    if (!Object.hasOwn(value, op))
+      continue;
+    if (!ops.includes(op) && !(op === "inList" && ops.includes("in"))) {
+      throw new OkmError2("OKM1120", `filters() cannot apply ${op} on ${field}.`, {
+        fix: { summary: "Send an operator that field's allow list names." }
+      });
+    }
+    applied.push(one(field, op, value[op]));
+  }
+  if (applied.length === 0) {
+    throw new OkmError2("OKM1120", `filters() cannot apply a value on ${field}.`, {
+      fix: { summary: "Send eq as a scalar, or an object of allowed operators." }
+    });
+  }
+  return applied;
+}
+function one(field, op, value) {
+  switch (op) {
+    case "eq":
+      return {
+        [field]: value !== null && typeof value === "object" ? tag("eq", value) : value
+      };
+    case "in":
+    case "inList":
+      return { [field]: tag("inList", list(value, op)) };
+    case "notIn":
+      return { [field]: tag("notIn", list(value, op)) };
+    case "lt":
+      return { [field]: tag("lt", value) };
+    case "lte":
+      return { [field]: tag("lte", value) };
+    case "gt":
+      return { [field]: tag("gt", value) };
+    case "gte":
+      return { [field]: tag("gte", value) };
+    case "between": {
+      if (!Array.isArray(value) || value.length !== 2) {
+        throw new OkmError2("OKM1120", `between on ${field} needs two bounds.`, {
+          fix: { summary: "Send between as [from, to]." }
+        });
+      }
+      return { [field]: tag("between", [value[0], value[1]]) };
+    }
+    case "startsWith":
+      return { [field]: tag("startsWith", text(value, op)) };
+    case "endsWith":
+      return { [field]: tag("endsWith", text(value, op)) };
+    case "contains":
+      return { [field]: tag("contains", value) };
+    case "like":
+      return { [field]: tag("like", text(value, op)) };
+    case "ilike":
+      return { [field]: tag("ilike", text(value, op)) };
+    default:
+      throw new OkmError2("OKM1120", `filters() cannot apply ${op} on ${field}.`, {
+        fix: { summary: "Use an operator parse applies." }
+      });
+  }
+}
+function combine(parts) {
+  const first = parts[0];
+  if (first === undefined)
+    return {};
+  if (parts.length === 1)
+    return first;
+  return tag("and", parts);
+}
+function list(value, op) {
+  if (!Array.isArray(value)) {
+    throw new OkmError2("OKM1120", `${op} needs an array.`, {
+      fix: { summary: "Send that operator an array of values." }
+    });
+  }
+  return value;
+}
+function text(value, op) {
+  if (typeof value !== "string") {
+    throw new OkmError2("OKM1120", `${op} needs a string.`, {
+      fix: { summary: "Send that operator a string." }
+    });
+  }
+  return value;
+}
+export {
+  parseQuery
+};

package/dist/shared/{7p2wbz7f.js → x72jb7ad.js}

@@ -6,7 +6,7 @@ import {
   acquireTimeout2,
   errorField2,
   mapDriverError2
-} from "./kyxb62mc.js";
+} from "./31vm914h.js";
 export {
   DriverError2 as DriverError,
   acquireTimeout2 as acquireTimeout,

package/dist/shared/{922qbgnw.js → zqrnhwsq.js}

@@ -1,9 +1,9 @@
 import {
   withHttp
-} from "./bt9sfq0z.js";
+} from "./hf22e0wt.js";
 import {
   decodeResult
-} from "./qgvt8nx1.js";
+} from "./gbtcc2d7.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -17,7 +17,7 @@ async function* streamRows(session, call, prepare, log) {
     })));
   }
   const { plan, params } = await prepare();
-  const decode = plan.outputs.includes.length === 0 ? decodeResult : (await import("./h8ne16fq.js")).decodeIncluded;
+  const decode = plan.outputs.includes.length === 0 ? decodeResult : (await import("./nkaxvt9q.js")).decodeIncluded;
   for await (const chunk of session.pool.stream(plan.text, params)) {
     const decoded = decode(plan, chunk, call.table);
     if (!Array.isArray(decoded))

package/dist/tooling/cli.js

@@ -1,6 +1,6 @@
 import"../shared/8bwbwy8h.js";
 import"../shared/n442h54c.js";
-import"../shared/wqem4jed.js";
+import"../shared/krxx77g0.js";
 import {
   formatFindings,
   hasError,
@@ -9,8 +9,8 @@ import {
   generateProject,
   planProject,
   checkProject
-} from "../shared/xdpj5kkm.js";
-import"../shared/ayz64vzj.js";
+} from "../shared/qv2ydck9.js";
+import"../shared/ga3sfy93.js";
 import"../shared/8xsbagad.js";
 import {
   OkmError2
@@ -22,14 +22,28 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/tooling/migrate/commands.ts
-function formatFailure(error) {
-  return `${error.code}: ${error.message}
-${error.fix.summary}
+function formatFailure(error, verbose = false) {
+  const mapped = OkmError2.from(error);
+  let text = `error ${mapped.code}: ${mapped.message}
+${mapped.fix.summary}
 `;
+  if (verbose && error instanceof Error && error.stack !== undefined) {
+    text += `${error.stack}
+`;
+  }
+  return text;
 }
 async function run(argv, io) {
   const cwd = io?.cwd ?? process.cwd();
   const stdout = io?.stdout ?? ((text) => process.stdout.write(text));
+  if (argv.length === 0 || argv[0] === "help" || argv[0] === "--help" || argv[0] === "-h") {
+    stdout(commandsTable());
+    return;
+  }
+  if (argv.includes("--help") || argv.includes("-h")) {
+    stdout(commandHelp(argv.filter((arg) => arg !== "--help" && arg !== "-h")));
+    return;
+  }
   const [command, ...rest] = argv;
   if (command === "build") {
     const directory = await buildProject(cwd);
@@ -57,12 +71,12 @@ async function run(argv, io) {
     return;
   }
   if (command === "dev") {
-    const { devProject } = await import("../shared/fyqkk1m0.js");
+    const { devProject } = await import("../shared/sdc7r2ww.js");
     stdout(await devProject(cwd));
     return;
   }
   if (command === "push") {
-    const { pushProject } = await import("../shared/rasvvzgz.js");
+    const { pushProject } = await import("../shared/q58y17hy.js");
     stdout(await pushProject(cwd, invoke(splitFlags(rest))));
     return;
   }
@@ -81,17 +95,17 @@ async function run(argv, io) {
       return;
     }
     if (sub === "apply") {
-      const { applyProject } = await import("../shared/rasvvzgz.js");
+      const { applyProject } = await import("../shared/q58y17hy.js");
       stdout(await applyProject(cwd, invoke(parsed), stdout));
       return;
     }
     if (sub === "status") {
-      const { statusProject } = await import("../shared/bzsjtd7c.js");
+      const { statusProject } = await import("../shared/6mnp99hx.js");
       stdout(await statusProject(cwd, invoke(parsed)));
       return;
     }
     if (sub === "check") {
-      const { checkMigrations } = await import("../shared/r73pt594.js");
+      const { checkMigrations } = await import("../shared/7zwwyh0v.js");
       const provision = parsed.flags.includes("--provision") || rest.slice(1).includes("--provision");
       stdout(await checkMigrations(cwd, invoke(parsed), { provision }));
       return;
@@ -104,13 +118,13 @@ async function run(argv, io) {
         fix: { summary: "Pass okm seed <file>." }
       });
     }
-    const { seedProject } = await import("../shared/jdgqqx31.js");
+    const { seedProject } = await import("../shared/2pqx26h8.js");
     stdout(await seedProject(cwd, parsed.name, invoke(parsed)));
     return;
   }
   if (command === "doctor") {
     const parsed = splitFlags(rest);
-    const { doctorProject } = await import("../shared/qy9rdq0g.js");
+    const { doctorProject } = await import("../shared/ps7a6h14.js");
     stdout(await doctorProject(cwd, parsed.name, invoke(parsed)));
     return;
   }
@@ -122,7 +136,7 @@ async function run(argv, io) {
       });
     }
     if (sub === "list" || sub === "check") {
-      const { extProject } = await import("../shared/990a291j.js");
+      const { extProject } = await import("../shared/janx09m5.js");
       stdout(await extProject(cwd, sub, invoke(splitFlags(rest.slice(1)))));
       return;
     }
@@ -210,6 +224,42 @@ function splitFlags(args) {
     statementTimeoutMs
   };
 }
+var COMMANDS = [
+  ["build", "Write the schema build."],
+  ["check", "Lint the schema and compare it with one target."],
+  ["dev", "Watch the schema and reload."],
+  ["doctor [code]", "Print a target report, or one error code."],
+  ["ext list", "List extensions the server can install."],
+  ["ext check", "Compare declared extensions with the server."],
+  ["generate [name]", "Write the next migration."],
+  ["migrate plan <name>", "Print the plan and its lock estimates."],
+  ["migrate apply", "Apply pending migrations."],
+  ["migrate status", "Print whether the target is current."],
+  ["migrate check", "Replay migration history in a scratch schema."],
+  ["push", "Apply the schema diff to one target."],
+  ["seed <file>", "Run a seed file on one target."]
+];
+function commandsTable() {
+  const lines = ["okm <command>", ""];
+  for (const [name, summary] of COMMANDS)
+    lines.push(`  ${name.padEnd(24)} ${summary}`);
+  lines.push("", "okm <command> --help prints that command.", "");
+  return `${lines.join(`
+`)}
+`;
+}
+function commandHelp(argv) {
+  const key = argv.join(" ");
+  const found = COMMANDS.find(([name]) => name === key || name.startsWith(`${key} `));
+  if (found === undefined) {
+    return `Unknown command ${key}.
+
+${commandsTable()}`;
+  }
+  return `${found[0]}
+${found[1]}
+`;
+}
 function numberFlag(flag, value) {
   const parsed = value === undefined ? Number.NaN : Number(value);
   if (!Number.isFinite(parsed) || parsed < 0) {
@@ -226,16 +276,13 @@ var packageJsonPath = join(here, "..", "..", "package.json");
 if (process.argv.includes("--version")) {
   process.stdout.write(`${readPackageVersion(packageJsonPath)}
 `);
-} else if (process.argv.length > 2) {
+} else {
   try {
     await run(process.argv.slice(2));
   } catch (error) {
-    if (error instanceof OkmError2) {
-      process.stderr.write(formatFailure(error));
-      process.exitCode = 1;
-    } else {
-      throw error;
-    }
+    const verbose = process.argv.includes("--verbose") || process.env.OKM_DEBUG === "1";
+    process.stderr.write(formatFailure(error, verbose));
+    process.exitCode = 1;
   }
 }
 function readPackageVersion(path) {

package/dist/tooling/migrate/commands.d.ts

@@ -4,7 +4,6 @@
  * The bin wrapper imports {@link run}. Importing this module does not parse
  * `process.argv`.
  */
-import { OkmError } from "../../contracts/error.js";
 /** Where a command reads the project and writes its text. */
 export type CommandIo = {
     readonly cwd?: string;
@@ -18,7 +17,7 @@ export type CommandIo = {
  * @param error - Failure from a command
  * @returns The stderr text, including the trailing newline
  */
-export declare function formatFailure(error: OkmError): string;
+export declare function formatFailure(error: unknown, verbose?: boolean): string;
 /**
  * Runs one `okm` invocation.
  *

package/dist/tooling/migrate/drift.d.ts

@@ -18,7 +18,7 @@ import type { RolesInput } from "../../dialects/pg/role/index.js";
  * @param author - Schema catalog, including roles when the config names them
  * @param roles - `defineConfig({ roles })`, when set
  */
-export declare function assertAuthorDrift(url: string, author: Catalog, roles?: RolesInput): Promise<void>;
+export declare function assertAuthorDrift(url: string, author: Catalog, roles?: RolesInput, allowPooler?: boolean): Promise<void>;
 /**
  * Turns a postgres.js handle into the query shape introspection uses.
  *

package/dist/tooling/migrate/estimate.d.ts

@@ -40,7 +40,20 @@ export declare function readRowEstimates(url: string, schema: string, tables: re
  * @param estimates - `reltuples` for tables that exist on the target
  * @returns The text after `-- lock: `
  */
-export declare function annotateLock(step: PlanStep, estimates: ReadonlyMap<string, RowEstimate>): string;
+export declare function annotateLock(step: PlanStep, estimates: ReadonlyMap<string, RowEstimate>, aliases?: ReadonlyMap<string, string>): string;
+/**
+ * Maps a rename destination to the table that still has `reltuples`.
+ *
+ * The rename statement names the old table. Later steps name the new one,
+ * which is not in `pg_class` yet.
+ *
+ * @param steps - Plan steps
+ * @returns New name to old name
+ */
+export declare function renameAliases(steps: readonly {
+    readonly kind?: string;
+    readonly sql: string;
+}[]): ReadonlyMap<string, string>;
 /**
  * Compact phrase for one estimate.
  *

package/dist/tooling/migrate/index.js

@@ -1,24 +1,25 @@
-import"../../shared/wqem4jed.js";
+import"../../shared/krxx77g0.js";
 import"../../shared/8bwbwy8h.js";
 import"../../shared/n442h54c.js";
 import {
   applyTarget2,
   backfillTiming2
-} from "../../shared/xhh1srw3.js";
+} from "../../shared/cctw17hj.js";
 import {
   loadMigrations,
   loadHeadSnapshot,
   readReference
-} from "../../shared/kdkxh3kb.js";
+} from "../../shared/gde73es6.js";
 import"../../shared/szm0cksa.js";
 import"../../shared/fancm5pt.js";
 import {
-  assertTargetPolicy,
-  selectTarget,
   loadBuiltSchema,
   loadConfig
-} from "../../shared/xdpj5kkm.js";
-import"../../shared/ayz64vzj.js";
+} from "../../shared/qv2ydck9.js";
+import {
+  assertTargetPolicy,
+  selectTarget
+} from "../../shared/ga3sfy93.js";
 import"../../shared/8xsbagad.js";
 import {
   OkmError2