@serve.zone/interfaces 32.2.0 → 32.3.0

package/changelog.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## 2026-09-18 - 32.3.0
+
+### Features
+
+- Add `platform.normalizeStorageRequest(value)`, the contract's own statement of which storage
+  requests exist: it reads a body against the exact request schema and returns the request in its
+  contract shape — canonical environment keys, no empty `protection` block, no explicitly undefined
+  member, `retentionDays` within its bound, no `-0` or unsafe integer, plain JSON data members
+  only. `canonicalizeStorageRequest` and `createStorageRequestSha256` are now derived from it, so a
+  consumer that admits requests and the control plane that digests them apply one set of acceptance
+  rules instead of each keeping an aligned copy. The input is never mutated, the returned request
+  is fresh, and a body that is not a storage request is refused with `platform.StorageContractError`
+  whose message names the failing member.
+- Add `data.validateSparkSwarmNodeHeartbeatRequest`, `data.validateSparkMetricsSampleRequest` and
+  `data.validateSparkActionResultRequest`, so all four Spark Swarm routes are judged by the
+  contract that owns their shapes instead of by member checks a consumer keeps beside them. Each
+  reads the exact key set, the sender's `protocol` offer and the reporter's identity, then names
+  every refused member of its payload — a heartbeat's metrics and runtime description down to each
+  described serve.zone service, a sample's observations and optional network rates, and an action
+  result whose status is one a node can report, never `pending`. They answer in the same
+  `Promise<string[]>` shape as `validateSparkSwarmObservationRequest`, refuse an accessor instead
+  of running it, and neither authenticate a node nor act on the body.
+
 ## 2026-09-18 - 32.2.0
 
 ### Features

package/dist_ts/00_commitinfo_data.js

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

package/dist_ts/data/clusternode.d.ts

