@vela-science/canopus 0.6.5 → 0.8.0

package/dist/src/run.js

@@ -5,73 +5,16 @@ import { ActivityStore } from "./activity/store.js";
 import { freezeArtifact, sealArtifactStore, } from "./artifact/freeze.js";
 import { materializeDraftArtifacts } from "./artifact/materialize.js";
 import { BudgetTracker } from "./budget/enforce.js";
+import { finalizeCandidate } from "./candidate/finalize.js";
 import { engineManifest, verifierManifest } from "./evidence/manifests.js";
-import { projectRun, RUN_RECORD_SCHEMA } from "./projection/run.js";
-import { finalizeCandidate, installFrozenArtifacts, mapCandidateToReceipt, } from "./receipt/map.js";
-import { canonicalJson, contentDigest, sha256Bytes } from "./util/canonical.js";
-import { isolatedEnvironment, runCommand } from "./util/command.js";
-import { retainedArtifactPath } from "./vela/cli.js";
+import { canonicalJson, contentDigest } from "./util/canonical.js";
 import { runVerifier } from "./verifier/run.js";
 import { cleanupWorkspace, prepareWorkspace } from "./workspace/prepare.js";
-function sameRoots(left, right) {
-    return (left.git_commit === right.git_commit &&
-        left.git_tree === right.git_tree &&
-        left.vela_event_log === right.vela_event_log &&
-        left.vela_snapshot === right.vela_snapshot);
-}
-function strictBaseline(mission) {
-    return mission.schema === "canopus.mission.v1" ? mission.strict_baseline : undefined;
-}
-function recordField(value, key, at) {
-    const field = value[key];
-    if (typeof field !== "object" || field === null || Array.isArray(field)) {
-        throw new Error(`${at}.${key} is not an object`);
-    }
-    return field;
-}
 function exactText(value, expected, at) {
     if (value !== expected) {
         throw new Error(`${at} mismatch: expected ${expected}, observed ${String(value)}`);
     }
 }
-function assertWorkBinding(mission, response, postWork) {
-    if (response.value.schema === "vela.work.v1") {
-        exactText(response.value.command, "work", "vela work.command");
-        exactText(response.value.target_id, mission.target, "vela work.target_id");
-        const roots = recordField(response.value, "starting_roots", "vela work");
-        exactText(roots.event_log, mission.roots.vela_event_log, "vela work.starting_roots.event_log");
-        exactText(roots.git_commit, mission.roots.git_commit, "vela work.starting_roots.git_commit");
-        const session = recordField(response.value, "session", "vela work");
-        if (typeof session.id !== "string" || session.id.length === 0) {
-            throw new Error("vela work.session.id must be nonempty");
-        }
-        if (postWork.roots.git_commit === mission.roots.git_commit ||
-            postWork.roots.git_tree === mission.roots.git_tree ||
-            postWork.roots.vela_event_log === mission.roots.vela_event_log) {
-            throw new Error("vela work did not publish an exact lease delta");
-        }
-        return;
-    }
-    const claim = recordField(response.value, "claim", "vela work");
-    const session = recordField(response.value, "session", "vela work");
-    const publication = recordField(claim, "publication", "vela work.claim");
-    exactText(response.value.command, "work", "vela work.command");
-    exactText(claim.state_root_before, mission.roots.vela_event_log, "vela work.claim.state_root_before");
-    exactText(session.base_event_log_root, mission.roots.vela_event_log, "vela work.session.base_event_log_root");
-    exactText(session.source_git_commit_oid, mission.roots.git_commit, "vela work.session.source_git_commit_oid");
-    exactText(claim.state_root_after, postWork.roots.vela_event_log, "vela work.claim.state_root_after");
-    const publicationState = publication.state;
-    if (publicationState !== "committed_local" &&
-        publicationState !== "pushed" &&
-        publicationState !== "unchanged") {
-        throw new Error(`vela work lease was not published: ${String(publicationState)}`);
-    }
-    exactText(publication.commit, postWork.roots.git_commit, "vela work publication commit");
-    if (postWork.roots.git_commit === mission.roots.git_commit ||
-        postWork.roots.git_tree === mission.roots.git_tree) {
-        throw new Error("vela work did not publish an exact lease delta");
-    }
-}
 export function validateTargetOffer(target, response) {
     exactText(response.value.command, "next", "vela next.command");
     const targets = response.value.targets;
@@ -95,87 +38,9 @@ export function validateTargetOffer(target, response) {
     }
     return matches[0];
 }
