@kungfu-tech/buildchain 4.0.1-alpha.3 → 4.0.1-alpha.31

package/packages/core/buildchain-contract.js

@@ -7,6 +7,15 @@ 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";
@@ -18,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);
@@ -796,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 = {
@@ -847,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,
@@ -854,6 +936,8 @@ export function createBuildchainContractLock({
         id: entry.id,
         kind: entry.kind,
         breakingDigest: entry.breakingDigest,
+        compatibilityProofRoots: entry.compatibilityProofRoots || [],
+        compatibilityFactRoots: entry.compatibilityFactRoots || [],
       })),
     },
   };
@@ -890,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 = "") {
@@ -1036,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;
+}

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

@@ -0,0 +1,164 @@
+import { semanticRoot } from "@kungfu-tech/kfd/scripts/self-conformance-contract.mjs";
+
+import {
+  resolvePublishedKfdAdopterCategoryProfiles,
+  verifyPublishedKfdAdopterCategoryInstance,
+} from "./kfd-adopter-category-driver.js";
+
+export const BUILDCHAIN_DELIVERY_INFRASTRUCTURE_ADOPTER_ID =
+  "kungfu-systems/buildchain";
+export const BUILDCHAIN_DELIVERY_INFRASTRUCTURE_PROFILE = Object.freeze({
+  id: "kfd.adopter-category/delivery-infrastructure",
+  version: "1.0.0",
+});
+
+const CATEGORY_INSTANCE_SCHEMA =
+  "https://kfd.libkungfu.dev/schemas/kfd-adopter-conformance/category-instance-manifest.schema.json";
+const CATEGORY_INSTANCE_CONTRACT = "kfd.adopter-category-instance-manifest/v1";
+const ROOT_PATTERN = /^sha256:[0-9a-f]{64}$/;
+const CLAIM_BOUNDARY = Object.freeze({
+  categoryConformanceIsDeclarationOnly: true,
+  evidenceTransfer: false,
+  runtimePermission: false,
+  releaseAuthorization: false,
+  independentCertification: false,
+  semanticAuthorityTransfer: false,
+});
+
+function exactEvidenceReference(value, index) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new TypeError(`evidence[${index}] must be an object`);
+  }
+  const fields = ["requirementId", "kind", "coordinate", "root", "observedAt"];
+  const actual = Object.keys(value).sort();
+  const expected = [...fields].sort();
+  if (
+    actual.length !== expected.length ||
+    actual.some((field, fieldIndex) => field !== expected[fieldIndex])
+  ) {
+    throw new TypeError(`evidence[${index}] has an invalid field set`);
+  }
+  for (const field of ["requirementId", "kind", "coordinate", "observedAt"]) {
+    if (typeof value[field] !== "string" || value[field].length === 0) {
+      throw new TypeError(`evidence[${index}].${field} must be non-empty`);
+    }
+  }
+  if (!ROOT_PATTERN.test(value.root ?? "")) {
+    throw new TypeError(`evidence[${index}].root must be a sha256 root`);
+  }
+  return structuredClone(value);
+}
+
+function releaseBound(adopterManifest, artifact, release) {
+  return (adopterManifest?.releaseBindings ?? []).some(
+    (binding) =>
+      semanticRoot(binding.artifact) === semanticRoot(artifact) &&
+      semanticRoot(binding.releasePassport) === semanticRoot(release) &&
+      binding.kfdPackageRoot === adopterManifest.kfdCut.package.artifactRoot,
+  );
+}
+
+export function createBuildchainDeliveryInfrastructureInstanceManifest({
+  instanceId,
+  adopterManifest,
+  source,
+  artifact,
+  release,
+  evidence = [],
+} = {}) {
+  if (typeof instanceId !== "string" || instanceId.length === 0) {
+    throw new TypeError("instanceId must be non-empty");
+  }
+  if (
+    adopterManifest?.adopter?.id !==
+    BUILDCHAIN_DELIVERY_INFRASTRUCTURE_ADOPTER_ID
+  ) {
+    throw new TypeError(
+      `adopterManifest must identify ${BUILDCHAIN_DELIVERY_INFRASTRUCTURE_ADOPTER_ID}`,
+    );
+  }
+  if (!releaseBound(adopterManifest, artifact, release)) {
+    throw new TypeError(
+      "adopterManifest must bind the exact Buildchain artifact and release",
+    );
+  }
+
+  const selection = {
+    schemaVersion: 1,
+    contract: "kfd.adopter-category-profile-selection/v1",
+    profiles: [structuredClone(BUILDCHAIN_DELIVERY_INFRASTRUCTURE_PROFILE)],
+  };
+  const resolution = resolvePublishedKfdAdopterCategoryProfiles(selection);
+  if (!resolution.valid) {
+    throw new Error(
+      `published delivery-infrastructure profile did not resolve: ${JSON.stringify(resolution.issues)}`,
+    );
+  }
+
+  const project = {
+    adopterId: BUILDCHAIN_DELIVERY_INFRASTRUCTURE_ADOPTER_ID,
+    source: structuredClone(source),
+    artifact: structuredClone(artifact),
+    release: structuredClone(release),
+  };
+  const projectRoot = semanticRoot(project);
+  const adopterManifestRoot = semanticRoot(adopterManifest);
+  const packageRoot = adopterManifest.kfdCut.package.artifactRoot;
+  const requirementIds = new Set(
+    resolution.requirements.map((requirement) => requirement.id),
+  );
+  const suppliedEvidence = evidence.map(exactEvidenceReference);
+  for (const [index, entry] of suppliedEvidence.entries()) {
+    if (!requirementIds.has(entry.requirementId)) {
+      throw new TypeError(
+        `evidence[${index}].requirementId is not selected by the published profile`,
+      );
+    }
+  }
+
+  return {
+    $schema: CATEGORY_INSTANCE_SCHEMA,
+    schemaVersion: 1,
+    contract: CATEGORY_INSTANCE_CONTRACT,
+    instanceId,
+    rootAlgorithm: "sha256-kfd-canonical-json-v1",
+    project,
+    adopterManifest: {
+      contract: adopterManifest.contract,
+      manifestId: adopterManifest.manifestId,
+      root: adopterManifestRoot,
+    },
+    kfdCut: {
+      packageVersion: adopterManifest.kfdCut.package.version,
+      packageRoot,
+      categoryCatalogRoot: resolution.catalogRoot,
+    },
+    selection,
+    selectionRoot: resolution.selectionRoot,
+    requirements: resolution.requirements.map((requirement) => ({
+      id: requirement.id,
+      evidence: suppliedEvidence
+        .filter((entry) => entry.requirementId === requirement.id)
+        .map(({ requirementId: _requirementId, ...entry }) => ({
+          ...entry,
+          projectInstanceId: instanceId,
+          projectRoot,
+          adopterManifestRoot,
+          kfdPackageRoot: packageRoot,
+          categorySelectionRoot: resolution.selectionRoot,
+        })),
+    })),
+    claimBoundary: structuredClone(CLAIM_BOUNDARY),
+  };
+}
+
+export function verifyBuildchainDeliveryInfrastructureInstance(
+  manifest,
+  { adopterManifest, verifiedAt, maxAgeSeconds } = {},
+) {
+  return verifyPublishedKfdAdopterCategoryInstance(manifest, {
+    adopterManifest,
+    verifiedAt,
+    maxAgeSeconds,
+  });
+}