@serve.zone/interfaces 27.4.0 → 28.0.0

package/.smartconfig.json

@@ -20,10 +20,16 @@
       ]
     },
     "release": {
+      "preflight": {
+        "test": true,
+        "build": true
+      },
       "targets": {
         "git": {
           "enabled": true,
-          "remote": "origin"
+          "remote": "origin",
+          "pushBranch": true,
+          "pushTags": true
         },
         "npm": {
           "enabled": true,
@@ -31,7 +37,8 @@
             "https://verdaccio.lossless.digital",
             "https://registry.npmjs.org"
           ],
-          "accessLevel": "public"
+          "accessLevel": "public",
+          "alreadyPublished": "success"
         },
         "docker": {
           "enabled": false,
@@ -41,7 +48,7 @@
     }
   },
   "@git.zone/tsdoc": {
-    "legal": "\n## License and Legal Information\n\nThis repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. \n\n**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.\n\n### Trademarks\n\nThis project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.\n\n### Company Information\n\nTask Venture Capital GmbH  \nRegistered at District court Bremen HRB 35230 HB, Germany\n\nFor any legal inquiries or if you require further information, please contact us via email at hello@task.vc.\n\nBy using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.\n"
+    "legal": "\n## License and Legal Information\n\nThis repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license.md](license.md) file within this repository. \n\n**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.\n\n### Trademarks\n\nThis project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.\n\n### Company Information\n\nTask Venture Capital GmbH  \nRegistered at District court Bremen HRB 35230 HB, Germany\n\nFor any legal inquiries or if you require further information, please contact us via email at hello@task.vc.\n\nBy using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.\n"
   },
   "@ship.zone/szci": {}
-}
+}

package/changelog.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## 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
+
+- add node-bound runtime assignment contracts (data)
+  - Add runtime assignment interfaces, canonical digest helpers, and data namespace exports.
+  - Add assignment and observation validators/evaluators for scope binding, CAS progression, replay handling, and sequence checks.
+  - Document node-bound runtime assignment semantics and add node test coverage.
+
+### Fixes
+
+- update release workflow and package metadata (release)
+  - Enable test and build preflight checks before releases
+  - Configure git releases to push branches and tags
+  - Update packaged license file references to license.md
+  - Bump dev tooling and package manager versions
+
 ## 2026-08-29 - 27.4.0
 
 ### Features

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@serve.zone/interfaces',
-    version: '27.4.0',
+    version: '28.0.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,7 +20,9 @@ export * from './immutableimage.js';
 export * from './isolatedrestore.js';
 export * from './isolatedrestore.golden.js';
 export * from './mail.js';
+export * from './nodecredential.js';
 export * from './registry.js';
+export * from './runtimeassignment.js';
 export * from './secret.js';
 export * from './baremetal.js';
 export * from './baseos.js';

package/dist_ts/data/index.js

@@ -20,7 +20,9 @@ export * from './immutableimage.js';
 export * from './isolatedrestore.js';
 export * from './isolatedrestore.golden.js';
 export * from './mail.js';
+export * from './nodecredential.js';
 export * from './registry.js';
+export * from './runtimeassignment.js';
 export * from './secret.js';
 export * from './baremetal.js';
 export * from './baseos.js';
@@ -35,4 +37,4 @@ export * from './traffic.js';
 export * from './user.js';
 export * from './version.js';
 export * from './webpush.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9kYXRhL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxjQUFjLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9kYXRhL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsY0FBYyxDQUFDIn0=

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/runtimeassignment.d.ts

