@astrosheep/keiyaku 4.5.28 → 4.6.1

package/build/src/library/nuke.js

@@ -1,15 +1,16 @@
 /** @architectureCompositionRoot */
 import { rmdir } from "node:fs/promises";
 import { resolve } from "node:path";
-import { stopAkuma } from "../akuma/nuke.js";
-import { nukeGit } from "../git/nuke.js";
-import { appendPrivateStateSeatClose } from "../git/private-state-seat.js";
+import { AkumaResetStopError, stopAkuma } from "../akuma/nuke.js";
+import { GitResetStopError, nukeGit } from "../git/nuke.js";
+import { isOperationalFailure } from "../protocol/progress.js";
 import { nukeTask } from "../task/operations.js";
 import { World } from "../world.js";
-import { KeiyakuRefused } from "./refusal.js";
 import { requireInput, requireMarkdown } from "./input.js";
-function diagnostic(error) {
-    return error instanceof Error ? error.message : String(error);
+import { InvocationAccumulator } from "./invocation.js";
+import { project, validated } from "./outcome.js";
+function operational(error) {
+    return error instanceof AkumaResetStopError || error instanceof GitResetStopError || isOperationalFailure(error);
 }
 async function removeEmptyWorldMarker(world) {
     try {
@@ -21,58 +22,70 @@ async function removeEmptyWorldMarker(world) {
             throw error;
     }
 }
-async function nukeInput(input) {
-    const value = requireInput(input, "nuke input");
-    const world = await World.prove(requireMarkdown(value.world, "world"));
-    const confirm = value.confirm === undefined ? undefined : requireMarkdown(value.confirm, "confirm");
-    return { world, ...(confirm === undefined ? {} : { confirm }) };
-}
-function withSeatClose(result, seatClose) {
-    return seatClose === undefined || seatClose.length === 0 ? result : { ...result, seatClose };
-}
 export async function nukeKeiyaku(input, gitOptions) {
-    const value = await nukeInput(input);
-    if (value.confirm === undefined) {
-        throw new KeiyakuRefused({ kind: "nuke-confirmation-required", world: value.world });
-    }
-    if (value.confirm !== value.world) {
-        throw new KeiyakuRefused({
-            kind: "nuke-confirmation-mismatch",
-            world: value.world,
-            confirmation: value.confirm,
-        });
-    }
-    let seatClose;
-    try {
-        const deleteAkuma = await stopAkuma(value.world);
-        let failed = false;
-        let firstDiagnostic;
-        const attempt = async (owner) => {
-            try {
-                await owner;
-            }
-            catch (error) {
-                if (!failed) {
-                    failed = true;
-                    firstDiagnostic = error;
-                }
-            }
+    const value = validated(() => {
+        const values = requireInput(input, "nuke input", ["world", "confirm"]);
+        return {
+            world: requireMarkdown(values.world, "world"),
+            confirm: values.confirm === undefined ? undefined : requireMarkdown(values.confirm, "confirm"),
         };
-        await Promise.all([
-            attempt(deleteAkuma()),
-            attempt(nukeGit(value.world, "git", gitOptions).then((outcome) => {
-                if (outcome.closeLag !== undefined) {
-                    seatClose = appendPrivateStateSeatClose(seatClose, outcome.closeLag);
-                }
-            })),
-            attempt(nukeTask(value.world)),
-        ]);
-        if (failed)
-            throw firstDiagnostic;
-        await removeEmptyWorldMarker(value.world);
-        return withSeatClose({ kind: "success", world: value.world }, seatClose);
-    }
-    catch (error) {
-        return withSeatClose({ kind: "failed", world: value.world, diagnostic: diagnostic(error) }, seatClose);
+    });
+    const world = await World.prove(value.world);
+    const accumulator = new InvocationAccumulator();
+    accumulator.beginReset(world);
+    let failure;
+    const stop = (owner, error) => {
+        if (!operational(error)) {
+            failure ??= { error };
+            return;
+        }
+        accumulator.recordReset({ kind: "reset-owner-stopped", world, owner, diagnostic: error.message });
+    };
+    const runOwner = async (owner, run) => {
+        try {
+            await run();
+        }
+        catch (error) {
+            stop(owner, error);
+        }
+    };
+    let refusal;
+    if (value.confirm === undefined)
+        refusal = { kind: "nuke-confirmation-required", world };
+    else if (value.confirm !== world)
+        refusal = { kind: "nuke-confirmation-mismatch", world, confirmation: value.confirm };
+    else {
+        let deleteAkuma;
+        await runOwner("akuma", async () => {
+            deleteAkuma = await stopAkuma(world);
+        });
+        // No deletion owner starts without proof that live writers have stopped.
+        if (deleteAkuma !== undefined) {
+            await Promise.all([
+                runOwner("akuma", deleteAkuma),
+                runOwner("git", async () => {
+                    const result = await nukeGit(world, "git", gitOptions, (counts) => accumulator.recordResetRemoved(counts));
+                    if (result.closeLag !== undefined)
+                        accumulator.recordReset({
+                            kind: "reset-residue",
+                            world,
+                            owner: "git",
+                            diagnostic: result.closeLag.diagnostic,
+                        });
+                }),
+                runOwner("task", async () => {
+                    await nukeTask(world, { onRemoved: (tasks) => accumulator.recordResetRemoved({ tasks }) });
+                }),
+            ]);
+            await runOwner("world", () => removeEmptyWorldMarker(world));
+        }
     }
+    const projected = project("nuke", accumulator.snapshot(), failure !== undefined
+        ? { kind: "failed", world, error: failure.error }
+        : refusal !== undefined
+            ? { kind: "refused", world, refusal }
+            : { kind: "accepted", world });
+    if (projected.kind === "failed")
+        throw projected.error;
+    return projected.outcome;
 }