@kungfu-tech/buildchain 3.0.9-alpha.10 → 3.0.9-alpha.12

package/docs/release-passport.md

@@ -404,6 +404,16 @@ inspect `buildchain.release.json` and know whether the released package
 actually exposes no more and no less than the declared collaboration interface,
 instead of trusting docs or release notes.
 
+### Adopter delivery binding
+
+Pass a completed protocol-neutral adopter delivery gate result as JSON or a
+path with `--adopter-delivery-json`. The collector validates the rooted gate
+closure and writes the same non-qualifying `adopterDelivery` binding into both
+`buildchain.release.json` and `artifact-evidence.json`. Release verification
+fails closed if the product identity, artifact root, gate root, or either copy
+is substituted. Reusable promotion callers can forward the same value with
+`release-passport-adopter-delivery-json`.
+
 ### KFD support projection
 
 Pass the standard full-cut declaration with `--kfd-adopter-manifest-json`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kungfu-tech/buildchain",
-  "version": "3.0.9-alpha.10",
+  "version": "3.0.9-alpha.12",
   "private": false,
   "description": "Buildchain Release Passport, release governance, CLI toolkit, and site facts.",
   "repository": "https://github.com/kungfu-systems/buildchain",
@@ -39,6 +39,8 @@
     "./kfd-adopter-category-driver": "./packages/core/kfd-adopter-category-driver.js",
     "./buildchain-delivery-infrastructure": "./packages/core/buildchain-delivery-infrastructure.js",
     "./buildchain-delivery-bootstrap": "./packages/core/buildchain-delivery-bootstrap.js",
+    "./buildchain-delivery-self-dogfood": "./packages/core/buildchain-delivery-self-dogfood.js",
+    "./published-delivery-authority": "./packages/core/published-delivery-authority.js",
     "./legacy-kfd-adopter-driver": "./packages/core/legacy-kfd-adopter-driver.js",
     "./adopter-delivery-passport": "./packages/core/adopter-delivery-passport.js",
     "./adopter-delivery-vectors": "./packages/core/adopter-delivery-vectors.js",

package/packages/core/buildchain-compatibility-proof.js

@@ -132,6 +132,72 @@ const HISTORICAL_ACCEPTANCES = [
       commit: "34fad9d3a94c450d75c0d06fd6ed00470c992ff7",
     },
   },
