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

package/packages/core/{v4-canonical-contracts.js → canonical-contracts.js}

@@ -1,9 +1,9 @@
-import { V4DomainWasmFault, invokeV4DomainWasm } from "./v4-domain-wasm.js";
+import { DomainWasmFault, invokeDomainWasm } from "./domain-wasm.js";
 
-export const V4_CANONICAL_JSON_CONTRACT = "buildchain-canonical-json/v1";
-export const V4_EVENT_ENVELOPE_CONTRACT = "buildchain-v4-event-envelope/v1";
-export const V4_RECEIPT_ENVELOPE_CONTRACT = "buildchain-v4-receipt-envelope/v1";
-export const V4_CONTRACT_FAULT_CONTRACT = "buildchain-v4-contract-fault/v1";
+export const CANONICAL_JSON_CONTRACT = "buildchain-canonical-json/v1";
+export const EVENT_ENVELOPE_CONTRACT = "buildchain-v4-event-envelope/v1";
+export const RECEIPT_ENVELOPE_CONTRACT = "buildchain-v4-receipt-envelope/v1";
+export const CONTRACT_FAULT_CONTRACT = "buildchain-v4-contract-fault/v1";
 
 const ROOT_PATTERN = /^sha256:[0-9a-f]{64}$/u;
 const CLOCK_PATTERN = /^(?!0000)\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/u;