-function publicationState(land) {
-    const value = land.publication.state;
-    return typeof value === "string" ? value : "unknown";
-}
-export function isPrivateWorkSessionStatus(entry) {
-    if (!entry.startsWith("?? "))
-        return false;
-    const relative = entry.slice(3);
-    const parts = relative.split("/");
-    return (parts.length === 4 &&
-        parts[0] === ".vela" &&
-        parts[1] === "work" &&
-        parts[2] !== undefined &&
-        /^[a-zA-Z0-9._-]+$/u.test(parts[2]) &&
-        parts[3] === "session.json");
-}
 async function writeExclusive(file, value) {
     await writeFile(file, canonicalJson(value), { flag: "wx", mode: 0o600 });
 }
-async function publishArtifactSources(options) {
-    const frontierRoot = path.resolve(options.repoRoot, options.frontier);
-    const paths = [...new Set(options.artifacts.map((artifact) => {
-            const absolute = path.resolve(frontierRoot, artifact.path);
-            const relative = path.relative(options.repoRoot, absolute);
-            if (relative === "" ||
-                relative === ".." ||
-                relative.startsWith(`..${path.sep}`) ||
-                path.isAbsolute(relative)) {
-                throw new Error(`artifact publication path escapes the landing repository: ${artifact.path}`);
-            }
-            return relative;
-        }))].sort();
-    const environment = isolatedEnvironment(options.home);
-    const git = async (argv) => {
-        const result = await runCommand({
-            argv: ["git", ...argv],
-            cwd: options.repoRoot,
-            env: environment,
-            timeoutMs: 30_000,
-            maxOutputBytes: 1_048_576,
-        });
-        if (result.exitCode !== 0 || result.stderr.length !== 0) {
-            throw new Error(`artifact publication git command failed: exit=${result.exitCode}; ` +
-                `stdout=${sha256Bytes(result.stdout)}; stderr=${sha256Bytes(result.stderr)}`);
-        }
-        return result.stdout;
-    };
-    await git(["add", "--force", "--", ...paths]);
-    const staged = (await git(["diff", "--cached", "--name-only", "-z"]))
-        .toString("utf8").split("\0").filter((entry) => entry.length > 0).sort();
-    if (canonicalJson(staged) !== canonicalJson(paths)) {
-        throw new Error("artifact publication staged a path outside the exact frozen artifact set");
-    }
-    const status = (await git(["status", "--porcelain=v1", "-z", "--untracked-files=all"]))
-        .toString("utf8").split("\0").filter((entry) => entry.length > 0).sort();
-    // `vela work` deliberately keeps its producer capability in one private,
-    // untracked session file until `vela land` consumes it. The worker cannot
-    // access the landing clone, and every other unstaged path remains fatal.
-    const privateWorkSessions = status.filter(isPrivateWorkSessionStatus);
-    if (privateWorkSessions.length > 1) {
-        throw new Error("artifact publication observed multiple private Vela work sessions");
-    }
-    const expectedStatus = [
-        ...paths.map((entry) => `A  ${entry}`),
-        ...privateWorkSessions,
-    ].sort();
-    if (canonicalJson(status) !== canonicalJson(expectedStatus)) {
-        throw new Error("artifact publication observed unrelated or unstaged repository changes");
-    }
-    await git([
-        "-c", "user.name=Canopus Agent",
-        "-c", "user.email=canopus-agent@invalid.example",
-        "commit", "--no-gpg-sign", "-m", "canopus: publish verified mission artifacts",
-    ]);
-    const commit = (await git(["rev-parse", "--verify", "HEAD^{commit}"])).toString("utf8").trim();
-    const tree = (await git(["rev-parse", "--verify", "HEAD^{tree}"])).toString("utf8").trim();
-    if (!/^[0-9a-f]{40}$/u.test(commit) || !/^[0-9a-f]{40}$/u.test(tree)) {
-        throw new Error("artifact publication returned malformed Git object IDs");
-    }
-    return { commit, tree, paths };
-}
 export async function runCanopus(options) {
     const runId = `run_${randomUUID()}`;
     const paths = await prepareWorkspace({
@@ -187,9 +52,6 @@ export async function runCanopus(options) {
     const activity = await ActivityStore.open(path.join(paths.root, "activity.jsonl"), runId);
     const budget = new BudgetTracker(options.mission.budgets);
     let phase = "initializing";
-    let landingCommand;
-    let rawLanding;
-    let parsedLanding;
     try {
         await activity.append("run.started", {
             mission_id: options.mission.id,
@@ -197,49 +59,33 @@ export async function runCanopus(options) {
         });
         await activity.append("workspace.prepared", {
             input: "input",
-            landing: "landing",
+            frontier: "frontier",
             output: "output",
             artifacts: "artifacts",
         });
         await Promise.all([
-            options.vela.assertRoots(paths.input, options.mission.frontier, options.mission.roots, strictBaseline(options.mission)),
-            options.vela.assertRoots(paths.landing, options.mission.frontier, options.mission.roots, strictBaseline(options.mission)),
+            options.vela.assertRoots(paths.input, options.mission.frontier, options.mission.roots),
+            options.vela.assertRoots(paths.frontier, options.mission.frontier, options.mission.roots),
         ]);
         await activity.append("roots.verified", { roots: options.mission.roots });
         // Vela's task offer performs recovery-barrier bookkeeping even though it
         // does not change scientific state. Run it in the exact-root control clone;
         // the separate worker input clone stays sealed and read-only.
-        const offer = await options.vela.next(options.mission, paths.landing);
+        const offer = await options.vela.next(options.mission, paths.frontier);
         const selected = validateTargetOffer(options.mission.target, offer);
         await activity.append("target.offered", {
             target: selected.id,
             rank: selected.index,
             offer_digest: contentDigest(offer.value),
         });
-        let workBriefing;
-        let postWork;
-        if (options.noLand === true) {
-            // Diagnostic mode has no landing edge and therefore needs no durable
-            // lease. Avoiding `vela work` keeps the disposable clone at the exact
-            // registered roots and prevents an operational attempt event from
-            // needlessly invalidating a previously exported proof packet.
-            workBriefing = offer.value;
-            await activity.append("work.skipped", {
-                target: options.mission.target,
-                mode: "no_land",
-                reason: "diagnostic run has no landing edge",
-            });
-        }
-        else {
-            const work = await options.vela.work(options.mission, paths.landing, options.mission.target, options.mission.roots);
-            postWork = await options.vela.inspect(paths.landing, options.mission.frontier, strictBaseline(options.mission));
-            assertWorkBinding(options.mission, work, postWork);
-            workBriefing = work.value;
-            await activity.append("work.claimed", {
-                target: options.mission.target,
-                roots: postWork.roots,
-            });
-        }
+        // A Run is nonmutating. The rooted offer is the complete bounded briefing;
+        // a durable Vela Attempt begins only through an explicit Vela workflow.
+        const workBriefing = offer.value;
+        await activity.append("work.skipped", {
+            target: options.mission.target,
+            mode: "no_submit",
+            reason: "Canopus run is nonmutating by contract",
+        });
         await activity.append("engine.started", {
             engine: options.engine.name,
             role: options.mission.role,
@@ -279,7 +125,7 @@ export async function runCanopus(options) {
         });
         if (engine.draft.status !== "success") {
             phase = "engine_non_success";
-            throw new Error(`worker returned ${engine.draft.status}; verifier and landing were not run`);
+            throw new Error(`worker returned ${engine.draft.status}; verifier and export were not run`);
         }
         await materializeDraftArtifacts({
             draft: engine.draft,
@@ -333,7 +179,7 @@ export async function runCanopus(options) {
         });
         if (verifier.status !== "passed") {
             phase = "verifier_non_success";
-            throw new Error(`verifier returned ${verifier.status}; candidate and landing were not advanced`);
+            throw new Error(`verifier returned ${verifier.status}; no Submission can be exported`);
         }
         const candidate = finalizeCandidate({
             mission: options.mission,
@@ -348,7 +194,7 @@ export async function runCanopus(options) {
             candidate_digest: candidateDigest,
             status: candidate.status,
         });
-        if (options.noLand === true) {
+        {
             phase = "clean_clone_reproduction";
             const reproductionRoot = `${paths.root}-reproduce`;
             const reproductionPaths = await prepareWorkspace({
@@ -359,7 +205,7 @@ export async function runCanopus(options) {
             });
             let reproductionVerifier;
             try {
-                await options.vela.assertRoots(reproductionPaths.input, options.mission.frontier, options.mission.roots, strictBaseline(options.mission));
+                await options.vela.assertRoots(reproductionPaths.input, options.mission.frontier, options.mission.roots);
                 reproductionVerifier = await runVerifier({
                     mission: options.mission,
                     paths: reproductionPaths,
@@ -376,13 +222,18 @@ export async function runCanopus(options) {
             const reproduced = reproductionVerifier.status === verifier.status &&
                 reproductionVerifier.record.stdout_digest === verifier.record.stdout_digest &&
                 reproductionVerifier.record.stderr_digest === verifier.record.stderr_digest;
-            if (!reproduced)
-                throw new Error("clean-clone diagnostic verifier replay did not match");
+            if (!reproduced) {
+                throw new Error(`clean-clone verifier replay did not match: initial=${verifier.status}/` +
+                    `${verifier.record.exit_code}/${verifier.record.stdout_digest}/${verifier.record.stderr_digest}, reproduced=` +
+                    `${reproductionVerifier.status}/${reproductionVerifier.record.exit_code}/` +
+                    `${reproductionVerifier.record.stdout_digest}/` +
+                    `${reproductionVerifier.record.stderr_digest}`);
+            }
             const record = {
-                schema: "canopus.diagnostic-run.v1",
+                schema: "canopus.run.v2",
                 run_id: runId,
                 status: "completed",
-                mode: "no_land",
+                effect: "none",
                 authority: "non_authoritative",
                 external_gate_credit: false,
                 mission: {
@@ -403,7 +254,7 @@ export async function runCanopus(options) {
                     sandbox: verifier.sandbox,
                     record: verifier.record,
                 },
-                landing: null,
+                submission: null,
                 reproduction: {
                     matched: true,
                     roots: options.mission.roots,
@@ -414,13 +265,13 @@ export async function runCanopus(options) {
                 budget: budget.snapshot(),
             };
             const projection = {
-                schema: "canopus.diagnostic-projection.v1",
+                schema: "canopus.run-projection.v2",
                 authority: "read_only_projection",
                 run_id: runId,
                 target: options.mission.target,
                 candidate_digest: candidateDigest,
                 verifier_status: verifier.status,
-                landed: false,
+                submitted: false,
                 clean_clone_reproduced: true,
             };
             await rm(paths.velaHome, { recursive: true, force: true });
@@ -428,254 +279,25 @@ export async function runCanopus(options) {
             await writeExclusive(path.join(paths.root, "projection.json"), projection);
             await writeExclusive(path.join(paths.root, "run.json"), record);
             await activity.append("run.completed", {
-                mode: "no_land",
+                effect: "none",
                 candidate_digest: candidateDigest,
             });
             return { record, projection, paths };
         }
-        if (postWork === undefined) {
-            throw new Error("landing run omitted the required Vela work lease");
-        }
-        const preLand = await options.vela.assertRoots(paths.landing, options.mission.frontier, postWork.roots, strictBaseline(options.mission));
-        // Verify the complete Vela state before placing candidate artifacts. The
-        // artifact files intentionally make vela.lock stale until `vela land`
-        // admits them transactionally, so a strict check between installation and
-        // the porcelain command would reject the ordinary authored-receipt flow.
-        await installFrozenArtifacts({
-            landingRepo: paths.landing,
-            frontier: options.mission.frontier,
-            frozen,
-            maxBytes: options.mission.budgets.max_artifact_bytes,
-        });
-        const artifactPublication = await publishArtifactSources({
-            repoRoot: paths.landing,
-            frontier: options.mission.frontier,
-            artifacts: candidate.artifacts,
-            home: paths.velaHome,
-        });
-        await activity.append("artifacts.published", {
-            authority: "non_authoritative_git_publication",
-            ...artifactPublication,
-        });
-        const receipt = mapCandidateToReceipt(options.mission, candidate, verifier, options.mission.target);
-        await activity.append("receipt.mapped", {
-            candidate_digest: candidateDigest,
-            evidence: receipt.evidence,
-            counterevidence: receipt.counterevidence,
-        });
-        phase = "landing_command";
-        landingCommand = await options.vela.landAuthoredCommand(options.mission, paths.landing, receipt, preLand.roots);
-        await writeExclusive(path.join(paths.root, "landing-command.json"), {
-            schema: "canopus.landing-command.v0",
-            authority: "observed_process_effect",
-            ...landingCommand,
-        });
-        rawLanding = options.vela.parseLandCommand(landingCommand);
-        const rawLandingDigest = contentDigest(rawLanding);
-        await writeExclusive(path.join(paths.root, "landing-observation.json"), {
-            schema: "canopus.landing-observation.v0",
-            authority: "observed_vela_effect",
-            raw_digest: rawLandingDigest,
-            raw: rawLanding,
-        });
-        await activity.append("landing.observed", {
-            raw_digest: rawLandingDigest,
-            observation: "landing-observation.json",
-        });
-        phase = "landing_validation";
-        const landing = options.vela.validateLandResult(options.mission, rawLanding);
-        parsedLanding = landing;
-        phase = "receipt_binding";
-        await options.vela.verifyReceiptBinding(options.mission, paths.landing, landing, receipt, candidate.artifacts);
-        await activity.append("landing.bound", {
-            receipt_root: landing.receiptRoot,
-            raw_digest: rawLandingDigest,
-        });
-        await activity.append("landing.completed", {
-            receipt_root: landing.receiptRoot,
-            proposal_id: landing.proposalId,
-            route: landing.route,
-            original_route: landing.originalRoute,
-            accepted_event_delta: landing.acceptedEventDelta,
-            publication_state: publicationState(landing),
-        });
-        const final = await options.vela.inspect(paths.landing, options.mission.frontier, strictBaseline(options.mission));
-        phase = "clean_clone_reproduction";
-        const reproductionRoot = `${paths.root}-reproduce`;
-        const reproductionPaths = await prepareWorkspace({
-            sourceRepo: paths.landing,
-            runRoot: reproductionRoot,
-            gitCommit: final.roots.git_commit,
-            gitTree: final.roots.git_tree,
-        });
-        let reproductionVerifier;
-        let reproductionInspection;
-        try {
-            reproductionInspection = await options.vela.assertRoots(reproductionPaths.input, options.mission.frontier, final.roots, strictBaseline(options.mission));
-            await options.vela.verifyReceiptBinding(options.mission, reproductionPaths.input, landing, receipt, candidate.artifacts);
-            const reproducedArtifacts = candidate.artifacts.map((artifact) => ({
-                artifact,
-                frozenPath: retainedArtifactPath(reproductionPaths.input, options.mission.frontier, artifact.digest),
-            }));
-            reproductionVerifier = await runVerifier({
-                mission: options.mission,
-                paths: reproductionPaths,
-                artifacts: reproducedArtifacts,
-                budget,
-                ...(options.bundleRoot === undefined ? {} : { bundleRoot: options.bundleRoot }),
-                ...(options.dockerBinary === undefined ? {} : { dockerBinary: options.dockerBinary }),
-                ...(options.verifierRunner === undefined ? {} : { runner: options.verifierRunner }),
-            });
-        }
-        finally {
-            await cleanupWorkspace(reproductionPaths);
-        }
-        const reproduced = sameRoots(reproductionInspection.roots, final.roots) &&
-            reproductionVerifier.status === verifier.status &&
-            reproductionVerifier.record.stdout_digest === verifier.record.stdout_digest &&
-            reproductionVerifier.record.stderr_digest === verifier.record.stderr_digest;
-        if (!reproduced) {
-            throw new Error("clean-clone reproduction did not match the landed run");
-        }
-        await activity.append("reproduction.completed", {
-            matched: true,
-            roots: reproductionInspection.roots,
-            verifier_status: reproductionVerifier.status,
-        });
-        if (options.retainWithdrawalCapability !== undefined) {
-            phase = "withdrawal_capability";
-            await options.retainWithdrawalCapability({
-                velaHome: paths.velaHome,
-                landingRepo: paths.landing,
-                mission: options.mission,
-                landing,
-                finalRoots: final.roots,
-            });
-            await activity.append("withdrawal_capability.retained", {
-                proposal_id: landing.proposalId,
-                authority: "producer_withdrawal_only",
-            });
-        }
-        await rm(paths.velaHome, { recursive: true, force: true });
-        const record = {
-            schema: RUN_RECORD_SCHEMA,
-            run_id: runId,
-            status: "completed",
-            authority: "non_authoritative",
-            external_gate_credit: false,
-            mission: {
-                id: options.mission.id,
-                target: options.mission.target,
-                digest: contentDigest(options.mission),
-                starting_roots: options.mission.roots,
-            },
-            candidate: {
-                digest: candidateDigest,
-                status: candidate.status,
-                claim: candidate.claim,
-                artifacts: candidate.artifacts,
-                caveats: candidate.caveats,
-            },
-            observations: {
-                worker_observations: candidate.observations,
-                verifier_observations: [
-                    `Frozen verifier passed in ${verifier.sandbox}.`,
-                    `Verifier stdout ${verifier.record.stdout_digest}; stderr ${verifier.record.stderr_digest}.`,
-                ],
-                standing_caveats: candidate.caveats,
-            },
-            verifier: {
-                status: verifier.status,
-                sandbox: verifier.sandbox,
-                record: verifier.record,
-            },
-            landing: {
-                operation_id: landing.operationId,
-                receipt_root: landing.receiptRoot,
-                proposal_id: landing.proposalId,
-                route: landing.route,
-                original_route: landing.originalRoute,
-                accepted_event_delta: landing.acceptedEventDelta,
-                publication_state: publicationState(landing),
-            },
-            final_roots: final.roots,
-            reproduction: {
-                matched: reproduced,
-                roots: reproductionInspection.roots,
-                verifier_status: reproductionVerifier.status,
-                stdout_digest: reproductionVerifier.record.stdout_digest,
-                stderr_digest: reproductionVerifier.record.stderr_digest,
-            },
-            budget: budget.snapshot(),
-        };
-        const projection = projectRun(record);
-        phase = "record_finalization";
-        await writeExclusive(path.join(paths.root, "candidate.json"), candidate);
-        await writeExclusive(path.join(paths.root, "projection.json"), projection);
-        await writeExclusive(path.join(paths.root, "run.json"), record);
-        await activity.append("projection.written", {
-            candidate_digest: candidateDigest,
-            run_digest: contentDigest(record),
-            projection_digest: contentDigest(projection),
-        });
-        await activity.append("run.completed", {
-            receipt_root: landing.receiptRoot,
-            candidate_digest: candidateDigest,
-        });
-        return { record, projection, paths };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        let recovery;
-        if (phase.startsWith("landing_") ||
-            phase === "receipt_binding" ||
-            phase === "clean_clone_reproduction" ||
-            phase === "withdrawal_capability" ||
-            phase === "record_finalization") {
-            let observedRoots = null;
-            let inspectionError = null;
-            try {
-                observedRoots = (await options.vela.inspect(paths.landing, options.mission.frontier, strictBaseline(options.mission))).roots;
-            }
-            catch (inspectionFailure) {
-                inspectionError =
-                    inspectionFailure instanceof Error ? inspectionFailure.message : String(inspectionFailure);
-            }
-            recovery = {
-                schema: "canopus.landing-recovery.v0",
-                authority: "observed_vela_effect",
-                phase,
-                command: landingCommand ?? null,
-                raw_digest: rawLanding === undefined ? null : contentDigest(rawLanding),
-                raw: rawLanding ?? null,
-                parsed: parsedLanding === undefined
-                    ? null
-                    : {
-                        operation_id: parsedLanding.operationId,
-                        receipt_root: parsedLanding.receiptRoot,
-                        proposal_id: parsedLanding.proposalId,
-                        route: parsedLanding.route,
-                        original_route: parsedLanding.originalRoute,
-                        accepted_event_delta: parsedLanding.acceptedEventDelta,
-                        publication: parsedLanding.publication,
-                    },
-                observed_roots: observedRoots,
-                inspection_error: inspectionError,
-            };
-            await writeExclusive(path.join(paths.root, "landing-recovery.json"), recovery).catch(() => undefined);
-        }
         await activity.append("run.failed", {
             error: message,
             phase,
-            landing_observed: landingCommand !== undefined,
+            effect: "none",
         }).catch(() => undefined);
         await writeExclusive(path.join(paths.root, "failure.json"), {
-            schema: "canopus.failure.v0",
+            schema: "canopus.failure.v1",
             run_id: runId,
             error: message,
             phase,
-            landing_observed: landingCommand !== undefined,
-            landing_recovery: recovery === undefined ? null : "landing-recovery.json",
+            effect: "none",
             activity_tip: activity.tip,
             authority: "non_authoritative",
         }).catch(() => undefined);

package/dist/src/util/canonical.d.ts

@@ -1,5 +1 @@
-export declare function canonicalJson(value: unknown): string;
-export declare function canonicalJcs(value: unknown): string;
-export declare function sha256Bytes(value: Uint8Array | string): string;
-export declare function contentDigest(value: unknown): string;
-export declare function protocolDigest(value: unknown): string;
+export { canonicalJcs, canonicalJson, contentDigest, protocolDigest, sha256Bytes, } from "@vela-science/protocol";

package/dist/src/util/canonical.js

@@ -1,53 +1 @@
-import { createHash } from "node:crypto";
-function normalize(value, at) {
-    if (value === null ||
-        typeof value === "string" ||
-        typeof value === "boolean") {
-        return value;
-    }
-    if (typeof value === "number") {
-        if (!Number.isFinite(value)) {
-            throw new TypeError(`${at} contains a non-finite number`);
-        }
-        return value;
-    }
-    if (Array.isArray(value)) {
-        return value.map((item, index) => normalize(item, `${at}[${index}]`));
-    }
-    if (typeof value === "object") {
-        const prototype = Object.getPrototypeOf(value);
-        if (prototype !== Object.prototype && prototype !== null) {
-            throw new TypeError(`${at} must contain plain JSON objects`);
-        }
-        const input = value;
-        const output = {};
-        for (const key of Object.keys(input).sort()) {
-            const item = input[key];
-            if (item === undefined) {
-                throw new TypeError(`${at}.${key} is undefined`);
-            }
-            output[key] = normalize(item, `${at}.${key}`);
-        }
-        return output;
-    }
-    throw new TypeError(`${at} contains a non-JSON value`);
-}
-export function canonicalJson(value) {
-    return `${JSON.stringify(normalize(value, "$"))}\n`;
-}
-// RFC 8785 uses ECMAScript JSON serialization over recursively sorted object
-// keys and does not append a record newline. Vela Receipt v1 uses these bytes.
-export function canonicalJcs(value) {
-    return JSON.stringify(normalize(value, "$"));
-}
-export function sha256Bytes(value) {
-    return `sha256:${createHash("sha256").update(value).digest("hex")}`;
-}
-export function contentDigest(value) {
-    return sha256Bytes(canonicalJson(value));
-}
-// Vela protocol objects use compact canonical JSON bytes, without the record
-// newline used by Canopus-owned manifests and activity records.
-export function protocolDigest(value) {
-    return sha256Bytes(canonicalJcs(value));
-}
+export { canonicalJcs, canonicalJson, contentDigest, protocolDigest, sha256Bytes, } from "@vela-science/protocol";