@kungfu-tech/buildchain 4.0.2 → 4.0.3

package/packages/core/{v4-runtime-ref-resume-authority.js → runtime-ref-resume-authority.js}

@@ -1,23 +1,20 @@
 import crypto from "node:crypto";
 import {
-  V4_RUNTIME_PERSISTENCE_SCAN_CONTRACT,
-  scanV4RuntimeSelectorPersistence,
-} from "./v4-runtime-selector-persistence.js";
+  RUNTIME_PERSISTENCE_SCAN_CONTRACT,
+  scanRuntimeSelectorPersistence,
+} from "./runtime-selector-persistence.js";
 
-export {
-  V4_RUNTIME_PERSISTENCE_SCAN_CONTRACT,
-  scanV4RuntimeSelectorPersistence,
-};
+export { RUNTIME_PERSISTENCE_SCAN_CONTRACT, scanRuntimeSelectorPersistence };
 
-export const V4_RUNTIME_AUTHORIZATION_CONTRACT =
+export const RUNTIME_AUTHORIZATION_CONTRACT =
   "kungfu-buildchain-v4-runtime-authorization/v1";
-export const V4_RUNTIME_RESUME_LINEAGE_CONTRACT =
+export const RUNTIME_RESUME_LINEAGE_CONTRACT =
   "kungfu-buildchain-v4-runtime-resume-lineage/v1";
 const EXACT_SHA = /^[0-9a-f]{40}$/u;
 const SHA256_ROOT = /^sha256:[0-9a-f]{64}$/u;
