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

package/packages/core/{v4-stage-capsule-qualification-campaign.js → stage-capsule-qualification-campaign.js}

@@ -2,23 +2,23 @@ import fs from "node:fs";
 import path from "node:path";
 
 import {
-  V4ContractFault,
-  v4CanonicalBytes,
-  v4ContentRoot,
-} from "./v4-canonical-contracts.js";
-import { emitV4PlatformStageCheckpoint } from "./v4-platform-stage-checkpoints.js";
-import { V4_STAGE_CAPSULE_QUALIFICATION_FAULTS } from "./v4-stage-capsule-qualification.js";
-import { planV4StageCapsuleResume } from "./v4-stage-capsule-resume-planner.js";
-import { v4StageCapsuleBlobRoot } from "./v4-stage-capsule-store.js";
+  ContractFault,
+  domainCanonicalBytes,
+  domainContentRoot,
+} from "./canonical-contracts.js";
+import { emitPlatformStageCheckpoint } from "./platform-stage-checkpoints.js";
+import { STAGE_CAPSULE_QUALIFICATION_FAULTS } from "./stage-capsule-qualification.js";
+import { planStageCapsuleResume } from "./stage-capsule-resume-planner.js";
+import { stageCapsuleBlobRoot } from "./stage-capsule-store.js";
 
