@serve.zone/interfaces 27.5.0 → 28.1.0

package/changelog.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## 2026-09-06 - 28.1.0
+
+### Features
+
+- add independent node enrollment contracts (node-enrollment)
+  - Export node enrollment data interfaces and helpers for strict snapshots, canonical digests, proof verification, acknowledgement binding, and state snapshots.
+  - Add node TypedRequest contracts for enrollment state checks and node enrollment transactions.
+  - Document node enrollment semantics and add tests for digest binding, proof validation, acknowledgement validation, and TypedRequest ownership.
+
+### Fixes
+
+- use qualified pnpm 11.25.0 for exact release packaging (package)
+  - Select the GitZone-qualified version permitted by the existing release-age policy.
+  - Remove the inactive pnpm 12 bootstrap lock document without changing application dependencies.
+- clarify pnpm release packaging changelog entry (changelog)
+  - Consolidates duplicate pnpm pinning notes into a single package fix entry.
+  - Documents qualified pnpm 11.25.0 selection for release packaging.
+
+## 2026-09-05 - 28.0.0
+
+### Breaking Changes
+
+- require identity for node config and add credential administration contracts (node-credentials)
+  - Add node credential metadata, mutation precondition, and mutation result interfaces for spark and pallet purposes.
+  - Add getNodeCredential, rotateNodeCredential, and revokeNodeCredential typed request contracts with infrastructure-admin identity requirements.
+  - Require identity on getNodeConfig requests, changing the existing request shape.
+  - Document node credential administration semantics and add type-level contract tests.
+
 ## 2026-09-05 - 27.5.0
 
 ### Features

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@serve.zone/interfaces',
-    version: '27.5.0',
+    version: '28.1.0',
     description: 'Shared TypeScript interfaces and TypedRequest contracts for the serve.zone ecosystem.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLHVGQUF1RjtDQUNyRyxDQUFBIn0=

package/dist_ts/data/index.d.ts

@@ -20,6 +20,8 @@ export * from './immutableimage.js';
 export * from './isolatedrestore.js';
 export * from './isolatedrestore.golden.js';
 export * from './mail.js';
+export * from './nodecredential.js';
+export * from './nodeenrollment.js';
 export * from './registry.js';
 export * from './runtimeassignment.js';
 export * from './secret.js';

package/dist_ts/data/index.js

@@ -20,6 +20,8 @@ export * from './immutableimage.js';
 export * from './isolatedrestore.js';
 export * from './isolatedrestore.golden.js';
 export * from './mail.js';
+export * from './nodecredential.js';
+export * from './nodeenrollment.js';
 export * from './registry.js';
 export * from './runtimeassignment.js';
 export * from './secret.js';
@@ -36,4 +38,4 @@ export * from './traffic.js';
 export * from './user.js';
 export * from './version.js';
 export * from './webpush.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9kYXRhL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLFdBQVcsQ0FBQztBQUMxQixjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGNBQWMsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9kYXRhL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxjQUFjLENBQUMifQ==

package/dist_ts/data/nodecredential.d.ts

@@ -0,0 +1,38 @@
+/** Independent infrastructure credentials; neither purpose grants workload RBAC. */
+export type TNodeCredentialPurpose = 'spark' | 'pallet';
+/**
+ * Public inspection and mutation-result metadata. Never includes bearer material,
+ * hashes, socket peer IDs or controller process IDs. On replay this is historical
+ * evidence, not an assertion that a credential or reporter session is still live.
+ */
+export interface INodeCredentialMetadataV1 {
+    schemaVersion: 1;
+    nodeId: string;
+    purpose: TNodeCredentialPurpose;
+    state: 'active' | 'revoked';
+    generation: number;
+    /** Migrated Spark credentials remain usable only until their staged rotation. */
+    requiresRotation: boolean;
+    sessionEpoch: number;
+    sessionId: string | null;
+    createdAt: number;
+    updatedAt: number;
+}
+/**
+ * Infrastructure-admin mutation preconditions. Both counters are exact CAS
+ * preconditions, not minimums. Retrying must retain this complete input and the
+ * original mutationId; a changed request with the same ID must fail closed.
+ */
+export interface INodeCredentialMutationPreconditionsV1 {
+    schemaVersion: 1;
+    nodeId: string;
+    purpose: TNodeCredentialPurpose;
+    mutationId: string;
+    expectedGeneration: number;
+    expectedSessionEpoch: number;
+}
+export interface INodeCredentialMutationResultV1 {
+    metadata: INodeCredentialMetadataV1;
+    /** A replay returns the original result without restoring its authority. */
+    replayed: boolean;
+}

package/dist_ts/data/nodecredential.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZWNyZWRlbnRpYWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9kYXRhL25vZGVjcmVkZW50aWFsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dist_ts/data/nodeenrollment.d.ts

