@kungfu-tech/buildchain 4.0.2 → 4.0.3

package/packages/core/{v4-stage-capsule-store.js → stage-capsule-store.js}

@@ -1,20 +1,20 @@
 import crypto from "node:crypto";
 
 import {
-  V4ContractFault,
-  v4ContentRoot,
-  validateV4Clock,
-  validateV4Root,
-} from "./v4-canonical-contracts.js";
-import { validateV4StageCapsule } from "./v4-stage-capsule.js";
+  ContractFault,
+  domainContentRoot,
+  validateClock,
+  validateRoot,
+} from "./canonical-contracts.js";
+import { validateStageCapsule } from "./stage-capsule.js";
 
-export const V4_STAGE_CAPSULE_OUTPUT_MANIFEST_CONTRACT =
+export const STAGE_CAPSULE_OUTPUT_MANIFEST_CONTRACT =
   "buildchain-v4-stage-capsule-output-manifest/v1";
-export const V4_STAGE_CAPSULE_RETENTION_STATE_CONTRACT =
+export const STAGE_CAPSULE_RETENTION_STATE_CONTRACT =
   "buildchain-v4-stage-capsule-retention-state/v1";
-export const V4_STAGE_CAPSULE_TRANSPORT_CONTRACT =
+export const STAGE_CAPSULE_TRANSPORT_CONTRACT =
   "buildchain-v4-stage-capsule-transport/v1";
-export const V4_STAGE_CAPSULE_STORE_RECEIPT_CONTRACT =
+export const STAGE_CAPSULE_STORE_RECEIPT_CONTRACT =
   "buildchain-v4-stage-capsule-store-receipt/v1";
 
 const TOKEN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u;
