@kungfu-tech/buildchain 3.0.9-alpha.8 → 4.0.0-alpha.0

package/scripts/web-surface-cloudfront-rewrite.mjs

@@ -49,8 +49,8 @@ function runAws(args, { allowFailure = false } = {}) {
   return { ok: true, status: result.status, stdout, stderr };
 }
 
-function runAwsJson(args, options = {}) {
-  const result = runAws([...args, "--output", "json"], options);
+function runAwsJson(args, options = {}, runAwsCommand = runAws) {
+  const result = runAwsCommand([...args, "--output", "json"], options);
   if (!result.ok) {
     return { ok: false, data: null, stderr: result.stderr };
   }
@@ -83,10 +83,10 @@ function writeFunctionCode(tmpDir) {
   return file;
 }
 
-function ensureFunction({ name, comment, codeFile }) {
+function ensureFunction({ name, comment, codeFile, runAwsCommand }) {
   const described = runAwsJson(["cloudfront", "describe-function", "--name", name, "--stage", "DEVELOPMENT"], {
     allowFailure: true,
-  });
+  }, runAwsCommand);
   if (!described.ok) {
     const created = runAwsJson([
       "cloudfront",
@@ -97,7 +97,7 @@ function ensureFunction({ name, comment, codeFile }) {
       functionConfig(comment),
       "--function-code",
       `fileb://${codeFile}`,
-    ]);
+    ], {}, runAwsCommand);
     return {
       etag: created.data?.ETag || "",
       action: "created",
@@ -118,14 +118,14 @@ function ensureFunction({ name, comment, codeFile }) {
     functionConfig(comment),
     "--function-code",
     `fileb://${codeFile}`,
-  ]);
+  ], {}, runAwsCommand);
   return {
     etag: updated.data?.ETag || etag,
     action: "updated",
   };
 }
 
-function publishFunction({ name, etag }) {
+function publishFunction({ name, etag, runAwsCommand }) {
   if (!etag) {
     throw new Error(`cloudfront publish-function requires an ETag for ${name}`);
   }
@@ -136,7 +136,7 @@ function publishFunction({ name, etag }) {
     name,
     "--if-match",
     etag,
-  ]);
+  ], {}, runAwsCommand);
   const summary = published.data?.FunctionSummary || {};
   const arn = summary.FunctionMetadata?.FunctionARN || summary.FunctionARN || "";
   if (!arn) {
@@ -148,10 +148,10 @@ function publishFunction({ name, etag }) {
   };
 }
 
