@serve.zone/interfaces 31.9.0 → 32.0.0

package/ts/data/nodeenrollment.ts

@@ -5,8 +5,11 @@ import {
   createSha256Hex,
   deepFreezeValue,
 } from '../private/canonicaljson.js';
+import {
+  readDataElements, readDataProperty, readExactDataRecord,
+} from '../private/dataproperties.js';
 
-export interface INodeEnrollmentCredentialProposalV1 {
+export interface INodeEnrollmentCredentialProposal {
   purpose: TNodeCredentialPurpose;
   installationId: string;
   mutationId: string;
@@ -17,8 +20,7 @@ export interface INodeEnrollmentCredentialProposalV1 {
 }
 
 /** Value-free, immutable proposal. Hashes are still sensitive transport fields. */
-export interface INodeEnrollmentV1 {
-  schemaVersion: 1;
+export interface INodeEnrollment {
   /** 32 CSPRNG bytes encoded as lowercase hexadecimal; retain across every retry. */
   enrollmentId: string;
   cloudlyOrigin: string;
@@ -27,18 +29,18 @@ export interface INodeEnrollmentV1 {
     | { kind: 'jump'; proofHash: string }
     | { kind: 'adopt-existing'; nodeId: string; proofHash: string };
   credentials: [
-    INodeEnrollmentCredentialProposalV1 & { purpose: 'spark' },
-    INodeEnrollmentCredentialProposalV1 & { purpose: 'pallet' },
+    INodeEnrollmentCredentialProposal & { purpose: 'spark' },
+    INodeEnrollmentCredentialProposal & { purpose: 'pallet' },
   ];
 }
 
-export interface INodeEnrollmentRequestV1 {
-  enrollment: INodeEnrollmentV1;
+export interface INodeEnrollmentRequest {
+  enrollment: INodeEnrollment;
   /** Never persist on the server, log, put in URLs, or expose in transport hooks. */
   proof: { kind: 'bootstrap' | 'pending-spark'; bearer: string };
 }
 
-export interface INodeEnrollmentCredentialAcknowledgementV1 {
+export interface INodeEnrollmentCredentialAcknowledgement {
   purpose: TNodeCredentialPurpose;
   installationId: string;
   mutationId: string;
@@ -47,29 +49,26 @@ export interface INodeEnrollmentCredentialAcknowledgementV1 {
 }
 
 /** Immutable commit evidence, not authorization or workload readiness. */
-export interface INodeEnrollmentAcknowledgementV1 {
-  schemaVersion: 1;
+export interface INodeEnrollmentAcknowledgement {
   enrollmentId: string;
   cloudlyOrigin: string;
   nodeId: string;
   requestDigest: string;
   credentials: [
-    INodeEnrollmentCredentialAcknowledgementV1 & { purpose: 'spark' },
-    INodeEnrollmentCredentialAcknowledgementV1 & { purpose: 'pallet' },
+    INodeEnrollmentCredentialAcknowledgement & { purpose: 'spark' },
+    INodeEnrollmentCredentialAcknowledgement & { purpose: 'pallet' },
   ];
 }
 
 /** Returned only after current Spark authentication and proof that Pallet is absent. */
-export interface INodeEnrollmentStateV1 {
-  schemaVersion: 1;
+export interface INodeEnrollmentState {
   nodeId: string;
   spark: { generation: number; sessionEpoch: number };
   pallet: 'absent';
 }
 
 /** Root-authenticated, node-local IPC only. Initial Pallet authority is always absent. */
-export interface IPalletNodeEnrollmentPreparationV1 {
-  schemaVersion: 1;
+export interface IPalletNodeEnrollmentPreparation {
   purpose: 'pallet';
   installationId: string;
   mutationId: string;
@@ -78,13 +77,12 @@ export interface IPalletNodeEnrollmentPreparationV1 {
 }
 
 /** Full exact activation wire body; Cloudly authentication remains the coordinator's responsibility. */
-export interface IPalletNodeEnrollmentActivationV1 {
-  enrollment: INodeEnrollmentV1;
-  acknowledgement: INodeEnrollmentAcknowledgementV1;
+export interface IPalletNodeEnrollmentActivation {
+  enrollment: INodeEnrollment;
+  acknowledgement: INodeEnrollmentAcknowledgement;
 }
 
-interface IPalletNodeEnrollmentConfirmationBaseV1 {
-  schemaVersion: 1;
+interface IPalletNodeEnrollmentConfirmationBase {
   purpose: 'pallet';
   enrollmentId: string;
   cloudlyOrigin: string;
@@ -92,23 +90,23 @@ interface IPalletNodeEnrollmentConfirmationBaseV1 {
 }
 
 /** The exact pending binding is durable now, not merely a historical receipt. */
-export interface IPalletNodeEnrollmentBoundV1 extends IPalletNodeEnrollmentConfirmationBaseV1 {
+export interface IPalletNodeEnrollmentBound extends IPalletNodeEnrollmentConfirmationBase {
   phase: 'bound';
   /** Null before Cloudly assigns a fresh Jump node; exact existing node for adoption. */
   nodeId: string | null;
 }
 
 /** Exact CURRENT local Pallet identity, not Spark activation or remote authorization. */
-export interface IPalletNodeEnrollmentActiveV1 extends IPalletNodeEnrollmentConfirmationBaseV1 {
+export interface IPalletNodeEnrollmentActive extends IPalletNodeEnrollmentConfirmationBase {
   phase: 'active';
   nodeId: string;
 }
 
-export type TPalletNodeEnrollmentConfirmationV1 =
-  | IPalletNodeEnrollmentBoundV1 | IPalletNodeEnrollmentActiveV1;
+export type TPalletNodeEnrollmentConfirmation =
+  | IPalletNodeEnrollmentBound | IPalletNodeEnrollmentActive;
 
 /** Wire bounds, not a listener, permission check, timeout implementation or storage API. */
-export const palletNodeEnrollmentV1Contract = Object.freeze({
+export const palletNodeEnrollmentContract = Object.freeze({
   socketPath: '/run/serve.zone/pallet/control.sock',
   frame: 'u32be-length-prefixed-utf8-json-then-write-half-close',
   requestsPerConnection: 1,
@@ -116,8 +114,8 @@ export const palletNodeEnrollmentV1Contract = Object.freeze({
   maxResponseBytes: 16384,
 } as const);
 
-export const nodeEnrollmentV1Contract = Object.freeze({
-  digestDomain: 'serve.zone/node-enrollment-v1',
+export const nodeEnrollmentContract = Object.freeze({
+  digestDomain: 'serve.zone/node-enrollment',
   localActivation: 'independently-durable-convergence',
   bootstrapProof: 'first-commit-only',
   pendingSparkProof: 'committed-exact-receipt-only',
@@ -128,31 +126,18 @@ function requireValue(valueArg: unknown): asserts valueArg {
   if (!valueArg) fail();
 }
 
-/** Decoded JSON/data records only. No input accessor is executed or preserved. */
+/** Exactly this shape's keys, read once as data; an accessor is refused, never invoked. */
 const record = (valueArg: unknown, keysArg: readonly string[]): Record<string, unknown> => {
-  requireValue(valueArg !== null && typeof valueArg === 'object' && !Array.isArray(valueArg));
-  const prototype = Object.getPrototypeOf(valueArg);
-  requireValue(prototype === Object.prototype || prototype === null);
-  const keys = Reflect.ownKeys(valueArg);
-  requireValue(keys.length === keysArg.length);
-  const snapshot: Record<string, unknown> = Object.create(null);
-  for (const key of keys) {
-    requireValue(typeof key === 'string' && keysArg.includes(key));
-    const descriptor = Object.getOwnPropertyDescriptor(valueArg, key);
-    requireValue(descriptor?.enumerable && Object.hasOwn(descriptor, 'value'));
-    snapshot[key] = descriptor.value;
-  }
+  const snapshot = readExactDataRecord(valueArg, keysArg);
+  requireValue(snapshot !== null);
   return snapshot;
 };
 
+/** The dense two-element credential tuple, read the same way as a record. */
 const pair = (valueArg: unknown): [unknown, unknown] => {
-  requireValue(Array.isArray(valueArg) && Object.getPrototypeOf(valueArg) === Array.prototype);
-  requireValue(Reflect.ownKeys(valueArg).length === 3 && valueArg.length === 2);
-  const first = Object.getOwnPropertyDescriptor(valueArg, '0');
-  const second = Object.getOwnPropertyDescriptor(valueArg, '1');
-  requireValue(first?.enumerable && Object.hasOwn(first, 'value'));
-  requireValue(second?.enumerable && Object.hasOwn(second, 'value'));
-  return [first.value, second.value];
+  const elements = readDataElements(valueArg, 2);
+  requireValue(elements !== null && elements.length === 2);
+  return [elements[0], elements[1]];
 };
 const id = (valueArg: unknown): string => {
   requireValue(typeof valueArg === 'string' && /^[A-Za-z0-9_-]{1,128}$/.test(valueArg));
@@ -184,7 +169,7 @@ const hostname = (valueArg: unknown): string => {
 
 const proposal = <TPurpose extends TNodeCredentialPurpose>(
   valueArg: unknown, purposeArg: TPurpose,
-): INodeEnrollmentCredentialProposalV1 & { purpose: TPurpose } => {
+): INodeEnrollmentCredentialProposal & { purpose: TPurpose } => {
   const value = record(valueArg, ['purpose', 'installationId', 'mutationId', 'tokenHash',
     'expectedGeneration', 'expectedSessionEpoch']);
   requireValue(value.purpose === purposeArg);
@@ -194,22 +179,20 @@ const proposal = <TPurpose extends TNodeCredentialPurpose>(
 };
 
 const distinctOwners = (
-  sparkArg: INodeEnrollmentCredentialAcknowledgementV1 | INodeEnrollmentCredentialProposalV1,
-  palletArg: INodeEnrollmentCredentialAcknowledgementV1 | INodeEnrollmentCredentialProposalV1,
+  sparkArg: INodeEnrollmentCredentialAcknowledgement | INodeEnrollmentCredentialProposal,
+  palletArg: INodeEnrollmentCredentialAcknowledgement | INodeEnrollmentCredentialProposal,
 ): void => {
   requireValue(sparkArg.installationId !== palletArg.installationId
     && sparkArg.mutationId !== palletArg.mutationId && sparkArg.tokenHash !== palletArg.tokenHash);
 };
 
 /** Detached frozen snapshot, captured synchronously before hashing or other awaits. */
-export const snapshotNodeEnrollmentV1 = (valueArg: unknown): INodeEnrollmentV1 => {
-  const value = record(valueArg, ['schemaVersion', 'enrollmentId', 'cloudlyOrigin', 'hostname',
+export const snapshotNodeEnrollment = (valueArg: unknown): INodeEnrollment => {
+  const value = record(valueArg, ['enrollmentId', 'cloudlyOrigin', 'hostname',
     'bootstrap', 'credentials']);
-  requireValue(value.schemaVersion === 1);
-  // Read the discriminant from its data descriptor, never an input getter.
-  requireValue(value.bootstrap !== null && typeof value.bootstrap === 'object');
-  const kind = Object.getOwnPropertyDescriptor(value.bootstrap, 'kind');
-  requireValue(kind && Object.hasOwn(kind, 'value'));
+  // Read the discriminant as data, never through an input getter.
+  const kind = readDataProperty(value.bootstrap, 'kind');
+  requireValue(kind !== null);
   const bootstrap = record(value.bootstrap, kind.value === 'jump'
     ? ['kind', 'proofHash'] : ['kind', 'nodeId', 'proofHash']);
   requireValue(bootstrap.kind === 'jump' || bootstrap.kind === 'adopt-existing');
@@ -221,7 +204,7 @@ export const snapshotNodeEnrollmentV1 = (valueArg: unknown): INodeEnrollmentV1 =
   requireValue(bootstrap.kind === 'jump'
     ? spark.expectedGeneration === 0 && spark.expectedSessionEpoch === 0
     : spark.expectedGeneration > 0);
-  return deepFreezeValue({ schemaVersion: 1, enrollmentId: hash(value.enrollmentId),
+  return deepFreezeValue({ enrollmentId: hash(value.enrollmentId),
     cloudlyOrigin: origin(value.cloudlyOrigin), hostname: hostname(value.hostname),
     bootstrap: bootstrap.kind === 'jump'
       ? { kind: 'jump', proofHash: hash(bootstrap.proofHash) }
@@ -229,16 +212,16 @@ export const snapshotNodeEnrollmentV1 = (valueArg: unknown): INodeEnrollmentV1 =
     credentials: [spark, pallet] });
 };
 
-export const computeNodeEnrollmentV1Digest = async (valueArg: INodeEnrollmentV1): Promise<string> => {
-  const payload = snapshotNodeEnrollmentV1(valueArg);
+export const computeNodeEnrollmentDigest = async (valueArg: INodeEnrollment): Promise<string> => {
+  const payload = snapshotNodeEnrollment(valueArg);
   return createCanonicalJsonSha256Hex(canonicalizeStrictJson({
-    domain: nodeEnrollmentV1Contract.digestDomain, payload,
+    domain: nodeEnrollmentContract.digestDomain, payload,
   }, fail), fail);
 };
 
-export const snapshotNodeEnrollmentRequestV1 = (valueArg: unknown): INodeEnrollmentRequestV1 => {
+export const snapshotNodeEnrollmentRequest = (valueArg: unknown): INodeEnrollmentRequest => {
   const value = record(valueArg, ['enrollment', 'proof']);
-  const enrollment = snapshotNodeEnrollmentV1(value.enrollment);
+  const enrollment = snapshotNodeEnrollment(value.enrollment);
   const proof = record(value.proof, ['kind', 'bearer']);
   requireValue(proof.kind === 'bootstrap' || proof.kind === 'pending-spark');
   requireValue(typeof proof.bearer === 'string');
@@ -252,11 +235,11 @@ export const snapshotNodeEnrollmentRequestV1 = (valueArg: unknown): INodeEnrollm
  * receiptState from its owned transaction, compare the complete stored proposal,
  * and fence current Jump/Spark/Pallet authority before any commit or replay.
  */
-export const verifyNodeEnrollmentProofV1 = async (
-  valueArg: INodeEnrollmentRequestV1, receiptStateArg: 'absent' | 'committed',
+export const verifyNodeEnrollmentProof = async (
+  valueArg: INodeEnrollmentRequest, receiptStateArg: 'absent' | 'committed',
 ): Promise<boolean> => {
   try {
-    const { enrollment, proof } = snapshotNodeEnrollmentRequestV1(valueArg);
+    const { enrollment, proof } = snapshotNodeEnrollmentRequest(valueArg);
     if (!(proof.kind === 'bootstrap' && receiptStateArg === 'absent')
       && !(proof.kind === 'pending-spark' && receiptStateArg === 'committed')) return false;
     // This helper hashes exact UTF-8 text; no JSON quoting or normalization.
@@ -268,35 +251,34 @@ export const verifyNodeEnrollmentProofV1 = async (
 
 const credentialAcknowledgement = <TPurpose extends TNodeCredentialPurpose>(
   valueArg: unknown, purposeArg: TPurpose,
-): INodeEnrollmentCredentialAcknowledgementV1 & { purpose: TPurpose } => {
+): INodeEnrollmentCredentialAcknowledgement & { purpose: TPurpose } => {
   const value = record(valueArg, ['purpose', 'installationId', 'mutationId', 'tokenHash', 'generation']);
   requireValue(value.purpose === purposeArg);
   return { purpose: purposeArg, installationId: id(value.installationId), mutationId: id(value.mutationId),
     tokenHash: hash(value.tokenHash), generation: counter(value.generation, 1) };
 };
 
-export const snapshotNodeEnrollmentAcknowledgementV1 = (
+export const snapshotNodeEnrollmentAcknowledgement = (
   valueArg: unknown,
-): INodeEnrollmentAcknowledgementV1 => {
-  const value = record(valueArg, ['schemaVersion', 'enrollmentId', 'cloudlyOrigin', 'nodeId',
+): INodeEnrollmentAcknowledgement => {
+  const value = record(valueArg, ['enrollmentId', 'cloudlyOrigin', 'nodeId',
     'requestDigest', 'credentials']);
-  requireValue(value.schemaVersion === 1);
   const [sparkInput, palletInput] = pair(value.credentials);
   const spark = credentialAcknowledgement(sparkInput, 'spark');
   const pallet = credentialAcknowledgement(palletInput, 'pallet');
   distinctOwners(spark, pallet);
   requireValue(pallet.generation === 1);
-  return deepFreezeValue({ schemaVersion: 1, enrollmentId: hash(value.enrollmentId),
+  return deepFreezeValue({ enrollmentId: hash(value.enrollmentId),
     cloudlyOrigin: origin(value.cloudlyOrigin), nodeId: id(value.nodeId),
     requestDigest: hash(value.requestDigest), credentials: [spark, pallet] });
 };
 
 /** Content binding only. Authenticate Cloudly first; persist only the returned snapshot. */
-export const bindNodeEnrollmentAcknowledgementV1 = async (
-  enrollmentArg: INodeEnrollmentV1, acknowledgementArg: INodeEnrollmentAcknowledgementV1,
-): Promise<INodeEnrollmentAcknowledgementV1> => {
-  const enrollment = snapshotNodeEnrollmentV1(enrollmentArg);
-  const ack = snapshotNodeEnrollmentAcknowledgementV1(acknowledgementArg);
+export const bindNodeEnrollmentAcknowledgement = async (
+  enrollmentArg: INodeEnrollment, acknowledgementArg: INodeEnrollmentAcknowledgement,
+): Promise<INodeEnrollmentAcknowledgement> => {
+  const enrollment = snapshotNodeEnrollment(enrollmentArg);
+  const ack = snapshotNodeEnrollmentAcknowledgement(acknowledgementArg);
   requireValue(ack.enrollmentId === enrollment.enrollmentId && ack.cloudlyOrigin === enrollment.cloudlyOrigin
     && (enrollment.bootstrap.kind === 'jump' || ack.nodeId === enrollment.bootstrap.nodeId));
   for (const index of [0, 1] as const) {
@@ -306,35 +288,35 @@ export const bindNodeEnrollmentAcknowledgementV1 = async (
       && actual.mutationId === expected.mutationId && actual.tokenHash === expected.tokenHash
       && actual.generation === expected.expectedGeneration + 1);
   }
-  requireValue(ack.requestDigest === await computeNodeEnrollmentV1Digest(enrollment));
+  requireValue(ack.requestDigest === await computeNodeEnrollmentDigest(enrollment));
   return ack;
 };
 
-export const snapshotNodeEnrollmentStateV1 = (valueArg: unknown): INodeEnrollmentStateV1 => {
-  const value = record(valueArg, ['schemaVersion', 'nodeId', 'spark', 'pallet']);
-  requireValue(value.schemaVersion === 1 && value.pallet === 'absent');
+export const snapshotNodeEnrollmentState = (valueArg: unknown): INodeEnrollmentState => {
+  const value = record(valueArg, ['nodeId', 'spark', 'pallet']);
+  requireValue(value.pallet === 'absent');
   const spark = record(value.spark, ['generation', 'sessionEpoch']);
-  return deepFreezeValue({ schemaVersion: 1, nodeId: id(value.nodeId), pallet: 'absent',
+  return deepFreezeValue({ nodeId: id(value.nodeId), pallet: 'absent',
     spark: { generation: counter(spark.generation, 1, true), sessionEpoch: counter(spark.sessionEpoch, 0, true) } });
 };
 
 /** Decoded JSON/data records only, captured synchronously; never invokes getters. */
-export const snapshotPalletNodeEnrollmentPreparationV1 = (
+export const snapshotPalletNodeEnrollmentPreparation = (
   valueArg: unknown,
-): IPalletNodeEnrollmentPreparationV1 => {
-  const value = record(valueArg, ['schemaVersion', 'purpose', 'installationId', 'mutationId',
+): IPalletNodeEnrollmentPreparation => {
+  const value = record(valueArg, ['purpose', 'installationId', 'mutationId',
     'cloudlyOrigin', 'nodeId']);
-  requireValue(value.schemaVersion === 1 && value.purpose === 'pallet');
-  return deepFreezeValue({ schemaVersion: 1, purpose: 'pallet',
+  requireValue(value.purpose === 'pallet');
+  return deepFreezeValue({ purpose: 'pallet',
     installationId: id(value.installationId), mutationId: id(value.mutationId),
     cloudlyOrigin: origin(value.cloudlyOrigin), nodeId: value.nodeId === null ? null : id(value.nodeId) });
 };
 
 /** Content binding only. Authenticate the local Pallet transport before trusting this proposal. */
-export const bindPalletNodeEnrollmentPreparationV1 = (
-  preparationArg: IPalletNodeEnrollmentPreparationV1, proposalArg: unknown,
-): INodeEnrollmentV1['credentials'][1] => {
-  const preparation = snapshotPalletNodeEnrollmentPreparationV1(preparationArg);
+export const bindPalletNodeEnrollmentPreparation = (
+  preparationArg: IPalletNodeEnrollmentPreparation, proposalArg: unknown,
+): INodeEnrollment['credentials'][1] => {
+  const preparation = snapshotPalletNodeEnrollmentPreparation(preparationArg);
   const result = proposal(proposalArg, 'pallet');
   requireValue(result.installationId === preparation.installationId
     && result.mutationId === preparation.mutationId
@@ -343,22 +325,22 @@ export const bindPalletNodeEnrollmentPreparationV1 = (
 };
 
 /** Capture the exact wrapper and both nested values before any asynchronous content binding. */
-export const snapshotPalletNodeEnrollmentActivationV1 = (
+export const snapshotPalletNodeEnrollmentActivation = (
   valueArg: unknown,
-): IPalletNodeEnrollmentActivationV1 => {
+): IPalletNodeEnrollmentActivation => {
   const value = record(valueArg, ['enrollment', 'acknowledgement']);
-  return deepFreezeValue({ enrollment: snapshotNodeEnrollmentV1(value.enrollment),
-    acknowledgement: snapshotNodeEnrollmentAcknowledgementV1(value.acknowledgement) });
+  return deepFreezeValue({ enrollment: snapshotNodeEnrollment(value.enrollment),
+    acknowledgement: snapshotNodeEnrollmentAcknowledgement(value.acknowledgement) });
 };
 
-export const snapshotPalletNodeEnrollmentConfirmationV1 = (
+export const snapshotPalletNodeEnrollmentConfirmation = (
   valueArg: unknown,
-): TPalletNodeEnrollmentConfirmationV1 => {
-  const value = record(valueArg, ['schemaVersion', 'purpose', 'enrollmentId', 'cloudlyOrigin',
+): TPalletNodeEnrollmentConfirmation => {
+  const value = record(valueArg, ['purpose', 'enrollmentId', 'cloudlyOrigin',
     'requestDigest', 'phase', 'nodeId']);
-  requireValue(value.schemaVersion === 1 && value.purpose === 'pallet'
+  requireValue(value.purpose === 'pallet'
     && (value.phase === 'bound' || value.phase === 'active'));
-  const common = { schemaVersion: 1 as const, purpose: 'pallet' as const,
+  const common = { purpose: 'pallet' as const,
     enrollmentId: hash(value.enrollmentId), cloudlyOrigin: origin(value.cloudlyOrigin),
     requestDigest: hash(value.requestDigest) };
   return deepFreezeValue(value.phase === 'bound'
@@ -367,15 +349,15 @@ export const snapshotPalletNodeEnrollmentConfirmationV1 = (
 };
 
 /** Pure binding only. Pallet must prove its durable pending binding before issuing this response. */
-export const bindPalletNodeEnrollmentBoundV1 = async (
-  enrollmentArg: INodeEnrollmentV1, confirmationArg: IPalletNodeEnrollmentBoundV1,
-): Promise<IPalletNodeEnrollmentBoundV1> => {
-  const enrollment = snapshotNodeEnrollmentV1(enrollmentArg);
-  const confirmation = snapshotPalletNodeEnrollmentConfirmationV1(confirmationArg);
+export const bindPalletNodeEnrollmentBound = async (
+  enrollmentArg: INodeEnrollment, confirmationArg: IPalletNodeEnrollmentBound,
+): Promise<IPalletNodeEnrollmentBound> => {
+  const enrollment = snapshotNodeEnrollment(enrollmentArg);
+  const confirmation = snapshotPalletNodeEnrollmentConfirmation(confirmationArg);
   requireValue(confirmation.phase === 'bound' && confirmation.enrollmentId === enrollment.enrollmentId
     && confirmation.cloudlyOrigin === enrollment.cloudlyOrigin
     && confirmation.nodeId === (enrollment.bootstrap.kind === 'jump' ? null : enrollment.bootstrap.nodeId));
-  requireValue(confirmation.requestDigest === await computeNodeEnrollmentV1Digest(enrollment));
+  requireValue(confirmation.requestDigest === await computeNodeEnrollmentDigest(enrollment));
   return confirmation;
 };
 
@@ -384,15 +366,15 @@ export const bindPalletNodeEnrollmentBoundV1 = async (
  * Pallet owner must first prove its exact CURRENT local identity, not just a receipt.
  * This does not assert Spark activation, current Cloudly authority or workload readiness.
  */
-export const bindPalletNodeEnrollmentActiveV1 = async (
-  activationArg: IPalletNodeEnrollmentActivationV1,
-  confirmationArg: IPalletNodeEnrollmentActiveV1,
-): Promise<IPalletNodeEnrollmentActiveV1> => {
+export const bindPalletNodeEnrollmentActive = async (
+  activationArg: IPalletNodeEnrollmentActivation,
+  confirmationArg: IPalletNodeEnrollmentActive,
+): Promise<IPalletNodeEnrollmentActive> => {
   // Capture every caller-owned value before the asynchronous shared acknowledgement binder.
-  const { enrollment, acknowledgement } = snapshotPalletNodeEnrollmentActivationV1(activationArg);
-  const confirmation = snapshotPalletNodeEnrollmentConfirmationV1(confirmationArg);
+  const { enrollment, acknowledgement } = snapshotPalletNodeEnrollmentActivation(activationArg);
+  const confirmation = snapshotPalletNodeEnrollmentConfirmation(confirmationArg);
   requireValue(confirmation.phase === 'active');
-  const ack = await bindNodeEnrollmentAcknowledgementV1(enrollment, acknowledgement);
+  const ack = await bindNodeEnrollmentAcknowledgement(enrollment, acknowledgement);
   requireValue(confirmation.enrollmentId === ack.enrollmentId && confirmation.cloudlyOrigin === ack.cloudlyOrigin
     && confirmation.nodeId === ack.nodeId && confirmation.requestDigest === ack.requestDigest);
   return confirmation;