@serve.zone/interfaces 32.69.0 → 32.71.0

package/changelog.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 2026-11-05 - 32.71.0
+
+### Features
+
+- All-or-nothing backup restore refusals (AGL-1501, Linus 2026-11-05 ruling): `data.backupRestoreRefusalNames` freezes the three reasons an in-place restore is refused before it writes anything: `restore-snapshot-unavailable` (`missing`, a non-empty list of `data.IBackupRestoreMissingSnapshot`: `snapshotId`, `capability` (`data.TBackupResourceType`) and an optional `resourceName`), `restore-preflight-unsupported` (the node's Corestore offers no restore check) and `restore-relay-contract-behind` (`relayInterfacesVersion`, a release version or `null`, below `minimumInterfacesVersion`). `data.TBackupRestoreRefusal` is discriminated by `name`; `data.validateBackupRestoreRefusal`, `data.isBackupRestoreRefusal` and `data.readBackupRestoreRefusal` judge untrusted `errorData` against each exact schema, and `data.buildBackupRestoreSnapshotUnavailableRefusal`, `data.buildBackupRestorePreflightUnsupportedRefusal` and `data.buildBackupRestoreRelayContractBehindRefusal` build them; bounds are `data.backupRestoreRefusalContract`. A restore event (`data.IBackupRestoreEvent`) adds the status `refused`, meaning nothing was written, with its `refusal`; `data.validateBackupRestoreEvent` judges only `status` and `refusal`, requiring `refusal` exactly when the status is `refused`. Additive: every existing restore event stays valid, including the unjudged `resourceTypes` and null `errorText` Cloudly already stores. Spec: `test.backuprestorerefusal`.
+
+## 2026-11-05 - 32.70.0
+
+### Features
+
+- Partial restore of an incomplete backup (Linus 2026-11-05 ruling): a `failed` backup record can name its failure's kind, `data.IBackupRecord.failure` (`data.TBackupFailure`): `incomplete` with `uncaptured`, each resource its service declares that the backup did not capture (`data.TBackupUncapturedResource`: a volume by mount path, always with reason `volume-capture-unavailable`, or a binding by id, always with reason `binding-not-snapshotted`; `data.TBackupUncapturedReason` names either), or `archive-unreadable`. `requests.backup.IReq_Any_Cloudly_RestoreServiceBackup` takes `confirmPartialRestore`, which an administrator sets to restore what an `incomplete` backup captured: `resourceTypes` is required and names only captured types, nothing in `uncaptured` is restored, so the service then holds data from two points in time, and the backup stays `failed`; it is refused for any other backup. `data.readPartialRestoreResourceTypes` answers the types such a restore may name: those the backup holds a snapshot of, except `volume` (a `volume` snapshot captures no service volume) and the type of any uncaptured resource; none for any other backup. A restore event (`data.IBackupRestoreEvent`) states the `resourceTypes` it was limited to and `partial` for such a restore. Additive: no validator reads these shapes. Spec: `test.backuppartialrestore`.
+
 ## 2026-11-05 - 32.69.0
 
 ### Features

package/dist_ts/00_commitinfo_data.js

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

package/dist_ts/data/backup.d.ts

@@ -1,3 +1,4 @@
+import type { TBackupRestoreRefusal } from './backuprestorerefusal.js';
 import type { ICorestoreDatabaseAllocationReference } from './corestore.js';
 export type TBackupStatus = 'pending' | 'running' | 'replicating' | 'replicated' | 'ready' | 'failed' | 'restoring' | 'restored';
 export type TBackupTrigger = 'manual' | 'scheduled';
@@ -48,10 +49,62 @@ export interface IBackupReplicationResult {
     totalSize: number;
     completedAt: number;
 }
+/**
+ * One resource a service declares that a backup of it did not capture, with why; each kind of
+ * resource has its own reason.
+ *
+ * `volume-capture-unavailable`: a service volume is a node-local storage claim on its Pallet node,
+ * which no relay can capture yet; a `volume` snapshot is a Corestore Docker volume and captures no
+ * service volume. `binding-not-snapshotted`: the backup holds no snapshot of the Corestore resource
+ * the binding names.
+ */
+export type TBackupUncapturedResource = {
+    type: 'volume';
+    mountPath: string;
+    reason: 'volume-capture-unavailable';
+} | {
+    type: 'database' | 'objectstorage';
+    bindingId: string;
+    reason: 'binding-not-snapshotted';
+};
+/** Why a resource a service declares is not in one of its backups (`TBackupUncapturedResource`). */
+export type TBackupUncapturedReason = TBackupUncapturedResource['reason'];
+/**
+ * The named kind of a `failed` backup's failure; a failure without one is named only in `errorText`.
+ *
+ * `incomplete`: the backup did not capture every resource its service declares, and `uncaptured`
+ * names each one it missed. What it did capture is restored only by a partial restore an
+ * administrator confirms (`IReq_Any_Cloudly_RestoreServiceBackup` `confirmPartialRestore`), which
+ * restores none of `uncaptured`, and the backup stays `failed`.
+ * `archive-unreadable`: its stored archive is missing or damaged, so it restores nothing.
+ */
+export type TBackupFailure = {
+    kind: 'incomplete';
+    uncaptured: TBackupUncapturedResource[];
+} | {
+    kind: 'archive-unreadable';
+};
+/**
+ * One restore of a backup, appended to its `restoreHistory`; `validateBackupRestoreEvent` judges its
+ * `status` and `refusal`.
+ *
+ * `refused`: the restore was refused before it wrote anything (`refusal` says why), so the service
+ * keeps the data it had. `failed`: it failed after it began writing.
+ */
 export interface IBackupRestoreEvent {
+    /** When the restore ended, or when it was refused. */
     restoredAt: number;
-    status: 'restored' | 'failed';
+    status: 'restored' | 'failed' | 'refused';
     errorText?: string;
+    /** The resource types the restore was limited to; absent when it restored every snapshot. */
+    resourceTypes?: TBackupResourceType[];
+    /**
+     * A confirmed partial restore of an `incomplete` backup: it restored only `resourceTypes`, and
+     * none of the backup's `failure.uncaptured`.
+     */
+    partial?: true;
+    /** Why a `refused` restore wrote nothing; present exactly when `status` is `refused`. */
+    refusal?: TBackupRestoreRefusal;
 }
 /**
  * Durable retention hold owned by one isolated restore. An entry is active
@@ -88,6 +141,8 @@ export interface IBackupRecord {
     completedAt?: number;
     requestedBy?: string;
     errorText?: string;
+    /** The named kind of a `failed` backup's failure (`TBackupFailure`). */
+    failure?: TBackupFailure;
     restoreHistory?: IBackupRestoreEvent[];
     /**
      * Authoritative isolated-restore holds. Cloudly atomically appends the
@@ -97,6 +152,17 @@ export interface IBackupRecord {
     restoreHolds?: IBackupRestoreHold[];
     tags?: Record<string, string>;
 }
+/**
+ * The resource types a partial restore of a backup may name (`confirmPartialRestore`).
+ *
+ * For a `failed` backup whose failure is `incomplete`: every type it holds a snapshot of, except
+ * `volume` (a `volume` snapshot is a Corestore Docker volume and captures no service volume) and the
+ * type of any resource it did not capture, so a partial restore never restores a snapshot standing
+ * for a resource the backup missed. For every other backup: none. Database before object storage.
+ */
+export declare const readPartialRestoreResourceTypes: (backupArg: Pick<IBackupRecord, 'status' | 'failure'> & {
+    snapshots: ReadonlyArray<Pick<TBackupSnapshot, 'type'>>;
+}) => Array<Exclude<TBackupResourceType, 'volume'>>;
 /** Retention policy understood by containerarchive prune. */
 export interface IArchiveRetentionPolicy {
     keepLast?: number;

package/dist_ts/data/backup.js

@@ -1,2 +1,16 @@
-export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFja3VwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvZGF0YS9iYWNrdXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9
+/**
+ * The resource types a partial restore of a backup may name (`confirmPartialRestore`).
+ *
+ * For a `failed` backup whose failure is `incomplete`: every type it holds a snapshot of, except
+ * `volume` (a `volume` snapshot is a Corestore Docker volume and captures no service volume) and the
+ * type of any resource it did not capture, so a partial restore never restores a snapshot standing
+ * for a resource the backup missed. For every other backup: none. Database before object storage.
+ */
+export const readPartialRestoreResourceTypes = (backupArg) => {
+    const failure = backupArg.failure;
+    if (backupArg.status !== 'failed' || failure?.kind !== 'incomplete')
+        return [];
+    const uncapturedTypes = new Set(failure.uncaptured.map((resourceArg) => resourceArg.type));
+    return ['database', 'objectstorage'].filter((typeArg) => (!uncapturedTypes.has(typeArg) && backupArg.snapshots.some((snapshotArg) => snapshotArg.type === typeArg)));
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFja3VwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvZGF0YS9iYWNrdXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBK0tBOzs7Ozs7O0dBT0c7QUFDSCxNQUFNLENBQUMsTUFBTSwrQkFBK0IsR0FBRyxDQUM3QyxTQUFrSCxFQUNuRSxFQUFFO0lBQ2pELE1BQU0sT0FBTyxHQUFHLFNBQVMsQ0FBQyxPQUFPLENBQUM7SUFDbEMsSUFBSSxTQUFTLENBQUMsTUFBTSxLQUFLLFFBQVEsSUFBSSxPQUFPLEVBQUUsSUFBSSxLQUFLLFlBQVk7UUFBRSxPQUFPLEVBQUUsQ0FBQztJQUMvRSxNQUFNLGVBQWUsR0FBRyxJQUFJLEdBQUcsQ0FBc0IsT0FBTyxDQUFDLFVBQVUsQ0FBQyxHQUFHLENBQUMsQ0FBQyxXQUFXLEVBQUUsRUFBRSxDQUFDLFdBQVcsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO0lBQ2hILE9BQVEsQ0FBQyxVQUFVLEVBQUUsZUFBZSxDQUFXLENBQUMsTUFBTSxDQUFDLENBQUMsT0FBTyxFQUFFLEVBQUUsQ0FBQyxDQUNsRSxDQUFDLGVBQWUsQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLElBQUksU0FBUyxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxXQUFXLEVBQUUsRUFBRSxDQUFDLFdBQVcsQ0FBQyxJQUFJLEtBQUssT0FBTyxDQUFDLENBQ3pHLENBQUMsQ0FBQztBQUNMLENBQUMsQ0FBQyJ9

package/dist_ts/data/backuprestorerefusal.d.ts

@@ -0,0 +1,85 @@
+import type { TBackupResourceType } from './backup.js';
+/**
+ * Why an in-place restore of a backup (`IReq_Any_Cloudly_RestoreServiceBackup`) was refused before
+ * it wrote anything. A restore is all-or-nothing: Corestore checks that it can read every snapshot
+ * the restore names before it replaces any data, and Cloudly dispatches the restore only to a relay
+ * whose contract carries that check. A refusal therefore always means nothing was written; the
+ * service keeps the data it had.
+ *
+ * - `restore-snapshot-unavailable`: the node's Corestore cannot read one or more snapshots the
+ *   restore names; `missing` names each of them.
+ * - `restore-preflight-unsupported`: the node's Corestore does not offer the restore check (a
+ *   Corestore built before it answers the check route with HTTP 404), so it cannot prove the
+ *   restore would be whole and nothing is restored.
+ * - `restore-relay-contract-behind`: the cluster relay speaks an interfaces release below the one
+ *   that carries the restore check, so Cloudly does not dispatch the restore; the relay states
+ *   `relayInterfacesVersion` (`null` when it stated none) and the restore needs
+ *   `minimumInterfacesVersion`.
+ *
+ * It travels as `TypedResponseError.errorData` of a refused restore and is recorded as the
+ * `refusal` of the backup's `refused` restore event (`IBackupRestoreEvent`). Each refusal is
+ * exactly its schema: `readBackupRestoreRefusal` refuses any other member, so a producer never adds
+ * one without gating it on the reader's interfaces version.
+ */
+export declare const backupRestoreRefusalNames: readonly ["restore-snapshot-unavailable", "restore-preflight-unsupported", "restore-relay-contract-behind"];
+export type TBackupRestoreRefusalName = typeof backupRestoreRefusalNames[number];
+export declare const backupRestoreRefusalContract: Readonly<{
+    /** At most this many snapshots are named in one `restore-snapshot-unavailable`. */
+    readonly maximumMissingSnapshots: 256;
+    /** A snapshot id or resource name is printable ASCII without spaces, at most this long. */
+    readonly maximumNameLength: 255;
+}>;
+/** One snapshot a restore names that the node's Corestore cannot read. */
+export interface IBackupRestoreMissingSnapshot {
+    snapshotId: string;
+    /** The snapshot's resource type (`TBackupSnapshot['type']`). */
+    capability: TBackupResourceType;
+    /** The Corestore resource of a database or object-storage snapshot, when it is known. */
+    resourceName?: string;
+}
+export interface IBackupRestoreSnapshotUnavailableRefusal {
+    name: 'restore-snapshot-unavailable';
+    /** Non-empty; each snapshot once. */
+    missing: IBackupRestoreMissingSnapshot[];
+}
+export interface IBackupRestorePreflightUnsupportedRefusal {
+    name: 'restore-preflight-unsupported';
+}
+export interface IBackupRestoreRelayContractBehindRefusal {
+    name: 'restore-relay-contract-behind';
+    /** The interfaces release the relay speaks, or `null` when it stated none. */
+    relayInterfacesVersion: string | null;
+    /** The lowest interfaces release a relay must speak to carry a restore. */
+    minimumInterfacesVersion: string;
+}
+/** A refused restore, discriminated by `name` (`backupRestoreRefusalNames`). */
+export type TBackupRestoreRefusal = IBackupRestoreSnapshotUnavailableRefusal | IBackupRestorePreflightUnsupportedRefusal | IBackupRestoreRelayContractBehindRefusal;
+/** Validates one restore refusal against its exact schema and names every reason it is refused. */
+export declare const validateBackupRestoreRefusal: (valueArg: unknown, pathArg?: string) => string[];
+/** Whether a value is exactly one restore refusal. */
+export declare const isBackupRestoreRefusal: (valueArg: unknown) => valueArg is TBackupRestoreRefusal;
+/**
+ * The restore refusal inside an error payload or a stored restore event, as an inert frozen copy,
+ * or `null` when the value is not exactly one. It reads own data properties only, so a refusal
+ * read here carries nothing that runs.
+ */
+export declare const readBackupRestoreRefusal: (valueArg: unknown) => TBackupRestoreRefusal | null;
+/** `restore-snapshot-unavailable` naming each snapshot the node's Corestore cannot read. */
+export declare const buildBackupRestoreSnapshotUnavailableRefusal: (missingArg: IBackupRestoreMissingSnapshot[]) => IBackupRestoreSnapshotUnavailableRefusal;
+/** `restore-preflight-unsupported`: the node's Corestore offers no restore check. */
+export declare const buildBackupRestorePreflightUnsupportedRefusal: () => IBackupRestorePreflightUnsupportedRefusal;
+/**
+ * `restore-relay-contract-behind`: the relay speaks an interfaces release below the minimum.
+ *
+ * Throws when a stated version is not a release version or is not below the minimum, so a caller
+ * passes `null` for a relay whose stated version it cannot read.
+ */
+export declare const buildBackupRestoreRelayContractBehindRefusal: (relayInterfacesVersionArg: string | null, minimumInterfacesVersionArg: string) => IBackupRestoreRelayContractBehindRefusal;
+/**
+ * Validates what this contract adds to a restore event of a backup's `restoreHistory` and names
+ * every reason it is refused: `status` is `restored`, `failed` or `refused`, and `refusal` is
+ * present exactly when `status` is `refused`, as one restore refusal. Every other member is left as
+ * it was written (records Cloudly already stores keep any `restoredAt`, `errorText`, `partial` and
+ * `resourceTypes` they hold), so every stored event stays valid.
+ */
+export declare const validateBackupRestoreEvent: (valueArg: unknown, pathArg?: string) => string[];

package/dist_ts/data/backuprestorerefusal.js

@@ -0,0 +1,228 @@
+import { hasExactKeys, readDataElements, readDataProperties, readExactDataRecord, } from '../private/dataproperties.js';
+import { compareReleaseVersions, parseReleaseVersion } from './releaseversion.js';
+/**
+ * Why an in-place restore of a backup (`IReq_Any_Cloudly_RestoreServiceBackup`) was refused before
+ * it wrote anything. A restore is all-or-nothing: Corestore checks that it can read every snapshot
+ * the restore names before it replaces any data, and Cloudly dispatches the restore only to a relay
+ * whose contract carries that check. A refusal therefore always means nothing was written; the
+ * service keeps the data it had.
+ *
+ * - `restore-snapshot-unavailable`: the node's Corestore cannot read one or more snapshots the
+ *   restore names; `missing` names each of them.
+ * - `restore-preflight-unsupported`: the node's Corestore does not offer the restore check (a
+ *   Corestore built before it answers the check route with HTTP 404), so it cannot prove the
+ *   restore would be whole and nothing is restored.
+ * - `restore-relay-contract-behind`: the cluster relay speaks an interfaces release below the one
+ *   that carries the restore check, so Cloudly does not dispatch the restore; the relay states
+ *   `relayInterfacesVersion` (`null` when it stated none) and the restore needs
+ *   `minimumInterfacesVersion`.
+ *
+ * It travels as `TypedResponseError.errorData` of a refused restore and is recorded as the
+ * `refusal` of the backup's `refused` restore event (`IBackupRestoreEvent`). Each refusal is
+ * exactly its schema: `readBackupRestoreRefusal` refuses any other member, so a producer never adds
+ * one without gating it on the reader's interfaces version.
+ */
+export const backupRestoreRefusalNames = Object.freeze([
+    'restore-snapshot-unavailable',
+    'restore-preflight-unsupported',
+    'restore-relay-contract-behind',
+]);
+export const backupRestoreRefusalContract = Object.freeze({
+    /** At most this many snapshots are named in one `restore-snapshot-unavailable`. */
+    maximumMissingSnapshots: 256,
+    /** A snapshot id or resource name is printable ASCII without spaces, at most this long. */
+    maximumNameLength: 255,
+});
+/** Every resource type, keyed so a new `TBackupResourceType` member fails to compile here. */
+const backupResourceTypeKeys = Object.freeze({
+    volume: true,
+    database: true,
+    objectstorage: true,
+});
+const isBackupResourceType = (valueArg) => (typeof valueArg === 'string' && Object.hasOwn(backupResourceTypeKeys, valueArg));
+const printableNamePattern = /^[\x21-\x7e]+$/;
+const isRestoreName = (valueArg) => (typeof valueArg === 'string'
+    && valueArg.length <= backupRestoreRefusalContract.maximumNameLength
+    && printableNamePattern.test(valueArg));
+const nameRule = 'must be printable ASCII without spaces, at most '
+    + `${backupRestoreRefusalContract.maximumNameLength} characters`;
+const isRefusalName = (valueArg) => (typeof valueArg === 'string'
+    && backupRestoreRefusalNames.includes(valueArg));
+const validateMissingSnapshot = (valueArg, pathArg) => {
+    const snapshot = readDataProperties(valueArg);
+    if (snapshot === null || !hasExactKeys(snapshot, ['snapshotId', 'capability'], ['resourceName'])) {
+        return [`${pathArg} must use its exact schema`];
+    }
+    const errors = [];
+    if (!isRestoreName(snapshot.snapshotId)) {
+        errors.push(`${pathArg}.snapshotId ${nameRule}`);
+    }
+    if (!isBackupResourceType(snapshot.capability)) {
+        errors.push(`${pathArg}.capability must be volume, database or objectstorage`);
+    }
+    if (Object.hasOwn(snapshot, 'resourceName') && !isRestoreName(snapshot.resourceName)) {
+        errors.push(`${pathArg}.resourceName ${nameRule}`);
+    }
+    return errors;
+};
+const validateMissingSnapshots = (valueArg, pathArg) => {
+    const elements = readDataElements(valueArg, backupRestoreRefusalContract.maximumMissingSnapshots);
+    if (elements === null) {
+        return [`${pathArg} must be a list of at most `
+                + `${backupRestoreRefusalContract.maximumMissingSnapshots} snapshots`];
+    }
+    if (elements.length === 0) {
+        return [`${pathArg} must name at least one snapshot`];
+    }
+    const errors = elements.flatMap((elementArg, indexArg) => (validateMissingSnapshot(elementArg, `${pathArg}[${indexArg}]`)));
+    if (errors.length > 0) {
+        return errors;
+    }
+    const snapshotIds = elements.map((elementArg) => elementArg.snapshotId);
+    if (new Set(snapshotIds).size !== snapshotIds.length) {
+        errors.push(`${pathArg} must name each snapshot once`);
+    }
+    return errors;
+};
+const validateRelayContractBehind = (refusalArg, pathArg) => {
+    const relay = refusalArg.relayInterfacesVersion === null
+        ? null
+        : parseReleaseVersion(refusalArg.relayInterfacesVersion);
+    const minimum = parseReleaseVersion(refusalArg.minimumInterfacesVersion);
+    const errors = [];
+    if (refusalArg.relayInterfacesVersion !== null && relay === null) {
+        errors.push(`${pathArg} relayInterfacesVersion must be a release version or null`);
+    }
+    if (minimum === null) {
+        errors.push(`${pathArg} minimumInterfacesVersion must be a release version`);
+    }
+    if (relay !== null && minimum !== null && compareReleaseVersions(relay, minimum) >= 0) {
+        errors.push(`${pathArg} relayInterfacesVersion must be below minimumInterfacesVersion`);
+    }
+    return errors;
+};
+/** The exact keys of each refusal. */
+const refusalKeys = Object.freeze({
+    'restore-snapshot-unavailable': Object.freeze(['name', 'missing']),
+    'restore-preflight-unsupported': Object.freeze(['name']),
+    'restore-relay-contract-behind': Object.freeze([
+        'name', 'relayInterfacesVersion', 'minimumInterfacesVersion',
+    ]),
+});
+/** Validates one restore refusal against its exact schema and names every reason it is refused. */
+export const validateBackupRestoreRefusal = (valueArg, pathArg = 'backup restore refusal') => {
+    const properties = readDataProperties(valueArg);
+    if (properties === null || !isRefusalName(properties.name)) {
+        return [`${pathArg} name must be one of ${backupRestoreRefusalNames.join(', ')}`];
+    }
+    const refusal = readExactDataRecord(valueArg, refusalKeys[properties.name]);
+    if (refusal === null) {
+        return [`${pathArg} must use the exact schema of ${properties.name}`];
+    }
+    switch (properties.name) {
+        case 'restore-snapshot-unavailable':
+            return validateMissingSnapshots(refusal.missing, `${pathArg} missing`);
+        case 'restore-preflight-unsupported':
+            return [];
+        case 'restore-relay-contract-behind':
+            return validateRelayContractBehind(refusal, pathArg);
+    }
+};
+/** Whether a value is exactly one restore refusal. */
+export const isBackupRestoreRefusal = (valueArg) => (validateBackupRestoreRefusal(valueArg).length === 0);
+const freezeMissingSnapshot = (snapshotArg) => Object.freeze({
+    snapshotId: snapshotArg.snapshotId,
+    capability: snapshotArg.capability,
+    ...(snapshotArg.resourceName === undefined ? {} : { resourceName: snapshotArg.resourceName }),
+});
+const copySnapshotUnavailableRefusal = (refusalArg) => {
+    const missing = refusalArg.missing.map(freezeMissingSnapshot);
+    Object.freeze(missing);
+    return Object.freeze({ name: refusalArg.name, missing });
+};
+const copyPreflightUnsupportedRefusal = (refusalArg) => Object.freeze({ name: refusalArg.name });
+const copyRelayContractBehindRefusal = (refusalArg) => Object.freeze({
+    name: refusalArg.name,
+    relayInterfacesVersion: refusalArg.relayInterfacesVersion,
+    minimumInterfacesVersion: refusalArg.minimumInterfacesVersion,
+});
+/** An inert frozen copy of a refusal that passed `validateBackupRestoreRefusal`. */
+const copyRefusal = (refusalArg) => {
+    switch (refusalArg.name) {
+        case 'restore-snapshot-unavailable':
+            return copySnapshotUnavailableRefusal(refusalArg);
+        case 'restore-preflight-unsupported':
+            return copyPreflightUnsupportedRefusal(refusalArg);
+        case 'restore-relay-contract-behind':
+            return copyRelayContractBehindRefusal(refusalArg);
+    }
+};
+/**
+ * The restore refusal inside an error payload or a stored restore event, as an inert frozen copy,
+ * or `null` when the value is not exactly one. It reads own data properties only, so a refusal
+ * read here carries nothing that runs.
+ */
+export const readBackupRestoreRefusal = (valueArg) => (
+// A value that passed holds own data properties of exactly the refusal's schema at every level,
+// so the copy reads the same data the validation judged.
+isBackupRestoreRefusal(valueArg) ? copyRefusal(valueArg) : null);
+/** The refusal a builder composed, unchanged, or an error naming every reason it is refused. */
+const requireRefusal = (refusalArg) => {
+    const errors = validateBackupRestoreRefusal(refusalArg);
+    if (errors.length > 0) {
+        throw new Error(errors.join('; '));
+    }
+    return refusalArg;
+};
+/** `restore-snapshot-unavailable` naming each snapshot the node's Corestore cannot read. */
+export const buildBackupRestoreSnapshotUnavailableRefusal = (missingArg) => copySnapshotUnavailableRefusal(requireRefusal({
+    name: 'restore-snapshot-unavailable',
+    missing: missingArg.map((snapshotArg) => ({ ...snapshotArg })),
+}));
+/** `restore-preflight-unsupported`: the node's Corestore offers no restore check. */
+export const buildBackupRestorePreflightUnsupportedRefusal = () => (copyPreflightUnsupportedRefusal(requireRefusal({ name: 'restore-preflight-unsupported' })));
+/**
+ * `restore-relay-contract-behind`: the relay speaks an interfaces release below the minimum.
+ *
+ * Throws when a stated version is not a release version or is not below the minimum, so a caller
+ * passes `null` for a relay whose stated version it cannot read.
+ */
+export const buildBackupRestoreRelayContractBehindRefusal = (relayInterfacesVersionArg, minimumInterfacesVersionArg) => copyRelayContractBehindRefusal(requireRefusal({
+    name: 'restore-relay-contract-behind',
+    relayInterfacesVersion: relayInterfacesVersionArg,
+    minimumInterfacesVersion: minimumInterfacesVersionArg,
+}));
+const restoreEventStatuses = Object.freeze([
+    'restored', 'failed', 'refused',
+]);
+/**
+ * Validates what this contract adds to a restore event of a backup's `restoreHistory` and names
+ * every reason it is refused: `status` is `restored`, `failed` or `refused`, and `refusal` is
+ * present exactly when `status` is `refused`, as one restore refusal. Every other member is left as
+ * it was written (records Cloudly already stores keep any `restoredAt`, `errorText`, `partial` and
+ * `resourceTypes` they hold), so every stored event stays valid.
+ */
+export const validateBackupRestoreEvent = (valueArg, pathArg = 'backup restore event') => {
+    const event = readDataProperties(valueArg);
+    if (event === null) {
+        return [`${pathArg} must be a plain record of data properties`];
+    }
+    const errors = [];
+    if (!restoreEventStatuses.includes(event.status)) {
+        errors.push(`${pathArg} status must be one of ${restoreEventStatuses.join(', ')}`);
+    }
+    const hasRefusal = Object.hasOwn(event, 'refusal');
+    if (event.status === 'refused') {
+        if (!hasRefusal) {
+            errors.push(`${pathArg} refusal is required when status is refused`);
+        }
+        else {
+            errors.push(...validateBackupRestoreRefusal(event.refusal, `${pathArg} refusal`));
+        }
+    }
+    else if (hasRefusal) {
+        errors.push(`${pathArg} refusal is allowed only when status is refused`);
+    }
+    return errors;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"backuprestorerefusal.js","sourceRoot":"","sources":["../../ts/data/backuprestorerefusal.ts"],"names":[],"mappings":"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"}

package/dist_ts/data/index.d.ts

@@ -75,6 +75,7 @@ export * from './secret.js';
 export * from './baremetal.js';
 export * from './baseos.js';
 export * from './backup.js';
+export * from './backuprestorerefusal.js';
 export * from './clusternode.js';
 export * from './clusternodehostname.js';
 export * from './settings.js';

package/dist_ts/data/index.js

@@ -70,6 +70,7 @@ export * from './secret.js';
 export * from './baremetal.js';
 export * from './baseos.js';
 export * from './backup.js';
+export * from './backuprestorerefusal.js';
 export * from './clusternode.js';
 export * from './clusternodehostname.js';
 export * from './settings.js';
@@ -91,4 +92,4 @@ export * from './user.js';
 export * from './version.js';
 export * from './webpush.js';
 export * from './workloadreplicaidentity.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9kYXRhL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxnQ0FBZ0MsQ0FBQztBQUMvQyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyx3QkFBd0IsQ0FBQztBQUl2QyxPQUFPLEVBQUUsMEJBQTBCLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUc5RCxPQUFPLEVBQUUscUNBQXFDLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUVwRixPQUFPLEVBQUUsMENBQTBDLEVBQUUsMENBQTBDLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUMxSSxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyxnQ0FBZ0MsQ0FBQztBQUMvQyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLFdBQVcsQ0FBQztBQUMxQixjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLDhCQUE4QixDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/requests/backup.d.ts

@@ -45,6 +45,14 @@ export interface IReq_Any_Cloudly_RestoreServiceBackup extends plugins.typedrequ
         backupId: string;
         clear?: boolean;
         resourceTypes?: Array<TBackupSnapshot['type']>;
+        /**
+         * Must be `true` to restore a `failed` backup whose failure is `incomplete`, and is refused for
+         * any other backup. Such a restore restores what the backup captured: `resourceTypes` is
+         * required and names only types it captured, none of the resources it did not capture
+         * (`failure.uncaptured`) is restored, so the service then holds data from two points in time,
+         * and the backup stays `failed`.
+         */
+        confirmPartialRestore?: boolean;
     };
     response: {
         backup: IBackupRecord;

package/package.json

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

package/ts/00_commitinfo_data.ts

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

package/ts/data/backup.ts

@@ -1,3 +1,4 @@
+import type { TBackupRestoreRefusal } from './backuprestorerefusal.js';
 import type { ICorestoreDatabaseAllocationReference } from './corestore.js';
 
 export type TBackupStatus =
@@ -72,10 +73,56 @@ export interface IBackupReplicationResult {
   completedAt: number;
 }
 
+/**
+ * One resource a service declares that a backup of it did not capture, with why; each kind of
+ * resource has its own reason.
+ *
+ * `volume-capture-unavailable`: a service volume is a node-local storage claim on its Pallet node,
+ * which no relay can capture yet; a `volume` snapshot is a Corestore Docker volume and captures no
+ * service volume. `binding-not-snapshotted`: the backup holds no snapshot of the Corestore resource
+ * the binding names.
+ */
+export type TBackupUncapturedResource =
+  | { type: 'volume'; mountPath: string; reason: 'volume-capture-unavailable' }
+  | { type: 'database' | 'objectstorage'; bindingId: string; reason: 'binding-not-snapshotted' };
+
+/** Why a resource a service declares is not in one of its backups (`TBackupUncapturedResource`). */
+export type TBackupUncapturedReason = TBackupUncapturedResource['reason'];
+
+/**
+ * The named kind of a `failed` backup's failure; a failure without one is named only in `errorText`.
+ *
+ * `incomplete`: the backup did not capture every resource its service declares, and `uncaptured`
+ * names each one it missed. What it did capture is restored only by a partial restore an
+ * administrator confirms (`IReq_Any_Cloudly_RestoreServiceBackup` `confirmPartialRestore`), which
+ * restores none of `uncaptured`, and the backup stays `failed`.
+ * `archive-unreadable`: its stored archive is missing or damaged, so it restores nothing.
+ */
+export type TBackupFailure =
+  | { kind: 'incomplete'; uncaptured: TBackupUncapturedResource[] }
+  | { kind: 'archive-unreadable' };
+
+/**
+ * One restore of a backup, appended to its `restoreHistory`; `validateBackupRestoreEvent` judges its
+ * `status` and `refusal`.
+ *
+ * `refused`: the restore was refused before it wrote anything (`refusal` says why), so the service
+ * keeps the data it had. `failed`: it failed after it began writing.
+ */
 export interface IBackupRestoreEvent {
+  /** When the restore ended, or when it was refused. */
   restoredAt: number;
-  status: 'restored' | 'failed';
+  status: 'restored' | 'failed' | 'refused';
   errorText?: string;
+  /** The resource types the restore was limited to; absent when it restored every snapshot. */
+  resourceTypes?: TBackupResourceType[];
+  /**
+   * A confirmed partial restore of an `incomplete` backup: it restored only `resourceTypes`, and
+   * none of the backup's `failure.uncaptured`.
+   */
+  partial?: true;
+  /** Why a `refused` restore wrote nothing; present exactly when `status` is `refused`. */
+  refusal?: TBackupRestoreRefusal;
 }
 
 /**
@@ -114,6 +161,8 @@ export interface IBackupRecord {
   completedAt?: number;
   requestedBy?: string;
   errorText?: string;
+  /** The named kind of a `failed` backup's failure (`TBackupFailure`). */
+  failure?: TBackupFailure;
   restoreHistory?: IBackupRestoreEvent[];
   /**
    * Authoritative isolated-restore holds. Cloudly atomically appends the
@@ -124,6 +173,25 @@ export interface IBackupRecord {
   tags?: Record<string, string>;
 }
 
+/**
+ * The resource types a partial restore of a backup may name (`confirmPartialRestore`).
+ *
+ * For a `failed` backup whose failure is `incomplete`: every type it holds a snapshot of, except
+ * `volume` (a `volume` snapshot is a Corestore Docker volume and captures no service volume) and the
+ * type of any resource it did not capture, so a partial restore never restores a snapshot standing
+ * for a resource the backup missed. For every other backup: none. Database before object storage.
+ */
+export const readPartialRestoreResourceTypes = (
+  backupArg: Pick<IBackupRecord, 'status' | 'failure'> & { snapshots: ReadonlyArray<Pick<TBackupSnapshot, 'type'>> },
+): Array<Exclude<TBackupResourceType, 'volume'>> => {
+  const failure = backupArg.failure;
+  if (backupArg.status !== 'failed' || failure?.kind !== 'incomplete') return [];
+  const uncapturedTypes = new Set<TBackupResourceType>(failure.uncaptured.map((resourceArg) => resourceArg.type));
+  return (['database', 'objectstorage'] as const).filter((typeArg) => (
+    !uncapturedTypes.has(typeArg) && backupArg.snapshots.some((snapshotArg) => snapshotArg.type === typeArg)
+  ));
+};
+
 /** Retention policy understood by containerarchive prune. */
 export interface IArchiveRetentionPolicy {
   keepLast?: number;

package/ts/data/backuprestorerefusal.ts

@@ -0,0 +1,324 @@
+import type { IBackupRestoreEvent, TBackupResourceType } from './backup.js';
+import {
+  hasExactKeys, readDataElements, readDataProperties, readExactDataRecord,
+} from '../private/dataproperties.js';
+import { compareReleaseVersions, parseReleaseVersion } from './releaseversion.js';
+
+/**
+ * Why an in-place restore of a backup (`IReq_Any_Cloudly_RestoreServiceBackup`) was refused before
+ * it wrote anything. A restore is all-or-nothing: Corestore checks that it can read every snapshot
+ * the restore names before it replaces any data, and Cloudly dispatches the restore only to a relay
+ * whose contract carries that check. A refusal therefore always means nothing was written; the
+ * service keeps the data it had.
+ *
+ * - `restore-snapshot-unavailable`: the node's Corestore cannot read one or more snapshots the
+ *   restore names; `missing` names each of them.
+ * - `restore-preflight-unsupported`: the node's Corestore does not offer the restore check (a
+ *   Corestore built before it answers the check route with HTTP 404), so it cannot prove the
+ *   restore would be whole and nothing is restored.
+ * - `restore-relay-contract-behind`: the cluster relay speaks an interfaces release below the one
+ *   that carries the restore check, so Cloudly does not dispatch the restore; the relay states
+ *   `relayInterfacesVersion` (`null` when it stated none) and the restore needs
+ *   `minimumInterfacesVersion`.
+ *
+ * It travels as `TypedResponseError.errorData` of a refused restore and is recorded as the
+ * `refusal` of the backup's `refused` restore event (`IBackupRestoreEvent`). Each refusal is
+ * exactly its schema: `readBackupRestoreRefusal` refuses any other member, so a producer never adds
+ * one without gating it on the reader's interfaces version.
+ */
+export const backupRestoreRefusalNames = Object.freeze([
+  'restore-snapshot-unavailable',
+  'restore-preflight-unsupported',
+  'restore-relay-contract-behind',
+] as const);
+
+export type TBackupRestoreRefusalName = typeof backupRestoreRefusalNames[number];
+
+export const backupRestoreRefusalContract = Object.freeze({
+  /** At most this many snapshots are named in one `restore-snapshot-unavailable`. */
+  maximumMissingSnapshots: 256,
+  /** A snapshot id or resource name is printable ASCII without spaces, at most this long. */
+  maximumNameLength: 255,
+} as const);
+
+/** One snapshot a restore names that the node's Corestore cannot read. */
+export interface IBackupRestoreMissingSnapshot {
+  snapshotId: string;
+  /** The snapshot's resource type (`TBackupSnapshot['type']`). */
+  capability: TBackupResourceType;
+  /** The Corestore resource of a database or object-storage snapshot, when it is known. */
+  resourceName?: string;
+}
+
+export interface IBackupRestoreSnapshotUnavailableRefusal {
+  name: 'restore-snapshot-unavailable';
+  /** Non-empty; each snapshot once. */
+  missing: IBackupRestoreMissingSnapshot[];
+}
+
+export interface IBackupRestorePreflightUnsupportedRefusal {
+  name: 'restore-preflight-unsupported';
+}
+
+export interface IBackupRestoreRelayContractBehindRefusal {
+  name: 'restore-relay-contract-behind';
+  /** The interfaces release the relay speaks, or `null` when it stated none. */
+  relayInterfacesVersion: string | null;
+  /** The lowest interfaces release a relay must speak to carry a restore. */
+  minimumInterfacesVersion: string;
+}
+
+/** A refused restore, discriminated by `name` (`backupRestoreRefusalNames`). */
+export type TBackupRestoreRefusal =
+  | IBackupRestoreSnapshotUnavailableRefusal
+  | IBackupRestorePreflightUnsupportedRefusal
+  | IBackupRestoreRelayContractBehindRefusal;
+
+/** Every resource type, keyed so a new `TBackupResourceType` member fails to compile here. */
+const backupResourceTypeKeys: Readonly<Record<TBackupResourceType, true>> = Object.freeze({
+  volume: true,
+  database: true,
+  objectstorage: true,
+});
+
+const isBackupResourceType = (valueArg: unknown): valueArg is TBackupResourceType => (
+  typeof valueArg === 'string' && Object.hasOwn(backupResourceTypeKeys, valueArg)
+);
+
+const printableNamePattern = /^[\x21-\x7e]+$/;
+
+const isRestoreName = (valueArg: unknown): valueArg is string => (
+  typeof valueArg === 'string'
+  && valueArg.length <= backupRestoreRefusalContract.maximumNameLength
+  && printableNamePattern.test(valueArg)
+);
+
+const nameRule = 'must be printable ASCII without spaces, at most '
+  + `${backupRestoreRefusalContract.maximumNameLength} characters`;
+
+const isRefusalName = (valueArg: unknown): valueArg is TBackupRestoreRefusalName => (
+  typeof valueArg === 'string'
+  && (backupRestoreRefusalNames as readonly string[]).includes(valueArg)
+);
+
+const validateMissingSnapshot = (valueArg: unknown, pathArg: string): string[] => {
+  const snapshot = readDataProperties(valueArg);
+  if (snapshot === null || !hasExactKeys(snapshot, ['snapshotId', 'capability'], ['resourceName'])) {
+    return [`${pathArg} must use its exact schema`];
+  }
+  const errors: string[] = [];
+  if (!isRestoreName(snapshot.snapshotId)) {
+    errors.push(`${pathArg}.snapshotId ${nameRule}`);
+  }
+  if (!isBackupResourceType(snapshot.capability)) {
+    errors.push(`${pathArg}.capability must be volume, database or objectstorage`);
+  }
+  if (Object.hasOwn(snapshot, 'resourceName') && !isRestoreName(snapshot.resourceName)) {
+    errors.push(`${pathArg}.resourceName ${nameRule}`);
+  }
+  return errors;
+};
+
+const validateMissingSnapshots = (valueArg: unknown, pathArg: string): string[] => {
+  const elements = readDataElements(valueArg, backupRestoreRefusalContract.maximumMissingSnapshots);
+  if (elements === null) {
+    return [`${pathArg} must be a list of at most `
+      + `${backupRestoreRefusalContract.maximumMissingSnapshots} snapshots`];
+  }
+  if (elements.length === 0) {
+    return [`${pathArg} must name at least one snapshot`];
+  }
+  const errors = elements.flatMap((elementArg, indexArg) => (
+    validateMissingSnapshot(elementArg, `${pathArg}[${indexArg}]`)
+  ));
+  if (errors.length > 0) {
+    return errors;
+  }
+  const snapshotIds = elements.map((elementArg) => (elementArg as IBackupRestoreMissingSnapshot).snapshotId);
+  if (new Set(snapshotIds).size !== snapshotIds.length) {
+    errors.push(`${pathArg} must name each snapshot once`);
+  }
+  return errors;
+};
+
+const validateRelayContractBehind = (
+  refusalArg: Record<string, unknown>,
+  pathArg: string,
+): string[] => {
+  const relay = refusalArg.relayInterfacesVersion === null
+    ? null
+    : parseReleaseVersion(refusalArg.relayInterfacesVersion);
+  const minimum = parseReleaseVersion(refusalArg.minimumInterfacesVersion);
+  const errors: string[] = [];
+  if (refusalArg.relayInterfacesVersion !== null && relay === null) {
+    errors.push(`${pathArg} relayInterfacesVersion must be a release version or null`);
+  }
+  if (minimum === null) {
+    errors.push(`${pathArg} minimumInterfacesVersion must be a release version`);
+  }
+  if (relay !== null && minimum !== null && compareReleaseVersions(relay, minimum) >= 0) {
+    errors.push(`${pathArg} relayInterfacesVersion must be below minimumInterfacesVersion`);
+  }
+  return errors;
+};
+
+/** The exact keys of each refusal. */
+const refusalKeys: Readonly<Record<TBackupRestoreRefusalName, readonly string[]>> = Object.freeze({
+  'restore-snapshot-unavailable': Object.freeze(['name', 'missing']),
+  'restore-preflight-unsupported': Object.freeze(['name']),
+  'restore-relay-contract-behind': Object.freeze([
+    'name', 'relayInterfacesVersion', 'minimumInterfacesVersion',
+  ]),
+});
+
+/** Validates one restore refusal against its exact schema and names every reason it is refused. */
+export const validateBackupRestoreRefusal = (
+  valueArg: unknown,
+  pathArg = 'backup restore refusal',
+): string[] => {
+  const properties = readDataProperties(valueArg);
+  if (properties === null || !isRefusalName(properties.name)) {
+    return [`${pathArg} name must be one of ${backupRestoreRefusalNames.join(', ')}`];
+  }
+  const refusal = readExactDataRecord(valueArg, refusalKeys[properties.name]);
+  if (refusal === null) {
+    return [`${pathArg} must use the exact schema of ${properties.name}`];
+  }
+  switch (properties.name) {
+    case 'restore-snapshot-unavailable':
+      return validateMissingSnapshots(refusal.missing, `${pathArg} missing`);
+    case 'restore-preflight-unsupported':
+      return [];
+    case 'restore-relay-contract-behind':
+      return validateRelayContractBehind(refusal, pathArg);
+  }
+};
+
+/** Whether a value is exactly one restore refusal. */
+export const isBackupRestoreRefusal = (valueArg: unknown): valueArg is TBackupRestoreRefusal => (
+  validateBackupRestoreRefusal(valueArg).length === 0
+);
+
+const freezeMissingSnapshot = (
+  snapshotArg: IBackupRestoreMissingSnapshot,
+): IBackupRestoreMissingSnapshot => Object.freeze({
+  snapshotId: snapshotArg.snapshotId,
+  capability: snapshotArg.capability,
+  ...(snapshotArg.resourceName === undefined ? {} : { resourceName: snapshotArg.resourceName }),
+});
+
+const copySnapshotUnavailableRefusal = (
+  refusalArg: IBackupRestoreSnapshotUnavailableRefusal,
+): IBackupRestoreSnapshotUnavailableRefusal => {
+  const missing = refusalArg.missing.map(freezeMissingSnapshot);
+  Object.freeze(missing);
+  return Object.freeze({ name: refusalArg.name, missing });
+};
+
+const copyPreflightUnsupportedRefusal = (
+  refusalArg: IBackupRestorePreflightUnsupportedRefusal,
+): IBackupRestorePreflightUnsupportedRefusal => Object.freeze({ name: refusalArg.name });
+
+const copyRelayContractBehindRefusal = (
+  refusalArg: IBackupRestoreRelayContractBehindRefusal,
+): IBackupRestoreRelayContractBehindRefusal => Object.freeze({
+  name: refusalArg.name,
+  relayInterfacesVersion: refusalArg.relayInterfacesVersion,
+  minimumInterfacesVersion: refusalArg.minimumInterfacesVersion,
+});
+
+/** An inert frozen copy of a refusal that passed `validateBackupRestoreRefusal`. */
+const copyRefusal = (refusalArg: TBackupRestoreRefusal): TBackupRestoreRefusal => {
+  switch (refusalArg.name) {
+    case 'restore-snapshot-unavailable':
+      return copySnapshotUnavailableRefusal(refusalArg);
+    case 'restore-preflight-unsupported':
+      return copyPreflightUnsupportedRefusal(refusalArg);
+    case 'restore-relay-contract-behind':
+      return copyRelayContractBehindRefusal(refusalArg);
+  }
+};
+
+/**
+ * The restore refusal inside an error payload or a stored restore event, as an inert frozen copy,
+ * or `null` when the value is not exactly one. It reads own data properties only, so a refusal
+ * read here carries nothing that runs.
+ */
+export const readBackupRestoreRefusal = (valueArg: unknown): TBackupRestoreRefusal | null => (
+  // A value that passed holds own data properties of exactly the refusal's schema at every level,
+  // so the copy reads the same data the validation judged.
+  isBackupRestoreRefusal(valueArg) ? copyRefusal(valueArg) : null
+);
+
+/** The refusal a builder composed, unchanged, or an error naming every reason it is refused. */
+const requireRefusal = <T extends TBackupRestoreRefusal>(refusalArg: T): T => {
+  const errors = validateBackupRestoreRefusal(refusalArg);
+  if (errors.length > 0) {
+    throw new Error(errors.join('; '));
+  }
+  return refusalArg;
+};
+
+/** `restore-snapshot-unavailable` naming each snapshot the node's Corestore cannot read. */
+export const buildBackupRestoreSnapshotUnavailableRefusal = (
+  missingArg: IBackupRestoreMissingSnapshot[],
+): IBackupRestoreSnapshotUnavailableRefusal => copySnapshotUnavailableRefusal(requireRefusal({
+  name: 'restore-snapshot-unavailable',
+  missing: missingArg.map((snapshotArg) => ({ ...snapshotArg })),
+}));
+
+/** `restore-preflight-unsupported`: the node's Corestore offers no restore check. */
+export const buildBackupRestorePreflightUnsupportedRefusal = (): IBackupRestorePreflightUnsupportedRefusal => (
+  copyPreflightUnsupportedRefusal(requireRefusal({ name: 'restore-preflight-unsupported' }))
+);
+
+/**
+ * `restore-relay-contract-behind`: the relay speaks an interfaces release below the minimum.
+ *
+ * Throws when a stated version is not a release version or is not below the minimum, so a caller
+ * passes `null` for a relay whose stated version it cannot read.
+ */
+export const buildBackupRestoreRelayContractBehindRefusal = (
+  relayInterfacesVersionArg: string | null,
+  minimumInterfacesVersionArg: string,
+): IBackupRestoreRelayContractBehindRefusal => copyRelayContractBehindRefusal(requireRefusal({
+  name: 'restore-relay-contract-behind',
+  relayInterfacesVersion: relayInterfacesVersionArg,
+  minimumInterfacesVersion: minimumInterfacesVersionArg,
+}));
+
+const restoreEventStatuses: readonly IBackupRestoreEvent['status'][] = Object.freeze([
+  'restored', 'failed', 'refused',
+]);
+
+/**
+ * Validates what this contract adds to a restore event of a backup's `restoreHistory` and names
+ * every reason it is refused: `status` is `restored`, `failed` or `refused`, and `refusal` is
+ * present exactly when `status` is `refused`, as one restore refusal. Every other member is left as
+ * it was written (records Cloudly already stores keep any `restoredAt`, `errorText`, `partial` and
+ * `resourceTypes` they hold), so every stored event stays valid.
+ */
+export const validateBackupRestoreEvent = (
+  valueArg: unknown,
+  pathArg = 'backup restore event',
+): string[] => {
+  const event = readDataProperties(valueArg);
+  if (event === null) {
+    return [`${pathArg} must be a plain record of data properties`];
+  }
+  const errors: string[] = [];
+  if (!(restoreEventStatuses as readonly unknown[]).includes(event.status)) {
+    errors.push(`${pathArg} status must be one of ${restoreEventStatuses.join(', ')}`);
+  }
+  const hasRefusal = Object.hasOwn(event, 'refusal');
+  if (event.status === 'refused') {
+    if (!hasRefusal) {
+      errors.push(`${pathArg} refusal is required when status is refused`);
+    } else {
+      errors.push(...validateBackupRestoreRefusal(event.refusal, `${pathArg} refusal`));
+    }
+  } else if (hasRefusal) {
+    errors.push(`${pathArg} refusal is allowed only when status is refused`);
+  }
+  return errors;
+};

package/ts/data/index.ts

@@ -76,6 +76,7 @@ export * from './secret.js';
 export * from './baremetal.js';
 export * from './baseos.js';
 export * from './backup.js';
+export * from './backuprestorerefusal.js';
 export * from './clusternode.js';
 export * from './clusternodehostname.js';
 export * from './settings.js';

package/ts/requests/backup.ts

@@ -81,6 +81,14 @@ extends plugins.typedrequestInterfaces.implementsTR<
     backupId: string;
     clear?: boolean;
     resourceTypes?: Array<TBackupSnapshot['type']>;
+    /**
+     * Must be `true` to restore a `failed` backup whose failure is `incomplete`, and is refused for
+     * any other backup. Such a restore restores what the backup captured: `resourceTypes` is
+     * required and names only types it captured, none of the resources it did not capture
+     * (`failure.uncaptured`) is restored, so the service then holds data from two points in time,
+     * and the backup stays `failed`.
+     */
+    confirmPartialRestore?: boolean;
   };
   response: {
     backup: IBackupRecord;