@@ -288,6 +288,27 @@ export declare const computeSwarmManagerSnapshotDigest: (swarmClusterIdArg: stri
 export declare const validateSparkSwarmObservation: (observationArg: unknown) => Promise<string[]>;
 export declare const validateSparkSwarmObservationRequest: (requestArg: unknown) => Promise<string[]>;
 export declare const validateSparkSwarmObservationResponse: (responseArg: unknown, expectedRequestArg: ISparkSwarmObservationRequest) => Promise<string[]>;
+/**
+ * Spark -> Cloudly body for `sparkSwarmNodeContracts.heartbeat.endpoint`.
+ *
+ * Stated here beside the shape it judges, so the server that reads the beat and the node that
+ * writes it apply one set of acceptance rules; a reader that kept its own member checks would
+ * decide on its own which beats exist.
+ *
+ * Every Spark route validator answers the same way — one string per refused member, empty for an
+ * admissible body, and the same `(body) => Promise<string[]>` signature, so a server can hold the
+ * four routes in one table.
+ */
+export declare const validateSparkSwarmNodeHeartbeatRequest: (requestArg: unknown) => Promise<string[]>;
+/** Spark -> Cloudly body for `sparkSwarmNodeContracts.metricsSample.endpoint`. */
+export declare const validateSparkMetricsSampleRequest: (requestArg: unknown) => Promise<string[]>;
+/**
+ * Spark -> Cloudly body for `sparkSwarmNodeContracts.actionResult.endpoint`.
+ *
+ * `pending` is the one status a node never reports: an action it has not started has no result to
+ * post, and a server that accepted one would reopen an action it already handed out.
+ */
+export declare const validateSparkActionResultRequest: (requestArg: unknown) => Promise<string[]>;
 export declare const createClusterRuntimeTargetSetDigestInput: (targetSetArg: IClusterRuntimeTargetSetReady) => string;
 export declare const computeClusterRuntimeTargetSetDigest: (targetSetArg: IClusterRuntimeTargetSetReady) => Promise<TSha256Digest>;
 export declare const validateClusterRuntimeTargetSet: (targetSetArg: unknown) => Promise<string[]>;

package/dist_ts/data/clusternode.js

@@ -1,7 +1,7 @@
 import * as plugins from '../plugins.js';
 import { protocolRefusalHttpStatus, validateProtocolOfferOn } from '../protocol.js';
 import { canonicalizeStrictJson, createCanonicalJsonSha256Hex, } from '../private/canonicaljson.js';
-import { hasExactKeys } from '../private/dataproperties.js';
+import { hasExactKeys, readDataElements, readDataProperties, } from '../private/dataproperties.js';
 /**
  * The Swarm-era Spark runtime's own routes.
  *
@@ -286,6 +286,25 @@ export const validateSparkSwarmObservation = async (observationArg) => {
         return ['Spark Swarm observation must be safely inspectable'];
     }
 };
+/**
+ * Which node is reporting, in the two members every Spark route body carries.
+ *
+ * All four routes authenticate the same reporter from the same pair, so the rule lives here: a
+ * copy per route is how one route ends up admitting a bearer another refuses.
+ */
+const validateSparkReporterIdentity = (requestArg, labelArg) => {
+    const errors = [];
+    if (!isRuntimeIdentifier(requestArg.nodeId)) {
+        errors.push(`${labelArg} nodeId must be canonical`);
+    }
+    if (typeof requestArg.nodeToken !== 'string'
+        || requestArg.nodeToken.length < 1
+        || requestArg.nodeToken.length > 512
+        || requestArg.nodeToken.trim() !== requestArg.nodeToken) {
+        errors.push(`${labelArg} nodeToken must be a bounded opaque token`);
+    }
+    return errors;
+};
 export const validateSparkSwarmObservationRequest = async (requestArg) => {
     try {
         if (!isRuntimeRecord(requestArg)
@@ -300,15 +319,7 @@ export const validateSparkSwarmObservationRequest = async (requestArg) => {
         }
         const errors = validateProtocolOfferOn(requestArg, 'Spark Swarm observation request protocol');
         errors.push(...await validateSparkSwarmObservation(requestArg.observation));
-        if (!isRuntimeIdentifier(requestArg.nodeId)) {
-            errors.push('Spark Swarm observation request nodeId must be canonical');
-        }
-        if (typeof requestArg.nodeToken !== 'string'
-            || requestArg.nodeToken.length < 1
-            || requestArg.nodeToken.length > 512
-            || requestArg.nodeToken.trim() !== requestArg.nodeToken) {
-            errors.push('Spark Swarm observation request nodeToken must be a bounded opaque token');
-        }
+        errors.push(...validateSparkReporterIdentity(requestArg, 'Spark Swarm observation request'));
         return errors;
     }
     catch {
@@ -389,6 +400,329 @@ export const validateSparkSwarmObservationResponse = async (responseArg, expecte
         return ['Spark Swarm observation response must be safely inspectable'];
     }
 };
+/** A runtime description or a service name: bounded, and free of bytes JSON text cannot carry. */
+const maximumSparkRuntimeTextLength = 512;
+/** An operator-facing message, which may hold line breaks but is still bounded. */
+const maximumSparkMessageTextLength = 2048;
+/** `sparkSwarmNodeContracts.actionResult` states what a server keeps of an action's output. */
+const maximumSparkActionResultTextLength = 4000;
+/**
+ * The route's own byte bound refuses an oversized runtime description first; this stops an
+ * in-process caller from making the validator walk a list no route could have delivered.
+ */
+const maximumSparkRuntimeServices = 64;
+const sparkCloudlyConnectionStatuses = new Set([
+    'not-configured',
+    'connecting',
+    'connected',
+    'failed',
+]);
+const sparkNodeModes = new Set(['cloudly', 'coreflow-node']);
+const sparkActionResultStatuses = new Set([
+    'running',
+    'succeeded',
+    'failed',
+]);
+const isBoundedText = (valueArg, maximumLengthArg = maximumSparkRuntimeTextLength) => (typeof valueArg === 'string'
+    && valueArg.length > 0
+    && valueArg.length <= maximumLengthArg
+    && !/[\u0000-\u001f\u007f]/u.test(valueArg));
+/** Message text a node reports: line breaks and tabs are its content, other control bytes are not. */
+const isBoundedMessageText = (valueArg, maximumLengthArg) => (typeof valueArg === 'string'
+    && valueArg.length <= maximumLengthArg
+    && !/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/u.test(valueArg));
+const isNonNegativeNumber = (valueArg, maximumArg = Number.MAX_SAFE_INTEGER) => (typeof valueArg === 'number'
+    && Number.isFinite(valueArg)
+    && !Object.is(valueArg, -0)
+    && valueArg >= 0
+    && valueArg <= maximumArg);
+const isNonNegativeSafeInteger = (valueArg) => (Number.isSafeInteger(valueArg) && !Object.is(valueArg, -0) && valueArg >= 0);
+/**
+ * One level of a Spark body: own enumerable data properties only, then the exact key set.
+ *
+ * The heartbeat, metrics-sample and action-result bodies are judged member by member rather than
+ * as canonical bytes, because only the observation is digested and those three legitimately carry
+ * fractional CPU, memory and rate observations that the digest's integer encoding would refuse.
+ * What the canonical reader also gave — a body that cannot run code or answer differently on a
+ * second read — is kept here by copying the data properties away from the caller's object before
+ * any member is judged.
+ */
+const readSparkRecord = (valueArg, labelArg, requiredKeysArg, optionalKeysArg = []) => {
+    const record = readDataProperties(valueArg);
+    if (record === null) {
+        return { record: null, errors: [`${labelArg} must contain plain JSON data properties`] };
+    }
+    if (!hasExactKeys(record, requiredKeysArg, optionalKeysArg)) {
+        return { record: null, errors: [`${labelArg} must use its exact schema`] };
+    }
+    return { record, errors: [] };
+};
+/**
+ * The envelope a Spark route body states before its payload: the exact key set, the reporter's
+ * protocol offer read by name, and the reporter's identity — in that order, because a server
+ * answers an unreadable offer before it looks at anything the body claims about a node.
+ */
+const readSparkRouteEnvelope = (requestArg, labelArg, requiredKeysArg, optionalKeysArg = []) => {
+    const reading = readSparkRecord(requestArg, labelArg, requiredKeysArg, optionalKeysArg);
+    if (reading.record === null) {
+        return reading;
+    }
+    return {
+        record: reading.record,
+        errors: [
+            ...validateProtocolOfferOn(reading.record, `${labelArg} protocol`),
+            ...validateSparkReporterIdentity(reading.record, labelArg),
+        ],
+    };
+};
+/**
+ * One reason per member, collected rather than thrown.
+ *
+ * A Spark route answers a refusal before the node is authenticated, so the reporter only ever
+ * learns which member of its own body was wrong; naming that member is what lets an operator fix
+ * a node without reading the server's source.
+ */
+const createSparkFieldErrors = (recordArg, labelArg) => {
+    const errors = [];
+    return {
+        errors,
+        number: (keyArg, maximumArg) => {
+            if (!isNonNegativeNumber(recordArg[keyArg], maximumArg)) {
+                errors.push(`${labelArg} ${keyArg} must be a bounded non-negative number`);
+            }
+        },
+        percentage: (keyArg) => {
+            if (!isNonNegativeNumber(recordArg[keyArg], 100)) {
+                errors.push(`${labelArg} ${keyArg} must be a percentage between 0 and 100`);
+            }
+        },
+        count: (keyArg) => {
+            if (!isNonNegativeSafeInteger(recordArg[keyArg])) {
+                errors.push(`${labelArg} ${keyArg} must be a non-negative safe integer`);
+            }
+        },
+        instant: (keyArg) => {
+            if (!isPositiveSafeInteger(recordArg[keyArg])) {
+                errors.push(`${labelArg} ${keyArg} must be a positive safe integer timestamp`);
+            }
+        },
+        text: (keyArg) => {
+            if (!isBoundedText(recordArg[keyArg])) {
+                errors.push(`${labelArg} ${keyArg} must be bounded non-empty text`);
+            }
+        },
+        messageText: (keyArg, maximumLengthArg) => {
+            if (!isBoundedMessageText(recordArg[keyArg], maximumLengthArg)) {
+                errors.push(`${labelArg} ${keyArg} must be bounded message text`);
+            }
+        },
+        identifier: (keyArg) => {
+            if (!isRuntimeIdentifier(recordArg[keyArg])) {
+                errors.push(`${labelArg} ${keyArg} must be canonical`);
+            }
+        },
+        boolean: (keyArg) => {
+            if (typeof recordArg[keyArg] !== 'boolean') {
+                errors.push(`${labelArg} ${keyArg} must be a boolean`);
+            }
+        },
+        member: (keyArg, allowedArg) => {
+            if (!allowedArg.has(recordArg[keyArg])) {
+                errors.push(`${labelArg} ${keyArg} is outside the supported values`);
+            }
+        },
+        /** Runs `checkArg` only when the optional member is present at all. */
+        optional: (keyArg, checkArg) => {
+            if (recordArg[keyArg] !== undefined) {
+                checkArg(keyArg);
+            }
+        },
+    };
+};
+const validateSparkNodeMetrics = (valueArg, labelArg) => {
+    const reading = readSparkRecord(valueArg, labelArg, [
+        'cpuUsagePercent',
+        'memoryUsedMB',
+        'memoryAvailableMB',
+        'diskUsedGB',
+        'diskAvailableGB',
+        'containerCount',
+        'timestamp',
+    ]);
+    if (reading.record === null) {
+        return reading.errors;
+    }
+    const field = createSparkFieldErrors(reading.record, labelArg);
+    field.percentage('cpuUsagePercent');
+    field.number('memoryUsedMB');
+    field.number('memoryAvailableMB');
+    field.number('diskUsedGB');
+    field.number('diskAvailableGB');
+    field.count('containerCount');
+    field.instant('timestamp');
+    return field.errors;
+};
+const validateNodeMetricsSample = (valueArg, labelArg) => {
+    const reading = readSparkRecord(valueArg, labelArg, ['timestamp', 'cpuUsagePercent', 'memoryUsedMB', 'memoryAvailableMB'], ['networkRxBytesPerSec', 'networkTxBytesPerSec']);
+    if (reading.record === null) {
+        return reading.errors;
+    }
+    const field = createSparkFieldErrors(reading.record, labelArg);
+    field.instant('timestamp');
+    field.percentage('cpuUsagePercent');
+    field.number('memoryUsedMB');
+    field.number('memoryAvailableMB');
+    field.optional('networkRxBytesPerSec', field.number);
+    field.optional('networkTxBytesPerSec', field.number);
+    return field.errors;
+};
+const validateServeZoneServiceRuntimeInfo = (valueArg, labelArg) => {
+    const reading = readSparkRecord(valueArg, labelArg, ['name', 'running', 'checkedAt'], [
+        'serviceId',
+        'image',
+        'desiredImage',
+        'imageVersion',
+        'runningImageId',
+        'runningTaskCount',
+        'updatedAt',
+        'error',
+    ]);
+    if (reading.record === null) {
+        return reading.errors;
+    }
+    const field = createSparkFieldErrors(reading.record, labelArg);
+    field.text('name');
+    field.boolean('running');
+    field.instant('checkedAt');
+    field.optional('serviceId', field.text);
+    field.optional('image', field.text);
+    field.optional('desiredImage', field.text);
+    field.optional('imageVersion', field.text);
+    field.optional('runningImageId', field.text);
+    field.optional('runningTaskCount', field.count);
+    field.optional('updatedAt', field.instant);
+    field.optional('error', (keyArg) => field.messageText(keyArg, maximumSparkMessageTextLength));
+    return field.errors;
+};
+const validateSparkNodeRuntimeInfo = (valueArg, labelArg) => {
+    const reading = readSparkRecord(valueArg, labelArg, [
+        'runtime',
+        'nodeId',
+        'platform',
+        'arch',
+        'sparkVersion',
+        'cloudlyConnectionStatus',
+        'dockerAvailable',
+        'checkedAt',
+    ], [
+        'mode',
+        'hostname',
+        'osRelease',
+        'cloudlyUrl',
+        'swarmNodeId',
+        'serveZoneServices',
+        'lastError',
+    ]);
+    if (reading.record === null) {
+        return reading.errors;
+    }
+    const runtimeInfo = reading.record;
+    const field = createSparkFieldErrors(runtimeInfo, labelArg);
+    if (runtimeInfo.runtime !== 'spark') {
+        field.errors.push(`${labelArg} runtime must be spark`);
+    }
+    field.identifier('nodeId');
+    field.text('platform');
+    field.text('arch');
+    field.text('sparkVersion');
+    field.member('cloudlyConnectionStatus', sparkCloudlyConnectionStatuses);
+    field.boolean('dockerAvailable');
+    field.instant('checkedAt');
+    field.optional('mode', (keyArg) => field.member(keyArg, sparkNodeModes));
+    field.optional('hostname', field.text);
+    field.optional('osRelease', field.text);
+    field.optional('cloudlyUrl', field.text);
+    field.optional('swarmNodeId', field.identifier);
+    field.optional('lastError', (keyArg) => field.messageText(keyArg, maximumSparkMessageTextLength));
+    if (runtimeInfo.serveZoneServices !== undefined) {
+        const services = readDataElements(runtimeInfo.serveZoneServices, maximumSparkRuntimeServices);
+        if (services === null) {
+            field.errors.push(`${labelArg} serveZoneServices must be a bounded list of at most `
+                + `${maximumSparkRuntimeServices} described services`);
+        }
+        else {
+            services.forEach((serviceArg, indexArg) => {
+                field.errors.push(...validateServeZoneServiceRuntimeInfo(serviceArg, `${labelArg} serveZoneServices[${indexArg}]`));
+            });
+        }
+    }
+    return field.errors;
+};
+/**
+ * Spark -> Cloudly body for `sparkSwarmNodeContracts.heartbeat.endpoint`.
+ *
+ * Stated here beside the shape it judges, so the server that reads the beat and the node that
+ * writes it apply one set of acceptance rules; a reader that kept its own member checks would
+ * decide on its own which beats exist.
+ *
+ * Every Spark route validator answers the same way — one string per refused member, empty for an
+ * admissible body, and the same `(body) => Promise<string[]>` signature, so a server can hold the
+ * four routes in one table.
+ */
+export const validateSparkSwarmNodeHeartbeatRequest = async (requestArg) => {
+    const label = 'Spark Swarm node heartbeat request';
+    try {
+        const envelope = readSparkRouteEnvelope(requestArg, label, ['nodeId', 'nodeToken', 'protocol', 'metrics', 'runtimeInfo']);
+        if (envelope.record === null) {
+            return envelope.errors;
+        }
+        envelope.errors.push(...validateSparkNodeMetrics(envelope.record.metrics, `${label} metrics`));
+        envelope.errors.push(...validateSparkNodeRuntimeInfo(envelope.record.runtimeInfo, `${label} runtimeInfo`));
+        return envelope.errors;
+    }
+    catch {
+        return [`${label} must be safely inspectable`];
+    }
+};
+/** Spark -> Cloudly body for `sparkSwarmNodeContracts.metricsSample.endpoint`. */
+export const validateSparkMetricsSampleRequest = async (requestArg) => {
+    const label = 'Spark metrics sample request';
+    try {
+        const envelope = readSparkRouteEnvelope(requestArg, label, ['nodeId', 'nodeToken', 'protocol', 'sample']);
+        if (envelope.record === null) {
+            return envelope.errors;
+        }
+        envelope.errors.push(...validateNodeMetricsSample(envelope.record.sample, `${label} sample`));
+        return envelope.errors;
+    }
+    catch {
+        return [`${label} must be safely inspectable`];
+    }
+};
+/**
+ * Spark -> Cloudly body for `sparkSwarmNodeContracts.actionResult.endpoint`.
+ *
+ * `pending` is the one status a node never reports: an action it has not started has no result to
+ * post, and a server that accepted one would reopen an action it already handed out.
+ */
+export const validateSparkActionResultRequest = async (requestArg) => {
+    const label = 'Spark action result request';
+    try {
+        const envelope = readSparkRouteEnvelope(requestArg, label, ['nodeId', 'nodeToken', 'protocol', 'actionId', 'status'], ['resultText']);
+        if (envelope.record === null) {
+            return envelope.errors;
+        }
+        const field = createSparkFieldErrors(envelope.record, label);
+        field.identifier('actionId');
+        field.member('status', sparkActionResultStatuses);
+        field.optional('resultText', (keyArg) => field.messageText(keyArg, maximumSparkActionResultTextLength));
+        envelope.errors.push(...field.errors);
+        return envelope.errors;
+    }
+    catch {
+        return [`${label} must be safely inspectable`];
+    }
+};
 /**
  * The exact five members of a target that the set digest is taken over.
  *
@@ -571,4 +905,4 @@ export const validateClusterNodeCorestore = (valueArg, pathArg = 'cluster node c
     }
     return errors;
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"clusternode.js","sourceRoot":"","sources":["../../ts/data/clusternode.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"clusternode.js","sourceRoot":"","sources":["../../ts/data/clusternode.ts"],"names":[],"mappings":"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"}

package/dist_ts/platform/storage.d.ts

@@ -1,3 +1,4 @@
+import type { TAppStoreStorageRequest } from '../appstore/types.js';
 import type { TSecretManagementScope } from '../data/secret.js';
 /**
  * Backend-neutral storage vocabulary shared by App Store manifests, control
@@ -187,6 +188,24 @@ export type TResolvedStorageBinding = IResolvedFilesystemStorageBinding | IResol
 export declare class StorageContractError extends Error {
     constructor(reasonArg: string);
 }
+/**
+ * The one judgement of what a storage request is: the request read against its exact schema and
+ * returned in its contract shape — required members present, optional members carried only when
+ * the request declares them, and every value within the bounds an adapter can fulfil.
+ *
+ * A control plane that admits requests, a fulfillment adapter that provisions them, and an App
+ * Store front end that assembles them all have to agree on the same acceptance rules; a second
+ * copy of them anywhere is a second answer to which requests exist, and the digest one side issues
+ * would name a request the other never accepted. `canonicalizeStorageRequest` and
+ * `createStorageRequestSha256` are derived from this function rather than the other way round, so
+ * a consumer that needs the judged request itself does not have to re-parse its own canonical
+ * bytes.
+ *
+ * The returned request is a fresh value; the input is never read again after normalization and
+ * never mutated. Anything that is not a storage request is refused with `StorageContractError`,
+ * whose message names the failing field so a consumer can map it to its own status vocabulary.
+ */
+export declare const normalizeStorageRequest: (valueArg: unknown) => TAppStoreStorageRequest;
 /**
  * The exact bytes a storage request's digest is taken over: the request normalized to its contract
  * shape, written as strict canonical JSON — keys in UTF-16 code-unit order, no whitespace, no

package/dist_ts/platform/storage.js

@@ -16,7 +16,27 @@ export class StorageContractError extends Error {
 const fail = (reasonArg) => {
     throw new StorageContractError(reasonArg);
 };
-const { normalizeStorageRequest } = createStorageContractReaders(fail);
+const { normalizeStorageRequest: readStorageRequest } = createStorageContractReaders(fail);
+/**
+ * The one judgement of what a storage request is: the request read against its exact schema and
+ * returned in its contract shape — required members present, optional members carried only when
+ * the request declares them, and every value within the bounds an adapter can fulfil.
+ *
+ * A control plane that admits requests, a fulfillment adapter that provisions them, and an App
+ * Store front end that assembles them all have to agree on the same acceptance rules; a second
+ * copy of them anywhere is a second answer to which requests exist, and the digest one side issues
+ * would name a request the other never accepted. `canonicalizeStorageRequest` and
+ * `createStorageRequestSha256` are derived from this function rather than the other way round, so
+ * a consumer that needs the judged request itself does not have to re-parse its own canonical
+ * bytes.
+ *
+ * The returned request is a fresh value; the input is never read again after normalization and
+ * never mutated. Anything that is not a storage request is refused with `StorageContractError`,
+ * whose message names the failing field so a consumer can map it to its own status vocabulary.
+ */
+export const normalizeStorageRequest = (valueArg) => {
+    return readStorageRequest(valueArg, 'storage request');
+};
 /**
  * The exact bytes a storage request's digest is taken over: the request normalized to its contract
  * shape, written as strict canonical JSON — keys in UTF-16 code-unit order, no whitespace, no
@@ -26,7 +46,7 @@ const { normalizeStorageRequest } = createStorageContractReaders(fail);
  * unjudged body would name a request no adapter could fulfil.
  */
 export const canonicalizeStorageRequest = (valueArg) => {
-    return canonicalizeStrictJson(normalizeStorageRequest(valueArg, 'storage request'), fail);
+    return canonicalizeStrictJson(normalizeStorageRequest(valueArg), fail);
 };
 /**
  * The storage request digest: bare lowercase hex SHA-256 over the canonical request, with no
@@ -41,4 +61,4 @@ export const createStorageRequestSha256 = async (valueArg) => {
     return createCanonicalJsonSha256Hex(canonicalizeStorageRequest(valueArg), fail);
 };
 export { storageRequestCanonicalDigestGoldenVectors, } from './storage.golden.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmFnZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL3BsYXRmb3JtL3N0b3JhZ2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUNMLHNCQUFzQixFQUN0Qiw0QkFBNEIsR0FDN0IsTUFBTSw2QkFBNkIsQ0FBQztBQUNyQyxPQUFPLEVBQUUsNEJBQTRCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQVE3RTs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxnQ0FBZ0MsR0FBRztJQUM5QyxhQUFhLEVBQUUsZUFBZTtDQUN0QixDQUFDO0FBaU9YLE1BQU0sT0FBTyxvQkFBcUIsU0FBUSxLQUFLO0lBQzdDLFlBQW1CLFNBQWlCO1FBQ2xDLEtBQUssQ0FBQywyQkFBMkIsU0FBUyxFQUFFLENBQUMsQ0FBQztRQUM5QyxJQUFJLENBQUMsSUFBSSxHQUFHLHNCQUFzQixDQUFDO0lBQ3JDLENBQUM7Q0FDRjtBQUVELE1BQU0sSUFBSSxHQUFHLENBQUMsU0FBaUIsRUFBUyxFQUFFO0lBQ3hDLE1BQU0sSUFBSSxvQkFBb0IsQ0FBQyxTQUFTLENBQUMsQ0FBQztBQUM1QyxDQUFDLENBQUM7QUFFRixNQUFNLEVBQUUsdUJBQXVCLEVBQUUsR0FBRyw0QkFBNEIsQ0FBQyxJQUFJLENBQUMsQ0FBQztBQUV2RTs7Ozs7OztHQU9HO0FBQ0gsTUFBTSxDQUFDLE1BQU0sMEJBQTBCLEdBQUcsQ0FBQyxRQUFpQixFQUFVLEVBQUU7SUFDdEUsT0FBTyxzQkFBc0IsQ0FDM0IsdUJBQXVCLENBQUMsUUFBUSxFQUFFLGlCQUFpQixDQUFDLEVBQ3BELElBQUksQ0FDTCxDQUFDO0FBQ0osQ0FBQyxDQUFDO0FBRUY7Ozs7Ozs7O0dBUUc7QUFDSCxNQUFNLENBQUMsTUFBTSwwQkFBMEIsR0FBRyxLQUFLLEVBQzdDLFFBQWlCLEVBQ0EsRUFBRTtJQUNuQixPQUFPLDRCQUE0QixDQUFDLDBCQUEwQixDQUFDLFFBQVEsQ0FBQyxFQUFFLElBQUksQ0FBQyxDQUFDO0FBQ2xGLENBQUMsQ0FBQztBQUVGLE9BQU8sRUFDTCwwQ0FBMEMsR0FFM0MsTUFBTSxxQkFBcUIsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmFnZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL3BsYXRmb3JtL3N0b3JhZ2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUNMLHNCQUFzQixFQUN0Qiw0QkFBNEIsR0FDN0IsTUFBTSw2QkFBNkIsQ0FBQztBQUNyQyxPQUFPLEVBQUUsNEJBQTRCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQVE3RTs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxnQ0FBZ0MsR0FBRztJQUM5QyxhQUFhLEVBQUUsZUFBZTtDQUN0QixDQUFDO0FBaU9YLE1BQU0sT0FBTyxvQkFBcUIsU0FBUSxLQUFLO0lBQzdDLFlBQW1CLFNBQWlCO1FBQ2xDLEtBQUssQ0FBQywyQkFBMkIsU0FBUyxFQUFFLENBQUMsQ0FBQztRQUM5QyxJQUFJLENBQUMsSUFBSSxHQUFHLHNCQUFzQixDQUFDO0lBQ3JDLENBQUM7Q0FDRjtBQUVELE1BQU0sSUFBSSxHQUFHLENBQUMsU0FBaUIsRUFBUyxFQUFFO0lBQ3hDLE1BQU0sSUFBSSxvQkFBb0IsQ0FBQyxTQUFTLENBQUMsQ0FBQztBQUM1QyxDQUFDLENBQUM7QUFFRixNQUFNLEVBQUUsdUJBQXVCLEVBQUUsa0JBQWtCLEVBQUUsR0FDbkQsNEJBQTRCLENBQUMsSUFBSSxDQUFDLENBQUM7QUFFckM7Ozs7Ozs7Ozs7Ozs7Ozs7R0FnQkc7QUFDSCxNQUFNLENBQUMsTUFBTSx1QkFBdUIsR0FBRyxDQUNyQyxRQUFpQixFQUNRLEVBQUU7SUFDM0IsT0FBTyxrQkFBa0IsQ0FBQyxRQUFRLEVBQUUsaUJBQWlCLENBQUMsQ0FBQztBQUN6RCxDQUFDLENBQUM7QUFFRjs7Ozs7OztHQU9HO0FBQ0gsTUFBTSxDQUFDLE1BQU0sMEJBQTBCLEdBQUcsQ0FBQyxRQUFpQixFQUFVLEVBQUU7SUFDdEUsT0FBTyxzQkFBc0IsQ0FBQyx1QkFBdUIsQ0FBQyxRQUFRLENBQUMsRUFBRSxJQUFJLENBQUMsQ0FBQztBQUN6RSxDQUFDLENBQUM7QUFFRjs7Ozs7Ozs7R0FRRztBQUNILE1BQU0sQ0FBQyxNQUFNLDBCQUEwQixHQUFHLEtBQUssRUFDN0MsUUFBaUIsRUFDQSxFQUFFO0lBQ25CLE9BQU8sNEJBQTRCLENBQUMsMEJBQTBCLENBQUMsUUFBUSxDQUFDLEVBQUUsSUFBSSxDQUFDLENBQUM7QUFDbEYsQ0FBQyxDQUFDO0FBRUYsT0FBTyxFQUNMLDBDQUEwQyxHQUUzQyxNQUFNLHFCQUFxQixDQUFDIn0=

package/package.json

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

package/readme.md

@@ -146,6 +146,22 @@ rather than with this release. `ISparkSwarmNodeHeartbeatRequest` is now owned he
 so Cloudly and Spark no longer carry private copies of it, and every Swarm-era body
 — request and answer alike — carries `protocol` and is judged in the same order.
 
+Each of the four routes has its validator here, so a server never writes its own
+member checks: `data.validateSparkSwarmNodeHeartbeatRequest`,
+`data.validateSparkMetricsSampleRequest`, `data.validateSparkActionResultRequest`
+and `data.validateSparkSwarmObservationRequest`. All four answer the same way —
+one string per refused member, naming the member, and an empty list for an
+admissible body — so a route table can hold them side by side. They read the
+envelope first (exact key set, the sender's offer, then the reporter's identity),
+then the payload: a heartbeat's metrics and full runtime description including
+each described serve.zone service, a sample's four observations and optional
+network rates, and an action result whose status is one a node can actually
+report, never `pending`. Bodies are judged member by member rather than as
+canonical bytes, because only the observation is digested and the others carry
+fractional CPU, memory and rate observations; every level is copied away from the
+caller's object first, so an accessor is refused instead of run. None of them
+authenticates a node or acts on the body.
+
 Cloudly must authenticate the bearer against current Spark authority and fence
 credential generation and session epoch transactionally before recording host
 liveness. `ISparkNodeHeartbeatReceipt` contains only server-derived acceptance
@@ -1308,6 +1324,25 @@ around the request. A body that is not a storage request is refused with
 taken over. `platform.storageRequestCanonicalDigestGoldenVectors` states both
 for a filesystem request and for both object-storage deliveries.
 
+Which requests exist at all is stated by the same contract:
+
+```typescript
+const storageRequest = platform.normalizeStorageRequest(declaredRequest);
+```
+
+`platform.normalizeStorageRequest` reads a body against the exact request schema
+and returns the request in its contract shape — required members present,
+optional members carried only when declared, canonical environment keys, no
+empty `protection` block, no explicitly undefined member, no `-0` or unsafe
+integer, and plain JSON data members only. It is the value the other two
+functions are derived from: canonicalizing and digesting a request normalize it
+first, so a consumer that admits a request through this function and a control
+plane that digests it cannot accept different sets of requests. The input is
+never mutated and the returned request is a fresh object. A body that is not a
+storage request is refused with `platform.StorageContractError`, whose message
+names the failing member so a consumer can map the refusal to its own status
+vocabulary instead of restating the rules.
+
 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.2.0',
+  version: '32.3.0',
   description: 'Shared TypeScript interfaces and TypedRequest contracts for the serve.zone ecosystem.'
 }

package/ts/data/clusternode.ts

@@ -6,7 +6,11 @@ import {
   canonicalizeStrictJson,
   createCanonicalJsonSha256Hex,
 } from '../private/canonicaljson.js';
-import { hasExactKeys } from '../private/dataproperties.js';
+import {
+  hasExactKeys,
+  readDataElements,
+  readDataProperties,
+} from '../private/dataproperties.js';
 
 export interface IClusterNodeMetrics {
   cpuUsagePercent: number;
@@ -610,6 +614,29 @@ export const validateSparkSwarmObservation = async (
   }
 };
 
+/**
+ * Which node is reporting, in the two members every Spark route body carries.
+ *
+ * All four routes authenticate the same reporter from the same pair, so the rule lives here: a
+ * copy per route is how one route ends up admitting a bearer another refuses.
+ */
+const validateSparkReporterIdentity = (
+  requestArg: Record<string, unknown>,
+  labelArg: string,
+): string[] => {
+  const errors: string[] = [];
+  if (!isRuntimeIdentifier(requestArg.nodeId)) {
+    errors.push(`${labelArg} nodeId must be canonical`);
+  }
+  if (typeof requestArg.nodeToken !== 'string'
+    || requestArg.nodeToken.length < 1
+    || requestArg.nodeToken.length > 512
+    || requestArg.nodeToken.trim() !== requestArg.nodeToken) {
+    errors.push(`${labelArg} nodeToken must be a bounded opaque token`);
+  }
+  return errors;
+};
+
 export const validateSparkSwarmObservationRequest = async (
   requestArg: unknown,
 ): Promise<string[]> => {
@@ -632,15 +659,10 @@ export const validateSparkSwarmObservationRequest = async (
       'Spark Swarm observation request protocol',
     );
     errors.push(...await validateSparkSwarmObservation(requestArg.observation));
-    if (!isRuntimeIdentifier(requestArg.nodeId)) {
-      errors.push('Spark Swarm observation request nodeId must be canonical');
-    }
-    if (typeof requestArg.nodeToken !== 'string'
-      || requestArg.nodeToken.length < 1
-      || requestArg.nodeToken.length > 512
-      || requestArg.nodeToken.trim() !== requestArg.nodeToken) {
-      errors.push('Spark Swarm observation request nodeToken must be a bounded opaque token');
-    }
+    errors.push(...validateSparkReporterIdentity(
+      requestArg,
+      'Spark Swarm observation request',
+    ));
     return errors;
   } catch {
     return ['Spark Swarm observation request must be safely inspectable'];
@@ -735,6 +757,431 @@ export const validateSparkSwarmObservationResponse = async (
   }
 };
 
+/** A runtime description or a service name: bounded, and free of bytes JSON text cannot carry. */
+const maximumSparkRuntimeTextLength = 512;
+/** An operator-facing message, which may hold line breaks but is still bounded. */
+const maximumSparkMessageTextLength = 2048;
+/** `sparkSwarmNodeContracts.actionResult` states what a server keeps of an action's output. */
+const maximumSparkActionResultTextLength = 4000;
+/**
+ * The route's own byte bound refuses an oversized runtime description first; this stops an
+ * in-process caller from making the validator walk a list no route could have delivered.
+ */
+const maximumSparkRuntimeServices = 64;
+
+const sparkCloudlyConnectionStatuses = new Set<TSparkCloudlyConnectionStatus>([
+  'not-configured',
+  'connecting',
+  'connected',
+  'failed',
+]);
+const sparkNodeModes = new Set<TSparkNodeMode>(['cloudly', 'coreflow-node']);
+const sparkActionResultStatuses = new Set<TNodeActionStatus>([
+  'running',
+  'succeeded',
+  'failed',
+]);
+
+const isBoundedText = (
+  valueArg: unknown,
+  maximumLengthArg = maximumSparkRuntimeTextLength,
+): valueArg is string => (
+  typeof valueArg === 'string'
+  && valueArg.length > 0
+  && valueArg.length <= maximumLengthArg
+  && !/[\u0000-\u001f\u007f]/u.test(valueArg)
+);
+
+/** Message text a node reports: line breaks and tabs are its content, other control bytes are not. */
+const isBoundedMessageText = (
+  valueArg: unknown,
+  maximumLengthArg: number,
+): valueArg is string => (
+  typeof valueArg === 'string'
+  && valueArg.length <= maximumLengthArg
+  && !/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/u.test(valueArg)
+);
+
+const isNonNegativeNumber = (
+  valueArg: unknown,
+  maximumArg = Number.MAX_SAFE_INTEGER,
+): valueArg is number => (
+  typeof valueArg === 'number'
+  && Number.isFinite(valueArg)
+  && !Object.is(valueArg, -0)
+  && valueArg >= 0
+  && valueArg <= maximumArg
+);
+
+const isNonNegativeSafeInteger = (valueArg: unknown): valueArg is number => (
+  Number.isSafeInteger(valueArg) && !Object.is(valueArg, -0) && (valueArg as number) >= 0
+);
+
+/** A record a Spark body states, detached from the caller's object, or `null` with the reason. */
+interface ISparkRecordReading {
+  record: Record<string, unknown> | null;
+  errors: string[];
+}
+
+/**
+ * One level of a Spark body: own enumerable data properties only, then the exact key set.
+ *
+ * The heartbeat, metrics-sample and action-result bodies are judged member by member rather than
+ * as canonical bytes, because only the observation is digested and those three legitimately carry
+ * fractional CPU, memory and rate observations that the digest's integer encoding would refuse.
+ * What the canonical reader also gave — a body that cannot run code or answer differently on a
+ * second read — is kept here by copying the data properties away from the caller's object before
+ * any member is judged.
+ */
+const readSparkRecord = (
+  valueArg: unknown,
+  labelArg: string,
+  requiredKeysArg: readonly string[],
+  optionalKeysArg: readonly string[] = [],
+): ISparkRecordReading => {
+  const record = readDataProperties(valueArg);
+  if (record === null) {
+    return { record: null, errors: [`${labelArg} must contain plain JSON data properties`] };
+  }
+  if (!hasExactKeys(record, requiredKeysArg, optionalKeysArg)) {
+    return { record: null, errors: [`${labelArg} must use its exact schema`] };
+  }
+  return { record, errors: [] };
+};
+
+/**
+ * The envelope a Spark route body states before its payload: the exact key set, the reporter's
+ * protocol offer read by name, and the reporter's identity — in that order, because a server
+ * answers an unreadable offer before it looks at anything the body claims about a node.
+ */
+const readSparkRouteEnvelope = (
+  requestArg: unknown,
+  labelArg: string,
+  requiredKeysArg: readonly string[],
+  optionalKeysArg: readonly string[] = [],
+): ISparkRecordReading => {
+  const reading = readSparkRecord(requestArg, labelArg, requiredKeysArg, optionalKeysArg);
+  if (reading.record === null) {
+    return reading;
+  }
+  return {
+    record: reading.record,
+    errors: [
+      ...validateProtocolOfferOn(reading.record, `${labelArg} protocol`),
+      ...validateSparkReporterIdentity(reading.record, labelArg),
+    ],
+  };
+};
+
+/**
+ * One reason per member, collected rather than thrown.
+ *
+ * A Spark route answers a refusal before the node is authenticated, so the reporter only ever
+ * learns which member of its own body was wrong; naming that member is what lets an operator fix
+ * a node without reading the server's source.
+ */
+const createSparkFieldErrors = (
+  recordArg: Record<string, unknown>,
+  labelArg: string,
+) => {
+  const errors: string[] = [];
+  return {
+    errors,
+    number: (keyArg: string, maximumArg?: number): void => {
+      if (!isNonNegativeNumber(recordArg[keyArg], maximumArg)) {
+        errors.push(`${labelArg} ${keyArg} must be a bounded non-negative number`);
+      }
+    },
+    percentage: (keyArg: string): void => {
+      if (!isNonNegativeNumber(recordArg[keyArg], 100)) {
+        errors.push(`${labelArg} ${keyArg} must be a percentage between 0 and 100`);
+      }
+    },
+    count: (keyArg: string): void => {
+      if (!isNonNegativeSafeInteger(recordArg[keyArg])) {
+        errors.push(`${labelArg} ${keyArg} must be a non-negative safe integer`);
+      }
+    },
+    instant: (keyArg: string): void => {
+      if (!isPositiveSafeInteger(recordArg[keyArg])) {
+        errors.push(`${labelArg} ${keyArg} must be a positive safe integer timestamp`);
+      }
+    },
+    text: (keyArg: string): void => {
+      if (!isBoundedText(recordArg[keyArg])) {
+        errors.push(`${labelArg} ${keyArg} must be bounded non-empty text`);
+      }
+    },
+    messageText: (keyArg: string, maximumLengthArg: number): void => {
+      if (!isBoundedMessageText(recordArg[keyArg], maximumLengthArg)) {
+        errors.push(`${labelArg} ${keyArg} must be bounded message text`);
+      }
+    },
+    identifier: (keyArg: string): void => {
+      if (!isRuntimeIdentifier(recordArg[keyArg])) {
+        errors.push(`${labelArg} ${keyArg} must be canonical`);
+      }
+    },
+    boolean: (keyArg: string): void => {
+      if (typeof recordArg[keyArg] !== 'boolean') {
+        errors.push(`${labelArg} ${keyArg} must be a boolean`);
+      }
+    },
+    member: <TMember extends string>(keyArg: string, allowedArg: ReadonlySet<TMember>): void => {
+      if (!allowedArg.has(recordArg[keyArg] as TMember)) {
+        errors.push(`${labelArg} ${keyArg} is outside the supported values`);
+      }
+    },
+    /** Runs `checkArg` only when the optional member is present at all. */
+    optional: (keyArg: string, checkArg: (keyArg: string) => void): void => {
+      if (recordArg[keyArg] !== undefined) {
+        checkArg(keyArg);
+      }
+    },
+  };
+};
+
+const validateSparkNodeMetrics = (valueArg: unknown, labelArg: string): string[] => {
+  const reading = readSparkRecord(valueArg, labelArg, [
+    'cpuUsagePercent',
+    'memoryUsedMB',
+    'memoryAvailableMB',
+    'diskUsedGB',
+    'diskAvailableGB',
+    'containerCount',
+    'timestamp',
+  ]);
+  if (reading.record === null) {
+    return reading.errors;
+  }
+  const field = createSparkFieldErrors(reading.record, labelArg);
+  field.percentage('cpuUsagePercent');
+  field.number('memoryUsedMB');
+  field.number('memoryAvailableMB');
+  field.number('diskUsedGB');
+  field.number('diskAvailableGB');
+  field.count('containerCount');
+  field.instant('timestamp');
+  return field.errors;
+};
+
+const validateNodeMetricsSample = (valueArg: unknown, labelArg: string): string[] => {
+  const reading = readSparkRecord(
+    valueArg,
+    labelArg,
+    ['timestamp', 'cpuUsagePercent', 'memoryUsedMB', 'memoryAvailableMB'],
+    ['networkRxBytesPerSec', 'networkTxBytesPerSec'],
+  );
+  if (reading.record === null) {
+    return reading.errors;
+  }
+  const field = createSparkFieldErrors(reading.record, labelArg);
+  field.instant('timestamp');
+  field.percentage('cpuUsagePercent');
+  field.number('memoryUsedMB');
+  field.number('memoryAvailableMB');
+  field.optional('networkRxBytesPerSec', field.number);
+  field.optional('networkTxBytesPerSec', field.number);
+  return field.errors;
+};
+
+const validateServeZoneServiceRuntimeInfo = (
+  valueArg: unknown,
+  labelArg: string,
+): string[] => {
+  const reading = readSparkRecord(
+    valueArg,
+    labelArg,
+    ['name', 'running', 'checkedAt'],
+    [
+      'serviceId',
+      'image',
+      'desiredImage',
+      'imageVersion',
+      'runningImageId',
+      'runningTaskCount',
+      'updatedAt',
+      'error',
+    ],
+  );
+  if (reading.record === null) {
+    return reading.errors;
+  }
+  const field = createSparkFieldErrors(reading.record, labelArg);
+  field.text('name');
+  field.boolean('running');
+  field.instant('checkedAt');
+  field.optional('serviceId', field.text);
+  field.optional('image', field.text);
+  field.optional('desiredImage', field.text);
+  field.optional('imageVersion', field.text);
+  field.optional('runningImageId', field.text);
+  field.optional('runningTaskCount', field.count);
+  field.optional('updatedAt', field.instant);
+  field.optional('error', (keyArg) => field.messageText(keyArg, maximumSparkMessageTextLength));
+  return field.errors;
+};
+
+const validateSparkNodeRuntimeInfo = (valueArg: unknown, labelArg: string): string[] => {
+  const reading = readSparkRecord(
+    valueArg,
+    labelArg,
+    [
+      'runtime',
+      'nodeId',
+      'platform',
+      'arch',
+      'sparkVersion',
+      'cloudlyConnectionStatus',
+      'dockerAvailable',
+      'checkedAt',
+    ],
+    [
+      'mode',
+      'hostname',
+      'osRelease',
+      'cloudlyUrl',
+      'swarmNodeId',
+      'serveZoneServices',
+      'lastError',
+    ],
+  );
+  if (reading.record === null) {
+    return reading.errors;
+  }
+  const runtimeInfo = reading.record;
+  const field = createSparkFieldErrors(runtimeInfo, labelArg);
+  if (runtimeInfo.runtime !== 'spark') {
+    field.errors.push(`${labelArg} runtime must be spark`);
+  }
+  field.identifier('nodeId');
+  field.text('platform');
+  field.text('arch');
+  field.text('sparkVersion');
+  field.member('cloudlyConnectionStatus', sparkCloudlyConnectionStatuses);
+  field.boolean('dockerAvailable');
+  field.instant('checkedAt');
+  field.optional('mode', (keyArg) => field.member(keyArg, sparkNodeModes));
+  field.optional('hostname', field.text);
+  field.optional('osRelease', field.text);
+  field.optional('cloudlyUrl', field.text);
+  field.optional('swarmNodeId', field.identifier);
+  field.optional('lastError', (keyArg) => field.messageText(keyArg, maximumSparkMessageTextLength));
+  if (runtimeInfo.serveZoneServices !== undefined) {
+    const services = readDataElements(runtimeInfo.serveZoneServices, maximumSparkRuntimeServices);
+    if (services === null) {
+      field.errors.push(
+        `${labelArg} serveZoneServices must be a bounded list of at most `
+        + `${maximumSparkRuntimeServices} described services`,
+      );
+    } else {
+      services.forEach((serviceArg, indexArg) => {
+        field.errors.push(...validateServeZoneServiceRuntimeInfo(
+          serviceArg,
+          `${labelArg} serveZoneServices[${indexArg}]`,
+        ));
+      });
+    }
+  }
+  return field.errors;
+};
+
+/**
+ * Spark -> Cloudly body for `sparkSwarmNodeContracts.heartbeat.endpoint`.
+ *
+ * Stated here beside the shape it judges, so the server that reads the beat and the node that
+ * writes it apply one set of acceptance rules; a reader that kept its own member checks would
+ * decide on its own which beats exist.
+ *
+ * Every Spark route validator answers the same way — one string per refused member, empty for an
+ * admissible body, and the same `(body) => Promise<string[]>` signature, so a server can hold the
+ * four routes in one table.
+ */
+export const validateSparkSwarmNodeHeartbeatRequest = async (
+  requestArg: unknown,
+): Promise<string[]> => {
+  const label = 'Spark Swarm node heartbeat request';
+  try {
+    const envelope = readSparkRouteEnvelope(
+      requestArg,
+      label,
+      ['nodeId', 'nodeToken', 'protocol', 'metrics', 'runtimeInfo'],
+    );
+    if (envelope.record === null) {
+      return envelope.errors;
+    }
+    envelope.errors.push(...validateSparkNodeMetrics(
+      envelope.record.metrics,
+      `${label} metrics`,
+    ));
+    envelope.errors.push(...validateSparkNodeRuntimeInfo(
+      envelope.record.runtimeInfo,
+      `${label} runtimeInfo`,
+    ));
+    return envelope.errors;
+  } catch {
+    return [`${label} must be safely inspectable`];
+  }
+};
+
+/** Spark -> Cloudly body for `sparkSwarmNodeContracts.metricsSample.endpoint`. */
+export const validateSparkMetricsSampleRequest = async (
+  requestArg: unknown,
+): Promise<string[]> => {
+  const label = 'Spark metrics sample request';
+  try {
+    const envelope = readSparkRouteEnvelope(
+      requestArg,
+      label,
+      ['nodeId', 'nodeToken', 'protocol', 'sample'],
+    );
+    if (envelope.record === null) {
+      return envelope.errors;
+    }
+    envelope.errors.push(...validateNodeMetricsSample(
+      envelope.record.sample,
+      `${label} sample`,
+    ));
+    return envelope.errors;
+  } catch {
+    return [`${label} must be safely inspectable`];
+  }
+};
+
+/**
+ * Spark -> Cloudly body for `sparkSwarmNodeContracts.actionResult.endpoint`.
+ *
+ * `pending` is the one status a node never reports: an action it has not started has no result to
+ * post, and a server that accepted one would reopen an action it already handed out.
+ */
+export const validateSparkActionResultRequest = async (
+  requestArg: unknown,
+): Promise<string[]> => {
+  const label = 'Spark action result request';
+  try {
+    const envelope = readSparkRouteEnvelope(
+      requestArg,
+      label,
+      ['nodeId', 'nodeToken', 'protocol', 'actionId', 'status'],
+      ['resultText'],
+    );
+    if (envelope.record === null) {
+      return envelope.errors;
+    }
+    const field = createSparkFieldErrors(envelope.record, label);
+    field.identifier('actionId');
+    field.member('status', sparkActionResultStatuses);
+    field.optional('resultText', (keyArg) => field.messageText(
+      keyArg,
+      maximumSparkActionResultTextLength,
+    ));
+    envelope.errors.push(...field.errors);
+    return envelope.errors;
+  } catch {
+    return [`${label} must be safely inspectable`];
+  }
+};
+
 /**
  * The exact five members of a target that the set digest is taken over.
  *

package/ts/platform/storage.ts

@@ -1,3 +1,4 @@
+import type { TAppStoreStorageRequest } from '../appstore/types.js';
 import type { TSecretManagementScope } from '../data/secret.js';
 import {
   canonicalizeStrictJson,
@@ -253,7 +254,31 @@ const fail = (reasonArg: string): never => {
   throw new StorageContractError(reasonArg);
 };
 
-const { normalizeStorageRequest } = createStorageContractReaders(fail);
+const { normalizeStorageRequest: readStorageRequest } =
+  createStorageContractReaders(fail);
+
+/**
+ * The one judgement of what a storage request is: the request read against its exact schema and
+ * returned in its contract shape — required members present, optional members carried only when
+ * the request declares them, and every value within the bounds an adapter can fulfil.
+ *
+ * A control plane that admits requests, a fulfillment adapter that provisions them, and an App
+ * Store front end that assembles them all have to agree on the same acceptance rules; a second
+ * copy of them anywhere is a second answer to which requests exist, and the digest one side issues
+ * would name a request the other never accepted. `canonicalizeStorageRequest` and
+ * `createStorageRequestSha256` are derived from this function rather than the other way round, so
+ * a consumer that needs the judged request itself does not have to re-parse its own canonical
+ * bytes.
+ *
+ * The returned request is a fresh value; the input is never read again after normalization and
+ * never mutated. Anything that is not a storage request is refused with `StorageContractError`,
+ * whose message names the failing field so a consumer can map it to its own status vocabulary.
+ */
+export const normalizeStorageRequest = (
+  valueArg: unknown,
+): TAppStoreStorageRequest => {
+  return readStorageRequest(valueArg, 'storage request');
+};
 
 /**
  * The exact bytes a storage request's digest is taken over: the request normalized to its contract
@@ -264,10 +289,7 @@ const { normalizeStorageRequest } = createStorageContractReaders(fail);
  * unjudged body would name a request no adapter could fulfil.
  */
 export const canonicalizeStorageRequest = (valueArg: unknown): string => {
-  return canonicalizeStrictJson(
-    normalizeStorageRequest(valueArg, 'storage request'),
-    fail,
-  );
+  return canonicalizeStrictJson(normalizeStorageRequest(valueArg), fail);
 };
 
 /**