@@ -0,0 +1,120 @@
+import type { TSha256Digest, TImmutableContainerPlatform } from './immutableimage.js';
+export interface IRuntimeControllerV1 {
+    kind: 'cloudly' | 'onebox';
+    id: string;
+    /** Persisted authority incarnation; changing it requires explicit re-admission. */
+    epoch: string;
+}
+/** Content-bound reference, not a credential, mount path or permission grant. */
+export interface IRuntimeAuthorityReferenceV1 {
+    id: string;
+    generation: number;
+    digest: TSha256Digest;
+}
+export interface IRuntimeAssignmentReferenceV1 {
+    assignmentId: string;
+    generation: number;
+    digest: TSha256Digest;
+}
+/** Derived from authenticated transport and locally configured ownership. */
+export interface IRuntimeAssignmentScopeV1 {
+    controller: IRuntimeControllerV1;
+    organizationId: string;
+    nodeId: string;
+    runtimeNamespace: string;
+}
+export type TRuntimeAssignmentDispositionV1 = 'run' | 'stop-preserve' | 'remove-runtime-preserve-storage';
+export interface IRuntimeAssignmentV1 extends IRuntimeAssignmentScopeV1 {
+    schemaVersion: 1;
+    assignmentId: string;
+    serviceId: string;
+    /** Stable logical replica; independent of container IDs and execution attempts. */
+    replicaId: string;
+    /** One execution attempt, immutable for this assignment. */
+    attemptId: string;
+    /** Logical topology provenance; placement authority remains nodeId. */
+    workerGroupId: string | null;
+    siteId: string | null;
+    generation: number;
+    /** Exact CAS predecessor; null only at generation 1. */
+    previous: IRuntimeAssignmentReferenceV1 | null;
+    disposition: TRuntimeAssignmentDispositionV1;
+    /** No automatic relocation or expiry-based claim of a stopped writer. */
+    offlinePolicy: 'continue-node-bound';
+    workload: {
+        registryHost: string;
+        repository: string;
+        imageDigest: TSha256Digest;
+        platform: TImmutableContainerPlatform;
+        /** Immutable complete invocation/configuration owned by the controller. */
+        config: IRuntimeAuthorityReferenceV1;
+        network: IRuntimeAuthorityReferenceV1 | null;
+        secrets: IRuntimeAuthorityReferenceV1 | null;
+        /** Sorted unique reference IDs. Empty means no persistent storage claims. */
+        storage: IRuntimeAuthorityReferenceV1[];
+    };
+    digest: TSha256Digest;
+}
+export type TRuntimeAssignmentDecisionV1 = {
+    status: 'accept' | 'replay';
+    assignment: IRuntimeAssignmentV1;
+} | {
+    status: 'reject';
+    reason: 'invalid' | 'scope-mismatch' | 'conflict' | 'stale' | 'predecessor-mismatch' | 'attempt-mismatch' | 'disposition-regression';
+};
+/** Value-free execution evidence. Receipt/acceptance alone never means ready. */
+export interface IRuntimeAssignmentObservationV1 {
+    schemaVersion: 1;
+    assignment: IRuntimeAssignmentReferenceV1;
+    /** Authenticated reporter session; its authority is verified by the receiver. */
+    reporterSessionId: string;
+    /** Durable per-assignment counter; never resets when a reporter reconnects. */
+    sequence: number;
+    observedAt: number;
+    phase: 'pending' | 'running' | 'stopped' | 'removed' | 'failed' | 'unknown';
+    ready: boolean;
+    runtime: {
+        sandboxId: string;
+        containerId: string;
+        imageDigest: TSha256Digest;
+    } | null;
+    digest: TSha256Digest;
+}
+export declare const runtimeAssignmentV1Contract: Readonly<{
+    readonly assignmentDigestDomain: "serve.zone/runtime-assignment-v1";
+    readonly observationDigestDomain: "serve.zone/runtime-assignment-observation-v1";
+    readonly maximumStorageReferences: 64;
+    readonly omission: "no-effect";
+    readonly removal: "retain-assignment-tombstone-and-storage";
+}>;
+/** Digest helpers validate structure and exclude only the object's own digest. */
+export declare const computeRuntimeAssignmentV1Digest: (assignmentArg: IRuntimeAssignmentV1) => Promise<TSha256Digest>;
+export declare const validateRuntimeAssignmentV1: (valueArg: unknown) => Promise<string[]>;
+export declare const getRuntimeAssignmentV1Reference: (assignmentArg: IRuntimeAssignmentV1) => IRuntimeAssignmentReferenceV1;
+/**
+ * Pure CAS decision, not authentication or execution. The caller must persist
+ * acceptance atomically before effects, serialize replica ownership, and retain
+ * removed assignments as tombstones. New attempts require separate stop/fencing
+ * admission for every older writer. An omitted assignment causes no transition.
+ * Persist only the returned detached snapshot, never the mutable input object.
+ */
+export declare const evaluateRuntimeAssignmentV1: (incomingArg: IRuntimeAssignmentV1, acceptedArg: IRuntimeAssignmentV1 | null, trustedScopeArg: IRuntimeAssignmentScopeV1) => Promise<TRuntimeAssignmentDecisionV1>;
+export declare const computeRuntimeAssignmentObservationV1Digest: (observationArg: IRuntimeAssignmentObservationV1) => Promise<TSha256Digest>;
+/** Checks exact assignment evidence; transport must separately bind reporter/session. */
+export declare const validateRuntimeAssignmentObservationV1: (observationArg: unknown, assignmentArg: IRuntimeAssignmentV1) => Promise<string[]>;
+export type TRuntimeObservationDecisionV1 = {
+    status: 'accept' | 'replay';
+    observation: IRuntimeAssignmentObservationV1;
+} | {
+    status: 'reject';
+    reason: 'invalid' | 'session-mismatch' | 'stale' | 'conflict' | 'sequence-gap';
+};
+/**
+ * Receiver must authorize the assignment's node before calling this helper.
+ * Compare/persist the returned snapshot atomically with the old receipt. A new
+ * session continues the durable counter; it does not reset observation history.
+ * Across dispositions, the old receipt must reference the exact predecessor;
+ * receivers must process each revision's observations in order.
+ * These observations are never sufficient authority to relocate a storage writer.
+ */
+export declare const evaluateRuntimeAssignmentObservationV1: (incomingArg: IRuntimeAssignmentObservationV1, acceptedArg: IRuntimeAssignmentObservationV1 | null, assignmentArg: IRuntimeAssignmentV1, trustedReporterSessionIdArg: string) => Promise<TRuntimeObservationDecisionV1>;

package/dist_ts/data/runtimeassignment.js

