@intentius/chant 0.124.14 → 0.124.16

package/dist/op/op-waves.js

@@ -67,6 +67,7 @@
  */
 import { gatePointProblems } from "./gate-point.js";
 import { notifyConfigProblem } from "../notify.js";
+import { WAVE_GATE_NAME_PATTERN, waveGateNameFrom, waveShare } from "../wave-layout.js";
 /**
  * The variables a wave job reads its notify secrets from, for the lexicons
  * that generate wave pipelines. Re-exported here because a lexicon's source
@@ -109,10 +110,10 @@ export const OP_WAVE_HOOK_MOMENTS = ["before-plan", "after-plan", "after-gate",
 export const OP_WAVE_APPLY_HOOKS_RUNNERS = ["chant", "apply"];
 export const OP_WAVES_DIGEST_OVER = ["all", "changing"];
 /** The default gate name pattern. */
-export const OP_WAVE_DEFAULT_GATE_NAME = "{gate}-wave-{k}";
+export const OP_WAVE_DEFAULT_GATE_NAME = WAVE_GATE_NAME_PATTERN;
 /** The gate wave `k` waits on (#3821): the spec's `gateName` pattern, by default `<gate>-wave-<k>`. */
 export function opWaveGateName(spec, k) {
-    return (spec.gateName ?? OP_WAVE_DEFAULT_GATE_NAME).replaceAll("{gate}", spec.gate ?? spec.name).replaceAll("{k}", String(k));
+    return waveGateNameFrom(spec.gateName, spec.gate ?? spec.name, k);
 }
 /** The command a resume job runs. */
 export function opWavesResumeCommand(spec) {
@@ -365,12 +366,7 @@ export function opWaveApplyHooksRunBy(spec, name) {
  * by target, cut into contiguous slices whose sizes differ by at most one.
  */
 export function opWaveShare(runs, share, shares) {
-    const sorted = [...runs].sort((a, b) => (a.target < b.target ? -1 : a.target > b.target ? 1 : 0));
-    const base = Math.floor(sorted.length / shares);
-    const extra = sorted.length % shares;
-    const start = (share - 1) * base + Math.min(share - 1, extra);
-    const size = base + (share <= extra ? 1 : 0);
-    return sorted.slice(start, start + size);
+    return waveShare(runs, share, shares, (run) => run.target);
 }
 /**
  * The jobs of an Op waves pipeline, in order. `specFile` is the spec's path

package/dist/package-version.d.ts

@@ -0,0 +1,2 @@
+export declare function readChantPackageVersion(): string;
+//# sourceMappingURL=package-version.d.ts.map

package/dist/package-version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-version.d.ts","sourceRoot":"","sources":["../src/package-version.ts"],"names":[],"mappings":"AAQA,wBAAgB,uBAAuB,IAAI,MAAM,CAEhD"}

package/dist/package-version.js

@@ -0,0 +1,10 @@
+/**
+ * `@intentius/chant`'s own version, read from its package.json as a file. The
+ * path is the same from `src/` and `dist/`. The slim wave-job runtime (#3896)
+ * has no package.json beside it, and its build writes the version in here.
+ */
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+export function readChantPackageVersion() {
+    return JSON.parse(readFileSync(fileURLToPath(new URL("../package.json", import.meta.url)), "utf-8")).version;
+}

package/dist/wave-engine.d.ts

@@ -0,0 +1,62 @@
+/**
+ * The wave engine (#3766): what `chant run wave` (the Op waves spec,
+ * `./op/op-waves-run.ts`) and `chant components fan-out --wave-gate`
+ * (`./components/fan-out-run.ts`) share once a wave is planned.
+ *
+ * - Gate naming: {@link waveGateName} and {@link waveGateNameFrom}.
+ * - The set digest: {@link waveSetDigest} over {@link waveDigestMembers}.
+ * - The share split of a wide wave: {@link waveShare}.
+ * - The gate decision call: {@link decideWaveGate}.
+ * - The record file a wave job hands the next one: {@link writeWaveRecordFile}.
+ *
+ * The parts that need neither the gate ledger nor the filesystem live in
+ * `./gated-waves.ts`, which terragucci bundles on its own (#3421), and
+ * `./wave-layout.ts`, which imports nothing so the Op waves spec module can
+ * use it without the change-set code; this module re-exports both so a
+ * runner imports the engine from one place.
+ *
+ * What stays with each entry point: how a wave is planned (Op runs' plan
+ * commands, or each component's capabilities), the gate policy, approval
+ * mode, decision point, hooks and spend rule (Op waves only), and the shape
+ * of the record each writes. Those shapes are read by jobs and approvals
+ * already in the wild, so the engine writes what it is handed.
+ */
+import { type GateCheck, type GateLedgerPort } from "./op/gate.js";
+import type { AppliedGateRecord } from "./lifecycle/gate-applied.js";
+export { WAVE_GATE_NAME_PATTERN, waveGateNameFrom, waveShare } from "./wave-layout.js";
+export { layerWaves, waveGateName, waveDigestMembers, waveSetDigest, readWaveRecords, withWaveRecord, describeChangedWave, type WaveDigestOver, type WaveMember, type WaveNode, type WaveRecord, type WaveStatus, } from "./gated-waves.js";
+/** What a wave asks its gate. */
+export interface WaveGateRequest {
+    /** The op the gate is recorded under: the fan-out's op, or the Op waves spec's name. */
+    op: string;
+    /** The wave's full gate name. */
+    gate: string;
+    /** The wave's set digest. */
+    digest: string;
+    /** The pending fact's description. */
+    description: string;
+    /** The pending fact's expiry, as a gate's `timeout`. */
+    timeout?: string;
+    now?: string;
+    /** Approvals a wave already applied under, which count for nothing (#3784). */
+    spent?: readonly AppliedGateRecord[];
+    /** Fields the pending fact carries (#3821). */
+    fields?: Record<string, unknown>;
+    /** The pending fact carries `neverOverMcp` (#3821). */
+    neverOverMcp?: boolean;
+}
+/**
+ * Decide a wave's gate: an approval of `digest` under `gate` on `op`'s
+ * ledger, or the pending fact that stands for it. A field left out of the
+ * request is left out of the call, so each entry point's pending facts are
+ * the ones it always wrote.
+ */
+export declare function decideWaveGate(port: GateLedgerPort, request: WaveGateRequest): Promise<GateCheck>;
+/**
+ * Write a wave record file as indented JSON, through a temporary file and a
+ * rename, so a job killed during the write leaves the previous record whole.
+ * The fan-out attempt record and an Op wave's decision record both go
+ * through it.
+ */
+export declare function writeWaveRecordFile(path: string, value: unknown): void;
+//# sourceMappingURL=wave-engine.d.ts.map

package/dist/wave-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wave-engine.d.ts","sourceRoot":"","sources":["../src/wave-engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAIH,OAAO,EAAgB,KAAK,SAAS,EAAE,KAAK,cAAc,EAAE,MAAM,WAAW,CAAC;AAC9E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAElE,OAAO,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AACpF,OAAO,EACL,UAAU,EACV,YAAY,EACZ,iBAAiB,EACjB,aAAa,EACb,eAAe,EACf,cAAc,EACd,mBAAmB,EACnB,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,KAAK,QAAQ,EACb,KAAK,UAAU,EACf,KAAK,UAAU,GAChB,MAAM,eAAe,CAAC;AAEvB,iCAAiC;AACjC,MAAM,WAAW,eAAe;IAC9B,wFAAwF;IACxF,EAAE,EAAE,MAAM,CAAC;IACX,iCAAiC;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,6BAA6B;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,sCAAsC;IACtC,WAAW,EAAE,MAAM,CAAC;IACpB,wDAAwD;IACxD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,+EAA+E;IAC/E,KAAK,CAAC,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACrC,+CAA+C;IAC/C,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,uDAAuD;IACvD,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,SAAS,CAAC,CAYjG;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAKtE"}

package/dist/wave-engine.js

@@ -0,0 +1,59 @@
+/**
+ * The wave engine (#3766): what `chant run wave` (the Op waves spec,
+ * `./op/op-waves-run.ts`) and `chant components fan-out --wave-gate`
+ * (`./components/fan-out-run.ts`) share once a wave is planned.
+ *
+ * - Gate naming: {@link waveGateName} and {@link waveGateNameFrom}.
+ * - The set digest: {@link waveSetDigest} over {@link waveDigestMembers}.
+ * - The share split of a wide wave: {@link waveShare}.
+ * - The gate decision call: {@link decideWaveGate}.
+ * - The record file a wave job hands the next one: {@link writeWaveRecordFile}.
+ *
+ * The parts that need neither the gate ledger nor the filesystem live in
+ * `./gated-waves.ts`, which terragucci bundles on its own (#3421), and
+ * `./wave-layout.ts`, which imports nothing so the Op waves spec module can
+ * use it without the change-set code; this module re-exports both so a
+ * runner imports the engine from one place.
+ *
+ * What stays with each entry point: how a wave is planned (Op runs' plan
+ * commands, or each component's capabilities), the gate policy, approval
+ * mode, decision point, hooks and spend rule (Op waves only), and the shape
+ * of the record each writes. Those shapes are read by jobs and approvals
+ * already in the wild, so the engine writes what it is handed.
+ */
+import { dirname } from "node:path";
+import { mkdirSync, renameSync, writeFileSync } from "node:fs";
+import { evaluateGate } from "./op/gate.js";
+export { WAVE_GATE_NAME_PATTERN, waveGateNameFrom, waveShare } from "./wave-layout.js";
+export { layerWaves, waveGateName, waveDigestMembers, waveSetDigest, readWaveRecords, withWaveRecord, describeChangedWave, } from "./gated-waves.js";
+/**
+ * Decide a wave's gate: an approval of `digest` under `gate` on `op`'s
+ * ledger, or the pending fact that stands for it. A field left out of the
+ * request is left out of the call, so each entry point's pending facts are
+ * the ones it always wrote.
+ */
+export function decideWaveGate(port, request) {
+    return evaluateGate(port, {
+        op: request.op,
+        gate: request.gate,
+        planDigest: request.digest,
+        description: request.description,
+        ...(request.timeout ? { timeout: request.timeout } : {}),
+        ...(request.now !== undefined ? { now: request.now } : {}),
+        ...(request.spent ? { spent: request.spent } : {}),
+        ...(request.fields ? { fields: request.fields } : {}),
+        ...(request.neverOverMcp ? { neverOverMcp: true } : {}),
+    });
+}
+/**
+ * Write a wave record file as indented JSON, through a temporary file and a
+ * rename, so a job killed during the write leaves the previous record whole.
+ * The fan-out attempt record and an Op wave's decision record both go
+ * through it.
+ */
+export function writeWaveRecordFile(path, value) {
+    mkdirSync(dirname(path), { recursive: true });
+    const temporary = `${path}.${process.pid}.tmp`;
+    writeFileSync(temporary, JSON.stringify(value, null, 2) + "\n");
+    renameSync(temporary, path);
+}

package/dist/wave-layout.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Wave gate names and the share split of a wide wave (#3766), the parts of
+ * the wave engine (`./wave-engine.ts`) that the Op waves spec module
+ * (`./op/op-waves.ts`) needs. That module is in the gate-decision bundle
+ * (`./gate-decision.ts` re-exports a constant from it), so this imports
+ * nothing and keeps the change-set digest code out of that bundle.
+ */
+/** The default wave gate name pattern: `{gate}` is the base gate name, `{k}` the wave's number. */
+export declare const WAVE_GATE_NAME_PATTERN = "{gate}-wave-{k}";
+/**
+ * The gate wave `k` waits on under a name pattern (#3821). With the default
+ * pattern this is `waveGateName(gate, k)` from `./gated-waves.ts`; an Op
+ * waves spec's `gateName` names another (such as `"wave-{k}"`) so approvals
+ * already on the ledger under a product's old names keep matching.
+ *
+ * `{gate}` is filled in before `{k}`, as `opWaveGateName` always did, so a
+ * base gate name holding the text `{k}` is filled in too. That is the one
+ * input on which this and `waveGateName` differ, and each entry point keeps
+ * the one it shipped with.
+ */
+export declare function waveGateNameFrom(pattern: string | undefined, gate: string, k: number): string;
+/**
+ * Share `share` (1-based) of `shares` of a wide wave (#3679): the items
+ * sorted by `keyOf`, cut into contiguous slices whose sizes differ by at most
+ * one. The deciding job and every share job cut the same way, so each item
+ * is applied by exactly one share.
+ */
+export declare function waveShare<T>(items: readonly T[], share: number, shares: number, keyOf: (item: T) => string): T[];
+//# sourceMappingURL=wave-layout.d.ts.map

package/dist/wave-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wave-layout.d.ts","sourceRoot":"","sources":["../src/wave-layout.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,mGAAmG;AACnG,eAAO,MAAM,sBAAsB,oBAAoB,CAAC;AAExD;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAE7F;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAAG,CAAC,EAAE,CAWhH"}

package/dist/wave-layout.js

@@ -0,0 +1,41 @@
+/**
+ * Wave gate names and the share split of a wide wave (#3766), the parts of
+ * the wave engine (`./wave-engine.ts`) that the Op waves spec module
+ * (`./op/op-waves.ts`) needs. That module is in the gate-decision bundle
+ * (`./gate-decision.ts` re-exports a constant from it), so this imports
+ * nothing and keeps the change-set digest code out of that bundle.
+ */
+/** The default wave gate name pattern: `{gate}` is the base gate name, `{k}` the wave's number. */
+export const WAVE_GATE_NAME_PATTERN = "{gate}-wave-{k}";
+/**
+ * The gate wave `k` waits on under a name pattern (#3821). With the default
+ * pattern this is `waveGateName(gate, k)` from `./gated-waves.ts`; an Op
+ * waves spec's `gateName` names another (such as `"wave-{k}"`) so approvals
+ * already on the ledger under a product's old names keep matching.
+ *
+ * `{gate}` is filled in before `{k}`, as `opWaveGateName` always did, so a
+ * base gate name holding the text `{k}` is filled in too. That is the one
+ * input on which this and `waveGateName` differ, and each entry point keeps
+ * the one it shipped with.
+ */
+export function waveGateNameFrom(pattern, gate, k) {
+    return (pattern ?? WAVE_GATE_NAME_PATTERN).replaceAll("{gate}", gate).replaceAll("{k}", String(k));
+}
+/**
+ * Share `share` (1-based) of `shares` of a wide wave (#3679): the items
+ * sorted by `keyOf`, cut into contiguous slices whose sizes differ by at most
+ * one. The deciding job and every share job cut the same way, so each item
+ * is applied by exactly one share.
+ */
+export function waveShare(items, share, shares, keyOf) {
+    const sorted = [...items].sort((a, b) => {
+        const x = keyOf(a);
+        const y = keyOf(b);
+        return x < y ? -1 : x > y ? 1 : 0;
+    });
+    const base = Math.floor(sorted.length / shares);
+    const extra = sorted.length % shares;
+    const start = (share - 1) * base + Math.min(share - 1, extra);
+    const size = base + (share <= extra ? 1 : 0);
+    return sorted.slice(start, start + size);
+}

package/dist/wave-runtime.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The slim wave-job runtime (#3896): the four commands a generated Op waves
+ * pipeline runs, and nothing else.
+ *
+ *   chant run wave --spec <file> --wave <k> [--decide | --share <i> | --record-plans]
+ *   chant run resume [--gate <op>/<gate>] [--dry-run]
+ *   chant approve <op> <gate> [...]
+ *   chant workspace points ask|answer|list|... [...]
+ *
+ * `scripts/build-runtime.mjs` bundles this file with esbuild into
+ * `dist/wave-runtime.mjs`: one self-contained ES module whose only imports are
+ * `node:` builtins, with no TypeScript compiler, esbuild, tsx or zod in it. A
+ * product copies that one file into its CI image and runs it with plain node,
+ * or runs it from an installed `@intentius/chant`
+ * (`node node_modules/@intentius/chant/dist/wave-runtime.mjs run wave ...`).
+ *
+ * The handlers are the full CLI's own (`./cli/main.ts` dispatches to the same
+ * functions), parsed by the same `parseArgs`, so flags, output, exit codes and
+ * the ledgers each command writes are the same. What the runtime does not do:
+ * evaluate `chant.config.ts` (which needs a TypeScript loader). None of the
+ * four commands reads the config; the full CLI loads it only to check `--env`
+ * against the declared `environments`, a check the runtime skips.
+ */
+import { type CommandDef } from "./cli/registry.js";
+/** The commands the runtime carries, under the names the full CLI registers them by. */
+export declare const RUNTIME_COMMANDS: CommandDef[];
+/** Parse, dispatch and return the exit code. Exported for tests. */
+export declare function runRuntime(argv: string[]): Promise<number>;
+//# sourceMappingURL=wave-runtime.d.ts.map

package/dist/wave-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wave-runtime.d.ts","sourceRoot":"","sources":["../src/wave-runtime.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,EAAkB,KAAK,UAAU,EAAmB,MAAM,gBAAgB,CAAC;AAYlF,wFAAwF;AACxF,eAAO,MAAM,gBAAgB,EAAE,UAAU,EAKxC,CAAC;AAsBF,oEAAoE;AACpE,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CA4BhE"}

package/dist/wave-runtime.js

@@ -0,0 +1,103 @@
+/**
+ * The slim wave-job runtime (#3896): the four commands a generated Op waves
+ * pipeline runs, and nothing else.
+ *
+ *   chant run wave --spec <file> --wave <k> [--decide | --share <i> | --record-plans]
+ *   chant run resume [--gate <op>/<gate>] [--dry-run]
+ *   chant approve <op> <gate> [...]
+ *   chant workspace points ask|answer|list|... [...]
+ *
+ * `scripts/build-runtime.mjs` bundles this file with esbuild into
+ * `dist/wave-runtime.mjs`: one self-contained ES module whose only imports are
+ * `node:` builtins, with no TypeScript compiler, esbuild, tsx or zod in it. A
+ * product copies that one file into its CI image and runs it with plain node,
+ * or runs it from an installed `@intentius/chant`
+ * (`node node_modules/@intentius/chant/dist/wave-runtime.mjs run wave ...`).
+ *
+ * The handlers are the full CLI's own (`./cli/main.ts` dispatches to the same
+ * functions), parsed by the same `parseArgs`, so flags, output, exit codes and
+ * the ledgers each command writes are the same. What the runtime does not do:
+ * evaluate `chant.config.ts` (which needs a TypeScript loader). None of the
+ * four commands reads the config; the full CLI loads it only to check `--env`
+ * against the declared `environments`, a check the runtime skips.
+ */
+import { parseArgs } from "./cli/parse-args.js";
+import { resolveCommand } from "./cli/registry.js";
+import { formatError } from "./cli/format.js";
+import { flushAndExit } from "./cli/flush.js";
+import { CHANT_VERSION } from "./cli/version.js";
+import { isEntryPoint } from "./cli/is-entry-point.js";
+import { ENV_VAR } from "./env.js";
+import { initRuntime } from "./runtime-adapter.js";
+import { runOpWaveCommand } from "./cli/handlers/run-wave.js";
+import { runResumeCommand } from "./cli/handlers/gate-resume.js";
+import { runApprove } from "./cli/handlers/approve.js";
+import { runWorkspacePoints } from "./workspace/points-cli.js";
+/** The commands the runtime carries, under the names the full CLI registers them by. */
+export const RUNTIME_COMMANDS = [
+    { name: "run wave", handler: runOpWaveCommand },
+    { name: "run resume", handler: runResumeCommand },
+    { name: "approve", handler: runApprove },
+    { name: "workspace points", handler: runWorkspacePoints },
+];
+const HELP = `
+chant runtime ${CHANT_VERSION} - the wave-job commands of chant, in one file
+
+Usage: node wave-runtime.mjs <command> [options]
+
+Commands:
+  run wave --spec <file> --wave <k>   Plan, gate and apply wave k of an Op waves spec
+                                      (--decide, --share <i>, --record-plans, --base <ref>, --json)
+  run resume                          Start the CI jobs that wait at gates whose approval arrived
+                                      (--gate <op>/<gate>, --dry-run, --json)
+  approve <op> <gate>                 Record a gate's resolution on the lifecycle ledger
+                                      (--actor, --plan, --note, --url, --sign, --expire, --resume, ...)
+  workspace points <verb>             Ask, answer and list decision points
+
+Flags, output, exit codes and ledger formats are the full chant CLI's;
+see "chant --help" in @intentius/chant for every flag. This runtime does
+not evaluate chant.config.ts, so --env is not checked against the
+declared environments.
+`;
+/** Parse, dispatch and return the exit code. Exported for tests. */
+export async function runRuntime(argv) {
+    let args;
+    try {
+        args = parseArgs(argv);
+    }
+    catch (err) {
+        console.error(formatError({ message: err instanceof Error ? err.message : String(err) }));
+        return 1;
+    }
+    const match = resolveCommand(args, RUNTIME_COMMANDS);
+    if (args.version && (!args.command || match)) {
+        console.log(CHANT_VERSION);
+        return 0;
+    }
+    if (args.help || !args.command) {
+        console.log(HELP);
+        return args.help ? 0 : 1;
+    }
+    if (!match) {
+        const name = args.path && args.path !== "." ? `${args.command} ${args.path}` : args.command;
+        console.error(formatError({
+            message: `"${name}" is not part of chant's wave-job runtime`,
+            hint: "It runs run wave, run resume, approve and workspace points. Every other command needs the full @intentius/chant CLI.",
+        }));
+        return 1;
+    }
+    if (args.env)
+        process.env[ENV_VAR] = args.env;
+    initRuntime();
+    return match.def.handler({ args, plugins: [], serializers: [] });
+}
+if (isEntryPoint(process.argv[1], import.meta.url)) {
+    runRuntime(process.argv.slice(2)).then(flushAndExit, async (err) => {
+        const verbose = process.argv.includes("--verbose") || process.argv.includes("-v");
+        if (verbose && err instanceof Error && err.stack)
+            console.error(err.stack);
+        else
+            console.error(formatError({ message: err instanceof Error ? err.message : String(err) }));
+        await flushAndExit(1);
+    });
+}