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

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 };

package/packages/core/published-delivery-authority.js

@@ -0,0 +1,247 @@
+import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { mkdir, mkdtemp, readFile, realpath, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { pathToFileURL } from "node:url";
+import { execFile } from "node:child_process";
+
+import { adopterDeliveryGateDigest } from "./adopter-delivery-gate.js";
+
+export const PUBLISHED_DELIVERY_AUTHORITY_CONTRACT =
+  "kungfu-buildchain-published-delivery-authority/v1";
+
+const execFileAsync = promisify(execFile);
+const ROOT_PATTERN = /^sha256:[0-9a-f]{64}$/;
+const PACKAGES = [
+  {
+    key: "buildchain",
+    name: "@kungfu-tech/buildchain",
+    packageRoot: "archive",
+    modules: {
+      adopterDeliveryGate: "packages/core/adopter-delivery-gate.js",
+      bootstrap: "packages/core/buildchain-delivery-bootstrap.js",
+      infrastructure: "packages/core/buildchain-delivery-infrastructure.js",
+      kfdCategoryDriver: "packages/core/kfd-adopter-category-driver.js",
+    },
+  },
+  {
+    key: "kfd",
+    name: "@kungfu-tech/kfd",
+    packageRoot: "profiles/adopter-conformance/adopters/kfd/manifest.json",
+    modules: {},
+  },
+];
+
+async function sha256File(file) {
+  const hash = createHash("sha256");
+  for await (const chunk of createReadStream(file)) hash.update(chunk);
+  return `sha256:${hash.digest("hex")}`;
+}
+
+function exactDeclaration(value, expectedName, label) {
+  if (
+    value?.name !== expectedName ||
+    typeof value.version !== "string" ||
+    value.version.length === 0 ||
+    typeof value.archivePath !== "string" ||
+    value.archivePath.length === 0 ||
+    !ROOT_PATTERN.test(value.archiveRoot ?? "") ||
+    !ROOT_PATTERN.test(value.artifactRoot ?? "")
+  ) {
+    throw new TypeError(`${label} package declaration is incomplete`);
+  }
+  return structuredClone(value);
+}
+
+function safeArchiveEntries(listing, verboseListing, label) {
+  const entries = listing.split("\n").filter(Boolean);
+  const types = verboseListing.split("\n").filter(Boolean);
+  if (entries.length === 0 || entries.length !== types.length) {
+    throw new Error(`${label} archive listing is incomplete`);
+  }
+  for (let index = 0; index < entries.length; index += 1) {
+    const entry = entries[index];
+    const parts = entry.split("/");
+    if (
+      parts[0] !== "package" ||
+      parts.some((part, partIndex) =>
+        partIndex === parts.length - 1 && part === ""
+          ? false
+          : part === "" || part === "." || part === "..",
+      )
+    ) {
+      throw new Error(`${label} archive contains an unsafe path`);
+    }
+    if (!["-", "d"].includes(types[index][0])) {
+      throw new Error(`${label} archive contains a non-file entry`);
+    }
+  }
+}
+
+async function extractPackage(declaration, destination, definition, label) {
+  const observedRoot = await sha256File(declaration.archivePath);
+  if (observedRoot !== declaration.archiveRoot) {
+    throw new Error(`${label} archive bytes do not match archiveRoot`);
+  }
+  const [{ stdout: listing }, { stdout: verboseListing }] = await Promise.all([
+    execFileAsync("tar", ["-tzf", declaration.archivePath], {
+      maxBuffer: 16 * 1024 * 1024,
+    }),
+    execFileAsync("tar", ["-tvzf", declaration.archivePath], {
+      maxBuffer: 16 * 1024 * 1024,
+    }),
+  ]);
+  safeArchiveEntries(listing, verboseListing, label);
+  await mkdir(destination, { recursive: true });
+  await execFileAsync(
+    "tar",
+    [
+      "-xzf",
+      declaration.archivePath,
+      "--strip-components",
+      "1",
+      "-C",
+      destination,
+    ],
+    { maxBuffer: 16 * 1024 * 1024 },
+  );
+  const packageJsonPath = path.join(destination, "package.json");
+  const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
+  if (
+    packageJson.name !== declaration.name ||
+    packageJson.version !== declaration.version
+  ) {
+    throw new Error(`${label} extracted package identity does not match`);
+  }
+  if (definition.packageRoot === "archive") {
+    if (declaration.artifactRoot !== declaration.archiveRoot) {
+      throw new Error(`${label} package artifactRoot must match archiveRoot`);
+    }
+  } else {
+    const packageManifest = JSON.parse(
+      await readFile(path.join(destination, definition.packageRoot), "utf8"),
+    );
+    const packageCut = packageManifest?.kfdCut?.package;
+    if (
+      packageCut?.name !== declaration.name ||
+      packageCut?.version !== declaration.version ||
+      packageCut?.artifactRoot !== declaration.artifactRoot
+    ) {
+      throw new Error(`${label} semantic package identity does not match`);
+    }
+  }
+  const destinationRoot = await realpath(destination);
+  if (!destinationRoot.endsWith(path.join(...declaration.name.split("/")))) {
+    throw new Error(`${label} extraction escaped its package coordinate`);
+  }
+  return {
+    name: declaration.name,
+    version: declaration.version,
+    archiveRoot: declaration.archiveRoot,
+    artifactRoot: declaration.artifactRoot,
+  };
+}
+
+async function importAuthorityRuntime(buildchainRoot) {
+  const definition = PACKAGES[0];
+  const imported = {};
+  for (const [key, relativePath] of Object.entries(definition.modules)) {
+    imported[key] = await import(
+      pathToFileURL(path.join(buildchainRoot, relativePath)).href
+    );
+  }
+  const runtime = {
+    createAdopterDeliveryGate:
+      imported.adopterDeliveryGate.createAdopterDeliveryGate,
+    createPackageArtifactProfile:
+      imported.adopterDeliveryGate.createPackageArtifactProfile,
+    qualifyBuildchainDeliveryInfrastructureBootstrap:
+      imported.bootstrap.qualifyBuildchainDeliveryInfrastructureBootstrap,
+    createBuildchainDeliveryInfrastructureInstanceManifest:
+      imported.infrastructure
+        .createBuildchainDeliveryInfrastructureInstanceManifest,
+    verifyBuildchainDeliveryInfrastructureInstance:
+      imported.infrastructure.verifyBuildchainDeliveryInfrastructureInstance,
+    createKfdAdopterCategoryProtocolDriver:
+      imported.kfdCategoryDriver.createKfdAdopterCategoryProtocolDriver,
+  };
+  for (const [name, implementation] of Object.entries(runtime)) {
+    if (typeof implementation !== "function") {
+      throw new Error(`published Buildchain authority is missing ${name}`);
+    }
+  }
+  return runtime;
+}
+
+export async function loadPublishedBuildchainDeliveryAuthority({
+  buildchain,
+  kfd,
+} = {}) {
+  const declarations = {
+    buildchain: exactDeclaration(
+      buildchain,
+      "@kungfu-tech/buildchain",
+      "Buildchain authority",
+    ),
+    kfd: exactDeclaration(kfd, "@kungfu-tech/kfd", "KFD authority"),
+  };
+  const temporaryRoot = await mkdtemp(
+    path.join(tmpdir(), "buildchain-published-delivery-authority-"),
+  );
+  let retained = false;
+  try {
+    const identities = {};
+    for (const definition of PACKAGES) {
+      identities[definition.key] = await extractPackage(
+        declarations[definition.key],
+        path.join(temporaryRoot, "node_modules", ...definition.name.split("/")),
+        definition,
+        `${definition.key} authority`,
+      );
+    }
+    const authorityRuntime = await importAuthorityRuntime(
+      path.join(temporaryRoot, "node_modules", ...PACKAGES[0].name.split("/")),
+    );
+    const authority = {
+      schemaVersion: 1,
+      contract: PUBLISHED_DELIVERY_AUTHORITY_CONTRACT,
+      packages: identities,
+      moduleCoordinates: structuredClone(PACKAGES[0].modules),
+      qualifying: false,
+      selfCertified: false,
+      releaseAuthorized: false,
+      finalAuthority:
+        "caller-bound-public-npm-archive-bytes-and-package-identity",
+    };
+    authority.authorityRoot = adopterDeliveryGateDigest(authority);
+    retained = true;
+    return {
+      ...authority,
+      authorityRuntime,
+      temporaryRoot,
+      async dispose() {
+        await rm(temporaryRoot, { recursive: true, force: true });
+      },
+    };
+  } finally {
+    if (!retained) await rm(temporaryRoot, { recursive: true, force: true });
+  }
+}
+
+export async function withPublishedBuildchainDeliveryAuthority(
+  declarations,
+  operation,
+) {
+  if (typeof operation !== "function") {
+    throw new TypeError("published authority operation must be a function");
+  }
+  const authority =
+    await loadPublishedBuildchainDeliveryAuthority(declarations);
+  try {
+    return await operation(authority);
+  } finally {
+    await authority.dispose();
+  }
+}

package/packages/core/release-passport.js

@@ -1533,7 +1533,7 @@ export function collectGitHubReleasePassport({
   kfd2ClaimJsons = [],
   kfd3PrebuildWitnessJsons = [],
   kfd3ArtifactWitnessJsons = [],
-  kfd3ArtifactVerifyCommand = "",
+  kfd3ArtifactVerifyCommand = "", adopterDeliveryJson = "",
   kfdAdopterManifestJson = "",
   kfdSupportMatrixJson = "",
   kfdProductGateJsons = [],
@@ -1594,6 +1594,11 @@ export function collectGitHubReleasePassport({
     cwd,
     label: "KFD-3 artifact verify command",
   });
+  const adopterDelivery = parseJsonInput(
+    adopterDeliveryJson,
+    undefined,
+    { cwd, label: "adopterDeliveryJson" },
+  );
   const basePassportMeta = parseJsonInputWithMeta(basePassportJson, undefined, { cwd, label: "basePassportJson" });
   const invariantPassportMetas = (invariantPassportJsons || [])
     .filter(Boolean)
@@ -1684,6 +1689,7 @@ export function collectGitHubReleasePassport({
     tag: resolvedTag,
     sourceSha,
     workflow,
+    adopterDelivery,
     kfdAdopter,
   });
   const bundledPublishEvidencePath = publishEvidenceMeta.value ? "evidence.json" : "";
@@ -1750,6 +1756,7 @@ export function collectGitHubReleasePassport({
     kfd1,
     kfd2Claims: kfd2ClaimMetas.map((meta) => meta.value),
     kfd3,
+    adopterDelivery,
     kfdAdopter,
     kfdAdopterManifestEvidencePath: kfdAdopter ? "kfd-adopter-manifest.json" : "",
     kfdAdopterGateEvidencePath: kfdAdopter ? "kfd-adopter-manifest-gate.json" : "",

package/scripts/buildchain-cli-help.mjs

@@ -67,6 +67,7 @@ export const BUILDCHAIN_USAGE = `Usage:
                                     [--kfd-3-prebuild-witness-json <json-or-path>]...
                                     [--kfd-3-artifact-witness-json <json-or-path>]...
                                     [--kfd-3-artifact-verify-cmd <command>]
+                                    [--adopter-delivery-json <json-or-path>]
                                     [--kfd-adopter-manifest-json <json-or-path>]
                                     [--kfd-support-matrix-json <json-or-path>]
                                     [--kfd-product-gate-json <json-or-path>]...

package/scripts/check-inventory.mjs

@@ -1003,7 +1003,7 @@ for (const forbiddenSnippet of [
 for (const requiredSnippet of [
   "id-token: write",
   "actions: write",
-  "uses: kungfu-systems/buildchain/.github/workflows/release-candidate-promote.yml@cc6c32845ab5779009aeb48cc34efe65e229fe30\n",
+  "uses: kungfu-systems/buildchain/.github/workflows/release-candidate-promote.yml@15db8a9d7c39f7a649a0e3971af68490356dd9ac\n",
   "github.event.workflow_run.event == 'push'",
   "!startsWith(github.event.workflow_run.display_title, 'chore(release): prepare v')",
   "!startsWith(github.event.workflow_run.display_title, 'chore(release): release v')",