@@ -38,7 +38,7 @@ const OUTCOMES = new Set([
 ]);
 
 function fault(code, path, message) {
-  throw new V4ContractFault(code, path, message);
+  throw new ContractFault(code, path, message);
 }
 
 function exactKeys(value, keys, path) {
@@ -71,7 +71,7 @@ function token(value, path) {
   return value;
 }
 
-export function v4StageCapsuleBlobRoot(bytes) {
+export function stageCapsuleBlobRoot(bytes) {
   const value = Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes);
   return `sha256:${crypto.createHash("sha256").update(value).digest("hex")}`;
 }
@@ -80,17 +80,20 @@ function manifestPayload(value) {
   return { schema: value.schema, entries: value.entries };
 }
 
-export function v4StageCapsuleOutputManifestRoot(value) {
-  validateV4StageCapsuleOutputManifest(value, { verifyRoot: false });
-  return v4ContentRoot("stage-capsule-output-manifest", manifestPayload(value));
+export function stageCapsuleOutputManifestRoot(value) {
+  validateStageCapsuleOutputManifest(value, { verifyRoot: false });
+  return domainContentRoot(
+    "stage-capsule-output-manifest",
+    manifestPayload(value),
+  );
 }
 
-export function validateV4StageCapsuleOutputManifest(
+export function validateStageCapsuleOutputManifest(
   value,
   { verifyRoot = true } = {},
 ) {
   exactKeys(value, ["schema", "entries", "manifestRoot"], "$/manifest");
-  if (value.schema !== V4_STAGE_CAPSULE_OUTPUT_MANIFEST_CONTRACT)
+  if (value.schema !== STAGE_CAPSULE_OUTPUT_MANIFEST_CONTRACT)
     fault(
       "unsupported-stage-capsule-store-version",
       "$/manifest/schema",
@@ -107,7 +110,7 @@ export function validateV4StageCapsuleOutputManifest(
     const entryPath = `$/manifest/entries/${index}`;
     exactKeys(entry, ["name", "root", "size"], entryPath);
     token(entry.name, `${entryPath}/name`);
-    validateV4Root(entry.root, `${entryPath}/root`);
+    validateRoot(entry.root, `${entryPath}/root`);
     if (!Number.isSafeInteger(entry.size) || entry.size < 0)
       fault(
         "invalid-stage-capsule-content-size",
@@ -122,11 +125,11 @@ export function validateV4StageCapsuleOutputManifest(
       );
     prior = entry.name;
   }
-  validateV4Root(value.manifestRoot, "$/manifest/manifestRoot");
+  validateRoot(value.manifestRoot, "$/manifest/manifestRoot");
   if (
     verifyRoot &&
     value.manifestRoot !==
-      v4ContentRoot("stage-capsule-output-manifest", manifestPayload(value))
+      domainContentRoot("stage-capsule-output-manifest", manifestPayload(value))
   )
     fault(
       "stage-capsule-manifest-root-mismatch",
@@ -136,20 +139,20 @@ export function validateV4StageCapsuleOutputManifest(
   return value;
 }
 
-export function v4StageCapsuleRetentionPromiseRoot(promise) {
+export function stageCapsuleRetentionPromiseRoot(promise) {
   exactKeys(promise, ["class", "retainUntil"], "$/retentionPromise");
   token(promise.class, "$/retentionPromise/class");
-  validateV4Clock(promise.retainUntil, "$/retentionPromise/retainUntil");
-  return v4ContentRoot("stage-capsule-retention-promise", promise);
+  validateClock(promise.retainUntil, "$/retentionPromise/retainUntil");
+  return domainContentRoot("stage-capsule-retention-promise", promise);
 }
 
-export function createV4StageCapsuleRetentionState({ capsule, evaluatedAt }) {
-  validateV4StageCapsule(capsule);
-  validateV4Clock(evaluatedAt, "$/evaluatedAt");
+export function createStageCapsuleRetentionState({ capsule, evaluatedAt }) {
+  validateStageCapsule(capsule);
+  validateClock(evaluatedAt, "$/evaluatedAt");
   const value = {
-    schema: V4_STAGE_CAPSULE_RETENTION_STATE_CONTRACT,
+    schema: STAGE_CAPSULE_RETENTION_STATE_CONTRACT,
     capsuleRoot: capsule.capsuleRoot,
-    promiseRoot: v4StageCapsuleRetentionPromiseRoot(capsule.retentionPromise),
+    promiseRoot: stageCapsuleRetentionPromiseRoot(capsule.retentionPromise),
     evaluatedAt,
     status:
       evaluatedAt <= capsule.retentionPromise.retainUntil
@@ -158,11 +161,11 @@ export function createV4StageCapsuleRetentionState({ capsule, evaluatedAt }) {
   };
   return {
     ...value,
-    stateRoot: v4ContentRoot("stage-capsule-retention-state", value),
+    stateRoot: domainContentRoot("stage-capsule-retention-state", value),
   };
 }
 
-export function validateV4StageCapsuleRetentionState(value) {
+export function validateStageCapsuleRetentionState(value) {
   exactKeys(
     value,
     [
@@ -175,24 +178,24 @@ export function validateV4StageCapsuleRetentionState(value) {
     ],
     "$/retentionState",
   );
-  if (value.schema !== V4_STAGE_CAPSULE_RETENTION_STATE_CONTRACT)
+  if (value.schema !== STAGE_CAPSULE_RETENTION_STATE_CONTRACT)
     fault(
       "unsupported-stage-capsule-store-version",
       "$/retentionState/schema",
       "unsupported retention-state schema",
     );
-  validateV4Root(value.capsuleRoot, "$/retentionState/capsuleRoot");
-  validateV4Root(value.promiseRoot, "$/retentionState/promiseRoot");
-  validateV4Clock(value.evaluatedAt, "$/retentionState/evaluatedAt");
+  validateRoot(value.capsuleRoot, "$/retentionState/capsuleRoot");
+  validateRoot(value.promiseRoot, "$/retentionState/promiseRoot");
+  validateClock(value.evaluatedAt, "$/retentionState/evaluatedAt");
   if (!new Set(["retained", "expired"]).has(value.status))
     fault(
       "invalid-stage-capsule-retention-state",
       "$/retentionState/status",
       "retention status must be retained or expired",
     );
-  validateV4Root(value.stateRoot, "$/retentionState/stateRoot");
+  validateRoot(value.stateRoot, "$/retentionState/stateRoot");
   const { stateRoot, ...body } = value;
-  if (stateRoot !== v4ContentRoot("stage-capsule-retention-state", body))
+  if (stateRoot !== domainContentRoot("stage-capsule-retention-state", body))
     fault(
       "stage-capsule-retention-root-mismatch",
       "$/retentionState/stateRoot",
@@ -201,7 +204,7 @@ export function validateV4StageCapsuleRetentionState(value) {
   return value;
 }
 
-export function createV4StageCapsuleTransport({
+export function createStageCapsuleTransport({
   provider,
   mode,
   locatorRoot,
@@ -214,10 +217,10 @@ export function createV4StageCapsuleTransport({
       "$/transport",
       "unsupported transport provider or mode",
     );
-  validateV4Root(locatorRoot, "$/transport/locatorRoot");
-  validateV4Clock(observedAt, "$/transport/observedAt");
+  validateRoot(locatorRoot, "$/transport/locatorRoot");
+  validateClock(observedAt, "$/transport/observedAt");
   const value = {
-    schema: V4_STAGE_CAPSULE_TRANSPORT_CONTRACT,
+    schema: STAGE_CAPSULE_TRANSPORT_CONTRACT,
     provider,
     mode,
     locatorRoot,
@@ -225,11 +228,11 @@ export function createV4StageCapsuleTransport({
   };
   return {
     ...value,
-    transportRoot: v4ContentRoot("stage-capsule-transport", value),
+    transportRoot: domainContentRoot("stage-capsule-transport", value),
   };
 }
 
-export function validateV4StageCapsuleTransport(value) {
+export function validateStageCapsuleTransport(value) {
   exactKeys(
     value,
     [
@@ -242,7 +245,7 @@ export function validateV4StageCapsuleTransport(value) {
     ],
     "$/transport",
   );
-  const rebuilt = createV4StageCapsuleTransport(value);
+  const rebuilt = createStageCapsuleTransport(value);
   if (
     rebuilt.schema !== value.schema ||
     rebuilt.transportRoot !== value.transportRoot
@@ -255,9 +258,9 @@ export function validateV4StageCapsuleTransport(value) {
   return value;
 }
 
-export function createV4StageCapsuleStoreReceipt(value) {
+export function createStageCapsuleStoreReceipt(value) {
   const body = {
-    schema: V4_STAGE_CAPSULE_STORE_RECEIPT_CONTRACT,
+    schema: STAGE_CAPSULE_STORE_RECEIPT_CONTRACT,
     operation: value.operation,
     recordedAt: value.recordedAt,
     capsuleRoot: value.capsuleRoot,
@@ -271,12 +274,12 @@ export function createV4StageCapsuleStoreReceipt(value) {
   };
   const receipt = {
     ...body,
-    receiptRoot: v4ContentRoot("stage-capsule-store-receipt", body),
+    receiptRoot: domainContentRoot("stage-capsule-store-receipt", body),
   };
-  return validateV4StageCapsuleStoreReceipt(receipt);
+  return validateStageCapsuleStoreReceipt(receipt);
 }
 
-export function validateV4StageCapsuleStoreReceipt(value) {
+export function validateStageCapsuleStoreReceipt(value) {
   exactKeys(
     value,
     [
@@ -295,7 +298,7 @@ export function validateV4StageCapsuleStoreReceipt(value) {
     ],
     "$/receipt",
   );
-  if (value.schema !== V4_STAGE_CAPSULE_STORE_RECEIPT_CONTRACT)
+  if (value.schema !== STAGE_CAPSULE_STORE_RECEIPT_CONTRACT)
     fault(
       "unsupported-stage-capsule-store-version",
       "$/receipt/schema",
@@ -307,7 +310,7 @@ export function validateV4StageCapsuleStoreReceipt(value) {
       "$/receipt",
       "unsupported store operation or outcome",
     );
-  validateV4Clock(value.recordedAt, "$/receipt/recordedAt");
+  validateClock(value.recordedAt, "$/receipt/recordedAt");
   for (const name of [
     "capsuleRoot",
     "manifestRoot",
@@ -317,7 +320,7 @@ export function validateV4StageCapsuleStoreReceipt(value) {
     "qualificationRoot",
     "receiptRoot",
   ])
-    validateV4Root(value[name], `$/receipt/${name}`);
+    validateRoot(value[name], `$/receipt/${name}`);
   if (value.faultCode !== null)
     fault(
       "invalid-stage-capsule-store-receipt",
@@ -325,7 +328,7 @@ export function validateV4StageCapsuleStoreReceipt(value) {
       "successful store receipts cannot carry a fault",
     );
   const { receiptRoot, ...body } = value;
-  if (receiptRoot !== v4ContentRoot("stage-capsule-store-receipt", body))
+  if (receiptRoot !== domainContentRoot("stage-capsule-store-receipt", body))
     fault(
       "stage-capsule-store-receipt-root-mismatch",
       "$/receipt/receiptRoot",
@@ -341,12 +344,12 @@ function validateProviderRequest(operation, request) {
       : ["capsuleRoot", "locatorRoot", "recordedAt"];
   exactKeys(request, keys, "$/adapter/request");
   for (const name of keys.filter((name) => name.endsWith("Root")))
-    validateV4Root(request[name], `$/adapter/request/${name}`);
-  validateV4Clock(request.recordedAt, "$/adapter/request/recordedAt");
+    validateRoot(request[name], `$/adapter/request/${name}`);
+  validateClock(request.recordedAt, "$/adapter/request/recordedAt");
   return request;
 }
 
-export function createV4StageCapsuleProviderAdapter({
+export function createStageCapsuleProviderAdapter({
   provider,
   mode = "effect-disabled",
   fixture = null,
@@ -388,7 +391,7 @@ export function createV4StageCapsuleProviderAdapter({
     mode,
     observe: (request) => {
       exactKeys(request, ["locatorRoot", "observedAt"], "$/adapter/request");
-      return createV4StageCapsuleTransport({
+      return createStageCapsuleTransport({
         provider,
         mode,
         locatorRoot: request.locatorRoot,

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

@@ -1,16 +1,16 @@
 import {
-  V4ContractFault,
-  v4ContentRoot,
-  validateV4Clock,
-  validateV4Root,
-} from "./v4-canonical-contracts.js";
+  ContractFault,
+  domainContentRoot,
+  validateClock,
+  validateRoot,
+} from "./canonical-contracts.js";
 
-export const V4_STAGE_CAPSULE_CONTRACT = "buildchain-v4-stage-capsule/v1";
-export const V4_STAGE_CAPSULE_IDENTITY_CONTRACT =
+export const STAGE_CAPSULE_CONTRACT = "buildchain-v4-stage-capsule/v1";
+export const STAGE_CAPSULE_IDENTITY_CONTRACT =
   "buildchain-v4-stage-capsule-identity/v1";
-export const V4_STAGE_CAPSULE_AVAILABILITY_CONTRACT =
+export const STAGE_CAPSULE_AVAILABILITY_CONTRACT =
   "buildchain-v4-stage-capsule-availability/v1";
-export const V4_STAGE_CAPSULE_REUSE_CONTRACT =
+export const STAGE_CAPSULE_REUSE_CONTRACT =
   "buildchain-v4-stage-capsule-reuse/v1";
 
 const TOKEN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u;
@@ -25,7 +25,7 @@ const AVAILABILITY = new Set([
 ]);
 
 function fault(code, path, message) {
-  throw new V4ContractFault(code, path, message);
+  throw new ContractFault(code, path, message);
 }
 
 function exactKeys(value, keys, path) {
@@ -61,7 +61,7 @@ function validateNamedRoots(value, path) {
     const entryPath = `${path}/${index}`;
     exactKeys(entry, ["name", "root"], entryPath);
     validateToken(entry.name, `${entryPath}/name`);
-    validateV4Root(entry.root, `${entryPath}/root`);
+    validateRoot(entry.root, `${entryPath}/root`);
     if (prior !== null && entry.name <= prior)
       fault(
         "unordered-stage-capsule-roots",
@@ -72,7 +72,7 @@ function validateNamedRoots(value, path) {
   }
 }
 
-export function validateV4StageCapsuleIdentity(value) {
+export function validateStageCapsuleIdentity(value) {
   exactKeys(
     value,
     [
@@ -92,7 +92,7 @@ export function validateV4StageCapsuleIdentity(value) {
     ],
     "$/identity",
   );
-  if (value.schema !== V4_STAGE_CAPSULE_IDENTITY_CONTRACT)
+  if (value.schema !== STAGE_CAPSULE_IDENTITY_CONTRACT)
     fault(
       "unsupported-stage-capsule-version",
       "$/identity/schema",
@@ -109,22 +109,22 @@ export function validateV4StageCapsuleIdentity(value) {
     "outputManifestRoot",
     "qualificationRoot",
   ])
-    validateV4Root(value[name], `$/identity/${name}`);
+    validateRoot(value[name], `$/identity/${name}`);
   validateNamedRoots(value.toolchainRoots, "$/identity/toolchainRoots");
   validateNamedRoots(value.declaredInputs, "$/identity/declaredInputs");
   validateNamedRoots(value.observationRoots, "$/identity/observationRoots");
   return value;
 }
 
-export function v4StageCapsuleIdentityRoot(identity) {
-  validateV4StageCapsuleIdentity(identity);
-  return v4ContentRoot("stage-capsule-identity", identity);
+export function stageCapsuleIdentityRoot(identity) {
+  validateStageCapsuleIdentity(identity);
+  return domainContentRoot("stage-capsule-identity", identity);
 }
 
 function validateRetentionPromise(value) {
   exactKeys(value, ["class", "retainUntil"], "$/retentionPromise");
   validateToken(value.class, "$/retentionPromise/class");
-  validateV4Clock(value.retainUntil, "$/retentionPromise/retainUntil");
+  validateClock(value.retainUntil, "$/retentionPromise/retainUntil");
 }
 
 function capsulePayload(value) {
@@ -138,7 +138,7 @@ function capsulePayload(value) {
   };
 }
 
-export function validateV4StageCapsule(value) {
+export function validateStageCapsule(value) {
   exactKeys(
     value,
     [
@@ -152,7 +152,7 @@ export function validateV4StageCapsule(value) {
     ],
     "$",
   );
-  if (value.schema !== V4_STAGE_CAPSULE_CONTRACT)
+  if (value.schema !== STAGE_CAPSULE_CONTRACT)
     fault(
       "unsupported-stage-capsule-version",
       "$/schema",
@@ -167,8 +167,8 @@ export function validateV4StageCapsule(value) {
       "$/writerAuthority",
       "Stage Capsule authority must remain TypeScript v3 with validation-only Rust",
     );
-  const identityRoot = v4StageCapsuleIdentityRoot(value.identity);
-  validateV4Root(value.identityRoot, "$/identityRoot");
+  const identityRoot = stageCapsuleIdentityRoot(value.identity);
+  validateRoot(value.identityRoot, "$/identityRoot");
   if (value.identityRoot !== identityRoot)
     fault(
       "stage-capsule-identity-root-mismatch",
@@ -176,8 +176,8 @@ export function validateV4StageCapsule(value) {
       "identityRoot does not bind the canonical Stage Capsule identity",
     );
   validateRetentionPromise(value.retentionPromise);
-  validateV4Root(value.capsuleRoot, "$/capsuleRoot");
-  const capsuleRoot = v4ContentRoot("stage-capsule", capsulePayload(value));
+  validateRoot(value.capsuleRoot, "$/capsuleRoot");
+  const capsuleRoot = domainContentRoot("stage-capsule", capsulePayload(value));
   if (value.capsuleRoot !== capsuleRoot)
     fault(
       "stage-capsule-root-mismatch",
@@ -187,13 +187,13 @@ export function validateV4StageCapsule(value) {
   return value;
 }
 
-export function v4StageCapsuleRoot(value) {
-  validateV4StageCapsuleIdentity(value.identity);
+export function stageCapsuleRoot(value) {
+  validateStageCapsuleIdentity(value.identity);
   validateRetentionPromise(value.retentionPromise);
-  return v4ContentRoot("stage-capsule", capsulePayload(value));
+  return domainContentRoot("stage-capsule", capsulePayload(value));
 }
 
-export function validateV4StageCapsuleAvailability(value) {
+export function validateStageCapsuleAvailability(value) {
   exactKeys(
     value,
     [
@@ -208,14 +208,14 @@ export function validateV4StageCapsuleAvailability(value) {
     ],
     "$/availability",
   );
-  if (value.schema !== V4_STAGE_CAPSULE_AVAILABILITY_CONTRACT)
+  if (value.schema !== STAGE_CAPSULE_AVAILABILITY_CONTRACT)
     fault(
       "unsupported-stage-capsule-version",
       "$/availability/schema",
       "unsupported Stage Capsule availability schema",
     );
-  validateV4Root(value.capsuleRoot, "$/availability/capsuleRoot");
-  validateV4Clock(value.observedAt, "$/availability/observedAt");
+  validateRoot(value.capsuleRoot, "$/availability/capsuleRoot");
+  validateClock(value.observedAt, "$/availability/observedAt");
   if (!AVAILABILITY.has(value.status))
     fault(
       "invalid-stage-capsule-availability",
@@ -224,7 +224,7 @@ export function validateV4StageCapsuleAvailability(value) {
     );
   for (const name of ["contentRoot", "qualificationRoot"])
     if (value[name] !== null)
-      validateV4Root(value[name], `$/availability/${name}`);
+      validateRoot(value[name], `$/availability/${name}`);
   validateNamedRoots(value.transports, "$/availability/transports");
   if (value.faultCode !== null)
     validateToken(value.faultCode, "$/availability/faultCode");
@@ -248,12 +248,12 @@ export function validateV4StageCapsuleAvailability(value) {
   return value;
 }
 
-export function v4StageCapsuleAvailabilityRoot(value) {
-  validateV4StageCapsuleAvailability(value);
-  return v4ContentRoot("stage-capsule-availability", value);
+export function stageCapsuleAvailabilityRoot(value) {
+  validateStageCapsuleAvailability(value);
+  return domainContentRoot("stage-capsule-availability", value);
 }
 
-export function evaluateV4StageCapsuleReuse(request) {
+export function evaluateStageCapsuleReuse(request) {
   exactKeys(
     request,
     [
@@ -267,26 +267,26 @@ export function evaluateV4StageCapsuleReuse(request) {
     ],
     "$",
   );
-  if (request.schema !== V4_STAGE_CAPSULE_REUSE_CONTRACT)
+  if (request.schema !== STAGE_CAPSULE_REUSE_CONTRACT)
     fault(
       "unsupported-stage-capsule-version",
       "$/schema",
       "unsupported Stage Capsule reuse schema",
     );
-  validateV4StageCapsule(request.capsule);
-  validateV4StageCapsuleAvailability(request.availability);
-  validateV4Clock(request.evaluatedAt, "$/evaluatedAt");
+  validateStageCapsule(request.capsule);
+  validateStageCapsuleAvailability(request.availability);
+  validateClock(request.evaluatedAt, "$/evaluatedAt");
   for (const name of [
     "expectedCapsuleRoot",
     "expectedOutputManifestRoot",
     "expectedQualificationRoot",
   ])
-    validateV4Root(request[name], `$/${name}`);
+    validateRoot(request[name], `$/${name}`);
   const fail = (reason) => ({
-    schema: V4_STAGE_CAPSULE_REUSE_CONTRACT,
+    schema: STAGE_CAPSULE_REUSE_CONTRACT,
     eligible: false,
     capsuleRoot: request.capsule.capsuleRoot,
-    availabilityRoot: v4StageCapsuleAvailabilityRoot(request.availability),
+    availabilityRoot: stageCapsuleAvailabilityRoot(request.availability),
     reason,
   });
   if (
@@ -310,10 +310,10 @@ export function evaluateV4StageCapsuleReuse(request) {
   )
     return fail("root-mismatch");
   return {
-    schema: V4_STAGE_CAPSULE_REUSE_CONTRACT,
+    schema: STAGE_CAPSULE_REUSE_CONTRACT,
     eligible: true,
     capsuleRoot: request.capsule.capsuleRoot,
-    availabilityRoot: v4StageCapsuleAvailabilityRoot(request.availability),
+    availabilityRoot: stageCapsuleAvailabilityRoot(request.availability),
     reason: "eligible",
   };
 }

package/packages/core/{v4-tail-reseal-contract.js → tail-reseal-contract.js}

@@ -1,24 +1,24 @@
-export const V4_TAIL_RESEAL_REQUEST_CONTRACT =
+export const TAIL_RESEAL_REQUEST_CONTRACT =
   "kungfu-buildchain-v4-tail-reseal-request/v1";
-export const V4_TAIL_RESEAL_PLAN_CONTRACT =
+export const TAIL_RESEAL_PLAN_CONTRACT =
   "kungfu-buildchain-v4-tail-reseal-plan/v1";
 
-export const V4_TAIL_RESEAL_PLATFORMS = Object.freeze([
+export const TAIL_RESEAL_PLATFORMS = Object.freeze([
   "linux-arm64",
   "linux-x64",
   "macos-arm64",
   "windows-x64",
 ]);
 
-export const V4_TAIL_RESEAL_PLATFORM_RUNNERS = Object.freeze({
+export const TAIL_RESEAL_PLATFORM_RUNNERS = Object.freeze({
   "linux-arm64": '["ubuntu-24.04-arm"]',
   "linux-x64": '["ubuntu-24.04"]',
   "macos-arm64": '["macos-15"]',
   "windows-x64": '["windows-2025"]',
 });
 
-export const V4_TAIL_RESEAL_REUSED_STAGE_KEYS = Object.freeze(
-  V4_TAIL_RESEAL_PLATFORMS.flatMap((platformId) =>
+export const TAIL_RESEAL_REUSED_STAGE_KEYS = Object.freeze(
+  TAIL_RESEAL_PLATFORMS.flatMap((platformId) =>
     ["build", "install", "package", "verify"].map(
       (stage) => `${platformId}:${stage}`,
     ),

package/packages/core/{v4-tail-reseal-github.js → tail-reseal-github.js}

@@ -1,10 +1,7 @@
-import { v4ContentRoot } from "./v4-canonical-contracts.js";
-import {
-  V4TailResealFault,
-  normalizeV4TailResealRequest,
-} from "./v4-tail-reseal.js";
+import { domainContentRoot } from "./canonical-contracts.js";
+import { TailResealFault, normalizeTailResealRequest } from "./tail-reseal.js";
 
-export const V4_TAIL_RESEAL_ADMISSION_CONTRACT =
+export const TAIL_RESEAL_ADMISSION_CONTRACT =
   "kungfu-buildchain-v4-tail-reseal-admission/v1";
 
 const REQUIRED_SUCCESS_JOBS = Object.freeze([
@@ -22,7 +19,7 @@ const REQUIRED_SUCCESS_JOBS = Object.freeze([
 ]);
 
 function fault(code, path, message) {
-  throw new V4TailResealFault(code, path, message);
+  throw new TailResealFault(code, path, message);
 }
 
 function exactArtifact(artifacts, name, digest, path) {
@@ -141,7 +138,7 @@ function validateSigningAuthority(normalized, signingRun, signingArtifacts) {
   );
 }
 
-export function validateV4TailResealGitHubEvidence({
+export function validateTailResealGitHubEvidence({
   request,
   sourceCommit,
   sourceRun,
@@ -150,13 +147,13 @@ export function validateV4TailResealGitHubEvidence({
   signingRun,
   signingArtifacts,
 } = {}) {
-  const normalized = normalizeV4TailResealRequest(request);
+  const normalized = normalizeTailResealRequest(request);
   validateSourceIdentity(normalized, sourceCommit, sourceRun);
   validateSourceJobs(normalized, sourceJobs);
   validateRetainedArtifacts(normalized, sourceArtifacts);
   validateSigningAuthority(normalized, signingRun, signingArtifacts);
   const payload = {
-    schema: V4_TAIL_RESEAL_ADMISSION_CONTRACT,
+    schema: TAIL_RESEAL_ADMISSION_CONTRACT,
     repository: normalized.repository,
     sourceRoot: normalized.source.sourceRoot,
     sourceRunId: normalized.source.runId,
@@ -171,8 +168,11 @@ export function validateV4TailResealGitHubEvidence({
   };
   return {
     ...payload,
-    admissionRoot: v4ContentRoot("tail-reseal-admission", payload),
+    admissionRoot: domainContentRoot("tail-reseal-admission", payload),
   };
 }
 
-export { REQUIRED_SUCCESS_JOBS as V4_TAIL_RESEAL_REQUIRED_SUCCESS_JOBS };
+export {
+  REQUIRED_SUCCESS_JOBS as TAIL_RESEAL_REQUIRED_SUCCESS_JOBS,
+  REQUIRED_SUCCESS_JOBS as V4_TAIL_RESEAL_REQUIRED_SUCCESS_JOBS,
+};