@kungfu-tech/buildchain 4.0.2-alpha.9 → 4.0.3-alpha.0

package/packages/core/{v4-delivery-warrant-fixture-runner.js → delivery-warrant-fixture-runner.js}

@@ -1,27 +1,27 @@
 import { TextDecoder } from "node:util";
 
 import {
-  V4ContractFault,
-  v4CanonicalBytes,
-  v4ContentRoot,
-  validateV4ContractFault,
-  validateV4EventEnvelope,
-  validateV4ReceiptEnvelope,
-  validateV4Root,
-} from "./v4-canonical-contracts.js";
+  ContractFault,
+  domainCanonicalBytes,
+  domainContentRoot,
+  validateContractFault,
+  validateEventEnvelope,
+  validateReceiptEnvelope,
+  validateRoot,
+} from "./canonical-contracts.js";
 
-export const V4_DELIVERY_WARRANT_TRACE_CONTRACT =
+export const DELIVERY_WARRANT_TRACE_CONTRACT =
   "buildchain-v4-delivery-warrant-trace-fixture/v1";
-export const V4_DELIVERY_WARRANT_RUNNER_CONTRACT =
+export const DELIVERY_WARRANT_RUNNER_CONTRACT =
   "buildchain-v4-delivery-warrant-fixture-runner/v1";
-export const V4_DELIVERY_WARRANT_PROJECTION_CONTRACT =
+export const DELIVERY_WARRANT_PROJECTION_CONTRACT =
   "buildchain-v4-delivery-warrant-semantic-projection/v1";
 
 const ASCII_TOKEN_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u;
 const UTF8 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: false });
 
 function fail(code, path, message) {
-  throw new V4ContractFault(code, path, message);
+  throw new ContractFault(code, path, message);
 }
 
 function exactKeys(value, keys, path) {
@@ -53,11 +53,11 @@ function nonNegativeInteger(value, path) {
 }
 
 function equalCanonical(left, right) {
-  return v4CanonicalBytes(left).equals(v4CanonicalBytes(right));
+  return domainCanonicalBytes(left).equals(domainCanonicalBytes(right));
 }
 
 function declaredRoot(value, expected, path, code) {
-  validateV4Root(value, path);
+  validateRoot(value, path);
   if (value !== expected)
     fail(code, path, `${path} does not match the retained canonical bytes`);
   return value;
@@ -113,7 +113,7 @@ function validateOrderedEntries(entries, path) {
         `${path} sequence must be contiguous and ordered`,
       );
     token(entry.type, `${path}/${index}/type`);
-    v4CanonicalBytes(entry.payload);
+    domainCanonicalBytes(entry.payload);
     return entry;
   });
 }
@@ -141,12 +141,12 @@ function validateState(state, path) {
       `${path}/candidates`,
       "state candidates must be an array",
     );
-  const canonicalUtf8 = v4CanonicalBytes(state).toString("utf8");
+  const canonicalUtf8 = domainCanonicalBytes(state).toString("utf8");
   return {
     generation,
     fencingCounter,
     canonicalUtf8,
-    root: v4ContentRoot("queue-state", state),
+    root: domainContentRoot("queue-state", state),
   };
 }
 