@@ -58,6 +58,7 @@ const ROOT_DOMAINS = new Set([
   "partial-mutation-recovery-checkpoint",
   "partial-mutation-recovery-plan",
   "v4-product-required-artifacts",
+  "oci-publication-family",
   "v4-product-publication-intent",
   "v4-product-publication-operation",
   "v4-product-publication-plan",
@@ -86,17 +87,17 @@ const FAULT_CLASSES = new Set([
 const RETRY_DECISIONS = new Set(["stop", "reread", "redecide", "reselect"]);
 const RECEIPT_OUTCOMES = new Set(["accepted", "rejected", "noop"]);
 
-export class V4ContractFault extends Error {
+export class ContractFault extends Error {
   constructor(code, path, message) {
     super(message);
-    this.name = "V4ContractFault";
+    this.name = "ContractFault";
     this.code = code;
     this.path = path;
   }
 }
 
 function fault(code, path, message) {
-  throw new V4ContractFault(code, path, message);
+  throw new ContractFault(code, path, message);
 }
 
 function exactKeys(value, keys, path) {
@@ -113,30 +114,30 @@ function exactKeys(value, keys, path) {
 
 function wasm(operation, payload) {
   try {
-    return invokeV4DomainWasm(operation, payload);
+    return invokeDomainWasm(operation, payload);
   } catch (error) {
-    if (error instanceof V4DomainWasmFault) {
+    if (error instanceof DomainWasmFault) {
       fault(error.code, error.path, error.message);
     }
     throw error;
   }
 }
 
-export function v4CanonicalBytes(value) {
+export function domainCanonicalBytes(value) {
   return Buffer.from(wasm("canonical-json", value).canonicalUtf8, "utf8");
 }
 
-export function v4ContentRoot(domain, value) {
+export function domainContentRoot(domain, value) {
   return wasm("content-root", { domain, value }).root;
 }
 
-export function validateV4Root(value, path = "$.root") {
+export function validateRoot(value, path = "$.root") {
   if (typeof value !== "string" || !ROOT_PATTERN.test(value))
     fault("invalid-root", path, `${path} must be a lowercase sha256 root`);
   return value;
 }
 
-export function validateV4Clock(value, path = "$.clock") {
+export function validateClock(value, path = "$.clock") {
   if (typeof value !== "string" || !CLOCK_PATTERN.test(value))
     fault(
       "invalid-clock",
@@ -149,13 +150,13 @@ export function validateV4Clock(value, path = "$.clock") {
   return value;
 }
 
-export function validateV4ContractFault(value, path = "$.fault") {
+export function validateContractFault(value, path = "$.fault") {
   exactKeys(
     value,
     ["schema", "code", "class", "path", "message", "retry"],
     path,
   );
-  if (value.schema !== V4_CONTRACT_FAULT_CONTRACT)
+  if (value.schema !== CONTRACT_FAULT_CONTRACT)
     fault("invalid-fault", `${path}/schema`, "unsupported fault schema");
   if (!ASCII_TOKEN_PATTERN.test(value.code))
     fault("invalid-fault", `${path}/code`, "fault code must be an ASCII token");
@@ -171,28 +172,28 @@ export function validateV4ContractFault(value, path = "$.fault") {
       `${path}/retry`,
       "fault retry decision is unsupported",
     );
-  v4CanonicalBytes(value);
+  domainCanonicalBytes(value);
   return value;
 }
 
-export function validateV4EventEnvelope(value) {
+export function validateEventEnvelope(value) {
   exactKeys(
     value,
     ["schema", "eventId", "eventType", "occurredAt", "subjectRoot", "payload"],
     "$",
   );
-  if (value.schema !== V4_EVENT_ENVELOPE_CONTRACT)
+  if (value.schema !== EVENT_ENVELOPE_CONTRACT)
     fault("invalid-event", "$/schema", "unsupported event schema");
-  validateV4Root(value.eventId, "$/eventId");
-  validateV4Root(value.subjectRoot, "$/subjectRoot");
-  validateV4Clock(value.occurredAt, "$/occurredAt");
+  validateRoot(value.eventId, "$/eventId");
+  validateRoot(value.subjectRoot, "$/subjectRoot");
+  validateClock(value.occurredAt, "$/occurredAt");
   if (!ASCII_TOKEN_PATTERN.test(value.eventType))
     fault("invalid-event", "$/eventType", "event type must be an ASCII token");
-  v4CanonicalBytes(value.payload);
+  domainCanonicalBytes(value.payload);
   return value;
 }
 
-export function validateV4ReceiptEnvelope(value) {
+export function validateReceiptEnvelope(value) {
   exactKeys(
     value,
     [
@@ -207,7 +208,7 @@ export function validateV4ReceiptEnvelope(value) {
     ],
     "$",
   );
-  if (value.schema !== V4_RECEIPT_ENVELOPE_CONTRACT)
+  if (value.schema !== RECEIPT_ENVELOPE_CONTRACT)
     fault("invalid-receipt", "$/schema", "unsupported receipt schema");
   if (!ASCII_TOKEN_PATTERN.test(value.receiptType))
     fault(
@@ -215,15 +216,15 @@ export function validateV4ReceiptEnvelope(value) {
       "$/receiptType",
       "receipt type must be an ASCII token",
     );
-  validateV4Clock(value.recordedAt, "$/recordedAt");
-  validateV4Root(value.eventRoot, "$/eventRoot");
+  validateClock(value.recordedAt, "$/recordedAt");
+  validateRoot(value.eventRoot, "$/eventRoot");
   if (value.priorStateRoot !== null)
-    validateV4Root(value.priorStateRoot, "$/priorStateRoot");
+    validateRoot(value.priorStateRoot, "$/priorStateRoot");
   if (value.nextStateRoot !== null)
-    validateV4Root(value.nextStateRoot, "$/nextStateRoot");
+    validateRoot(value.nextStateRoot, "$/nextStateRoot");
   if (!RECEIPT_OUTCOMES.has(value.outcome))
     fault("invalid-receipt", "$/outcome", "receipt outcome is unsupported");
-  if (value.fault !== null) validateV4ContractFault(value.fault);
+  if (value.fault !== null) validateContractFault(value.fault);
   if ((value.outcome === "rejected") !== (value.fault !== null))
     fault(
       "invalid-receipt",
@@ -233,6 +234,6 @@ export function validateV4ReceiptEnvelope(value) {
   return value;
 }
 
-export function v4ContractDomains() {
+export function contractDomains() {
   return [...ROOT_DOMAINS];
 }

package/packages/core/{v4-cross-platform-adopter-qualification.js → cross-platform-adopter-qualification.js}

@@ -1,15 +1,15 @@
 import { adopterDeliveryGateDigest } from "./adopter-delivery-json.js";
 
-export const V4_CROSS_PLATFORM_ADOPTER_REPORT_CONTRACT =
+export const CROSS_PLATFORM_ADOPTER_REPORT_CONTRACT =
   "kungfu-buildchain-v4-cross-platform-adopter-report/v1";
-export const V4_CROSS_PLATFORM_ADOPTER_QUALIFICATION_CONTRACT =
+export const CROSS_PLATFORM_ADOPTER_QUALIFICATION_CONTRACT =
   "kungfu-buildchain-v4-cross-platform-adopter-qualification/v1";
-export const V4_CROSS_PLATFORM_ADOPTER_PLATFORMS = Object.freeze([
+export const CROSS_PLATFORM_ADOPTER_PLATFORMS = Object.freeze([
   "linux-x64",
   "macos-arm64",
   "windows-x64",
 ]);
-export const V4_CROSS_PLATFORM_NEUTRAL_DRIVER = "ledger-specification-driver";
+export const CROSS_PLATFORM_NEUTRAL_DRIVER = "ledger-specification-driver";
 
 const SHA = /^[0-9a-f]{40}$/u;
 const ROOT = /^sha256:[0-9a-f]{64}$/u;
@@ -36,7 +36,7 @@ function same(left, right) {
   return adopterDeliveryGateDigest(left) === adopterDeliveryGateDigest(right);
 }
 
-export function summarizeV3V4CapabilityInventory(inventory) {
+export function summarizeBaselineCapabilityInventory(inventory) {
   exactKeys(
     inventory,
     [
@@ -197,7 +197,7 @@ function validateExecutionEvidence(execution) {
       execution.retryRun.readbackRoot &&
     execution.bootstrap?.status === "passed" &&
     ROOT.test(execution.bootstrap?.resultRoot || "") &&
-    execution.neutralDriver?.id === V4_CROSS_PLATFORM_NEUTRAL_DRIVER &&
+    execution.neutralDriver?.id === CROSS_PLATFORM_NEUTRAL_DRIVER &&
     execution.neutralDriver?.status === "passed" &&
     execution.neutralDriver?.kfdDependencyPresent === false;
   if (!complete)
@@ -219,7 +219,7 @@ function validateAuthorityCeiling(authority) {
     fail("qualification report must not grant production or release authority");
 }
 
-export function validateV4CrossPlatformAdopterReport(report) {
+export function validateCrossPlatformAdopterReport(report) {
   exactKeys(
     report,
     [
@@ -237,10 +237,10 @@ export function validateV4CrossPlatformAdopterReport(report) {
   );
   if (
     report.schemaVersion !== 1 ||
-    report.contract !== V4_CROSS_PLATFORM_ADOPTER_REPORT_CONTRACT
+    report.contract !== CROSS_PLATFORM_ADOPTER_REPORT_CONTRACT
   )
     fail("platform report contract is unsupported");
-  if (!V4_CROSS_PLATFORM_ADOPTER_PLATFORMS.includes(report.platform))
+  if (!CROSS_PLATFORM_ADOPTER_PLATFORMS.includes(report.platform))
     fail(`undeclared platform ${report.platform}`);
   if (!CONSUMER.test(report.consumer || ""))
     fail("consumer must be a stable lowercase identity");
@@ -256,18 +256,18 @@ export function validateV4CrossPlatformAdopterReport(report) {
   return structuredClone(report);
 }
 
-export function createV4CrossPlatformAdopterReport(input) {
+export function createCrossPlatformAdopterReport(input) {
   const body = structuredClone(input);
   const report = {
     schemaVersion: 1,
-    contract: V4_CROSS_PLATFORM_ADOPTER_REPORT_CONTRACT,
+    contract: CROSS_PLATFORM_ADOPTER_REPORT_CONTRACT,
     ...body,
   };
   report.reportRoot = adopterDeliveryGateDigest(report);
-  return validateV4CrossPlatformAdopterReport(report);
+  return validateCrossPlatformAdopterReport(report);
 }
 
-export function qualifyV4CrossPlatformAdopters({ reports, consumers }) {
+export function qualifyCrossPlatformAdopters({ reports, consumers }) {
   if (!Array.isArray(reports) || reports.length === 0)
     fail("at least one raw platform report is required");
   if (
@@ -277,9 +277,9 @@ export function qualifyV4CrossPlatformAdopters({ reports, consumers }) {
     new Set(consumers).size !== consumers.length
   )
     fail("required consumers must be unique stable lowercase identities");
-  const normalized = reports.map(validateV4CrossPlatformAdopterReport);
+  const normalized = reports.map(validateCrossPlatformAdopterReport);
   const expectedKeys = consumers.flatMap((consumer) =>
-    V4_CROSS_PLATFORM_ADOPTER_PLATFORMS.map(
+    CROSS_PLATFORM_ADOPTER_PLATFORMS.map(
       (platform) => `${consumer}:${platform}`,
     ),
   );
@@ -310,14 +310,14 @@ export function qualifyV4CrossPlatformAdopters({ reports, consumers }) {
   const orderedReports = expectedKeys.map((key) => reportByKey.get(key));
   const body = {
     schemaVersion: 1,
-    contract: V4_CROSS_PLATFORM_ADOPTER_QUALIFICATION_CONTRACT,
+    contract: CROSS_PLATFORM_ADOPTER_QUALIFICATION_CONTRACT,
     sourceBinding: {
       runtimeSha: reference.runtimeSha,
       inventoryRoot: reference.inventoryRoot,
       sourceCuts: structuredClone(reference.sourceCuts),
     },
     consumers: [...consumers],
-    platforms: [...V4_CROSS_PLATFORM_ADOPTER_PLATFORMS],
+    platforms: [...CROSS_PLATFORM_ADOPTER_PLATFORMS],
     capabilityMatrix: structuredClone(normalized[0].capabilityMatrix),
     reports: orderedReports.map(({ consumer, platform, reportRoot }) => ({
       consumer,
@@ -325,8 +325,8 @@ export function qualifyV4CrossPlatformAdopters({ reports, consumers }) {
       reportRoot,
     })),
     neutralDriver: {
-      id: V4_CROSS_PLATFORM_NEUTRAL_DRIVER,
-      platformCoverage: [...V4_CROSS_PLATFORM_ADOPTER_PLATFORMS],
+      id: CROSS_PLATFORM_NEUTRAL_DRIVER,
+      platformCoverage: [...CROSS_PLATFORM_ADOPTER_PLATFORMS],
       status: "passed",
     },
     authority: {

package/packages/core/{v4-delivery-warrant-fixture-runner.js → delivery-warrant-fixture-runner.js}

@@ -1,27 +1,27 @@
 import { TextDecoder } from "node:util";
 
 import {
-  V4ContractFault,
-  v4CanonicalBytes,
-  v4ContentRoot,
-  validateV4ContractFault,
-  validateV4EventEnvelope,
-  validateV4ReceiptEnvelope,
-  validateV4Root,
-} from "./v4-canonical-contracts.js";
+  ContractFault,
+  domainCanonicalBytes,
+  domainContentRoot,
+  validateContractFault,
+  validateEventEnvelope,
+  validateReceiptEnvelope,
+  validateRoot,
+} from "./canonical-contracts.js";
 
-export const V4_DELIVERY_WARRANT_TRACE_CONTRACT =
+export const DELIVERY_WARRANT_TRACE_CONTRACT =
   "buildchain-v4-delivery-warrant-trace-fixture/v1";
-export const V4_DELIVERY_WARRANT_RUNNER_CONTRACT =
+export const DELIVERY_WARRANT_RUNNER_CONTRACT =
   "buildchain-v4-delivery-warrant-fixture-runner/v1";
-export const V4_DELIVERY_WARRANT_PROJECTION_CONTRACT =
+export const DELIVERY_WARRANT_PROJECTION_CONTRACT =
   "buildchain-v4-delivery-warrant-semantic-projection/v1";
 
 const ASCII_TOKEN_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u;
 const UTF8 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: false });
 
 function fail(code, path, message) {
-  throw new V4ContractFault(code, path, message);
+  throw new ContractFault(code, path, message);
 }
 
 function exactKeys(value, keys, path) {
@@ -53,11 +53,11 @@ function nonNegativeInteger(value, path) {
 }
 
 function equalCanonical(left, right) {
-  return v4CanonicalBytes(left).equals(v4CanonicalBytes(right));
+  return domainCanonicalBytes(left).equals(domainCanonicalBytes(right));
 }
 
 function declaredRoot(value, expected, path, code) {
-  validateV4Root(value, path);
+  validateRoot(value, path);
   if (value !== expected)
     fail(code, path, `${path} does not match the retained canonical bytes`);
   return value;
@@ -113,7 +113,7 @@ function validateOrderedEntries(entries, path) {
         `${path} sequence must be contiguous and ordered`,
       );
     token(entry.type, `${path}/${index}/type`);
-    v4CanonicalBytes(entry.payload);
+    domainCanonicalBytes(entry.payload);
     return entry;
   });
 }
@@ -141,12 +141,12 @@ function validateState(state, path) {
       `${path}/candidates`,
       "state candidates must be an array",
     );
-  const canonicalUtf8 = v4CanonicalBytes(state).toString("utf8");
+  const canonicalUtf8 = domainCanonicalBytes(state).toString("utf8");
   return {
     generation,
     fencingCounter,
     canonicalUtf8,
-    root: v4ContentRoot("queue-state", state),
+    root: domainContentRoot("queue-state", state),
   };
 }
 
@@ -169,7 +169,7 @@ function validateDecision(decision, receipt, path) {
         "an action cannot bind a rejected receipt",
       );
   } else {
-    validateV4ContractFault(decision.fault, `${path}/fault`);
+    validateContractFault(decision.fault, `${path}/fault`);
     if (
       receipt.outcome !== "rejected" ||
       receipt.fault === null ||
@@ -219,14 +219,14 @@ function projectStep(step, index, priorStateRoot) {
     "stale-prior-root",
   );
 
-  validateV4EventEnvelope(step.event);
+  validateEventEnvelope(step.event);
   if (step.event.subjectRoot !== priorStateRoot)
     fail(
       "stale-prior-root",
       `${path}/event/subjectRoot`,
       "event subjectRoot must bind the exact prior state",
     );
-  const eventRoot = v4ContentRoot("observation", step.event);
+  const eventRoot = domainContentRoot("observation", step.event);
 
   const successor = validateState(
     step.successorState,
@@ -239,7 +239,7 @@ function projectStep(step, index, priorStateRoot) {
     "stale-successor-root",
   );
 
-  validateV4ReceiptEnvelope(step.receipt);
+  validateReceiptEnvelope(step.receipt);
   if (
     step.receipt.eventRoot !== eventRoot ||
     step.receipt.priorStateRoot !== priorStateRoot ||
@@ -266,10 +266,12 @@ function projectStep(step, index, priorStateRoot) {
     step.observations,
     `${path}/observations`,
   );
-  const receiptCanonicalUtf8 = v4CanonicalBytes(step.receipt).toString("utf8");
+  const receiptCanonicalUtf8 = domainCanonicalBytes(step.receipt).toString(
+    "utf8",
+  );
   const receiptRoot = declaredRoot(
     step.receiptRoot,
-    v4ContentRoot("transition-receipt", step.receipt),
+    domainContentRoot("transition-receipt", step.receipt),
     `${path}/receiptRoot`,
     "stale-receipt-root",
   );
@@ -288,13 +290,15 @@ function projectStep(step, index, priorStateRoot) {
       effects: effects.map((effect) => ({
         sequence: effect.sequence,
         type: effect.type,
-        canonicalUtf8: v4CanonicalBytes(effect.payload).toString("utf8"),
+        canonicalUtf8: domainCanonicalBytes(effect.payload).toString("utf8"),
       })),
       observations: observations.map((observation) => ({
         sequence: observation.sequence,
         type: observation.type,
-        canonicalUtf8: v4CanonicalBytes(observation.payload).toString("utf8"),
-        root: v4ContentRoot("observation", observation.payload),
+        canonicalUtf8: domainCanonicalBytes(observation.payload).toString(
+          "utf8",
+        ),
+        root: domainContentRoot("observation", observation.payload),
       })),
       receiptCanonicalUtf8,
       receiptRoot,
@@ -303,7 +307,7 @@ function projectStep(step, index, priorStateRoot) {
   };
 }
 
-export function runV4DeliveryWarrantTraceFixture(
+export function runDeliveryWarrantTraceFixture(
   bytes,
   { verifyExpectedRoot = true } = {},
 ) {
@@ -315,8 +319,8 @@ export function runV4DeliveryWarrantTraceFixture(
   );
   if (
     fixture.schemaVersion !== 1 ||
-    fixture.contract !== V4_DELIVERY_WARRANT_TRACE_CONTRACT ||
-    fixture.runner !== V4_DELIVERY_WARRANT_RUNNER_CONTRACT
+    fixture.contract !== DELIVERY_WARRANT_TRACE_CONTRACT ||
+    fixture.runner !== DELIVERY_WARRANT_RUNNER_CONTRACT
   )
     fail(
       "unsupported-trace-version",
@@ -354,13 +358,13 @@ export function runV4DeliveryWarrantTraceFixture(
     return result.projection;
   });
   const projection = {
-    schema: V4_DELIVERY_WARRANT_PROJECTION_CONTRACT,
+    schema: DELIVERY_WARRANT_PROJECTION_CONTRACT,
     traceId: fixture.trace.id,
     traceKind: fixture.trace.kind,
     steps,
   };
-  const projectionRoot = v4ContentRoot("semantic-diff", projection);
-  validateV4Root(fixture.expectedProjectionRoot, "$/expectedProjectionRoot");
+  const projectionRoot = domainContentRoot("semantic-diff", projection);
+  validateRoot(fixture.expectedProjectionRoot, "$/expectedProjectionRoot");
   if (verifyExpectedRoot && fixture.expectedProjectionRoot !== projectionRoot)
     fail(
       "stale-projection-root",