@kungfu-tech/buildchain 3.0.9-alpha.9 → 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/dev-delivery-authority-v2.schema.json

@@ -1,253 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://buildchain.libkungfu.dev/schemas/dev-delivery-authority-v2.schema.json",
-  "title": "Buildchain Dev Delivery Authority State v2",
-  "description": "Opt-in durable state separating bounded qualification-only leases from one exclusive merge_group Landing Warrant.",
-  "type": "object",
-  "additionalProperties": false,
-  "required": [
-    "schemaVersion",
-    "contract",
-    "authorityMode",
-    "repository",
-    "protectedBase",
-    "generation",
-    "qualificationCounter",
-    "landingCounter",
-    "policy",
-    "qualificationLeases",
-    "landingWarrant",
-    "candidates",
-    "migration",
-    "updatedAt",
-    "stateRoot"
-  ],
-  "properties": {
-    "schemaVersion": { "const": 2 },
-    "contract": { "const": "kungfu-buildchain-dev-delivery-authority" },
-    "authorityMode": { "const": "bounded-qualification-landing" },
-    "repository": {
-      "type": "string",
-      "pattern": "^[^/\\s]+/[^/\\s]+$"
-    },
-    "protectedBase": {
-      "type": "string",
-      "pattern": "^dev/v[0-9]+/v[0-9]+\\.[0-9]+$"
-    },
-    "generation": { "type": "integer", "minimum": 0 },
-    "qualificationCounter": { "type": "integer", "minimum": 0 },
-    "landingCounter": { "type": "integer", "minimum": 0 },
-    "policy": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": [
-        "maxQualificationLeases",
-        "qualificationLeaseSeconds",
-        "landingLeaseSeconds"
-      ],
-      "properties": {
-        "maxQualificationLeases": { "type": "integer", "minimum": 1 },
-        "qualificationLeaseSeconds": { "type": "integer", "minimum": 1 },
-        "landingLeaseSeconds": { "type": "integer", "minimum": 1 },
-        "maxLandingOvertakes": { "type": "integer", "minimum": 0 },
-        "maxQualificationAttempts": { "type": "integer", "minimum": 1 }
-      }
-    },
-    "qualificationLeases": {
-      "type": "array",
-      "items": { "$ref": "#/$defs/qualificationLease" }
-    },
-    "landingWarrant": {
-      "oneOf": [{ "type": "null" }, { "$ref": "#/$defs/landingWarrant" }]
-    },
-    "candidates": {
-      "type": "array",
-      "items": { "$ref": "#/$defs/candidate" }
-    },
-    "migration": {
-      "oneOf": [{ "type": "null" }, { "$ref": "#/$defs/migration" }]
-    },
-    "updatedAt": { "type": "string", "format": "date-time" },
-    "stateRoot": { "$ref": "#/$defs/root" }
-  },
-  "$defs": {
-    "root": {
-      "type": "string",
-      "pattern": "^sha256:[0-9a-f]{64}$"
-    },
-    "sha": {
-      "type": "string",
-      "pattern": "^[0-9a-f]{40}$"
-    },
-    "qualificationLease": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": [
-        "schema",
-        "authority",
-        "mergeGroupAdmission",
-        "candidateId",
-        "token",
-        "generation",
-        "issuedAt",
-        "expiresAt"
-      ],
-      "properties": {
-        "schema": {
-          "const": "kungfu.buildchain.dev-delivery-qualification-lease/v1"
-        },
-        "authority": { "const": "qualification-only" },
-        "mergeGroupAdmission": { "const": false },
-        "candidateId": { "$ref": "#/$defs/root" },
-        "token": { "$ref": "#/$defs/root" },
-        "generation": { "type": "integer", "minimum": 1 },
-        "issuedAt": { "type": "string", "format": "date-time" },
-        "heartbeatAt": { "type": "string", "format": "date-time" },
-        "expiresAt": { "type": "string", "format": "date-time" }
-      }
-    },
-    "landingWarrant": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": [
-        "schema",
-        "authority",
-        "mergeGroupAdmission",
-        "candidateId",
-        "token",
-        "generation",
-        "issuedAt",
-        "expiresAt"
-      ],
-      "properties": {
-        "schema": {
-          "const": "kungfu.buildchain.dev-delivery-landing-warrant/v1"
-        },
-        "authority": { "const": "merge-group-admission" },
-        "mergeGroupAdmission": { "const": true },
-        "candidateId": { "$ref": "#/$defs/root" },
-        "token": { "$ref": "#/$defs/root" },
-        "generation": { "type": "integer", "minimum": 1 },
-        "issuedAt": { "type": "string", "format": "date-time" },
-        "heartbeatAt": { "type": "string", "format": "date-time" },
-        "expiresAt": { "type": "string", "format": "date-time" }
-      }
-    },
-    "qualification": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["evidenceRoot", "qualifiedAt"],
-      "properties": {
-        "evidenceRoot": { "$ref": "#/$defs/root" },
-        "qualifiedAt": { "type": "string", "format": "date-time" }
-      }
-    },
-    "terminal": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["outcome", "evidenceRoot", "reason", "settledAt"],
-      "properties": {
-        "outcome": {
-          "enum": ["merged", "terminal-failure", "dequeued", "cancelled"]
-        },
-        "evidenceRoot": { "$ref": "#/$defs/root" },
-        "reason": { "type": "string" },
-        "settledAt": { "type": "string", "format": "date-time" }
-      }
-    },
-    "migration": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["schema", "legacyContract", "legacyStateRoot", "migratedAt"],
-      "properties": {
-        "schema": {
-          "const": "kungfu.buildchain.dev-delivery-authority-migration/v1"
-        },
-        "legacyContract": {
-          "const": "kungfu-buildchain-dev-delivery-warrant-queue"
-        },
-        "legacyStateRoot": { "$ref": "#/$defs/root" },
-        "migratedAt": { "type": "string", "format": "date-time" }
-      }
-    },
-    "candidate": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": [
-        "repository",
-        "protectedBase",
-        "pullRequestNumber",
-        "assignmentRoot",
-        "initiativeRoot",
-        "sourceIdentityRoot",
-        "deliveryClass",
-        "candidateId",
-        "sourceHead",
-        "sourcePatchRoot",
-        "sourceProofRoot",
-        "planRoot",
-        "closureRoot",
-        "dependencyRoot",
-        "toolchainRoot",
-        "enqueuedAt",
-        "updatedAt",
-        "status",
-        "qualification",
-        "terminal"
-      ],
-      "properties": {
-        "repository": { "type": "string" },
-        "protectedBase": { "type": "string" },
-        "pullRequestNumber": { "type": "integer", "minimum": 1 },
-        "assignmentRoot": { "$ref": "#/$defs/root" },
-        "initiativeRoot": { "$ref": "#/$defs/root" },
-        "sourceIdentityRoot": { "$ref": "#/$defs/root" },
-        "deliveryClass": {
-          "enum": [
-            "non-native-fast",
-            "native-proof-required",
-            "cross-platform",
-            "release"
-          ]
-        },
-        "identitySemantics": { "const": "chained-attempt-v2" },
-        "predecessorCandidateId": { "$ref": "#/$defs/root" },
-        "candidateId": { "$ref": "#/$defs/root" },
-        "sourceHead": { "$ref": "#/$defs/sha" },
-        "sourcePatchRoot": { "$ref": "#/$defs/root" },
-        "sourceProofRoot": { "$ref": "#/$defs/root" },
-        "planRoot": { "$ref": "#/$defs/root" },
-        "closureRoot": { "$ref": "#/$defs/root" },
-        "dependencyRoot": { "$ref": "#/$defs/root" },
-        "toolchainRoot": { "$ref": "#/$defs/root" },
-        "qualificationDomains": {
-          "type": "array",
-          "uniqueItems": true,
-          "items": { "$ref": "#/$defs/root" }
-        },
-        "qualificationAttempts": { "type": "integer", "minimum": 0 },
-        "landingOvertakes": { "type": "integer", "minimum": 0 },
-        "enqueuedAt": { "type": "string", "format": "date-time" },
-        "updatedAt": { "type": "string", "format": "date-time" },
-        "status": {
-          "enum": [
-            "queued",
-            "qualifying",
-            "qualified",
-            "landing",
-            "merged",
-            "terminal-failure",
-            "dequeued",
-            "cancelled"
-          ]
-        },
-        "qualification": {
-          "oneOf": [{ "type": "null" }, { "$ref": "#/$defs/qualification" }]
-        },
-        "terminal": {
-          "oneOf": [{ "type": "null" }, { "$ref": "#/$defs/terminal" }]
-        }
-      }
-    }
-  }
-}

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