@@ -169,7 +169,7 @@ function validateDecision(decision, receipt, path) {
         "an action cannot bind a rejected receipt",
       );
   } else {
-    validateV4ContractFault(decision.fault, `${path}/fault`);
+    validateContractFault(decision.fault, `${path}/fault`);
     if (
       receipt.outcome !== "rejected" ||
       receipt.fault === null ||
@@ -219,14 +219,14 @@ function projectStep(step, index, priorStateRoot) {
     "stale-prior-root",
   );
 
-  validateV4EventEnvelope(step.event);
+  validateEventEnvelope(step.event);
   if (step.event.subjectRoot !== priorStateRoot)
     fail(
       "stale-prior-root",
       `${path}/event/subjectRoot`,
       "event subjectRoot must bind the exact prior state",
     );
-  const eventRoot = v4ContentRoot("observation", step.event);
+  const eventRoot = domainContentRoot("observation", step.event);
 
   const successor = validateState(
     step.successorState,
@@ -239,7 +239,7 @@ function projectStep(step, index, priorStateRoot) {
     "stale-successor-root",
   );
 
-  validateV4ReceiptEnvelope(step.receipt);
+  validateReceiptEnvelope(step.receipt);
   if (
     step.receipt.eventRoot !== eventRoot ||
     step.receipt.priorStateRoot !== priorStateRoot ||
@@ -266,10 +266,12 @@ function projectStep(step, index, priorStateRoot) {
     step.observations,
     `${path}/observations`,
   );
-  const receiptCanonicalUtf8 = v4CanonicalBytes(step.receipt).toString("utf8");
+  const receiptCanonicalUtf8 = domainCanonicalBytes(step.receipt).toString(
+    "utf8",
+  );
   const receiptRoot = declaredRoot(
     step.receiptRoot,
-    v4ContentRoot("transition-receipt", step.receipt),
+    domainContentRoot("transition-receipt", step.receipt),
     `${path}/receiptRoot`,
     "stale-receipt-root",
   );
@@ -288,13 +290,15 @@ function projectStep(step, index, priorStateRoot) {
       effects: effects.map((effect) => ({
         sequence: effect.sequence,
         type: effect.type,
-        canonicalUtf8: v4CanonicalBytes(effect.payload).toString("utf8"),
+        canonicalUtf8: domainCanonicalBytes(effect.payload).toString("utf8"),
       })),
       observations: observations.map((observation) => ({
         sequence: observation.sequence,
         type: observation.type,
-        canonicalUtf8: v4CanonicalBytes(observation.payload).toString("utf8"),
-        root: v4ContentRoot("observation", observation.payload),
+        canonicalUtf8: domainCanonicalBytes(observation.payload).toString(
+          "utf8",
+        ),
+        root: domainContentRoot("observation", observation.payload),
       })),
       receiptCanonicalUtf8,
       receiptRoot,
@@ -303,7 +307,7 @@ function projectStep(step, index, priorStateRoot) {
   };
 }
 
-export function runV4DeliveryWarrantTraceFixture(
+export function runDeliveryWarrantTraceFixture(
   bytes,
   { verifyExpectedRoot = true } = {},
 ) {
@@ -315,8 +319,8 @@ export function runV4DeliveryWarrantTraceFixture(
   );
   if (
     fixture.schemaVersion !== 1 ||
-    fixture.contract !== V4_DELIVERY_WARRANT_TRACE_CONTRACT ||
-    fixture.runner !== V4_DELIVERY_WARRANT_RUNNER_CONTRACT
+    fixture.contract !== DELIVERY_WARRANT_TRACE_CONTRACT ||
+    fixture.runner !== DELIVERY_WARRANT_RUNNER_CONTRACT
   )
     fail(
       "unsupported-trace-version",
@@ -354,13 +358,13 @@ export function runV4DeliveryWarrantTraceFixture(
     return result.projection;
   });
   const projection = {
-    schema: V4_DELIVERY_WARRANT_PROJECTION_CONTRACT,
+    schema: DELIVERY_WARRANT_PROJECTION_CONTRACT,
     traceId: fixture.trace.id,
     traceKind: fixture.trace.kind,
     steps,
   };
-  const projectionRoot = v4ContentRoot("semantic-diff", projection);
-  validateV4Root(fixture.expectedProjectionRoot, "$/expectedProjectionRoot");
+  const projectionRoot = domainContentRoot("semantic-diff", projection);
+  validateRoot(fixture.expectedProjectionRoot, "$/expectedProjectionRoot");
   if (verifyExpectedRoot && fixture.expectedProjectionRoot !== projectionRoot)
     fail(
       "stale-projection-root",

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) };
 }