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

package/packages/core/publication-development.js

@@ -0,0 +1,72 @@
+import { nextDevelopmentRoot } from "./next-development-transition.js";
+
+const VERSION =
+  /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-alpha\.(0|[1-9]\d*))?$/u;
+
+export function developmentVersionParts(version) {
+  const parts = VERSION.exec(version || "");
+  if (!parts) throw new Error("expected a stable or alpha semantic version");
+  return parts
+    .slice(1)
+    .map((part) => (part === undefined ? null : BigInt(part)));
+}
+
+export function compareDevelopmentVersions(left, right) {
+  const a = developmentVersionParts(left),
+    b = developmentVersionParts(right);
+  for (let i = 0; i < 4; i += 1) {
+    if (a[i] === b[i]) continue;
+    if (a[i] === null) return 1;
+    if (b[i] === null) return -1;
+    return a[i] < b[i] ? -1 : 1;
+  }
+  return 0;
+}
+
+export function nextPatchDevelopmentVersion(stableVersion) {
+  const [major, minor, patch, alpha] = developmentVersionParts(stableVersion);
+  if (alpha !== null)
+    throw new Error("completed stable version must not be a prerelease");
+  return `${major}.${minor}.${patch + 1n}-alpha.0`;
+}
+
+export function createStableDevelopmentTransition({
+  repository,
+  completedStable,
+  model,
+  sourcePaths,
+  derivedPaths,
+}) {
+  const value = completedStable || {};
+  const version = nextPatchDevelopmentVersion(value.version);
+  if (
+    !/^[^/\s]+\/[^/\s]+$/u.test(repository || "") ||
+    value.outcome !== "succeeded" ||
+    value.exactTag !== `v${value.version}` ||
+    ![value.releaseSha, value.treeSha].every((sha) =>
+      /^[a-f0-9]{40}$/u.test(sha || ""),
+    ) ||
+    !/^sha256:[a-f0-9]{64}$/u.test(value.publicationRoot || "") ||
+    !Number.isFinite(Date.parse(value.completedAt))
+  )
+    throw new Error(
+      "stable development requires an exact completed publication",
+    );
+  if (model.strategy !== "semver" || model.next !== "auto")
+    throw new Error("automatic next-patch development requires semver/auto");
+  const identity = {
+    contract: "buildchain.stable-development-transition/v1",
+    repository,
+    completedStable: value,
+    model,
+    sourcePaths,
+    derivedPaths,
+  };
+  return {
+    ...identity,
+    idempotencyKey: nextDevelopmentRoot(identity),
+    target: { version },
+    state: { status: "planned" },
+    publicationOutcome: "preserved-success",
+  };
+}

package/packages/core/{v4-publication-qualification.js → publication-qualification.js}

@@ -1,6 +1,6 @@
 import crypto from "node:crypto";
 
-export const V4_PUBLICATION_QUALIFICATION_SCHEMA =
+export const PUBLICATION_QUALIFICATION_SCHEMA =
   "kungfu.buildchain.v4-publication-qualification/v1";
 
 const ROOT = /^sha256:[0-9a-f]{64}$/u;
@@ -16,16 +16,16 @@ const FORBIDDEN_EXECUTION_KEYS = new Set([
   "shell",
 ]);
 
