@kungfu-tech/buildchain 4.0.2 → 4.0.3

package/packages/core/{v4-delivery-warrant-read-candidate.js → delivery-warrant-read-candidate.js}

@@ -5,19 +5,19 @@ import {
   observeDevDeliveryQueue,
 } from "./dev-delivery-warrant.js";
 import {
-  v4CanonicalBytes,
-  v4ContentRoot,
-  validateV4Clock,
-  validateV4Root,
-} from "./v4-canonical-contracts.js";
-import { invokeV4RustShadowHost } from "./v4-delivery-warrant-shadow-adapter.js";
-import { V4_DELIVERY_WARRANT_SEMANTIC_DIFF_REPORT_CONTRACT } from "./v4-delivery-warrant-semantic-diff-gate.js";
+  domainCanonicalBytes,
+  domainContentRoot,
+  validateClock,
+  validateRoot,
+} from "./canonical-contracts.js";
+import { invokeRustShadowHost } from "./delivery-warrant-shadow-adapter.js";
+import { DELIVERY_WARRANT_SEMANTIC_DIFF_REPORT_CONTRACT } from "./delivery-warrant-semantic-diff-gate.js";
 
-export const V4_DELIVERY_WARRANT_READ_PROJECTION_CONTRACT =
+export const DELIVERY_WARRANT_READ_PROJECTION_CONTRACT =
   "buildchain-v4-delivery-warrant-read-projection/v1";
-export const V4_DELIVERY_WARRANT_READ_RESULT_CONTRACT =
+export const DELIVERY_WARRANT_READ_RESULT_CONTRACT =
   "buildchain-v4-delivery-warrant-read-result/v1";
-export const V4_DELIVERY_WARRANT_READ_EVIDENCE_CONTRACT =
+export const DELIVERY_WARRANT_READ_EVIDENCE_CONTRACT =
   "buildchain-v4-delivery-warrant-read-evidence/v1";
 
 const HOST_REQUEST_CONTRACT = "kungfu-buildchain-v4-host-request";