@@ -0,0 +1,267 @@
+import { buildDigestPinnedImageReference, isSha256Digest } from './immutableimage.js';
+import { canonicalizeStrictJson, createCanonicalJsonSha256Hex } from '../private/canonicaljson.js';
+export const runtimeAssignmentV1Contract = Object.freeze({
+    assignmentDigestDomain: 'serve.zone/runtime-assignment-v1',
+    observationDigestDomain: 'serve.zone/runtime-assignment-observation-v1',
+    maximumStorageReferences: 64,
+    omission: 'no-effect',
+    removal: 'retain-assignment-tombstone-and-storage',
+});
+const fail = (messageArg) => { throw new Error(messageArg); };
+const isIdentifier = (valueArg) => typeof valueArg === 'string' && /^[A-Za-z0-9][A-Za-z0-9:._-]{0,199}$/.test(valueArg);
+const isPositiveInteger = (valueArg) => typeof valueArg === 'number' && Number.isSafeInteger(valueArg) && valueArg > 0;
+const isDigest = (valueArg) => typeof valueArg === 'string' && isSha256Digest(valueArg);
+/** Reject accessors before reading any fields; do not run input-owned code. */
+const isExactRecord = (valueArg, keysArg) => {
+    if (!valueArg || typeof valueArg !== 'object' || Array.isArray(valueArg))
+        return false;
+    const prototype = Object.getPrototypeOf(valueArg);
+    if (prototype !== Object.prototype && prototype !== null)
+        return false;
+    const keys = Reflect.ownKeys(valueArg);
+    return keys.length === keysArg.length && keys.every((keyArg) => {
+        const descriptor = Object.getOwnPropertyDescriptor(valueArg, keyArg);
+        return typeof keyArg === 'string' && keysArg.includes(keyArg)
+            && descriptor?.enumerable === true && Object.hasOwn(descriptor, 'value');
+    });
+};
+const isController = (valueArg) => isExactRecord(valueArg, ['kind', 'id', 'epoch'])
+    && (valueArg.kind === 'cloudly' || valueArg.kind === 'onebox')
+    && isIdentifier(valueArg.id) && isIdentifier(valueArg.epoch);
+const isAuthorityReference = (valueArg) => isExactRecord(valueArg, ['id', 'generation', 'digest'])
+    && isIdentifier(valueArg.id) && isPositiveInteger(valueArg.generation) && isDigest(valueArg.digest);
+const isAssignmentReference = (valueArg) => isExactRecord(valueArg, ['assignmentId', 'generation', 'digest'])
+    && isIdentifier(valueArg.assignmentId) && isPositiveInteger(valueArg.generation)
+    && isDigest(valueArg.digest);
+const assignmentKeys = [
+    'schemaVersion', 'controller', 'organizationId', 'nodeId', 'runtimeNamespace',
+    'assignmentId', 'serviceId', 'replicaId', 'attemptId', 'workerGroupId', 'siteId',
+    'generation', 'previous', 'disposition', 'offlinePolicy', 'workload', 'digest',
+];
+const assertAssignment = (valueArg) => {
+    if (!isExactRecord(valueArg, assignmentKeys)
+        || valueArg.schemaVersion !== 1 || !isController(valueArg.controller)
+        || !isPositiveInteger(valueArg.generation) || !isDigest(valueArg.digest)
+        || valueArg.offlinePolicy !== 'continue-node-bound'
+        || !['run', 'stop-preserve', 'remove-runtime-preserve-storage'].includes(valueArg.disposition))
+        fail('runtime assignment must use its exact v1 schema');
+    for (const key of ['organizationId', 'nodeId', 'runtimeNamespace', 'assignmentId',
+        'serviceId', 'replicaId', 'attemptId']) {
+        if (!isIdentifier(valueArg[key]))
+            fail(`runtime assignment ${key} must be a canonical identifier`);
+    }
+    for (const key of ['workerGroupId', 'siteId']) {
+        if (valueArg[key] !== null && !isIdentifier(valueArg[key]))
+            fail('invalid runtime topology ID');
+    }
+    if (valueArg.generation === 1 ? valueArg.previous !== null
+        : !isAssignmentReference(valueArg.previous)
+            || valueArg.previous.assignmentId !== valueArg.assignmentId
+            || valueArg.previous.generation !== valueArg.generation - 1) {
+        fail('runtime assignment must bind its exact preceding generation');
+    }
+    const workload = valueArg.workload;
+    if (!isExactRecord(workload, ['registryHost', 'repository', 'imageDigest', 'platform',
+        'config', 'network', 'secrets', 'storage'])
+        || typeof workload.registryHost !== 'string' || workload.registryHost.length > 253
+        || typeof workload.repository !== 'string' || workload.repository.length > 255
+        || !isDigest(workload.imageDigest)
+        || !['linux/amd64', 'linux/arm64'].includes(workload.platform)
+        || !isAuthorityReference(workload.config)
+        || (workload.network !== null && !isAuthorityReference(workload.network))
+        || (workload.secrets !== null && !isAuthorityReference(workload.secrets))
+        || !Array.isArray(workload.storage)
+        || workload.storage.length > runtimeAssignmentV1Contract.maximumStorageReferences) {
+        fail('runtime assignment workload must use exact immutable references');
+    }
+    buildDigestPinnedImageReference(workload.registryHost, workload.repository, workload.imageDigest);
+    let previousId = '';
+    for (let index = 0; index < workload.storage.length; index++) {
+        const descriptor = Object.getOwnPropertyDescriptor(workload.storage, String(index));
+        if (!descriptor || !Object.hasOwn(descriptor, 'value')
+            || !isAuthorityReference(descriptor.value) || descriptor.value.id <= previousId) {
+            fail('runtime assignment storage references must be dense, sorted and unique');
+        }
+        previousId = descriptor.value.id;
+    }
+    canonicalizeStrictJson(valueArg, fail);
+    return valueArg;
+};
+const digestPayload = async (domainArg, valueArg) => {
+    const { digest: _digest, ...payload } = valueArg;
+    return `sha256:${await createCanonicalJsonSha256Hex(canonicalizeStrictJson({ domain: domainArg, payload }, fail), fail)}`;
+};
+/** Digest helpers validate structure and exclude only the object's own digest. */
+export const computeRuntimeAssignmentV1Digest = async (assignmentArg) => digestPayload(runtimeAssignmentV1Contract.assignmentDigestDomain, assertAssignment(assignmentArg));
+export const validateRuntimeAssignmentV1 = async (valueArg) => {
+    try {
+        const assignment = snapshotAssignment(valueArg);
+        return assignment.digest === await computeRuntimeAssignmentV1Digest(assignment)
+            ? [] : ['runtime assignment digest does not match'];
+    }
+    catch {
+        return ['runtime assignment must use its exact canonical v1 schema'];
+    }
+};
+const snapshotAssignment = (valueArg) => JSON.parse(canonicalizeStrictJson(assertAssignment(valueArg), fail));
+export const getRuntimeAssignmentV1Reference = (assignmentArg) => ({
+    assignmentId: assignmentArg.assignmentId,
+    generation: assignmentArg.generation,
+    digest: assignmentArg.digest,
+});
+const canonical = (valueArg) => canonicalizeStrictJson(valueArg, fail);
+const immutableAttempt = (assignmentArg) => {
+    const { generation, previous, disposition, digest, ...attempt } = assignmentArg;
+    return canonical(attempt);
+};
+/**
+ * Pure CAS decision, not authentication or execution. The caller must persist
+ * acceptance atomically before effects, serialize replica ownership, and retain
+ * removed assignments as tombstones. New attempts require separate stop/fencing
+ * admission for every older writer. An omitted assignment causes no transition.
+ * Persist only the returned detached snapshot, never the mutable input object.
+ */
+export const evaluateRuntimeAssignmentV1 = async (incomingArg, acceptedArg, trustedScopeArg) => {
+    try {
+        incomingArg = snapshotAssignment(incomingArg);
+        acceptedArg = acceptedArg === null ? null : snapshotAssignment(acceptedArg);
+        if (!isExactRecord(trustedScopeArg, ['controller', 'organizationId', 'nodeId', 'runtimeNamespace'])
+            || !isController(trustedScopeArg.controller)
+            || !isIdentifier(trustedScopeArg.organizationId) || !isIdentifier(trustedScopeArg.nodeId)
+            || !isIdentifier(trustedScopeArg.runtimeNamespace))
+            return { status: 'reject', reason: 'invalid' };
+        trustedScopeArg = JSON.parse(canonical(trustedScopeArg));
+    }
+    catch {
+        return { status: 'reject', reason: 'invalid' };
+    }
+    if ((await validateRuntimeAssignmentV1(incomingArg)).length
+        || (acceptedArg !== null && (await validateRuntimeAssignmentV1(acceptedArg)).length)) {
+        return { status: 'reject', reason: 'invalid' };
+    }
+    const matchesScope = (assignmentArg) => assignmentArg.controller.kind === trustedScopeArg.controller.kind
+        && assignmentArg.controller.id === trustedScopeArg.controller.id
+        && assignmentArg.controller.epoch === trustedScopeArg.controller.epoch
+        && assignmentArg.organizationId === trustedScopeArg.organizationId
+        && assignmentArg.nodeId === trustedScopeArg.nodeId
+        && assignmentArg.runtimeNamespace === trustedScopeArg.runtimeNamespace;
+    if (!matchesScope(incomingArg) || (acceptedArg !== null && !matchesScope(acceptedArg))) {
+        return { status: 'reject', reason: 'scope-mismatch' };
+    }
+    if (acceptedArg === null) {
+        return incomingArg.generation === 1
+            && incomingArg.disposition === 'run'
+            ? { status: 'accept', assignment: incomingArg }
+            : { status: 'reject', reason: 'predecessor-mismatch' };
+    }
+    if (incomingArg.assignmentId !== acceptedArg.assignmentId) {
+        return { status: 'reject', reason: 'attempt-mismatch' };
+    }
+    if (incomingArg.generation < acceptedArg.generation)
+        return { status: 'reject', reason: 'stale' };
+    if (incomingArg.generation === acceptedArg.generation) {
+        return incomingArg.digest === acceptedArg.digest
+            ? { status: 'replay', assignment: acceptedArg } : { status: 'reject', reason: 'conflict' };
+    }
+    if (canonical(incomingArg.previous) !== canonical(getRuntimeAssignmentV1Reference(acceptedArg))) {
+        return { status: 'reject', reason: 'predecessor-mismatch' };
+    }
+    if (immutableAttempt(incomingArg) !== immutableAttempt(acceptedArg)) {
+        return { status: 'reject', reason: 'attempt-mismatch' };
+    }
+    const order = {
+        run: 0, 'stop-preserve': 1, 'remove-runtime-preserve-storage': 2,
+    };
+    if (order[incomingArg.disposition] !== order[acceptedArg.disposition] + 1) {
+        return { status: 'reject', reason: 'disposition-regression' };
+    }
+    return { status: 'accept', assignment: incomingArg };
+};
+const assertObservation = (valueArg) => {
+    if (!isExactRecord(valueArg, ['schemaVersion', 'assignment', 'reporterSessionId',
+        'sequence', 'observedAt', 'phase', 'ready', 'runtime', 'digest'])
+        || valueArg.schemaVersion !== 1 || !isAssignmentReference(valueArg.assignment)
+        || !isIdentifier(valueArg.reporterSessionId) || !isPositiveInteger(valueArg.sequence)
+        || !isPositiveInteger(valueArg.observedAt) || !isDigest(valueArg.digest)
+        || typeof valueArg.ready !== 'boolean'
+        || !['pending', 'running', 'stopped', 'removed', 'failed', 'unknown'].includes(valueArg.phase)) {
+        fail('runtime observation must use its exact v1 schema');
+    }
+    if (valueArg.runtime !== null && (!isExactRecord(valueArg.runtime, [
+        'sandboxId', 'containerId', 'imageDigest',
+    ]) || !isIdentifier(valueArg.runtime.sandboxId) || !isIdentifier(valueArg.runtime.containerId)
+        || !isDigest(valueArg.runtime.imageDigest)))
+        fail('runtime identity must be canonical');
+    if ((valueArg.ready && valueArg.phase !== 'running')
+        || (valueArg.phase === 'running' && valueArg.runtime === null)
+        || (valueArg.phase === 'removed' && valueArg.runtime !== null)) {
+        fail('runtime observation readiness and identity contradict its phase');
+    }
+    canonical(valueArg);
+    return valueArg;
+};
+export const computeRuntimeAssignmentObservationV1Digest = async (observationArg) => digestPayload(runtimeAssignmentV1Contract.observationDigestDomain, assertObservation(observationArg));
+/** Checks exact assignment evidence; transport must separately bind reporter/session. */
+export const validateRuntimeAssignmentObservationV1 = async (observationArg, assignmentArg) => {
+    try {
+        const observation = JSON.parse(canonical(assertObservation(observationArg)));
+        assignmentArg = snapshotAssignment(assignmentArg);
+        if ((await validateRuntimeAssignmentV1(assignmentArg)).length)
+            return ['invalid assignment'];
+        if (canonical(observation.assignment) !== canonical(getRuntimeAssignmentV1Reference(assignmentArg))) {
+            return ['runtime observation does not match the exact assignment'];
+        }
+        if (observation.digest !== await computeRuntimeAssignmentObservationV1Digest(observation)) {
+            return ['runtime observation digest does not match'];
+        }
+        if (observation.ready && (assignmentArg.disposition !== 'run'
+            || observation.runtime?.imageDigest !== assignmentArg.workload.imageDigest)) {
+            return ['runtime readiness does not match authorized execution'];
+        }
+        return [];
+    }
+    catch {
+        return ['runtime observation must use its exact canonical v1 schema'];
+    }
+};
+/**
+ * Receiver must authorize the assignment's node before calling this helper.
+ * Compare/persist the returned snapshot atomically with the old receipt. A new
+ * session continues the durable counter; it does not reset observation history.
+ * Across dispositions, the old receipt must reference the exact predecessor;
+ * receivers must process each revision's observations in order.
+ * These observations are never sufficient authority to relocate a storage writer.
+ */
+export const evaluateRuntimeAssignmentObservationV1 = async (incomingArg, acceptedArg, assignmentArg, trustedReporterSessionIdArg) => {
+    try {
+        incomingArg = JSON.parse(canonical(assertObservation(incomingArg)));
+        acceptedArg = acceptedArg === null ? null
+            : JSON.parse(canonical(assertObservation(acceptedArg)));
+        assignmentArg = snapshotAssignment(assignmentArg);
+        if (!isIdentifier(trustedReporterSessionIdArg)
+            || (await validateRuntimeAssignmentObservationV1(incomingArg, assignmentArg)).length
+            || (acceptedArg !== null && (acceptedArg.digest !== await computeRuntimeAssignmentObservationV1Digest(acceptedArg)
+                || acceptedArg.assignment.assignmentId !== assignmentArg.assignmentId
+                || (canonical(acceptedArg.assignment) !== canonical(getRuntimeAssignmentV1Reference(assignmentArg))
+                    && canonical(acceptedArg.assignment) !== canonical(assignmentArg.previous)))))
+            return { status: 'reject', reason: 'invalid' };
+        if (incomingArg.reporterSessionId !== trustedReporterSessionIdArg) {
+            return { status: 'reject', reason: 'session-mismatch' };
+        }
+        if (acceptedArg !== null && incomingArg.sequence <= acceptedArg.sequence) {
+            if (incomingArg.sequence < acceptedArg.sequence)
+                return { status: 'reject', reason: 'stale' };
+            return incomingArg.digest === acceptedArg.digest
+                ? { status: 'replay', observation: acceptedArg }
+                : { status: 'reject', reason: 'conflict' };
+        }
+        if (incomingArg.sequence !== (acceptedArg?.sequence ?? 0) + 1) {
+            return { status: 'reject', reason: 'sequence-gap' };
+        }
+        return { status: 'accept', observation: incomingArg };
+    }
+    catch {
+        return { status: 'reject', reason: 'invalid' };
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtimeassignment.js","sourceRoot":"","sources":["../../ts/data/runtimeassignment.ts"],"names":[],"mappings":"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"}

package/dist_ts/requests/node.d.ts

@@ -4,15 +4,54 @@ 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';
+/** 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.4.0",
+  "version": "28.0.0",
   "private": false,
   "description": "Shared TypeScript interfaces and TypedRequest contracts for the serve.zone ecosystem.",
   "exports": {
@@ -28,10 +28,10 @@
   },
   "devDependencies": {
     "@git.zone/tsbuild": "^4.4.2",
-    "@git.zone/tsdoc": "^2.1.1",
+    "@git.zone/tsdoc": "^2.2.0",
     "@git.zone/tsrun": "^2.0.6",
     "@git.zone/tstest": "^4.0.0",
-    "@types/node": "^26.2.0"
+    "@types/node": "^26.4.1"
   },
   "files": [
     "ts/**/*",
@@ -41,7 +41,7 @@
     ".smartconfig.json",
     "readme.md",
     "changelog.md",
-    "license"
+    "license.md"
   ],
   "repository": {
     "type": "git",

package/readme.md

@@ -47,6 +47,67 @@ 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.
+
+### Node-Bound Runtime Assignments
+
+The `data` namespace exports `IRuntimeAssignmentV1`, canonical digest helpers,
+`evaluateRuntimeAssignmentV1`, and assignment observation validators/evaluators
+for Cloudly/Onebox controllers and Pallet nodes. These are shared contracts;
+they do not install a runtime, schedule containers or expose an RPC endpoint.
+
+Each assignment binds a controller incarnation, organization, stable node and
+replica IDs, one immutable execution attempt, image/configuration and opaque
+network/storage/secret references. Group and site IDs are nullable topology
+provenance. All fields except the digest itself participate in a domain-separated
+SHA-256 digest. Digests provide integrity and compare-and-swap identity;
+authentication must separately establish the trusted controller/node scope.
+
+An attempt starts at generation one with `run`, then advances through
+`stop-preserve` and `remove-runtime-preserve-storage` using exact predecessor
+generation/digest references. Exact retries return `replay`; conflicts, stale
+revisions, gaps, changed execution specifications and resurrection are rejected.
+Consumers must atomically persist the evaluator's detached snapshot before effects,
+retain removal tombstones and storage, and serialize ownership of each replica.
+Omission causes no change. A new attempt requires separate admission proving any
+older exclusive writer stopped or fenced. The supported offline policy is
+`continue-node-bound`; no heartbeat timeout or lease expiry proves a writer absent.
+
+Observations bind the exact assignment, authenticated reporter session, durable
+per-assignment sequence and digest. Reconnect does not reset the counter. Observation
+history must reference the same assignment revision or its exact predecessor;
+receivers process each disposition's observations in order. Session
+authorization, clock/freshness policy and durable receipt persistence belong to
+the receiving service. Readiness requires matching running image evidence and
+`run` intent; assignment acceptance alone is never readiness. A valid observation
+can describe drift (such as a removed runtime while intent remains `run`), and
+does not authorize storage relocation or prove fencing.
+
 ### Offline SmartDB Settlement And Packaging
 
 The Node-only `@serve.zone/interfaces/runtime` export includes isolated V1
@@ -1108,7 +1169,7 @@ The package is authored as ESM TypeScript and built with `tsbuild tsfolders`.
 
 ## License and Legal Information
 
-This repository contains open-source code licensed under the MIT License. A copy of the license can be found in the [license](./license) file.
+This repository contains open-source code licensed under the MIT License. A copy of the license can be found in the [license.md](./license.md) file.
 
 **Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.
 

package/ts/00_commitinfo_data.ts

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

package/ts/data/index.ts

@@ -20,7 +20,9 @@ export * from './immutableimage.js';
 export * from './isolatedrestore.js';
 export * from './isolatedrestore.golden.js';
 export * from './mail.js';
+export * from './nodecredential.js';
 export * from './registry.js';
+export * from './runtimeassignment.js';
 export * from './secret.js';
 export * from './baremetal.js';
 export * from './baseos.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/runtimeassignment.ts

@@ -0,0 +1,402 @@
+import type { TSha256Digest, TImmutableContainerPlatform } from './immutableimage.js';
+import { buildDigestPinnedImageReference, isSha256Digest } from './immutableimage.js';
+import { canonicalizeStrictJson, createCanonicalJsonSha256Hex } from '../private/canonicaljson.js';
+
+export interface IRuntimeControllerV1 {
+  kind: 'cloudly' | 'onebox';
+  id: string;
+  /** Persisted authority incarnation; changing it requires explicit re-admission. */
+  epoch: string;
+}
+
+/** Content-bound reference, not a credential, mount path or permission grant. */
+export interface IRuntimeAuthorityReferenceV1 {
+  id: string;
+  generation: number;
+  digest: TSha256Digest;
+}
+
+export interface IRuntimeAssignmentReferenceV1 {
+  assignmentId: string;
+  generation: number;
+  digest: TSha256Digest;
+}
+
+/** Derived from authenticated transport and locally configured ownership. */
+export interface IRuntimeAssignmentScopeV1 {
+  controller: IRuntimeControllerV1;
+  organizationId: string;
+  nodeId: string;
+  runtimeNamespace: string;
+}
+
+export type TRuntimeAssignmentDispositionV1 =
+  | 'run'
+  | 'stop-preserve'
+  | 'remove-runtime-preserve-storage';
+
+export interface IRuntimeAssignmentV1 extends IRuntimeAssignmentScopeV1 {
+  schemaVersion: 1;
+  assignmentId: string;
+  serviceId: string;
+  /** Stable logical replica; independent of container IDs and execution attempts. */
+  replicaId: string;
+  /** One execution attempt, immutable for this assignment. */
+  attemptId: string;
+  /** Logical topology provenance; placement authority remains nodeId. */
+  workerGroupId: string | null;
+  siteId: string | null;
+  generation: number;
+  /** Exact CAS predecessor; null only at generation 1. */
+  previous: IRuntimeAssignmentReferenceV1 | null;
+  disposition: TRuntimeAssignmentDispositionV1;
+  /** No automatic relocation or expiry-based claim of a stopped writer. */
+  offlinePolicy: 'continue-node-bound';
+  workload: {
+    registryHost: string;
+    repository: string;
+    imageDigest: TSha256Digest;
+    platform: TImmutableContainerPlatform;
+    /** Immutable complete invocation/configuration owned by the controller. */
+    config: IRuntimeAuthorityReferenceV1;
+    network: IRuntimeAuthorityReferenceV1 | null;
+    secrets: IRuntimeAuthorityReferenceV1 | null;
+    /** Sorted unique reference IDs. Empty means no persistent storage claims. */
+    storage: IRuntimeAuthorityReferenceV1[];
+  };
+  digest: TSha256Digest;
+}
+
+export type TRuntimeAssignmentDecisionV1 =
+  | { status: 'accept' | 'replay'; assignment: IRuntimeAssignmentV1 }
+  | { status: 'reject'; reason: 'invalid' | 'scope-mismatch' | 'conflict' | 'stale'
+      | 'predecessor-mismatch' | 'attempt-mismatch' | 'disposition-regression' };
+
+/** Value-free execution evidence. Receipt/acceptance alone never means ready. */
+export interface IRuntimeAssignmentObservationV1 {
+  schemaVersion: 1;
+  assignment: IRuntimeAssignmentReferenceV1;
+  /** Authenticated reporter session; its authority is verified by the receiver. */
+  reporterSessionId: string;
+  /** Durable per-assignment counter; never resets when a reporter reconnects. */
+  sequence: number;
+  observedAt: number;
+  phase: 'pending' | 'running' | 'stopped' | 'removed' | 'failed' | 'unknown';
+  ready: boolean;
+  runtime: {
+    sandboxId: string;
+    containerId: string;
+    imageDigest: TSha256Digest;
+  } | null;
+  digest: TSha256Digest;
+}
+
+export const runtimeAssignmentV1Contract = Object.freeze({
+  assignmentDigestDomain: 'serve.zone/runtime-assignment-v1',
+  observationDigestDomain: 'serve.zone/runtime-assignment-observation-v1',
+  maximumStorageReferences: 64,
+  omission: 'no-effect',
+  removal: 'retain-assignment-tombstone-and-storage',
+} as const);
+
+const fail: (messageArg: string) => never = (messageArg) => { throw new Error(messageArg); };
+const isIdentifier = (valueArg: unknown): valueArg is string =>
+  typeof valueArg === 'string' && /^[A-Za-z0-9][A-Za-z0-9:._-]{0,199}$/.test(valueArg);
+const isPositiveInteger = (valueArg: unknown): valueArg is number =>
+  typeof valueArg === 'number' && Number.isSafeInteger(valueArg) && valueArg > 0;
+const isDigest = (valueArg: unknown): valueArg is TSha256Digest =>
+  typeof valueArg === 'string' && isSha256Digest(valueArg);
+
+/** Reject accessors before reading any fields; do not run input-owned code. */
+const isExactRecord = (
+  valueArg: unknown,
+  keysArg: readonly string[],
+): valueArg is Record<string, unknown> => {
+  if (!valueArg || typeof valueArg !== 'object' || Array.isArray(valueArg)) return false;
+  const prototype = Object.getPrototypeOf(valueArg);
+  if (prototype !== Object.prototype && prototype !== null) return false;
+  const keys = Reflect.ownKeys(valueArg);
+  return keys.length === keysArg.length && keys.every((keyArg) => {
+    const descriptor = Object.getOwnPropertyDescriptor(valueArg, keyArg);
+    return typeof keyArg === 'string' && keysArg.includes(keyArg)
+      && descriptor?.enumerable === true && Object.hasOwn(descriptor, 'value');
+  });
+};
+
+const isController = (valueArg: unknown): valueArg is IRuntimeControllerV1 =>
+  isExactRecord(valueArg, ['kind', 'id', 'epoch'])
+  && (valueArg.kind === 'cloudly' || valueArg.kind === 'onebox')
+  && isIdentifier(valueArg.id) && isIdentifier(valueArg.epoch);
+const isAuthorityReference = (valueArg: unknown): valueArg is IRuntimeAuthorityReferenceV1 =>
+  isExactRecord(valueArg, ['id', 'generation', 'digest'])
+  && isIdentifier(valueArg.id) && isPositiveInteger(valueArg.generation) && isDigest(valueArg.digest);
+const isAssignmentReference = (valueArg: unknown): valueArg is IRuntimeAssignmentReferenceV1 =>
+  isExactRecord(valueArg, ['assignmentId', 'generation', 'digest'])
+  && isIdentifier(valueArg.assignmentId) && isPositiveInteger(valueArg.generation)
+  && isDigest(valueArg.digest);
+
+const assignmentKeys = [
+  'schemaVersion', 'controller', 'organizationId', 'nodeId', 'runtimeNamespace',
+  'assignmentId', 'serviceId', 'replicaId', 'attemptId', 'workerGroupId', 'siteId',
+  'generation', 'previous', 'disposition', 'offlinePolicy', 'workload', 'digest',
+] as const;
+
+const assertAssignment = (valueArg: unknown): IRuntimeAssignmentV1 => {
+  if (!isExactRecord(valueArg, assignmentKeys)
+    || valueArg.schemaVersion !== 1 || !isController(valueArg.controller)
+    || !isPositiveInteger(valueArg.generation) || !isDigest(valueArg.digest)
+    || valueArg.offlinePolicy !== 'continue-node-bound'
+    || !['run', 'stop-preserve', 'remove-runtime-preserve-storage'].includes(
+      valueArg.disposition as string,
+    )) fail('runtime assignment must use its exact v1 schema');
+  for (const key of ['organizationId', 'nodeId', 'runtimeNamespace', 'assignmentId',
+    'serviceId', 'replicaId', 'attemptId']) {
+    if (!isIdentifier(valueArg[key])) fail(`runtime assignment ${key} must be a canonical identifier`);
+  }
+  for (const key of ['workerGroupId', 'siteId']) {
+    if (valueArg[key] !== null && !isIdentifier(valueArg[key])) fail('invalid runtime topology ID');
+  }
+  if (valueArg.generation === 1 ? valueArg.previous !== null
+    : !isAssignmentReference(valueArg.previous)
+      || valueArg.previous.assignmentId !== valueArg.assignmentId
+      || valueArg.previous.generation !== (valueArg.generation as number) - 1) {
+    fail('runtime assignment must bind its exact preceding generation');
+  }
+  const workload = valueArg.workload;
+  if (!isExactRecord(workload, ['registryHost', 'repository', 'imageDigest', 'platform',
+    'config', 'network', 'secrets', 'storage'])
+    || typeof workload.registryHost !== 'string' || workload.registryHost.length > 253
+    || typeof workload.repository !== 'string' || workload.repository.length > 255
+    || !isDigest(workload.imageDigest)
+    || !['linux/amd64', 'linux/arm64'].includes(workload.platform as string)
+    || !isAuthorityReference(workload.config)
+    || (workload.network !== null && !isAuthorityReference(workload.network))
+    || (workload.secrets !== null && !isAuthorityReference(workload.secrets))
+    || !Array.isArray(workload.storage)
+    || workload.storage.length > runtimeAssignmentV1Contract.maximumStorageReferences) {
+    fail('runtime assignment workload must use exact immutable references');
+  }
+  buildDigestPinnedImageReference(workload.registryHost as string,
+    workload.repository as string, workload.imageDigest as TSha256Digest);
+  let previousId = '';
+  for (let index = 0; index < (workload.storage as unknown[]).length; index++) {
+    const descriptor = Object.getOwnPropertyDescriptor(workload.storage, String(index));
+    if (!descriptor || !Object.hasOwn(descriptor, 'value')
+      || !isAuthorityReference(descriptor.value) || descriptor.value.id <= previousId) {
+      fail('runtime assignment storage references must be dense, sorted and unique');
+    }
+    previousId = descriptor.value.id;
+  }
+  canonicalizeStrictJson(valueArg, fail);
+  return valueArg as unknown as IRuntimeAssignmentV1;
+};
+
+const digestPayload = async (domainArg: string, valueArg: { digest: TSha256Digest }): Promise<TSha256Digest> => {
+  const { digest: _digest, ...payload } = valueArg;
+  return `sha256:${await createCanonicalJsonSha256Hex(
+    canonicalizeStrictJson({ domain: domainArg, payload }, fail), fail,
+  )}`;
+};
+
+/** Digest helpers validate structure and exclude only the object's own digest. */
+export const computeRuntimeAssignmentV1Digest = async (
+  assignmentArg: IRuntimeAssignmentV1,
+): Promise<TSha256Digest> => digestPayload(
+  runtimeAssignmentV1Contract.assignmentDigestDomain, assertAssignment(assignmentArg),
+);
+
+export const validateRuntimeAssignmentV1 = async (valueArg: unknown): Promise<string[]> => {
+  try {
+    const assignment = snapshotAssignment(valueArg);
+    return assignment.digest === await computeRuntimeAssignmentV1Digest(assignment)
+      ? [] : ['runtime assignment digest does not match'];
+  } catch {
+    return ['runtime assignment must use its exact canonical v1 schema'];
+  }
+};
+
+const snapshotAssignment = (valueArg: unknown): IRuntimeAssignmentV1 =>
+  JSON.parse(canonicalizeStrictJson(assertAssignment(valueArg), fail)) as IRuntimeAssignmentV1;
+
+export const getRuntimeAssignmentV1Reference = (
+  assignmentArg: IRuntimeAssignmentV1,
+): IRuntimeAssignmentReferenceV1 => ({
+  assignmentId: assignmentArg.assignmentId,
+  generation: assignmentArg.generation,
+  digest: assignmentArg.digest,
+});
+
+const canonical = (valueArg: unknown): string => canonicalizeStrictJson(valueArg, fail);
+const immutableAttempt = (assignmentArg: IRuntimeAssignmentV1): string => {
+  const { generation, previous, disposition, digest, ...attempt } = assignmentArg;
+  return canonical(attempt);
+};
+
+/**
+ * Pure CAS decision, not authentication or execution. The caller must persist
+ * acceptance atomically before effects, serialize replica ownership, and retain
+ * removed assignments as tombstones. New attempts require separate stop/fencing
+ * admission for every older writer. An omitted assignment causes no transition.
+ * Persist only the returned detached snapshot, never the mutable input object.
+ */
+export const evaluateRuntimeAssignmentV1 = async (
+  incomingArg: IRuntimeAssignmentV1,
+  acceptedArg: IRuntimeAssignmentV1 | null,
+  trustedScopeArg: IRuntimeAssignmentScopeV1,
+): Promise<TRuntimeAssignmentDecisionV1> => {
+  try {
+    incomingArg = snapshotAssignment(incomingArg);
+    acceptedArg = acceptedArg === null ? null : snapshotAssignment(acceptedArg);
+    if (!isExactRecord(trustedScopeArg, ['controller', 'organizationId', 'nodeId', 'runtimeNamespace'])
+      || !isController(trustedScopeArg.controller)
+      || !isIdentifier(trustedScopeArg.organizationId) || !isIdentifier(trustedScopeArg.nodeId)
+      || !isIdentifier(trustedScopeArg.runtimeNamespace)) return { status: 'reject', reason: 'invalid' };
+    trustedScopeArg = JSON.parse(canonical(trustedScopeArg)) as IRuntimeAssignmentScopeV1;
+  } catch {
+    return { status: 'reject', reason: 'invalid' };
+  }
+  if ((await validateRuntimeAssignmentV1(incomingArg)).length
+    || (acceptedArg !== null && (await validateRuntimeAssignmentV1(acceptedArg)).length)) {
+    return { status: 'reject', reason: 'invalid' };
+  }
+  const matchesScope = (assignmentArg: IRuntimeAssignmentV1): boolean =>
+    assignmentArg.controller.kind === trustedScopeArg.controller.kind
+    && assignmentArg.controller.id === trustedScopeArg.controller.id
+    && assignmentArg.controller.epoch === trustedScopeArg.controller.epoch
+    && assignmentArg.organizationId === trustedScopeArg.organizationId
+    && assignmentArg.nodeId === trustedScopeArg.nodeId
+    && assignmentArg.runtimeNamespace === trustedScopeArg.runtimeNamespace;
+  if (!matchesScope(incomingArg) || (acceptedArg !== null && !matchesScope(acceptedArg))) {
+    return { status: 'reject', reason: 'scope-mismatch' };
+  }
+  if (acceptedArg === null) {
+    return incomingArg.generation === 1
+      && incomingArg.disposition === 'run'
+      ? { status: 'accept', assignment: incomingArg }
+      : { status: 'reject', reason: 'predecessor-mismatch' };
+  }
+  if (incomingArg.assignmentId !== acceptedArg.assignmentId) {
+    return { status: 'reject', reason: 'attempt-mismatch' };
+  }
+  if (incomingArg.generation < acceptedArg.generation) return { status: 'reject', reason: 'stale' };
+  if (incomingArg.generation === acceptedArg.generation) {
+    return incomingArg.digest === acceptedArg.digest
+      ? { status: 'replay', assignment: acceptedArg } : { status: 'reject', reason: 'conflict' };
+  }
+  if (canonical(incomingArg.previous) !== canonical(getRuntimeAssignmentV1Reference(acceptedArg))) {
+    return { status: 'reject', reason: 'predecessor-mismatch' };
+  }
+  if (immutableAttempt(incomingArg) !== immutableAttempt(acceptedArg)) {
+    return { status: 'reject', reason: 'attempt-mismatch' };
+  }
+  const order: Record<TRuntimeAssignmentDispositionV1, number> = {
+    run: 0, 'stop-preserve': 1, 'remove-runtime-preserve-storage': 2,
+  };
+  if (order[incomingArg.disposition] !== order[acceptedArg.disposition] + 1) {
+    return { status: 'reject', reason: 'disposition-regression' };
+  }
+  return { status: 'accept', assignment: incomingArg };
+};
+
+const assertObservation = (valueArg: unknown): IRuntimeAssignmentObservationV1 => {
+  if (!isExactRecord(valueArg, ['schemaVersion', 'assignment', 'reporterSessionId',
+    'sequence', 'observedAt', 'phase', 'ready', 'runtime', 'digest'])
+    || valueArg.schemaVersion !== 1 || !isAssignmentReference(valueArg.assignment)
+    || !isIdentifier(valueArg.reporterSessionId) || !isPositiveInteger(valueArg.sequence)
+    || !isPositiveInteger(valueArg.observedAt) || !isDigest(valueArg.digest)
+    || typeof valueArg.ready !== 'boolean'
+    || !['pending', 'running', 'stopped', 'removed', 'failed', 'unknown'].includes(valueArg.phase as string)) {
+    fail('runtime observation must use its exact v1 schema');
+  }
+  if (valueArg.runtime !== null && (!isExactRecord(valueArg.runtime, [
+    'sandboxId', 'containerId', 'imageDigest',
+  ]) || !isIdentifier(valueArg.runtime.sandboxId) || !isIdentifier(valueArg.runtime.containerId)
+    || !isDigest(valueArg.runtime.imageDigest))) fail('runtime identity must be canonical');
+  if ((valueArg.ready && valueArg.phase !== 'running')
+    || (valueArg.phase === 'running' && valueArg.runtime === null)
+    || (valueArg.phase === 'removed' && valueArg.runtime !== null)) {
+    fail('runtime observation readiness and identity contradict its phase');
+  }
+  canonical(valueArg);
+  return valueArg as unknown as IRuntimeAssignmentObservationV1;
+};
+
+export const computeRuntimeAssignmentObservationV1Digest = async (
+  observationArg: IRuntimeAssignmentObservationV1,
+): Promise<TSha256Digest> => digestPayload(
+  runtimeAssignmentV1Contract.observationDigestDomain, assertObservation(observationArg),
+);
+
+/** Checks exact assignment evidence; transport must separately bind reporter/session. */
+export const validateRuntimeAssignmentObservationV1 = async (
+  observationArg: unknown,
+  assignmentArg: IRuntimeAssignmentV1,
+): Promise<string[]> => {
+  try {
+    const observation = JSON.parse(canonical(assertObservation(observationArg))) as IRuntimeAssignmentObservationV1;
+    assignmentArg = snapshotAssignment(assignmentArg);
+    if ((await validateRuntimeAssignmentV1(assignmentArg)).length) return ['invalid assignment'];
+    if (canonical(observation.assignment) !== canonical(getRuntimeAssignmentV1Reference(assignmentArg))) {
+      return ['runtime observation does not match the exact assignment'];
+    }
+    if (observation.digest !== await computeRuntimeAssignmentObservationV1Digest(observation)) {
+      return ['runtime observation digest does not match'];
+    }
+    if (observation.ready && (assignmentArg.disposition !== 'run'
+      || observation.runtime?.imageDigest !== assignmentArg.workload.imageDigest)) {
+      return ['runtime readiness does not match authorized execution'];
+    }
+    return [];
+  } catch {
+    return ['runtime observation must use its exact canonical v1 schema'];
+  }
+};
+
+export type TRuntimeObservationDecisionV1 =
+  | { status: 'accept' | 'replay'; observation: IRuntimeAssignmentObservationV1 }
+  | { status: 'reject'; reason: 'invalid' | 'session-mismatch' | 'stale' | 'conflict' | 'sequence-gap' };
+
+/**
+ * Receiver must authorize the assignment's node before calling this helper.
+ * Compare/persist the returned snapshot atomically with the old receipt. A new
+ * session continues the durable counter; it does not reset observation history.
+ * Across dispositions, the old receipt must reference the exact predecessor;
+ * receivers must process each revision's observations in order.
+ * These observations are never sufficient authority to relocate a storage writer.
+ */
+export const evaluateRuntimeAssignmentObservationV1 = async (
+  incomingArg: IRuntimeAssignmentObservationV1,
+  acceptedArg: IRuntimeAssignmentObservationV1 | null,
+  assignmentArg: IRuntimeAssignmentV1,
+  trustedReporterSessionIdArg: string,
+): Promise<TRuntimeObservationDecisionV1> => {
+  try {
+    incomingArg = JSON.parse(canonical(assertObservation(incomingArg))) as IRuntimeAssignmentObservationV1;
+    acceptedArg = acceptedArg === null ? null
+      : JSON.parse(canonical(assertObservation(acceptedArg))) as IRuntimeAssignmentObservationV1;
+    assignmentArg = snapshotAssignment(assignmentArg);
+    if (!isIdentifier(trustedReporterSessionIdArg)
+      || (await validateRuntimeAssignmentObservationV1(incomingArg, assignmentArg)).length
+      || (acceptedArg !== null && (
+        acceptedArg.digest !== await computeRuntimeAssignmentObservationV1Digest(acceptedArg)
+        || acceptedArg.assignment.assignmentId !== assignmentArg.assignmentId
+        || (canonical(acceptedArg.assignment) !== canonical(getRuntimeAssignmentV1Reference(assignmentArg))
+          && canonical(acceptedArg.assignment) !== canonical(assignmentArg.previous))
+      ))) return { status: 'reject', reason: 'invalid' };
+    if (incomingArg.reporterSessionId !== trustedReporterSessionIdArg) {
+      return { status: 'reject', reason: 'session-mismatch' };
+    }
+    if (acceptedArg !== null && incomingArg.sequence <= acceptedArg.sequence) {
+      if (incomingArg.sequence < acceptedArg.sequence) return { status: 'reject', reason: 'stale' };
+      return incomingArg.digest === acceptedArg.digest
+        ? { status: 'replay', observation: acceptedArg }
+        : { status: 'reject', reason: 'conflict' };
+    }
+    if (incomingArg.sequence !== (acceptedArg?.sequence ?? 0) + 1) {
+      return { status: 'reject', reason: 'sequence-gap' };
+    }
+    return { status: 'accept', observation: incomingArg };
+  } catch {
+    return { status: 'reject', reason: 'invalid' };
+  }
+};

package/ts/requests/node.ts

@@ -4,10 +4,21 @@ 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';
 
-export interface IRequest_Any_Cloudly_GetNodeConfig {
+/** 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 +26,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: {