@serve.zone/interfaces 32.0.2 → 32.2.0

package/dist_ts/private/storagecontract.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The readers a storage control body is judged by, and the one normalizer that turns a storage
+ * request into the exact value its digest is taken over.
+ *
+ * Two modules judge the same bytes in their own error vocabulary — `platform/storage.ts` for a
+ * storage request on its own and `platform/storagemigration.ts` for the migration control plane
+ * that carries one — so the rules take the failure they report through. A second copy of them
+ * would be a second answer to what a request is, and a request digest that a control plane issues
+ * and a consumer re-derives would stop being one value.
+ */
+import type { IAppStoreFilesystemStorageRequest, IAppStoreObjectStorageRequest, TAppStoreStorageRequest } from '../appstore/types.js';
+import type { TObjectStorageDelivery } from '../platform/storage.js';
+import type { TCanonicalJsonFailure } from './canonicaljson.js';
+/** Byte bounds every reader of a storage control string applies. */
+export declare const storageContractStringLimits: Readonly<{
+    maximumConfiguredStringBytes: 2048;
+    maximumEnvironmentKeyBytes: 256;
+    maximumSecretPathBytes: 2048;
+}>;
+export declare const createStorageContractReaders: (failArg: TCanonicalJsonFailure) => {
+    utf8ByteLength: (valueArg: string) => number;
+    readRecord: (valueArg: unknown, fieldNameArg: string) => Record<string, unknown>;
+    readDenseArray: (valueArg: unknown, fieldNameArg: string, minimumLengthArg: number, maximumLengthArg: number) => unknown[];
+    assertKeys: (recordArg: Record<string, unknown>, requiredKeysArg: readonly string[], optionalKeysArg: readonly string[], fieldNameArg: string) => void;
+    assertExactKeys: (recordArg: Record<string, unknown>, expectedKeysArg: readonly string[], fieldNameArg: string) => void;
+    readString: (valueArg: unknown, fieldNameArg: string, maximumBytesArg?: number) => string;
+    readIdentifier: (valueArg: unknown, fieldNameArg: string) => string;
+    readSha256: (valueArg: unknown, fieldNameArg: string) => string;
+    readSafeInteger: (valueArg: unknown, fieldNameArg: string, minimumArg: number, maximumArg?: number) => number;
+    readBoolean: (valueArg: unknown, fieldNameArg: string) => boolean;
+    readLiteral: <TLiteral extends string>(valueArg: unknown, allowedArg: readonly TLiteral[], fieldNameArg: string) => TLiteral;
+    readCapacityQuantity: (valueArg: unknown, fieldNameArg: string) => string;
+    capacityQuantityBytes: (valueArg: string) => bigint;
+    readEnvironmentKey: (valueArg: unknown, fieldNameArg: string) => string;
+    normalizeCapacityRequest: (valueArg: unknown, fieldNameArg: string) => NonNullable<TAppStoreStorageRequest["capacity"]>;
+    normalizeDelivery: (valueArg: unknown, fieldNameArg: string) => TObjectStorageDelivery;
+    normalizeObjectStorageRequest: (valueArg: unknown, fieldNameArg: string) => IAppStoreObjectStorageRequest;
+    normalizeFilesystemStorageRequest: (valueArg: unknown, fieldNameArg: string) => IAppStoreFilesystemStorageRequest;
+    normalizeStorageRequest: (valueArg: unknown, fieldNameArg: string) => TAppStoreStorageRequest;
+};

package/dist_ts/private/storagecontract.js