+  {
+    proofId: "reusable-build-a6a353-to-dfbedd",
+    surfaceId: "reusable-build",
+    surfaceKind: "workflow",
+    sourceBreakingDigest: "sha256:a6a35370d6b0d0f46e1b2712dcc01961fe53c2febde95409a27a485c10a36650",
+    targetBreakingDigest: "sha256:dfbedd543ae0c067982b5c8c02d98dd2f7f7df88752be97fb330da6b0ba30faa",
+    evidence: {
+      kind: "protected-pull-request-contract-acceptance",
+      pullRequest: "https://github.com/kungfu-systems/buildchain/pull/2089",
+      protectedBase: "dev/v3/v3.0",
+      sourceCommit: "1a6cb874bc6f1611f3eef607e711d3532798e9e7",
+      mergeCommit: "71a75f21159b994241ec7cb2c50f7a150c5d440b",
+      contractDigest: "sha256:7c2a7c132a2b2722f70f148b81048147047d4d2c46cf33f7cd2dc158aec092e0",
+      compatibilityDigest: "sha256:61af7d0871220bc0909008bdc571905ad500cccf853e7841bc5d462a34b2d436",
+    },
+    cut: {
+      kind: "protected-git-cut",
+      repository: "kungfu-systems/buildchain",
+      protectedBase: "dev/v3/v3.0",
+      commit: "71a75f21159b994241ec7cb2c50f7a150c5d440b",
+    },
+  },
+  {
+    proofId: "web-surface-da569f-to-27f0cb",
+    surfaceId: "web-surface",
+    surfaceKind: "workflow",
+    sourceBreakingDigest: "sha256:da569f90374e878948e3d5160ed9929338ce0572473ca8ee54867b0fe1aaeace",
+    targetBreakingDigest: "sha256:27f0cb9c7d97288850d215be8696b323471c41fd1cdf3a2ff3ebf21f62541960",
+    evidence: {
+      kind: "protected-pull-request-contract-acceptance",
+      pullRequest: "https://github.com/kungfu-systems/buildchain/pull/2089",
+      protectedBase: "dev/v3/v3.0",
+      sourceCommit: "1a6cb874bc6f1611f3eef607e711d3532798e9e7",
+      mergeCommit: "71a75f21159b994241ec7cb2c50f7a150c5d440b",
+      contractDigest: "sha256:7c2a7c132a2b2722f70f148b81048147047d4d2c46cf33f7cd2dc158aec092e0",
+      compatibilityDigest: "sha256:61af7d0871220bc0909008bdc571905ad500cccf853e7841bc5d462a34b2d436",
+    },
+    cut: {
+      kind: "protected-git-cut",
+      repository: "kungfu-systems/buildchain",
+      protectedBase: "dev/v3/v3.0",
+      commit: "71a75f21159b994241ec7cb2c50f7a150c5d440b",
+    },
+  },
+  {
+    proofId: "release-propagation-d7a1f1-to-b873ce",
+    surfaceId: "controller:release-propagation",
+    surfaceKind: "controller",
+    sourceBreakingDigest: "sha256:d7a1f15990ce8bd13149474888232c7d4451dd2a49bebf4d4ce1336695da430e",
+    targetBreakingDigest: "sha256:b873ceb65618972bea615afcb9c616c138ce834b3246ec7237ef87c1618d68bd",
+    evidence: {
+      kind: "protected-pull-request-contract-acceptance",
+      pullRequest: "https://github.com/kungfu-systems/buildchain/pull/2143",
+      protectedBase: "dev/v3/v3.0",
+      sourceCommit: "b63aff4dd63ad6017b8f48e1c690f595a9c832a2",
+      mergeCommit: "487ee09ca4832ffd15607db00060df4c0839fbae",
+      contractDigest: "sha256:00c37f8a663387831ba4d066056d0b21d4f3c5f3ea5b0cf84456af332cf8d87e",
+      compatibilityDigest: "sha256:3bbcaf835844260ed98414d3bd176667245d12131e13fc748e4c2fae12399691",
+    },
+    cut: {
+      kind: "protected-git-cut",
+      repository: "kungfu-systems/buildchain",
+      protectedBase: "dev/v3/v3.0",
+      commit: "487ee09ca4832ffd15607db00060df4c0839fbae",
+    },
+  },
 ];
 
 function exactText(value, label) {

package/packages/core/buildchain-delivery-self-dogfood.js

@@ -0,0 +1,395 @@
+import { initAdopterManifest } from "@kungfu-tech/kfd/adopter-conformance/toolchain";
+
+import { adopterDeliveryGateDigest } from "./adopter-delivery-gate.js";
+import { withPublishedBuildchainDeliveryAuthority } from "./published-delivery-authority.js";
+
+export const BUILDCHAIN_DELIVERY_SELF_DOGFOOD_CONTRACT =
+  "kungfu-buildchain-delivery-infrastructure-self-dogfood/v1";
+
+const ROOT_PATTERN = /^sha256:[0-9a-f]{64}$/;
+const SHA_PATTERN = /^[0-9a-f]{40}$/;
+const BUILDCHAIN_PACKAGE = "@kungfu-tech/buildchain";
+const KFD_PACKAGE = "@kungfu-tech/kfd";
+const PROFILE_REQUIREMENTS = Object.freeze([
+  ["adopter-identity", ["declaration"]],
+  ["artifact-readback", ["verification"]],
+  ["claim-boundary", ["declaration"]],
+  ["delivery-policy-cut", ["declaration", "verification"]],
+  ["kfd-cut", ["verification"]],
+  ["protected-delivery", ["implementation", "review", "verification"]],
+  ["source-artifact", ["implementation"]],
+]);
+
+function exactPackage(value, { name, version = "", root = "", label }) {
+  if (
+    value?.name !== name ||
+    typeof value.version !== "string" ||
+    value.version.length === 0 ||
+    !ROOT_PATTERN.test(value.artifactRoot ?? "")
+  ) {
+    throw new TypeError(`${label} package identity is incomplete`);
+  }
+  if (version && value.version !== version) {
+    throw new TypeError(`${label} package version does not match its binding`);
+  }
+  if (root && value.artifactRoot !== root) {
+    throw new TypeError(`${label} package root does not match its binding`);
+  }
+  return structuredClone(value);
+}
+
+function authorityFunctions(authorityRuntime) {
+  const names = [
+    "createBuildchainDeliveryInfrastructureInstanceManifest",
+    "verifyBuildchainDeliveryInfrastructureInstance",
+    "createAdopterDeliveryGate",
+    "createPackageArtifactProfile",
+    "createKfdAdopterCategoryProtocolDriver",
+    "qualifyBuildchainDeliveryInfrastructureBootstrap",
+  ];
+  for (const name of names) {
+    if (typeof authorityRuntime?.[name] !== "function") {
+      throw new TypeError(`authority runtime is missing ${name}`);
+    }
+  }
+  return authorityRuntime;
+}
+
+function passed(value, label) {
+  if (value?.status !== "passed") {
+    throw new Error(
+      `${label} failed closed: ${JSON.stringify(value?.issues ?? [])}`,
+    );
+  }
+  return value;
+}
+
+function candidateWarrant(candidate) {
+  const terminal = candidate?.terminal;
+  if (
+    candidate?.status !== "merged" ||
+    !SHA_PATTERN.test(candidate?.sourceHead ?? "") ||
+    !ROOT_PATTERN.test(candidate?.sourceProofRoot ?? "") ||
+    terminal?.outcome !== "merged" ||
+    !ROOT_PATTERN.test(terminal?.nativeProofRoot ?? "") ||
+    !ROOT_PATTERN.test(terminal?.evidenceRoot ?? "")
+  ) {
+    throw new TypeError("candidate Warrant settlement is incomplete");
+  }
+  return {
+    outcome: "merged",
+    sourceHead: candidate.sourceHead,
+    sourceProofRoot: candidate.sourceProofRoot,
+    nativeProofRoot: terminal.nativeProofRoot,
+    integrationProofRoot: terminal.evidenceRoot,
+  };
+}
+
+function deliveryCut() {
+  const protocol = {
+    id: "kfd.adopter-category/instance-manifest",
+    version: "1.0.0",
+  };
+  protocol.root = adopterDeliveryGateDigest(protocol);
+  const profile = {
+    id: "kfd.adopter-category/delivery-infrastructure",
+    version: "1.0.0",
+  };
+  profile.root = adopterDeliveryGateDigest({
+    ...profile,
+    requirements: PROFILE_REQUIREMENTS,
+  });
+  return {
+    gateRoot: adopterDeliveryGateDigest({
+      protocol,
+      profile,
+      artifactProfile: {
+        id: "buildchain.artifact/package",
+        version: "1.0.0",
+      },
+    }),
+    protocol,
+    profile,
+  };
+}
+
+function candidateEvidence({
+  source,
+  artifact,
+  authority,
+  warrant,
+  kfdRoot,
+  observedAt,
+}) {
+  const roots = {
+    "adopter-identity:declaration": source.root,
+    "artifact-readback:verification": artifact.root,
+    "claim-boundary:declaration": adopterDeliveryGateDigest({
+      qualifying: false,
+      selfCertified: false,
+      releaseAuthorized: false,
+    }),
+    "delivery-policy-cut:declaration": authority.gateRoot,
+    "delivery-policy-cut:verification": warrant.integrationProofRoot,
+    "kfd-cut:verification": kfdRoot,
+    "protected-delivery:implementation": artifact.root,
+    "protected-delivery:review": warrant.sourceProofRoot,
+    "protected-delivery:verification": warrant.nativeProofRoot,
+    "source-artifact:implementation": source.root,
+  };
+  return PROFILE_REQUIREMENTS.flatMap(([requirementId, kinds]) =>
+    kinds.map((kind) => ({
+      requirementId,
+      kind,
+      coordinate: `evidence://kungfu-systems/buildchain/${requirementId}/${kind}`,
+      root: roots[`${requirementId}:${kind}`],
+      observedAt,
+    })),
+  );
+}
+
+export function createBuildchainDeliveryInfrastructureSelfDogfood(
+  {
+    authorityPackage,
+    kfdPackage,
+    authority,
+    candidate,
+    instanceId,
+    adopterManifest,
+    source,
+    artifact,
+    release,
+    evidence = [],
+    warrant,
+    transitionEvidence,
+    verifiedAt,
+    maxAgeSeconds,
+  } = {},
+  authorityRuntime,
+) {
+  const runtime = authorityFunctions(authorityRuntime);
+  const boundAuthorityPackage = exactPackage(authorityPackage, {
+    name: BUILDCHAIN_PACKAGE,
+    version: authority?.version,
+    root: authority?.packageRoot,
+    label: "Buildchain authority",
+  });
+  const boundKfdPackage = exactPackage(kfdPackage, {
+    name: KFD_PACKAGE,
+    version: adopterManifest?.kfdCut?.package?.version,
+    root: adopterManifest?.kfdCut?.package?.artifactRoot,
+    label: "KFD authority",
+  });
+  if (candidate?.authorityVersion !== boundAuthorityPackage.version) {
+    throw new TypeError(
+      "candidate does not name the exact Buildchain N-1 authority",
+    );
+  }
+
+  const instanceManifest =
+    runtime.createBuildchainDeliveryInfrastructureInstanceManifest({
+      instanceId,
+      adopterManifest,
+      source,
+      artifact,
+      release,
+      evidence,
+    });
+  const instanceReport = runtime.verifyBuildchainDeliveryInfrastructureInstance(
+    instanceManifest,
+    {
+      adopterManifest,
+      verifiedAt,
+      maxAgeSeconds,
+    },
+  );
+  if (instanceReport?.valid !== true) {
+    throw new Error(
+      `delivery-infrastructure instance failed closed: ${JSON.stringify(instanceReport?.issues ?? [])}`,
+    );
+  }
+
+  const gateResult = passed(
+    runtime
+      .createAdopterDeliveryGate({
+        drivers: [runtime.createKfdAdopterCategoryProtocolDriver()],
+        artifactProfiles: [runtime.createPackageArtifactProfile()],
+      })
+      .evaluate(
+        {
+          schemaVersion: 1,
+          contract: "kungfu-buildchain-adopter-delivery-request",
+          protocol: {
+            id: "kfd.adopter-category/instance-manifest",
+            version: "1.0.0",
+          },
+          artifactProfile: {
+            id: "buildchain.artifact/package",
+            version: "1.0.0",
+          },
+          project: {
+            instanceId,
+            adopterId: "kungfu-systems/buildchain",
+          },
+          artifact: structuredClone(artifact),
+          declaration: instanceManifest,
+        },
+        { adopterManifest, verifiedAt, maxAgeSeconds },
+      ),
+    "adopter delivery gate",
+  );
+  const bootstrap = passed(
+    runtime.qualifyBuildchainDeliveryInfrastructureBootstrap({
+      authority,
+      candidate,
+      gateResult,
+      warrant,
+      transitionEvidence,
+    }),
+    "delivery-infrastructure bootstrap",
+  );
+
+  const result = {
+    schemaVersion: 1,
+    contract: BUILDCHAIN_DELIVERY_SELF_DOGFOOD_CONTRACT,
+    status: "passed",
+    authorityRuntime: {
+      buildchainPackage: boundAuthorityPackage,
+      kfdPackage: boundKfdPackage,
+    },
+    candidate: structuredClone(candidate),
+    roots: {
+      adopterManifest: adopterDeliveryGateDigest(adopterManifest),
+      instanceManifest: adopterDeliveryGateDigest(instanceManifest),
+      instanceReport: adopterDeliveryGateDigest(instanceReport),
+      gateResult: gateResult.gateRoot,
+      bootstrap: bootstrap.bootstrapRoot,
+      warrant: adopterDeliveryGateDigest(warrant),
+    },
+    instanceManifest,
+    instanceReport,
+    gateResult,
+    bootstrap,
+    qualifying: false,
+    selfCertified: false,
+    releaseAuthorized: false,
+    finalAuthority:
+      "protected-n-minus-one-runtime-plus-exact-delivery-evidence",
+  };
+  result.selfDogfoodRoot = adopterDeliveryGateDigest(result);
+  return result;
+}
+
+export async function createPublishedBuildchainDeliveryInfrastructureSelfDogfood({
+  authorityPackages,
+  selfDogfood,
+} = {}) {
+  return withPublishedBuildchainDeliveryAuthority(
+    authorityPackages,
+    async ({ packages, authorityRuntime, authorityRoot }) => {
+      const result = createBuildchainDeliveryInfrastructureSelfDogfood(
+        {
+          ...structuredClone(selfDogfood ?? {}),
+          authorityPackage: packages.buildchain,
+          kfdPackage: packages.kfd,
+        },
+        authorityRuntime,
+      );
+      return {
+        ...result,
+        publishedAuthorityRoot: authorityRoot,
+      };
+    },
+  );
+}
+
+export async function createPublishedBuildchainDeliveryInfrastructureCandidateSelfDogfood({
+  authorityPackages,
+  authoritySourceCommit,
+  candidatePackage,
+  warrantCandidate,
+  source,
+  release,
+  verifiedAt,
+  maxAgeSeconds = 86400,
+} = {}) {
+  if (!SHA_PATTERN.test(authoritySourceCommit ?? "")) {
+    throw new TypeError("authority source commit is invalid");
+  }
+  const artifact = exactPackage(candidatePackage, {
+    name: BUILDCHAIN_PACKAGE,
+    label: "Buildchain candidate",
+  });
+  if (
+    source?.coordinate !==
+      `kungfu-systems/buildchain@${warrantCandidate?.sourceHead ?? ""}` ||
+    !ROOT_PATTERN.test(source?.root ?? "") ||
+    !ROOT_PATTERN.test(release?.root ?? "")
+  ) {
+    throw new TypeError("candidate source or release binding is incomplete");
+  }
+  const warrant = candidateWarrant(warrantCandidate);
+  const cut = deliveryCut();
+  const authority = {
+    version: authorityPackages?.buildchain?.version,
+    sourceCommit: authoritySourceCommit,
+    packageRoot: authorityPackages?.buildchain?.artifactRoot,
+    ...cut,
+    protected: true,
+    published: true,
+  };
+  const candidate = {
+    version: artifact.version,
+    sourceCommit: warrant.sourceHead,
+    packageRoot: artifact.artifactRoot,
+    ...cut,
+    authorityVersion: authority.version,
+  };
+  const adopterManifest = initAdopterManifest({
+    manifestId: `buildchain-delivery-infrastructure-${artifact.version}`,
+    adopterId: "kungfu-systems/buildchain",
+    artifactKind: "package",
+    artifactCoordinate: `${artifact.name}@${artifact.version}`,
+    artifactRoot: artifact.artifactRoot,
+    scope: "Buildchain delivery infrastructure release candidate self-dogfood",
+    packageArtifactRoot: authorityPackages?.kfd?.artifactRoot,
+    verifiedAt,
+    maxAgeSeconds,
+  });
+  adopterManifest.releaseBindings.push({
+    id: `buildchain-${artifact.version}`,
+    artifact: {
+      kind: "package",
+      coordinate: `${artifact.name}@${artifact.version}`,
+      root: artifact.artifactRoot,
+    },
+    releasePassport: structuredClone(release),
+    kfdPackageRoot: authorityPackages.kfd.artifactRoot,
+  });
+  const evidence = candidateEvidence({
+    source,
+    artifact: adopterManifest.releaseBindings[0].artifact,
+    authority,
+    warrant,
+    kfdRoot: authorityPackages.kfd.artifactRoot,
+    observedAt: verifiedAt,
+  });
+  const result =
+    await createPublishedBuildchainDeliveryInfrastructureSelfDogfood({
+      authorityPackages,
+      selfDogfood: {
+        authority,
+        candidate,
+        instanceId: `kungfu-systems/buildchain@${artifact.version}`,
+        adopterManifest,
+        source,
+        artifact: adopterManifest.releaseBindings[0].artifact,
+        release,
+        evidence,
+        warrant,
+        verifiedAt,
+        maxAgeSeconds,
+      },
+    });
+  return { ...result, adopterManifest, deliveryEvidence: evidence };
+}

package/packages/core/dev-delivery-warrant.js

@@ -610,6 +610,7 @@ export function closeDevDeliveryWarrant(queueInput, warrant, { outcome, evidence
         closedAt: currentTime,
         fencingToken: active.fencingToken,
         leaseGeneration: active.generation,
+        ...(active.nativeProofRoot ? { nativeProofRoot: exactRoot(active.nativeProofRoot, "nativeProofRoot") } : {}),
       };
       queue.activeWarrant = null;
       return { candidate, active };