@kungfu-tech/buildchain 4.0.1-alpha.2 → 4.0.1-alpha.21

package/packages/core/buildchain-contract.js

@@ -7,8 +7,18 @@ import {
   normalizeBuildchainRef,
   parseBuildchainRefIdentity,
 } from "./buildchain-channel-identity.js";
+import {
+  createHistoricalBuildchainCompatibilityFacts,
+  createHistoricalBuildchainCompatibilityProofs,
+} from "./buildchain-compatibility-fact.js";
+import {
+  assertBuildchainCompatibilityProjection,
+  createBuildchainCompatibilityProofRegistry,
+} from "./buildchain-compatibility-authority.js";
+import { evaluateBuildchainContractLock as evaluateFactBackedBuildchainContractLock } from "./buildchain-compatibility-proof.js";
 import { createControllerRegistry } from "./controller-evidence.js";
 import { enumerateWorkflowInputs } from "./public-surface-audit.js";
+import { devDeliveryWorkflowContractSurface } from "./dev-delivery-contract-surface.js";
 
 export {
   BUILDCHAIN_CHANNELS,
@@ -17,11 +27,47 @@ export {
   parseBuildchainRefIdentity,
 };
 
+export {
+  BUILDCHAIN_COMPATIBILITY_FACT_REGISTRY_SCHEMA,
+  BUILDCHAIN_COMPATIBILITY_FACT_SCHEMA,
+  BUILDCHAIN_COMPATIBILITY_PROOF_REGISTRY_SCHEMA,
+  BUILDCHAIN_COMPATIBILITY_PROOF_SCHEMA,
+  BUILDCHAIN_COMPATIBILITY_RELEASE_EVIDENCE_SCHEMA,
+  createBuildchainCompatibilityFact,
+  createBuildchainCompatibilityFactRegistry,
+  createBuildchainCompatibilityProof,
+  createHistoricalBuildchainCompatibilityFacts,
+  createHistoricalBuildchainCompatibilityProofs,
+  verifyBuildchainCompatibilityFact,
+  verifyBuildchainCompatibilityFactRegistry,
+  verifyBuildchainCompatibilityProof,
+} from "./buildchain-compatibility-fact.js";
+export {
+  assertBuildchainCompatibilityProjection,
+  createBuildchainCompatibilityPathQuery,
+  createBuildchainCompatibilityProofRegistry,
+  createBuildchainCompatibilityReleaseEvidence,
+  resolveBuildchainCompatibilityProof,
+  verifyBuildchainCompatibilityPath,
+} from "./buildchain-compatibility-authority.js";
+export {
+  BUILDCHAIN_COMPATIBILITY_VERIFICATION_RECEIPT_SCHEMA,
+  BUILDCHAIN_LEGACY_COMPATIBILITY_VERIFICATION_RECEIPT_SCHEMA,
+  createBuildchainCompatibilityVerificationReceipt,
+  verifyBuildchainCompatibilityVerificationReceipt,
+} from "./buildchain-compatibility-proof.js";
+
 export const BUILDCHAIN_RUNTIME_CONTRACT_WORLD = "kungfu-buildchain-runtime-contract-world";
 export const BUILDCHAIN_CONTRACT_LOCK = "kungfu-buildchain-contract-lock";
 
 const DEFAULT_POLICY = "major-compatible";
-const FLOATING_CLASSES = new Set(["stable", "alpha"]);
+
+function compatibilityAuthority() {
+  return {
+    compatibilityFacts: createHistoricalBuildchainCompatibilityFacts(),
+    compatibilityProofs: createHistoricalBuildchainCompatibilityProofs(),
+  };
+}
 
 function optionalString(value) {
   return value === undefined || value === null ? "" : String(value);
@@ -125,8 +171,7 @@ export function createBuildchainContractWorld({
   packageJson = undefined,
   controllerRegistry = undefined,
 } = {}) {
-  const pkg = packageJson || readJson(path.join(root, "package.json"), {});
-  const majorLine = majorLineFromPackageVersion(pkg.version);
+  const pkg = packageJson || readJson(path.join(root, "package.json"), {}), majorLine = majorLineFromPackageVersion(pkg.version);
   const workflowDescriptors = controllerRegistry ? [] : enumerateWorkflowInputs({ root });
   const controllerWorkflowIds = new Set([
     "check",
@@ -217,6 +262,7 @@ export function createBuildchainContractWorld({
         "alpha and stable channel selections use separate consumer contract locks by default",
       ],
     }),
+    surface(root, devDeliveryWorkflowContractSurface(pkg, majorLine)),
     surface(root, {
       id: "release-candidate-promote",
       kind: "workflow",
@@ -795,26 +841,60 @@ export function createBuildchainContractWorld({
       version: pkg.version || "",
       repository: pkg.repository?.url || pkg.repository || "https://github.com/kungfu-systems/buildchain",
     },
-    majorLine,
-    compatibilityPolicy: DEFAULT_POLICY,
+    majorLine, compatibilityPolicy: DEFAULT_POLICY,
+    ...compatibilityAuthority(),
     surfaces,
   };
   return finalizeBuildchainContractWorld(base);
 }
 
 export function finalizeBuildchainContractWorld(contractWorld) {
+  if (!Array.isArray(contractWorld?.compatibilityFacts) || !Array.isArray(contractWorld?.compatibilityProofs)) {
+    throw new Error("contract world requires compatibility Facts and their proof projection");
+  }
+  const sourceSurfaces = (contractWorld.surfaces || []).map((entry) => ({ ...entry }));
+  const proofRegistry = createBuildchainCompatibilityProofRegistry({
+    proofs: contractWorld.compatibilityProofs,
+    surfaces: sourceSurfaces,
+    majorLine: contractWorld.majorLine,
+  });
+  if (JSON.stringify(contractWorld.compatibilityFacts) !== JSON.stringify(proofRegistry.facts)) {
+    throw new Error("contract world compatibility Facts drift from the verified registry");
+  }
   const world = {
     ...contractWorld,
-    surfaces: (contractWorld.surfaces || []).map((entry) => ({ ...entry })),
+    compatibilityFacts: proofRegistry.facts,
+    compatibilityFactRegistryRoot: proofRegistry.factRegistryRoot,
+    compatibilityFactCutRoot: proofRegistry.factCutRoot,
+    compatibilityProofs: proofRegistry.proofs,
+    compatibilityProofRegistryRoot: proofRegistry.registryRoot,
+    surfaces: sourceSurfaces.map((entry) => {
+      const surfaceEntry = { ...entry };
+      delete surfaceEntry.compatibleBreakingDigests;
+      delete surfaceEntry.compatibilityProofRoots;
+      delete surfaceEntry.compatibilityFactRoots;
+      const projection = proofRegistry.projections[entry.id] || [];
+      if (projection.length > 0) {
+        surfaceEntry.compatibleBreakingDigests = projection.map((item) => item.breakingDigest);
+        surfaceEntry.compatibilityProofRoots = projection.map((item) => item.proofRoot);
+        surfaceEntry.compatibilityFactRoots = projection.map((item) => item.factRoot);
+      }
+      return surfaceEntry;
+    }),
   };
   const compatibilityModel = {
     schemaVersion: world.schemaVersion,
     contract: world.contract,
     majorLine: world.majorLine,
+    compatibilityFactRegistryRoot: world.compatibilityFactRegistryRoot,
+    compatibilityFactCutRoot: world.compatibilityFactCutRoot,
+    compatibilityProofRegistryRoot: world.compatibilityProofRegistryRoot,
     surfaces: world.surfaces.map((entry) => ({
       id: entry.id,
       kind: entry.kind,
       breakingDigest: entry.breakingDigest,
+      compatibilityProofRoots: entry.compatibilityProofRoots || [],
+      compatibilityFactRoots: entry.compatibilityFactRoots || [],
     })),
   };
   const digestModel = {
@@ -846,6 +926,9 @@ export function createBuildchainContractLock({
       contract: contractWorld.contract,
       contractDigest: contractWorld.contractDigest,
       compatibilityDigest: contractWorld.compatibilityDigest,
+      compatibilityFactRegistryRoot: contractWorld.compatibilityFactRegistryRoot,
+      compatibilityFactCutRoot: contractWorld.compatibilityFactCutRoot,
+      compatibilityProofRegistryRoot: contractWorld.compatibilityProofRegistryRoot,
       majorLine: contractWorld.majorLine,
       compatibilityPolicy,
       acceptedAt,
@@ -853,6 +936,8 @@ export function createBuildchainContractLock({
         id: entry.id,
         kind: entry.kind,
         breakingDigest: entry.breakingDigest,
+        compatibilityProofRoots: entry.compatibilityProofRoots || [],
+        compatibilityFactRoots: entry.compatibilityFactRoots || [],
       })),
     },
   };
@@ -889,143 +974,8 @@ export function readBuildchainContractLock(filePath) {
   return value;
 }
 
-function surfaceMap(surfaces = []) {
-  return new Map(surfaces.map((entry) => [entry.id, entry]));
-}
-
-function evaluateChannelBinding({
-  lock,
-  workflowShellRef,
-  runtimeRef,
-  expectedChannel,
-  expectedMajor,
-  allowOpaqueRuntime,
-}) {
-  if (!workflowShellRef && !expectedChannel && !expectedMajor) return null;
-  return evaluateBuildchainChannelBinding({
-    workflowShellRef,
-    runtimeRef,
-    lockRef: lock?.buildchain?.ref || "",
-    lockMajorLine: lock?.buildchain?.majorLine || "",
-    expectedChannel,
-    expectedMajor,
-    allowOpaqueRuntime,
-  });
-}
-
-export function evaluateBuildchainContractLock({
-  lock,
-  current,
-  runtimeRef = "",
-  runtimeSha = "",
-  runtimeClass = "",
-  compatibilityPolicy = "",
-  workflowShellRef = "",
-  expectedChannel = "",
-  expectedMajor = "",
-  allowOpaqueRuntime = false,
-} = {}) {
-  if (!current || current.contract !== BUILDCHAIN_RUNTIME_CONTRACT_WORLD) {
-    throw new Error("current must be a Buildchain runtime contract world");
-  }
-  const binding = evaluateChannelBinding({
-    lock,
-    workflowShellRef,
-    runtimeRef,
-    expectedChannel,
-    expectedMajor,
-    allowOpaqueRuntime,
-  });
-  if (binding?.ok === false) {
-    return {
-      ok: false,
-      status: binding.status,
-      drift: false,
-      compatible: false,
-      issueRecommended: false,
-      reasons: binding.reasons,
-      channelBinding: binding,
-    };
-  }
-  const floatingRuntime = FLOATING_CLASSES.has(runtimeClass);
-  if (!floatingRuntime) {
-    return {
-      ok: true,
-      status: "non-floating-runtime",
-      drift: false,
-      compatible: true,
-      issueRecommended: false,
-      reason: `runtime class ${runtimeClass || "unknown"} is not a stable floating ref`,
-    };
-  }
-  if (!lock) {
-    return {
-      ok: true,
-      status: "missing-lock",
-      drift: false,
-      compatible: true,
-      issueRecommended: false,
-      reason: "consumer repository has no Buildchain contract lock",
-    };
-  }
-  const accepted = lock.buildchain || {};
-  const policy = compatibilityPolicy || accepted.compatibilityPolicy || DEFAULT_POLICY;
-  const shaDrift = !!accepted.resolvedSha && !!runtimeSha && accepted.resolvedSha !== runtimeSha;
-  const contractDrift = !!accepted.contractDigest && accepted.contractDigest !== current.contractDigest;
-  if (!shaDrift && !contractDrift) {
-    return {
-      ok: true,
-      status: "unchanged",
-      drift: false,
-      compatible: true,
-      issueRecommended: false,
-      policy,
-      accepted,
-      current: contractSummary(current, runtimeRef, runtimeSha),
-    };
-  }
-  const reasons = [];
-  if (accepted.contract !== current.contract) {
-    reasons.push(`contract changed from ${accepted.contract || "(unknown)"} to ${current.contract}`);
-  }
-  if (accepted.majorLine && accepted.majorLine !== current.majorLine) {
-    reasons.push(`major line changed from ${accepted.majorLine} to ${current.majorLine}`);
-  }
-  if (policy === "exact" && accepted.contractDigest !== current.contractDigest) {
-    reasons.push("exact policy requires the contract digest to remain unchanged");
-  }
-  if (!["major-compatible", "allow-additive", "exact"].includes(policy)) {
-    reasons.push(`unsupported compatibility policy: ${policy}`);
-  }
-  const currentSurfaces = surfaceMap(current.surfaces);
-  for (const oldSurface of accepted.surfaces || []) {
-    const nextSurface = currentSurfaces.get(oldSurface.id);
-    if (!nextSurface) {
-      reasons.push(`surface removed: ${oldSurface.id}`);
-      continue;
-    }
-    const compatibleBreakingDigests = new Set(nextSurface.compatibleBreakingDigests || []);
-    if (
-      nextSurface.breakingDigest !== oldSurface.breakingDigest
-      && !compatibleBreakingDigests.has(oldSurface.breakingDigest)
-    ) {
-      reasons.push(`surface breaking digest changed: ${oldSurface.id}`);
-    }
-  }
-  const compatible = reasons.length === 0;
-  return {
-    ok: compatible,
-    status: compatible ? "compatible-drift" : "breaking-drift",
-    drift: shaDrift || contractDrift,
-    shaDrift,
-    contractDrift,
-    compatible,
-    issueRecommended: true,
-    policy,
-    reasons,
-    accepted,
-    current: contractSummary(current, runtimeRef, runtimeSha),
-  };
+export function evaluateBuildchainContractLock(options = {}) {
+  return evaluateFactBackedBuildchainContractLock(options);
 }
 
 export function contractSummary(contractWorld, runtimeRef = "", runtimeSha = "") {
@@ -1035,6 +985,9 @@ export function contractSummary(contractWorld, runtimeRef = "", runtimeSha = "")
     contract: contractWorld.contract,
     contractDigest: contractWorld.contractDigest,
     compatibilityDigest: contractWorld.compatibilityDigest,
+    compatibilityFactRegistryRoot: contractWorld.compatibilityFactRegistryRoot,
+    compatibilityFactCutRoot: contractWorld.compatibilityFactCutRoot,
+    compatibilityProofRegistryRoot: contractWorld.compatibilityProofRegistryRoot,
     majorLine: contractWorld.majorLine,
     surfaceCount: Array.isArray(contractWorld.surfaces) ? contractWorld.surfaces.length : 0,
   };

package/packages/core/buildchain-delivery-bootstrap.js

@@ -0,0 +1,240 @@
+import { adopterDeliveryGateDigest } from "./adopter-delivery-gate.js";
+import { validateAdopterDeliveryGateResult } from "./adopter-delivery-passport.js";
+
+export const BUILDCHAIN_DELIVERY_BOOTSTRAP_CONTRACT =
+  "kungfu-buildchain-delivery-infrastructure-bootstrap/v1";
+
+const ROOT_PATTERN = /^sha256:[0-9a-f]{64}$/;
+const SHA_PATTERN = /^[0-9a-f]{40}$/;
+const SEMVER_PATTERN =
+  /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+
+function issue(code, message) {
+  return { code, message };
+}
+
+function exactRoot(value) {
+  return ROOT_PATTERN.test(value ?? "");
+}
+
+function exactCut(cut) {
+  return (
+    cut &&
+    typeof cut === "object" &&
+    typeof cut.version === "string" &&
+    SHA_PATTERN.test(cut.sourceCommit ?? "") &&
+    exactRoot(cut.packageRoot) &&
+    exactRoot(cut.gateRoot) &&
+    typeof cut.protocol?.id === "string" &&
+    typeof cut.protocol?.version === "string" &&
+    exactRoot(cut.protocol?.root) &&
+    typeof cut.profile?.id === "string" &&
+    typeof cut.profile?.version === "string" &&
+    exactRoot(cut.profile?.root)
+  );
+}
+
+function parseSemver(value) {
+  const match = SEMVER_PATTERN.exec(value ?? "");
+  if (!match) return null;
+  return {
+    core: match.slice(1, 4).map(Number),
+    prerelease: match[4] ? match[4].split(".") : [],
+  };
+}
+
+function compareIdentifier(left, right) {
+  const leftNumber = /^\d+$/.test(left) ? Number(left) : null;
+  const rightNumber = /^\d+$/.test(right) ? Number(right) : null;
+  if (leftNumber !== null && rightNumber !== null) {
+    return Math.sign(leftNumber - rightNumber);
+  }
+  if (leftNumber !== null) return -1;
+  if (rightNumber !== null) return 1;
+  return left === right ? 0 : left < right ? -1 : 1;
+}
+
+function compareSemver(leftValue, rightValue) {
+  const left = parseSemver(leftValue);
+  const right = parseSemver(rightValue);
+  if (!left || !right) return null;
+  for (let index = 0; index < left.core.length; index += 1) {
+    if (left.core[index] !== right.core[index]) {
+      return Math.sign(left.core[index] - right.core[index]);
+    }
+  }
+  if (left.prerelease.length === 0 || right.prerelease.length === 0) {
+    if (left.prerelease.length === right.prerelease.length) return 0;
+    return left.prerelease.length === 0 ? 1 : -1;
+  }
+  const width = Math.max(left.prerelease.length, right.prerelease.length);
+  for (let index = 0; index < width; index += 1) {
+    if (left.prerelease[index] === undefined) return -1;
+    if (right.prerelease[index] === undefined) return 1;
+    const comparison = compareIdentifier(
+      left.prerelease[index],
+      right.prerelease[index],
+    );
+    if (comparison !== 0) return comparison;
+  }
+  return 0;
+}
+
+function sameProtocol(left, right) {
+  return (
+    left?.id === right?.id &&
+    left?.version === right?.version &&
+    left?.root === right?.root
+  );
+}
+
+function validTransition(transition, authority, candidate) {
+  if (!transition || typeof transition !== "object") return false;
+  const body = structuredClone(transition);
+  const transitionRoot = body.transitionRoot;
+  delete body.transitionRoot;
+  return (
+    exactRoot(transitionRoot) &&
+    adopterDeliveryGateDigest(body) === transitionRoot &&
+    body.fromGateRoot === authority.gateRoot &&
+    body.toGateRoot === candidate.gateRoot &&
+    body.fromProtocolRoot === authority.protocol.root &&
+    body.toProtocolRoot === candidate.protocol.root &&
+    body.fromProfileRoot === authority.profile.root &&
+    body.toProfileRoot === candidate.profile.root &&
+    exactRoot(body.compatibilityProofRoot) &&
+    exactRoot(body.independentReviewRoot)
+  );
+}
+
+function validateWarrant(warrant, candidate) {
+  return (
+    warrant &&
+    typeof warrant === "object" &&
+    warrant.outcome === "merged" &&
+    warrant.sourceHead === candidate.sourceCommit &&
+    exactRoot(warrant.sourceProofRoot) &&
+    exactRoot(warrant.nativeProofRoot) &&
+    exactRoot(warrant.integrationProofRoot)
+  );
+}
+
+export function qualifyBuildchainDeliveryInfrastructureBootstrap({
+  authority,
+  candidate,
+  gateResult,
+  warrant,
+  transitionEvidence,
+} = {}) {
+  const issues = [];
+  if (!exactCut(authority)) {
+    issues.push(
+      issue("bootstrap.authority.cut", "N-1 authority cut is incomplete"),
+    );
+  }
+  if (!exactCut(candidate)) {
+    issues.push(
+      issue("bootstrap.candidate.cut", "candidate cut is incomplete"),
+    );
+  }
+  if (authority?.protected !== true || authority?.published !== true) {
+    issues.push(
+      issue(
+        "bootstrap.authority.release",
+        "N-1 authority must be both protected and publicly released",
+      ),
+    );
+  }
+  if (candidate?.authorityVersion !== authority?.version) {
+    issues.push(
+      issue(
+        "bootstrap.authority.stale",
+        "candidate must name the exact N-1 authority version",
+      ),
+    );
+  }
+  const versionOrder = compareSemver(authority?.version, candidate?.version);
+  if (versionOrder === null || versionOrder >= 0) {
+    issues.push(
+      issue(
+        "bootstrap.authority.order",
+        "N-1 authority version must precede the candidate version",
+      ),
+    );
+  }
+  if (
+    authority?.sourceCommit === candidate?.sourceCommit ||
+    authority?.packageRoot === candidate?.packageRoot
+  ) {
+    issues.push(
+      issue(
+        "bootstrap.self-authorization",
+        "candidate source or package cannot serve as its own N-1 authority",
+      ),
+    );
+  }
+
+  const gateValidation = validateAdopterDeliveryGateResult(gateResult);
+  if (!gateValidation.passed) {
+    issues.push(
+      issue(
+        "bootstrap.gate.failed",
+        "candidate must retain a passed public adopter delivery gate result",
+      ),
+    );
+  }
+  if (
+    gateResult?.artifact?.root !== candidate?.packageRoot ||
+    gateResult?.project?.adopterId !== "kungfu-systems/buildchain"
+  ) {
+    issues.push(
+      issue(
+        "bootstrap.gate.candidate",
+        "gate result must bind the exact Buildchain candidate package",
+      ),
+    );
+  }
+  if (!validateWarrant(warrant, candidate)) {
+    issues.push(
+      issue(
+        "bootstrap.warrant",
+        "merged Delivery Warrant evidence must bind the candidate source",
+      ),
+    );
+  }
+
+  const transitionRequired =
+    !sameProtocol(authority?.protocol, candidate?.protocol) ||
+    !sameProtocol(authority?.profile, candidate?.profile) ||
+    authority?.gateRoot !== candidate?.gateRoot;
+  if (
+    transitionRequired &&
+    !validTransition(transitionEvidence, authority, candidate)
+  ) {
+    issues.push(
+      issue(
+        "bootstrap.transition",
+        "gate, protocol, or profile changes require exact independent transition evidence",
+      ),
+    );
+  }
+
+  const result = {
+    schemaVersion: 1,
+    contract: BUILDCHAIN_DELIVERY_BOOTSTRAP_CONTRACT,
+    status: issues.length === 0 ? "passed" : "failed",
+    authority: structuredClone(authority ?? null),
+    candidate: structuredClone(candidate ?? null),
+    gateResultRoot: gateResult?.gateRoot ?? null,
+    warrant: structuredClone(warrant ?? null),
+    transitionRequired,
+    transitionEvidenceRoot: transitionEvidence?.transitionRoot ?? null,
+    issues,
+    qualifying: false,
+    selfCertified: false,
+    releaseAuthorized: false,
+    finalAuthority: "protected-n-minus-one-plus-exact-delivery-evidence",
+  };
+  result.bootstrapRoot = adopterDeliveryGateDigest(result);
+  return result;
+}