@@ -0,0 +1,399 @@
+import { normalizeServiceAbsolutePath } from '../data/service.js';
+/** Byte bounds every reader of a storage control string applies. */
+export const storageContractStringLimits = Object.freeze({
+    maximumConfiguredStringBytes: 2048,
+    maximumEnvironmentKeyBytes: 256,
+    maximumSecretPathBytes: 2048,
+});
+const canonicalIdPattern = /^[A-Za-z0-9][A-Za-z0-9._:@-]{0,191}$/;
+const environmentKeyPattern = /^[A-Z_][A-Z0-9_]{0,255}$/;
+const sha256Pattern = /^[a-f0-9]{64}$/;
+const capacityPattern = /^[1-9][0-9]*(?:KiB|MiB|GiB|TiB)$/;
+/**
+ * The mount a Secret file is delivered under. A filesystem request that mounts it, or anything
+ * containing it, would shadow every credential the platform writes for the same service.
+ */
+const secretDeliveryRoot = '/run/secrets';
+export const createStorageContractReaders = (failArg) => {
+    const utf8ByteLength = (valueArg) => {
+        return new TextEncoder().encode(valueArg).byteLength;
+    };
+    const readRecord = (valueArg, fieldNameArg) => {
+        if (!valueArg || typeof valueArg !== 'object' || Array.isArray(valueArg)) {
+            return failArg(`${fieldNameArg} must be a plain object`);
+        }
+        const prototype = Object.getPrototypeOf(valueArg);
+        if (prototype !== Object.prototype && prototype !== null) {
+            return failArg(`${fieldNameArg} must be a plain object`);
+        }
+        const record = valueArg;
+        const ownKeys = Reflect.ownKeys(record);
+        if (ownKeys.some((keyArg) => typeof keyArg !== 'string')) {
+            return failArg(`${fieldNameArg} must not contain symbol keys`);
+        }
+        for (const key of ownKeys) {
+            const descriptor = Object.getOwnPropertyDescriptor(record, key);
+            if (!descriptor ||
+                !descriptor.enumerable ||
+                !Object.hasOwn(descriptor, 'value') ||
+                descriptor.value === undefined) {
+                return failArg(`${fieldNameArg} must contain enumerable JSON data properties only`);
+            }
+        }
+        return record;
+    };
+    const readDenseArray = (valueArg, fieldNameArg, minimumLengthArg, maximumLengthArg) => {
+        if (!Array.isArray(valueArg) ||
+            Object.getPrototypeOf(valueArg) !== Array.prototype) {
+            return failArg(`${fieldNameArg} must be a dense plain array`);
+        }
+        if (valueArg.length < minimumLengthArg ||
+            valueArg.length > maximumLengthArg) {
+            return failArg(`${fieldNameArg} must contain between ${minimumLengthArg} and ${maximumLengthArg} entries`);
+        }
+        for (let index = 0; index < valueArg.length; index++) {
+            if (!Object.hasOwn(valueArg, index)) {
+                return failArg(`${fieldNameArg} must not contain sparse entries`);
+            }
+            const descriptor = Object.getOwnPropertyDescriptor(valueArg, String(index));
+            if (!descriptor ||
+                !descriptor.enumerable ||
+                !Object.hasOwn(descriptor, 'value') ||
+                descriptor.value === undefined) {
+                return failArg(`${fieldNameArg} must contain enumerable JSON data entries only`);
+            }
+        }
+        for (const key of Reflect.ownKeys(valueArg)) {
+            if (key === 'length')
+                continue;
+            if (typeof key !== 'string' ||
+                !/^(?:0|[1-9][0-9]*)$/.test(key) ||
+                Number(key) >= valueArg.length) {
+                return failArg(`${fieldNameArg} must not contain extra properties`);
+            }
+        }
+        return valueArg;
+    };
+    const assertKeys = (recordArg, requiredKeysArg, optionalKeysArg, fieldNameArg) => {
+        const actualKeys = Object.keys(recordArg).sort();
+        const allowedKeys = new Set([...requiredKeysArg, ...optionalKeysArg]);
+        if (requiredKeysArg.some((keyArg) => !Object.hasOwn(recordArg, keyArg)) ||
+            actualKeys.some((keyArg) => !allowedKeys.has(keyArg))) {
+            failArg(`${fieldNameArg} does not match its exact schema`);
+        }
+    };
+    const assertExactKeys = (recordArg, expectedKeysArg, fieldNameArg) => {
+        assertKeys(recordArg, expectedKeysArg, [], fieldNameArg);
+    };
+    const readString = (valueArg, fieldNameArg, maximumBytesArg = storageContractStringLimits.maximumConfiguredStringBytes) => {
+        if (typeof valueArg !== 'string' ||
+            valueArg.length === 0 ||
+            utf8ByteLength(valueArg) > maximumBytesArg ||
+            /[\u0000-\u001f\u007f]/u.test(valueArg)) {
+            return failArg(`${fieldNameArg} must be a bounded non-empty JSON string`);
+        }
+        for (let index = 0; index < valueArg.length; index++) {
+            const codeUnit = valueArg.charCodeAt(index);
+            if (codeUnit >= 0xd800 && codeUnit <= 0xdbff) {
+                const following = valueArg.charCodeAt(index + 1);
+                if (following < 0xdc00 || following > 0xdfff) {
+                    return failArg(`${fieldNameArg} contains an unpaired UTF-16 surrogate`);
+                }
+                index++;
+            }
+            else if (codeUnit >= 0xdc00 && codeUnit <= 0xdfff) {
+                return failArg(`${fieldNameArg} contains an unpaired UTF-16 surrogate`);
+            }
+        }
+        return valueArg;
+    };
+    const readIdentifier = (valueArg, fieldNameArg) => {
+        if (typeof valueArg !== 'string' || !canonicalIdPattern.test(valueArg)) {
+            return failArg(`${fieldNameArg} must be a canonical identifier`);
+        }
+        return valueArg;
+    };
+    const readSha256 = (valueArg, fieldNameArg) => {
+        if (typeof valueArg !== 'string' || !sha256Pattern.test(valueArg)) {
+            return failArg(`${fieldNameArg} must be a bare lowercase 64-hex SHA-256 digest`);
+        }
+        return valueArg;
+    };
+    const readSafeInteger = (valueArg, fieldNameArg, minimumArg, maximumArg = Number.MAX_SAFE_INTEGER) => {
+        if (typeof valueArg !== 'number' ||
+            !Number.isSafeInteger(valueArg) ||
+            Object.is(valueArg, -0) ||
+            valueArg < minimumArg ||
+            valueArg > maximumArg) {
+            return failArg(`${fieldNameArg} must be a safe integer between ${minimumArg} and ${maximumArg}`);
+        }
+        return valueArg;
+    };
+    const readBoolean = (valueArg, fieldNameArg) => {
+        if (typeof valueArg !== 'boolean') {
+            return failArg(`${fieldNameArg} must be a boolean`);
+        }
+        return valueArg;
+    };
+    const readLiteral = (valueArg, allowedArg, fieldNameArg) => {
+        if (typeof valueArg !== 'string' ||
+            !allowedArg.includes(valueArg)) {
+            return failArg(`${fieldNameArg} is outside the supported values`);
+        }
+        return valueArg;
+    };
+    const readCapacityQuantity = (valueArg, fieldNameArg) => {
+        if (typeof valueArg !== 'string' || !capacityPattern.test(valueArg)) {
+            return failArg(`${fieldNameArg} must be a canonical base-2 capacity quantity`);
+        }
+        const numericPart = valueArg.replace(/(?:KiB|MiB|GiB|TiB)$/, '');
+        if (!Number.isSafeInteger(Number(numericPart))) {
+            return failArg(`${fieldNameArg} exceeds the safe integer quantity range`);
+        }
+        return valueArg;
+    };
+    const capacityQuantityBytes = (valueArg) => {
+        const units = {
+            KiB: 1024n,
+            MiB: 1024n ** 2n,
+            GiB: 1024n ** 3n,
+            TiB: 1024n ** 4n,
+        };
+        const unit = valueArg.slice(-3);
+        return BigInt(valueArg.slice(0, -3)) * units[unit];
+    };
+    const normalizeCapacityRequest = (valueArg, fieldNameArg) => {
+        const value = readRecord(valueArg, fieldNameArg);
+        assertKeys(value, ['request'], ['limit'], fieldNameArg);
+        const request = readCapacityQuantity(value.request, `${fieldNameArg}.request`);
+        const limit = Object.hasOwn(value, 'limit')
+            ? readCapacityQuantity(value.limit, `${fieldNameArg}.limit`)
+            : undefined;
+        if (limit && capacityQuantityBytes(limit) < capacityQuantityBytes(request)) {
+            return failArg(`${fieldNameArg}.limit must be at least request`);
+        }
+        return {
+            request,
+            ...(limit ? { limit } : {}),
+        };
+    };
+    const readEnvironmentKey = (valueArg, fieldNameArg) => {
+        if (typeof valueArg !== 'string' ||
+            utf8ByteLength(valueArg) >
+                storageContractStringLimits.maximumEnvironmentKeyBytes ||
+            !environmentKeyPattern.test(valueArg)) {
+            return failArg(`${fieldNameArg} must be a canonical environment key`);
+        }
+        return valueArg;
+    };
+    const normalizeDelivery = (valueArg, fieldNameArg) => {
+        const value = readRecord(valueArg, fieldNameArg);
+        if (value.type === 'launcher-environment') {
+            assertExactKeys(value, ['type', 'keys'], fieldNameArg);
+            const keys = readRecord(value.keys, `${fieldNameArg}.keys`);
+            assertKeys(keys, ['endpoint', 'bucket', 'region', 'accessKeyId', 'secretAccessKey'], ['sessionToken'], `${fieldNameArg}.keys`);
+            const normalizedKeys = {
+                endpoint: readEnvironmentKey(keys.endpoint, `${fieldNameArg}.keys.endpoint`),
+                bucket: readEnvironmentKey(keys.bucket, `${fieldNameArg}.keys.bucket`),
+                region: readEnvironmentKey(keys.region, `${fieldNameArg}.keys.region`),
+                accessKeyId: readEnvironmentKey(keys.accessKeyId, `${fieldNameArg}.keys.accessKeyId`),
+                secretAccessKey: readEnvironmentKey(keys.secretAccessKey, `${fieldNameArg}.keys.secretAccessKey`),
+                ...(Object.hasOwn(keys, 'sessionToken')
+                    ? {
+                        sessionToken: readEnvironmentKey(keys.sessionToken, `${fieldNameArg}.keys.sessionToken`),
+                    }
+                    : {}),
+            };
+            if (new Set(Object.values(normalizedKeys)).size !==
+                Object.keys(normalizedKeys).length) {
+                return failArg(`${fieldNameArg}.keys values must be distinct`);
+            }
+            return { type: 'launcher-environment', keys: normalizedKeys };
+        }
+        if (value.type === 'file') {
+            assertExactKeys(value, ['type', 'targetPath', 'format', 'uid', 'gid', 'mode'], fieldNameArg);
+            const targetPath = readString(value.targetPath, `${fieldNameArg}.targetPath`, storageContractStringLimits.maximumSecretPathBytes);
+            if (!targetPath.startsWith(`${secretDeliveryRoot}/`) ||
+                targetPath.includes('\\') ||
+                targetPath.split('/').some((segmentArg) => segmentArg === '.' || segmentArg === '..')) {
+                return failArg(`${fieldNameArg}.targetPath must be a canonical path below ${secretDeliveryRoot}`);
+            }
+            if (value.format !== 'servezone-object-storage') {
+                return failArg(`${fieldNameArg}.format is unsupported`);
+            }
+            return {
+                type: 'file',
+                targetPath,
+                format: 'servezone-object-storage',
+                uid: readSafeInteger(value.uid, `${fieldNameArg}.uid`, 0, 2_147_483_647),
+                gid: readSafeInteger(value.gid, `${fieldNameArg}.gid`, 0, 2_147_483_647),
+                mode: value.mode === 0o400 || value.mode === 0o440
+                    ? value.mode
+                    : failArg(`${fieldNameArg}.mode must be 0400 or 0440`),
+            };
+        }
+        return failArg(`${fieldNameArg}.type is unsupported`);
+    };
+    const normalizeObjectStorageProtection = (valueArg, fieldNameArg) => {
+        const value = readRecord(valueArg, fieldNameArg);
+        assertKeys(value, [], ['backup', 'versioning', 'retentionDays'], fieldNameArg);
+        if (Object.keys(value).length === 0) {
+            return failArg(`${fieldNameArg} must not be empty`);
+        }
+        return {
+            ...(Object.hasOwn(value, 'backup')
+                ? {
+                    backup: value.backup === 'required'
+                        ? 'required'
+                        : failArg(`${fieldNameArg}.backup must be required`),
+                }
+                : {}),
+            ...(Object.hasOwn(value, 'versioning')
+                ? {
+                    versioning: value.versioning === 'required'
+                        ? 'required'
+                        : failArg(`${fieldNameArg}.versioning must be required`),
+                }
+                : {}),
+            ...(Object.hasOwn(value, 'retentionDays')
+                ? {
+                    retentionDays: readSafeInteger(value.retentionDays, `${fieldNameArg}.retentionDays`, 1, 365_000),
+                }
+                : {}),
+        };
+    };
+    const normalizeFilesystemProtection = (valueArg, fieldNameArg) => {
+        const value = readRecord(valueArg, fieldNameArg);
+        assertKeys(value, [], ['backup', 'snapshots', 'consistency'], fieldNameArg);
+        if (Object.keys(value).length === 0) {
+            return failArg(`${fieldNameArg} must not be empty`);
+        }
+        return {
+            ...(Object.hasOwn(value, 'backup')
+                ? {
+                    backup: value.backup === 'required'
+                        ? 'required'
+                        : failArg(`${fieldNameArg}.backup must be required`),
+                }
+                : {}),
+            ...(Object.hasOwn(value, 'snapshots')
+                ? {
+                    snapshots: readLiteral(value.snapshots, ['portable', 'native'], `${fieldNameArg}.snapshots`),
+                }
+                : {}),
+            ...(Object.hasOwn(value, 'consistency')
+                ? {
+                    consistency: readLiteral(value.consistency, ['crashConsistent', 'applicationConsistent'], `${fieldNameArg}.consistency`),
+                }
+                : {}),
+        };
+    };
+    const readMountPath = (valueArg, fieldNameArg) => {
+        const value = readString(valueArg, fieldNameArg, storageContractStringLimits.maximumSecretPathBytes);
+        if (normalizeServiceAbsolutePath(value) !== value || value === '/') {
+            return failArg(`${fieldNameArg} must be a canonical non-root absolute path`);
+        }
+        if (value === secretDeliveryRoot ||
+            value.startsWith(`${secretDeliveryRoot}/`) ||
+            secretDeliveryRoot.startsWith(`${value}/`)) {
+            return failArg(`${fieldNameArg} must not overlap ${secretDeliveryRoot}`);
+        }
+        return value;
+    };
+    const normalizeObjectStorageRequest = (valueArg, fieldNameArg) => {
+        const value = readRecord(valueArg, fieldNameArg);
+        assertKeys(value, [
+            'id',
+            'kind',
+            'storageClass',
+            'accessMode',
+            'reclaimPolicy',
+            'delivery',
+        ], ['capacity', 'protection'], fieldNameArg);
+        if (value.kind !== 'objectStorage') {
+            return failArg(`${fieldNameArg}.kind must be objectStorage`);
+        }
+        return {
+            id: readIdentifier(value.id, `${fieldNameArg}.id`),
+            kind: 'objectStorage',
+            storageClass: readIdentifier(value.storageClass, `${fieldNameArg}.storageClass`),
+            accessMode: readLiteral(value.accessMode, ['readOnly', 'readWrite'], `${fieldNameArg}.accessMode`),
+            reclaimPolicy: readLiteral(value.reclaimPolicy, ['retain', 'delete'], `${fieldNameArg}.reclaimPolicy`),
+            delivery: normalizeDelivery(value.delivery, `${fieldNameArg}.delivery`),
+            ...(Object.hasOwn(value, 'capacity')
+                ? {
+                    capacity: normalizeCapacityRequest(value.capacity, `${fieldNameArg}.capacity`),
+                }
+                : {}),
+            ...(Object.hasOwn(value, 'protection')
+                ? {
+                    protection: normalizeObjectStorageProtection(value.protection, `${fieldNameArg}.protection`),
+                }
+                : {}),
+        };
+    };
+    const normalizeFilesystemStorageRequest = (valueArg, fieldNameArg) => {
+        const value = readRecord(valueArg, fieldNameArg);
+        assertKeys(value, [
+            'id',
+            'kind',
+            'storageClass',
+            'accessMode',
+            'reclaimPolicy',
+            'mountPath',
+        ], ['capacity', 'protection'], fieldNameArg);
+        if (value.kind !== 'filesystem') {
+            return failArg(`${fieldNameArg}.kind must be filesystem`);
+        }
+        return {
+            id: readIdentifier(value.id, `${fieldNameArg}.id`),
+            kind: 'filesystem',
+            storageClass: readIdentifier(value.storageClass, `${fieldNameArg}.storageClass`),
+            accessMode: readLiteral(value.accessMode, ['ReadWriteOnce', 'ReadOnlyMany', 'ReadWriteMany'], `${fieldNameArg}.accessMode`),
+            reclaimPolicy: readLiteral(value.reclaimPolicy, ['retain', 'delete'], `${fieldNameArg}.reclaimPolicy`),
+            mountPath: readMountPath(value.mountPath, `${fieldNameArg}.mountPath`),
+            ...(Object.hasOwn(value, 'capacity')
+                ? {
+                    capacity: normalizeCapacityRequest(value.capacity, `${fieldNameArg}.capacity`),
+                }
+                : {}),
+            ...(Object.hasOwn(value, 'protection')
+                ? {
+                    protection: normalizeFilesystemProtection(value.protection, `${fieldNameArg}.protection`),
+                }
+                : {}),
+        };
+    };
+    const normalizeStorageRequest = (valueArg, fieldNameArg) => {
+        const value = readRecord(valueArg, fieldNameArg);
+        if (value.kind === 'filesystem') {
+            return normalizeFilesystemStorageRequest(value, fieldNameArg);
+        }
+        if (value.kind === 'objectStorage') {
+            return normalizeObjectStorageRequest(value, fieldNameArg);
+        }
+        return failArg(`${fieldNameArg}.kind must be filesystem or objectStorage`);
+    };
+    return {
+        utf8ByteLength,
+        readRecord,
+        readDenseArray,
+        assertKeys,
+        assertExactKeys,
+        readString,
+        readIdentifier,
+        readSha256,
+        readSafeInteger,
+        readBoolean,
+        readLiteral,
+        readCapacityQuantity,
+        capacityQuantityBytes,
+        readEnvironmentKey,
+        normalizeCapacityRequest,
+        normalizeDelivery,
+        normalizeObjectStorageRequest,
+        normalizeFilesystemStorageRequest,
+        normalizeStorageRequest,
+    };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storagecontract.js","sourceRoot":"","sources":["../../ts/private/storagecontract.ts"],"names":[],"mappings":"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"}

package/dist_ts/requests/node.d.ts

@@ -5,6 +5,7 @@ import type { IClusterNode, INodeAction, INodeMetricsSample, TNodeActionName } f
 import type { IDeployment } from '../data/deployment.js';
 import type { IIdentity } from '../data/user.js';
 import type { INodeCredentialMetadata, INodeCredentialMutationPreconditions, INodeCredentialMutationResult, TNodeCredentialPurpose } from '../data/nodecredential.js';
+import type { INodeRuntimeRetirement } from '../data/noderetirement.js';
 import type { INodeEnrollmentRequest, INodeEnrollmentAcknowledgement, INodeEnrollmentState } from '../data/nodeenrollment.js';
 /** Node-self adoption preconditions, not an admin or workload RBAC grant. */
 export interface IReq_Spark_Cloudly_GetNodeEnrollmentState extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_Spark_Cloudly_GetNodeEnrollmentState> {
@@ -150,6 +151,30 @@ export interface IReq_Any_Cloudly_DeleteNodeById extends plugins.typedrequestInt
         ok: boolean;
     };
 }
