@kungfu-tech/buildchain 4.0.2 → 4.0.3

package/packages/core/dev-delivery-warrant-legacy-recovery.js

@@ -140,7 +140,7 @@ export function recoverLegacyTerminalDevDeliveryQueue(
     );
   }
   const before = normalizeDevDeliveryQueue(queueInput, {
-    allowLegacyV3Readback: true,
+    allowLegacyBaselineReadback: true,
   });
   const expectedOldStateRoot = exactRoot(
     request.expectedOldStateRoot,

package/packages/core/dev-delivery-warrant-native-compatibility.js

@@ -1,6 +1,6 @@
 export function lacksExactNativeExecutionContract(
   candidate,
-  allowLegacyV3Readback = false,
+  allowLegacyBaselineReadback = false,
 ) {
   const native =
     candidate.deliveryClass !== "non-native-fast" ||
@@ -9,17 +9,17 @@ export function lacksExactNativeExecutionContract(
   return Boolean(
     native &&
     (!candidate.environmentRoot ||
-      (!candidate.nativeCommandContract && !allowLegacyV3Readback)),
+      (!candidate.nativeCommandContract && !allowLegacyBaselineReadback)),
   );
 }
 
 export function lacksLiveNativeProof(
   candidate,
   status,
-  { allowLegacyV3Readback = false, allowLegacyQueuedReadback = false } = {},
+  { allowLegacyV3Readback: legacyReadback = false, allowLegacyBaselineReadback = legacyReadback, allowLegacyQueuedReadback = false } = {},
 ) {
   return (
-    lacksExactNativeExecutionContract(candidate, allowLegacyV3Readback) &&
+    lacksExactNativeExecutionContract(candidate, allowLegacyBaselineReadback) &&
     !(status === "queued" && allowLegacyQueuedReadback) &&
     !TERMINAL_STATES.has(status)
   );

package/packages/core/dev-delivery-warrant-state.js

@@ -279,7 +279,8 @@ function normalizeCandidate(input, expected) {
   }
   if (
     lacksLiveNativeProof(candidate, status, {
-      allowLegacyV3Readback: expected.allowLegacyV3Readback,
+      allowLegacyBaselineReadback:
+        expected.allowLegacyBaselineReadback ?? expected.allowLegacyV3Readback,
       allowLegacyQueuedReadback: expected.allowLegacyQueuedNativeReadback,
     })
   )
@@ -358,12 +359,12 @@ export function normalizeDevDeliveryQueue(input, expected = {}) {
   const hasExecutionReceipt = !!queue.activeWarrant?.nativeExecutionReceiptRoot;
   const hasQualificationReceipt =
     !!queue.activeWarrant?.qualificationReceiptRoot;
-  const allowLegacyV3Readback =
-    expected.allowLegacyV3Readback === true &&
-    hasExecutionReceipt === hasQualificationReceipt;
+  const allowLegacyBaselineReadback =
+    (expected.allowLegacyBaselineReadback ?? expected.allowLegacyV3Readback) ===
+      true && hasExecutionReceipt === hasQualificationReceipt;
   const candidateExpected = {
     ...queue,
-    allowLegacyV3Readback,
+    allowLegacyBaselineReadback,
     allowLegacyQueuedNativeReadback: true,
   };
   queue.candidates = (queue.candidates || []).map((candidate) =>
@@ -372,7 +373,7 @@ export function normalizeDevDeliveryQueue(input, expected = {}) {
   validateDevDeliveryCandidateChain(queue.candidates, TERMINAL_STATES);
   queue.updatedAt = timestamp(queue.updatedAt, "queue updatedAt");
   if (queue.activeWarrant) {
-    validateActiveDevDeliveryWarrant(queue, { allowLegacyV3Readback });
+    validateActiveDevDeliveryWarrant(queue, { allowLegacyBaselineReadback });
   } else if (
     queue.candidates.some((candidate) =>
       ["selected", "proving", "waiting", "blocked", "qualified"].includes(
@@ -571,12 +572,11 @@ function effectivePriority(candidate, policy, now) {
     releaseBlocker: Boolean(candidate.releaseBlockerPriority),
   };
 }
-export function rankDevDeliveryCandidates(
-  queueInput,
-  { now = new Date().toISOString(), allowLegacyV3Readback = false } = {},
-) {
+export function rankDevDeliveryCandidates(queueInput, options = {}) {
+  const { now = new Date().toISOString() } = options;
   const queue = normalizeDevDeliveryQueue(queueInput, {
-    allowLegacyV3Readback,
+    allowLegacyBaselineReadback:
+      options.allowLegacyBaselineReadback ?? options.allowLegacyV3Readback,
   });
   const currentTime = timestamp(now, "now");
   return queue.candidates

package/packages/core/dev-delivery-warrant.js

@@ -534,10 +534,10 @@ export const reconcileDevDeliveryTerminalEvidence =
   });
 export function observeDevDeliveryQueue(
   queueInput,
-  { now = new Date().toISOString(), allowLegacyV3Readback = false } = {},
+  { now = new Date().toISOString(), allowLegacyV3Readback: legacyReadback = false, allowLegacyBaselineReadback = legacyReadback } = {},
 ) {
   const queue = normalizeDevDeliveryQueue(queueInput, {
-    allowLegacyV3Readback,
+    allowLegacyBaselineReadback,
   });
   const currentTime = timestamp(now, "now");
   const states = {};
@@ -545,7 +545,7 @@ export function observeDevDeliveryQueue(
     states[candidate.status] = (states[candidate.status] || 0) + 1;
   const queued = rankDevDeliveryCandidates(queue, {
     now: currentTime,
-    allowLegacyV3Readback,
+    allowLegacyBaselineReadback,
   });
   return {
     schema: "kungfu.buildchain.dev-delivery-queue-observation/v1",

package/packages/core/domain-wasm-artifact.js

@@ -0,0 +1,7 @@
+// Generated by scripts/build-domain-wasm.mjs.
+export const DOMAIN_WASM_ABI_VERSION = 1;
+export const DOMAIN_WASM_RUSTC = "rustc 1.96.0 (ac68faa20 2026-05-25)";
+export const DOMAIN_WASM_SOURCE_SHA256 =
+  "d575dc3680de68f5f165b9fe584cf63ba2498adf45d286320b797a9caccf19f9";
+export const DOMAIN_WASM_SHA256 =
+  "e04814473796c483e82e450b651b60e63609bfca182140b333dd0e6994ae63db";

package/packages/core/{v4-domain-wasm.js → domain-wasm.js}

@@ -2,32 +2,32 @@ import fs from "node:fs";
 import { createHash } from "node:crypto";
 
 import {
-  V4_DOMAIN_WASM_ABI_VERSION,
-  V4_DOMAIN_WASM_SHA256,
-} from "./v4-domain-wasm-artifact.js";
+  DOMAIN_WASM_ABI_VERSION,
+  DOMAIN_WASM_SHA256,
+} from "./domain-wasm-artifact.js";
 
-export const V4_DOMAIN_WASM_REQUEST_CONTRACT =
+export const DOMAIN_WASM_REQUEST_CONTRACT =
   "kungfu-buildchain-v4-domain-wasm-request/v1";
-export const V4_DOMAIN_WASM_RESPONSE_CONTRACT =
+export const DOMAIN_WASM_RESPONSE_CONTRACT =
   "kungfu-buildchain-v4-domain-wasm-response/v1";
 
-const WASM_URL = new URL("./buildchain-v4-domain.wasm", import.meta.url);
+const WASM_URL = new URL("./buildchain-domain.wasm", import.meta.url);
 const REQUIRED_EXPORTS = [
   "memory",
-  "buildchain_v4_wasm_abi_version",
-  "buildchain_v4_wasm_alloc",
-  "buildchain_v4_wasm_dealloc",
-  "buildchain_v4_wasm_invoke",
-  "buildchain_v4_wasm_response_pointer",
-  "buildchain_v4_wasm_response_length",
+  "buildchain_domain_wasm_abi_version",
+  "buildchain_domain_wasm_alloc",
+  "buildchain_domain_wasm_dealloc",
+  "buildchain_domain_wasm_invoke",
+  "buildchain_domain_wasm_response_pointer",
+  "buildchain_domain_wasm_response_length",
 ];
 
 let loaded;
 
-export class V4DomainWasmFault extends Error {
+export class DomainWasmFault extends Error {
   constructor(fault) {
     super(fault?.message || "Rust/WASM domain request failed");
-    this.name = "V4DomainWasmFault";
+    this.name = "DomainWasmFault";
     this.fault = fault;
     this.code = fault?.code || "rust-wasm-domain-failed";
     this.path = fault?.path || "$";
@@ -43,7 +43,7 @@ function failClosed(message, cause) {
 }
 
 function invalidTransport(code, path, message) {
-  throw new V4DomainWasmFault({ code, path, message, retry: "stop" });
+  throw new DomainWasmFault({ code, path, message, retry: "stop" });
 }
 
 function validateJsonTransport(value, path, active) {
@@ -131,9 +131,9 @@ function loadAuthority() {
     failClosed(`cannot read ${WASM_URL.pathname}`, error);
   }
   const observedSha256 = createHash("sha256").update(bytes).digest("hex");
-  if (observedSha256 !== V4_DOMAIN_WASM_SHA256) {
+  if (observedSha256 !== DOMAIN_WASM_SHA256) {
     failClosed(
-      `artifact digest mismatch (expected ${V4_DOMAIN_WASM_SHA256}, observed ${observedSha256})`,
+      `artifact digest mismatch (expected ${DOMAIN_WASM_SHA256}, observed ${observedSha256})`,
     );
   }
   let instance;
@@ -148,17 +148,17 @@ function loadAuthority() {
   if (missing.length > 0) {
     failClosed(`artifact is missing exports: ${missing.join(", ")}`);
   }
-  const abiVersion = instance.exports.buildchain_v4_wasm_abi_version();
-  if (abiVersion !== V4_DOMAIN_WASM_ABI_VERSION) {
+  const abiVersion = instance.exports.buildchain_domain_wasm_abi_version();
+  if (abiVersion !== DOMAIN_WASM_ABI_VERSION) {
     failClosed(
-      `ABI mismatch (expected ${V4_DOMAIN_WASM_ABI_VERSION}, observed ${abiVersion})`,
+      `ABI mismatch (expected ${DOMAIN_WASM_ABI_VERSION}, observed ${abiVersion})`,
     );
   }
   loaded = instance.exports;
   return loaded;
 }
 
-export function invokeV4DomainWasm(operation, payload) {
+export function invokeDomainWasm(operation, payload) {
   if (
     ["canonical-json", "content-root", "release-tail-root"].includes(operation)
   ) {
@@ -167,23 +167,23 @@ export function invokeV4DomainWasm(operation, payload) {
   const authority = loadAuthority();
   const input = new TextEncoder().encode(
     JSON.stringify({
-      schema: V4_DOMAIN_WASM_REQUEST_CONTRACT,
+      schema: DOMAIN_WASM_REQUEST_CONTRACT,
       operation,
       payload,
     }),
   );
-  const inputPointer = authority.buildchain_v4_wasm_alloc(input.byteLength);
+  const inputPointer = authority.buildchain_domain_wasm_alloc(input.byteLength);
   try {
     new Uint8Array(authority.memory.buffer, inputPointer, input.byteLength).set(
       input,
     );
     try {
-      authority.buildchain_v4_wasm_invoke(inputPointer, input.byteLength);
+      authority.buildchain_domain_wasm_invoke(inputPointer, input.byteLength);
     } catch (error) {
       failClosed(`operation '${operation}' trapped`, error);
     }
-    const responsePointer = authority.buildchain_v4_wasm_response_pointer();
-    const responseLength = authority.buildchain_v4_wasm_response_length();
+    const responsePointer = authority.buildchain_domain_wasm_response_pointer();
+    const responseLength = authority.buildchain_domain_wasm_response_length();
     let response;
     try {
       const responseBytes = new Uint8Array(
@@ -199,18 +199,18 @@ export function invokeV4DomainWasm(operation, payload) {
       );
     }
     if (
-      response?.schema !== V4_DOMAIN_WASM_RESPONSE_CONTRACT ||
+      response?.schema !== DOMAIN_WASM_RESPONSE_CONTRACT ||
       typeof response.ok !== "boolean"
     ) {
       failClosed(`operation '${operation}' returned an unsupported response`);
     }
-    if (!response.ok) throw new V4DomainWasmFault(response.fault);
+    if (!response.ok) throw new DomainWasmFault(response.fault);
     return response.value;
   } finally {
-    authority.buildchain_v4_wasm_dealloc(inputPointer, input.byteLength);
+    authority.buildchain_domain_wasm_dealloc(inputPointer, input.byteLength);
   }
 }
 
-export function v4DomainWasmInfo() {
-  return invokeV4DomainWasm("abi-info", {});
+export function domainWasmInfo() {
+  return invokeDomainWasm("abi-info", {});
 }

package/packages/core/{v4-floating-consumer-evidence.js → floating-consumer-evidence.js}

@@ -1,10 +1,10 @@
 import crypto from "node:crypto";
 
-export const V4_FLOATING_CONSUMER_POLICY =
+export const FLOATING_CONSUMER_POLICY =
   "kungfu-buildchain-v4-floating-consumer-policy/v1";
-export const V4_FLOATING_CONSUMER_RECEIPT =
+export const FLOATING_CONSUMER_RECEIPT =
   "kungfu-buildchain-v4-floating-consumer-policy-receipt/v1";
-export const V4_FLOATING_CONSUMER_CERTIFICATION =
+export const FLOATING_CONSUMER_CERTIFICATION =
   "kungfu-buildchain-v4-floating-consumer-certification/v1";
 
 const SHA256_ROOT = /^sha256:[0-9a-f]{64}$/u;
@@ -135,18 +135,18 @@ function verifyFloatingSelector(value, check, label) {
   );
 }
 
-export function v4FloatingConsumerDocumentRoot(value) {
+export function floatingConsumerDocumentRoot(value) {
   return documentRoot(value);
 }
 
-export function verifyV4FloatingConsumerPolicyReceipt(options = {}) {
+export function verifyFloatingConsumerPolicyReceipt(options = {}) {
   const { receipt, receiptRoot = "", expectedReceiptRoot = "" } = options;
   const failures = [];
   const check = checker(failures);
   check(
-    receipt?.schema === V4_FLOATING_CONSUMER_RECEIPT,
+    receipt?.schema === FLOATING_CONSUMER_RECEIPT,
     "receipt-contract-invalid",
-    `receipt must use ${V4_FLOATING_CONSUMER_RECEIPT}`,
+    `receipt must use ${FLOATING_CONSUMER_RECEIPT}`,
   );
   check(
     receipt?.status === "passed",
@@ -199,10 +199,10 @@ function defaultAuthority(options, receiptRoot) {
   };
 }
 
-export function certifyV4FloatingConsumerPolicyReceipt(options = {}) {
-  const verification = verifyV4FloatingConsumerPolicyReceipt(options);
+export function certifyFloatingConsumerPolicyReceipt(options = {}) {
+  const verification = verifyFloatingConsumerPolicyReceipt(options);
   const certification = {
-    schema: V4_FLOATING_CONSUMER_CERTIFICATION,
+    schema: FLOATING_CONSUMER_CERTIFICATION,
     status: verification.ok ? "certified" : "rejected",
     receiptRoot: verification.receiptRoot,
     caller: options.receipt?.caller || {},
@@ -284,14 +284,14 @@ function verifyCertificationAuthority(certification, expected, check) {
     );
 }
 
-export function verifyV4FloatingConsumerPolicyCertification(options = {}) {
+export function verifyFloatingConsumerPolicyCertification(options = {}) {
   const { certification, certificationRoot = "" } = options;
   const failures = [];
   const check = checker(failures);
   check(
-    certification?.schema === V4_FLOATING_CONSUMER_CERTIFICATION,
+    certification?.schema === FLOATING_CONSUMER_CERTIFICATION,
     "certification-contract-invalid",
-    `certification must use ${V4_FLOATING_CONSUMER_CERTIFICATION}`,
+    `certification must use ${FLOATING_CONSUMER_CERTIFICATION}`,
   );
   check(
     certification?.status === "certified",

package/packages/core/{v4-floating-consumer-policy.js → floating-consumer-policy.js}

@@ -7,20 +7,20 @@ import {
 } from "./buildchain-contract.js";
 import { parseYamlUses } from "./workflow-yaml-contract.js";
 import {
-  V4_FLOATING_CONSUMER_POLICY,
-  V4_FLOATING_CONSUMER_RECEIPT,
-  v4FloatingConsumerDocumentRoot,
-} from "./v4-floating-consumer-evidence.js";
+  FLOATING_CONSUMER_POLICY,
+  FLOATING_CONSUMER_RECEIPT,
+  floatingConsumerDocumentRoot,
+} from "./floating-consumer-evidence.js";
 
 export {
-  V4_FLOATING_CONSUMER_CERTIFICATION,
-  V4_FLOATING_CONSUMER_POLICY,
-  V4_FLOATING_CONSUMER_RECEIPT,
-  certifyV4FloatingConsumerPolicyReceipt,
-  v4FloatingConsumerDocumentRoot,
-  verifyV4FloatingConsumerPolicyCertification,
-  verifyV4FloatingConsumerPolicyReceipt,
-} from "./v4-floating-consumer-evidence.js";
+  FLOATING_CONSUMER_CERTIFICATION,
+  FLOATING_CONSUMER_POLICY,
+  FLOATING_CONSUMER_RECEIPT,
+  certifyFloatingConsumerPolicyReceipt,
+  floatingConsumerDocumentRoot,
+  verifyFloatingConsumerPolicyCertification,
+  verifyFloatingConsumerPolicyReceipt,
+} from "./floating-consumer-evidence.js";
 
 const EXACT_SHA = /^[0-9a-f]{40}$/u;
 const SHA256_ROOT = /^sha256:[0-9a-f]{64}$/u;
@@ -36,12 +36,12 @@ const DEFAULT_ALPHA_LOCK_PATH = ".buildchain/alpha-contract-lock.json";
 const TRANSIENT_ACTION =
   /^\.\/\.buildchain\/(?:runtime|workflow-shell|attester-runtime|release-tail-runtime)\//u;
 const SCANNER_PATHS = Object.freeze([
-  "architecture/v4-floating-consumer-policy.json",
+  "architecture/floating-consumer-policy.json",
   "contracts/v4-floating-consumer-policy-receipt-v1.schema.json",
   "packages/core/buildchain-contract.js",
-  "packages/core/v4-floating-consumer-policy.js",
+  "packages/core/floating-consumer-policy.js",
   "packages/core/workflow-yaml-contract.js",
-  "scripts/v4-consumer-policy.mjs",
+  "scripts/consumer-policy.mjs",
 ]);
 
 function defaultRuntimeRoot() {
@@ -73,9 +73,7 @@ function resolveInside(root, relative, label) {
   return file;
 }
 
-export function v4ConsumerPolicyScannerRoot(
-  runtimeRoot = defaultRuntimeRoot(),
-) {
+export function consumerPolicyScannerRoot(runtimeRoot = defaultRuntimeRoot()) {
   return sha256(
     stableJson(
       SCANNER_PATHS.map((relative) => ({
@@ -86,7 +84,7 @@ export function v4ConsumerPolicyScannerRoot(
   );
 }
 
-export function resolveV4FloatingConsumerPolicyAuthority({
+export function resolveFloatingConsumerPolicyAuthority({
   runtimeRoot = defaultRuntimeRoot(),
   callerRoot = process.cwd(),
   stableLockPath = DEFAULT_STABLE_LOCK_PATH,
@@ -94,7 +92,7 @@ export function resolveV4FloatingConsumerPolicyAuthority({
 } = {}) {
   const policy = readJson(
     runtimeRoot,
-    "architecture/v4-floating-consumer-policy.json",
+    "architecture/floating-consumer-policy.json",
     "v4 floating consumer policy",
   ).value;
   const readLock = (relative, label) => {
@@ -102,12 +100,12 @@ export function resolveV4FloatingConsumerPolicyAuthority({
     if (!fs.existsSync(file))
       throw new Error(`${label} contract lock is missing: ${relative}`);
     const value = JSON.parse(fs.readFileSync(file, "utf8"));
-    return { path: relative, root: v4FloatingConsumerDocumentRoot(value) };
+    return { path: relative, root: floatingConsumerDocumentRoot(value) };
   };
   return {
     policy,
-    policyRoot: v4FloatingConsumerDocumentRoot(policy),
-    scannerRoot: v4ConsumerPolicyScannerRoot(runtimeRoot),
+    policyRoot: floatingConsumerDocumentRoot(policy),
+    scannerRoot: consumerPolicyScannerRoot(runtimeRoot),
     contractLocks: {
       stable: readLock(stableLockPath, "stable"),
       alpha: readLock(alphaLockPath, "alpha"),
@@ -287,14 +285,14 @@ function classifyBuildchainUses(records, failures, { repository } = {}) {
   for (const record of records) {
     const parsed = coordinate(record.uses);
     if (!parsed || parsed.repository !== BUILDCHAIN_REPOSITORY) continue;
-    const v4Candidate =
+    const domainCandidate =
       parsed.selector === "v4" ||
       parsed.selector === "v4-alpha" ||
       /^v4(?:[./-]|$)/u.test(parsed.selector) ||
       parsed.selector === ALPHA_RECOVERY_BOOTSTRAP.selector ||
       EXACT_SHA.test(parsed.selector.toLowerCase()) ||
       parsed.selector.includes("${{");
-    if (!v4Candidate) continue;
+    if (!domainCandidate) continue;
     const bootstrapShape =
       normalizeWorkflowPath(parsed.path) ===
         ALPHA_RECOVERY_BOOTSTRAP.workflow &&
@@ -429,7 +427,7 @@ function verifySelectedLock({
   }
 }
 
-export function scanV4FloatingConsumerPolicy({
+export function scanFloatingConsumerPolicy({
   root = process.cwd(),
   invocationRoot = root,
   repository = "",
@@ -446,8 +444,8 @@ export function scanV4FloatingConsumerPolicy({
 } = {}) {
   const resolvedRoot = path.resolve(root);
   const resolvedInvocationRoot = path.resolve(invocationRoot);
-  if (!policy || policy.contract !== V4_FLOATING_CONSUMER_POLICY) {
-    throw new Error(`policy must use ${V4_FLOATING_CONSUMER_POLICY}`);
+  if (!policy || policy.contract !== FLOATING_CONSUMER_POLICY) {
+    throw new Error(`policy must use ${FLOATING_CONSUMER_POLICY}`);
   }
   const failures = [];
   const normalizedSourceSha = String(sourceSha || "").toLowerCase();
@@ -535,7 +533,7 @@ export function scanV4FloatingConsumerPolicy({
     invocationUses,
   });
   const receipt = {
-    schema: V4_FLOATING_CONSUMER_RECEIPT,
+    schema: FLOATING_CONSUMER_RECEIPT,
     status: failures.length ? "failed" : "passed",
     caller: { repository, sourceSha: normalizedSourceSha },
     invocation: {

package/packages/core/{v4-floating-consumer-release-passport.js → floating-consumer-release-passport.js}

@@ -1,15 +1,15 @@
 import fs from "node:fs";
 import path from "node:path";
 import {
-  v4FloatingConsumerDocumentRoot,
-  verifyV4FloatingConsumerPolicyCertification,
-} from "./v4-floating-consumer-evidence.js";
+  floatingConsumerDocumentRoot,
+  verifyFloatingConsumerPolicyCertification,
+} from "./floating-consumer-evidence.js";
 import {
-  verifyV4RuntimeAuthorizationReceipt,
-  verifyV4RuntimeResumeLineage,
-} from "./v4-runtime-ref-resume-authority.js";
+  verifyRuntimeAuthorizationReceipt,
+  verifyRuntimeResumeLineage,
+} from "./runtime-ref-resume-authority.js";
 const SHA256_ROOT = /^sha256:[0-9a-f]{64}$/u;
-export function isV4PromotionRouting(value = undefined) {
+export function isPromotionRouting(value = undefined) {
   return [
     value?.router?.ref,
     value?.shell?.ref,
@@ -31,13 +31,13 @@ function resolveCallerLock(root, relative, label) {
   }
   return {
     path: relative,
-    root: v4FloatingConsumerDocumentRoot(
+    root: floatingConsumerDocumentRoot(
       JSON.parse(fs.readFileSync(file, "utf8")),
     ),
   };
 }
 
-export function resolveV4FloatingConsumerCallerLocks(value, cwd) {
+export function resolveFloatingConsumerCallerLocks(value, cwd) {
   const certification = value?.certification || value;
   const declared = certification?.authority || {};
   const stableLockPath = declared?.contractLocks?.stable?.path || "";
@@ -55,7 +55,7 @@ function normalizeCertification(value, expected) {
     throw new Error("v4ConsumerPolicyCertification must be a JSON object");
   }
   const certification = value.certification || value;
-  const verification = verifyV4FloatingConsumerPolicyCertification({
+  const verification = verifyFloatingConsumerPolicyCertification({
     certification,
     certificationRoot: value.certificationRoot || "",
     expectedCertificationRoot: expected.certificationRoot,
@@ -76,7 +76,7 @@ function normalizeCertification(value, expected) {
   }
   return { certificationRoot: verification.certificationRoot, certification };
 }
-export function resolveV4ConsumerPolicyCertificationIdentity({
+export function resolveConsumerPolicyCertificationIdentity({
   release = {},
   routing = {},
   runtimeResume = undefined,
@@ -101,7 +101,7 @@ export function resolveV4ConsumerPolicyCertificationIdentity({
     runtimeSha: buildSha || certifiedSha || routing?.runtime?.resolvedSha || "",
   };
 }
-export function requireV4ConsumerPolicyCertification({
+export function requireConsumerPolicyCertification({
   value,
   repository,
   sourceSha,
@@ -110,14 +110,14 @@ export function requireV4ConsumerPolicyCertification({
   cwd,
   certificationRoot,
 }) {
-  const v4Routing = isV4PromotionRouting(routing);
-  if (v4Routing && !value) {
+  const domainRouting = isPromotionRouting(routing);
+  if (domainRouting && !value) {
     throw new Error(
       "Buildchain v4 Release Passport requires an external floating consumer policy certification",
     );
   }
   if (!value) return undefined;
-  if (v4Routing && !SHA256_ROOT.test(String(certificationRoot || ""))) {
+  if (domainRouting && !SHA256_ROOT.test(String(certificationRoot || ""))) {
     throw new Error(
       "Buildchain v4 Release Passport requires an expected external certification root",
     );
@@ -127,7 +127,7 @@ export function requireV4ConsumerPolicyCertification({
     sourceSha,
     runtimeSha: runtimeSha || routing?.runtime?.resolvedSha || "",
     certificationRoot,
-    ...(v4Routing ? resolveV4FloatingConsumerCallerLocks(value, cwd) : {}),
+    ...(domainRouting ? resolveFloatingConsumerCallerLocks(value, cwd) : {}),
   });
 }
 
@@ -137,7 +137,7 @@ export function releasePassportCertificationVerificationOptions({
   routing,
 }) {
   const authority = evidence?.certification?.authority || {};
-  const identity = resolveV4ConsumerPolicyCertificationIdentity({
+  const identity = resolveConsumerPolicyCertificationIdentity({
     release: { ...passport?.release, certification: evidence?.certification },
     routing,
     runtimeResume: passport?.v4RuntimeResume,
@@ -203,21 +203,21 @@ export function normalizePromotionEvidence({
   release = {},
   v4ConsumerPolicyCertification: certification,
   v4ConsumerPolicyCertificationRoot: certificationRoot,
-  v4RuntimeResumeEvidence,
+  domainRuntimeResumeEvidence,
   repository,
   sourceSha,
   cwd,
 }) {
   const routing = normalizePromotionRouting(release.promotionRouting);
-  const identity = resolveV4ConsumerPolicyCertificationIdentity({
+  const identity = resolveConsumerPolicyCertificationIdentity({
     release: { ...release, certification },
     routing,
-    runtimeResume: v4RuntimeResumeEvidence,
+    runtimeResume: domainRuntimeResumeEvidence,
     sourceSha,
   });
   return {
     routing,
-    consumerPolicy: requireV4ConsumerPolicyCertification({
+    consumerPolicy: requireConsumerPolicyCertification({
       value: certification,
       repository,
       sourceSha: identity.sourceSha,
@@ -229,12 +229,12 @@ export function normalizePromotionEvidence({
   };
 }
 
-export function normalizeV4RuntimeResumeEvidence(value, expected = {}) {
+export function normalizeRuntimeResumeEvidence(value, expected = {}) {
   if (value === undefined || value === null || value === "") return undefined;
   if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error("v4RuntimeResumeEvidence must be a JSON object");
+    throw new Error("domainRuntimeResumeEvidence must be a JSON object");
   }
-  const authorizationVerification = verifyV4RuntimeAuthorizationReceipt({
+  const authorizationVerification = verifyRuntimeAuthorizationReceipt({
     receipt: value.authorization,
     receiptRoot: value.authorizationRoot,
     repository: expected.repository,
@@ -247,7 +247,7 @@ export function normalizeV4RuntimeResumeEvidence(value, expected = {}) {
       `v4 runtime authorization invalid: ${authorizationVerification.failures.join(", ")}`,
     );
   }
-  const lineageVerification = verifyV4RuntimeResumeLineage({
+  const lineageVerification = verifyRuntimeResumeLineage({
     lineage: value.lineage,
     lineageRoot: value.lineageRoot,
     repository: expected.repository,

package/packages/core/index.js

@@ -644,9 +644,9 @@ export {
 } from "./kfd3-surface-register.js";
 
 export * from "./release-propagation.js";
-export * from "./v4-floating-consumer-policy.js";
-export * from "./v4-runtime-ref-resume-authority.js";
-export * from "./v4-publication-qualification.js";
+export * from "./floating-consumer-policy.js";
+export * from "./runtime-ref-resume-authority.js";
+export * from "./publication-qualification.js";
 
 export {
   RELEASE_ACTIVATION_CONTRACT,
@@ -698,8 +698,4 @@ export {
   writePaperScaffold,
 } from "./paper.js"; export * from "./paper-work.js"; export * from "./paper-fleet.js";
 
-export {
-  SURFACE_TIMESTAMP_POLICY_CONTRACT,
-  applySurfaceTimestampPolicy,
-  createSurfaceTimestampPolicy,
-} from "./surface-manifest.js";
+export * from "./public-export-compatibility.js";