@kungfu-tech/buildchain 4.0.2-alpha.9 → 4.0.3-alpha.0

package/packages/core/{v4-platform-stage-checkpoints.js → platform-stage-checkpoints.js}

@@ -2,34 +2,34 @@ import fs from "node:fs";
 import path from "node:path";
 
 import {
-  V4ContractFault,
-  v4CanonicalBytes,
-  validateV4Clock,
-  validateV4Root,
-} from "./v4-canonical-contracts.js";
+  ContractFault,
+  domainCanonicalBytes,
+  validateClock,
+  validateRoot,
+} from "./canonical-contracts.js";
 import {
-  V4_STAGE_CAPSULE_CONTRACT,
-  V4_STAGE_CAPSULE_IDENTITY_CONTRACT,
-  v4StageCapsuleIdentityRoot,
-  v4StageCapsuleRoot,
-  validateV4StageCapsule,
-} from "./v4-stage-capsule.js";
+  STAGE_CAPSULE_CONTRACT,
+  STAGE_CAPSULE_IDENTITY_CONTRACT,
+  stageCapsuleIdentityRoot,
+  stageCapsuleRoot,
+  validateStageCapsule,
+} from "./stage-capsule.js";
 import {
-  V4_STAGE_CAPSULE_OUTPUT_MANIFEST_CONTRACT,
-  v4StageCapsuleBlobRoot,
-  v4StageCapsuleOutputManifestRoot,
-} from "./v4-stage-capsule-store.js";
+  STAGE_CAPSULE_OUTPUT_MANIFEST_CONTRACT,
+  stageCapsuleBlobRoot,
+  stageCapsuleOutputManifestRoot,
+} from "./stage-capsule-store.js";
 
-export const V4_PLATFORM_STAGE_CHECKPOINT_CONTRACT =
+export const PLATFORM_STAGE_CHECKPOINT_CONTRACT =
   "buildchain-v4-platform-stage-checkpoint/v1";
