@kungfu-tech/buildchain 3.0.8 → 3.0.9-alpha.1

package/packages/core/kfd-product-gates.js

@@ -10,12 +10,8 @@ export const KFD_PRODUCT_GATE_INPUT_CONTRACT =
   "kungfu-buildchain-kfd-product-gate-input";
 export const KFD_PRODUCT_GATE_CONTRACT =
   "kungfu-buildchain-kfd-product-gate";
-export const KFD_SUPPORT_PROJECTION_CONTRACT =
-  "kungfu-buildchain-kfd-support-projection";
 export const KFD_PRODUCT_GATE_INPUT_SCHEMA_ID =
   "https://buildchain.libkungfu.dev/schemas/kfd-product-gate-input-v1.schema.json";
-export const KFD_SUPPORT_PROJECTION_SCHEMA_ID =
-  "https://buildchain.libkungfu.dev/schemas/kfd-support-projection-v1.schema.json";
 
 const SUPPORTED_GATE_STANDARDS = Object.freeze(["kfd-4", "kfd-5", "kfd-7"]);
 const SUPPORTED_GATE_STANDARD_SET = new Set(SUPPORTED_GATE_STANDARDS);
@@ -127,48 +123,6 @@ export const KFD_PRODUCT_GATE_INPUT_SCHEMA = {
   },
 };
 
-export const KFD_SUPPORT_PROJECTION_SCHEMA = {
-  $schema: "https://json-schema.org/draft/2020-12/schema",
-  $id: KFD_SUPPORT_PROJECTION_SCHEMA_ID,
-  title: "Buildchain KFD support projection v1",
-  description:
-    "A release-bound, non-authoritative projection of one product-owned KFD support matrix.",
-  type: "object",
-  additionalProperties: false,
-  required: [
-    "schemaVersion",
-    "contract",
-    "matrix",
-    "standardPackage",
-    "gateResults",
-    "rows",
-    "status",
-    "projectionRoot",
-    "nonClaims",
-  ],
-  properties: {
-    schemaVersion: { const: 1 },
-    contract: { const: KFD_SUPPORT_PROJECTION_CONTRACT },
-    matrix: {
-      type: "object",
-      additionalProperties: false,
-      required: ["contract", "root", "authorityPath"],
-      properties: { contract: STRING, root: SHA256, authorityPath: STRING },
-    },
-    standardPackage: {
-      type: "object",
-      additionalProperties: false,
-      required: ["name", "version", "standardsSha256"],
-      properties: { name: STRING, version: STRING, standardsSha256: SHA256 },
-    },
-    gateResults: { type: "array", minItems: 3, items: { type: "object" } },
-    rows: { type: "array", minItems: 13, maxItems: 13, items: { type: "object" } },
-    status: { enum: ["passed", "failed"] },
-    projectionRoot: SHA256,
-    nonClaims: { type: "array", minItems: 1, items: STRING },
-  },
-};
-
 const require = createRequire(import.meta.url);
 let verifierPromise;
 