@@ -0,0 +1,95 @@
+import type { TNodeCredentialPurpose } from './nodecredential.js';
+export interface INodeEnrollmentCredentialProposalV1 {
+    purpose: TNodeCredentialPurpose;
+    installationId: string;
+    mutationId: string;
+    /** SHA-256 of the independently generated, durably prepared bearer UTF-8 bytes. */
+    tokenHash: string;
+    expectedGeneration: number;
+    expectedSessionEpoch: number;
+}
+/** Value-free, immutable proposal. Hashes are still sensitive transport fields. */
+export interface INodeEnrollmentV1 {
+    schemaVersion: 1;
+    /** 32 CSPRNG bytes encoded as lowercase hexadecimal; retain across every retry. */
+    enrollmentId: string;
+    cloudlyOrigin: string;
+    hostname: string;
+    bootstrap: {
+        kind: 'jump';
+        proofHash: string;
+    } | {
+        kind: 'adopt-existing';
+        nodeId: string;
+        proofHash: string;
+    };
+    credentials: [
+        INodeEnrollmentCredentialProposalV1 & {
+            purpose: 'spark';
+        },
+        INodeEnrollmentCredentialProposalV1 & {
+            purpose: 'pallet';
+        }
+    ];
+}
+export interface INodeEnrollmentRequestV1 {
+    enrollment: INodeEnrollmentV1;
+    /** Never persist on the server, log, put in URLs, or expose in transport hooks. */
+    proof: {
+        kind: 'bootstrap' | 'pending-spark';
+        bearer: string;
+    };
+}
+export interface INodeEnrollmentCredentialAcknowledgementV1 {
+    purpose: TNodeCredentialPurpose;
+    installationId: string;
+    mutationId: string;
+    tokenHash: string;
+    generation: number;
+}
+/** Immutable commit evidence, not authorization or workload readiness. */
+export interface INodeEnrollmentAcknowledgementV1 {
+    schemaVersion: 1;
+    enrollmentId: string;
+    cloudlyOrigin: string;
+    nodeId: string;
+    requestDigest: string;
+    credentials: [
+        INodeEnrollmentCredentialAcknowledgementV1 & {
+            purpose: 'spark';
+        },
+        INodeEnrollmentCredentialAcknowledgementV1 & {
+            purpose: 'pallet';
+        }
+    ];
+}
+/** Returned only after current Spark authentication and proof that Pallet is absent. */
+export interface INodeEnrollmentStateV1 {
+    schemaVersion: 1;
+    nodeId: string;
+    spark: {
+        generation: number;
+        sessionEpoch: number;
+    };
+    pallet: 'absent';
+}
+export declare const nodeEnrollmentV1Contract: Readonly<{
+    readonly digestDomain: "serve.zone/node-enrollment-v1";
+    readonly localActivation: "independently-durable-convergence";
+    readonly bootstrapProof: "first-commit-only";
+    readonly pendingSparkProof: "committed-exact-receipt-only";
+}>;
+/** Detached frozen snapshot, captured synchronously before hashing or other awaits. */
+export declare const snapshotNodeEnrollmentV1: (valueArg: unknown) => INodeEnrollmentV1;
+export declare const computeNodeEnrollmentV1Digest: (valueArg: INodeEnrollmentV1) => Promise<string>;
+export declare const snapshotNodeEnrollmentRequestV1: (valueArg: unknown) => INodeEnrollmentRequestV1;
+/**
+ * Pure proof binding/mode check only, NOT authentication. The server must derive
+ * receiptState from its owned transaction, compare the complete stored proposal,
+ * and fence current Jump/Spark/Pallet authority before any commit or replay.
+ */
+export declare const verifyNodeEnrollmentProofV1: (valueArg: INodeEnrollmentRequestV1, receiptStateArg: "absent" | "committed") => Promise<boolean>;
+export declare const snapshotNodeEnrollmentAcknowledgementV1: (valueArg: unknown) => INodeEnrollmentAcknowledgementV1;
+/** Content binding only. Authenticate Cloudly first; persist only the returned snapshot. */
+export declare const bindNodeEnrollmentAcknowledgementV1: (enrollmentArg: INodeEnrollmentV1, acknowledgementArg: INodeEnrollmentAcknowledgementV1) => Promise<INodeEnrollmentAcknowledgementV1>;
+export declare const snapshotNodeEnrollmentStateV1: (valueArg: unknown) => INodeEnrollmentStateV1;

package/dist_ts/data/nodeenrollment.js

