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

package/packages/core/paper-runtime-channels.js

@@ -264,7 +264,7 @@ function explicitWorld(root, ref) {
   };
 }
 
-export function paperV4Channels({
+export function paperChannels({
   cwd,
   buildchainRoot,
   buildchainVersion,
@@ -312,7 +312,7 @@ export function paperV4Channels({
   return { selectedRef, channels };
 }
 
-export function bindPaperV4Authority(authority, channelPlan, files) {
+export function bindPaperAuthority(authority, channelPlan, files) {
   const { selectedRef, channels } = channelPlan;
   const entryPath = authority.agentEntry.policyPath;
   const entry = JSON.parse(files.get(entryPath));

package/packages/core/paper.js

@@ -1,5 +1,5 @@
 import crypto from "node:crypto";
-import { bindPaperV4Authority, paperV4Channels, selectPaperRuntime, paperRuntimeLockPath, paperProvisioningWorkflowErrors, resolvePaperNpmRuntimeSha } from "./paper-runtime-channels.js";
+import { bindPaperAuthority, paperChannels, selectPaperRuntime, paperRuntimeLockPath, paperProvisioningWorkflowErrors, resolvePaperNpmRuntimeSha } from "./paper-runtime-channels.js";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -808,7 +808,7 @@ function migrationFiles({
     [".gitignore", paperDependencyIgnore(fs.existsSync(path.join(cwd, ".gitignore")) ? fs.readFileSync(path.join(cwd, ".gitignore"), "utf8") : "")],
   ]);
   if (runtimeIdentity.version.startsWith("4.")) {
-    const channelPlan = paperV4Channels({
+    const channelPlan = paperChannels({
       cwd, buildchainRoot, buildchainVersion: runtimeIdentity.version,
       buildchainSha: runtimeSha, contractWorld: runtimeContractWorld(buildchainRoot),
       acceptedAt: contractLock.buildchain.acceptedAt,
@@ -823,7 +823,7 @@ function migrationFiles({
     const alphaJob = releaseJob.replace("  paper-release:\n", "  paper-release-alpha:\n    if: ${{ startsWith(github.ref_name, 'alpha/') }}\n").replaceAll(runtimeSha, "v4-alpha").replaceAll(".buildchain/contract-lock.json", ".buildchain/alpha-contract-lock.json");
     const stableJob = releaseJob.replace("  paper-release:\n", "  paper-release:\n    if: ${{ startsWith(github.ref_name, 'release/') }}\n").replaceAll(runtimeSha, "v4");
     files.set(PAPER_PATHS.releaseWorkflow, `${releaseWorkflow.slice(0, releaseStart)}${alphaJob}\n${stableJob}`);
-    files.set(PAPER_PATHS.provisioningAuthority, jsonText(bindPaperV4Authority(provisioningAuthority, channelPlan, files)));
+    files.set(PAPER_PATHS.provisioningAuthority, jsonText(bindPaperAuthority(provisioningAuthority, channelPlan, files)));
   }
   return files;
 }

package/packages/core/partial-mutation-recovery-qualification.js

@@ -0,0 +1,18 @@
+import { ContractFault } from "./canonical-contracts.js";
+import { DomainWasmFault, invokeDomainWasm } from "./domain-wasm.js";
+
+export const PARTIAL_MUTATION_RECOVERY_REQUEST_CONTRACT =
+  "buildchain-v4-partial-mutation-recovery-request/v1";
+export const PARTIAL_MUTATION_RECOVERY_PLAN_CONTRACT =
+  "buildchain-v4-partial-mutation-recovery-plan/v1";
+
+export function planPartialMutationRecovery(request) {
+  try {
+    return invokeDomainWasm("partial-mutation-recovery", request);
+  } catch (error) {
+    if (error instanceof DomainWasmFault) {
+      throw new ContractFault(error.code, error.path, error.message);
+    }
+    throw error;
+  }
+}

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/{v4-product-publication.js → product-publication.js}

@@ -1,11 +1,11 @@
-import { invokeV4DomainWasm } from "./v4-domain-wasm.js";
+import { invokeDomainWasm } from "./domain-wasm.js";
 
-export const V4_PRODUCT_PUBLICATION_INTENT_CONTRACT =
+export const PRODUCT_PUBLICATION_INTENT_CONTRACT =
   "kungfu-buildchain-v4-product-publication-intent/v1";
-export const V4_PRODUCT_PUBLICATION_PLAN_CONTRACT =
+export const PRODUCT_PUBLICATION_PLAN_CONTRACT =
   "kungfu-buildchain-v4-product-publication-plan/v1";
 
-export function selectV4ProductPublicationIntent({
+export function selectProductPublicationIntent({
   channel,
   targetRef,
   sourceSha,
@@ -13,6 +13,7 @@ export function selectV4ProductPublicationIntent({
   repository,
   artifactKind = "npm",
   packageName,
+  npmPackages,
   distTag,
   sealedBundleRoot,
   requiredArtifactsRoot,
@@ -20,13 +21,14 @@ export function selectV4ProductPublicationIntent({
   recoveredVersion = "",
   observedVersions = [],
 }) {
-  return invokeV4DomainWasm("product-publication-intent", {
+  return invokeDomainWasm("product-publication-intent", {
     channel,
     targetRef,
     sourceSha,
     sourceTimestamp,
     repository,
     artifactKind,
+    ...(npmPackages === undefined ? {} : { npmPackages }),
     ...(packageName === undefined ? {} : { packageName }),
     ...(distTag === undefined ? {} : { distTag }),
     ...(sealedBundleRoot === undefined ? {} : { sealedBundleRoot }),
@@ -37,20 +39,20 @@ export function selectV4ProductPublicationIntent({
   });
 }
 
-export function createV4ProductPublicationPlan({
+export function createProductPublicationPlan({
   intent,
   invocationRoot,
   transactionRoot,
 }) {
-  return invokeV4DomainWasm("product-publication-plan", {
+  return invokeDomainWasm("product-publication-plan", {
     intent,
     invocationRoot,
     transactionRoot,
   });
 }
 
-export function createV4ProductPublicationDeclaration({ intent, plan }) {
-  return invokeV4DomainWasm("product-publication-declaration", {
+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,4 +1,4 @@
-import { v4ContentRoot } from "./v4-canonical-contracts.js";
+import { domainContentRoot } from "./canonical-contracts.js";
 
 const SHA_PATTERN = /^[0-9a-f]{40}$/u;
 
@@ -15,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,
@@ -86,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,14 +1,14 @@
 import {
-  V4ContractFault,
-  v4ContentRoot,
-  validateV4Root,
-} from "./v4-canonical-contracts.js";
-import { v4ProviderOperationJournalStateRoot } from "./v4-provider-operation-journal.js";
-import { V4DomainWasmFault, invokeV4DomainWasm } from "./v4-domain-wasm.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({
@@ -48,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) {
@@ -74,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") {
@@ -96,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`,
@@ -113,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
       ),
     )
@@ -176,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}`,
     );
@@ -221,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,
@@ -234,39 +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) {
+export function foldProviderReadbackSamples(samples, coordinates) {
   try {
-    return invokeV4DomainWasm("provider-readback-fold", {
+    return invokeDomainWasm("provider-readback-fold", {
       samples,
       coordinates,
     });
   } catch (error) {
-    if (error instanceof V4DomainWasmFault) {
-      throw new V4ContractFault(error.code, error.path, error.message);
+    if (error instanceof DomainWasmFault) {
+      throw new ContractFault(error.code, error.path, error.message);
     }
     throw error;
   }
 }
 
 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),
@@ -277,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,
       ]),
@@ -295,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;
     }

package/packages/core/public-export-compatibility.js

@@ -0,0 +1,33 @@
+// Published export aliases; implementations use responsibility names.
+export { PublicationQualificationError as V4PublicationQualificationError } from "./publication-qualification.js";
+export { FLOATING_CONSUMER_CERTIFICATION as V4_FLOATING_CONSUMER_CERTIFICATION } from "./floating-consumer-evidence.js";
+export { FLOATING_CONSUMER_POLICY as V4_FLOATING_CONSUMER_POLICY } from "./floating-consumer-evidence.js";
+export { FLOATING_CONSUMER_RECEIPT as V4_FLOATING_CONSUMER_RECEIPT } from "./floating-consumer-evidence.js";
+export { PUBLICATION_QUALIFICATION_SCHEMA as V4_PUBLICATION_QUALIFICATION_SCHEMA } from "./publication-qualification.js";
+export { RUNTIME_AUTHORIZATION_CONTRACT as V4_RUNTIME_AUTHORIZATION_CONTRACT } from "./runtime-ref-resume-authority.js";
+export { RUNTIME_PERSISTENCE_SCAN_CONTRACT as V4_RUNTIME_PERSISTENCE_SCAN_CONTRACT } from "./runtime-selector-persistence.js";
+export { RUNTIME_RESUME_LINEAGE_CONTRACT as V4_RUNTIME_RESUME_LINEAGE_CONTRACT } from "./runtime-ref-resume-authority.js";
+export { assertNoExecutionFields as assertNoV4ExecutionFields } from "./publication-qualification.js";
+export { assertDeclarativePromotionInputs as assertV4DeclarativePromotionInputs } from "./publication-qualification.js";
+export { authorizeRuntimeSelection as authorizeV4RuntimeSelection } from "./runtime-ref-resume-authority.js";
+export { certifyFloatingConsumerPolicyReceipt as certifyV4FloatingConsumerPolicyReceipt } from "./floating-consumer-evidence.js";
+export { createDomainPublicationQualificationReceipt as createV4PublicationQualificationReceipt } from "./publication-qualification.js";
+export { createRuntimeResumeLineage as createV4RuntimeResumeLineage } from "./runtime-ref-resume-authority.js";
+export { resolveFloatingConsumerPolicyAuthority as resolveV4FloatingConsumerPolicyAuthority } from "./floating-consumer-policy.js";
+export { scanFloatingConsumerPolicy as scanV4FloatingConsumerPolicy } from "./floating-consumer-policy.js";
+export { scanRuntimeSelectorPersistence as scanV4RuntimeSelectorPersistence } from "./runtime-selector-persistence.js";
+export { consumerPolicyScannerRoot as v4ConsumerPolicyScannerRoot } from "./floating-consumer-policy.js";
+export { floatingConsumerDocumentRoot as v4FloatingConsumerDocumentRoot } from "./floating-consumer-evidence.js";
+export { domainPublicationQualificationRoot as v4PublicationQualificationRoot } from "./publication-qualification.js";
+export { runtimeResumeDocumentRoot as v4RuntimeResumeDocumentRoot } from "./runtime-ref-resume-authority.js";
+export { validatePublicationQualificationReceipt as validateV4PublicationQualificationReceipt } from "./publication-qualification.js";
+export { verifyFloatingConsumerPolicyCertification as verifyV4FloatingConsumerPolicyCertification } from "./floating-consumer-evidence.js";
+export { verifyFloatingConsumerPolicyReceipt as verifyV4FloatingConsumerPolicyReceipt } from "./floating-consumer-evidence.js";
+export { verifyRuntimeAuthorizationReceipt as verifyV4RuntimeAuthorizationReceipt } from "./runtime-ref-resume-authority.js";
+export { verifyRuntimeResumeLineage as verifyV4RuntimeResumeLineage } from "./runtime-ref-resume-authority.js";
+
+export {
+  SURFACE_TIMESTAMP_POLICY_CONTRACT,
+  applySurfaceTimestampPolicy,
+  createSurfaceTimestampPolicy,
+} from "./surface-manifest.js";