-function attachFunction({ distributionId, functionArn }) {
+function attachFunction({ distributionId, functionArn, runAwsCommand }) {
   let previousViewerRequestFunction;
   for (let attempt = 1; attempt <= DISTRIBUTION_UPDATE_MAX_ATTEMPTS; attempt += 1) {
-    const current = runAwsJson(["cloudfront", "get-distribution-config", "--id", distributionId]);
+    const current = runAwsJson(["cloudfront", "get-distribution-config", "--id", distributionId], {}, runAwsCommand);
     const etag = current.data?.ETag || "";
     const config = current.data?.DistributionConfig;
     if (!etag || !config) {
@@ -207,7 +207,7 @@ function attachFunction({ distributionId, functionArn }) {
         "--distribution-config",
         `file://${configFile}`,
       ];
-      updated = runAws(args, { allowFailure: true });
+      updated = runAwsCommand(args, { allowFailure: true });
     } finally {
       fs.rmSync(tmpDir, { recursive: true, force: true });
     }
@@ -233,7 +233,7 @@ function attachFunction({ distributionId, functionArn }) {
 export function ensureCloudFrontDirectoryIndexRewrite({
   distributionId = "",
   functionName = "",
-  comment = "Buildchain web-surface directory index rewrite",
+  comment = "Buildchain web-surface directory index rewrite", runAwsCommand = runAws,
 } = {}) {
   if (!distributionId) {
     throw new Error("--distribution-id is required");
@@ -244,9 +244,9 @@ export function ensureCloudFrontDirectoryIndexRewrite({
   const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "buildchain-cloudfront-function-"));
   try {
     const codeFile = writeFunctionCode(tmpDir);
-    const ensured = ensureFunction({ name: functionName, comment, codeFile });
-    const published = publishFunction({ name: functionName, etag: ensured.etag });
-    const attached = attachFunction({ distributionId, functionArn: published.arn });
+    const ensured = ensureFunction({ name: functionName, comment, codeFile, runAwsCommand });
+    const published = publishFunction({ name: functionName, etag: ensured.etag, runAwsCommand });
+    const attached = attachFunction({ distributionId, functionArn: published.arn, runAwsCommand });
     return {
       schemaVersion: 1,
       contract: "kungfu-buildchain-web-surface-cloudfront-directory-index-rewrite",

package/scripts/web-surface-core.mjs

@@ -1725,13 +1725,12 @@ async function fetchWithRetry(url, {
   attempts = 3,
   intervalMs = 5000,
   shouldRetry = () => false,
-  requestOptions = { redirect: "follow" },
 } = {}) {
   const maxAttempts = Math.max(1, Number(attempts) || 1);
   let lastError = null;
   for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
     try {
-      const response = await fetchImpl(url, requestOptions);
+      const response = await fetchImpl(url, { redirect: "follow" });
       if (attempt >= maxAttempts || !shouldRetry(response)) {
         return { response, attempts: attempt };
       }
@@ -1752,11 +1751,6 @@ function retryableHealthResponse(response) {
   return response.status === 403 || response.status === 404 || response.status >= 500;
 }
 
-function retryingHealthFetch(fetchImpl, attempts, intervalMs) {
-  return (url, requestOptions) => fetchWithRetry(url, { fetchImpl, attempts, intervalMs,
-    shouldRetry: retryableHealthResponse, requestOptions }).then(({ response }) => response);
-}
-
 const DEFAULT_HEALTH_HTTP_RETRY_ATTEMPTS = 12;
 const DEFAULT_HEALTH_HTTP_RETRY_INTERVAL_MS = 10000;
 
@@ -1990,7 +1984,7 @@ export async function checkWebSurfaceHealth({
       };
       const evidence = await verifyInstallerPublicReadback({
         publication: projected,
-        fetchImpl: retryingHealthFetch(fetchImpl, httpRetryAttempts, httpRetryIntervalMs),
+        fetchImpl,
       });
       checks.push({
         surface: "__installer__",

package/scripts/workflow-call-contract.mjs

@@ -4,170 +4,13 @@ import path from "node:path";
 import { execFileSync } from "node:child_process";
 import { pathToFileURL } from "node:url";
 import { evaluateWorkflowCallContract } from "../packages/core/workflow-call-contract.js";
-import { parseWorkflowDocument } from "../packages/core/workflow-yaml-contract.js";
-
-export const SELF_RELEASE_REF = "cc6c32845ab5779009aeb48cc34efe65e229fe30";
-export const SELF_RELEASE_PUBLIC_WORKFLOW = `kungfu-systems/buildchain/.github/workflows/release-candidate-promote.yml@${SELF_RELEASE_REF}`;
-
-function parityFailure(message) {
-  throw new Error(`self-release route parity: ${message}`);
-}
-
-function literal(job, name) {
-  const value = job?.with?.[name];
-  if (!value || value.kind === "expression") {
-    parityFailure(`${job?.id || "<missing>"}.${name} must be a literal`);
-  }
-  return value.value;
-}
-
-export function selfReleaseRouteIdentity(workflowText, jobId = "promote") {
-  const job = parseWorkflowDocument(workflowText).callJobs.find(
-    (entry) => entry.id === jobId,
-  );
-  if (!job) parityFailure(`reusable workflow job is missing: ${jobId}`);
-  if (
-    job.uses.startsWith("./") ||
-    job.uses.includes("/.release-candidate-promote.yml@")
-  ) {
-    parityFailure(
-      `authoritative caller uses an internal or checkout-relative route: ${job.uses}`,
-    );
-  }
-  if (job.uses !== SELF_RELEASE_PUBLIC_WORKFLOW) {
-    parityFailure(
-      `caller uses ${job.uses}, expected ${SELF_RELEASE_PUBLIC_WORKFLOW}`,
-    );
-  }
-  if (literal(job, "buildchain-ref") !== SELF_RELEASE_REF) {
-    parityFailure("caller runtime ref differs from the public workflow ref");
-  }
-  if (literal(job, "declarative-release-tail") !== true) {
-    parityFailure(
-      "caller does not require the declarative release-tail provider plane",
-    );
-  }
-  return {
-    publicWorkflow: job.uses,
-    runtimeRef: SELF_RELEASE_REF,
-    declarationContract: "kungfu-buildchain-release-tail-capabilities/v1",
-    declarationCompiler:
-      "packages/core/release-tail-provider-plane.js#compileReleaseTailDeclaration",
-    transaction:
-      "packages/core/release-tail-provider-plane.js#executeReleaseTailTransaction",
-    providerAdapter:
-      "packages/core/release-tail-provider-adapters.js#createGitHubReleaseAssetsAdapter",
-    receiptValidator:
-      "packages/core/release-tail-provider-plane.js#validateReleaseTailTransaction",
-  };
-}
-
-export function assertSelfReleaseRouteParity({
-  selfWorkflowText,
-  consumerWorkflowText,
-  routing,
-  publicWorkflowText,
-  advancedWorkflowText,
-  actionText,
-  providerPlanText,
-} = {}) {
-  const self = selfReleaseRouteIdentity(selfWorkflowText);
-  const consumer = selfReleaseRouteIdentity(consumerWorkflowText);
-  if (JSON.stringify(self) !== JSON.stringify(consumer)) {
-    parityFailure(
-      "Buildchain self-release and representative consumer identities differ",
-    );
-  }
-  const alphaShellRef = routing?.alpha?.callRef;
-  if (alphaShellRef !== "train/v3/v3.0/consumer-equivalent-self-dogfood") {
-    parityFailure(
-      "alpha workflow shell does not resolve through the self-dogfood train",
-    );
-  }
-  for (const required of [
-    "uses: kungfu-systems/buildchain/.github/workflows/.release-candidate-promote.yml@train/v3/v3.0/consumer-equivalent-self-dogfood",
-    "declarative-release-tail: ${{ inputs.declarative-release-tail }}",
-  ]) {
-    if (!publicWorkflowText.includes(required)) {
-      parityFailure(`public router is missing: ${required}`);
-    }
-  }
-  for (const required of [
-    "declarative-release-tail:",
-    "declarative-release-tail: ${{ inputs.declarative-release-tail }}",
-    "release-tail-transaction-root:",
-  ]) {
-    if (!advancedWorkflowText.includes(required)) {
-      parityFailure(`advanced workflow shell is missing: ${required}`);
-    }
-  }
-  for (const required of [
-    "executeReleaseTailTransaction",
-    "createGitHubReleaseAssetsAdapter",
-    "publishDeclarativeGitHubReleaseEvidence",
-  ]) {
-    if (!actionText.includes(required)) {
-      parityFailure(
-        `promotion action is missing provider-plane identity: ${required}`,
-      );
-    }
-  }
-  for (const required of [
-    "compileReleaseTailDeclaration",
-    "githubReleaseAssetsTargetRoot",
-    "createDeclarativeGitHubReleasePlan",
-  ]) {
-    if (!providerPlanText.includes(required)) {
-      parityFailure(`declarative GitHub Release plan is missing: ${required}`);
-    }
-  }
-  return {
-    schema: "kungfu.buildchain.self-release-route-parity/v1",
-    ok: true,
-    self,
-    consumer,
-    workflowShellRef: routing.alpha.callRef,
-  };
-}
-
-export function checkSelfReleaseRouteParity({ root, observed = {} } = {}) {
-  const read = (relative) => fs.readFileSync(path.join(root, relative), "utf8");
-  const report = assertSelfReleaseRouteParity({
-    selfWorkflowText: read(".github/workflows/buildchain-ref-promotion.yml"),
-    consumerWorkflowText: read(
-      "tests/fixtures/self-release-route/external-consumer.yml",
-    ),
-    routing: JSON.parse(read(".buildchain/promotion-shell-routing.json")),
-    publicWorkflowText: read(".github/workflows/release-candidate-promote.yml"),
-    advancedWorkflowText: read(
-      ".github/workflows/.release-candidate-promote.yml",
-    ),
-    actionText: `${read("actions/promote-buildchain-ref/index.js")}\n${read("actions/promote-buildchain-ref/github-release.js")}`,
-    providerPlanText: read("actions/promote-buildchain-ref/github-release.js"),
-  });
-  const rootPattern = /^sha256:[0-9a-f]{64}$/u;
-  const shaPattern = /^[0-9a-f]{40}$/u;
-  for (const [name, value] of Object.entries(observed)) {
-    if (!value) continue;
-    const valid =
-      name === "runtimeSha" ? shaPattern.test(value) : rootPattern.test(value);
-    if (!valid)
-      parityFailure(`observed ${name} is not an exact rooted identity`);
-  }
-  return { ...report, observed };
-}
 
 function usage() {
-  return `usage:
-  node scripts/workflow-call-contract.mjs check \\
+  return `usage: node scripts/workflow-call-contract.mjs check \\
   --caller-workflow <path> --job <id> --caller-repository <owner/repo> \\
   --callee-root <checkout> --callee-workflow <path> --callee-repository <owner/repo> \\
   --trusted-event <event[:type]> [--trusted-event ...] \\
-  [--expected-contract-root sha256:...] [--allow-dirty] [--output <path>]
-  node scripts/workflow-call-contract.mjs self-release-parity \\
-  [--root <checkout>] [--runtime-sha <sha>] [--contract-root <root>] \\
-  [--release-tail-declaration-root <root>] [--release-tail-transaction-root <root>] \\
-  [--release-tail-state-root <root>] [--output <path>]`;
+  [--expected-contract-root sha256:...] [--allow-dirty] [--output <path>]`;
 }
 
 function parseArgs(argv) {
@@ -178,7 +21,7 @@ function parseArgs(argv) {
       options.allowDirty = true;
       continue;
     }
-    if (!arg.startsWith("--") || index + 1 >= argv.length)
+    if (!arg.startsWith("--") || !argv[index + 1])
       throw new Error(`invalid argument: ${arg}`);
     const value = argv[index + 1];
     index += 1;
@@ -224,9 +67,7 @@ export function checkWorkflowCall(options) {
     "--untracked-files=no",
   );
   if (calleeStatus) {
-    throw new Error(
-      "callee checkout is dirty; exact pinned-ref bytes are required",
-    );
+    throw new Error("callee checkout is dirty; exact pinned-ref bytes are required");
   }
   const callerSha = git(callerRoot, "rev-parse", "HEAD");
   const callerTree = git(callerRoot, "rev-parse", "HEAD^{tree}");
@@ -262,28 +103,8 @@ export function checkWorkflowCall(options) {
 
 function main(argv = process.argv.slice(2)) {
   const command = argv.shift();
-  const options = parseArgs(argv);
-  if (command === "self-release-parity") {
-    const root = options.root ? path.resolve(options.root) : process.cwd();
-    const report = checkSelfReleaseRouteParity({
-      root,
-      observed: {
-        runtimeSha: options.runtimeSha || "",
-        contractRoot: options.contractRoot || "",
-        releaseTailDeclarationRoot: options.releaseTailDeclarationRoot || "",
-        releaseTailTransactionRoot: options.releaseTailTransactionRoot || "",
-        releaseTailStateRoot: options.releaseTailStateRoot || "",
-      },
-    });
-    if (options.output) {
-      const output = path.resolve(root, options.output);
-      fs.mkdirSync(path.dirname(output), { recursive: true });
-      fs.writeFileSync(output, `${JSON.stringify(report, null, 2)}\n`);
-    }
-    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
-    return;
-  }
   if (command !== "check") throw new Error(usage());
+  const options = parseArgs(argv);
   required(options, [
     "callerWorkflow",
     "job",

package/contracts/fixtures/kfd-adopter-release-v1/kfd-4-perspective.json

@@ -1,16 +0,0 @@
-{
-  "schemaVersion": 1,
-  "contract": "kfd-4-observer-perspective",
-  "standard": "kfd-4",
-  "id": "buildchain-release-maintainer-view",
-  "observer": { "id": "buildchain-release-maintainer", "kind": "human" },
-  "acceptedFacts": [
-    { "sourceId": "kungfu-systems/buildchain@{{SOURCE_SHA}}", "sourceKind": "repository" }
-  ],
-  "projectionPolicy": {
-    "policyVersion": "1",
-    "causalDominance": true,
-    "tieBreaker": "source-coordinate"
-  },
-  "verification": { "result": "pass" }
-}

package/contracts/fixtures/kfd-adopter-release-v1/kfd-4-replay.json

@@ -1,57 +0,0 @@
-{
-  "schemaVersion": 1,
-  "contract": "kfd-4-perspective-replay",
-  "standard": "kfd-4",
-  "replayId": "buildchain-release-product-contrast",
-  "mode": "contrastive",
-  "sourceViews": [
-    {
-      "id": "maintainer",
-      "kind": "observer-view",
-      "coordinate": "git://kungfu-systems/buildchain@{{SOURCE_SHA}}",
-      "observer": "buildchain-release-maintainer",
-      "perspective": "release-integrity",
-      "acceptedFactCut": "git://kungfu-systems/buildchain@{{SOURCE_SHA}}",
-      "naturalObjects": ["release"],
-      "consequences": ["published artifact"],
-      "knownGaps": []
-    },
-    {
-      "id": "consumer",
-      "kind": "observer-view",
-      "coordinate": "npm://@kungfu-tech/buildchain@{{SOURCE_SHA}}",
-      "observer": "buildchain-release-consumer",
-      "perspective": "artifact-consumption",
-      "acceptedFactCut": "artifact://published-package",
-      "naturalObjects": ["installed package"],
-      "consequences": ["local build execution"],
-      "knownGaps": ["consumer runtime state"]
-    }
-  ],
-  "replayObserver": {
-    "id": "buildchain",
-    "kind": "service",
-    "purpose": "retain source and artifact fact boundaries"
-  },
-  "reconstruction": {
-    "policyVersion": "1",
-    "sharedContext": "same source-bound release",
-    "preservedElements": ["observer", "accepted-fact-cut", "evidence-boundary"],
-    "declaredLoss": ["consumer runtime state"],
-    "degradedState": "none"
-  },
-  "contrast": {
-    "dimensions": ["evidence-boundary"],
-    "mismatches": [
-      {
-        "sourceViewIds": ["maintainer", "consumer"],
-        "observation": "source and installed artifact evidence have different custody",
-        "primitiveSignal": "inconclusive"
-      }
-    ]
-  },
-  "verification": {
-    "result": "pass",
-    "evidence": ["evidence/projection-fsck.json"]
-  }
-}

package/contracts/fixtures/next-development-transition-v1/anchored-manual-waiting.json

@@ -1,47 +0,0 @@
-{
-  "schemaVersion": 1,
-  "contract": "kungfu-buildchain-next-development-transition/v1",
-  "idempotencyKey": "sha256:cf805c1933cbc3e571c21af3ae030139bebafb08e2436b3c479c411b2cd2d22c",
-  "repository": "example/widget",
-  "completedAlpha": {
-    "outcome": "succeeded",
-    "version": "1.4.2-alpha.7",
-    "exactTag": "v1.4.2-alpha.7",
-    "releaseSha": "1111111111111111111111111111111111111111",
-    "treeSha": "2222222222222222222222222222222222222222",
-    "publicationRoot": "sha256:3333333333333333333333333333333333333333333333333333333333333333",
-    "completedAt": "2026-08-11T01:00:00.000Z"
-  },
-  "completedAlphaRoot": "sha256:18e65c63aba0df789e0b0e68903733825d87e292b82bcb8fd3793ca45dca6266",
-  "alphaOutcome": "preserved-success",
-  "model": {
-    "strategy": "anchored",
-    "next": "manual"
-  },
-  "target": {
-    "version": null,
-    "anchor": null
-  },
-  "declaredPaths": ["package.json", "release.json"],
-  "adapter": {
-    "environmentVariable": "BUILDCHAIN_VERSION",
-    "sourcePaths": ["package.json"],
-    "derivedPaths": [],
-    "allowedChangePaths": ["package.json"],
-    "readOnlyPaths": ["release.json"],
-    "derivationStage": null,
-    "verificationStage": "lifecycle.verify"
-  },
-  "effectBounds": {
-    "allowedPaths": ["package.json"],
-    "refUpdates": [],
-    "forbiddenRefNamespaces": ["refs/heads/alpha/", "refs/tags/"]
-  },
-  "state": {
-    "status": "waiting-anchor",
-    "generation": 1,
-    "stateRoot": "sha256:4bbca86f960a7c1a10d76d01736422e3129f3f16d3e69e0800a0829201122dd4"
-  },
-  "materialization": null,
-  "transitions": []
-}

package/contracts/fixtures/next-development-transition-v1/semver-auto-planned.json

@@ -1,47 +0,0 @@
-{
-  "schemaVersion": 1,
-  "contract": "kungfu-buildchain-next-development-transition/v1",
-  "idempotencyKey": "sha256:37ee52799584a989b059db060b7ce062feb56fbeff452033245046fdf3b21e78",
-  "repository": "example/widget",
-  "completedAlpha": {
-    "outcome": "succeeded",
-    "version": "1.4.2-alpha.7",
-    "exactTag": "v1.4.2-alpha.7",
-    "releaseSha": "1111111111111111111111111111111111111111",
-    "treeSha": "2222222222222222222222222222222222222222",
-    "publicationRoot": "sha256:3333333333333333333333333333333333333333333333333333333333333333",
-    "completedAt": "2026-08-11T01:00:00.000Z"
-  },
-  "completedAlphaRoot": "sha256:18e65c63aba0df789e0b0e68903733825d87e292b82bcb8fd3793ca45dca6266",
-  "alphaOutcome": "preserved-success",
-  "model": {
-    "strategy": "semver",
-    "next": "auto"
-  },
-  "target": {
-    "version": "1.4.2-alpha.8",
-    "anchor": null
-  },
-  "declaredPaths": ["package.json"],
-  "adapter": {
-    "environmentVariable": "BUILDCHAIN_VERSION",
-    "sourcePaths": ["package.json"],
-    "derivedPaths": [],
-    "allowedChangePaths": ["package.json"],
-    "readOnlyPaths": [],
-    "derivationStage": null,
-    "verificationStage": "lifecycle.verify"
-  },
-  "effectBounds": {
-    "allowedPaths": ["package.json"],
-    "refUpdates": [],
-    "forbiddenRefNamespaces": ["refs/heads/alpha/", "refs/tags/"]
-  },
-  "state": {
-    "status": "planned",
-    "generation": 1,
-    "stateRoot": "sha256:4ef8ac1ff07cb14633994625e65a340acb3130ae56bbc88ee81504f09df3fa0f"
-  },
-  "materialization": null,
-  "transitions": []
-}

package/contracts/fixtures/next-development-transition-v1/version-model-cases.json

@@ -1,40 +0,0 @@
-{
-  "contract": "kungfu-buildchain-next-development-version-model-fixtures/v1",
-  "positive": [
-    {
-      "name": "semver-auto",
-      "model": { "strategy": "semver", "next": "auto" }
-    },
-    {
-      "name": "anchored-manual",
-      "model": { "strategy": "anchored", "next": "manual" }
-    }
-  ],
-  "negative": [
-    {
-      "name": "semver-manual",
-      "model": { "strategy": "semver", "next": "manual" },
-      "error": "version model must be semver/auto or anchored/manual"
-    },
-    {
-      "name": "anchored-auto",
-      "model": { "strategy": "anchored", "next": "auto" },
-      "error": "version model must be semver/auto or anchored/manual"
-    },
-    {
-      "name": "semver-auto-with-anchor",
-      "model": { "strategy": "semver", "next": "auto" },
-      "anchor": {
-        "manifestPath": "release.json",
-        "manifestRoot": "sha256:4444444444444444444444444444444444444444444444444444444444444444"
-      },
-      "error": "semver/auto must not declare an anchor"
-    },
-    {
-      "name": "anchored-manual-target-without-anchor",
-      "model": { "strategy": "anchored", "next": "manual" },
-      "targetVersion": "22.1.0",
-      "error": "anchored/manual targetVersion requires an anchor"
-    }
-  ]
-}

package/contracts/next-development-request-v1.schema.json

@@ -1,66 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://buildchain.libkungfu.dev/schemas/next-development-request-v1.schema.json",
-  "title": "Buildchain Next-development Request v1",
-  "type": "object",
-  "additionalProperties": false,
-  "required": ["contract", "repository", "completedAlpha", "recordedAt"],
-  "properties": {
-    "contract": {
-      "const": "kungfu-buildchain-next-development-request/v1"
-    },
-    "repository": {
-      "type": "string",
-      "pattern": "^[^/\\s]+/[^/\\s]+$"
-    },
-    "completedAlpha": { "$ref": "#/$defs/completedAlpha" },
-    "targetVersion": { "$ref": "#/$defs/semver" },
-    "anchor": { "$ref": "#/$defs/anchor" },
-    "recordedAt": { "type": "string", "format": "date-time" }
-  },
-  "$defs": {
-    "gitSha": { "type": "string", "pattern": "^[0-9a-f]{40}$" },
-    "root": { "type": "string", "pattern": "^sha256:[0-9a-f]{64}$" },
-    "semver": {
-      "type": "string",
-      "pattern": "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)(?:-[0-9A-Za-z.-]+)?(?:\\+[0-9A-Za-z.-]+)?$"
-    },
-    "completedAlpha": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": [
-        "outcome",
-        "version",
-        "exactTag",
-        "releaseSha",
-        "treeSha",
-        "publicationRoot",
-        "completedAt"
-      ],
-      "properties": {
-        "outcome": { "const": "succeeded" },
-        "version": {
-          "type": "string",
-          "pattern": "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)-alpha\\.(0|[1-9][0-9]*)$"
-        },
-        "exactTag": { "type": "string", "minLength": 1 },
-        "releaseSha": { "$ref": "#/$defs/gitSha" },
-        "treeSha": { "$ref": "#/$defs/gitSha" },
-        "publicationRoot": { "$ref": "#/$defs/root" },
-        "completedAt": { "type": "string", "format": "date-time" }
-      }
-    },
-    "anchor": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["manifestPath", "manifestRoot"],
-      "properties": {
-        "manifestPath": {
-          "type": "string",
-          "pattern": "^(?!/)(?!.*(?:^|/)\\.\\.(?:/|$))[^\\s]+$"
-        },
-        "manifestRoot": { "$ref": "#/$defs/root" }
-      }
-    }
-  }
-}