-export class V4PublicationQualificationError extends Error {
+export class PublicationQualificationError extends Error {
   constructor(code, message) {
     super(message);
-    this.name = "V4PublicationQualificationError";
+    this.name = "PublicationQualificationError";
     this.code = code;
   }
 }
 
 function fail(code, message) {
-  throw new V4PublicationQualificationError(code, message);
+  throw new PublicationQualificationError(code, message);
 }
 
 function canonical(value) {
@@ -39,14 +39,14 @@ function canonical(value) {
   return JSON.stringify(value);
 }
 
-export function v4PublicationQualificationRoot(value) {
+export function domainPublicationQualificationRoot(value) {
   return `sha256:${crypto.createHash("sha256").update(canonical(value)).digest("hex")}`;
 }
 
-export function assertNoV4ExecutionFields(value, location = "$") {
+export function assertNoExecutionFields(value, location = "$") {
   if (Array.isArray(value)) {
     value.forEach((entry, index) =>
-      assertNoV4ExecutionFields(entry, `${location}[${index}]`),
+      assertNoExecutionFields(entry, `${location}[${index}]`),
     );
     return;
   }
@@ -58,7 +58,7 @@ export function assertNoV4ExecutionFields(value, location = "$") {
         `v4 declarative publication forbids ${location}.${key}`,
       );
     }
-    assertNoV4ExecutionFields(entry, `${location}.${key}`);
+    assertNoExecutionFields(entry, `${location}.${key}`);
   }
 }
 
@@ -109,7 +109,7 @@ function normalizedArtifacts(artifacts) {
   return normalized;
 }
 
-export function createV4PublicationQualificationReceipt({
+export function createDomainPublicationQualificationReceipt({
   repository,
   candidateRoot,
   sourceSha,
@@ -120,7 +120,7 @@ export function createV4PublicationQualificationReceipt({
   expiresAt,
 }) {
   const body = {
-    schema: V4_PUBLICATION_QUALIFICATION_SCHEMA,
+    schema: PUBLICATION_QUALIFICATION_SCHEMA,
     repository: String(repository || ""),
     candidateRoot: exactRoot(candidateRoot, "candidateRoot"),
     sourceSha: exactSha(sourceSha, "sourceSha"),
@@ -140,16 +140,16 @@ export function createV4PublicationQualificationReceipt({
     expires <= issued
   )
     fail("schema-invalid", "qualification freshness interval is invalid");
-  assertNoV4ExecutionFields(body);
-  const artifactRoot = v4PublicationQualificationRoot(body.artifacts);
+  assertNoExecutionFields(body);
+  const artifactRoot = domainPublicationQualificationRoot(body.artifacts);
   const receipt = { ...body, artifactRoot };
   return {
     ...receipt,
-    receiptRoot: v4PublicationQualificationRoot(receipt),
+    receiptRoot: domainPublicationQualificationRoot(receipt),
   };
 }
 
-export function validateV4PublicationQualificationReceipt(
+export function validatePublicationQualificationReceipt(
   receipt,
   {
     repository,
@@ -163,8 +163,8 @@ export function validateV4PublicationQualificationReceipt(
 ) {
   if (!receipt)
     fail("qualification-missing", "qualification receipt is required");
-  assertNoV4ExecutionFields(receipt);
-  const recreated = createV4PublicationQualificationReceipt(receipt);
+  assertNoExecutionFields(receipt);
+  const recreated = createDomainPublicationQualificationReceipt(receipt);
   if (
     receipt.artifactRoot !== recreated.artifactRoot ||
     receipt.receiptRoot !== recreated.receiptRoot
@@ -204,7 +204,7 @@ export function validateV4PublicationQualificationReceipt(
   });
 }
 
-export function assertV4DeclarativePromotionInputs(inputs) {
+export function assertDeclarativePromotionInputs(inputs) {
   const forbidden = Object.entries(inputs || {}).filter(
     ([name, value]) =>
       name !== "dry-run" &&

package/packages/core/{v4-publication-rehearsal-capsule.js → publication-rehearsal-capsule.js}

@@ -7,7 +7,7 @@ import {
   validateReleaseTailTransaction,
 } from "./release-tail-provider-plane.js";
 import {
-  V4PublicationRehearsalFault,
+  PublicationRehearsalFault,
   publicationRehearsalByteSorted as byteSorted,
   publicationRehearsalExactKeys as exactKeys,
   publicationRehearsalFault as fault,
@@ -15,26 +15,26 @@ import {
   publicationRehearsalRoot as root,
   publicationRehearsalText as text,
   publicationRehearsalToken as token,
-  validateV4PublicationRehearsalProviderBindings,
-} from "./v4-publication-rehearsal-provider-bindings.js";
+  validatePublicationRehearsalProviderBindings,
+} from "./publication-rehearsal-provider-bindings.js";
 
 export {
-  V4PublicationRehearsalFault,
+  PublicationRehearsalFault,
   exactKeys as assertPublicationRehearsalExactKeys,
   fault as publicationRehearsalFault,
   root as publicationRehearsalRoot,
-  validateV4PublicationRehearsalProviderBindings,
+  validatePublicationRehearsalProviderBindings,
 };
 
-export const V4_PUBLICATION_REHEARSAL_CAPSULE_CONTRACT =
+export const DOMAIN_PUBLICATION_REHEARSAL_CAPSULE_CONTRACT =
   "buildchain-v4-publication-rehearsal-capsule/v1";
-export const V4_PUBLICATION_REHEARSAL_EVIDENCE_CONTRACT =
+export const DOMAIN_PUBLICATION_REHEARSAL_EVIDENCE_CONTRACT =
   "buildchain-v4-publication-rehearsal-evidence/v1";
-export const V4_PUBLICATION_REHEARSAL_AUTHORITY_CONTRACT =
+export const PUBLICATION_REHEARSAL_AUTHORITY_CONTRACT =
   "buildchain-v4-publication-rehearsal-authority/v1";
-export const V4_PUBLICATION_REHEARSAL_PROVIDER_POLICY_CONTRACT =
+export const PUBLICATION_REHEARSAL_PROVIDER_POLICY_CONTRACT =
   "buildchain-v4-publication-rehearsal-provider-policy/v1";
-export const V4_PUBLICATION_REHEARSAL_CORE_VERSION =
+export const PUBLICATION_REHEARSAL_CORE_VERSION =
   RELEASE_TAIL_TRANSACTION_POLICY;
 
 const ROOT = /^sha256:[0-9a-f]{64}$/u;
@@ -138,7 +138,7 @@ function normalizeCandidateInputs(value) {
         `$/${name}`,
         `${name} is not bound by the candidate inventory`,
       );
-  const providerBindings = validateV4PublicationRehearsalProviderBindings(
+  const providerBindings = validatePublicationRehearsalProviderBindings(
     value.providerBindings,
   );
   root(value.providerBindingsRoot, "$/providerBindingsRoot");
@@ -177,7 +177,7 @@ function normalizeProviderPolicy(value, declaration) {
     "$/providerPolicy",
   );
   if (
-    value.schema !== V4_PUBLICATION_REHEARSAL_PROVIDER_POLICY_CONTRACT ||
+    value.schema !== PUBLICATION_REHEARSAL_PROVIDER_POLICY_CONTRACT ||
     value.effectDefault !== "disabled"
   )
     fault(
@@ -295,10 +295,10 @@ function normalizeObservation(value, index, operationIds) {
   return structuredClone(value);
 }
 
-export function createV4PublicationRehearsalProviderPolicy(declarationInput) {
+export function createPublicationRehearsalProviderPolicy(declarationInput) {
   const declaration = parseReleaseTailDeclaration(declarationInput);
   const body = {
-    schema: V4_PUBLICATION_REHEARSAL_PROVIDER_POLICY_CONTRACT,
+    schema: PUBLICATION_REHEARSAL_PROVIDER_POLICY_CONTRACT,
     effectDefault: "disabled",
     allowedCapabilityIds: declaration.capabilities
       .map(({ id }) => id)
@@ -310,7 +310,7 @@ export function createV4PublicationRehearsalProviderPolicy(declarationInput) {
   return { ...body, root: releaseTailRoot(body) };
 }
 
-export function createV4PublicationRehearsalCapsule(input) {
+export function createDomainPublicationRehearsalCapsule(input) {
   const declaration = parseReleaseTailDeclaration(input.declaration);
   const transaction =
     input.transaction || createReleaseTailTransaction(declaration);
@@ -323,14 +323,14 @@ export function createV4PublicationRehearsalCapsule(input) {
   };
   const policy =
     input.providerPolicy ||
-    createV4PublicationRehearsalProviderPolicy(declaration);
+    createPublicationRehearsalProviderPolicy(declaration);
   const observations = structuredClone(input.expectedObservations || []);
-  const providerBindings = validateV4PublicationRehearsalProviderBindings(
+  const providerBindings = validatePublicationRehearsalProviderBindings(
     input.providerBindings,
   );
   const body = {
-    schema: V4_PUBLICATION_REHEARSAL_CAPSULE_CONTRACT,
-    coreVersion: V4_PUBLICATION_REHEARSAL_CORE_VERSION,
+    schema: DOMAIN_PUBLICATION_REHEARSAL_CAPSULE_CONTRACT,
+    coreVersion: PUBLICATION_REHEARSAL_CORE_VERSION,
     source: { ...source, root: sourceRoot(source) },
     candidate: { root: candidateRoot(files) },
     manifest: structuredClone(input.manifest),
@@ -346,13 +346,13 @@ export function createV4PublicationRehearsalCapsule(input) {
     transaction: structuredClone(transaction),
     files,
   };
-  return validateV4PublicationRehearsalCapsule({
+  return validatePublicationRehearsalCapsule({
     ...body,
     capsuleRoot: releaseTailRoot(body),
   });
 }
 
-export function validateV4PublicationRehearsalCapsule(value) {
+export function validatePublicationRehearsalCapsule(value) {
   exactKeys(
     value,
     [
@@ -374,8 +374,8 @@ export function validateV4PublicationRehearsalCapsule(value) {
     "$",
   );
   if (
-    value.schema !== V4_PUBLICATION_REHEARSAL_CAPSULE_CONTRACT ||
-    value.coreVersion !== V4_PUBLICATION_REHEARSAL_CORE_VERSION
+    value.schema !== DOMAIN_PUBLICATION_REHEARSAL_CAPSULE_CONTRACT ||
+    value.coreVersion !== PUBLICATION_REHEARSAL_CORE_VERSION
   )
     fault(
       "unsupported-publication-rehearsal-core-version",

package/packages/core/publication-rehearsal-projection.js

@@ -6,9 +6,9 @@ import {
 } from "./publication-rehearsal-runtime.js";
 
 export const PUBLICATION_REHEARSAL_AGENT_SECTION_START =
-  "<!-- buildchain:publication-rehearsal:v4:start -->";
+  "<!-- buildchain:publication-rehearsal:start -->";
 export const PUBLICATION_REHEARSAL_AGENT_SECTION_END =
-  "<!-- buildchain:publication-rehearsal:v4:end -->";
+  "<!-- buildchain:publication-rehearsal:end -->";
 export const PUBLICATION_REHEARSAL_WORKFLOW_PATH =
   ".github/workflows/publication-rehearsal.yml";
 

package/packages/core/{v4-publication-rehearsal-provider-bindings.js → publication-rehearsal-provider-bindings.js}

@@ -1,14 +1,14 @@
-export class V4PublicationRehearsalFault extends Error {
+export class PublicationRehearsalFault extends Error {
   constructor(code, location, message) {
     super(`${location}: ${message}`);
-    this.name = "V4PublicationRehearsalFault";
+    this.name = "PublicationRehearsalFault";
     this.code = code;
     this.location = location;
   }
 }
 
 export function publicationRehearsalFault(code, location, message) {
-  throw new V4PublicationRehearsalFault(code, location, message);
+  throw new PublicationRehearsalFault(code, location, message);
 }
 
 export function publicationRehearsalExactKeys(value, expected, location) {
@@ -130,7 +130,7 @@ function canonicalObject(value, location, normalize) {
   );
 }
 
-export function validateV4PublicationRehearsalProviderBindings(value) {
+export function validatePublicationRehearsalProviderBindings(value) {
   publicationRehearsalExactKeys(
     value,
     ["schema", "artifacts", "documents", "evidence"],

package/packages/core/publication-rehearsal-runtime.js

@@ -3,18 +3,18 @@ import path from "node:path";
 
 import { releaseTailRoot } from "./release-tail-provider-plane.js";
 import {
-  V4_PUBLICATION_REHEARSAL_CAPSULE_CONTRACT,
-  V4_PUBLICATION_REHEARSAL_EVIDENCE_CONTRACT,
-  createV4PublicationRehearsalCapsule,
-  executeV4PublicationRehearsal,
-  validateV4PublicationRehearsalCapsule,
-  verifyV4PublicationRehearsalCapsule,
-} from "./v4-publication-rehearsal.js";
+  DOMAIN_PUBLICATION_REHEARSAL_CAPSULE_CONTRACT,
+  DOMAIN_PUBLICATION_REHEARSAL_EVIDENCE_CONTRACT,
+  createDomainPublicationRehearsalCapsule,
+  executeDomainPublicationRehearsal,
+  validatePublicationRehearsalCapsule,
+  verifyDomainPublicationRehearsalCapsule,
+} from "./publication-rehearsal.js";
 
 export const PUBLICATION_REHEARSAL_CAPSULE_CONTRACT =
-  V4_PUBLICATION_REHEARSAL_CAPSULE_CONTRACT;
+  DOMAIN_PUBLICATION_REHEARSAL_CAPSULE_CONTRACT;
 export const PUBLICATION_REHEARSAL_EVIDENCE_CONTRACT =
-  V4_PUBLICATION_REHEARSAL_EVIDENCE_CONTRACT;
+  DOMAIN_PUBLICATION_REHEARSAL_EVIDENCE_CONTRACT;
 export const PUBLICATION_REHEARSAL_DIAGNOSTIC_CONTRACT =
   "buildchain-v4-publication-rehearsal-compatibility-diagnostic/v1";
 export const RELEASE_LOCAL_CONSTRUCTIBILITY_ADR =
@@ -24,7 +24,7 @@ export const RELEASE_LOCAL_CONSTRUCTIBILITY_INVARIANT =
 export const PUBLICATION_REHEARSAL_COMMAND =
   'buildchain release-tail rehearse --capsule "$PWD/.buildchain/publication-rehearsal/capsule.json" --candidate-root "$PWD/.buildchain/publication-rehearsal/candidate" --mode simulate --state "$PWD/.buildchain/publication-rehearsal/state.json" --evidence "$PWD/.buildchain/publication-rehearsal/evidence.json"';
 
-const REQUIRED_V4_INPUTS = Object.freeze([
+const REQUIRED_INPUTS = Object.freeze([
   "source.repository",
   "source.revision",
   "manifest.path",
@@ -41,8 +41,8 @@ function migrationReceipt(surface, reasonCode) {
     reasonCode,
     replacement: {
       module: "@kungfu-tech/buildchain/v4-publication-rehearsal",
-      capsuleContract: V4_PUBLICATION_REHEARSAL_CAPSULE_CONTRACT,
-      requiredInputs: REQUIRED_V4_INPUTS,
+      capsuleContract: DOMAIN_PUBLICATION_REHEARSAL_CAPSULE_CONTRACT,
+      requiredInputs: REQUIRED_INPUTS,
     },
     productionAuthority: false,
   };
@@ -68,7 +68,7 @@ export class PublicationRehearsalError extends Error {
   }
 }
 
-function hasV4CreationBindings(input) {
+function hasCreationBindings(input) {
   return Boolean(
     input?.source?.repository &&
     input?.source?.revision &&
@@ -79,8 +79,8 @@ function hasV4CreationBindings(input) {
   );
 }
 
-function requireV4CreationBindings(input, surface) {
-  if (hasV4CreationBindings(input)) return;
+function requireCreationBindings(input, surface) {
+  if (hasCreationBindings(input)) return;
   const migration = migrationReceipt(surface, "v4-source-binding-required");
   throw new PublicationRehearsalError(
     "v3 rehearsal capsules cannot be upgraded implicitly; provide the v4 source, manifest, and config bindings",
@@ -89,15 +89,15 @@ function requireV4CreationBindings(input, surface) {
 }
 
 export function createPublicationRehearsalCapsule(input = {}) {
-  requireV4CreationBindings(
+  requireCreationBindings(
     input,
     "@kungfu-tech/buildchain/publication-rehearsal-runtime#createPublicationRehearsalCapsule",
   );
-  return createV4PublicationRehearsalCapsule(input);
+  return createDomainPublicationRehearsalCapsule(input);
 }
 
 export function normalizePublicationRehearsalCapsule(input) {
-  return validateV4PublicationRehearsalCapsule(input);
+  return validatePublicationRehearsalCapsule(input);
 }
 
 export function verifyPublicationRehearsalCapsule({
@@ -105,11 +105,11 @@ export function verifyPublicationRehearsalCapsule({
   capsuleRoot,
   candidateRoot = capsuleRoot,
 } = {}) {
-  return verifyV4PublicationRehearsalCapsule({ capsule, candidateRoot });
+  return verifyDomainPublicationRehearsalCapsule({ capsule, candidateRoot });
 }
 
 export function publicationRehearsalBindingRoot(capsule) {
-  return validateV4PublicationRehearsalCapsule(capsule).capsuleRoot;
+  return validatePublicationRehearsalCapsule(capsule).capsuleRoot;
 }
 
 export function publicationRehearsalDiagnostic(error, { capsule } = {}) {
@@ -156,7 +156,7 @@ export async function executePublicationRehearsal({
       { code: "undeclared-environment", classification: "input", migration },
     );
   }
-  return executeV4PublicationRehearsal({
+  return executeDomainPublicationRehearsal({
     capsule,
     candidateRoot,
     mode,

package/packages/core/{v4-publication-rehearsal.js → publication-rehearsal.js}

@@ -8,32 +8,32 @@ import {
   validateReleaseTailTransaction,
 } from "./release-tail-provider-plane.js";
 import {
-  V4_PUBLICATION_REHEARSAL_AUTHORITY_CONTRACT,
-  V4_PUBLICATION_REHEARSAL_CAPSULE_CONTRACT,
-  V4_PUBLICATION_REHEARSAL_CORE_VERSION,
-  V4_PUBLICATION_REHEARSAL_EVIDENCE_CONTRACT,
-  V4_PUBLICATION_REHEARSAL_PROVIDER_POLICY_CONTRACT,
-  V4PublicationRehearsalFault,
+  PUBLICATION_REHEARSAL_AUTHORITY_CONTRACT,
+  DOMAIN_PUBLICATION_REHEARSAL_CAPSULE_CONTRACT,
+  PUBLICATION_REHEARSAL_CORE_VERSION,
+  DOMAIN_PUBLICATION_REHEARSAL_EVIDENCE_CONTRACT,
+  PUBLICATION_REHEARSAL_PROVIDER_POLICY_CONTRACT,
+  PublicationRehearsalFault,
   assertPublicationRehearsalExactKeys as exactKeys,
-  createV4PublicationRehearsalCapsule,
-  createV4PublicationRehearsalProviderPolicy,
+  createDomainPublicationRehearsalCapsule,
+  createPublicationRehearsalProviderPolicy,
   publicationRehearsalFault as fault,
   publicationRehearsalRoot,
-  validateV4PublicationRehearsalCapsule,
-  validateV4PublicationRehearsalProviderBindings,
-} from "./v4-publication-rehearsal-capsule.js";
+  validatePublicationRehearsalCapsule,
+  validatePublicationRehearsalProviderBindings,
+} from "./publication-rehearsal-capsule.js";
 
 export {
-  V4_PUBLICATION_REHEARSAL_AUTHORITY_CONTRACT,
-  V4_PUBLICATION_REHEARSAL_CAPSULE_CONTRACT,
-  V4_PUBLICATION_REHEARSAL_CORE_VERSION,
-  V4_PUBLICATION_REHEARSAL_EVIDENCE_CONTRACT,
-  V4_PUBLICATION_REHEARSAL_PROVIDER_POLICY_CONTRACT,
-  V4PublicationRehearsalFault,
-  createV4PublicationRehearsalCapsule,
-  createV4PublicationRehearsalProviderPolicy,
-  validateV4PublicationRehearsalCapsule,
-  validateV4PublicationRehearsalProviderBindings,
+  PUBLICATION_REHEARSAL_AUTHORITY_CONTRACT,
+  DOMAIN_PUBLICATION_REHEARSAL_CAPSULE_CONTRACT,
+  PUBLICATION_REHEARSAL_CORE_VERSION,
+  DOMAIN_PUBLICATION_REHEARSAL_EVIDENCE_CONTRACT,
+  PUBLICATION_REHEARSAL_PROVIDER_POLICY_CONTRACT,
+  PublicationRehearsalFault,
+  createDomainPublicationRehearsalCapsule,
+  createPublicationRehearsalProviderPolicy,
+  validatePublicationRehearsalCapsule,
+  validatePublicationRehearsalProviderBindings,
 };
 
 const ROOT = /^sha256:[0-9a-f]{64}$/u;
@@ -118,11 +118,11 @@ function resolveCandidateOutput(candidateRootPath, relative, location) {
   return resolved;
 }
 
-export function verifyV4PublicationRehearsalCapsule({
+export function verifyDomainPublicationRehearsalCapsule({
   capsule,
   candidateRoot: candidateRootPath,
 }) {
-  const normalized = validateV4PublicationRehearsalCapsule(capsule);
+  const normalized = validatePublicationRehearsalCapsule(capsule);
   if (!path.isAbsolute(candidateRootPath || ""))
     fault(
       "publication-rehearsal-implicit-root-forbidden",
@@ -157,17 +157,17 @@ export function verifyV4PublicationRehearsalCapsule({
   return normalized;
 }
 
-export function resolveV4PublicationRehearsalProviderBindings({
+export function resolvePublicationRehearsalProviderBindings({
   capsule,
   candidateRoot: candidateRootPath,
   providerBindings = capsule?.providerBindings,
 }) {
-  const normalized = verifyV4PublicationRehearsalCapsule({
+  const normalized = verifyDomainPublicationRehearsalCapsule({
     capsule,
     candidateRoot: candidateRootPath,
   });
   const supplied =
-    validateV4PublicationRehearsalProviderBindings(providerBindings);
+    validatePublicationRehearsalProviderBindings(providerBindings);
   if (
     releaseTailRoot(supplied) !== normalized.providerBindingsRoot ||
     JSON.stringify(supplied) !== JSON.stringify(normalized.providerBindings)
@@ -347,13 +347,13 @@ function observationAdapters(capsule, transcript, adapters, mode) {
   );
 }
 
-export function createV4PublicationRehearsalAuthority(
+export function createPublicationRehearsalAuthority(
   capsule,
   { authorizationRoot } = {},
 ) {
-  const normalized = validateV4PublicationRehearsalCapsule(capsule);
+  const normalized = validatePublicationRehearsalCapsule(capsule);
   const body = {
-    schema: V4_PUBLICATION_REHEARSAL_AUTHORITY_CONTRACT,
+    schema: PUBLICATION_REHEARSAL_AUTHORITY_CONTRACT,
     mode: "provider-rehearsal",
     capsuleRoot: normalized.capsuleRoot,
     providerPolicyRoot: normalized.providerPolicy.root,
@@ -385,7 +385,7 @@ function validateAuthority(value, capsule) {
   const body = { ...value };
   delete body.authorityRoot;
   if (
-    value.schema !== V4_PUBLICATION_REHEARSAL_AUTHORITY_CONTRACT ||
+    value.schema !== PUBLICATION_REHEARSAL_AUTHORITY_CONTRACT ||
     value.mode !== "provider-rehearsal" ||
     value.productionAuthority !== false ||
     value.capsuleRoot !== capsule.capsuleRoot ||
@@ -402,7 +402,7 @@ function validateAuthority(value, capsule) {
   return structuredClone(value);
 }
 
-export async function executeV4PublicationRehearsal({
+export async function executeDomainPublicationRehearsal({
   capsule,
   candidateRoot: candidateRootPath,
   mode = "simulate",
@@ -417,7 +417,7 @@ export async function executeV4PublicationRehearsal({
       "$/mode",
       "simulate, replay, or provider required",
     );
-  const normalized = verifyV4PublicationRehearsalCapsule({
+  const normalized = verifyDomainPublicationRehearsalCapsule({
     capsule,
     candidateRoot: candidateRootPath,
   });
@@ -448,7 +448,7 @@ export async function executeV4PublicationRehearsal({
     checkpoint,
   });
   const body = {
-    schema: V4_PUBLICATION_REHEARSAL_EVIDENCE_CONTRACT,
+    schema: DOMAIN_PUBLICATION_REHEARSAL_EVIDENCE_CONTRACT,
     mode,
     truth:
       mode === "provider"