okmodel 0.6.0 → 0.8.0

package/dist/shared/{929h19xp.js → 0wrea3jq.js}

@@ -1,10 +1,10 @@
 import {
   isConnectionSqlstate,
   isConnectionErrno
-} from "./gwn6v667.js";
+} from "./cnkky55j.js";
 import {
   createClient
-} from "./j60w0dvr.js";
+} from "./bah9nbg3.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -96,8 +96,7 @@ async function connectTopology(target, options, open) {
     const client = createClient(options.schema, router, { ownsPool: true, ...shared });
     const routed = client;
     routed.using = (route) => derive(options.schema, handle, router, shared, route);
-    handles.set(routed, handle);
-    return routed;
+    return instrument(routed, handle);
   } catch (error) {
     for (const endpoint of opened) {
       if (endpoint.timer !== undefined)
@@ -108,6 +107,105 @@ async function connectTopology(target, options, open) {
     throw error;
   }
 }
+function instrument(client, handle, forced) {
+  const proxy = new Proxy(client, {
+    get(target, key, receiver) {
+      if (key === "using")
+        return Reflect.get(target, key, receiver);
+      const value = Reflect.get(target, key, receiver);
+      if (typeof value !== "function")
+        return retarget(value, handle, forced);
+      if (key === "tx") {
+        return (...args) => {
+          const index = typeof args[0] === "function" ? 0 : 1;
+          const fn = args[index];
+          if (typeof fn === "function") {
+            args[index] = (inner, ...rest) => fn(typeof inner === "object" && inner !== null ? instrument(inner, handle, "primary") : inner, ...rest);
+          }
+          return value.apply(target, args);
+        };
+      }
+      return (...args) => retarget(value.apply(target, args), handle, forced);
+    }
+  });
+  handles.set(proxy, handle);
+  return proxy;
+}
+function wrapTable(table, handle, forced) {
+  return new Proxy(table, {
+    get(target, key, receiver) {
+      const value = Reflect.get(target, key, receiver);
+      if (typeof value !== "function")
+        return value;
+      return (...args) => {
+        const route = forced ?? readCallRoute(args[0]);
+        return retarget(value.apply(target, args), handle, route);
+      };
+    }
+  });
+}
+function retarget(value, handle, route) {
+  if (typeof value !== "object" || value === null)
+    return value;
+  if (typeof Reflect.get(value, "inspect") === "function" && typeof Reflect.get(value, "then") === "function") {
+    return showReason(value, handle, route);
+  }
+  if (typeof Reflect.get(value, "find") === "function")
+    return wrapTable(value, handle, route);
+  if (typeof Reflect.get(value, "table") === "function")
+    return instrument(value, handle, route);
+  return value;
+}
+function showReason(query, handle, route) {
+  return new Proxy(query, {
+    get(target, key, receiver) {
+      const value = Reflect.get(target, key, receiver);
+      if (key === "inspect" && typeof value === "function") {
+        const inspect = value;
+        return () => Promise.resolve(inspect.call(target)).then(async (view) => {
+          if (typeof view !== "object" || view === null)
+            return view;
+          const sql = Reflect.get(view, "sql");
+          const text = typeof sql === "object" && sql !== null && typeof Reflect.get(sql, "text") === "string" ? Reflect.get(sql, "text") : "";
+          const choice = await preview(handle, text, route);
+          return {
+            ...view,
+            routing: {
+              endpoint: choice.endpoint.name,
+              role: choice.endpoint.role,
+              reason: choice.reason
+            }
+          };
+        });
+      }
+      if ((key === "all" || key === "required") && typeof value === "function") {
+        const method = value;
+        return (...args) => retarget(method.apply(target, args), handle, route);
+      }
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+function readCallRoute(value) {
+  if (typeof value !== "object" || value === null)
+    return;
+  const route = Reflect.get(value, "route");
+  return route === "primary" || route === "replica" ? route : undefined;
+}
+async function preview(handle, text, route) {
+  const currents = handle.endpoints.map((endpoint) => endpoint.current);
+  const rrLast = handle.rrLast;
+  try {
+    return await choose(handle, text, route);
+  } finally {
+    for (let index = 0;index < handle.endpoints.length; index += 1) {
+      const endpoint = handle.endpoints[index];
+      if (endpoint !== undefined)
+        endpoint.current = currents[index] ?? 0;
+    }
+    handle.rrLast = rrLast;
+  }
+}
 function refuseRouting(routing) {
   if (routing === undefined)
     return;
@@ -506,7 +604,7 @@ function routePool(handle) {
     execute: async (text, params, options) => {
       if (handle.closed)
         closed();
-      const choice = await choose(handle, text, options?.route);
+      const choice = await resolve(handle, text, options);
       const result = await attempt(handle, choice, (endpoint) => endpoint.pool.execute(text, params, strip(options)));
       if (choice.op === "write")
         await noteWrite(handle, primary.pool);
@@ -574,7 +672,7 @@ function derive(schema, handle, router, shared, route) {
   const name = readRoute(route);
   const client = createClient(schema, force(handle, router, name), { ...shared, ownsPool: false });
   delete client.close;
-  return client;
+  return instrument(client, handle, name);
 }
 function force(handle, router, route) {
   const pool = {
@@ -628,7 +726,7 @@ function force(handle, router, route) {
 async function readOnlyUnit(handle, text, params, prelude, options) {
   if (handle.closed)
     closed();
-  const choice = await choose(handle, text, options?.route);
+  const choice = await resolve(handle, text, options);
   return attempt(handle, choice, async (endpoint) => {
     if (endpoint.pool.reserve === undefined)
       replicaReserve();
@@ -764,7 +862,7 @@ async function attempt(handle, choice, run) {
       await callGuard(choice.endpoint);
     return await tracked(choice.endpoint, choice.op === "read", () => run(choice.endpoint));
   } catch (error) {
-    if (choice.op !== "read" || !isUnreachable(error))
+    if (choice.pinned === true || choice.op !== "read" || !isUnreachable(error))
       throw error;
     choice.endpoint.generation += 1;
     const next = await retryOf(handle, choice);
@@ -817,9 +915,7 @@ function unreachableNode(node) {
       return true;
     }
   }
-  if (!(node instanceof Error))
-    return false;
-  return node.message.includes("ECONNREFUSED") || node.message.includes("ECONNRESET") || node.message.includes("CONNECTION_CLOSED") || node.message.includes("terminating connection") || node.message.includes("The pool is closed");
+  return false;
 }
 async function tracked(endpoint, time, run) {
   const replica = endpoint.role === "replica";
@@ -1109,13 +1205,45 @@ function noteFailure(endpoint) {
     endpoint.circuit = "open";
 }
 function strip(options) {
-  if (options === undefined || options.route === undefined)
+  if (options === undefined)
+    return;
+  if (!("route" in options) && !("pin" in options))
     return options;
-  const { route: _route, ...rest } = options;
+  const bag = options;
+  const { route: _route, pin: _pin, ...rest } = bag;
   if (rest.signal === undefined && rest.timeout === undefined)
     return;
   return rest;
 }
+async function resolve(handle, text, options) {
+  const pin = taken(options);
+  if (pin?.name !== undefined)
+    return held(handle, pin.name);
+  const choice = await choose(handle, text, options?.route);
+  if (pin !== undefined && choice.op === "read") {
+    pin.name = choice.endpoint.name;
+    return { ...choice, pinned: true };
+  }
+  return choice;
+}
+function taken(options) {
+  if (options === undefined || !("pin" in options))
+    return;
+  const pin = options.pin;
+  if (typeof pin !== "object" || pin === null)
+    return;
+  return pin;
+}
+function held(handle, name) {
+  for (const endpoint of handle.endpoints) {
+    if (endpoint.name !== name)
+      continue;
+    return { endpoint, op: "read", reason: `stream:${name}`, pinned: true };
+  }
+  throw new OkmError2("OKM1120", `stream() stays on ${name}. That target is not in this topology.`, {
+    fix: { summary: "The first batch chose this target. Later batches do not move." }
+  });
+}
 async function noteWrite(handle, runner) {
   if (!tracks(handle))
     return;

package/dist/shared/{qq3899ht.js → 12z7aznj.js}

@@ -1,18 +1,6 @@
 import {
   policyObject
 } from "./bdk4sty6.js";
-import {
-  functionObject,
-  triggerObject
-} from "./y34a8714.js";
-import {
-  viewObject,
-  materializedViewObject,
-  materializedViewIndex
-} from "./zy8r7qvz.js";
-import {
-  extensionObject
-} from "./r3j8s5y0.js";
 import {
   dependencyOrder,
   catalog,
@@ -20,10 +8,14 @@ import {
   domainType,
   isDomain
 } from "./ywspezzx.js";
+import {
+  extensionObject
+} from "./r3j8s5y0.js";
 import {
   canonicalJson,
   staticNamespace2,
   templateNamespace2,
+  assertNamespace2,
   identityKey2,
   identityLabel2,
   sameRef2,
@@ -48,7 +40,8 @@ import {
 import {
   sha2562,
   assertIdentifier2,
-  fitIdentifier2
+  fitIdentifier2,
+  deterministicName2
 } from "./nfzc5z0w.js";
 import {
   catalogError2
@@ -164,6 +157,242 @@ function defaultPrivilegeObject(input) {
   };
 }
 
+// src/contracts/catalog/routine.ts
+var VOLATILITY = new Set(["volatile", "stable", "immutable"]);
+var SECURITY = new Set(["invoker", "definer"]);
+var TIMING = new Set(["before", "after", "instead"]);
+var LEVEL = new Set(["row", "statement"]);
+var EVENT_ORDER = ["insert", "update", "delete", "truncate"];
+var TYPE_TEXT = /^[A-Za-z][A-Za-z0-9_ ]*(\(\d+(,\s*\d+)?\))?(\[\])*$/;
+function functionObject(input) {
+  assertIdentifier2(input.name, "function");
+  const namespace = input.namespace ?? staticNamespace2("public");
+  assertNamespace2(namespace);
+  assertProvenance(input.provenance);
+  if (input.language !== "sql" && input.language !== "plpgsql") {
+    catalogError2("OKM1020", `Function ${input.name} language must be sql or plpgsql.`);
+  }
+  const volatility = input.volatility ?? "volatile";
+  if (!VOLATILITY.has(volatility)) {
+    catalogError2("OKM1020", `Function ${input.name} volatility ${volatility} is not supported.`);
+  }
+  const security = input.security ?? "invoker";
+  if (!SECURITY.has(security)) {
+    catalogError2("OKM1020", `Function ${input.name} security ${security} is not supported.`);
+  }
+  assertTypeName(input.returns, `function ${input.name} return type`);
+  const args = (input.arguments ?? []).map((argument) => readArgument(input.name, argument));
+  if (input.body.length === 0) {
+    catalogError2("OKM1020", `Function ${input.name} needs a body.`);
+  }
+  const atomic = input.atomic === true;
+  if (atomic && input.language !== "sql") {
+    catalogError2("OKM1020", `Function ${input.name} BEGIN ATOMIC needs language sql.`);
+  }
+  if (input.searchPath !== undefined && input.searchPath.trim().length === 0) {
+    catalogError2("OKM1020", `Function ${input.name} search_path is empty.`);
+  }
+  const definition = {
+    arguments: args,
+    returns: input.returns,
+    language: input.language,
+    volatility,
+    security,
+    body: input.body,
+    ...input.searchPath !== undefined ? { searchPath: input.searchPath } : {},
+    ...atomic ? { atomic: true } : {}
+  };
+  return {
+    kind: "function",
+    identity: {
+      kind: "function",
+      namespace,
+      name: input.name,
+      argTypes: args.map((arg) => arg.type)
+    },
+    owner: input.owner ?? "managed",
+    definition,
+    dependencies: normaliseEdges(input.dependencies ?? []),
+    provenance: input.provenance
+  };
+}
+function triggerObject(input) {
+  assertIdentifier2(input.name, "trigger");
+  assertNamespace2(input.parent.namespace);
+  assertIdentifier2(input.parent.name, "trigger table");
+  assertProvenance(input.provenance);
+  if (!TIMING.has(input.timing)) {
+    catalogError2("OKM1020", `Trigger ${input.name} timing ${input.timing} is not supported.`);
+  }
+  if (!LEVEL.has(input.level)) {
+    catalogError2("OKM1020", `Trigger ${input.name} level ${input.level} is not supported.`);
+  }
+  const events = EVENT_ORDER.filter((event) => input.events.includes(event));
+  if (events.length === 0) {
+    catalogError2("OKM1020", `Trigger ${input.name} needs an event.`);
+  }
+  const updateOf = input.updateOf === undefined ? undefined : [...input.updateOf];
+  if (updateOf !== undefined) {
+    if (!events.includes("update")) {
+      catalogError2("OKM1020", `Trigger ${input.name} lists UPDATE OF columns without an update event.`);
+    }
+    if (input.level !== "row") {
+      catalogError2("OKM1020", `Trigger ${input.name} UPDATE OF columns need level row.`);
+    }
+    for (const column of updateOf)
+      assertIdentifier2(column, "trigger column");
+  }
+  assertIdentifier2(input.calls.name, "trigger function");
+  assertNamespace2(input.calls.namespace);
+  for (const typeName of input.calls.argTypes)
+    assertTypeName(typeName, `trigger ${input.name}`);
+  const edges = [
+    { kind: "table", namespace: input.parent.namespace, name: input.parent.name },
+    {
+      kind: "function",
+      namespace: input.calls.namespace,
+      name: input.calls.name,
+      argTypes: input.calls.argTypes
+    },
+    ...(updateOf ?? []).map((column) => ({
+      kind: "column",
+      parent: input.parent,
+      name: column
+    })),
+    ...input.dependencies ?? []
+  ];
+  const definition = {
+    timing: input.timing,
+    events,
+    level: input.level,
+    calls: {
+      namespace: input.calls.namespace,
+      name: input.calls.name,
+      argTypes: [...input.calls.argTypes]
+    },
+    ...updateOf !== undefined && updateOf.length > 0 ? { updateOf } : {},
+    ...input.when !== undefined && input.when.length > 0 ? { when: input.when } : {}
+  };
+  return {
+    kind: "trigger",
+    identity: { kind: "trigger", parent: input.parent, name: input.name },
+    owner: input.owner ?? "managed",
+    definition,
+    dependencies: normaliseEdges(edges),
+    provenance: input.provenance
+  };
+}
+function readArgument(fn, argument) {
+  assertIdentifier2(argument.name, `function ${fn} argument`);
+  assertTypeName(argument.type, `function ${fn} argument ${argument.name}`);
+  return { name: argument.name, type: argument.type };
+}
+function assertTypeName(typeName, role) {
+  if (!TYPE_TEXT.test(typeName)) {
+    catalogError2("OKM1020", `${role} ${typeName} is not a type name.`);
+  }
+}
+
+// src/contracts/catalog/view.ts
+function normaliseViewQuery(query) {
+  return query.trim().replace(/;\s*$/, "");
+}
+function viewObject(input) {
+  const namespace = input.namespace ?? staticNamespace2("public");
+  const columns = readColumns(input.name, input.columns);
+  const query = readQuery(input.name, input.query);
+  assertNamespace2(namespace);
+  assertProvenance(input.provenance);
+  const definition = {
+    columns,
+    query,
+    ...input.securityInvoker === true ? { securityInvoker: true } : {}
+  };
+  return {
+    kind: "view",
+    identity: { kind: "view", namespace, name: input.name },
+    owner: input.owner ?? "managed",
+    definition,
+    dependencies: normaliseEdges(input.dependencies ?? []),
+    provenance: input.provenance
+  };
+}
+function materializedViewObject(input) {
+  const namespace = input.namespace ?? staticNamespace2("public");
+  const columns = readColumns(input.name, input.columns);
+  const query = readQuery(input.name, input.query);
+  assertNamespace2(namespace);
+  assertProvenance(input.provenance);
+  const definition = {
+    columns,
+    query,
+    ...input.refresh === "concurrently" ? { refresh: "concurrently" } : {}
+  };
+  return {
+    kind: "materializedView",
+    identity: { kind: "materializedView", namespace, name: input.name },
+    owner: input.owner ?? "managed",
+    definition,
+    dependencies: normaliseEdges(input.dependencies ?? []),
+    provenance: input.provenance
+  };
+}
+function materializedViewIndex(input) {
+  assertNamespace2(input.parent.namespace);
+  assertIdentifier2(input.parent.name, "index parent");
+  assertProvenance(input.provenance);
+  const columns = [...input.columns];
+  for (const name of columns)
+    assertIdentifier2(name, "index column");
+  if (columns.length === 0 && input.expression === undefined) {
+    catalogError2("OKM1020", `Index on ${input.parent.name} needs a column or an expression.`);
+  }
+  const nameKey = input.nameKey ?? (columns.length > 0 ? columns.join("_") : "expr");
+  const name = input.name === undefined ? deterministicName2({ parent: input.parent.name, purpose: "index", nameKey }) : fitIdentifier2(input.name);
+  const parentView = {
+    kind: "materializedView",
+    namespace: input.parent.namespace,
+    name: input.parent.name
+  };
+  return {
+    kind: "index",
+    identity: { kind: "index", parent: input.parent, name },
+    owner: input.owner ?? "managed",
+    definition: {
+      columns,
+      unique: input.unique === true,
+      nameKey,
+      ...input.expression !== undefined ? { expression: input.expression } : {},
+      ...input.predicate !== undefined ? { predicate: input.predicate } : {}
+    },
+    dependencies: normaliseEdges(input.dependencies ?? [parentView]),
+    provenance: input.provenance
+  };
+}
+function readColumns(view, columns) {
+  assertIdentifier2(view, "view");
+  if (columns.length === 0)
+    catalogError2("OKM1020", `View ${view} needs a column.`);
+  const seen = new Set;
+  return columns.map((column) => {
+    assertIdentifier2(column.name, `view ${view} column`);
+    if (seen.has(column.name)) {
+      catalogError2("OKM1020", `View ${view} lists column ${column.name} twice.`);
+    }
+    seen.add(column.name);
+    if (column.dataType.length === 0 || /[;'"\\]/.test(column.dataType)) {
+      catalogError2("OKM1020", `View ${view} column ${column.name} type is not a type name.`);
+    }
+    return { name: column.name, dataType: column.dataType };
+  });
+}
+function readQuery(view, query) {
+  const text = normaliseViewQuery(query);
+  if (text.length === 0)
+    catalogError2("OKM1020", `View ${view} needs a query.`);
+  return text;
+}
+
 // src/contracts/catalog/document.ts
 function creationOrder2(source) {
   return dependencyOrder(source.objects);
@@ -1565,4 +1794,4 @@ function assertNeverKind(value) {
   return catalogError2("OKM1020", `Unexpected kind ${JSON.stringify(value)}.`);
 }
 
-export { roleObject, grantObject, defaultPrivilegeObject, creationOrder2, renameColumn2, renameTable2, serializeCatalog2, catalogHash2, startupCatalog2, startupHash2, loadTrustedCatalog2, catalogFileText2, parseCatalog2 };
+export { roleObject, grantObject, defaultPrivilegeObject, functionObject, triggerObject, normaliseViewQuery, viewObject, materializedViewObject, materializedViewIndex, creationOrder2, renameColumn2, renameTable2, serializeCatalog2, catalogHash2, startupCatalog2, startupHash2, loadTrustedCatalog2, catalogFileText2, parseCatalog2 };

package/dist/shared/{1z04fa85.js → 14x60fbf.js}

@@ -1,16 +1,14 @@
 import {
-  quoteIdent2,
   noticeBuffer,
-  WireSession,
-  cursorStream
-} from "./4az561fn.js";
+  WireSession
+} from "./mtw6jz76.js";
 import {
   NODE_POSTGRES_CAPABILITIES,
   driverErrors,
   rejectClosed,
   mapFailure,
   runCall
-} from "./cgbamx3e.js";
+} from "./ae4j5f42.js";
 
 // src/adapters/pg/nodepostgres.ts
 import net from "node:net";
@@ -57,7 +55,7 @@ function open4(config) {
     counters.busy = Math.max(0, counters.busy - 1);
   }, inflight);
   const held = { pool, acquireMs, counters, notices, named, isClosed };
-  const checkout = () => closed ? rejectClosed() : import("./zm0mafk4.js").then((mod) => mod.checkout(held));
+  const checkout = () => closed ? rejectClosed() : import("./mfedzr74.js").then((mod) => mod.checkout(held));
   return {
     capabilities: NODE_POSTGRES_CAPABILITIES,
     execute(text, params, options) {
@@ -89,10 +87,15 @@ function open4(config) {
     },
     reserve: () => checkout(),
     stream(text, params) {
-      return stream(text, params);
+      return async function* () {
+        const { streamRows } = await import("./mfedzr74.js");
+        yield* streamRows(checkout, text, params);
+      }();
     },
     listen(channel, onNotify) {
-      return listen(channel, onNotify);
+      if (closed)
+        return rejectClosed();
+      return import("./mfedzr74.js").then((mod) => mod.listen(held, channel, onNotify));
     },
     cancel() {
       for (const pending of inflight)
@@ -104,54 +107,6 @@ function open4(config) {
       await pool.end();
     }
   };
-  function stream(text, params) {
-    return async function* () {
-      const connection = await checkout();
-      try {
-        yield* cursorStream((statement, values) => connection.execute(statement, values), text, params);
-      } finally {
-        await connection.release();
-      }
-    }();
-  }
-  async function listen(channel, onNotify) {
-    if (closed)
-      return rejectClosed();
-    const client = await connectClient(pool, acquireMs, counters);
-    counters.reserved += 1;
-    const quoted = quoteIdent2(channel);
-    const onNotification = (message) => {
-      if (message.channel === channel)
-        onNotify(message.payload ?? "");
-    };
-    client.on("notification", onNotification);
-    let released = false;
-    const release = (dead) => {
-      if (released)
-        return;
-      released = true;
-      client.removeListener("notification", onNotification);
-      client.removeListener("error", release);
-      counters.reserved = Math.max(0, counters.reserved - 1);
-      client.release(Boolean(dead));
-    };
-    armDriverError(client, release);
-    try {
-      await client.query(`LISTEN ${quoted}`);
-    } catch (error) {
-      release(false);
-      throw error;
-    }
-    return async () => {
-      if (released)
-        return;
-      try {
-        await client.query(`UNLISTEN ${quoted}`);
-      } finally {
-        release(false);
-      }
-    };
-  }
 }
 function send(runner, text, params, named, client) {
   const query = {
@@ -236,4 +191,4 @@ function statsOf(counters, size) {
   };
 }
 
-export { open4, send, connectClient };
+export { armDriverError, open4, send, connectClient };

package/dist/shared/{ek2wt2dz.js → 16kvjebh.js}

@@ -1,6 +1,6 @@
 import {
   catalogFileText2
-} from "./qq3899ht.js";
+} from "./12z7aznj.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -14,7 +14,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,7 +28,7 @@ async function assertCompatible(pool, schema, recordedHash, source, options) {
           }
         });
       }
-      const { loadTrustedCatalog } = await import("./dk8v79p3.js");
+      const { loadTrustedCatalog } = await import("./d5nmj7vv.js");
       loadTrustedCatalog(text, code.hash);
     });
   }
@@ -42,7 +42,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) {

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

@@ -1,7 +1,7 @@
 import {
   open2
-} from "./wkme6tep.js";
-import"./qq3899ht.js";
+} from "./35q0n9tz.js";
+import"./12z7aznj.js";
 import"./n442h54c.js";
 import {
   CURRENT,
@@ -14,21 +14,21 @@ import {
 import {
   expandProvisioned,
   provisionHistoryIsKnown
-} from "./p248q79y.js";
-import"./knmes2kh.js";
-import"./vjpnzwjz.js";
+} from "./mnvjvqyp.js";
+import"./kj9d8maq.js";
+import"./p3xbdcvt.js";
 import {
   projectPath,
   loadMigrations,
   loadConfig
-} from "./t3g0k88x.js";
+} from "./f4jy1j7x.js";
 import {
   sessionFailure,
   finishQuiet,
   assertTargetPolicy,
   listTargets
-} from "./ttmg09vd.js";
-import"./9s0ypp87.js";
+} from "./dpc2r7rb.js";
+import"./sjk86yrx.js";
 import {
   OkmError2
 } from "./52szzakm.js";