-export const V4_PLATFORM_STAGE_RESTORE_CONTRACT =
+export const PLATFORM_STAGE_RESTORE_CONTRACT =
   "buildchain-v4-platform-stage-restore/v1";
 
 const TOKEN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u;
 const ZERO_ROOT = `sha256:${"0".repeat(64)}`;
 
 function fault(code, location, message) {
-  throw new V4ContractFault(code, location, message);
+  throw new ContractFault(code, location, message);
 }
 
 function object(value, location) {
@@ -76,14 +76,14 @@ function tokens(values, location) {
 }
 
 function rootOf(value) {
-  return v4StageCapsuleBlobRoot(v4CanonicalBytes(value));
+  return stageCapsuleBlobRoot(domainCanonicalBytes(value));
 }
 
 function declaredMap(value, names, location, { roots = false } = {}) {
   exactKeys(value, names, location);
   return names.map((name) => {
     const entry = value[name];
-    if (roots) validateV4Root(entry, `${location}/${name}`);
+    if (roots) validateRoot(entry, `${location}/${name}`);
     else if (typeof entry !== "string")
       fault(
         "invalid-stage-checkpoint-value",
@@ -112,7 +112,7 @@ function safeRelative(relativePath, location) {
   return relativePath;
 }
 
-export function validateV4PlatformStageCheckpointDeclaration(value) {
+export function validatePlatformStageCheckpointDeclaration(value) {
   exactKeys(
     value,
     [
@@ -250,7 +250,7 @@ export function validateV4PlatformStageCheckpointDeclaration(value) {
 }
 
 function select(declaration, platformId, stageId) {
-  validateV4PlatformStageCheckpointDeclaration(declaration);
+  validatePlatformStageCheckpointDeclaration(declaration);
   const platform = declaration.platforms.find(
     (entry) => entry.id === platformId,
   );
@@ -273,24 +273,24 @@ function outputManifest(stage, outputs) {
   const entries = stage.outputs
     .map(({ name }) => {
       const bytes = Buffer.from(outputs[name]);
-      return { name, root: v4StageCapsuleBlobRoot(bytes), size: bytes.length };
+      return { name, root: stageCapsuleBlobRoot(bytes), size: bytes.length };
     })
     .sort((left, right) => left.name.localeCompare(right.name, "en"));
   const draft = {
-    schema: V4_STAGE_CAPSULE_OUTPUT_MANIFEST_CONTRACT,
+    schema: STAGE_CAPSULE_OUTPUT_MANIFEST_CONTRACT,
     entries,
     manifestRoot: ZERO_ROOT,
   };
-  return { ...draft, manifestRoot: v4StageCapsuleOutputManifestRoot(draft) };
+  return { ...draft, manifestRoot: stageCapsuleOutputManifestRoot(draft) };
 }
 
-export function emitV4PlatformStageCheckpoint(request) {
+export function emitPlatformStageCheckpoint(request) {
   const { platform, stage } = select(
     request.declaration,
     request.platformId,
     request.stageId,
   );
-  validateV4Clock(request.recordedAt, "$/request/recordedAt");
+  validateClock(request.recordedAt, "$/request/recordedAt");
   if (request.stageOutcome !== "success")
     return Object.freeze({ emitted: false, reason: "stage-not-successful" });
   if (!Number.isSafeInteger(request.overheadMs) || request.overheadMs < 0)
@@ -342,7 +342,7 @@ export function emitV4PlatformStageCheckpoint(request) {
     shadowLifecycleRoot,
   };
   const identity = {
-    schema: V4_STAGE_CAPSULE_IDENTITY_CONTRACT,
+    schema: STAGE_CAPSULE_IDENTITY_CONTRACT,
     sourceRoot: request.inputs["source-tree"],
     platform: platform.id,
     platformRoot: rootOf(platform),
@@ -360,16 +360,16 @@ export function emitV4PlatformStageCheckpoint(request) {
     ],
   };
   const capsule = {
-    schema: V4_STAGE_CAPSULE_CONTRACT,
+    schema: STAGE_CAPSULE_CONTRACT,
     writerAuthority: "typescript-v3",
     rustAuthority: "validation-only",
     identity,
-    identityRoot: v4StageCapsuleIdentityRoot(identity),
+    identityRoot: stageCapsuleIdentityRoot(identity),
     retentionPromise: request.retentionPromise,
     capsuleRoot: ZERO_ROOT,
   };
-  capsule.capsuleRoot = v4StageCapsuleRoot(capsule);
-  validateV4StageCapsule(capsule);
+  capsule.capsuleRoot = stageCapsuleRoot(capsule);
+  validateStageCapsule(capsule);
   const blobs = manifest.entries.map((entry) => ({
     name: entry.name,
     bytes: Buffer.from(request.outputs[entry.name]),
@@ -381,7 +381,7 @@ export function emitV4PlatformStageCheckpoint(request) {
     recordedAt: request.recordedAt,
   });
   const body = {
-    schema: V4_PLATFORM_STAGE_CHECKPOINT_CONTRACT,
+    schema: PLATFORM_STAGE_CHECKPOINT_CONTRACT,
     mode: "shadow-only",
     platform: platform.id,
     stage: stage.id,
@@ -413,13 +413,13 @@ function ensureEmptyDirectory(targetDirectory) {
   return target;
 }
 
-export function restoreV4PlatformStageCheckpoint(request) {
+export function restorePlatformStageCheckpoint(request) {
   const { stage } = select(
     request.declaration,
     request.expectedPlatform,
     request.expectedStage,
   );
-  validateV4Clock(request.recordedAt, "$/request/recordedAt");
+  validateClock(request.recordedAt, "$/request/recordedAt");
   const restored = request.store.restore({
     capsuleRoot: request.capsuleRoot,
     recordedAt: request.recordedAt,
@@ -449,7 +449,7 @@ export function restoreV4PlatformStageCheckpoint(request) {
     );
     fs.mkdirSync(path.dirname(destination), { recursive: true });
     fs.writeFileSync(destination, blob.bytes, { flag: "wx" });
-    if (v4StageCapsuleBlobRoot(fs.readFileSync(destination)) !== blob.root)
+    if (stageCapsuleBlobRoot(fs.readFileSync(destination)) !== blob.root)
       fault(
         "stage-capsule-root-mismatch",
         `$/restore/${output.name}`,
@@ -457,7 +457,7 @@ export function restoreV4PlatformStageCheckpoint(request) {
       );
   }
   const body = {
-    schema: V4_PLATFORM_STAGE_RESTORE_CONTRACT,
+    schema: PLATFORM_STAGE_RESTORE_CONTRACT,
     platform: request.expectedPlatform,
     stage: request.expectedStage,
     capsuleRoot: request.capsuleRoot,

package/packages/core/product-publication.js

@@ -0,0 +1,59 @@
+import { invokeDomainWasm } from "./domain-wasm.js";
+
+export const PRODUCT_PUBLICATION_INTENT_CONTRACT =
+  "kungfu-buildchain-v4-product-publication-intent/v1";
+export const PRODUCT_PUBLICATION_PLAN_CONTRACT =
+  "kungfu-buildchain-v4-product-publication-plan/v1";
+
+export function selectProductPublicationIntent({
+  channel,
+  targetRef,
+  sourceSha,
+  sourceTimestamp,
+  repository,
+  artifactKind = "npm",
+  packageName,
+  npmPackages,
+  distTag,
+  sealedBundleRoot,
+  requiredArtifactsRoot,
+  candidateVersion,
+  recoveredVersion = "",
+  observedVersions = [],
+}) {
+  return invokeDomainWasm("product-publication-intent", {
+    channel,
+    targetRef,
+    sourceSha,
+    sourceTimestamp,
+    repository,
+    artifactKind,
+    ...(npmPackages === undefined ? {} : { npmPackages }),
+    ...(packageName === undefined ? {} : { packageName }),
+    ...(distTag === undefined ? {} : { distTag }),
+    ...(sealedBundleRoot === undefined ? {} : { sealedBundleRoot }),
+    requiredArtifactsRoot,
+    candidateVersion,
+    recoveredVersion,
+    observedVersions,
+  });
+}
+
+export function createProductPublicationPlan({
+  intent,
+  invocationRoot,
+  transactionRoot,
+}) {
+  return invokeDomainWasm("product-publication-plan", {
+    intent,
+    invocationRoot,
+    transactionRoot,
+  });
+}
+
+export function createProductPublicationDeclaration({ intent, plan }) {
+  return invokeDomainWasm("product-publication-declaration", {
+    intent,
+    plan,
+  });
+}

package/packages/core/{v4-protected-publication-source.js → protected-publication-source.js}

@@ -1,13 +1,11 @@
-import { v4ContentRoot } from "./v4-canonical-contracts.js";
+import { domainContentRoot } from "./canonical-contracts.js";
 
 const SHA_PATTERN = /^[0-9a-f]{40}$/u;
 
 function exactSha(value, label) {
   const normalized = String(value || "").toLowerCase();
-  if (!SHA_PATTERN.test(normalized)) {
-    throw new Error(`${label} must be an exact Git SHA`);
-  }
-  return normalized;
+  if (SHA_PATTERN.test(normalized)) return normalized;
+  throw new Error(`${label} must be an exact Git SHA`);
 }
 
 function exactParents(value, label) {
@@ -17,7 +15,7 @@ function exactParents(value, label) {
   return value.map((entry, index) => exactSha(entry, `${label}[${index}]`));
 }
 
-export function bindV4ProtectedPublicationSource({
+export function bindProtectedPublicationSource({
   repository,
   protectedCommit,
   candidateCommit,
@@ -26,16 +24,14 @@ export function bindV4ProtectedPublicationSource({
   if (!/^[^/\s]+\/[^/\s]+$/u.test(String(repository || ""))) {
     throw new Error("protected publication source requires owner/repository");
   }
-  const protectedSource = {
-    sha: exactSha(protectedCommit?.sha, "protected source SHA"),
-    tree: exactSha(protectedCommit?.tree, "protected source tree"),
-    parents: exactParents(protectedCommit?.parents, "protected source parents"),
-  };
-  const candidateSource = {
-    sha: exactSha(candidateCommit?.sha, "candidate source SHA"),
-    tree: exactSha(candidateCommit?.tree, "candidate source tree"),
-    parents: exactParents(candidateCommit?.parents, "candidate source parents"),
-  };
+  const [protectedSource, candidateSource] = [
+    ["protected", protectedCommit],
+    ["candidate", candidateCommit],
+  ].map(([kind, commit]) => ({
+    sha: exactSha(commit?.sha, `${kind} source SHA`),
+    tree: exactSha(commit?.tree, `${kind} source tree`),
+    parents: exactParents(commit?.parents, `${kind} source parents`),
+  }));
   if (protectedSource.tree !== candidateSource.tree) {
     throw new Error(
       "protected publication source tree does not match the qualified candidate tree",
@@ -45,13 +41,13 @@ export function bindV4ProtectedPublicationSource({
   let mode = "exact-commit";
   let pullRequestNumber = null;
   if (protectedSource.sha !== candidateSource.sha) {
-    mode = "merge-equivalent";
     const sameParents =
-      protectedSource.parents.length === candidateSource.parents.length &&
-      protectedSource.parents.every(
-        (parent, index) => parent === candidateSource.parents[index],
-      );
-    if (!sameParents) {
+      protectedSource.parents.join(",") === candidateSource.parents.join(",");
+    const squashParents =
+      protectedSource.parents.length === 1 &&
+      candidateSource.parents.length === 2 &&
+      protectedSource.parents[0] === candidateSource.parents[0];
+    if (!sameParents && !squashParents) {
       throw new Error(
         "protected publication source is not parent-equivalent to the qualified merge candidate",
       );
@@ -70,12 +66,14 @@ export function bindV4ProtectedPublicationSource({
       pullRequestNumber <= 0 ||
       pullRequest?.merged !== true ||
       pullRequestMerge !== protectedSource.sha ||
-      !candidateSource.parents.includes(pullRequestHead)
+      !candidateSource.parents.includes(pullRequestHead) ||
+      (squashParents && candidateSource.parents[1] !== pullRequestHead)
     ) {
       throw new Error(
         "protected publication source does not match the merged pull request and qualified merge candidate",
       );
     }
+    mode = sameParents ? "merge-equivalent" : "squash-equivalent";
   }
 
   const binding = {
@@ -88,6 +86,6 @@ export function bindV4ProtectedPublicationSource({
   };
   return {
     ...binding,
-    bindingRoot: v4ContentRoot("candidate-identity", binding),
+    bindingRoot: domainContentRoot("candidate-identity", binding),
   };
 }

package/packages/core/provider-operation-journal.js

@@ -0,0 +1,62 @@
+import { ContractFault } from "./canonical-contracts.js";
+import { DomainWasmFault, invokeDomainWasm } from "./domain-wasm.js";
+
+export const PROVIDER_OPERATION_IDENTITY_CONTRACT =
+  "buildchain-v4-provider-operation-identity/v1";
+export const PROVIDER_OPERATION_INTENT_CONTRACT =
+  "buildchain-v4-provider-operation-intent/v1";
+export const PROVIDER_OPERATION_ATTEMPT_CONTRACT =
+  "buildchain-v4-provider-operation-attempt/v1";
+export const PROVIDER_OPERATION_OBSERVATION_CONTRACT =
+  "buildchain-v4-provider-operation-observation/v1";
+export const PROVIDER_OPERATION_CONFIRMATION_CONTRACT =
+  "buildchain-v4-provider-operation-confirmation/v1";
+export const PROVIDER_OPERATION_RECONCILIATION_CONTRACT =
+  "buildchain-v4-provider-operation-reconciliation/v1";
+export const PROVIDER_OPERATION_JOURNAL_STATE_CONTRACT =
+  "buildchain-v4-provider-operation-journal-state/v1";
+
+function invoke(operation, payload) {
+  try {
+    return invokeDomainWasm(operation, payload);
+  } catch (error) {
+    if (error instanceof DomainWasmFault) {
+      throw new ContractFault(error.code, error.path, error.message);
+    }
+    throw error;
+  }
+}
+
+export function validateProviderOperationIdentity(value) {
+  invoke("provider-operation-identity-validate", value);
+  return value;
+}
+
+export function providerOperationRoot(identity) {
+  return invoke("provider-operation-identity-root", identity).root;
+}
+
+export function providerOperationEntryRoot(entry) {
+  return invoke("provider-operation-entry-root", entry).root;
+}
+
+export function validateProviderOperationEntry(entry) {
+  invoke("provider-operation-entry-validate", entry);
+  return entry;
+}
+
+export function foldProviderOperationJournal(entries) {
+  return invoke("provider-operation-journal", entries).state;
+}
+
+export function providerOperationJournalRoot(entries) {
+  return invoke("provider-operation-journal", entries).journalRoot;
+}
+
+export function providerOperationJournalStateRoot(entries) {
+  return invoke("provider-operation-journal", entries).stateRoot;
+}
+
+export function projectProviderOperationFixtures(fixtures) {
+  return invoke("provider-operation-fixtures", fixtures);
+}

package/packages/core/{v4-provider-readback-idempotency.js → provider-readback-idempotency.js}

@@ -1,19 +1,14 @@
 import {
-  V4ContractFault,
-  v4ContentRoot,
-  validateV4Clock,
-  validateV4Root,
-} from "./v4-canonical-contracts.js";
-import {
-  V4_PROVIDER_OPERATION_OBSERVATION_CONTRACT,
-  v4ProviderOperationJournalStateRoot,
-  v4ProviderOperationEntryRoot,
-  validateV4ProviderOperationEntry,
-} from "./v4-provider-operation-journal.js";
+  ContractFault,
+  domainContentRoot,
+  validateRoot,
+} from "./canonical-contracts.js";
+import { providerOperationJournalStateRoot } from "./provider-operation-journal.js";
+import { DomainWasmFault, invokeDomainWasm } from "./domain-wasm.js";
 
-export const V4_PROVIDER_READBACK_SAMPLE_CONTRACT =
+export const PROVIDER_READBACK_SAMPLE_CONTRACT =
   "buildchain-v4-provider-readback-sample/v1";
-export const V4_PROVIDER_READBACK_FOLD_CONTRACT =
+export const PROVIDER_READBACK_FOLD_CONTRACT =
   "buildchain-v4-provider-readback-fold/v1";
 
 const PROVIDERS = Object.freeze({
@@ -53,7 +48,7 @@ const PROVIDERS = Object.freeze({
 });
 
 function fault(code, path, message) {
-  throw new V4ContractFault(code, path, message);
+  throw new ContractFault(code, path, message);
 }
 
 function exactKeys(value, keys, path) {
@@ -79,12 +74,12 @@ function validateContext(context) {
     "$/context",
   );
   for (const key of Object.keys(context))
-    validateV4Root(context[key], `$/context/${key}`);
+    validateRoot(context[key], `$/context/${key}`);
 }
 
 function sampleRoot(sample) {
   const { sampleRoot: _sampleRoot, ...payload } = sample;
-  return v4ContentRoot("provider-readback-sample", payload);
+  return domainContentRoot("provider-readback-sample", payload);
 }
 
 function validateSample(sample, path = "$/samples") {
@@ -101,7 +96,7 @@ function validateSample(sample, path = "$/samples") {
     ],
     path,
   );
-  if (sample.schema !== V4_PROVIDER_READBACK_SAMPLE_CONTRACT)
+  if (sample.schema !== PROVIDER_READBACK_SAMPLE_CONTRACT)
     fault(
       "unsupported-provider-readback-version",
       `${path}/schema`,
@@ -118,15 +113,15 @@ function validateSample(sample, path = "$/samples") {
       "provider readback state is unsupported",
     );
   for (const key of ["operationRoot", "attemptRoot", "sampleRoot"])
-    validateV4Root(sample[key], `${path}/${key}`);
+    validateRoot(sample[key], `${path}/${key}`);
   if (sample.observedTargetRoot !== null)
-    validateV4Root(sample.observedTargetRoot, `${path}/observedTargetRoot`);
+    validateRoot(sample.observedTargetRoot, `${path}/observedTargetRoot`);
   if (
     !Array.isArray(sample.evidenceRoots) ||
     sample.evidenceRoots.length === 0 ||
     sample.evidenceRoots.some(
       (root, index) => (
-        validateV4Root(root, `${path}/evidenceRoots/${index}`),
+        validateRoot(root, `${path}/evidenceRoots/${index}`),
         false
       ),
     )
@@ -181,13 +176,13 @@ function adaptProviderReadback(provider, response, context) {
       "$/response/schema",
       "provider response schema does not match its adapter",
     );
-  validateV4Root(
+  validateRoot(
     response[descriptor.subject],
     `$/response/${descriptor.subject}`,
   );
-  validateV4Root(response.evidenceRoot, "$/response/evidenceRoot");
+  validateRoot(response.evidenceRoot, "$/response/evidenceRoot");
   if (response[descriptor.target] !== null)
-    validateV4Root(
+    validateRoot(
       response[descriptor.target],
       `$/response/${descriptor.target}`,
     );
@@ -226,7 +221,7 @@ function adaptProviderReadback(provider, response, context) {
     );
   }
   const sample = {
-    schema: V4_PROVIDER_READBACK_SAMPLE_CONTRACT,
+    schema: PROVIDER_READBACK_SAMPLE_CONTRACT,
     operationRoot: context.operationRoot,
     attemptRoot: context.attemptRoot,
     state,
@@ -239,119 +234,39 @@ function adaptProviderReadback(provider, response, context) {
   return validateSample(sample);
 }
 
-export function adaptV4GitHubReleaseReadback(response, context) {
+export function adaptGitHubReleaseReadback(response, context) {
   return adaptProviderReadback("github", response, context);
 }
 
-export function adaptV4NpmPublicationReadback(response, context) {
+export function adaptNpmPublicationReadback(response, context) {
   return adaptProviderReadback("npm", response, context);
 }
 
-export function adaptV4OciManifestReadback(response, context) {
+export function adaptOciManifestReadback(response, context) {
   return adaptProviderReadback("oci", response, context);
 }
 
-export function foldV4ProviderReadbackSamples(samples, coordinates) {
-  exactKeys(
-    coordinates,
-    [
-      "sequence",
-      "priorEntryRoot",
-      "operationRoot",
-      "attemptRoot",
-      "observedAt",
-    ],
-    "$/coordinates",
-  );
-  if (!Number.isSafeInteger(coordinates.sequence) || coordinates.sequence < 0)
-    fault(
-      "malformed-provider-readback",
-      "$/coordinates/sequence",
-      "readback sequence must be a non-negative safe integer",
-    );
-  for (const key of ["priorEntryRoot", "operationRoot", "attemptRoot"])
-    validateV4Root(coordinates[key], `$/coordinates/${key}`);
-  validateV4Clock(coordinates.observedAt, "$/coordinates/observedAt");
-  if (!Array.isArray(samples) || samples.length === 0)
-    fault(
-      "malformed-provider-readback",
-      "$/samples",
-      "at least one rooted provider readback sample is required",
-    );
-  const unique = new Map();
-  for (const [index, sample] of samples.entries()) {
-    validateSample(sample, `$/samples/${index}`);
-    if (
-      sample.operationRoot !== coordinates.operationRoot ||
-      sample.attemptRoot !== coordinates.attemptRoot
-    )
-      fault(
-        "provider-readback-coordinate-mismatch",
-        `$/samples/${index}`,
-        "provider readback sample does not bind the journal coordinates",
-      );
-    unique.set(sample.sampleRoot, sample);
+export function foldProviderReadbackSamples(samples, coordinates) {
+  try {
+    return invokeDomainWasm("provider-readback-fold", {
+      samples,
+      coordinates,
+    });
+  } catch (error) {
+    if (error instanceof DomainWasmFault) {
+      throw new ContractFault(error.code, error.path, error.message);
+    }
+    throw error;
   }
-  const folded = [...unique.values()].sort((left, right) =>
-    left.sampleRoot.localeCompare(right.sampleRoot),
-  );
-  const states = new Set(folded.map((sample) => sample.state));
-  if (states.has("already-applied") && states.size !== 1)
-    fault(
-      "conflicting-provider-readback",
-      "$/samples",
-      "successful and unresolved readbacks cannot describe one attempt",
-    );
-  const targets = new Set(
-    folded.map((sample) => sample.observedTargetRoot).filter(Boolean),
-  );
-  if (targets.size > 1)
-    fault(
-      "conflicting-provider-readback",
-      "$/samples",
-      "provider readbacks disagree about the observed target",
-    );
-  const classification = states.has("already-applied")
-    ? "already-applied"
-    : states.has("eventually-visible")
-      ? "eventually-visible"
-      : "not-found";
-  const readbackRoots = folded.map((sample) => sample.sampleRoot);
-  const observation = {
-    kind: "observation",
-    schema: V4_PROVIDER_OPERATION_OBSERVATION_CONTRACT,
-    sequence: coordinates.sequence,
-    priorEntryRoot: coordinates.priorEntryRoot,
-    operationRoot: coordinates.operationRoot,
-    attemptRoot: coordinates.attemptRoot,
-    observedAt: coordinates.observedAt,
-    status: classification === "already-applied" ? "succeeded" : "unknown",
-    evidenceRoots: readbackRoots,
-    entryRoot:
-      "sha256:0000000000000000000000000000000000000000000000000000000000000000",
-  };
-  observation.entryRoot = v4ProviderOperationEntryRoot(observation);
-  validateV4ProviderOperationEntry(observation);
-  const projection = {
-    schema: V4_PROVIDER_READBACK_FOLD_CONTRACT,
-    classification,
-    readbackRoots,
-    observation,
-    projectionRoot:
-      "sha256:0000000000000000000000000000000000000000000000000000000000000000",
-  };
-  const { projectionRoot: _projectionRoot, ...payload } = projection;
-  projection.projectionRoot = v4ContentRoot("provider-readback-fold", payload);
-  return projection;
 }
 
 const ADAPTERS = Object.freeze({
-  github: adaptV4GitHubReleaseReadback,
-  npm: adaptV4NpmPublicationReadback,
-  oci: adaptV4OciManifestReadback,
+  github: adaptGitHubReleaseReadback,
+  npm: adaptNpmPublicationReadback,
+  oci: adaptOciManifestReadback,
 });
 
-export function projectV4ProviderReadbackFixtures(fixtures) {
+export function projectProviderReadbackFixtures(fixtures) {
   const projectCase = (fixture) => {
     const samples = fixture.readbacks.map(({ provider, response }) =>
       ADAPTERS[provider](response, fixtures.context),
@@ -362,14 +277,14 @@ export function projectV4ProviderReadbackFixtures(fixtures) {
         "$/neutralSamples",
         "provider adapters did not produce the retained neutral samples",
       );
-    const projection = foldV4ProviderReadbackSamples(
+    const projection = foldProviderReadbackSamples(
       samples,
       fixtures.coordinates,
     );
     return {
       id: fixture.id,
       ...projection,
-      journalStateRoot: v4ProviderOperationJournalStateRoot([
+      journalStateRoot: providerOperationJournalStateRoot([
         ...fixtures.journalPrefix,
         projection.observation,
       ]),
@@ -380,7 +295,7 @@ export function projectV4ProviderReadbackFixtures(fixtures) {
     try {
       projectCase(fixture);
     } catch (error) {
-      if (error instanceof V4ContractFault)
+      if (error instanceof ContractFault)
         return { id: fixture.id, fault: error.code };
       throw error;
     }