@vela-science/canopus 0.7.0 → 0.8.0

package/dist/src/cli.js

@@ -3,45 +3,37 @@ import os from "node:os";
 import path from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
-import { mkdir, mkdtemp, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { readdir, stat } from "node:fs/promises";
 import { parseMission } from "./contracts/mission.js";
-import { CodexExecEngine } from "./engines/codex-exec.js";
-import { CodexToolsNativeEngine } from "./engines/codex-tools-native.js";
 import { prepareMission, validateMissionBundle } from "./mission/prepare.js";
-import { parseDiagnosticRunRecord, projectDiagnosticRun } from "./projection/diagnostic.js";
+import { projectCurrentRun } from "./projection/current-run.js";
+import { parseRetainedRunRecord } from "./projection/retained-run.js";
 import { parseFailureRecord, projectFailure } from "./projection/failure.js";
-import { parseRunRecord, projectRun } from "./projection/run.js";
-import { projectPublicRun } from "./projection/public-run.js";
-import { buildPublicationBundle } from "./projection/publication.js";
 import { doctorProduct } from "./product/doctor.js";
 import { replayProduct } from "./product/replay.js";
 import { runProduct } from "./product/run.js";
+import { exportSubmission } from "./product/submission.js";
+import { submitBundle } from "./product/submit.js";
 import { CANOPUS_VERSION } from "./product/version.js";
 import { listProductProfiles, packProductProfile, validateProductProfile, } from "./product/profile-bundle.js";
 import { loadProductProfile } from "./product/profile.js";
-import { runCanopus } from "./run.js";
 import { readBoundedRegularFile } from "./util/files.js";
-import { canonicalJson, contentDigest } from "./util/canonical.js";
-import { VelaClient } from "./vela/cli.js";
 function usage() {
     return `Canopus — bounded Vela research harness
 
 Primary workflow:
-  canopus --version
   canopus doctor [frontier] [--profile <name>]
-  canopus run [frontier] [--first | --target <id>] [--profile <name>] \\
-    [--output <dir>] [--no-land]
-  canopus inspect [run.json | latest]
-  canopus public-run <run.json> --mission <mission.json> \
-    --repository <public-url> --output <file>
-  canopus publish-run <run.json> --mission <mission.json> \
-    --repository <public-url> --output <new-directory>
+  canopus run [frontier] [--first | --target <id>] [--profile <name>] [--output <dir>]
+  canopus show [run.json | failure.json | latest]
   canopus replay <run.json>
+  canopus export <run.json | latest> [--output <new-directory>] [--as <agent:id>] \\
+    [--claim <corrected-bounded-claim> --scope-limit <limit>]
+  canopus submit <submission-bundle> [frontier] [--vela <binary>]
 
 Mission v1 prepare/validate remains available under advanced help.
 
-Canopus may land a Receipt v1 as an agent after verifier success. It cannot
-sign, accept, or make a human scientific decision.`;
+Run and export never mutate Vela. submit explicitly registers an authenticated
+Submission as pending review. Canopus cannot verify, decide, or change Standing.`;
 }
 function missionUsage() {
     return `Usage:
@@ -66,19 +58,19 @@ remain replay-only; new tool-using missions require a validated version 2 profil
 function runUsage() {
     return `Usage:
   canopus run [frontier] [--first | --target <id>] [--profile <name>] \\
-    [--output <dir>] [--no-land]
+    [--output <dir>]
 
 Discovers and binds Vela, Codex, Git, Docker, the exact frontier roots, and the
-registered verifier profile. --no-land runs the worker and verifier in disposable
-clones and leaves the source frontier unchanged.`;
+registered verifier profile. Runs the worker and verifier in disposable clones
+and always leaves the source frontier unchanged.`;
 }
-function inspectUsage() {
+function showUsage() {
     return `Usage:
-  canopus inspect [run.json | failure.json | latest]
+  canopus show [run.json | failure.json | latest]
 
-Projects the newest completed or safely stopped non-authoritative run record
-without mutating Vela. A failed run never implies that landing was unchanged;
-inspect reports whether retained landing-recovery evidence is required.`;
+Shows the newest completed or safely stopped non-authoritative Run without
+mutating Vela. Historical formats remain readable through their exact Canopus
+release; the current product accepts only Run v2 and failure records.`;
 }
 function doctorUsage() {
     return `Usage:
@@ -95,23 +87,23 @@ function replayUsage() {
 Re-runs the frozen verifier over the content-addressed candidate without a
 model call, Vela mutation, network, or authority action.`;
 }
-function publicRunUsage() {
+function exportUsage() {
     return `Usage:
-  canopus public-run <run.json> --mission <mission.json> \\
-    --repository <public-url> --output <file>
+  canopus export <run.json | latest> [--output <new-directory>] [--as <agent:id>] \\
+    [--claim <corrected-bounded-claim> --scope-limit <limit>]
 
-Generates one canonical, sanitized canopus.public-run.v1 projection from a
-submission-ready completed run. Raw worker logs, homes, credentials, private
-paths, and unrestricted transcripts are never copied.`;
+Creates a signed portable vela.submission.v1 bundle from a successful Run.
+Export does not touch a frontier and does not create Verification or Standing.
+The correction pair is accepted only when the retained Run Claim has stale
+verifier wording or control bytes; the immutable Run remains unchanged.`;
 }
-function publishRunUsage() {
+function submitUsage() {
     return `Usage:
-  canopus publish-run <run.json> --mission <mission.json> \\
-    --repository <public-url> --output <new-directory>
+  canopus submit <submission-bundle> [frontier] [--vela <binary>]
 
-Creates a sanitized public projection, root manifest, proposal-scoped pending
-commands, and a read-only Vela Observatory import descriptor. It never lands,
-signs, accepts, pushes, or deploys.`;
+Explicitly registers one authenticated Submission through Vela in a disposable
+exact-head clone, then fast-forwards the clean source checkout. The result is
+pending review with zero accepted-event delta.`;
 }
 function isHelp(value) {
     return value === "--help" || value === "-h" || value === "help";
@@ -168,9 +160,6 @@ function required(values, key) {
         throw new Error(`${key} is required`);
     return value;
 }
-function authHome(values) {
-    return path.resolve(values.get("--codex-home") ?? process.env.CODEX_HOME ?? path.join(os.homedir(), ".codex"));
-}
 function packagedOutputSchema() {
     return fileURLToPath(new URL("../../schemas/engine-output.v0.json", import.meta.url));
 }
@@ -274,67 +263,6 @@ async function profileCommand(args) {
     }
     throw new Error(`unknown profile command ${subcommand}`);
 }
-async function runMission(file, rest) {
-    const values = options(rest, [
-        "--source",
-        "--run-root",
-        "--vela",
-        "--docker",
-        "--codex",
-        "--codex-version",
-        "--codex-sha256",
-        "--model",
-        "--codex-home",
-    ]);
-    const mission = parseMission(await jsonFile(file));
-    const sourceRepo = path.resolve(required(values, "--source"));
-    const runRoot = path.resolve(required(values, "--run-root"));
-    const velaBinary = path.resolve(required(values, "--vela"));
-    const outputSchema = mission.schema === "canopus.mission.v1"
-        ? path.join(path.dirname(path.resolve(file)), "contract", "engine-output.v0.json")
-        : packagedOutputSchema();
-    const vela = new VelaClient({
-        binary: velaBinary,
-        expectedVersion: mission.vela_version,
-        expectedSha256: mission.vela_sha256,
-        home: path.join(runRoot, "vela-home"),
-    });
-    const engine = mission.schema === "canopus.mission.v1"
-        ? new CodexToolsNativeEngine({
-            binary: path.resolve(required(values, "--codex")),
-            authHome: authHome(values),
-            outputSchema,
-            permissionProfile: path.join(path.dirname(path.resolve(file)), mission.worker.permission_profile_path),
-        })
-        : new CodexExecEngine({
-            binary: path.resolve(required(values, "--codex")),
-            expectedSha256: required(values, "--codex-sha256"),
-            expectedVersion: required(values, "--codex-version"),
-            model: required(values, "--model"),
-            authHome: authHome(values),
-            outputSchema,
-        });
-    const result = await runCanopus({
-        mission,
-        sourceRepo,
-        runRoot,
-        vela,
-        engine,
-        bundleRoot: path.dirname(path.resolve(file)),
-        dockerBinary: values.get("--docker") ?? "docker",
-    });
-    process.stdout.write(`${JSON.stringify({
-        ok: true,
-        command: "run",
-        run_id: result.record.run_id,
-        candidate_digest: result.record.candidate.digest,
-        receipt_root: result.record.landing.receipt_root,
-        route: result.record.landing.route,
-        accepted_event_delta: result.record.landing.accepted_event_delta,
-        clean_clone_reproduced: result.record.reproduction.matched,
-        run_file: path.join(result.paths.root, "run.json"),
-    })}\n`);
-}
 async function doctorCommand(args) {
     const parsed = productOptions(args, ["--profile"], []);
     if (parsed.positional.length > 1)
@@ -347,7 +275,7 @@ async function doctorCommand(args) {
     process.stdout.write(`${JSON.stringify(result.public)}\n`);
 }
 async function productRunCommand(args) {
-    const parsed = productOptions(args, ["--target", "--profile", "--output", "--codex-home"], ["--first", "--no-land"]);
+    const parsed = productOptions(args, ["--target", "--profile", "--output", "--codex-home"], ["--first"]);
     if (parsed.positional.length > 1)
         throw new Error("run accepts at most one frontier");
     if (parsed.flags.has("--first") && parsed.values.has("--target")) {
@@ -364,25 +292,20 @@ async function productRunCommand(args) {
         ...(requested === undefined ? {} : { requestedTarget: requested }),
         ...(outputRoot === undefined ? {} : { outputRoot: path.resolve(outputRoot) }),
         ...(codexHome === undefined ? {} : { codexHome: path.resolve(codexHome) }),
-        noLand: parsed.flags.has("--no-land"),
     });
-    const landing = result.run.record.landing;
     process.stdout.write(`${JSON.stringify({
         ok: true,
         command: "run",
-        mode: landing === null ? "no_land" : "land",
+        effect: "none",
         run_id: result.run.record.run_id,
         target: result.run.record.mission.target,
         candidate_digest: result.run.record.candidate.digest,
         verifier_status: result.run.record.verifier.status,
         observed_tokens: result.run.record.budget.observed_tokens,
-        receipt_root: landing?.receipt_root ?? null,
-        proposal_id: landing?.proposal_id ?? null,
-        route: landing?.route ?? null,
-        accepted_event_delta: landing?.accepted_event_delta ?? null,
+        submission: null,
         clean_clone_reproduced: result.run.record.reproduction.matched,
         evidence_root: result.evidence_root,
-        source_publication: result.source_publication,
+        source_state: result.source_state,
         run_file: path.join(result.run.paths.root, "run.json"),
     })}\n`);
 }
@@ -419,9 +342,9 @@ async function latestInspectionFile() {
     ranked.sort((left, right) => right.modified - left.modified || left.file.localeCompare(right.file));
     return ranked[0]?.file ?? (() => { throw new Error("no inspectable Canopus product run was found"); })();
 }
-async function inspectCommand(value, rest) {
+async function showCommand(value, rest) {
     if (rest.length !== 0)
-        throw new Error("inspect accepts at most one run file");
+        throw new Error("show accepts at most one run file");
     const file = value === undefined || value === "latest"
         ? await latestInspectionFile()
         : path.resolve(value);
@@ -429,76 +352,52 @@ async function inspectCommand(value, rest) {
     const schema = typeof raw === "object" && raw !== null && !Array.isArray(raw)
         ? raw.schema
         : undefined;
-    const projection = schema === "canopus.diagnostic-run.v1"
-        ? projectDiagnosticRun(parseDiagnosticRunRecord(raw))
-        : schema === "canopus.failure.v0"
+    const projection = schema === "canopus.run.v2"
+        ? projectCurrentRun(parseRetainedRunRecord(raw).record)
+        : schema === "canopus.failure.v0" || schema === "canopus.failure.v1"
             ? projectFailure(parseFailureRecord(raw))
-            : projectRun(parseRunRecord(raw));
-    process.stdout.write(`${JSON.stringify({ ok: true, command: "inspect", run_file: file, projection })}\n`);
+            : (() => {
+                throw new Error("current Canopus accepts only canopus.run.v2 and retained failure records; use the exact historical release for older Run schemas");
+            })();
+    process.stdout.write(`${JSON.stringify({ ok: true, command: "show", run_file: file, projection })}\n`);
 }
 async function replayCommand(file, rest) {
     if (file === undefined || rest.length !== 0)
         throw new Error("replay requires exactly one run file");
     process.stdout.write(`${JSON.stringify(await replayProduct(path.resolve(file)))}\n`);
 }
-async function publicRunCommand(file, rest) {
+async function exportCommand(file, rest) {
     if (file === undefined)
-        throw new Error("public-run requires one completed run file");
-    const values = options(rest, ["--mission", "--repository", "--output"]);
-    const record = parseRunRecord(await jsonFile(file));
-    const mission = parseMission(await jsonFile(required(values, "--mission")));
-    const projection = projectPublicRun({
-        record,
-        mission,
-        repository: required(values, "--repository"),
-    });
-    const output = path.resolve(required(values, "--output"));
-    await writeFile(output, canonicalJson(projection), { flag: "wx", mode: 0o644 });
-    process.stdout.write(`${JSON.stringify({
-        ok: true,
-        command: "public-run",
-        run_id: projection.run_id,
-        output,
-        projection_root: contentDigest(projection),
-    })}\n`);
+        throw new Error("export requires a Run file or latest");
+    const parsed = productOptions(rest, ["--output", "--as", "--claim", "--scope-limit"], []);
+    if (parsed.positional.length !== 0)
+        throw new Error("export accepts one Run file");
+    const runFile = file === "latest" ? await latestRunFile() : path.resolve(file);
+    const output = parsed.values.get("--output") ??
+        path.join(path.dirname(path.dirname(runFile)), `submission-${Date.now()}`);
+    const actor = parsed.values.get("--as");
+    const correctedClaim = parsed.values.get("--claim");
+    const scopeLimit = parsed.values.get("--scope-limit");
+    process.stdout.write(`${JSON.stringify(await exportSubmission({
+        runFile,
+        outputRoot: path.resolve(output),
+        ...(actor === undefined ? {} : { actor }),
+        ...(correctedClaim === undefined ? {} : { correctedClaim }),
+        ...(scopeLimit === undefined ? {} : { scopeLimit }),
+    }))}\n`);
 }
-async function publishRunCommand(file, rest) {
-    if (file === undefined)
-        throw new Error("publish-run requires one completed run file");
-    const values = options(rest, ["--mission", "--repository", "--output"]);
-    const record = parseRunRecord(await jsonFile(file));
-    const mission = parseMission(await jsonFile(required(values, "--mission")));
-    const bundle = buildPublicationBundle({
-        record,
-        mission,
-        repository: required(values, "--repository"),
-    });
-    const output = path.resolve(required(values, "--output"));
-    const parent = path.dirname(output);
-    await mkdir(parent, { recursive: true, mode: 0o755 });
-    const temporary = await mkdtemp(path.join(parent, `.${path.basename(output)}.tmp-`));
-    try {
-        await Promise.all([
-            writeFile(path.join(temporary, "public-run.json"), canonicalJson(bundle.projection), { flag: "wx", mode: 0o644 }),
-            writeFile(path.join(temporary, "pending-commands.json"), canonicalJson(bundle.pendingCommands), { flag: "wx", mode: 0o644 }),
-            writeFile(path.join(temporary, "web-import.json"), canonicalJson(bundle.webImport), { flag: "wx", mode: 0o644 }),
-            writeFile(path.join(temporary, "root-manifest.json"), canonicalJson(bundle.manifest), { flag: "wx", mode: 0o644 }),
-        ]);
-        await rename(temporary, output);
-    }
-    catch (error) {
-        await rm(temporary, { recursive: true, force: true });
-        throw error;
-    }
-    process.stdout.write(`${JSON.stringify({
-        ok: true,
-        command: "publish-run",
-        run_id: bundle.projection.run_id,
-        output,
-        projection_root: contentDigest(bundle.projection),
-        bundle_root: contentDigest(bundle.manifest),
-        authority_effect: "none",
-    })}\n`);
+async function submitCommand(bundle, rest) {
+    if (bundle === undefined)
+        throw new Error("submit requires a Submission bundle");
+    const parsed = productOptions(rest, ["--vela"], []);
+    if (parsed.positional.length > 1)
+        throw new Error("submit accepts at most one frontier");
+    const velaBinary = parsed.values.get("--vela");
+    process.stdout.write(`${JSON.stringify(await submitBundle({
+        bundle: path.resolve(bundle),
+        frontier: path.resolve(parsed.positional[0] ?? "."),
+        ...(velaBinary === undefined ? {} : { velaBinary }),
+    }))}\n`);
 }
 async function main(argv) {
     const [command, file, ...rest] = argv;
@@ -522,11 +421,11 @@ async function main(argv) {
     }
     if (isHelp(file)) {
         process.stdout.write(`${command === "run" ? runUsage()
-            : command === "inspect" ? inspectUsage()
+            : command === "show" ? showUsage()
                 : command === "doctor" ? doctorUsage()
                     : command === "replay" ? replayUsage()
-                        : command === "public-run" ? publicRunUsage()
-                            : command === "publish-run" ? publishRunUsage()
+                        : command === "export" ? exportUsage()
+                            : command === "submit" ? submitUsage()
                                 : usage()}\n`);
         return;
     }
@@ -538,31 +437,26 @@ async function main(argv) {
         await replayCommand(file, rest);
         return;
     }
-    if (command === "public-run") {
-        await publicRunCommand(file, rest);
-        return;
-    }
-    if (command === "publish-run") {
-        await publishRunCommand(file, rest);
-        return;
-    }
     if (command === "validate") {
         if (file === undefined)
             throw new Error("validate requires a mission file");
         await missionCommand(["validate", file, ...rest]);
         return;
     }
-    if (command === "inspect") {
-        await inspectCommand(file, rest);
+    if (command === "show") {
+        await showCommand(file, rest);
         return;
     }
     if (command === "run") {
-        if (file !== undefined && (file.endsWith(".json") || rest.includes("--source"))) {
-            await runMission(file, rest);
-        }
-        else {
-            await productRunCommand(argv.slice(1));
-        }
+        await productRunCommand(argv.slice(1));
+        return;
+    }
+    if (command === "export") {
+        await exportCommand(file, rest);
+        return;
+    }
+    if (command === "submit") {
+        await submitCommand(file, rest);
         return;
     }
     throw new Error(`unknown command ${command}`);

package/dist/src/contracts/mission.d.ts

@@ -13,8 +13,7 @@ export type Replayability = (typeof REPLAYABILITY)[number];
 export interface MissionRoots {
     git_commit: string;
     git_tree: string;
-    vela_event_log: string;
-    vela_snapshot: string;
+    vela_repository: string;
 }
 export interface MissionBudgets {
     max_research_wall_time_ms: number;
@@ -61,16 +60,6 @@ export interface ProducerProfileSpec {
     name: string;
     root: string;
 }
-export interface StrictRuleCount {
-    rule: string;
-    count: number;
-}
-export interface StrictBaseline {
-    status: "pass" | "fail";
-    blocker_count: number;
-    blockers_root: string;
-    rule_counts: StrictRuleCount[];
-}
 export interface LandingSpec {
     expected_routes: LandRoute[];
     max_accepted_delta: number;
@@ -127,7 +116,6 @@ export interface MissionV1 extends MissionBase {
     schema: typeof MISSION_V1_SCHEMA;
     target_packet: TargetPacketSpec;
     profile?: ProducerProfileSpec;
-    strict_baseline: StrictBaseline;
     worker: WorkerSpec;
     verifier: ContainerVerifierSpec;
     execution_binding?: ExecutionBindingV1;

package/dist/src/contracts/mission.js

@@ -24,12 +24,11 @@ export const REPLAYABILITY = [
 ];
 function parseRoots(value) {
     const object = objectAt(value, "mission.roots");
-    exactKeys(object, ["git_commit", "git_tree", "vela_event_log", "vela_snapshot"], [], "mission.roots");
+    exactKeys(object, ["git_commit", "git_tree", "vela_repository"], [], "mission.roots");
     return {
         git_commit: gitObjectAt(object.git_commit, "mission.roots.git_commit"),
         git_tree: gitObjectAt(object.git_tree, "mission.roots.git_tree"),
-        vela_event_log: sha256At(object.vela_event_log, "mission.roots.vela_event_log"),
-        vela_snapshot: sha256At(object.vela_snapshot, "mission.roots.vela_snapshot"),
+        vela_repository: sha256At(object.vela_repository, "mission.roots.vela_repository"),
     };
 }
 function frontierPathAt(value) {
@@ -118,41 +117,6 @@ function parseTargetPacket(value) {
         sha256: sha256At(object.sha256, "mission.target_packet.sha256"),
     };
 }
-function parseStrictBaseline(value) {
-    const object = objectAt(value, "mission.strict_baseline");
-    exactKeys(object, ["status", "blocker_count", "blockers_root", "rule_counts"], [], "mission.strict_baseline");
-    const rule_counts = arrayAt(object.rule_counts, "mission.strict_baseline.rule_counts", { min: 0, max: 64 }, (item, at) => {
-        const entry = objectAt(item, at);
-        exactKeys(entry, ["rule", "count"], [], at);
-        return {
-            rule: stringAt(entry.rule, `${at}.rule`, {
-                min: 1,
-                max: 128,
-                pattern: /^[a-z][a-z0-9_]*$/u,
-            }),
-            count: integerAt(entry.count, `${at}.count`, 1, 1_000_000),
-        };
-    });
-    for (let index = 1; index < rule_counts.length; index += 1) {
-        if ((rule_counts[index - 1]?.rule ?? "") >= (rule_counts[index]?.rule ?? "")) {
-            throw new ContractError("mission.strict_baseline.rule_counts must be sorted and unique");
-        }
-    }
-    const blocker_count = integerAt(object.blocker_count, "mission.strict_baseline.blocker_count", 0, 1_000_000);
-    if (rule_counts.reduce((sum, entry) => sum + entry.count, 0) !== blocker_count) {
-        throw new ContractError("mission.strict_baseline.rule_counts must sum to blocker_count");
-    }
-    const status = enumAt(object.status, "mission.strict_baseline.status", ["pass", "fail"]);
-    if ((status === "pass") !== (blocker_count === 0)) {
-        throw new ContractError("mission.strict_baseline status must agree with blocker_count");
-    }
-    return {
-        status,
-        blocker_count,
-        blockers_root: sha256At(object.blockers_root, "mission.strict_baseline.blockers_root"),
-        rule_counts,
-    };
-}
 function parseLanding(value) {
     const object = objectAt(value, "mission.landing");
     exactKeys(object, ["expected_routes", "max_accepted_delta"], [], "mission.landing");
@@ -275,14 +239,13 @@ export function parseMission(value) {
             "repair_reason",
             "target_packet",
             "profile",
-            "strict_baseline",
             "worker",
             "execution_binding",
             "result_contract",
         ]
         : ["parent_candidate", "repair_reason"], "mission");
     if (isV1) {
-        for (const required of ["target_packet", "strict_baseline", "worker"]) {
+        for (const required of ["target_packet", "worker"]) {
             if (object[required] === undefined) {
                 throw new ContractError(`mission.${required} is required for mission v1`);
             }
@@ -313,7 +276,7 @@ export function parseMission(value) {
         vela_version: stringAt(object.vela_version, "mission.vela_version", {
             min: 5,
             max: 32,
-            pattern: /^0\.[0-9]+\.[0-9]+$/u,
+            pattern: /^0\.[0-9]+\.[0-9]+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/u,
         }),
         vela_sha256: sha256At(object.vela_sha256, "mission.vela_sha256"),
         frontier: frontierPathAt(object.frontier),
@@ -376,7 +339,6 @@ export function parseMission(value) {
                 schema: MISSION_V1_SCHEMA,
                 target_packet: targetPacket,
                 ...(profile === undefined ? {} : { profile }),
-                strict_baseline: parseStrictBaseline(object.strict_baseline),
                 worker: parseWorker(object.worker),
                 verifier: verifier,
                 ...(executionBinding === undefined ? {} : { execution_binding: executionBinding }),

package/dist/src/contracts/validation.d.ts

@@ -1,25 +1 @@
-export declare class ContractError extends Error {
-    constructor(message: string);
-}
-export type JsonObject = Record<string, unknown>;
-export declare function objectAt(value: unknown, at: string): JsonObject;
-export declare function exactKeys(value: JsonObject, required: readonly string[], optional: readonly string[], at: string): void;
-export declare function stringAt(value: unknown, at: string, options: {
-    min?: number;
-    max: number;
-    pattern?: RegExp;
-}): string;
-export declare function integerAt(value: unknown, at: string, min: number, max: number): number;
-export declare function enumAt<const T extends string>(value: unknown, at: string, allowed: readonly T[]): T;
-export declare function arrayAt<T>(value: unknown, at: string, options: {
-    min?: number;
-    max: number;
-    unique?: boolean;
-}, parse: (item: unknown, at: string) => T): T[];
-export declare const GIT_OBJECT_RE: RegExp;
-export declare const SHA256_RE: RegExp;
-export declare const MISSION_ID_RE: RegExp;
-export declare const AGENT_RE: RegExp;
-export declare function relativePathAt(value: unknown, at: string): string;
-export declare function sha256At(value: unknown, at: string): string;
-export declare function gitObjectAt(value: unknown, at: string): string;
+export { AGENT_RE, ContractError, GIT_OBJECT_RE, MISSION_ID_RE, SHA256_RE, arrayAt, enumAt, exactKeys, gitObjectAt, integerAt, objectAt, relativePathAt, sha256At, stringAt, type JsonObject, } from "@vela-science/protocol";