@@ -33,16 +33,16 @@ const REQUIRED_CAPABILITIES = Object.freeze([
 const REVISION = /^[0-9a-f]{40,64}$/u;
 const MAX_TIMEOUT_MS = 30_000;
 
-export class V4DeliveryWarrantReadFault extends Error {
+export class DeliveryWarrantReadFault extends Error {
   constructor(code, message) {
     super(message);
-    this.name = "V4DeliveryWarrantReadFault";
+    this.name = "DeliveryWarrantReadFault";
     this.code = code;
   }
 }
 
 function fail(code, message) {
-  throw new V4DeliveryWarrantReadFault(code, message);
+  throw new DeliveryWarrantReadFault(code, message);
 }
 
 function validateSources(actual, expected) {
@@ -61,22 +61,22 @@ function validateSources(actual, expected) {
     fail("qualification-source-drift", "qualification revisions are invalid");
 }
 
-export function validateV4DeliveryWarrantReadQualification(
+export function validateDeliveryWarrantReadQualification(
   report,
   { expectedRoot, expectedSources, observedAt },
 ) {
-  validateV4Root(expectedRoot, "$/expectedQualificationRoot");
-  validateV4Clock(observedAt, "$/observedAt");
+  validateRoot(expectedRoot, "$/expectedQualificationRoot");
+  validateClock(observedAt, "$/observedAt");
   const body = structuredClone(report || {});
   const reportedRoot = body.reportRoot;
   delete body.reportRoot;
   if (
     reportedRoot !== expectedRoot ||
-    v4ContentRoot("semantic-diff", body) !== expectedRoot
+    domainContentRoot("semantic-diff", body) !== expectedRoot
   )
     fail("qualification-root-drift", "semantic-diff report root drifted");
   if (
-    report.schema !== V4_DELIVERY_WARRANT_SEMANTIC_DIFF_REPORT_CONTRACT ||
+    report.schema !== DELIVERY_WARRANT_SEMANTIC_DIFF_REPORT_CONTRACT ||
     report.authority !== "typescript-v3" ||
     report.rustAuthority !== "none" ||
     report.rustEffects !== "disabled" ||
@@ -92,16 +92,16 @@ export function validateV4DeliveryWarrantReadQualification(
       "qualification-not-eligible",
       "semantic-diff report does not authorize a read-only candidate",
     );
-  validateV4Clock(report.retainUntil, "$/qualification/retainUntil");
+  validateClock(report.retainUntil, "$/qualification/retainUntil");
   if (Date.parse(report.retainUntil) <= Date.parse(observedAt))
     fail("qualification-expired", "semantic-diff retention window expired");
   validateSources(report.sources, expectedSources);
   return report;
 }
 
-export function projectV3QueueToV4ReadState(queueInput) {
+export function projectBaselineQueueToReadState(queueInput) {
   const queue = normalizeDevDeliveryQueue(queueInput, {
-    allowLegacyV3Readback: true,
+    allowLegacyBaselineReadback: true,
   });
   return {
     schema: STATE_CONTRACT,
@@ -137,7 +137,7 @@ export function projectV3QueueToV4ReadState(queueInput) {
   };
 }
 
-export function createV4DeliveryWarrantReadRequest(
+export function createDeliveryWarrantReadRequest(
   state,
   { requestId = crypto.randomUUID(), timeoutMs = 5_000 } = {},
 ) {
@@ -155,7 +155,7 @@ export function createV4DeliveryWarrantReadRequest(
     command: { id: "delivery-warrant.state-project", arguments: [] },
     input: {
       encoding: "base64",
-      bytes: v4CanonicalBytes(state).toString("base64"),
+      bytes: domainCanonicalBytes(state).toString("base64"),
     },
     requiredCapabilities: [...REQUIRED_CAPABILITIES],
     timeoutMs,
@@ -184,22 +184,22 @@ function validateProjection(response, request, expectedState) {
     fail("rust-projection-failed", "Rust read projection failed closed");
   const projection = response.structuredResult;
   if (
-    projection?.schema !== V4_DELIVERY_WARRANT_READ_PROJECTION_CONTRACT ||
+    projection?.schema !== DELIVERY_WARRANT_READ_PROJECTION_CONTRACT ||
     !projection.stateRoot
   )
     fail("host-response-invalid", "Rust read projection shape is invalid");
-  validateV4Root(projection.stateRoot, "$/projection/stateRoot");
+  validateRoot(projection.stateRoot, "$/projection/stateRoot");
   if (
-    !v4CanonicalBytes(projection.state).equals(
-      v4CanonicalBytes(expectedState),
+    !domainCanonicalBytes(projection.state).equals(
+      domainCanonicalBytes(expectedState),
     ) ||
-    projection.stateRoot !== v4ContentRoot("queue-state", expectedState)
+    projection.stateRoot !== domainContentRoot("queue-state", expectedState)
   )
     fail("projection-drift", "Rust read projection disagrees with v3 state");
   return projection;
 }
 
-export async function runV4DeliveryWarrantReadCandidate(
+export async function runDeliveryWarrantReadCandidate(
   queueInput,
   {
     qualification,
@@ -209,12 +209,12 @@ export async function runV4DeliveryWarrantReadCandidate(
     requestId,
     timeoutMs = 5_000,
     signal,
-    invokeRust = invokeV4RustShadowHost,
+    invokeRust = invokeRustShadowHost,
     host = {},
     retain,
   } = {},
 ) {
-  validateV4DeliveryWarrantReadQualification(qualification, {
+  validateDeliveryWarrantReadQualification(qualification, {
     expectedRoot: expectedQualificationRoot,
     expectedSources,
     observedAt,
@@ -222,10 +222,10 @@ export async function runV4DeliveryWarrantReadCandidate(
   if (typeof retain !== "function")
     fail("retention-required", "v4 read evidence retention is required");
   const queue = normalizeDevDeliveryQueue(queueInput, {
-    allowLegacyV3Readback: true,
+    allowLegacyBaselineReadback: true,
   });
-  const state = projectV3QueueToV4ReadState(queue);
-  const request = createV4DeliveryWarrantReadRequest(state, {
+  const state = projectBaselineQueueToReadState(queue);
+  const request = createDeliveryWarrantReadRequest(state, {
     requestId,
     timeoutMs,
   });
@@ -241,10 +241,10 @@ export async function runV4DeliveryWarrantReadCandidate(
   const projection = validateProjection(response, request, state);
   const observation = observeDevDeliveryQueue(queue, {
     now: observedAt,
-    allowLegacyV3Readback: true,
+    allowLegacyBaselineReadback: true,
   });
   const evidence = {
-    schema: V4_DELIVERY_WARRANT_READ_EVIDENCE_CONTRACT,
+    schema: DELIVERY_WARRANT_READ_EVIDENCE_CONTRACT,
     authority: "typescript-v3",
     writerAuthority: "typescript-v3",
     rustAuthority: "read-only",
@@ -254,21 +254,21 @@ export async function runV4DeliveryWarrantReadCandidate(
     qualificationRoot: expectedQualificationRoot,
     legacyStateRoot: queue.stateRoot,
     v4StateRoot: projection.stateRoot,
-    observationRoot: v4ContentRoot("observation", observation),
+    observationRoot: domainContentRoot("observation", observation),
     parity: "matched",
   };
-  const evidenceRoot = v4ContentRoot("observation", evidence);
+  const evidenceRoot = domainContentRoot("observation", evidence);
   let retentionReceipt;
   try {
     retentionReceipt = await retain(
       structuredClone({ ...evidence, evidenceRoot }),
     );
-    validateV4Root(retentionReceipt?.receiptRoot, "$/retention/receiptRoot");
+    validateRoot(retentionReceipt?.receiptRoot, "$/retention/receiptRoot");
   } catch {
     fail("retention-failed", "v4 read evidence retention failed");
   }
   return {
-    schema: V4_DELIVERY_WARRANT_READ_RESULT_CONTRACT,
+    schema: DELIVERY_WARRANT_READ_RESULT_CONTRACT,
     mode: "v4-read",
     authority: "typescript-v3",
     writerAuthority: "typescript-v3",

package/packages/core/{v4-delivery-warrant-semantic-diff-gate.js → delivery-warrant-semantic-diff-gate.js}

@@ -1,42 +1,41 @@
 import crypto from "node:crypto";
 
 import {
-  v4ContentRoot,
-  validateV4Clock,
-  validateV4Root,
-} from "./v4-canonical-contracts.js";
+  domainContentRoot,
+  validateClock,
+  validateRoot,
+} from "./canonical-contracts.js";
 import {
-  V4_DELIVERY_WARRANT_PROJECTION_CONTRACT,
-  V4_DELIVERY_WARRANT_RUNNER_CONTRACT,
-  V4_DELIVERY_WARRANT_TRACE_CONTRACT,
-} from "./v4-delivery-warrant-fixture-runner.js";
+  DELIVERY_WARRANT_PROJECTION_CONTRACT,
+  DELIVERY_WARRANT_RUNNER_CONTRACT,
+  DELIVERY_WARRANT_TRACE_CONTRACT,
+} from "./delivery-warrant-fixture-runner.js";
 import {
-  V4_DELIVERY_WARRANT_SHADOW_OBSERVATION_CONTRACT,
-  runV4DeliveryWarrantShadow,
-} from "./v4-delivery-warrant-shadow-adapter.js";
+  DELIVERY_WARRANT_SHADOW_OBSERVATION_CONTRACT,
+  runDeliveryWarrantShadow,
+} from "./delivery-warrant-shadow-adapter.js";
 
-export const V4_DELIVERY_WARRANT_SEMANTIC_DIFF_REPORT_CONTRACT =
+export const DELIVERY_WARRANT_SEMANTIC_DIFF_REPORT_CONTRACT =
   "buildchain-v4-delivery-warrant-semantic-diff-report/v1";
-export const V4_DELIVERY_WARRANT_SEMANTIC_DIFF_VALIDATOR_VERSION =
+export const DELIVERY_WARRANT_SEMANTIC_DIFF_VALIDATOR_VERSION =
   "semantic-diff-gate-v1";
-export const V4_DELIVERY_WARRANT_SEMANTIC_DIFF_REQUIRED_COVERAGE =
-  Object.freeze([
-    "cancellation",
-    "cas",
-    "conflict",
-    "duplicate",
-    "golden",
-    "lease-fence",
-    "property",
-    "replay",
-    "response-loss",
-  ]);
+export const DELIVERY_WARRANT_SEMANTIC_DIFF_REQUIRED_COVERAGE = Object.freeze([
+  "cancellation",
+  "cas",
+  "conflict",
+  "duplicate",
+  "golden",
+  "lease-fence",
+  "property",
+  "replay",
+  "response-loss",
+]);
 
 const REVISION = /^[0-9a-f]{40,64}$/u;
 const TOKEN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u;
 const stop = (code) => ({ code, retry: "stop" });
 const valueRoot = (value) =>
-  value === undefined ? null : v4ContentRoot("semantic-diff", { value });
+  value === undefined ? null : domainContentRoot("semantic-diff", { value });
 
 function difference(path, kind, legacy, rust) {
   const summary = {
@@ -47,11 +46,11 @@ function difference(path, kind, legacy, rust) {
   };
   return {
     ...summary,
-    differenceRoot: v4ContentRoot("semantic-diff", summary),
+    differenceRoot: domainContentRoot("semantic-diff", summary),
   };
 }
 
-export function compareV4DeliveryWarrantSemantics(legacy, rust, path = "$") {
+export function compareDeliveryWarrantSemantics(legacy, rust, path = "$") {
   if (Object.is(legacy, rust)) return [];
   if (legacy === undefined)
     return [difference(path, "missing-legacy", legacy, rust)];
@@ -69,12 +68,12 @@ export function compareV4DeliveryWarrantSemantics(legacy, rust, path = "$") {
     ? Array.from({ length: Math.max(legacy.length, rust.length) }, (_, i) => i)
     : [...new Set([...Object.keys(legacy), ...Object.keys(rust)])].sort();
   return keys.flatMap((key) =>
-    compareV4DeliveryWarrantSemantics(legacy[key], rust[key], `${path}/${key}`),
+    compareDeliveryWarrantSemantics(legacy[key], rust[key], `${path}/${key}`),
   );
 }
 
-export function v4DeliveryWarrantDispositionRoot(value) {
-  return v4ContentRoot("semantic-diff", {
+export function deliveryWarrantDispositionRoot(value) {
+  return domainContentRoot("semantic-diff", {
     differenceRoot: value.differenceRoot,
     disposition: value.disposition,
     reasonCode: value.reasonCode,
@@ -85,13 +84,13 @@ export function v4DeliveryWarrantDispositionRoot(value) {
 function dispositions(values = []) {
   return new Map(
     values.map((value) => {
-      validateV4Root(value.differenceRoot);
-      validateV4Root(value.reviewRoot);
-      validateV4Root(value.dispositionRoot);
+      validateRoot(value.differenceRoot);
+      validateRoot(value.reviewRoot);
+      validateRoot(value.dispositionRoot);
       if (
         value.disposition !== "reviewed-exclusion" ||
         !TOKEN.test(value.reasonCode) ||
-        value.dispositionRoot !== v4DeliveryWarrantDispositionRoot(value)
+        value.dispositionRoot !== deliveryWarrantDispositionRoot(value)
       )
         throw new TypeError(
           "semantic difference disposition is not review-rooted",
@@ -145,7 +144,7 @@ async function projectCase(definition, options, dispositionIndex) {
     blockers.push(stop("missing-observation"));
   if (
     observation &&
-    (observation.schema !== V4_DELIVERY_WARRANT_SHADOW_OBSERVATION_CONTRACT ||
+    (observation.schema !== DELIVERY_WARRANT_SHADOW_OBSERVATION_CONTRACT ||
       observation.authority !== "typescript-v3" ||
       observation.rustAuthority !== "none" ||
       observation.rustEffects !== "disabled")
@@ -171,7 +170,7 @@ async function projectCase(definition, options, dispositionIndex) {
   const rust = observation?.rust?.projection;
   const differences = classify(
     rust
-      ? compareV4DeliveryWarrantSemantics(result.authoritativeResult, rust)
+      ? compareDeliveryWarrantSemantics(result.authoritativeResult, rust)
       : [],
     dispositionIndex,
   );
@@ -182,18 +181,18 @@ async function projectCase(definition, options, dispositionIndex) {
     coverage: [...new Set(definition.coverage)].sort(),
     inputRoot,
     observationRoot: observation
-      ? v4ContentRoot("semantic-diff", observation)
+      ? domainContentRoot("semantic-diff", observation)
       : null,
     legacyProjectionRoot: result.authoritativeResult?.projectionRoot || null,
     rustProjectionRoot: rust?.projectionRoot || null,
     differences,
-    differenceRoot: v4ContentRoot("semantic-diff", differences),
+    differenceRoot: domainContentRoot("semantic-diff", differences),
     blockers,
   };
   return {
     report: {
       ...evidence,
-      evidenceRoot: v4ContentRoot("semantic-diff", evidence),
+      evidenceRoot: domainContentRoot("semantic-diff", evidence),
       status: blockers.length ? "blocked" : "zero-unexplained-diff",
     },
     legacy: result.authoritativeResult,
@@ -220,7 +219,7 @@ function probeReceipts(probes, runtime) {
   return probes.map((probe) => {
     const target = runtime.get(probe.caseId);
     const differences = target?.rust
-      ? compareV4DeliveryWarrantSemantics(
+      ? compareDeliveryWarrantSemantics(
           target.legacy,
           inject(target.rust, probe),
         )
@@ -233,15 +232,15 @@ function probeReceipts(probes, runtime) {
       detected: differences.length > 0,
       differenceRoots: differences.map((entry) => entry.differenceRoot).sort(),
     };
-    return { ...receipt, receiptRoot: v4ContentRoot("semantic-diff", receipt) };
+    return {
+      ...receipt,
+      receiptRoot: domainContentRoot("semantic-diff", receipt),
+    };
   });
 }
 
-export async function runV4DeliveryWarrantSemanticDiffGate(
-  cases,
-  options = {},
-) {
-  validateV4Clock(options.recordedAt);
+export async function runDeliveryWarrantSemanticDiffGate(cases, options = {}) {
+  validateClock(options.recordedAt);
   if (!Array.isArray(cases) || cases.length < 1 || cases.length > 64)
     throw new RangeError("semantic diff cases must contain 1-64 entries");
   if (
@@ -251,7 +250,7 @@ export async function runV4DeliveryWarrantSemanticDiffGate(
   )
     throw new TypeError("semantic diff source binding is invalid");
   for (const key of ["traceSchemaRoot", "reportSchemaRoot", "runnerRoot"])
-    validateV4Root(options.contracts?.[key]);
+    validateRoot(options.contracts?.[key]);
   const index = dispositions(options.dispositions);
   const projected = [];
   for (const entry of cases)
@@ -260,7 +259,7 @@ export async function runV4DeliveryWarrantSemanticDiffGate(
         entry,
         {
           ...options,
-          runShadow: options.runShadow || runV4DeliveryWarrantShadow,
+          runShadow: options.runShadow || runDeliveryWarrantShadow,
         },
         index,
       ),
@@ -268,7 +267,7 @@ export async function runV4DeliveryWarrantSemanticDiffGate(
   const runtime = new Map(projected.map((entry, i) => [cases[i].id, entry]));
   const receipts = probeReceipts(options.faultProbes, runtime);
   const coverage = new Set(cases.flatMap((entry) => entry.coverage));
-  const missing = V4_DELIVERY_WARRANT_SEMANTIC_DIFF_REQUIRED_COVERAGE.filter(
+  const missing = DELIVERY_WARRANT_SEMANTIC_DIFF_REQUIRED_COVERAGE.filter(
     (entry) => !coverage.has(entry),
   );
   const blockers = projected.flatMap((entry) => entry.report.blockers);
@@ -276,7 +275,7 @@ export async function runV4DeliveryWarrantSemanticDiffGate(
   if (receipts.some((entry) => !entry.detected))
     blockers.push(stop("fault-injection-undetected"));
   const body = {
-    schema: V4_DELIVERY_WARRANT_SEMANTIC_DIFF_REPORT_CONTRACT,
+    schema: DELIVERY_WARRANT_SEMANTIC_DIFF_REPORT_CONTRACT,
     authority: "typescript-v3",
     rustAuthority: "none",
     rustEffects: "disabled",
@@ -286,14 +285,14 @@ export async function runV4DeliveryWarrantSemanticDiffGate(
     ).toISOString(),
     sources: options.sources,
     contracts: {
-      trace: V4_DELIVERY_WARRANT_TRACE_CONTRACT,
-      projection: V4_DELIVERY_WARRANT_PROJECTION_CONTRACT,
-      observation: V4_DELIVERY_WARRANT_SHADOW_OBSERVATION_CONTRACT,
-      runner: V4_DELIVERY_WARRANT_RUNNER_CONTRACT,
+      trace: DELIVERY_WARRANT_TRACE_CONTRACT,
+      projection: DELIVERY_WARRANT_PROJECTION_CONTRACT,
+      observation: DELIVERY_WARRANT_SHADOW_OBSERVATION_CONTRACT,
+      runner: DELIVERY_WARRANT_RUNNER_CONTRACT,
       ...options.contracts,
     },
     coverage: {
-      required: [...V4_DELIVERY_WARRANT_SEMANTIC_DIFF_REQUIRED_COVERAGE],
+      required: [...DELIVERY_WARRANT_SEMANTIC_DIFF_REQUIRED_COVERAGE],
       observed: [...coverage].sort(),
       missing,
     },
@@ -316,12 +315,12 @@ export async function runV4DeliveryWarrantSemanticDiffGate(
   };
   let retention = {
     status: "failed",
-    evidenceRoot: v4ContentRoot("semantic-diff", body),
+    evidenceRoot: domainContentRoot("semantic-diff", body),
     receiptRoot: null,
   };
   try {
     const receipt = await options.retain?.(structuredClone(body));
-    validateV4Root(receipt?.receiptRoot);
+    validateRoot(receipt?.receiptRoot);
     retention = {
       ...retention,
       status: "retained",
@@ -348,5 +347,5 @@ export async function runV4DeliveryWarrantSemanticDiffGate(
       v4WriteAuthorized: false,
     },
   };
-  return { ...report, reportRoot: v4ContentRoot("semantic-diff", report) };
+  return { ...report, reportRoot: domainContentRoot("semantic-diff", report) };
 }

package/packages/core/{v4-delivery-warrant-shadow-adapter.js → delivery-warrant-shadow-adapter.js}

@@ -3,11 +3,11 @@ import crypto from "node:crypto";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
-import { runV4DeliveryWarrantTraceFixture } from "./v4-delivery-warrant-fixture-runner.js";
+import { runDeliveryWarrantTraceFixture } from "./delivery-warrant-fixture-runner.js";
 
-export const V4_DELIVERY_WARRANT_SHADOW_OBSERVATION_CONTRACT =
+export const DELIVERY_WARRANT_SHADOW_OBSERVATION_CONTRACT =
   "buildchain-v4-delivery-warrant-shadow-observation/v1";
-export const V4_DELIVERY_WARRANT_SHADOW_RESULT_CONTRACT =
+export const DELIVERY_WARRANT_SHADOW_RESULT_CONTRACT =
   "buildchain-v4-delivery-warrant-shadow-result/v1";
 
 const HOST_REQUEST_CONTRACT = "kungfu-buildchain-v4-host-request";
@@ -117,7 +117,7 @@ function retainUntil(recordedAt) {
   return new Date(time + RETENTION_DAYS * 24 * 60 * 60 * 1000).toISOString();
 }
 
-export function createV4DeliveryWarrantShadowRequest(
+export function createDeliveryWarrantShadowRequest(
   bytes,
   { requestId = crypto.randomUUID(), timeoutMs = 5_000 } = {},
 ) {
@@ -203,14 +203,14 @@ function defaultHost() {
       "--locked",
       "--quiet",
       "--manifest-path",
-      path.join(root, "crates", "buildchain-v4-contracts", "Cargo.toml"),
+      path.join(root, "crates", "buildchain-domain-contracts", "Cargo.toml"),
       "--",
       "host",
     ],
   };
 }
 
-export function invokeV4RustShadowHost(
+export function invokeRustShadowHost(
   request,
   { command, arguments: commandArguments, cwd = root, signal } = {},
 ) {
@@ -322,12 +322,12 @@ function skippedShadow(inputRoot, code) {
   };
 }
 
-export async function runV4DeliveryWarrantShadow(
+export async function runDeliveryWarrantShadow(
   value,
   {
     enabled = enabledByDefault(),
-    invokeLegacy = runV4DeliveryWarrantTraceFixture,
-    invokeRust = invokeV4RustShadowHost,
+    invokeLegacy = runDeliveryWarrantTraceFixture,
+    invokeRust = invokeRustShadowHost,
     host = {},
     requestId,
     timeoutMs = 5_000,
@@ -343,7 +343,7 @@ export async function runV4DeliveryWarrantShadow(
   const inputRoot = sha256(bytes);
   if (!enabled) {
     return {
-      schema: V4_DELIVERY_WARRANT_SHADOW_RESULT_CONTRACT,
+      schema: DELIVERY_WARRANT_SHADOW_RESULT_CONTRACT,
       authoritativeResult,
       shadow: skippedShadow(inputRoot, "shadow-disabled"),
     };
@@ -354,7 +354,7 @@ export async function runV4DeliveryWarrantShadow(
     retentionScope = publicRetention(retention);
   } catch (error) {
     return {
-      schema: V4_DELIVERY_WARRANT_SHADOW_RESULT_CONTRACT,
+      schema: DELIVERY_WARRANT_SHADOW_RESULT_CONTRACT,
       authoritativeResult,
       shadow: skippedShadow(inputRoot, error.code || "input-not-public-safe"),
     };
@@ -371,13 +371,13 @@ export async function runV4DeliveryWarrantShadow(
       rustRevision: exactSource(sources.rustRevision, "rustRevision"),
       validatorVersion: exactValidator(sources.validatorVersion),
     };
-    request = createV4DeliveryWarrantShadowRequest(bytes, {
+    request = createDeliveryWarrantShadowRequest(bytes, {
       requestId,
       timeoutMs,
     });
   } catch {
     return {
-      schema: V4_DELIVERY_WARRANT_SHADOW_RESULT_CONTRACT,
+      schema: DELIVERY_WARRANT_SHADOW_RESULT_CONTRACT,
       authoritativeResult,
       shadow: skippedShadow(inputRoot, "shadow-config-invalid"),
     };
@@ -396,7 +396,7 @@ export async function runV4DeliveryWarrantShadow(
   }
 
   const observation = {
-    schema: V4_DELIVERY_WARRANT_SHADOW_OBSERVATION_CONTRACT,
+    schema: DELIVERY_WARRANT_SHADOW_OBSERVATION_CONTRACT,
     authority: "typescript-v3",
     rustAuthority: "none",
     rustEffects: "disabled",
@@ -431,7 +431,7 @@ export async function runV4DeliveryWarrantShadow(
     }
   }
   return {
-    schema: V4_DELIVERY_WARRANT_SHADOW_RESULT_CONTRACT,
+    schema: DELIVERY_WARRANT_SHADOW_RESULT_CONTRACT,
     authoritativeResult,
     shadow: {
       status,

package/packages/core/dev-delivery-execution-transfer.js

@@ -37,10 +37,10 @@ const FAILURE_FILES = [
   "warrant.json",
 ];
 
-const V4_RUNTIME_SELECTOR =
+const DOMAIN_RUNTIME_SELECTOR =
   /^(?:[0-9a-f]{40}|v4|v4-alpha|train\/v4\/v4\.0\/[a-z0-9][a-z0-9._-]*)$/u;
 
-const V4_RUNTIME_SELECTOR_DESCRIPTION =
+const RUNTIME_SELECTOR_DESCRIPTION =
   "runtime selector must be an exact immutable SHA, v4, v4-alpha, or train/v4/v4.0/<capability>";
 
 function requiredFiles(outcome) {
@@ -165,8 +165,8 @@ function runtimeBinding(input = {}) {
     resolvedSha: exactSha(input.resolvedSha, "resolved runtime SHA"),
     selectionRoot: exactRoot(input.selectionRoot, "runtime selection root"),
   };
-  if (!V4_RUNTIME_SELECTOR.test(runtime.selector)) {
-    throw new Error(V4_RUNTIME_SELECTOR_DESCRIPTION);
+  if (!DOMAIN_RUNTIME_SELECTOR.test(runtime.selector)) {
+    throw new Error(RUNTIME_SELECTOR_DESCRIPTION);
   }
   return runtime;
 }
@@ -207,8 +207,8 @@ function verifiedRuntimeSelection(directory, expected = {}) {
   if (JSON.stringify(selection) !== JSON.stringify(normalized)) {
     throw new Error("runtime selection is not exact canonical content");
   }
-  if (!V4_RUNTIME_SELECTOR.test(normalized.selector)) {
-    throw new Error(V4_RUNTIME_SELECTOR_DESCRIPTION);
+  if (!DOMAIN_RUNTIME_SELECTOR.test(normalized.selector)) {
+    throw new Error(RUNTIME_SELECTOR_DESCRIPTION);
   }
   const selectionRoot = sha256Bytes(
     Buffer.from(`${JSON.stringify(normalized, null, 2)}\n`),

package/packages/core/dev-delivery-native-proof.js

@@ -30,7 +30,7 @@ export {
 };
 export const NATIVE_QUALIFICATION_PROOF_SCHEMA =
   "kungfu.buildchain.native-qualification-proof/v4";
-const LEGACY_NATIVE_QUALIFICATION_PROOF_V3_SCHEMA =
+const LEGACY_NATIVE_QUALIFICATION_PROOF_BASELINE_SCHEMA =
   "kungfu.buildchain.native-qualification-proof/v3";
 const LEGACY_NATIVE_QUALIFICATION_PROOF_V2_SCHEMA =
   "kungfu.buildchain.native-qualification-proof/v2";
@@ -44,9 +44,13 @@ export const NATIVE_PROOF_BASE_DELTA_SCHEMA =
   "kungfu.buildchain.native-proof-base-delta/v1";
 const NATIVE_QUALIFICATION_ROOT_SEMANTICS = "semantic-native-identity-v1";
 
-function normalizeQualifiedWarrant(warrant, candidate, allowLegacyV3Readback) {
-  const qualifiedV3Readback =
-    allowLegacyV3Readback &&
+function normalizeQualifiedWarrant(
+  warrant,
+  candidate,
+  allowLegacyBaselineReadback,
+) {
+  const qualifiedBaselineReadback =
+    allowLegacyBaselineReadback &&
     !warrant.nativeCommandContract &&
     !candidate.nativeCommandContract &&
     !warrant.nativeExecutionReceiptRoot &&
@@ -59,7 +63,7 @@ function normalizeQualifiedWarrant(warrant, candidate, allowLegacyV3Readback) {
     warrant.nativeProofReuseRoot,
     "Warrant nativeProofReuseRoot",
   );
-  if (!qualifiedV3Readback) {
+  if (!qualifiedBaselineReadback) {
     warrant.nativeExecutionReceiptRoot = exactRoot(
       warrant.nativeExecutionReceiptRoot,
       "Warrant nativeExecutionReceiptRoot",
@@ -74,7 +78,7 @@ function normalizeQualifiedWarrant(warrant, candidate, allowLegacyV3Readback) {
 
 export function validateActiveDevDeliveryWarrant(
   queue,
-  { allowLegacyV3Readback = false } = {},
+  { allowLegacyBaselineReadback = false } = {},
 ) {
   const warrant = queue.activeWarrant;
   if (warrant.schema !== "kungfu.buildchain.dev-delivery-warrant/v1")
@@ -110,7 +114,7 @@ export function validateActiveDevDeliveryWarrant(
       "exactly one active candidate must match the active Warrant",
     );
   if (warrant.phase === "qualified") {
-    normalizeQualifiedWarrant(warrant, active[0], allowLegacyV3Readback);
+    normalizeQualifiedWarrant(warrant, active[0], allowLegacyBaselineReadback);
   } else if (
     warrant.phase === "provisional" &&
     (warrant.nativeProofRoot ||
@@ -288,7 +292,7 @@ export function verifyNativeQualificationProof(proofInput, expected = {}) {
     if (
       ![
         NATIVE_QUALIFICATION_PROOF_SCHEMA,
-        LEGACY_NATIVE_QUALIFICATION_PROOF_V3_SCHEMA,
+        LEGACY_NATIVE_QUALIFICATION_PROOF_BASELINE_SCHEMA,
         LEGACY_NATIVE_QUALIFICATION_PROOF_V2_SCHEMA,
         LEGACY_NATIVE_QUALIFICATION_PROOF_SCHEMA,
       ].includes(proof.schema)