-const OFFICIAL_V4_REF = /^v4(?:-alpha)?$/u;
-const TRAIN_V4_REF = /^train\/v4\/v4\.\d+\/[A-Za-z0-9._/-]+$/u;
-const AUTHORITY_V4_REF = /^authority\/v4\/v4\.\d+\/[A-Za-z0-9._/-]+$/u;
+const OFFICIAL_DOMAIN_REF = /^v4(?:-alpha)?$/u;
+const TRAIN_DOMAIN_REF = /^train\/v4\/v4\.\d+\/[A-Za-z0-9._/-]+$/u;
+const AUTHORITY_DOMAIN_REF = /^authority\/v4\/v4\.\d+\/[A-Za-z0-9._/-]+$/u;
 const TOKEN = /^[A-Za-z0-9][A-Za-z0-9._:/-]*$/u;
 
 function stableJson(value) {
@@ -31,7 +28,7 @@ function stableJson(value) {
   return JSON.stringify(value);
 }
 
-export function v4RuntimeResumeDocumentRoot(value) {
+export function runtimeResumeDocumentRoot(value) {
   return `sha256:${crypto.createHash("sha256").update(stableJson(value)).digest("hex")}`;
 }
 
@@ -108,21 +105,21 @@ function normalizeRef(value) {
     .replace(/^refs\/(?:heads|tags)\//u, "");
 }
 
-function approvedV4Ref(value) {
+function approvedRef(value) {
   const ref = normalizeRef(value);
   return (
-    OFFICIAL_V4_REF.test(ref) ||
-    TRAIN_V4_REF.test(ref) ||
-    AUTHORITY_V4_REF.test(ref)
+    OFFICIAL_DOMAIN_REF.test(ref) ||
+    TRAIN_DOMAIN_REF.test(ref) ||
+    AUTHORITY_DOMAIN_REF.test(ref)
   );
 }
 
 function runtimeClass(value) {
   const ref = normalizeRef(value);
   if (EXACT_SHA.test(ref.toLowerCase())) return "exact-sha";
-  if (OFFICIAL_V4_REF.test(ref)) return "floating";
-  if (TRAIN_V4_REF.test(ref)) return "train";
-  if (AUTHORITY_V4_REF.test(ref)) return "authority";
+  if (OFFICIAL_DOMAIN_REF.test(ref)) return "floating";
+  if (TRAIN_DOMAIN_REF.test(ref)) return "train";
+  if (AUTHORITY_DOMAIN_REF.test(ref)) return "authority";
   return "rejected";
 }
 
@@ -139,7 +136,7 @@ function normalizeReadbacks(values, runtimeSha) {
       `approvedRefReadbacks[${index}]`,
     );
     const ref = normalizeRef(value.ref);
-    if (!approvedV4Ref(ref)) {
+    if (!approvedRef(ref)) {
       throw new Error(
         `approvedRefReadbacks[${index}].ref is not an approved v4 ref`,
       );
@@ -170,7 +167,7 @@ function normalizeReadbacks(values, runtimeSha) {
   return normalized;
 }
 
-export function authorizeV4RuntimeSelection({
+export function authorizeRuntimeSelection({
   repository,
   eventName,
   mode = "dispatch",
@@ -210,7 +207,7 @@ export function authorizeV4RuntimeSelection({
   }
   if (
     !persistenceScan ||
-    persistenceScan.contract !== V4_RUNTIME_PERSISTENCE_SCAN_CONTRACT
+    persistenceScan.contract !== RUNTIME_PERSISTENCE_SCAN_CONTRACT
   ) {
     throw new Error("a v4 runtime persistence scan is required");
   }
@@ -221,7 +218,7 @@ export function authorizeV4RuntimeSelection({
   }
   const scanPayload = { ...persistenceScan };
   delete scanPayload.root;
-  if (persistenceScan.root !== v4RuntimeResumeDocumentRoot(scanPayload)) {
+  if (persistenceScan.root !== runtimeResumeDocumentRoot(scanPayload)) {
     throw new Error("runtime persistence scan root mismatch");
   }
   const readbacks = normalizeReadbacks(approvedRefReadbacks, runtimeSha);
@@ -238,7 +235,7 @@ export function authorizeV4RuntimeSelection({
     throw new Error("authorizedAt must be an ISO-8601 timestamp");
   const receipt = {
     schemaVersion: 1,
-    contract: V4_RUNTIME_AUTHORIZATION_CONTRACT,
+    contract: RUNTIME_AUTHORIZATION_CONTRACT,
     status: "authorized",
     mode,
     eventName,
@@ -265,10 +262,10 @@ export function authorizeV4RuntimeSelection({
     ),
     persistenceScanRoot: root(persistenceScan.root, "persistenceScan.root"),
   };
-  return { receipt, receiptRoot: v4RuntimeResumeDocumentRoot(receipt) };
+  return { receipt, receiptRoot: runtimeResumeDocumentRoot(receipt) };
 }
 
-export function verifyV4RuntimeAuthorizationReceipt({
+export function verifyRuntimeAuthorizationReceipt({
   receipt,
   receiptRoot,
   repository = "",
@@ -281,13 +278,13 @@ export function verifyV4RuntimeAuthorizationReceipt({
     if (!condition) failures.push(code);
   };
   check(
-    receipt?.contract === V4_RUNTIME_AUTHORIZATION_CONTRACT,
+    receipt?.contract === RUNTIME_AUTHORIZATION_CONTRACT,
     "contract-invalid",
   );
   check(receipt?.status === "authorized", "status-not-authorized");
   check(
     SHA256_ROOT.test(String(receiptRoot || "")) &&
-      receiptRoot === v4RuntimeResumeDocumentRoot(receipt),
+      receiptRoot === runtimeResumeDocumentRoot(receipt),
     "receipt-root-mismatch",
   );
   check(receipt?.eventName === "workflow_dispatch", "event-not-trusted");
@@ -302,8 +299,7 @@ export function verifyV4RuntimeAuthorizationReceipt({
   check(
     Array.isArray(receipt?.runtime?.reachableFrom) &&
       receipt.runtime.reachableFrom.some(
-        (entry) =>
-          approvedV4Ref(entry.ref) && entry.containsRuntimeSha === true,
+        (entry) => approvedRef(entry.ref) && entry.containsRuntimeSha === true,
       ),
     "runtime-unreachable",
   );
@@ -322,7 +318,7 @@ export function verifyV4RuntimeAuthorizationReceipt({
   return { ok: failures.length === 0, failures };
 }
 
-export function createV4RuntimeResumeLineage({
+export function createRuntimeResumeLineage({
   authorization,
   authorizationRoot,
   buildAttempt,
@@ -336,7 +332,7 @@ export function createV4RuntimeResumeLineage({
   floatingRefBefore,
   floatingRefAfter,
 } = {}) {
-  const verification = verifyV4RuntimeAuthorizationReceipt({
+  const verification = verifyRuntimeAuthorizationReceipt({
     receipt: authorization,
     receiptRoot: authorizationRoot,
     sourceSha: source?.sha,
@@ -437,7 +433,7 @@ export function createV4RuntimeResumeLineage({
     ref: normalizeRef(floatingRefAfter?.ref),
     sha: exactSha(floatingRefAfter?.sha, "floatingRefAfter.sha"),
   };
-  if (!OFFICIAL_V4_REF.test(before.ref) || before.ref !== after.ref) {
+  if (!OFFICIAL_DOMAIN_REF.test(before.ref) || before.ref !== after.ref) {
     throw new Error(
       "floating ref movement must remain on one official v4 channel",
     );
@@ -455,7 +451,7 @@ export function createV4RuntimeResumeLineage({
   );
   const lineage = {
     schemaVersion: 1,
-    contract: V4_RUNTIME_RESUME_LINEAGE_CONTRACT,
+    contract: RUNTIME_RESUME_LINEAGE_CONTRACT,
     status: "qualified",
     authorizationRoot: root(authorizationRoot, "authorizationRoot"),
     source: sourceIdentity,
@@ -480,7 +476,7 @@ export function createV4RuntimeResumeLineage({
       "finalPublicReadbackRoot",
     ),
   };
-  return { lineage, lineageRoot: v4RuntimeResumeDocumentRoot(lineage) };
+  return { lineage, lineageRoot: runtimeResumeDocumentRoot(lineage) };
 }
 
 function validSourceIdentity(source) {
@@ -500,7 +496,7 @@ function validRuntimeTransition(attempts) {
 
 function validFloatingRefMovement(movement) {
   return (
-    OFFICIAL_V4_REF.test(String(movement?.before?.ref || "")) &&
+    OFFICIAL_DOMAIN_REF.test(String(movement?.before?.ref || "")) &&
     movement.before.ref === movement?.after?.ref &&
     EXACT_SHA.test(String(movement.before.sha || "")) &&
     EXACT_SHA.test(String(movement.after.sha || "")) &&
@@ -548,7 +544,7 @@ function platformLineageFailures(stageCapsules) {
   return failures;
 }
 
-export function verifyV4RuntimeResumeLineage({
+export function verifyRuntimeResumeLineage({
   lineage,
   lineageRoot,
   repository = "",
@@ -562,13 +558,13 @@ export function verifyV4RuntimeResumeLineage({
     if (!condition) failures.push(code);
   };
   check(
-    lineage?.contract === V4_RUNTIME_RESUME_LINEAGE_CONTRACT,
+    lineage?.contract === RUNTIME_RESUME_LINEAGE_CONTRACT,
     "contract-invalid",
   );
   check(lineage?.status === "qualified", "status-not-qualified");
   check(
     SHA256_ROOT.test(String(lineageRoot || "")) &&
-      lineageRoot === v4RuntimeResumeDocumentRoot(lineage),
+      lineageRoot === runtimeResumeDocumentRoot(lineage),
     "lineage-root-mismatch",
   );
   check(

package/packages/core/{v4-runtime-selector-persistence.js → runtime-selector-persistence.js}

@@ -2,12 +2,12 @@ import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 
-export const V4_RUNTIME_PERSISTENCE_SCAN_CONTRACT =
+export const RUNTIME_PERSISTENCE_SCAN_CONTRACT =
   "kungfu-buildchain-v4-runtime-persistence-scan/v1";
 
 const EXACT_SHA = /^[0-9a-f]{40}$/u;
-const TRAIN_V4_REF = /^train\/v4\/v4\.\d+\/[A-Za-z0-9._/-]+$/u;
-const AUTHORITY_V4_REF = /^authority\/v4\/v4\.\d+\/[A-Za-z0-9._/-]+$/u;
+const TRAIN_DOMAIN_REF = /^train\/v4\/v4\.\d+\/[A-Za-z0-9._/-]+$/u;
+const AUTHORITY_DOMAIN_REF = /^authority\/v4\/v4\.\d+\/[A-Za-z0-9._/-]+$/u;
 const RUNTIME_SELECTOR =
   /(?:buildchain[-_. ]?(?:ref|runtime)|runtime[-_. ]?sha|resume[-_. ]?buildchain)/iu;
 const EXACT_SHA_LITERAL = /\b[0-9a-f]{40}\b/giu;
@@ -44,8 +44,8 @@ function transientSelector(value) {
   const normalized = normalizeRef(value);
   return (
     EXACT_SHA.test(normalized.toLowerCase()) ||
-    TRAIN_V4_REF.test(normalized) ||
-    AUTHORITY_V4_REF.test(normalized) ||
+    TRAIN_DOMAIN_REF.test(normalized) ||
+    AUTHORITY_DOMAIN_REF.test(normalized) ||
     /\$\{\{\s*(?:vars|secrets|env)\./u.test(value)
   );
 }
@@ -178,7 +178,7 @@ function inspectSource({
   }
 }
 
-export function scanV4RuntimeSelectorPersistence({
+export function scanRuntimeSelectorPersistence({
   root: callerRoot = process.cwd(),
   paths = undefined,
 } = {}) {
@@ -214,7 +214,7 @@ export function scanV4RuntimeSelectorPersistence({
   }
   const payload = {
     schemaVersion: 1,
-    contract: V4_RUNTIME_PERSISTENCE_SCAN_CONTRACT,
+    contract: RUNTIME_PERSISTENCE_SCAN_CONTRACT,
     status: failures.length === 0 ? "passed" : "rejected",
     files,
     authorityUsage: authorityUsage.sort((left, right) =>

package/packages/core/stable-publication-fence.js

@@ -0,0 +1,28 @@
+import { ContractFault } from "./canonical-contracts.js";
+import { DomainWasmFault, invokeDomainWasm } from "./domain-wasm.js";
+
+export const STABLE_PUBLICATION_REQUEST_CONTRACT =
+  "buildchain-v4-stable-publication-request/v1";
+export const STABLE_PUBLICATION_PLAN_CONTRACT =
+  "buildchain-v4-stable-publication-plan/v1";
+export const STABLE_PUBLICATION_FENCE_CONTRACT =
+  "buildchain-v4-stable-publication-fence/v1";
+
+function project(request) {
+  try {
+    return invokeDomainWasm("stable-publication", request);
+  } catch (error) {
+    if (error instanceof DomainWasmFault) {
+      throw new ContractFault(error.code, error.path, error.message);
+    }
+    throw error;
+  }
+}
+
+export function planStablePublication(request) {
+  return project(request).plan;
+}
+
+export function projectStablePublication(request) {
+  return project(request);
+}

package/packages/core/{v4-stage-capsule-local-store.js → stage-capsule-local-store.js}

@@ -2,30 +2,30 @@ import fs from "node:fs";
 import path from "node:path";
 
 import {
-  V4ContractFault,
-  v4CanonicalBytes,
-  v4ContentRoot,
-  validateV4Clock,
-  validateV4Root,
-} from "./v4-canonical-contracts.js";
+  ContractFault,
+  domainCanonicalBytes,
+  domainContentRoot,
+  validateClock,
+  validateRoot,
+} from "./canonical-contracts.js";
 import {
-  V4_STAGE_CAPSULE_AVAILABILITY_CONTRACT,
-  v4StageCapsuleAvailabilityRoot,
-  validateV4StageCapsule,
-  validateV4StageCapsuleAvailability,
-} from "./v4-stage-capsule.js";
+  STAGE_CAPSULE_AVAILABILITY_CONTRACT,
+  stageCapsuleAvailabilityRoot,
+  validateStageCapsule,
+  validateStageCapsuleAvailability,
+} from "./stage-capsule.js";
 import {
-  createV4StageCapsuleRetentionState,
-  createV4StageCapsuleStoreReceipt,
-  createV4StageCapsuleTransport,
-  v4StageCapsuleBlobRoot,
-  validateV4StageCapsuleOutputManifest,
-} from "./v4-stage-capsule-store.js";
+  createStageCapsuleRetentionState,
+  createStageCapsuleStoreReceipt,
+  createStageCapsuleTransport,
+  stageCapsuleBlobRoot,
+  validateStageCapsuleOutputManifest,
+} from "./stage-capsule-store.js";
 
 const TOKEN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u;
 
 function fault(code, pathValue, message) {
-  throw new V4ContractFault(code, pathValue, message);
+  throw new ContractFault(code, pathValue, message);
 }
 
 function exactKeys(value, keys, pathValue) {
@@ -55,7 +55,7 @@ function token(value, pathValue) {
 }
 
 function rootedPath(rootDirectory, family, root, suffix = "") {
-  validateV4Root(root);
+  validateRoot(root);
   return path.join(
     rootDirectory,
     family,
@@ -99,7 +99,7 @@ function readCanonicalJson(file, missingCode) {
   } catch {
     fault("stage-capsule-corrupt", "$/store", "stored JSON is invalid");
   }
-  if (!v4CanonicalBytes(value).equals(bytes))
+  if (!domainCanonicalBytes(value).equals(bytes))
     fault("stage-capsule-corrupt", "$/store", "stored JSON is not canonical");
   return value;
 }
@@ -126,7 +126,7 @@ function normalizeBlobs(manifest, blobs) {
     if (
       !bytes ||
       bytes.length !== entry.size ||
-      v4StageCapsuleBlobRoot(bytes) !== entry.root
+      stageCapsuleBlobRoot(bytes) !== entry.root
     )
       fault(
         "stage-capsule-root-mismatch",
@@ -151,7 +151,7 @@ function statusForFault(code) {
     : "corrupt";
 }
 
-export class V4StageCapsuleLocalStore {
+export class StageCapsuleLocalStore {
   constructor(rootDirectory, { locatorRoot } = {}) {
     if (typeof rootDirectory !== "string" || rootDirectory.length === 0)
       fault(
@@ -162,15 +162,15 @@ export class V4StageCapsuleLocalStore {
     this.rootDirectory = path.resolve(rootDirectory);
     this.locatorRoot =
       locatorRoot ??
-      v4ContentRoot("stage-capsule-transport", {
+      domainContentRoot("stage-capsule-transport", {
         provider: "local-filesystem",
         mode: "local-reference",
       });
-    validateV4Root(this.locatorRoot, "$/locatorRoot");
+    validateRoot(this.locatorRoot, "$/locatorRoot");
   }
 
   transport(observedAt) {
-    return createV4StageCapsuleTransport({
+    return createStageCapsuleTransport({
       provider: "local-filesystem",
       mode: "local-reference",
       locatorRoot: this.locatorRoot,
@@ -195,9 +195,9 @@ export class V4StageCapsuleLocalStore {
   }
 
   put({ capsule, manifest, blobs, recordedAt }) {
-    validateV4StageCapsule(capsule);
-    validateV4StageCapsuleOutputManifest(manifest);
-    validateV4Clock(recordedAt, "$/recordedAt");
+    validateStageCapsule(capsule);
+    validateStageCapsuleOutputManifest(manifest);
+    validateClock(recordedAt, "$/recordedAt");
     if (manifest.manifestRoot !== capsule.identity.outputManifestRoot)
       fault(
         "stage-capsule-root-mismatch",
@@ -205,7 +205,7 @@ export class V4StageCapsuleLocalStore {
         "capsule does not bind the stored manifest",
       );
     const content = normalizeBlobs(manifest, blobs);
-    const retention = createV4StageCapsuleRetentionState({
+    const retention = createStageCapsuleRetentionState({
       capsule,
       evaluatedAt: recordedAt,
     });
@@ -219,19 +219,21 @@ export class V4StageCapsuleLocalStore {
           entry.bytes,
         ) || wrote;
     const files = this.paths(capsule.capsuleRoot, manifest.manifestRoot);
-    wrote = immutableWrite(files.manifest, v4CanonicalBytes(manifest)) || wrote;
-    wrote = immutableWrite(files.capsule, v4CanonicalBytes(capsule)) || wrote;
+    wrote =
+      immutableWrite(files.manifest, domainCanonicalBytes(manifest)) || wrote;
+    wrote =
+      immutableWrite(files.capsule, domainCanonicalBytes(capsule)) || wrote;
     const record = {
       schema: "buildchain-v4-stage-capsule-store-record/v1",
       capsuleRoot: capsule.capsuleRoot,
       manifestRoot: manifest.manifestRoot,
     };
-    wrote = immutableWrite(files.record, v4CanonicalBytes(record)) || wrote;
+    wrote = immutableWrite(files.record, domainCanonicalBytes(record)) || wrote;
     const located = this.locate({
       capsuleRoot: capsule.capsuleRoot,
       recordedAt,
     });
-    return createV4StageCapsuleStoreReceipt({
+    return createStageCapsuleStoreReceipt({
       ...located.receipt,
       operation: "put",
       outcome: wrote ? "stored" : "already-stored",
@@ -240,8 +242,8 @@ export class V4StageCapsuleLocalStore {
   }
 
   verifyStored(capsuleRoot, evaluatedAt, { skipQuarantine = false } = {}) {
-    validateV4Root(capsuleRoot, "$/capsuleRoot");
-    validateV4Clock(evaluatedAt, "$/evaluatedAt");
+    validateRoot(capsuleRoot, "$/capsuleRoot");
+    validateClock(evaluatedAt, "$/evaluatedAt");
     const base = this.paths(capsuleRoot);
     if (!skipQuarantine && fs.existsSync(base.quarantine))
       fault("stage-capsule-quarantined", "$/store", "capsule is quarantined");
@@ -252,10 +254,10 @@ export class V4StageCapsuleLocalStore {
       record.capsuleRoot !== capsuleRoot
     )
       fault("stage-capsule-root-mismatch", "$/record", "record root mismatch");
-    validateV4Root(record.manifestRoot, "$/record/manifestRoot");
+    validateRoot(record.manifestRoot, "$/record/manifestRoot");
     const files = this.paths(capsuleRoot, record.manifestRoot);
     const capsule = readCanonicalJson(files.capsule, "stage-capsule-partial");
-    validateV4StageCapsule(capsule);
+    validateStageCapsule(capsule);
     if (capsule.capsuleRoot !== capsuleRoot)
       fault(
         "stage-capsule-root-mismatch",
@@ -263,7 +265,7 @@ export class V4StageCapsuleLocalStore {
         "stored capsule root mismatch",
       );
     const manifest = readCanonicalJson(files.manifest, "stage-capsule-partial");
-    validateV4StageCapsuleOutputManifest(manifest);
+    validateStageCapsuleOutputManifest(manifest);
     if (
       manifest.manifestRoot !== record.manifestRoot ||
       manifest.manifestRoot !== capsule.identity.outputManifestRoot
@@ -273,7 +275,7 @@ export class V4StageCapsuleLocalStore {
         "$/manifest/manifestRoot",
         "stored manifest root mismatch",
       );
-    const retention = createV4StageCapsuleRetentionState({
+    const retention = createStageCapsuleRetentionState({
       capsule,
       evaluatedAt,
     });
@@ -286,7 +288,7 @@ export class V4StageCapsuleLocalStore {
       );
       if (
         bytes.length !== entry.size ||
-        v4StageCapsuleBlobRoot(bytes) !== entry.root
+        stageCapsuleBlobRoot(bytes) !== entry.root
       )
         fault(
           "stage-capsule-corrupt",
@@ -305,8 +307,8 @@ export class V4StageCapsuleLocalStore {
       return {
         stored,
         transport,
-        availability: validateV4StageCapsuleAvailability({
-          schema: V4_STAGE_CAPSULE_AVAILABILITY_CONTRACT,
+        availability: validateStageCapsuleAvailability({
+          schema: STAGE_CAPSULE_AVAILABILITY_CONTRACT,
           capsuleRoot,
           observedAt,
           status: "available",
@@ -319,12 +321,12 @@ export class V4StageCapsuleLocalStore {
         }),
       };
     } catch (error) {
-      if (!(error instanceof V4ContractFault)) throw error;
+      if (!(error instanceof ContractFault)) throw error;
       return {
         stored: null,
         transport,
-        availability: validateV4StageCapsuleAvailability({
-          schema: V4_STAGE_CAPSULE_AVAILABILITY_CONTRACT,
+        availability: validateStageCapsuleAvailability({
+          schema: STAGE_CAPSULE_AVAILABILITY_CONTRACT,
           capsuleRoot,
           observedAt,
           status: statusForFault(error.code),
@@ -350,13 +352,13 @@ export class V4StageCapsuleLocalStore {
     const { stored, transport, availability } = observation;
     return {
       ...observation,
-      receipt: createV4StageCapsuleStoreReceipt({
+      receipt: createStageCapsuleStoreReceipt({
         operation: "locate",
         recordedAt,
         capsuleRoot,
         manifestRoot: stored.manifest.manifestRoot,
         retentionStateRoot: stored.retention.stateRoot,
-        availabilityRoot: v4StageCapsuleAvailabilityRoot(availability),
+        availabilityRoot: stageCapsuleAvailabilityRoot(availability),
         transportRoot: transport.transportRoot,
         qualificationRoot: stored.capsule.identity.qualificationRoot,
         outcome: "located",
@@ -372,7 +374,7 @@ export class V4StageCapsuleLocalStore {
       manifest: located.stored.manifest,
       blobs: located.stored.blobs,
       availability: located.availability,
-      receipt: createV4StageCapsuleStoreReceipt({
+      receipt: createStageCapsuleStoreReceipt({
         ...located.receipt,
         operation: "restore",
         outcome: "restored",
@@ -394,14 +396,14 @@ export class V4StageCapsuleLocalStore {
     };
     immutableWrite(
       this.paths(capsuleRoot).quarantine,
-      v4CanonicalBytes({
+      domainCanonicalBytes({
         ...markerBody,
-        markerRoot: v4ContentRoot("stage-capsule-quarantine", markerBody),
+        markerRoot: domainContentRoot("stage-capsule-quarantine", markerBody),
       }),
     );
     const transport = this.transport(recordedAt);
-    const availability = validateV4StageCapsuleAvailability({
-      schema: V4_STAGE_CAPSULE_AVAILABILITY_CONTRACT,
+    const availability = validateStageCapsuleAvailability({
+      schema: STAGE_CAPSULE_AVAILABILITY_CONTRACT,
       capsuleRoot,
       observedAt: recordedAt,
       status: "quarantined",
@@ -410,13 +412,13 @@ export class V4StageCapsuleLocalStore {
       transports: [{ name: "local-reference", root: transport.transportRoot }],
       faultCode: "stage-capsule-quarantined",
     });
-    return createV4StageCapsuleStoreReceipt({
+    return createStageCapsuleStoreReceipt({
       operation: "quarantine",
       recordedAt,
       capsuleRoot,
       manifestRoot: stored.manifest.manifestRoot,
       retentionStateRoot: stored.retention.stateRoot,
-      availabilityRoot: v4StageCapsuleAvailabilityRoot(availability),
+      availabilityRoot: stageCapsuleAvailabilityRoot(availability),
       transportRoot: transport.transportRoot,
       qualificationRoot: stored.capsule.identity.qualificationRoot,
       outcome: "quarantined",