@@ -0,0 +1,186 @@
+import { canonicalizeStrictJson, createCanonicalJsonSha256Hex, createSha256Hex, deepFreezeValue, } from '../private/canonicaljson.js';
+export const nodeEnrollmentV1Contract = Object.freeze({
+    digestDomain: 'serve.zone/node-enrollment-v1',
+    localActivation: 'independently-durable-convergence',
+    bootstrapProof: 'first-commit-only',
+    pendingSparkProof: 'committed-exact-receipt-only',
+});
+const fail = () => { throw new Error('Node enrollment contract rejected.'); };
+function requireValue(valueArg) {
+    if (!valueArg)
+        fail();
+}
+/** Decoded JSON/data records only. No input accessor is executed or preserved. */
+const record = (valueArg, keysArg) => {
+    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 = 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;
+    }
+    return snapshot;
+};
+const pair = (valueArg) => {
+    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 id = (valueArg) => {
+    requireValue(typeof valueArg === 'string' && /^[A-Za-z0-9_-]{1,128}$/.test(valueArg));
+    return valueArg;
+};
+const hash = (valueArg) => {
+    requireValue(typeof valueArg === 'string' && /^[a-f0-9]{64}$/.test(valueArg));
+    return valueArg;
+};
+const counter = (valueArg, minimumArg = 0, incrementArg = false) => {
+    requireValue(typeof valueArg === 'number' && Number.isSafeInteger(valueArg)
+        && !Object.is(valueArg, -0) && valueArg >= minimumArg
+        && (!incrementArg || valueArg < Number.MAX_SAFE_INTEGER));
+    return valueArg;
+};
+const origin = (valueArg) => {
+    requireValue(typeof valueArg === 'string' && valueArg.length <= 2048);
+    let url;
+    try {
+        url = new URL(valueArg);
+    }
+    catch {
+        return fail();
+    }
+    requireValue(url.protocol === 'https:' && !url.username && !url.password && url.origin === valueArg);
+    return valueArg;
+};
+const hostname = (valueArg) => {
+    requireValue(typeof valueArg === 'string' && valueArg.length <= 253 && valueArg.length > 0);
+    requireValue(valueArg.split('.').every((labelArg) => /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/.test(labelArg)));
+    return valueArg;
+};
+const proposal = (valueArg, purposeArg) => {
+    const value = record(valueArg, ['purpose', 'installationId', 'mutationId', 'tokenHash',
+        'expectedGeneration', 'expectedSessionEpoch']);
+    requireValue(value.purpose === purposeArg);
+    return { purpose: purposeArg, installationId: id(value.installationId), mutationId: id(value.mutationId),
+        tokenHash: hash(value.tokenHash), expectedGeneration: counter(value.expectedGeneration, 0, true),
+        expectedSessionEpoch: counter(value.expectedSessionEpoch, 0, true) };
+};
+const distinctOwners = (sparkArg, palletArg) => {
+    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) => {
+    const value = record(valueArg, ['schemaVersion', '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'));
+    const bootstrap = record(value.bootstrap, kind.value === 'jump'
+        ? ['kind', 'proofHash'] : ['kind', 'nodeId', 'proofHash']);
+    requireValue(bootstrap.kind === 'jump' || bootstrap.kind === 'adopt-existing');
+    const [sparkInput, palletInput] = pair(value.credentials);
+    const spark = proposal(sparkInput, 'spark');
+    const pallet = proposal(palletInput, 'pallet');
+    distinctOwners(spark, pallet);
+    requireValue(pallet.expectedGeneration === 0 && pallet.expectedSessionEpoch === 0);
+    requireValue(bootstrap.kind === 'jump'
+        ? spark.expectedGeneration === 0 && spark.expectedSessionEpoch === 0
+        : spark.expectedGeneration > 0);
+    return deepFreezeValue({ schemaVersion: 1, enrollmentId: hash(value.enrollmentId),
+        cloudlyOrigin: origin(value.cloudlyOrigin), hostname: hostname(value.hostname),
+        bootstrap: bootstrap.kind === 'jump'
+            ? { kind: 'jump', proofHash: hash(bootstrap.proofHash) }
+            : { kind: 'adopt-existing', nodeId: id(bootstrap.nodeId), proofHash: hash(bootstrap.proofHash) },
+        credentials: [spark, pallet] });
+};
+export const computeNodeEnrollmentV1Digest = async (valueArg) => {
+    const payload = snapshotNodeEnrollmentV1(valueArg);
+    return createCanonicalJsonSha256Hex(canonicalizeStrictJson({
+        domain: nodeEnrollmentV1Contract.digestDomain, payload,
+    }, fail), fail);
+};
+export const snapshotNodeEnrollmentRequestV1 = (valueArg) => {
+    const value = record(valueArg, ['enrollment', 'proof']);
+    const enrollment = snapshotNodeEnrollmentV1(value.enrollment);
+    const proof = record(value.proof, ['kind', 'bearer']);
+    requireValue(proof.kind === 'bootstrap' || proof.kind === 'pending-spark');
+    requireValue(typeof proof.bearer === 'string');
+    requireValue(proof.kind === 'bootstrap' && enrollment.bootstrap.kind === 'jump'
+        ? /^[A-Za-z0-9_-]{16}$/.test(proof.bearer) : /^secureToken[a-f0-9]{64}$/.test(proof.bearer));
+    return deepFreezeValue({ enrollment, proof: { kind: proof.kind, bearer: proof.bearer } });
+};
+/**
+ * Pure proof binding/mode check only, NOT authentication. The server must derive
+ * 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, receiptStateArg) => {
+    try {
+        const { enrollment, proof } = snapshotNodeEnrollmentRequestV1(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.
+        const actual = await createSha256Hex(new TextEncoder().encode(proof.bearer), fail);
+        return actual === (proof.kind === 'bootstrap'
+            ? enrollment.bootstrap.proofHash : enrollment.credentials[0].tokenHash);
+    }
+    catch {
+        return false;
+    }
+};
+const credentialAcknowledgement = (valueArg, purposeArg) => {
+    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 = (valueArg) => {
+    const value = record(valueArg, ['schemaVersion', '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),
+        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, acknowledgementArg) => {
+    const enrollment = snapshotNodeEnrollmentV1(enrollmentArg);
+    const ack = snapshotNodeEnrollmentAcknowledgementV1(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]) {
+        const expected = enrollment.credentials[index];
+        const actual = ack.credentials[index];
+        requireValue(actual.purpose === expected.purpose && actual.installationId === expected.installationId
+            && actual.mutationId === expected.mutationId && actual.tokenHash === expected.tokenHash
+            && actual.generation === expected.expectedGeneration + 1);
+    }
+    requireValue(ack.requestDigest === await computeNodeEnrollmentV1Digest(enrollment));
+    return ack;
+};
+export const snapshotNodeEnrollmentStateV1 = (valueArg) => {
+    const value = record(valueArg, ['schemaVersion', 'nodeId', 'spark', 'pallet']);
+    requireValue(value.schemaVersion === 1 && value.pallet === 'absent');
+    const spark = record(value.spark, ['generation', 'sessionEpoch']);
+    return deepFreezeValue({ schemaVersion: 1, nodeId: id(value.nodeId), pallet: 'absent',
+        spark: { generation: counter(spark.generation, 1, true), sessionEpoch: counter(spark.sessionEpoch, 0, true) } });
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nodeenrollment.js","sourceRoot":"","sources":["../../ts/data/nodeenrollment.ts"],"names":[],"mappings":"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"}

package/dist_ts/requests/node.d.ts

@@ -4,15 +4,72 @@ import type { ICluster } from '../data/cluster.js';
 import type { IClusterNode, IClusterNodeMetrics, INodeAction, INodeMetricsSample, ISparkNodeRuntimeInfo, TNodeActionName } from '../data/clusternode.js';
 import type { IDeployment } from '../data/deployment.js';
 import type { IIdentity } from '../data/user.js';
-export interface IRequest_Any_Cloudly_GetNodeConfig {
+import type { INodeCredentialMetadataV1, INodeCredentialMutationPreconditionsV1, INodeCredentialMutationResultV1, TNodeCredentialPurpose } from '../data/nodecredential.js';
+import type { INodeEnrollmentRequestV1, INodeEnrollmentAcknowledgementV1, INodeEnrollmentStateV1 } from '../data/nodeenrollment.js';
+/** Node-self adoption preconditions, not an admin or workload RBAC grant. */
+export interface IReq_Spark_Cloudly_GetNodeEnrollmentStateV1 extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_Spark_Cloudly_GetNodeEnrollmentStateV1> {
+    method: 'getNodeEnrollmentStateV1';
+    request: {
+        nodeId: string;
+        nodeToken: string;
+    };
+    /** Reject unless Spark is currently authenticated and Pallet authority is absent. */
+    response: INodeEnrollmentStateV1;
+}
+/** One server transaction; each node-local owner durably activates independently. */
+export interface IReq_Spark_Cloudly_EnrollNodeV1 extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_Spark_Cloudly_EnrollNodeV1> {
+    method: 'enrollNodeV1';
+    request: INodeEnrollmentRequestV1;
+    /** Replays require the exact receipt AND both current credential authorities. */
+    response: INodeEnrollmentAcknowledgementV1;
+}
+/** Requires verified platform-infrastructure admin authority; returns public data only. */
+export interface IRequest_Any_Cloudly_GetNodeConfig extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IRequest_Any_Cloudly_GetNodeConfig> {
     method: 'getNodeConfig';
     request: {
+        identity: IIdentity;
         nodeId: string;
     };
     response: {
         configData: IClusterNode;
     };
 }
+/** These credential methods require verified infrastructure-admin authority. */
+export interface IReq_Any_Cloudly_GetNodeCredential extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_Any_Cloudly_GetNodeCredential> {
+    method: 'getNodeCredential';
+    request: {
+        identity: IIdentity;
+        nodeId: string;
+        purpose: TNodeCredentialPurpose;
+    };
+    response: {
+        metadata: INodeCredentialMetadataV1 | null;
+    };
+}
+export interface IReq_Any_Cloudly_RotateNodeCredential extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_Any_Cloudly_RotateNodeCredential> {
+    method: 'rotateNodeCredential';
+    request: {
+        identity: IIdentity;
+        mutation: INodeCredentialMutationPreconditionsV1 & {
+            /**
+             * SHA-256(token UTF-8 bytes), exactly 64 lowercase hexadecimal characters.
+             * The node must durably retain its pending CSPRNG credential and mutation
+             * identity before this request. A metadata-only retry never issues plaintext.
+             * Treat this request field as sensitive; never include it in hooks or logs.
+             */
+            newTokenHash: string;
+        };
+    };
+    response: INodeCredentialMutationResultV1;
+}
+export interface IReq_Any_Cloudly_RevokeNodeCredential extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_Any_Cloudly_RevokeNodeCredential> {
+    method: 'revokeNodeCredential';
+    request: {
+        identity: IIdentity;
+        mutation: INodeCredentialMutationPreconditionsV1;
+    };
+    response: INodeCredentialMutationResultV1;
+}
 export interface IRequest_Any_Cloudly_GetNodesByCluster {
     method: 'getNodesByCluster';
     request: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serve.zone/interfaces",
-  "version": "27.5.0",
+  "version": "28.1.0",
   "private": false,
   "description": "Shared TypeScript interfaces and TypedRequest contracts for the serve.zone ecosystem.",
   "exports": {

package/readme.md

@@ -47,6 +47,65 @@ validator; unlike `@serve.zone/interfaces/runtime`, it does not load the general
 runtime graph, `plugins.js`, SmartCrypto, TypedRequest, Corestore, or settlement
 runtime modules.
 
+### Node Credential Administration
+
+`requests.node` defines `getNodeCredential`, `rotateNodeCredential` and
+`revokeNodeCredential` for verified platform-infrastructure administrators.
+`getNodeConfig` now also requires `identity`; callers using the previous
+unauthenticated request shape must update. Its response remains the public
+`IClusterNode`, never a persisted backend document.
+
+`data.INodeCredentialMetadataV1` separates `spark` and `pallet` purposes and
+exposes lifecycle state, generation, rotation-required status and session epoch,
+but no bearer, hash, socket peer or controller process identity. Infrastructure
+credentials do not grant organization or workload permissions.
+
+Mutations require the exact generation and session epoch plus a stable mutation
+ID. Rotation takes the SHA-256 hash of a node-generated CSPRNG credential that the
+node has already durably retained with that mutation ID. Lost-response retries
+repeat the complete request and receive the original metadata, never newly minted
+plaintext. A replay result is historical and cannot authorize a current session.
+Treat rotation request hashes as sensitive in transport hooks and logs.
+
+These types do not implement authentication, storage, enrollment or endpoints.
+Cloudly must verify current administrator authority, validate complete inputs,
+atomically persist the credential transition and immutable actor-bound receipt,
+and fence subsequent control effects against current durable credential/session
+authority. Node identity storage and transport integration must be qualified
+before enabling rotation or Pallet enrollment.
+
+### Independent Node Enrollment
+
+`requests.node` defines `getNodeEnrollmentStateV1` for current Spark-authenticated
+adoption preconditions and `enrollNodeV1` for atomic Spark/Pallet enrollment. These
+contracts do not implement endpoints, authentication, a database or a daemon.
+
+The enrollment proposal binds the canonical HTTPS Cloudly origin, hostname,
+enrollment identity, original bootstrap proof hash and an exact ordered pair of
+independently prepared Spark/Pallet credential hashes and CAS counters. Fresh Jump
+starts both at zero; existing-node adoption rotates current Spark and requires
+Pallet authority to be absent. `snapshotNodeEnrollmentV1` returns a detached,
+frozen snapshot; `computeNodeEnrollmentV1Digest` hashes domain-separated strict
+canonical JSON. Neither helper generates or persists credential material.
+
+Transport proof is excluded from the digest to permit exact lost-response
+recovery. Bootstrap proof must hash to the original proof hash and is allowed only
+before a receipt exists. Pending-Spark proof must hash to the prepared Spark hash
+and is allowed only for an existing exact receipt. `verifyNodeEnrollmentProofV1`
+checks this binding and mode only: Cloudly must derive receipt state itself and
+fence live bootstrap/credential authority in the same owned transaction. Current
+Jump codes are 12 random bytes encoded as 16 canonical base64url characters.
+
+`bindNodeEnrollmentAcknowledgementV1` checks the complete digest, both owners,
+exact next generations and unchanged adopted node ID, returning a detached frozen
+acknowledgement. Authenticate Cloudly before accepting it. The acknowledgement is
+immutable commit evidence, not ongoing authority or workload readiness. Server
+replay must still verify both active credential generations and hashes; reporter
+reconnect alone does not invalidate the credential. Spark and Pallet commit their
+local activation independently and converge after restart; there is no shared
+plaintext vault or cross-local-database ACID claim. Never log proof/request bodies
+or hashes, put them in URLs, or expose them through transport hooks.
+
 ### Node-Bound Runtime Assignments
 
 The `data` namespace exports `IRuntimeAssignmentV1`, canonical digest helpers,

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@serve.zone/interfaces',
-  version: '27.5.0',
+  version: '28.1.0',
   description: 'Shared TypeScript interfaces and TypedRequest contracts for the serve.zone ecosystem.'
 }

package/ts/data/index.ts

@@ -20,6 +20,8 @@ export * from './immutableimage.js';
 export * from './isolatedrestore.js';
 export * from './isolatedrestore.golden.js';
 export * from './mail.js';
+export * from './nodecredential.js';
+export * from './nodeenrollment.js';
 export * from './registry.js';
 export * from './runtimeassignment.js';
 export * from './secret.js';

package/ts/data/nodecredential.ts

@@ -0,0 +1,41 @@
+/** Independent infrastructure credentials; neither purpose grants workload RBAC. */
+export type TNodeCredentialPurpose = 'spark' | 'pallet';
+
+/**
+ * Public inspection and mutation-result metadata. Never includes bearer material,
+ * hashes, socket peer IDs or controller process IDs. On replay this is historical
+ * evidence, not an assertion that a credential or reporter session is still live.
+ */
+export interface INodeCredentialMetadataV1 {
+  schemaVersion: 1;
+  nodeId: string;
+  purpose: TNodeCredentialPurpose;
+  state: 'active' | 'revoked';
+  generation: number;
+  /** Migrated Spark credentials remain usable only until their staged rotation. */
+  requiresRotation: boolean;
+  sessionEpoch: number;
+  sessionId: string | null;
+  createdAt: number;
+  updatedAt: number;
+}
+
+/**
+ * Infrastructure-admin mutation preconditions. Both counters are exact CAS
+ * preconditions, not minimums. Retrying must retain this complete input and the
+ * original mutationId; a changed request with the same ID must fail closed.
+ */
+export interface INodeCredentialMutationPreconditionsV1 {
+  schemaVersion: 1;
+  nodeId: string;
+  purpose: TNodeCredentialPurpose;
+  mutationId: string;
+  expectedGeneration: number;
+  expectedSessionEpoch: number;
+}
+
+export interface INodeCredentialMutationResultV1 {
+  metadata: INodeCredentialMetadataV1;
+  /** A replay returns the original result without restoring its authority. */
+  replayed: boolean;
+}

package/ts/data/nodeenrollment.ts

@@ -0,0 +1,270 @@
+import type { TNodeCredentialPurpose } from './nodecredential.js';
+import {
+  canonicalizeStrictJson,
+  createCanonicalJsonSha256Hex,
+  createSha256Hex,
+  deepFreezeValue,
+} from '../private/canonicaljson.js';
+
+export interface INodeEnrollmentCredentialProposalV1 {
+  purpose: TNodeCredentialPurpose;
+  installationId: string;
+  mutationId: string;
+  /** SHA-256 of the independently generated, durably prepared bearer UTF-8 bytes. */
+  tokenHash: string;
+  expectedGeneration: number;
+  expectedSessionEpoch: number;
+}
+
+/** Value-free, immutable proposal. Hashes are still sensitive transport fields. */
+export interface INodeEnrollmentV1 {
+  schemaVersion: 1;
+  /** 32 CSPRNG bytes encoded as lowercase hexadecimal; retain across every retry. */
+  enrollmentId: string;
+  cloudlyOrigin: string;
+  hostname: string;
+  bootstrap:
+    | { kind: 'jump'; proofHash: string }
+    | { kind: 'adopt-existing'; nodeId: string; proofHash: string };
+  credentials: [
+    INodeEnrollmentCredentialProposalV1 & { purpose: 'spark' },
+    INodeEnrollmentCredentialProposalV1 & { purpose: 'pallet' },
+  ];
+}
+
+export interface INodeEnrollmentRequestV1 {
+  enrollment: INodeEnrollmentV1;
+  /** Never persist on the server, log, put in URLs, or expose in transport hooks. */
+  proof: { kind: 'bootstrap' | 'pending-spark'; bearer: string };
+}
+
+export interface INodeEnrollmentCredentialAcknowledgementV1 {
+  purpose: TNodeCredentialPurpose;
+  installationId: string;
+  mutationId: string;
+  tokenHash: string;
+  generation: number;
+}
+
+/** Immutable commit evidence, not authorization or workload readiness. */
+export interface INodeEnrollmentAcknowledgementV1 {
+  schemaVersion: 1;
+  enrollmentId: string;
+  cloudlyOrigin: string;
+  nodeId: string;
+  requestDigest: string;
+  credentials: [
+    INodeEnrollmentCredentialAcknowledgementV1 & { purpose: 'spark' },
+    INodeEnrollmentCredentialAcknowledgementV1 & { purpose: 'pallet' },
+  ];
+}
+
+/** Returned only after current Spark authentication and proof that Pallet is absent. */
+export interface INodeEnrollmentStateV1 {
+  schemaVersion: 1;
+  nodeId: string;
+  spark: { generation: number; sessionEpoch: number };
+  pallet: 'absent';
+}
+
+export const nodeEnrollmentV1Contract = Object.freeze({
+  digestDomain: 'serve.zone/node-enrollment-v1',
+  localActivation: 'independently-durable-convergence',
+  bootstrapProof: 'first-commit-only',
+  pendingSparkProof: 'committed-exact-receipt-only',
+} as const);
+
+const fail = (): never => { throw new Error('Node enrollment contract rejected.'); };
+function requireValue(valueArg: unknown): asserts valueArg {
+  if (!valueArg) fail();
+}
+
+/** Decoded JSON/data records only. No input accessor is executed or preserved. */
+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;
+  }
+  return snapshot;
+};
+
+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 id = (valueArg: unknown): string => {
+  requireValue(typeof valueArg === 'string' && /^[A-Za-z0-9_-]{1,128}$/.test(valueArg));
+  return valueArg;
+};
+const hash = (valueArg: unknown): string => {
+  requireValue(typeof valueArg === 'string' && /^[a-f0-9]{64}$/.test(valueArg));
+  return valueArg;
+};
+const counter = (valueArg: unknown, minimumArg = 0, incrementArg = false): number => {
+  requireValue(typeof valueArg === 'number' && Number.isSafeInteger(valueArg)
+    && !Object.is(valueArg, -0) && valueArg >= minimumArg
+    && (!incrementArg || valueArg < Number.MAX_SAFE_INTEGER));
+  return valueArg;
+};
+const origin = (valueArg: unknown): string => {
+  requireValue(typeof valueArg === 'string' && valueArg.length <= 2048);
+  let url: URL;
+  try { url = new URL(valueArg); } catch { return fail(); }
+  requireValue(url.protocol === 'https:' && !url.username && !url.password && url.origin === valueArg);
+  return valueArg;
+};
+const hostname = (valueArg: unknown): string => {
+  requireValue(typeof valueArg === 'string' && valueArg.length <= 253 && valueArg.length > 0);
+  requireValue(valueArg.split('.').every((labelArg) =>
+    /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/.test(labelArg)));
+  return valueArg;
+};
+
+const proposal = <TPurpose extends TNodeCredentialPurpose>(
+  valueArg: unknown, purposeArg: TPurpose,
+): INodeEnrollmentCredentialProposalV1 & { purpose: TPurpose } => {
+  const value = record(valueArg, ['purpose', 'installationId', 'mutationId', 'tokenHash',
+    'expectedGeneration', 'expectedSessionEpoch']);
+  requireValue(value.purpose === purposeArg);
+  return { purpose: purposeArg, installationId: id(value.installationId), mutationId: id(value.mutationId),
+    tokenHash: hash(value.tokenHash), expectedGeneration: counter(value.expectedGeneration, 0, true),
+    expectedSessionEpoch: counter(value.expectedSessionEpoch, 0, true) };
+};
+
+const distinctOwners = (
+  sparkArg: INodeEnrollmentCredentialAcknowledgementV1 | INodeEnrollmentCredentialProposalV1,
+  palletArg: INodeEnrollmentCredentialAcknowledgementV1 | INodeEnrollmentCredentialProposalV1,
+): 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',
+    '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'));
+  const bootstrap = record(value.bootstrap, kind.value === 'jump'
+    ? ['kind', 'proofHash'] : ['kind', 'nodeId', 'proofHash']);
+  requireValue(bootstrap.kind === 'jump' || bootstrap.kind === 'adopt-existing');
+  const [sparkInput, palletInput] = pair(value.credentials);
+  const spark = proposal(sparkInput, 'spark');
+  const pallet = proposal(palletInput, 'pallet');
+  distinctOwners(spark, pallet);
+  requireValue(pallet.expectedGeneration === 0 && pallet.expectedSessionEpoch === 0);
+  requireValue(bootstrap.kind === 'jump'
+    ? spark.expectedGeneration === 0 && spark.expectedSessionEpoch === 0
+    : spark.expectedGeneration > 0);
+  return deepFreezeValue({ schemaVersion: 1, enrollmentId: hash(value.enrollmentId),
+    cloudlyOrigin: origin(value.cloudlyOrigin), hostname: hostname(value.hostname),
+    bootstrap: bootstrap.kind === 'jump'
+      ? { kind: 'jump', proofHash: hash(bootstrap.proofHash) }
+      : { kind: 'adopt-existing', nodeId: id(bootstrap.nodeId), proofHash: hash(bootstrap.proofHash) },
+    credentials: [spark, pallet] });
+};
+
+export const computeNodeEnrollmentV1Digest = async (valueArg: INodeEnrollmentV1): Promise<string> => {
+  const payload = snapshotNodeEnrollmentV1(valueArg);
+  return createCanonicalJsonSha256Hex(canonicalizeStrictJson({
+    domain: nodeEnrollmentV1Contract.digestDomain, payload,
+  }, fail), fail);
+};
+
+export const snapshotNodeEnrollmentRequestV1 = (valueArg: unknown): INodeEnrollmentRequestV1 => {
+  const value = record(valueArg, ['enrollment', 'proof']);
+  const enrollment = snapshotNodeEnrollmentV1(value.enrollment);
+  const proof = record(value.proof, ['kind', 'bearer']);
+  requireValue(proof.kind === 'bootstrap' || proof.kind === 'pending-spark');
+  requireValue(typeof proof.bearer === 'string');
+  requireValue(proof.kind === 'bootstrap' && enrollment.bootstrap.kind === 'jump'
+    ? /^[A-Za-z0-9_-]{16}$/.test(proof.bearer) : /^secureToken[a-f0-9]{64}$/.test(proof.bearer));
+  return deepFreezeValue({ enrollment, proof: { kind: proof.kind, bearer: proof.bearer } });
+};
+
+/**
+ * Pure proof binding/mode check only, NOT authentication. The server must derive
+ * 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',
+): Promise<boolean> => {
+  try {
+    const { enrollment, proof } = snapshotNodeEnrollmentRequestV1(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.
+    const actual = await createSha256Hex(new TextEncoder().encode(proof.bearer), fail);
+    return actual === (proof.kind === 'bootstrap'
+      ? enrollment.bootstrap.proofHash : enrollment.credentials[0].tokenHash);
+  } catch { return false; }
+};
+
+const credentialAcknowledgement = <TPurpose extends TNodeCredentialPurpose>(
+  valueArg: unknown, purposeArg: TPurpose,
+): INodeEnrollmentCredentialAcknowledgementV1 & { 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 = (
+  valueArg: unknown,
+): INodeEnrollmentAcknowledgementV1 => {
+  const value = record(valueArg, ['schemaVersion', '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),
+    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);
+  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) {
+    const expected = enrollment.credentials[index];
+    const actual = ack.credentials[index];
+    requireValue(actual.purpose === expected.purpose && actual.installationId === expected.installationId
+      && actual.mutationId === expected.mutationId && actual.tokenHash === expected.tokenHash
+      && actual.generation === expected.expectedGeneration + 1);
+  }
+  requireValue(ack.requestDigest === await computeNodeEnrollmentV1Digest(enrollment));
+  return ack;
+};
+
+export const snapshotNodeEnrollmentStateV1 = (valueArg: unknown): INodeEnrollmentStateV1 => {
+  const value = record(valueArg, ['schemaVersion', 'nodeId', 'spark', 'pallet']);
+  requireValue(value.schemaVersion === 1 && value.pallet === 'absent');
+  const spark = record(value.spark, ['generation', 'sessionEpoch']);
+  return deepFreezeValue({ schemaVersion: 1, nodeId: id(value.nodeId), pallet: 'absent',
+    spark: { generation: counter(spark.generation, 1, true), sessionEpoch: counter(spark.sessionEpoch, 0, true) } });
+};

package/ts/requests/node.ts

@@ -4,10 +4,48 @@ import type { ICluster } from '../data/cluster.js';
 import type { IClusterNode, IClusterNodeMetrics, INodeAction, INodeMetricsSample, ISparkNodeRuntimeInfo, TNodeActionName } from '../data/clusternode.js';
 import type { IDeployment } from '../data/deployment.js';
 import type { IIdentity } from '../data/user.js';
+import type {
+  INodeCredentialMetadataV1,
+  INodeCredentialMutationPreconditionsV1,
+  INodeCredentialMutationResultV1,
+  TNodeCredentialPurpose,
+} from '../data/nodecredential.js';
+import type {
+  INodeEnrollmentRequestV1,
+  INodeEnrollmentAcknowledgementV1,
+  INodeEnrollmentStateV1,
+} from '../data/nodeenrollment.js';
 
-export interface IRequest_Any_Cloudly_GetNodeConfig {
+/** Node-self adoption preconditions, not an admin or workload RBAC grant. */
+export interface IReq_Spark_Cloudly_GetNodeEnrollmentStateV1 extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_Spark_Cloudly_GetNodeEnrollmentStateV1
+> {
+  method: 'getNodeEnrollmentStateV1';
+  request: { nodeId: string; nodeToken: string };
+  /** Reject unless Spark is currently authenticated and Pallet authority is absent. */
+  response: INodeEnrollmentStateV1;
+}
+
+/** One server transaction; each node-local owner durably activates independently. */
+export interface IReq_Spark_Cloudly_EnrollNodeV1 extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_Spark_Cloudly_EnrollNodeV1
+> {
+  method: 'enrollNodeV1';
+  request: INodeEnrollmentRequestV1;
+  /** Replays require the exact receipt AND both current credential authorities. */
+  response: INodeEnrollmentAcknowledgementV1;
+}
+
+/** Requires verified platform-infrastructure admin authority; returns public data only. */
+export interface IRequest_Any_Cloudly_GetNodeConfig extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IRequest_Any_Cloudly_GetNodeConfig
+> {
   method: 'getNodeConfig';
   request: {
+    identity: IIdentity;
     nodeId: string;
   };
   response: {
@@ -15,6 +53,54 @@ export interface IRequest_Any_Cloudly_GetNodeConfig {
   };
 }
 
+/** These credential methods require verified infrastructure-admin authority. */
+export interface IReq_Any_Cloudly_GetNodeCredential extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_Any_Cloudly_GetNodeCredential
+> {
+  method: 'getNodeCredential';
+  request: {
+    identity: IIdentity;
+    nodeId: string;
+    purpose: TNodeCredentialPurpose;
+  };
+  response: {
+    metadata: INodeCredentialMetadataV1 | null;
+  };
+}
+
+export interface IReq_Any_Cloudly_RotateNodeCredential extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_Any_Cloudly_RotateNodeCredential
+> {
+  method: 'rotateNodeCredential';
+  request: {
+    identity: IIdentity;
+    mutation: INodeCredentialMutationPreconditionsV1 & {
+      /**
+       * SHA-256(token UTF-8 bytes), exactly 64 lowercase hexadecimal characters.
+       * The node must durably retain its pending CSPRNG credential and mutation
+       * identity before this request. A metadata-only retry never issues plaintext.
+       * Treat this request field as sensitive; never include it in hooks or logs.
+       */
+      newTokenHash: string;
+    };
+  };
+  response: INodeCredentialMutationResultV1;
+}
+
+export interface IReq_Any_Cloudly_RevokeNodeCredential extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_Any_Cloudly_RevokeNodeCredential
+> {
+  method: 'revokeNodeCredential';
+  request: {
+    identity: IIdentity;
+    mutation: INodeCredentialMutationPreconditionsV1;
+  };
+  response: INodeCredentialMutationResultV1;
+}
+
 export interface IRequest_Any_Cloudly_GetNodesByCluster {
   method: 'getNodesByCluster';
   request: {