+/**
+ * An administrator retires one node from its cluster's Pallet runtime.
+ *
+ * Requires verified platform-infrastructure admin authority. This is the step that makes a node
+ * deletable: it writes the retirement row, on which the producer stops and removes the node's
+ * slots, the compiler quarantines its handoff, and both node credentials are revoked. Cloudly
+ * answers the row as it stands, which is `retiring` until all of that has settled.
+ *
+ * `expectedGeneration` is the cluster runtime generation the caller read with `getClusterRuntime`:
+ * retirement is a statement about a node of a Pallet cluster, so a cutover that moved the phase
+ * meanwhile refuses the write instead of retiring a node out of a runtime it no longer runs in.
+ * Every refusal is one of `data.nodeRuntimeRetirementRefusals` and takes nothing away.
+ */
+export interface IReq_Any_Cloudly_RetireClusterNode extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_Any_Cloudly_RetireClusterNode> {
+    method: 'retireClusterNode';
+    request: {
+        identity: IIdentity;
+        nodeId: string;
+        expectedGeneration: number;
+    };
+    response: {
+        retirement: INodeRuntimeRetirement;
+    };
+}
 /**
  * An administrator states where one node's Corestore control API answers.
  *

package/package.json

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

package/readme.md

@@ -892,9 +892,14 @@ on one spec revision, and each reason belongs to exactly one state. `converged`
 carry `reason: null`. `waiting` carries a `TServiceRuntimeWaitingReason`: `node-network-pending`,
 `conflict` or `failure-backoff`. `refused` carries a `TServiceRuntimeRefusal`:
 `cluster-runtime-missing`, `organization-missing`, `image-plan-missing`, `platform-unsupported`,
-`secrets-unsupported`, `volumes-unsupported`, `port-protocol-unsupported`,
-`readiness-target-undeclared`, `environment-too-large`, `no-eligible-node` or `replica-limit`. A
-refusal never retires running slots. `snapshotServiceRuntimeStatus` enforces the pairing.
+`secrets-unsupported`, `volumes-unsupported`, `port-protocol-unsupported`, `ports-too-many`,
+`readiness-target-undeclared`, `environment-too-large`, `no-eligible-node`, `replica-limit` or
+`node-authority-unsupported`. `ports-too-many` is a service declaring more target ports than the
+`runtimeConfigContract.maximumTargetPorts` (64) a config carries, where `port-protocol-unsupported`
+is about one port's protocol; `node-authority-unsupported` is a node whose session resolved fewer
+workload authorities than the spec needs, refused at the admit step rather than handed to a node
+that would silently park it. A refusal never retires running slots.
+`snapshotServiceRuntimeStatus` enforces the pairing.
 
 ### Runtime Assignment Views
 
@@ -911,6 +916,23 @@ through every slot on a cluster's nodes; `limit` runs from 1 to
 `requests.service.pushServiceRuntimeChanged { serviceId }` tells admin UIs that a service's spec,
 status or assignments changed; it carries no state, so a late push never overwrites a newer read.
 
+### Node Retirement
+
+`data.INodeRuntimeRetirement { id, clusterId, state, actorId, since }` records that one node leaves
+its cluster's Pallet runtime. `TNodeRuntimeRetirementState` is `retiring` while the producer still
+stops and removes the node's slots, the compiler quarantines its handoff and both node credentials
+are revoked, and `retired` once that has settled. It is stored beside the node document, because a
+node update merges caller data and no caller may retire a node with it. The producers read the row's
+presence rather than its state: a node that has one is no longer an egress member and desires no
+slots, so the row is written before anything is taken away and stays as long as the node document.
+`snapshotNodeRuntimeRetirement` checks the record.
+
+`requests.node.retireClusterNode { identity, nodeId, expectedGeneration }` answers `{ retirement }`.
+`expectedGeneration` is the cluster runtime generation the caller read with `getClusterRuntime`, so a
+cutover that moved the phase meanwhile refuses the write. Every refusal is one of
+`data.nodeRuntimeRetirementRefusals` — `node-missing`, `cluster-runtime-not-pallet`,
+`node-already-retired` or `conflict` — and takes nothing away.
+
 ### Corestore Database Export Packaging
 
 The Node-only `@serve.zone/interfaces/runtime` export provides metadata-only
@@ -1271,6 +1293,21 @@ metadata plus a service-owned credential management scope and delivery policy,
 never credential references or values. Filesystem
 bindings expose the container mount and access mode, never a host path.
 
+A binding's `requestDigest` is stated by one function, so the control plane that
+issues it and the consumer that re-derives it compute the same value:
+
+```typescript
+const requestDigest = await platform.createStorageRequestSha256(storageRequest);
+```
+
+It normalizes the request to its contract shape, canonicalizes it and returns
+bare lowercase hex over the request alone — no prefix, and nothing wrapped
+around the request. A body that is not a storage request is refused with
+`platform.StorageContractError` instead of hashed, and
+`platform.canonicalizeStorageRequest` returns the exact bytes the digest is
+taken over. `platform.storageRequestCanonicalDigestGoldenVectors` states both
+for a filesystem request and for both object-storage deliveries.
+
 Portable manifests and resolved bindings intentionally have no fields for
 Synology, NFS, Kerberos, Corestore, Kubernetes, Docker drivers, servers,
 exports, mount options, provider credential values, or local fallback paths. Runtimes

package/ts/00_commitinfo_data.ts

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

package/ts/data/index.ts

@@ -25,6 +25,7 @@ export * from './isolatedrestore.golden.js';
 export * from './mail.js';
 export * from './nodecredential.js';
 export * from './nodeenrollment.js';
+export * from './noderetirement.js';
 export * from './networkaddressplan.js';
 export * from './networkauthority.js';
 export * from './networkcredential.js';