-export const V4_STAGE_CAPSULE_CAMPAIGN_RECORDED_AT = "2026-08-08T00:00:00.000Z";
-export const V4_STAGE_CAPSULE_CAMPAIGN_STAGES = Object.freeze([
+export const STAGE_CAPSULE_CAMPAIGN_RECORDED_AT = "2026-08-08T00:00:00.000Z";
+export const STAGE_CAPSULE_CAMPAIGN_STAGES = Object.freeze([
   "install",
   "build",
   "verify",
   "package",
 ]);
-export const V4_STAGE_CAPSULE_CAMPAIGN_DEPENDENCIES = Object.freeze({
+export const STAGE_CAPSULE_CAMPAIGN_DEPENDENCIES = Object.freeze({
   install: [],
   build: ["install"],
   verify: ["build"],
@@ -39,18 +39,18 @@ const EXTERNAL_CONSUMER_EXCLUSIONS = Object.freeze({
 });
 
 function rootOf(label) {
-  return v4StageCapsuleBlobRoot(
+  return stageCapsuleBlobRoot(
     Buffer.isBuffer(label)
       ? label
       : typeof label === "string"
         ? Buffer.from(`${label}\n`, "utf8")
-        : v4CanonicalBytes(label),
+        : domainCanonicalBytes(label),
   );
 }
 
 function outputBytes(context, stageId, outputName) {
   const evidence = context.campaignProfile?.stageEvidence?.[stageId];
-  if (evidence) return v4CanonicalBytes(evidence);
+  if (evidence) return domainCanonicalBytes(evidence);
   return Buffer.from(
     `${context.consumer}:${context.consumerSourceRevision}:${context.platform}:${stageId}:${outputName}:qualified-bytes\n`,
     "utf8",
@@ -66,15 +66,14 @@ function inputRoot(context, stageId, name) {
     "verification-report": ["verify", "verification-report"],
     "package-archive": ["package", "package-archive"],
   }[name];
-  if (producer)
-    return v4StageCapsuleBlobRoot(outputBytes(context, ...producer));
+  if (producer) return stageCapsuleBlobRoot(outputBytes(context, ...producer));
   return rootOf(
     `${context.consumer}:${context.consumerSourceRevision}:${context.platform}:input:${name}`,
   );
 }
 
 function campaignFault(code, location, message) {
-  throw new V4ContractFault(code, location, message);
+  throw new ContractFault(code, location, message);
 }
 
 function readJson(file, label) {
@@ -157,7 +156,7 @@ function lifecycleStageEvidence({ stageId, manifest, summary, command }) {
   };
 }
 
-export function createV4StageCapsuleCampaignProfile(context) {
+export function createStageCapsuleCampaignProfile(context) {
   const loaded = context.lifecycleConfig;
   if (!loaded?.filePath || !loaded?.config)
     campaignFault(
@@ -226,11 +225,11 @@ export function createV4StageCapsuleCampaignProfile(context) {
     configRoot: rootOf(configBytes),
     sourceRevision: context.consumerSourceRevision,
   });
-  const installOutputRoot = v4StageCapsuleBlobRoot(
-    v4CanonicalBytes(stageEvidence.install),
+  const installOutputRoot = stageCapsuleBlobRoot(
+    domainCanonicalBytes(stageEvidence.install),
   );
   const buildOutputRoot = stageEvidence.build
-    ? v4StageCapsuleBlobRoot(v4CanonicalBytes(stageEvidence.build))
+    ? stageCapsuleBlobRoot(domainCanonicalBytes(stageEvidence.build))
     : installOutputRoot;
   const lifecycleDeclarations = stageNames.map((name) => ({
     name,
@@ -275,18 +274,18 @@ export function createV4StageCapsuleCampaignProfile(context) {
   };
 }
 
-export function v4StageCapsuleCampaignStages(context) {
-  return context.campaignProfile?.stages || V4_STAGE_CAPSULE_CAMPAIGN_STAGES;
+export function stageCapsuleCampaignStages(context) {
+  return context.campaignProfile?.stages || STAGE_CAPSULE_CAMPAIGN_STAGES;
 }
 
-export function v4StageCapsuleCampaignDependencies(context, stageId) {
+export function stageCapsuleCampaignDependencies(context, stageId) {
   return (
     context.campaignProfile?.dependencies?.[stageId] ||
-    V4_STAGE_CAPSULE_CAMPAIGN_DEPENDENCIES[stageId]
+    STAGE_CAPSULE_CAMPAIGN_DEPENDENCIES[stageId]
   );
 }
 
-export function createV4StageCapsuleCampaignCheckpointRequest(
+export function createStageCapsuleCampaignCheckpointRequest(
   context,
   stageId,
   store,
@@ -305,7 +304,7 @@ export function createV4StageCapsuleCampaignCheckpointRequest(
     platformId: context.platform,
     stageId,
     stageOutcome,
-    recordedAt: V4_STAGE_CAPSULE_CAMPAIGN_RECORDED_AT,
+    recordedAt: STAGE_CAPSULE_CAMPAIGN_RECORDED_AT,
     overheadMs: 0,
     inputs: Object.fromEntries(
       stage.inputs.map((name) => [name, inputRoot(context, stageId, name)]),
@@ -314,7 +313,7 @@ export function createV4StageCapsuleCampaignCheckpointRequest(
     productionOutputRoots: Object.fromEntries(
       Object.entries(outputs).map(([name, bytes]) => [
         name,
-        v4StageCapsuleBlobRoot(bytes),
+        stageCapsuleBlobRoot(bytes),
       ]),
     ),
     productionLifecycleResult: { outcome: stageOutcome, stage: stageId },
@@ -357,14 +356,14 @@ export function createV4StageCapsuleCampaignCheckpointRequest(
   };
 }
 
-export function emitV4StageCapsuleCampaignCheckpoint(
+export function emitStageCapsuleCampaignCheckpoint(
   context,
   stageId,
   store,
   stageOutcome = "success",
 ) {
-  return emitV4PlatformStageCheckpoint(
-    createV4StageCapsuleCampaignCheckpointRequest(
+  return emitPlatformStageCheckpoint(
+    createStageCapsuleCampaignCheckpointRequest(
       context,
       stageId,
       store,
@@ -373,7 +372,7 @@ export function emitV4StageCapsuleCampaignCheckpoint(
   );
 }
 
-export function v4StageCapsuleCampaignAggregateRoots(entries) {
+export function stageCapsuleCampaignAggregateRoots(entries) {
   const manifests = entries.map(({ stage, manifest }) => ({
     stage,
     manifestRoot: manifest.manifestRoot,
@@ -387,11 +386,11 @@ export function v4StageCapsuleCampaignAggregateRoots(entries) {
     })),
   );
   return {
-    artifactManifestRoot: v4ContentRoot(
+    artifactManifestRoot: domainContentRoot(
       "stage-capsule-artifact-manifest",
       manifests,
     ),
-    contentRoot: v4ContentRoot("stage-capsule-artifact-content", content),
+    contentRoot: domainContentRoot("stage-capsule-artifact-content", content),
   };
 }
 
@@ -479,9 +478,9 @@ function faultDefinitions() {
   };
 }
 
-export function runV4StageCapsuleFaultCampaign(baseRequest) {
+export function runStageCapsuleFaultCampaign(baseRequest) {
   const definitions = faultDefinitions();
-  return V4_STAGE_CAPSULE_QUALIFICATION_FAULTS.map((id) => {
+  return STAGE_CAPSULE_QUALIFICATION_FAULTS.map((id) => {
     const request = structuredClone(baseRequest);
     const faultNode =
       request.nodes.find(({ key }) => key === "build") ||
@@ -494,11 +493,11 @@ export function runV4StageCapsuleFaultCampaign(baseRequest) {
     let actual = "contract-fault";
     let reasonCode = "unknown-fault";
     try {
-      const decision = planV4StageCapsuleResume(request).decisions[0];
+      const decision = planStageCapsuleResume(request).decisions[0];
       actual = decision.decision;
       reasonCode = decision.reasonCode;
     } catch (error) {
-      if (!(error instanceof V4ContractFault)) throw error;
+      if (!(error instanceof ContractFault)) throw error;
       reasonCode = error.code;
     }
     return {

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

@@ -1,14 +1,14 @@
 import {
-  V4ContractFault,
-  v4ContentRoot,
-  validateV4Root,
-} from "./v4-canonical-contracts.js";
+  ContractFault,
+  domainContentRoot,
+  validateRoot,
+} from "./canonical-contracts.js";
 
-export const V4_STAGE_CAPSULE_PLATFORM_QUALIFICATION_CONTRACT =
+export const STAGE_CAPSULE_PLATFORM_QUALIFICATION_CONTRACT =
   "buildchain-v4-stage-capsule-platform-qualification/v1";
-export const V4_STAGE_CAPSULE_QUALIFICATION_CONTRACT =
+export const STAGE_CAPSULE_QUALIFICATION_CONTRACT =
   "buildchain-v4-stage-capsule-qualification/v1";
-export const V4_STAGE_CAPSULE_WAVE_RECONCILIATION_CONTRACT =
+export const STAGE_CAPSULE_WAVE_RECONCILIATION_CONTRACT =
   "buildchain-v4-stage-capsule-wave-reconciliation/v1";
 
 const PLATFORMS = ["linux-x64", "macos-arm64", "windows-x64"];
@@ -37,7 +37,7 @@ const TOKEN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u;
 const REVISION = /^[0-9a-f]{40}$/u;
 
 function fault(code, location, message) {
-  throw new V4ContractFault(code, location, message);
+  throw new ContractFault(code, location, message);
 }
 
 function object(value, location) {
@@ -94,7 +94,7 @@ function string(value, location) {
 
 function roots(value, names, location) {
   exactKeys(value, names, location);
-  for (const name of names) validateV4Root(value[name], `${location}/${name}`);
+  for (const name of names) validateRoot(value[name], `${location}/${name}`);
 }
 
 function validateFaults(entries, location) {
@@ -123,7 +123,7 @@ function validateFaults(entries, location) {
 
 function validateAuthorityAndRuns(value) {
   if (
-    value.schema !== V4_STAGE_CAPSULE_PLATFORM_QUALIFICATION_CONTRACT ||
+    value.schema !== STAGE_CAPSULE_PLATFORM_QUALIFICATION_CONTRACT ||
     value.mode !== "shadow-only" ||
     value.productionAuthority !== "v3" ||
     value.providerEffects !== false ||
@@ -163,7 +163,7 @@ function validateAuthorityAndRuns(value) {
         `$/processRuns/${index}`,
         "run order or outcome differs",
       );
-    validateV4Root(run.evidenceRoot, `$/processRuns/${index}/evidenceRoot`);
+    validateRoot(run.evidenceRoot, `$/processRuns/${index}/evidenceRoot`);
   }
 }
 
@@ -188,7 +188,7 @@ function validateBuildAndPlan(value) {
     ["planRoot", "requiredRestores", "requiredStages"],
     "$/resumePlan",
   );
-  validateV4Root(value.resumePlan.planRoot, "$/resumePlan/planRoot");
+  validateRoot(value.resumePlan.planRoot, "$/resumePlan/planRoot");
   for (const name of ["requiredRestores", "requiredStages"])
     if (
       !Array.isArray(value.resumePlan[name]) ||
@@ -252,7 +252,7 @@ function validateMetricsAndRollback(value) {
     );
 }
 
-export function validateV4StageCapsulePlatformQualification(value) {
+export function validateStageCapsulePlatformQualification(value) {
   exactKeys(
     value,
     [
@@ -277,13 +277,13 @@ export function validateV4StageCapsulePlatformQualification(value) {
     "$",
   );
   validateAuthorityAndRuns(value);
-  validateV4Root(value.campaignProfileRoot, "$/campaignProfileRoot");
+  validateRoot(value.campaignProfileRoot, "$/campaignProfileRoot");
   validateBuildAndPlan(value);
   validateFaults(value.faultCampaign, "$/faultCampaign");
   validateMetricsAndRollback(value);
   const payload = structuredClone(value);
   delete payload.reportRoot;
-  const expectedRoot = v4ContentRoot(
+  const expectedRoot = domainContentRoot(
     "stage-capsule-platform-qualification",
     payload,
   );
@@ -296,7 +296,7 @@ export function validateV4StageCapsulePlatformQualification(value) {
   return value;
 }
 
-export function qualifyV4StageCapsuleCampaign(
+export function qualifyStageCapsuleCampaign(
   platformEvidence,
   expectedConsumers = CONSUMERS,
 ) {
@@ -323,7 +323,7 @@ export function qualifyV4StageCapsuleCampaign(
       "every expected consumer must qualify on all three platforms",
     );
   const evidence = platformEvidence.map((entry) =>
-    structuredClone(validateV4StageCapsulePlatformQualification(entry)),
+    structuredClone(validateStageCapsulePlatformQualification(entry)),
   );
   const expectedPairs = requiredConsumers.flatMap((consumer) =>
     PLATFORMS.map((platform) => `${consumer}/${platform}`),
@@ -349,7 +349,7 @@ export function qualifyV4StageCapsuleCampaign(
       "the exact expected consumer set is required",
     );
   const body = {
-    schema: V4_STAGE_CAPSULE_QUALIFICATION_CONTRACT,
+    schema: STAGE_CAPSULE_QUALIFICATION_CONTRACT,
     mode: "shadow-only",
     productionAuthority: "v3",
     platforms: evidence.map(({ platform, reportRoot }) => ({
@@ -370,23 +370,23 @@ export function qualifyV4StageCapsuleCampaign(
   };
   return {
     ...body,
-    qualificationRoot: v4ContentRoot("stage-capsule-qualification", body),
+    qualificationRoot: domainContentRoot("stage-capsule-qualification", body),
   };
 }
 
-export function reconcileV4StageCapsuleWave(request) {
+export function reconcileStageCapsuleWave(request) {
   exactKeys(
     request,
     ["schema", "qualificationRoot", "protectedDeliveryDrained", "children"],
     "$",
   );
-  if (request.schema !== V4_STAGE_CAPSULE_WAVE_RECONCILIATION_CONTRACT)
+  if (request.schema !== STAGE_CAPSULE_WAVE_RECONCILIATION_CONTRACT)
     fault(
       "unsupported-stage-capsule-wave-reconciliation",
       "$/schema",
       "unsupported reconciliation contract",
     );
-  validateV4Root(request.qualificationRoot, "$/qualificationRoot");
+  validateRoot(request.qualificationRoot, "$/qualificationRoot");
   if (request.protectedDeliveryDrained !== true)
     fault(
       "stage-capsule-protected-delivery-not-drained",
@@ -428,10 +428,10 @@ export function reconcileV4StageCapsuleWave(request) {
         "child identity or terminal delivery is incomplete",
       );
     for (const name of ["nativeGateRoot", "reviewRoot", "warrantRoot"])
-      validateV4Root(child[name], `$/children/${index}/${name}`);
+      validateRoot(child[name], `$/children/${index}/${name}`);
   }
   const body = {
-    schema: V4_STAGE_CAPSULE_WAVE_RECONCILIATION_CONTRACT,
+    schema: STAGE_CAPSULE_WAVE_RECONCILIATION_CONTRACT,
     wave: 2,
     qualificationRoot: request.qualificationRoot,
     protectedDeliveryDrained: true,
@@ -443,14 +443,13 @@ export function reconcileV4StageCapsuleWave(request) {
   };
   return {
     ...body,
-    reconciliationRoot: v4ContentRoot(
+    reconciliationRoot: domainContentRoot(
       "stage-capsule-wave-reconciliation",
       body,
     ),
   };
 }
 
-export const V4_STAGE_CAPSULE_QUALIFICATION_PLATFORMS =
-  Object.freeze(PLATFORMS);
-export const V4_STAGE_CAPSULE_QUALIFICATION_FAULTS = Object.freeze(FAULTS);
-export const V4_STAGE_CAPSULE_WAVE_CHILDREN = Object.freeze(CHILDREN);
+export const STAGE_CAPSULE_QUALIFICATION_PLATFORMS = Object.freeze(PLATFORMS);
+export const STAGE_CAPSULE_QUALIFICATION_FAULTS = Object.freeze(FAULTS);
+export const STAGE_CAPSULE_WAVE_CHILDREN = Object.freeze(CHILDREN);

package/packages/core/{v4-stage-capsule-resume-planner.js → stage-capsule-resume-planner.js}

@@ -1,27 +1,27 @@
 import {
-  V4ContractFault,
-  v4ContentRoot,
-  validateV4Clock,
-  validateV4Root,
-} from "./v4-canonical-contracts.js";
+  ContractFault,
+  domainContentRoot,
+  validateClock,
+  validateRoot,
+} from "./canonical-contracts.js";
 import {
-  V4_STAGE_CAPSULE_REUSE_CONTRACT,
-  evaluateV4StageCapsuleReuse,
-  v4StageCapsuleAvailabilityRoot,
-  validateV4StageCapsule,
-  validateV4StageCapsuleAvailability,
-  validateV4StageCapsuleIdentity,
-} from "./v4-stage-capsule.js";
+  STAGE_CAPSULE_REUSE_CONTRACT,
+  evaluateStageCapsuleReuse,
+  stageCapsuleAvailabilityRoot,
+  validateStageCapsule,
+  validateStageCapsuleAvailability,
+  validateStageCapsuleIdentity,
+} from "./stage-capsule.js";
 
-export const V4_STAGE_CAPSULE_RESUME_REQUEST_CONTRACT =
+export const STAGE_CAPSULE_RESUME_REQUEST_CONTRACT =
   "buildchain-v4-stage-capsule-resume-request/v1";
-export const V4_STAGE_CAPSULE_RESUME_PLAN_CONTRACT =
+export const STAGE_CAPSULE_RESUME_PLAN_CONTRACT =
   "buildchain-v4-stage-capsule-resume-plan/v1";
 
 const TOKEN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u;
 
 function fault(code, path, message) {
-  throw new V4ContractFault(code, path, message);
+  throw new ContractFault(code, path, message);
 }
 
 function exactKeys(value, expected, location) {
@@ -68,16 +68,16 @@ function orderedTokens(values, location) {
 function validateRetentionPromise(value, location) {
   exactKeys(value, ["class", "retainUntil"], location);
   token(value.class, `${location}/class`);
-  validateV4Clock(value.retainUntil, `${location}/retainUntil`);
+  validateClock(value.retainUntil, `${location}/retainUntil`);
 }
 
 function observationRoot(value) {
-  return v4ContentRoot("stage-capsule-resume-observation", value);
+  return domainContentRoot("stage-capsule-resume-observation", value);
 }
 
 function rootOrObservationRoot(value) {
   try {
-    validateV4Root(value, "$/resumeObservation");
+    validateRoot(value, "$/resumeObservation");
     return value;
   } catch {
     return observationRoot(value);
@@ -103,7 +103,7 @@ function validateRequest(request) {
     "$",
   );
   if (
-    request.schema !== V4_STAGE_CAPSULE_RESUME_REQUEST_CONTRACT ||
+    request.schema !== STAGE_CAPSULE_RESUME_REQUEST_CONTRACT ||
     !Array.isArray(request.nodes) ||
     request.nodes.length === 0
   )
@@ -112,7 +112,7 @@ function validateRequest(request) {
       "$/schema",
       "unsupported or empty Stage Capsule resume request",
     );
-  validateV4Clock(request.evaluatedAt, "$/evaluatedAt");
+  validateClock(request.evaluatedAt, "$/evaluatedAt");
   const positions = new Map();
   for (const [index, node] of request.nodes.entries()) {
     const location = `$/nodes/${index}`;
@@ -147,7 +147,7 @@ function validateRequest(request) {
         `${location}/dependencies`,
         "dependencies must name an earlier node in topological order",
       );
-    validateV4StageCapsuleIdentity(node.expectedIdentity);
+    validateStageCapsuleIdentity(node.expectedIdentity);
     validateRetentionPromise(
       node.expectedRetentionPromise,
       `${location}/expectedRetentionPromise`,
@@ -158,8 +158,8 @@ function validateRequest(request) {
         ["capsule", "availability"],
         `${location}/candidate`,
       );
-      validateV4StageCapsule(node.candidate.capsule);
-      validateV4StageCapsuleAvailability(node.candidate.availability);
+      validateStageCapsule(node.candidate.capsule);
+      validateStageCapsuleAvailability(node.candidate.availability);
     }
   }
   orderedTokens(request.targets, "$/targets");
@@ -299,11 +299,11 @@ function changedDecision(node, candidate, availabilityRoot) {
 function candidateDecision(node, evaluatedAt) {
   if (node.candidate === null) return decision(node, "rebuild", "unavailable");
   const { capsule, availability } = node.candidate;
-  const availabilityRoot = v4StageCapsuleAvailabilityRoot(availability);
+  const availabilityRoot = stageCapsuleAvailabilityRoot(availability);
   const changed = changedDecision(node, node.candidate, availabilityRoot);
   if (changed) return changed;
-  const reuse = evaluateV4StageCapsuleReuse({
-    schema: V4_STAGE_CAPSULE_REUSE_CONTRACT,
+  const reuse = evaluateStageCapsuleReuse({
+    schema: STAGE_CAPSULE_REUSE_CONTRACT,
     capsule,
     availability,
     evaluatedAt,
@@ -355,7 +355,7 @@ function candidateDecision(node, evaluatedAt) {
   });
 }
 
-export function planV4StageCapsuleResume(request) {
+export function planStageCapsuleResume(request) {
   const positions = validateRequest(request);
   const decisions = request.nodes.map((node) =>
     candidateDecision(node, request.evaluatedAt),
@@ -381,7 +381,7 @@ export function planV4StageCapsuleResume(request) {
     )
     .map(({ key }) => key);
   const payload = {
-    schema: V4_STAGE_CAPSULE_RESUME_PLAN_CONTRACT,
+    schema: STAGE_CAPSULE_RESUME_PLAN_CONTRACT,
     mode: "shadow-only",
     productionAuthority: "v3",
     evaluatedAt: request.evaluatedAt,
@@ -392,6 +392,6 @@ export function planV4StageCapsuleResume(request) {
   };
   return {
     ...payload,
-    planRoot: v4ContentRoot("stage-capsule-resume-plan", payload),
+    planRoot: domainContentRoot("stage-capsule-resume-plan", payload),
   };
 }