superpowers-manager 0.6.0 → 0.7.1

package/dist/harnesses/pi/package.js

@@ -1,112 +1,10 @@
-import { execFile } from "node:child_process";
-import { createHash } from "node:crypto";
-import { chmod, mkdir, symlink, writeFile } from "node:fs/promises";
-import { dirname, isAbsolute, join, relative, resolve } from "node:path";
-import { promisify } from "node:util";
-import { ARTIFACT_DIGEST_RE, ARTIFACT_RECEIPT, addArtifactHashField, digestArtifactTree, readArtifactObject, } from "../../artifact-tree.js";
+import { join } from "node:path";
+import { ARTIFACT_DIGEST_RE, ARTIFACT_RECEIPT, digestArtifactTree, readArtifactObject, } from "../../artifact-tree.js";
 import { COMMIT_RE } from "../../domain/refs.js";
-import { assertNoFollowType, assertSymlinkTargetContained, } from "../../safe-path.js";
 import { SafetyError } from "../../safety-error.js";
 import { validateSource } from "../../selection.js";
 import { assessPiCompatibility } from "./compatibility.js";
-const exec = promisify(execFile);
-const DECODER = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
-// A consistency checksum, not authentication. A coherent manual rewrite of
-// both receipt and bytes remains possible; installed comparison must still use
-// an independently validated candidate.
-export function piReceiptBinding(receipt) {
-    const hash = createHash("sha256");
-    for (const field of [
-        String(receipt.schema),
-        receipt.manager,
-        receipt.harness,
-        receipt.source,
-        receipt.commit,
-        receipt.digest,
-    ])
-        addArtifactHashField(hash, Buffer.from(field));
-    return hash.digest("hex");
-}
-async function gitBytes(repository, args) {
-    try {
-        return (await exec("git", ["--no-replace-objects", "-C", repository, ...args], {
-            encoding: null,
-            maxBuffer: 256 * 1024 * 1024,
-        })).stdout;
-    }
-    catch (cause) {
-        throw new SafetyError("pi-package", `cannot read Pi tree objects from repository: ${repository}`, { cause });
-    }
-}
-export async function materializePiTree(repository, commit, destination) {
-    try {
-        if (!COMMIT_RE.test(commit))
-            throw new Error("commit");
-        if (!(await gitBytes(repository, ["cat-file", "-t", commit])).equals(Buffer.from("commit\n")))
-            throw new Error("not a commit");
-        await assertNoFollowType(destination, ["missing"]);
-        const bytes = await gitBytes(repository, [
-            "ls-tree",
-            "-rz",
-            "--full-tree",
-            commit,
-        ]);
-        const entries = [];
-        let offset = 0;
-        while (offset < bytes.length) {
-            const end = bytes.indexOf(0, offset);
-            if (end < 0)
-                throw new Error("tree framing");
-            const record = DECODER.decode(bytes.subarray(offset, end));
-            offset = end + 1;
-            const match = /^(100644|100755|120000) blob ([a-f0-9]{40})\t([\s\S]+)$/.exec(record);
-            if (!match)
-                throw new Error("tree entry");
-            const path = match[3];
-            if (path
-                .split("/")
-                .some((part) => !part ||
-                part === "." ||
-                part === ".." ||
-                part.toLowerCase() === ".git") ||
-                isAbsolute(path) ||
-                path.includes("\\") ||
-                path.split("/")[0] === ARTIFACT_RECEIPT)
-                throw new Error("tree path");
-            entries.push({ mode: match[1], oid: match[2], path });
-        }
-        await mkdir(destination, { recursive: true });
-        for (const entry of entries) {
-            await mkdir(dirname(join(destination, entry.path)), { recursive: true });
-        }
-        for (const entry of entries.filter((entry) => entry.mode !== "120000")) {
-            const path = join(destination, entry.path);
-            await writeFile(path, await gitBytes(repository, ["cat-file", "blob", entry.oid]), { flag: "wx", mode: entry.mode === "100755" ? 0o755 : 0o644 });
-            await chmod(path, entry.mode === "100755" ? 0o755 : 0o644);
-        }
-        for (const entry of entries.filter((entry) => entry.mode === "120000")) {
-            const target = DECODER.decode(await gitBytes(repository, ["cat-file", "blob", entry.oid]));
-            const path = join(destination, entry.path);
-            const suffix = relative(resolve(destination), resolve(dirname(path), target));
-            if (!target ||
-                target.includes("\0") ||
-                isAbsolute(target) ||
-                suffix === ".." ||
-                suffix.startsWith("../") ||
-                isAbsolute(suffix))
-                throw new Error("link escape");
-            await symlink(target, path);
-        }
-        for (const entry of entries.filter((entry) => entry.mode === "120000"))
-            await assertSymlinkTargetContained(destination, join(destination, entry.path));
-    }
-    catch (cause) {
-        throw new SafetyError("pi-package", `cannot materialize Pi tree from ${repository} into ${destination}`, { cause });
-    }
-}
-export async function digestPiTree(root) {
-    return await digestArtifactTree(root);
-}
+import { snapshotReceiptBinding } from "../../snapshot-package.js";
 export async function readPiReceipt(root) {
     const path = join(root, ARTIFACT_RECEIPT);
     try {
@@ -123,7 +21,7 @@ export async function readPiReceipt(root) {
             !ARTIFACT_DIGEST_RE.test(value.binding))
             throw new Error("receipt fields");
         validateSource(value.source);
-        if (piReceiptBinding(value) !== value.binding)
+        if (snapshotReceiptBinding(value) !== value.binding)
             throw new Error("receipt binding");
         const compatibility = value.compatibility;
         if (!compatibility ||
@@ -144,7 +42,7 @@ export async function readPiReceipt(root) {
 }
 export async function readPiPackageAssessment(root) {
     const receipt = await readPiReceipt(root);
-    if ((await digestPiTree(root)) !== receipt.digest)
+    if ((await digestArtifactTree(root)) !== receipt.digest)
         throw new SafetyError("pi-package", `Pi artifact digest mismatch: ${root}`);
     const compatibility = await assessPiCompatibility(root, {
         effectiveSource: receipt.source,

package/dist/harnesses/pi/prepare.js

@@ -1,111 +1,20 @@
-import { writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { failureResult, successResult, } from "../../adapter-result.js";
-import { ARTIFACT_RECEIPT } from "../../artifact-tree.js";
+import { createSnapshotPreparation } from "../../snapshot-prepare.js";
 import { piPaths } from "./paths.js";
-import { assessPiCompatibility, samePiSource } from "./compatibility.js";
-import { digestPiTree, materializePiTree, readPiPackageAssessment, piReceiptBinding, } from "./package.js";
-import { classifyPathNoFollow } from "../../safe-path.js";
+import { assessPiCompatibility } from "./compatibility.js";
+import { readPiPackageAssessment } from "./package.js";
 export function piPreparationLocation(ctx) {
     return {
         destinationRoot: piPaths(ctx.env ?? {}, process.cwd()).preparedRoot,
         stagingLeaf: "superpowers",
     };
 }
-export async function preparePiCandidate(input, _ctx) {
-    try {
-        await materializePiTree(input.upstreamRoot, input.selection.desiredCommit, input.candidateRoot);
-        const compatibility = await assessPiCompatibility(input.candidateRoot, input.selection);
-        if (compatibility.kind === "unsupported" ||
-            compatibility.kind === "unknown")
-            return failureResult("prepare", "unsupported", compatibility.reason, [], []);
-        const digest = await digestPiTree(input.candidateRoot);
-        const identity = {
-            schema: 1,
-            manager: "superpowers-manager",
-            harness: "pi",
-            source: input.selection.effectiveSource,
-            commit: input.selection.desiredCommit,
-            digest,
-        };
-        const receipt = {
-            ...identity,
-            binding: piReceiptBinding(identity),
-            compatibility,
-        };
-        await writeFile(join(input.candidateRoot, ARTIFACT_RECEIPT), JSON.stringify(receipt) + "\n", { flag: "wx" });
-        return successResult("prepare", {
-            root: input.candidateRoot,
-            commit: receipt.commit,
-            identity: digest,
-            compatibility,
-        }, []);
-    }
-    catch {
-        return failureResult("prepare", "invalid-package", `cannot prepare Pi artifact: ${input.candidateRoot}`, [], []);
-    }
-}
-async function readArtifactAssessment(root) {
-    const { receipt, compatibility } = await readPiPackageAssessment(root);
-    return {
-        receipt,
-        artifact: {
-            root,
-            commit: receipt.commit,
-            identity: receipt.digest,
-            compatibility,
-        },
-    };
-}
-async function readArtifact(root) {
-    const { artifact } = await readArtifactAssessment(root);
-    const { compatibility } = artifact;
-    if (compatibility.kind !== "supported" &&
-        compatibility.kind !== "experimental")
-        throw new Error("unsupported profile");
-    return artifact;
-}
-export async function inspectPiPrepared(selection, ctx) {
-    const root = piPreparationLocation(ctx).destinationRoot;
-    const unknown = {
-        kind: "unknown",
-        reason: "Pi prepared compatibility evidence is missing",
-    };
-    try {
-        if ((await classifyPathNoFollow(join(root, ARTIFACT_RECEIPT))) === "missing")
-            return successResult("inspect-prepared", { kind: "needs-prepare", observedIdentity: "", compatibility: unknown }, []);
-        const { artifact, receipt } = await readArtifactAssessment(root);
-        if (artifact.commit !== selection.desiredCommit ||
-            !samePiSource(receipt.source, selection.effectiveSource))
-            return successResult("inspect-prepared", {
-                kind: "needs-prepare",
-                observedIdentity: artifact.identity,
-                compatibility: unknown,
-            }, []);
-        if (artifact.compatibility.kind !== "supported" &&
-            artifact.compatibility.kind !== "experimental")
-            return successResult("inspect-prepared", {
-                kind: "needs-prepare",
-                observedIdentity: artifact.identity,
-                compatibility: artifact.compatibility,
-            }, []);
-        return successResult("inspect-prepared", {
-            kind: "current",
-            artifact,
-            observedIdentity: artifact.identity,
-            compatibility: artifact.compatibility,
-        }, []);
-    }
-    catch {
-        return failureResult("inspect-prepared", "invalid-package", `cannot inspect Pi prepared artifact: ${root}`, [], []);
-    }
-}
-export async function readPiPrepared(ctx) {
-    const root = piPreparationLocation(ctx).destinationRoot;
-    try {
-        return successResult("read-prepared", await readArtifact(root), []);
-    }
-    catch {
-        return failureResult("read-prepared", "invalid-package", `cannot read Pi prepared artifact: ${root}`, [], []);
-    }
-}
+const preparation = createSnapshotPreparation({
+    harness: "pi",
+    label: "Pi",
+    preparationLocation: piPreparationLocation,
+    assessCompatibility: assessPiCompatibility,
+    readAssessment: readPiPackageAssessment,
+});
+export const preparePiCandidate = preparation.prepareCandidate;
+export const inspectPiPrepared = preparation.inspectPrepared;
+export const readPiPrepared = preparation.readPrepared;

package/dist/harnesses/pi/presentation.js

@@ -1,67 +1,24 @@
-export const piPresentation = {
-    installNotice: "",
-    currentNotice: "The Superpowers Pi snapshot is current.",
-    renderProbe(facts) {
-        const fields = [
-            ["harness", "pi"],
-            ["desired_commit", facts.selection.desiredCommit],
-            ["prepared_identity", facts.prepared.observedIdentity],
-            ["installed_identity", facts.installed.observedIdentity],
-            ["installation_state", facts.installed.kind],
-            ["resource_state", facts.resourceState ?? "idle"],
-            ["ownership", facts.ownership.presentationValue],
-            ["conflicts", (facts.ownership.presentationConflicts ?? []).join("; ")],
-            ["update_control", facts.control.presentationValue],
-            ["compatibility", facts.compatibility.kind],
-            ["compatibility_reason", facts.compatibility.reason],
-            ["status", facts.status],
-        ];
-        return {
-            human: fields
-                .map(([key, value]) => `${key.replaceAll("_", " ")}: ${value || "not present"}\n`)
-                .join(""),
-            porcelain: fields.map(([key, value]) => `${key}=${value}\n`).join(""),
-        };
-    },
-    renderInstallVerification(_desiredCommit, receipt, inspection) {
-        if (receipt.status !== 0 || !receipt.outcome.ok)
-            return {
-                stdout: [],
-                stderr: [
-                    "error: Pi activation did not return a verified installation receipt",
-                ],
-            };
-        if (inspection.status !== 0 || !inspection.outcome.ok)
-            return receipt.outcome.result.missingVerificationOutput;
-        if (inspection.outcome.result.kind === "current")
-            return {
-                stdout: [
-                    "Installed the frozen Superpowers Pi snapshot. Restart Pi to load it.",
-                ],
-                stderr: [],
-            };
-        return inspection.outcome.result.kind === "absent"
-            ? receipt.outcome.result.missingVerificationOutput
-            : receipt.outcome.result.mismatchVerificationOutput;
-    },
-    renderRemovalCompletion(_ownership, removalInput) {
-        return removalInput.receiptDigest === null &&
-            removalInput.registrationIdentity === null
-            ? {
-                stdout: ["No managed Superpowers Pi installation is present."],
-                stderr: [],
-            }
-            : {
-                stdout: [
-                    "Removed the managed Superpowers Pi installation. Restart Pi to load the resulting state.",
-                ],
-                stderr: [],
-            };
-    },
-    callFailure(site) {
-        return {
-            unexpected: `Pi ${site} did not complete`,
-            invalidStatus: `Pi ${site} returned an invalid status`,
-        };
-    },
+import { createSnapshotPresentation } from "../../snapshot-presentation.js";
+const renderProbe = (facts) => {
+    const fields = [
+        ["harness", "pi"],
+        ["desired_commit", facts.selection.desiredCommit],
+        ["prepared_identity", facts.prepared.observedIdentity],
+        ["installed_identity", facts.installed.observedIdentity],
+        ["installation_state", facts.installed.kind],
+        ["resource_state", facts.resourceState ?? "idle"],
+        ["ownership", facts.ownership.presentationValue],
+        ["conflicts", (facts.ownership.presentationConflicts ?? []).join("; ")],
+        ["update_control", facts.control.presentationValue],
+        ["compatibility", facts.compatibility.kind],
+        ["compatibility_reason", facts.compatibility.reason],
+        ["status", facts.status],
+    ];
+    return {
+        human: fields
+            .map(([key, value]) => `${key.replaceAll("_", " ")}: ${value || "not present"}\n`)
+            .join(""),
+        porcelain: fields.map(([key, value]) => `${key}=${value}\n`).join(""),
+    };
 };
+export const piPresentation = createSnapshotPresentation("Pi", renderProbe, (input) => input.receiptDigest === null && input.registrationIdentity === null);

package/dist/harnesses/pi/shared-skills.js

@@ -1,7 +1,7 @@
 import { readdir, readFile, readlink, realpath } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep, } from "node:path";
 import { fileURLToPath } from "node:url";
-import { classifyPathNoFollow } from "../../safe-path.js";
+import { classifyPathNoFollow, isContained } from "../../safe-path.js";
 const PI_IGNORE_FILES = [".gitignore", ".ignore", ".fdignore"];
 function toPosixPath(path) {
     return path.split(sep).join("/");
@@ -164,6 +164,20 @@ function normalizeExactSkillPattern(pattern) {
         : pattern;
     return toPosixPath(normalized);
 }
+function forcedSkillActivity(path, identityRoot, controls) {
+    const identities = exactSkillIdentities(path, identityRoot);
+    for (const [prefix, activity] of [
+        ["-", "disabled"],
+        ["+", "active"],
+    ]) {
+        const patterns = controls
+            .filter((control) => control.startsWith(prefix))
+            .map((control) => normalizeExactSkillPattern(control.slice(1)));
+        if (patterns.some((pattern) => identities.includes(pattern)))
+            return activity;
+    }
+    return null;
+}
 function hasUnknownMinimatchSyntax(pattern) {
     return (pattern.startsWith("#") ||
         pattern.includes("!") ||
@@ -171,19 +185,9 @@ function hasUnknownMinimatchSyntax(pattern) {
         toPosixPath(pattern).includes("//"));
 }
 function sharedSkillActivity(path, agentsRoot, controls) {
-    const exactIdentities = exactSkillIdentities(path, agentsRoot);
-    const forceExcludes = controls
-        .filter((control) => control.startsWith("-"))
-        .map((control) => normalizeExactSkillPattern(control.slice(1)));
-    if (forceExcludes.some((pattern) => exactIdentities.includes(pattern))) {
-        return "disabled";
-    }
-    const forceIncludes = controls
-        .filter((control) => control.startsWith("+"))
-        .map((control) => normalizeExactSkillPattern(control.slice(1)));
-    if (forceIncludes.some((pattern) => exactIdentities.includes(pattern))) {
-        return "active";
-    }
+    const forced = forcedSkillActivity(path, agentsRoot, controls);
+    if (forced !== null)
+        return forced;
     const excludePatterns = controls
         .filter((control) => control.startsWith("!"))
         .map((control) => control.slice(1));
@@ -233,11 +237,6 @@ function resolveTopLevelSkillPath(source, paths) {
         ? resolve(normalized)
         : resolve(paths.agentDir, normalized);
 }
-function containedBy(root, candidate) {
-    const suffix = relative(root, candidate);
-    return (suffix === "" ||
-        (!isAbsolute(suffix) && suffix !== ".." && !suffix.startsWith(`..${sep}`)));
-}
 async function hasSafeSharedSkillAncestors(path, sharedRoot) {
     const suffix = relative(sharedRoot, dirname(path));
     const directories = [sharedRoot];
@@ -260,19 +259,9 @@ async function hasSafeSharedSkillAncestors(path, sharedRoot) {
     return true;
 }
 function explicitSharedSkillActivity(path, paths, controls) {
-    const exactIdentities = exactSkillIdentities(path, paths.agentDir);
-    const forceExcludes = controls
-        .filter((control) => control.startsWith("-"))
-        .map((control) => normalizeExactSkillPattern(control.slice(1)));
-    if (forceExcludes.some((pattern) => exactIdentities.includes(pattern))) {
-        return "disabled";
-    }
-    const forceIncludes = controls
-        .filter((control) => control.startsWith("+"))
-        .map((control) => normalizeExactSkillPattern(control.slice(1)));
-    if (forceIncludes.some((pattern) => exactIdentities.includes(pattern))) {
-        return "active";
-    }
+    const forced = forcedSkillActivity(path, paths.agentDir, controls);
+    if (forced !== null)
+        return forced;
     const excludePatterns = controls
         .filter((control) => control.startsWith("!"))
         .map((control) => control.slice(1));
@@ -321,7 +310,7 @@ async function explicitSharedSkillActivities(settings, paths) {
             lexicalKind = await classifyPathNoFollow(path);
         }
         catch {
-            if (containedBy(sharedRoot, path) || containedBy(path, sharedRoot)) {
+            if (isContained(sharedRoot, path) || isContained(path, sharedRoot)) {
                 indeterminate = true;
             }
             continue;
@@ -333,12 +322,12 @@ async function explicitSharedSkillActivities(settings, paths) {
             canonicalPath = await realpath(path);
         }
         catch {
-            let related = containedBy(sharedRoot, path) || containedBy(path, sharedRoot);
+            let related = isContained(sharedRoot, path) || isContained(path, sharedRoot);
             if (!related && lexicalKind === "symlink") {
                 try {
                     const target = resolve(dirname(path), await readlink(path));
                     related =
-                        containedBy(sharedRoot, target) || containedBy(target, sharedRoot);
+                        isContained(sharedRoot, target) || isContained(target, sharedRoot);
                 }
                 catch {
                     // Without a relationship to the known route, preserve unrelated state.
@@ -348,10 +337,10 @@ async function explicitSharedSkillActivities(settings, paths) {
                 indeterminate = true;
             continue;
         }
-        const related = containedBy(sharedRoot, path) ||
-            containedBy(path, sharedRoot) ||
-            containedBy(canonicalSharedRoot, canonicalPath) ||
-            containedBy(canonicalPath, canonicalSharedRoot);
+        const related = isContained(sharedRoot, path) ||
+            isContained(path, sharedRoot) ||
+            isContained(canonicalSharedRoot, canonicalPath) ||
+            isContained(canonicalPath, canonicalSharedRoot);
         if (!related)
             continue;
         let canonicalKind;

package/dist/harnesses/pi/state.js

@@ -1,9 +1,9 @@
 import { join } from "node:path";
 import { sharedPiSkillsActivity } from "./shared-skills.js";
-import { failureResult, successResult, } from "../../adapter-result.js";
+import { inspectionFailure, successResult, } from "../../adapter-result.js";
 import { readArtifactObject } from "../../artifact-tree.js";
-import { samePiSource } from "./compatibility.js";
-import { digestPiTree, readPiPackageAssessment, readPiReceipt, } from "./package.js";
+import { observeSnapshot, sameSnapshotSource, } from "../../snapshot-package.js";
+import { readPiPackageAssessment, readPiReceipt, } from "./package.js";
 import { piPaths } from "./paths.js";
 import { readPiSettings, resolveCanonicalPiLocalSource, resolvePiLocalSource, } from "./settings.js";
 import { classifyPathNoFollow } from "../../safe-path.js";
@@ -111,23 +111,6 @@ async function observeSettings(paths) {
     }
     return { settings, registration };
 }
-async function observeSnapshot(paths) {
-    const kind = await classifyPathNoFollow(paths.installedRoot);
-    if (kind === "missing")
-        return { kind: "absent" };
-    if (kind !== "directory")
-        return { kind: "unverified" };
-    try {
-        const receipt = await readPiReceipt(paths.installedRoot);
-        const digest = await digestPiTree(paths.installedRoot);
-        return receipt.digest === digest
-            ? { kind: "owned", receipt, digest }
-            : { kind: "unverified" };
-    }
-    catch {
-        return { kind: "unverified" };
-    }
-}
 async function isNamedLocalSuperpowers(entry, paths, canonicalInstalledRoot) {
     const root = resolvePiLocalSource(entry.source, paths.agentDir, paths.homeDir);
     if (root === null ||
@@ -176,16 +159,13 @@ async function unmanagedConflicts(settings, paths) {
     }
     return [...conflicts];
 }
-function inspectionFailure(operation, subject) {
-    return failureResult(operation, "invalid-state", `cannot inspect ${subject}`, [], []);
-}
 export async function inspectPiOwnership(ctx) {
     const operation = "inspect-pi-ownership";
     const paths = pathsFor(ctx);
     try {
         const [{ settings, registration }, snapshot] = await Promise.all([
             observeSettings(paths),
-            observeSnapshot(paths),
+            observeSnapshot(paths.installedRoot, readPiReceipt),
         ]);
         if (snapshot.kind === "unverified") {
             return inspectionFailure(operation, `Pi ownership at ${paths.installedRoot}`);
@@ -240,7 +220,7 @@ export async function inspectPiInstalled(selection, ctx) {
     try {
         [settings, snapshot] = await Promise.all([
             observeSettings(paths),
-            observeSnapshot(paths),
+            observeSnapshot(paths.installedRoot, readPiReceipt),
         ]);
     }
     catch {
@@ -267,9 +247,9 @@ export async function inspectPiInstalled(selection, ctx) {
         if ((intended.compatibility.kind !== "supported" &&
             intended.compatibility.kind !== "experimental") ||
             intended.receipt.commit !== selection.desiredCommit ||
-            !samePiSource(intended.receipt.source, selection.effectiveSource) ||
+            !sameSnapshotSource(intended.receipt.source, selection.effectiveSource) ||
             snapshot.receipt.commit !== intended.receipt.commit ||
-            !samePiSource(snapshot.receipt.source, intended.receipt.source) ||
+            !sameSnapshotSource(snapshot.receipt.source, intended.receipt.source) ||
             snapshot.digest !== intended.receipt.digest) {
             return mismatch;
         }

package/dist/provenance.js

@@ -67,8 +67,8 @@ export function generatedMetadataPath(root) {
 // Ported from
 // `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/core/lifecycle.sh:33-37::spw_generated_commit_or_empty`.
 // Lenient by design: a missing or malformed generated provenance file yields
-// "", which `statusForCommits` reads as "needs prepare". Aborting here would
-// deny the operator the remediation path.
+// "", which the typed prepared-state flow reports as "needs prepare".
+// Aborting here would deny the operator the remediation path.
 export async function generatedCommitOrEmpty(root) {
     return readGeneratedCommitLenient(generatedMetadataPath(root));
 }

package/dist/safe-path.js

@@ -1,12 +1,12 @@
 import { lstat, readlink, realpath } from "node:fs/promises";
 import { basename, dirname, isAbsolute, relative, resolve, sep, } from "node:path";
 import { SafetyError } from "./safety-error.js";
-function isErrno(value, code) {
+export function isErrno(value, code) {
     return (value instanceof Error &&
         "code" in value &&
         value.code === code);
 }
-function isContained(root, candidate) {
+export function isContained(root, candidate) {
     const suffix = relative(root, candidate);
     return (suffix === "" ||
         (!isAbsolute(suffix) && suffix !== ".." && !suffix.startsWith(`..${sep}`)));

package/dist/selection-store.js

@@ -1,7 +1,7 @@
 import { constants } from "node:fs";
 import { mkdir, open } from "node:fs/promises";
 import { dirname } from "node:path";
-import { atomicWriteFile, } from "./atomic.js";
+import { atomicWriteFile } from "./atomic.js";
 import { classifyPathNoFollow } from "./safe-path.js";
 import { SafetyError } from "./safety-error.js";
 import { selectionError, serializeRecord, validateRecord, } from "./selection.js";
@@ -132,19 +132,6 @@ async function ensureStateDirectory(path) {
         throw selectionError(`selection state directory is not usable: ${path}`);
     }
 }
-async function finalStateDiagnostic(path, finalBytes) {
-    try {
-        const record = finalBytes === undefined
-            ? await readSelectionState(path)
-            : parseRecordBytes(path, finalBytes);
-        return record === null
-            ? "selection state is now absent"
-            : `selection state is now ${record.mode}`;
-    }
-    catch (cause) {
-        return `final selection state cannot be validated: ${errorText(cause)}`;
-    }
-}
 export async function writeSelectionState(path, proposed, options = {}) {
     await ensureStateDirectory(dirname(path));
     // Invalid existing state must block overwrite.
@@ -160,13 +147,6 @@ export async function writeSelectionState(path, proposed, options = {}) {
         });
     }
     catch (cause) {
-        const details = cause instanceof SafetyError && cause.module === "atomic"
-            ? cause.details
-            : undefined;
-        if (details?.phase !== "post-replacement") {
-            throw selectionError(`cannot write selection state: ${causedErrorText(cause)}`, cause);
-        }
-        const diagnostic = await finalStateDiagnostic(path, details.finalBytes);
-        throw selectionError(`cannot complete selection state write: ${causedErrorText(cause)}; ${diagnostic}`, cause);
+        throw selectionError(`cannot write selection state: ${causedErrorText(cause)}`, cause);
     }
 }