@@ -604,262 +558,8 @@ export function validateKfdProductGateResult(result, {
   return { valid: issues.length === 0, issues };
 }
 
-function expectedKfdIds() {
-  return Array.from({ length: 13 }, (_, index) => `KFD-${index + 1}`);
-}
-
-function normalizeMatrixRoot(matrix, matrixRoot) {
-  const normalized = normalizeSha256(matrixRoot);
-  return normalized || kfdProductGateDigest(matrix);
-}
-
-function projectMatrixRow(row) {
-  return {
-    id: row.id,
-    key: row.key,
-    title: row.title,
-    supportStatus: row.supportStatus,
-    normative: row.normative,
-    implementation: row.implementation,
-    verification: row.verification,
-    buildchain: row.buildchain,
-    releaseQualification: row.releaseQualification,
-    claimClass: row.claimClass,
-    knownLimitations: row.knownLimitations,
-    owner: row.owner,
-    nextGate: row.nextGate,
-  };
-}
-
-function validateMatrixRows(matrix, gatesByStandard, issues) {
-  const rows = Array.isArray(matrix?.rows) ? matrix.rows : [];
-  const expectedIds = expectedKfdIds();
-  const ids = rows.map((row) => row?.id);
-  if (rows.length !== expectedIds.length || new Set(ids).size !== expectedIds.length) {
-    issues.push(issue("matrix-row-set", "rows", "support matrix must contain exactly one row for KFD-1 through KFD-13"));
-  }
-  for (const id of expectedIds) {
-    const row = rows.find((entry) => entry?.id === id);
-    if (!row) {
-      issues.push(issue("matrix-row-missing", "rows", `${id} is missing`));
-      continue;
-    }
-    const key = id.toLowerCase();
-    const metadata = standardMetadata(key);
-    if (row.key !== key || row?.normative?.status !== metadata.status || row?.normative?.revision !== metadata.revision) {
-      issues.push(issue("matrix-normative-drift", `rows.${id}.normative`, `${id} must match installed KFD status and revision`, {
-        expected: { key, status: metadata.status, revision: metadata.revision },
-        actual: { key: row.key, status: row?.normative?.status, revision: row?.normative?.revision },
-      }));
-    }
-    const shipped = row?.releaseQualification?.shippedSupport === true;
-    if (
-      shipped &&
-      (
-        row?.implementation?.status !== "implemented" ||
-        row?.verification?.status !== "passed" ||
-        row?.buildchain?.gateStatus !== "passed" ||
-        !String(row.supportStatus || "").includes("supported")
-      )
-    ) {
-      issues.push(issue("matrix-shipped-widening", `rows.${id}`, `${id} cannot be shipped without implemented, verified, and passed Buildchain evidence`));
-    }
-  }
-  for (const id of ["KFD-4", "KFD-5"]) {
-    const row = rows.find((entry) => entry?.id === id);
-    if (row?.supportStatus !== "candidate" || row?.releaseQualification?.shippedSupport !== false) {
-      issues.push(issue("matrix-candidate-widening", `rows.${id}`, `${id} must remain a non-shipped candidate`));
-    }
-  }
-  const kfd6 = rows.find((entry) => entry?.id === "KFD-6");
-  if (
-    kfd6?.supportStatus !== "unsupported" ||
-    kfd6?.releaseQualification?.shippedSupport !== false ||
-    kfd6?.buildchain?.gateStatus === "passed"
-  ) {
-    issues.push(issue("matrix-kfd6-barrier", "rows.KFD-6", "KFD-6 must remain explicitly unsupported and non-shipped"));
-  }
-  for (let number = 8; number <= 13; number += 1) {
-    const id = `KFD-${number}`;
-    const row = rows.find((entry) => entry?.id === id);
-    if (
-      row?.supportStatus !== "draft-adopter-evidence" ||
-      row?.releaseQualification?.shippedSupport !== false ||
-      row?.buildchain?.gateStatus === "passed"
-    ) {
-      issues.push(issue("matrix-draft-barrier", `rows.${id}`, `${id} must remain draft adopter evidence and non-shipped`));
-    }
-  }
-  for (const standard of SUPPORTED_GATE_STANDARDS) {
-    const id = standard.toUpperCase();
-    const row = rows.find((entry) => entry?.id === id);
-    const gate = gatesByStandard.get(standard);
-    if (!gate) {
-      issues.push(issue("matrix-gate-missing", `rows.${id}.buildchain`, `${id} requires a Buildchain product-gate result`));
-      continue;
-    }
-    const rowPassed = row?.buildchain?.gateStatus === "passed";
-    const gatePassed = gate.status === "passed";
-    if (rowPassed !== gatePassed) {
-      issues.push(issue("matrix-gate-disagreement", `rows.${id}.buildchain.gateStatus`, `${id} matrix and Buildchain gate disagree`, {
-        matrix: row?.buildchain?.gateStatus,
-        gate: gate.status,
-      }));
-    }
-    if (row?.buildchain?.protocol !== `${KFD_PRODUCT_GATE_CONTRACT}/v1`) {
-      issues.push(issue("matrix-gate-protocol", `rows.${id}.buildchain.protocol`, `${id} must name the versioned Buildchain product-gate protocol`));
-    }
-  }
-  return rows;
-}
-
-export function createKfdSupportProjection({
-  matrix,
-  matrixRoot = "",
-  gateResults = [],
-  authorityPath = ".buildchain/kfd/support-matrix.json",
-  expectedSourceSha = "",
-  checkedAt = new Date().toISOString(),
-} = {}) {
-  const issues = [];
-  if (!isObject(matrix) || matrix.contract !== "kungfu-kfd-support-matrix" || matrix.schemaVersion !== 1) {
-    issues.push(issue("matrix-contract", "", "support matrix must use kungfu-kfd-support-matrix v1"));
-  }
-  if (
-    matrix?.upstream?.package !== kfdPackageJson.name ||
-    matrix?.upstream?.version !== kfdPackageJson.version ||
-    matrix?.upstream?.standardsSha256 !== standardsFileDigest()
-  ) {
-    issues.push(issue("matrix-standard-package", "upstream", "support matrix must bind the installed KFD package and standards bytes", {
-      expected: {
-        package: kfdPackageJson.name,
-        version: kfdPackageJson.version,
-        standardsSha256: standardsFileDigest(),
-      },
-      actual: matrix?.upstream,
-    }));
-  }
-  const gatesByStandard = new Map();
-  for (const [index, gate] of gateResults.entries()) {
-    const validation = validateKfdProductGateResult(gate, { expectedSourceSha, checkedAt });
-    if (!validation.valid) {
-      issues.push(issue("gate-result-invalid", `gateResults[${index}]`, "gate result is invalid", {
-        gateIssues: validation.issues,
-      }));
-    }
-    if (gatesByStandard.has(gate?.standard)) {
-      issues.push(issue("gate-result-duplicate", `gateResults[${index}].standard`, `${gate.standard} gate result is duplicated`));
-    }
-    gatesByStandard.set(gate?.standard, gate);
-  }
-  const rows = validateMatrixRows(matrix, gatesByStandard, issues);
-  const projection = {
-    schemaVersion: 1,
-    contract: KFD_SUPPORT_PROJECTION_CONTRACT,
-    matrix: {
-      contract: matrix?.contract || "",
-      root: normalizeMatrixRoot(matrix, matrixRoot),
-      authorityPath: optionalString(matrix?.authority?.path || authorityPath),
-    },
-    standardPackage: {
-      name: kfdPackageJson.name,
-      version: kfdPackageJson.version,
-      standardsSha256: standardsFileDigest(),
-    },
-    gateResults: SUPPORTED_GATE_STANDARDS.map((standard) => {
-      const gate = gatesByStandard.get(standard);
-      return gate
-        ? {
-            standard,
-            standardRevision: gate.standardRevision,
-            sourceSha: gate?.source?.sha || "",
-            evidenceCut: gate.evidenceCut,
-            status: gate.status,
-            gateRoot: gate.gateRoot,
-            issueCount: Array.isArray(gate.issues) ? gate.issues.length : 0,
-          }
-        : { standard, status: "missing", gateRoot: "", issueCount: 1 };
-    }),
-    rows: rows.map(projectMatrixRow),
-    status: issues.length === 0 ? "passed" : "failed",
-    nonClaims: [
-      "This projection does not replace the product-owned support matrix.",
-      "A passed Buildchain gate does not by itself activate, ship, or certify a KFD adoption.",
-      "Candidate, unsupported, draft, and non-qualifying matrix states cannot be widened by this projection.",
-    ],
-    issues,
-  };
-  projection.projectionRoot = kfdProductGateDigest(projection);
-  return projection;
-}
-
-export function validateKfdSupportProjection(projection, {
-  expectedSourceSha = "",
-  checkedAt = new Date().toISOString(),
-} = {}) {
-  const issues = [];
-  if (!isObject(projection) || projection.schemaVersion !== 1 || projection.contract !== KFD_SUPPORT_PROJECTION_CONTRACT) {
-    issues.push(issue("projection-contract", "", `projection must use ${KFD_SUPPORT_PROJECTION_CONTRACT} v1`));
-    return { valid: false, issues };
-  }
-  const copy = structuredClone(projection);
-  const root = copy.projectionRoot;
-  delete copy.projectionRoot;
-  if (root !== kfdProductGateDigest(copy)) {
-    issues.push(issue("projection-root", "projectionRoot", "support projection root does not match its content"));
-  }
-  if (projection.status !== "passed" || (projection.issues || []).length !== 0) {
-    issues.push(issue("projection-status", "status", "release passport requires a passed support projection"));
-  }
-  if (
-    projection?.standardPackage?.name !== kfdPackageJson.name ||
-    projection?.standardPackage?.version !== kfdPackageJson.version ||
-    projection?.standardPackage?.standardsSha256 !== standardsFileDigest()
-  ) {
-    issues.push(issue("projection-standard-package", "standardPackage", "support projection uses stale KFD package metadata"));
-  }
-  if (!new RegExp(SHA256_PATTERN).test(optionalString(projection?.matrix?.root))) {
-    issues.push(issue("projection-matrix-root", "matrix.root", "support projection must bind the exact support matrix bytes"));
-  }
-  if (!optionalString(projection?.matrix?.authorityPath)) {
-    issues.push(issue("projection-matrix-authority", "matrix.authorityPath", "support projection must retain the product-owned matrix authority path"));
-  }
-  const gatesByStandard = new Map();
-  for (const [index, gate] of (projection.gateResults || []).entries()) {
-    if (!SUPPORTED_GATE_STANDARD_SET.has(gate?.standard)) {
-      issues.push(issue("projection-gate-standard", `gateResults[${index}].standard`, "projected gate must be kfd-4, kfd-5, or kfd-7"));
-      continue;
-    }
-    if (gatesByStandard.has(gate.standard)) {
-      issues.push(issue("projection-gate-duplicate", `gateResults[${index}].standard`, `${gate.standard} is duplicated`));
-    }
-    gatesByStandard.set(gate.standard, gate);
-    if (gate.standardRevision !== standardMetadata(gate.standard).revision) {
-      issues.push(issue("projection-gate-revision", `gateResults[${index}].standardRevision`, "projected gate revision is stale"));
-    }
-    if (!new RegExp(SHA256_PATTERN).test(optionalString(gate.gateRoot))) {
-      issues.push(issue("projection-gate-root", `gateResults[${index}].gateRoot`, "projected gate must retain its gate root"));
-    }
-    if (expectedSourceSha && gate.sourceSha !== expectedSourceSha) {
-      issues.push(issue("projection-source", `gateResults[${index}].sourceSha`, "gate source must match the release source"));
-    }
-    const checked = parseDate(checkedAt);
-    const expires = parseDate(gate?.evidenceCut?.expiresAt);
-    if (!Number.isFinite(expires) || (Number.isFinite(checked) && expires <= checked)) {
-      issues.push(issue("projection-stale-gate", `gateResults[${index}].evidenceCut.expiresAt`, "projected gate evidence is stale"));
-    }
-  }
-  validateMatrixRows({ rows: projection.rows }, gatesByStandard, issues);
-  if (!Array.isArray(projection.nonClaims) || projection.nonClaims.length === 0) {
-    issues.push(issue("projection-non-claims", "nonClaims", "support projection must preserve non-claims"));
-  }
-  return { valid: issues.length === 0, issues };
-}
-
 export const kfdProductGates = Object.freeze({
   evaluate: evaluateKfdProductGate,
-  projectSupport: createKfdSupportProjection,
   validateGateResult: validateKfdProductGateResult,
-  validateSupportProjection: validateKfdSupportProjection,
   verifyRecord: verifyKfdRecord,
 });

package/packages/core/release-blocker-priority.js

@@ -0,0 +1,192 @@
+// SPDX-License-Identifier: Apache-2.0
+
+import {
+  devDeliveryContentRoot,
+  devDeliveryExactRoot as exactRoot,
+  devDeliveryExactSha as exactSha,
+  devDeliveryPositiveInteger as positiveInteger,
+  devDeliveryProtectedBase as protectedBase,
+  devDeliveryRepository as repository,
+  devDeliveryText as text,
+  devDeliveryTimestamp as timestamp,
+} from "./dev-delivery-common.js";
+import { validateReleaseBlockerRepair } from "./release-train.js";
+
+export const RELEASE_BLOCKER_PRIORITY_CLAIM_SCHEMA =
+  "kungfu.buildchain.release-blocker-priority-claim/v1";
+
+function exactFields(value, fields, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+  const actual = Object.keys(value).sort();
+  const expected = [...fields].sort();
+  if (
+    actual.length !== expected.length ||
+    actual.some((field, index) => field !== expected[index])
+  ) {
+    throw new Error(`${label} has an invalid field set`);
+  }
+}
+
+export function createReleaseBlockerPriorityClaim(repairInput, input = {}) {
+  const repair = validateReleaseBlockerRepair(repairInput);
+  if (!repair.publication.eligible || repair.devLanding.status !== "landed") {
+    throw new Error(
+      "release-blocker priority requires an exact settled dev landing",
+    );
+  }
+  const body = {
+    schema: RELEASE_BLOCKER_PRIORITY_CLAIM_SCHEMA,
+    repository: repository(repair.successorTrain.releaseCut.repository),
+    protectedBase: protectedBase(repair.successorTrain.releaseCut.sourceBranch),
+    assignmentRoot: exactRoot(input.assignmentRoot, "assignmentRoot"),
+    initiativeRoot: exactRoot(input.initiativeRoot, "initiativeRoot"),
+    repairRoot: exactRoot(repair.repairRoot, "repairRoot"),
+    priorCutRoot: exactRoot(
+      repair.priorTrain.releaseCut.cutRoot,
+      "priorCutRoot",
+    ),
+    successorCutRoot: exactRoot(
+      repair.successorTrain.releaseCut.cutRoot,
+      "successorCutRoot",
+    ),
+    candidateGeneration: positiveInteger(
+      repair.successorTrain.releaseCut.generation,
+      "candidateGeneration",
+    ),
+    cutCandidateSha: exactSha(repair.cutLanding.landedSha, "cutCandidateSha"),
+    sourceHead: exactSha(repair.devLanding.landedSha, "sourceHead"),
+    sourcePatchRoot: exactRoot(repair.patchRoot, "sourcePatchRoot"),
+    cutLandingEvidenceRoot: exactRoot(
+      repair.cutLanding.evidenceRoot,
+      "cutLandingEvidenceRoot",
+    ),
+    devLandingEvidenceRoot: exactRoot(
+      repair.devLanding.evidenceRoot,
+      "devLandingEvidenceRoot",
+    ),
+    publicationGateRoot: exactRoot(
+      repair.publication.gateRoot,
+      "publicationGateRoot",
+    ),
+    issuedAt: timestamp(input.issuedAt, "issuedAt"),
+  };
+  return { ...body, claimRoot: devDeliveryContentRoot(body) };
+}
+
+export function normalizeReleaseBlockerPriorityClaim(
+  input,
+  candidate,
+  expected,
+) {
+  exactFields(
+    input,
+    [
+      "schema",
+      "repository",
+      "protectedBase",
+      "assignmentRoot",
+      "initiativeRoot",
+      "repairRoot",
+      "priorCutRoot",
+      "successorCutRoot",
+      "candidateGeneration",
+      "cutCandidateSha",
+      "sourceHead",
+      "sourcePatchRoot",
+      "cutLandingEvidenceRoot",
+      "devLandingEvidenceRoot",
+      "publicationGateRoot",
+      "issuedAt",
+      "claimRoot",
+    ],
+    "releaseBlockerPriority",
+  );
+  const body = {
+    schema: text(input.schema),
+    repository: repository(input.repository),
+    protectedBase: protectedBase(input.protectedBase),
+    assignmentRoot: exactRoot(
+      input.assignmentRoot,
+      "releaseBlockerPriority.assignmentRoot",
+    ),
+    initiativeRoot: exactRoot(
+      input.initiativeRoot,
+      "releaseBlockerPriority.initiativeRoot",
+    ),
+    repairRoot: exactRoot(
+      input.repairRoot,
+      "releaseBlockerPriority.repairRoot",
+    ),
+    priorCutRoot: exactRoot(
+      input.priorCutRoot,
+      "releaseBlockerPriority.priorCutRoot",
+    ),
+    successorCutRoot: exactRoot(
+      input.successorCutRoot,
+      "releaseBlockerPriority.successorCutRoot",
+    ),
+    candidateGeneration: positiveInteger(
+      input.candidateGeneration,
+      "releaseBlockerPriority.candidateGeneration",
+    ),
+    cutCandidateSha: exactSha(
+      input.cutCandidateSha,
+      "releaseBlockerPriority.cutCandidateSha",
+    ),
+    sourceHead: exactSha(input.sourceHead, "releaseBlockerPriority.sourceHead"),
+    sourcePatchRoot: exactRoot(
+      input.sourcePatchRoot,
+      "releaseBlockerPriority.sourcePatchRoot",
+    ),
+    cutLandingEvidenceRoot: exactRoot(
+      input.cutLandingEvidenceRoot,
+      "releaseBlockerPriority.cutLandingEvidenceRoot",
+    ),
+    devLandingEvidenceRoot: exactRoot(
+      input.devLandingEvidenceRoot,
+      "releaseBlockerPriority.devLandingEvidenceRoot",
+    ),
+    publicationGateRoot: exactRoot(
+      input.publicationGateRoot,
+      "releaseBlockerPriority.publicationGateRoot",
+    ),
+    issuedAt: timestamp(input.issuedAt, "releaseBlockerPriority.issuedAt"),
+  };
+  if (body.schema !== RELEASE_BLOCKER_PRIORITY_CLAIM_SCHEMA) {
+    throw new Error("releaseBlockerPriority schema is unsupported");
+  }
+  if (input.claimRoot !== devDeliveryContentRoot(body)) {
+    throw new Error("releaseBlockerPriority claimRoot drift");
+  }
+  if (
+    body.repository !== expected.repository ||
+    body.protectedBase !== expected.protectedBase
+  ) {
+    throw new Error("releaseBlockerPriority queue route mismatch");
+  }
+  if (
+    body.assignmentRoot !== candidate.assignmentRoot ||
+    body.initiativeRoot !== candidate.initiativeRoot
+  ) {
+    throw new Error("releaseBlockerPriority Work identity mismatch");
+  }
+  if (
+    body.sourceHead !== candidate.sourceHead ||
+    body.sourcePatchRoot !== candidate.sourcePatchRoot
+  ) {
+    throw new Error("releaseBlockerPriority source identity mismatch");
+  }
+  return { ...body, claimRoot: input.claimRoot };
+}
+
+export function compareReleaseBlockerPriority(left, right) {
+  const leftBlocker =
+    left.priority.releaseBlocker && left.candidate.priority === "ordinary";
+  const rightBlocker =
+    right.priority.releaseBlocker && right.candidate.priority === "ordinary";
+  if (leftBlocker === rightBlocker) return 0;
+  const peer = leftBlocker ? right : left;
+  return peer.candidate.priority === "ordinary" ? (leftBlocker ? -1 : 1) : 0;
+}