@serve.zone/interfaces 10.1.0 → 11.1.0

package/dist_ts/data/isolatedrestore.js

@@ -0,0 +1,1299 @@
+/** Operations carried by a short-lived, single-operation restore grant. */
+export const isolatedRestoreGrantOperations = Object.freeze([
+    'prepare',
+    'write-object',
+    'execute',
+    'cleanup',
+    'status',
+]);
+/**
+ * Versioned limits shared by signers, relays, and Corestore.
+ *
+ * V1 uses an inline descriptor manifest inside a 1 MiB control request. Its
+ * 4,096 object slots reserve 256 entries for config, snapshots, keys, and
+ * index segments; the remaining 3,840 slots fit 1,920 default 8 MiB pack/index
+ * pairs. The 15 GiB total envelope is therefore reachable with the default
+ * ContainerArchive packing profile instead of advertising impossible capacity.
+ */
+export const isolatedRestoreContractLimits = Object.freeze({
+    version: 1,
+    maximumControlJsonBytes: 1024 * 1024,
+    maximumRestoreGrantBytes: 64 * 1024,
+    maximumConfiguredStringBytes: 2048,
+    maximumPathBytes: 4096,
+    maximumResourceMappings: 256,
+    maximumArchiveObjects: 4096,
+    reservedArchiveMetadataObjects: 256,
+    defaultContainerArchivePackTargetBytes: 8 * 1024 * 1024,
+    maximumArchiveObjectBytes: 64 * 1024 * 1024,
+    maximumArchiveTotalBytes: 15 * 1024 * 1024 * 1024,
+    maximumWriteChunkBytes: 512 * 1024,
+    maximumWriteChunkBase64Characters: 699_052,
+    maximumObjectChunks: 4096,
+});
+/** ContainerArchive v1 paths that may be replicated into restore staging. */
+export const isolatedRestoreRepositoryPathProfile = Object.freeze({
+    version: 1,
+    rootObject: 'config.json',
+    topLevelDirectories: Object.freeze([
+        'packs',
+        'snapshots',
+        'index',
+        'keys',
+    ]),
+    temporaryFilesAllowed: false,
+    ancestorConflictsAllowed: false,
+});
+export class IsolatedRestoreContractError extends Error {
+    constructor(reasonArg) {
+        super(`isolated restore contract error: ${reasonArg}`);
+        this.name = 'IsolatedRestoreContractError';
+    }
+}
+/** Cross-runtime rules for restore authority digests. */
+export const isolatedRestoreCanonicalJsonRules = Object.freeze({
+    version: 1,
+    encoding: 'utf-8',
+    objectKeyOrdering: 'utf-16-code-unit-ascending',
+    arrayOrdering: 'preserved-dense',
+    unicodeNormalization: 'preserved',
+    numberEncoding: 'safe-integer-json-no-negative-zero',
+    digest: 'sha256-lowercase-hex',
+});
+const canonicalIdentifierPattern = /^[A-Za-z0-9][A-Za-z0-9._:@-]{0,255}$/;
+const canonicalScopedIdPattern = /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,191}$/;
+const canonicalVolumeNamePattern = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/;
+const canonicalResourceNamePattern = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/;
+const canonicalDatabaseNamePattern = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/;
+const canonicalBucketNamePattern = /^[a-z0-9][a-z0-9.-]{1,61}[a-z0-9]$/;
+const canonicalIpv4SegmentPattern = /^(?:0|[1-9][0-9]{0,2})$/;
+const canonicalSha256Pattern = /^[a-f0-9]{64}$/;
+const standardBase64Alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const base64UrlAlphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+const fail = (reasonArg) => {
+    throw new IsolatedRestoreContractError(reasonArg);
+};
+const utf8ByteLength = (valueArg) => {
+    return new TextEncoder().encode(valueArg).byteLength;
+};
+/**
+ * Enforces the raw HTTP ingress limit before buffering or JSON parsing.
+ * Apply it to Content-Length and to the running byte count after every chunk.
+ */
+export const assertIsolatedRestoreControlIngressByteLength = (byteLengthArg) => {
+    if (typeof byteLengthArg !== 'number' ||
+        !Number.isSafeInteger(byteLengthArg) ||
+        Object.is(byteLengthArg, -0) ||
+        byteLengthArg < 0 ||
+        byteLengthArg > isolatedRestoreContractLimits.maximumControlJsonBytes) {
+        return fail(`raw control ingress must contain between 0 and ${isolatedRestoreContractLimits.maximumControlJsonBytes} bytes`);
+    }
+    return byteLengthArg;
+};
+const deepFreeze = (valueArg, seenArg = new WeakSet()) => {
+    if (!valueArg || typeof valueArg !== 'object') {
+        return valueArg;
+    }
+    const object = valueArg;
+    if (ArrayBuffer.isView(object) || seenArg.has(object)) {
+        return valueArg;
+    }
+    seenArg.add(object);
+    for (const key of Reflect.ownKeys(object)) {
+        const descriptor = Object.getOwnPropertyDescriptor(object, key);
+        if (descriptor && Object.hasOwn(descriptor, 'value')) {
+            deepFreeze(descriptor.value, seenArg);
+        }
+    }
+    return Object.freeze(valueArg);
+};
+const verifiedIsolatedRestoreGrantCompacts = new WeakMap();
+const verifiedIsolatedRestoreWriteBindings = new WeakSet();
+const completedIsolatedRestoreObjects = new WeakSet();
+const assertUnicodeScalarString = (valueArg, fieldNameArg) => {
+    for (let index = 0; index < valueArg.length; index++) {
+        const codeUnit = valueArg.charCodeAt(index);
+        if (codeUnit >= 0xd800 && codeUnit <= 0xdbff) {
+            const followingCodeUnit = valueArg.charCodeAt(index + 1);
+            if (!Number.isInteger(followingCodeUnit) ||
+                followingCodeUnit < 0xdc00 ||
+                followingCodeUnit > 0xdfff) {
+                fail(`${fieldNameArg} must not contain an unpaired UTF-16 surrogate`);
+            }
+            index++;
+            continue;
+        }
+        if (codeUnit >= 0xdc00 && codeUnit <= 0xdfff) {
+            fail(`${fieldNameArg} must not contain an unpaired UTF-16 surrogate`);
+        }
+    }
+};
+const readRecord = (valueArg, fieldNameArg) => {
+    if (!valueArg || typeof valueArg !== 'object' || Array.isArray(valueArg)) {
+        return fail(`${fieldNameArg} must be a plain object`);
+    }
+    const prototype = Object.getPrototypeOf(valueArg);
+    if (prototype !== Object.prototype && prototype !== null) {
+        return fail(`${fieldNameArg} must be a plain object`);
+    }
+    const record = valueArg;
+    const ownKeys = Reflect.ownKeys(record);
+    if (ownKeys.some((keyArg) => typeof keyArg !== 'string')) {
+        return fail(`${fieldNameArg} must not contain symbol keys`);
+    }
+    for (const key of ownKeys) {
+        const descriptor = Object.getOwnPropertyDescriptor(record, key);
+        if (!descriptor ||
+            !descriptor.enumerable ||
+            !Object.hasOwn(descriptor, 'value')) {
+            return fail(`${fieldNameArg} must contain enumerable data properties only`);
+        }
+    }
+    return record;
+};
+const readDenseArray = (valueArg, fieldNameArg, minimumLengthArg, maximumLengthArg) => {
+    if (!Array.isArray(valueArg) || Object.getPrototypeOf(valueArg) !== Array.prototype) {
+        return fail(`${fieldNameArg} must be a dense plain array`);
+    }
+    if (valueArg.length < minimumLengthArg ||
+        valueArg.length > maximumLengthArg) {
+        return fail(`${fieldNameArg} must contain between ${minimumLengthArg} and ${maximumLengthArg} entries`);
+    }
+    for (let index = 0; index < valueArg.length; index++) {
+        if (!Object.hasOwn(valueArg, index)) {
+            return fail(`${fieldNameArg} must not contain sparse entries`);
+        }
+        const descriptor = Object.getOwnPropertyDescriptor(valueArg, String(index));
+        if (!descriptor ||
+            !descriptor.enumerable ||
+            !Object.hasOwn(descriptor, 'value')) {
+            return fail(`${fieldNameArg} must contain enumerable data entries only`);
+        }
+    }
+    for (const key of Reflect.ownKeys(valueArg)) {
+        if (key === 'length') {
+            continue;
+        }
+        if (typeof key !== 'string' ||
+            !/^(?:0|[1-9][0-9]*)$/.test(key) ||
+            Number(key) >= valueArg.length) {
+            return fail(`${fieldNameArg} must not contain extra properties`);
+        }
+    }
+    return valueArg;
+};
+const assertExactKeys = (recordArg, expectedKeysArg, fieldNameArg) => {
+    const actualKeys = Object.keys(recordArg).sort();
+    const expectedKeys = [...expectedKeysArg].sort();
+    if (actualKeys.length !== expectedKeys.length ||
+        actualKeys.some((keyArg, indexArg) => keyArg !== expectedKeys[indexArg])) {
+        fail(`${fieldNameArg} does not match its exact versioned schema`);
+    }
+};
+const readString = (valueArg, fieldNameArg, maximumBytesArg) => {
+    if (typeof valueArg !== 'string' || valueArg.length === 0) {
+        return fail(`${fieldNameArg} must be a non-empty string`);
+    }
+    assertUnicodeScalarString(valueArg, fieldNameArg);
+    if (utf8ByteLength(valueArg) > maximumBytesArg) {
+        return fail(`${fieldNameArg} exceeds its UTF-8 byte limit`);
+    }
+    return valueArg;
+};
+const readConfiguredString = (valueArg, fieldNameArg) => {
+    const value = readString(valueArg, fieldNameArg, isolatedRestoreContractLimits.maximumConfiguredStringBytes);
+    if (value.trim() !== value ||
+        /\s/u.test(value) ||
+        /[\u0000-\u001f\u007f]/u.test(value)) {
+        return fail(`${fieldNameArg} must be a canonical string without whitespace`);
+    }
+    return value;
+};
+const readIdentifier = (valueArg, fieldNameArg) => {
+    if (typeof valueArg !== 'string' || !canonicalIdentifierPattern.test(valueArg)) {
+        return fail(`${fieldNameArg} must be a canonical identifier`);
+    }
+    return valueArg;
+};
+const readScopedId = (valueArg, fieldNameArg) => {
+    if (typeof valueArg !== 'string' || !canonicalScopedIdPattern.test(valueArg)) {
+        return fail(`${fieldNameArg} must be a canonical scoped identifier`);
+    }
+    return valueArg;
+};
+const readPatternName = (valueArg, fieldNameArg, patternArg, descriptionArg) => {
+    if (typeof valueArg !== 'string' || !patternArg.test(valueArg)) {
+        return fail(`${fieldNameArg} must be a canonical ${descriptionArg}`);
+    }
+    return valueArg;
+};
+const readVolumeName = (valueArg, fieldNameArg) => {
+    return readPatternName(valueArg, fieldNameArg, canonicalVolumeNamePattern, 'volume name');
+};
+const readResourceName = (valueArg, fieldNameArg) => {
+    return readPatternName(valueArg, fieldNameArg, canonicalResourceNamePattern, 'resource name');
+};
+const readDatabaseName = (valueArg, fieldNameArg) => {
+    return readPatternName(valueArg, fieldNameArg, canonicalDatabaseNamePattern, 'database name');
+};
+const readBucketName = (valueArg, fieldNameArg) => {
+    const value = readPatternName(valueArg, fieldNameArg, canonicalBucketNamePattern, 'bucket name');
+    const ipv4Segments = value.split('.');
+    const isIpv4Address = ipv4Segments.length === 4 &&
+        ipv4Segments.every((segmentArg) => canonicalIpv4SegmentPattern.test(segmentArg) &&
+            Number(segmentArg) <= 255);
+    if (value.includes('..') || isIpv4Address) {
+        return fail(`${fieldNameArg} must be a canonical bucket name`);
+    }
+    return value;
+};
+const readSha256 = (valueArg, fieldNameArg) => {
+    if (typeof valueArg !== 'string' || !canonicalSha256Pattern.test(valueArg)) {
+        return fail(`${fieldNameArg} must be a lowercase sha256 digest`);
+    }
+    return valueArg;
+};
+const readSafeInteger = (valueArg, fieldNameArg, minimumArg, maximumArg = Number.MAX_SAFE_INTEGER) => {
+    if (typeof valueArg !== 'number' ||
+        !Number.isSafeInteger(valueArg) ||
+        Object.is(valueArg, -0) ||
+        valueArg < minimumArg ||
+        valueArg > maximumArg) {
+        return fail(`${fieldNameArg} must be a safe integer between ${minimumArg} and ${maximumArg}`);
+    }
+    return valueArg;
+};
+const readMountPath = (valueArg, fieldNameArg) => {
+    const value = readString(valueArg, fieldNameArg, isolatedRestoreContractLimits.maximumPathBytes);
+    if (!value.startsWith('/') ||
+        value.includes('\\') ||
+        /[\u0000-\u001f\u007f]/u.test(value)) {
+        return fail(`${fieldNameArg} must be a canonical absolute POSIX path`);
+    }
+    if (value !== '/') {
+        const segments = value.slice(1).split('/');
+        if (segments.some((segmentArg) => segmentArg.length === 0 || segmentArg === '.' || segmentArg === '..')) {
+            return fail(`${fieldNameArg} must be a canonical absolute POSIX path`);
+        }
+    }
+    return value;
+};
+const readRepositoryPath = (valueArg, fieldNameArg) => {
+    const value = readString(valueArg, fieldNameArg, isolatedRestoreContractLimits.maximumPathBytes);
+    if (value.startsWith('/') ||
+        value.includes('\\') ||
+        /[\u0000-\u001f\u007f]/u.test(value)) {
+        return fail(`${fieldNameArg} is outside the supported repository path profile`);
+    }
+    if (value === 'config.json') {
+        return value;
+    }
+    let match = /^packs\/data\/([a-f0-9]{2})\/([a-f0-9]{32})\.(?:pack|idx)$/.exec(value);
+    if (match) {
+        if (match[1] !== match[2].slice(0, 2)) {
+            return fail(`${fieldNameArg} pack shard does not match its object id`);
+        }
+        return value;
+    }
+    match = /^packs\/parity\/([a-f0-9]{2})\/([a-f0-9]{32})(?:(?:\.(0|[1-9]|[12][0-9]|3[01]))?\.par|\.parx)$/.exec(value);
+    if (match) {
+        if (match[1] !== match[2].slice(0, 2)) {
+            return fail(`${fieldNameArg} parity shard does not match its object id`);
+        }
+        if (match[3] !== undefined && Number(match[3]) > 31) {
+            return fail(`${fieldNameArg} parity index is outside the supported range`);
+        }
+        return value;
+    }
+    if (/^snapshots\/[A-Za-z0-9][A-Za-z0-9_.:-]{0,191}\.json$/.test(value)) {
+        return value;
+    }
+    if (/^index\/[a-f0-9]{32}\.json$/.test(value)) {
+        return value;
+    }
+    if (/^keys\/[A-Za-z0-9][A-Za-z0-9_.:-]{0,191}\.key$/.test(value)) {
+        return value;
+    }
+    return fail(`${fieldNameArg} is outside the supported repository path profile`);
+};
+const assertCanonicalBase64 = (valueArg, fieldNameArg) => {
+    if (typeof valueArg !== 'string') {
+        return fail(`${fieldNameArg} must be canonical padded base64`);
+    }
+    if (valueArg.length >
+        isolatedRestoreContractLimits.maximumWriteChunkBase64Characters) {
+        return fail(`${fieldNameArg} exceeds the encoded chunk character limit`);
+    }
+    if (valueArg.length % 4 !== 0 ||
+        !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(valueArg)) {
+        return fail(`${fieldNameArg} must be canonical padded base64`);
+    }
+    if (valueArg.endsWith('==')) {
+        const sextet = standardBase64Alphabet.indexOf(valueArg[valueArg.length - 3]);
+        if (sextet < 0 || (sextet & 0x0f) !== 0) {
+            return fail(`${fieldNameArg} has non-zero base64 pad bits`);
+        }
+    }
+    else if (valueArg.endsWith('=')) {
+        const sextet = standardBase64Alphabet.indexOf(valueArg[valueArg.length - 2]);
+        if (sextet < 0 || (sextet & 0x03) !== 0) {
+            return fail(`${fieldNameArg} has non-zero base64 pad bits`);
+        }
+    }
+    return valueArg;
+};
+const decodeCanonicalBase64 = (valueArg, fieldNameArg) => {
+    const value = assertCanonicalBase64(valueArg, fieldNameArg);
+    const paddingLength = value.endsWith('==') ? 2 : value.endsWith('=') ? 1 : 0;
+    const result = new Uint8Array(value.length / 4 * 3 - paddingLength);
+    let outputOffset = 0;
+    for (let inputOffset = 0; inputOffset < value.length; inputOffset += 4) {
+        const first = standardBase64Alphabet.indexOf(value[inputOffset]);
+        const second = standardBase64Alphabet.indexOf(value[inputOffset + 1]);
+        const third = value[inputOffset + 2] === '='
+            ? 0
+            : standardBase64Alphabet.indexOf(value[inputOffset + 2]);
+        const fourth = value[inputOffset + 3] === '='
+            ? 0
+            : standardBase64Alphabet.indexOf(value[inputOffset + 3]);
+        const combined = (first << 18) | (second << 12) | (third << 6) | fourth;
+        if (outputOffset < result.length) {
+            result[outputOffset++] = combined >>> 16 & 0xff;
+        }
+        if (outputOffset < result.length) {
+            result[outputOffset++] = combined >>> 8 & 0xff;
+        }
+        if (outputOffset < result.length) {
+            result[outputOffset++] = combined & 0xff;
+        }
+    }
+    return result;
+};
+const assertCanonicalBase64UrlSegment = (valueArg, fieldNameArg) => {
+    if (valueArg.length === 0 ||
+        valueArg.length % 4 === 1 ||
+        !/^[A-Za-z0-9_-]+$/.test(valueArg)) {
+        fail(`${fieldNameArg} must be canonical unpadded base64url`);
+    }
+    const remainder = valueArg.length % 4;
+    const finalSextet = base64UrlAlphabet.indexOf(valueArg[valueArg.length - 1]);
+    if ((remainder === 2 && (finalSextet & 0x0f) !== 0) ||
+        (remainder === 3 && (finalSextet & 0x03) !== 0)) {
+        fail(`${fieldNameArg} has non-zero base64url pad bits`);
+    }
+};
+const readCompactRestoreGrant = (valueArg) => {
+    const value = readString(valueArg, 'restoreGrant', isolatedRestoreContractLimits.maximumRestoreGrantBytes);
+    const segments = value.split('.');
+    if (segments.length !== 3) {
+        return fail('restoreGrant must be a three-segment compact JWT');
+    }
+    segments.forEach((segmentArg, indexArg) => {
+        assertCanonicalBase64UrlSegment(segmentArg, `restoreGrant segment ${indexArg + 1}`);
+    });
+    return value;
+};
+const assertControlJsonLimit = (valueArg, fieldNameArg) => {
+    const json = JSON.stringify(valueArg);
+    if (typeof json !== 'string' ||
+        utf8ByteLength(json) > isolatedRestoreContractLimits.maximumControlJsonBytes) {
+        return fail(`${fieldNameArg} exceeds the ${isolatedRestoreContractLimits.maximumControlJsonBytes}-byte control JSON limit`);
+    }
+    return deepFreeze(valueArg);
+};
+const normalizeMapping = (mappingArg, indexArg) => {
+    const fieldName = `resourceMappings[${indexArg}]`;
+    const mapping = readRecord(mappingArg, fieldName);
+    assertExactKeys(mapping, ['id', 'type', 'source', 'target'], fieldName);
+    const id = readScopedId(mapping.id, `${fieldName}.id`);
+    if (mapping.type === 'volume') {
+        const source = readRecord(mapping.source, `${fieldName}.source`);
+        const target = readRecord(mapping.target, `${fieldName}.target`);
+        assertExactKeys(source, ['snapshotId', 'volumeName', 'mountPath'], `${fieldName}.source`);
+        assertExactKeys(target, ['volumeName', 'mountPath'], `${fieldName}.target`);
+        const sourceVolumeName = readVolumeName(source.volumeName, `${fieldName}.source.volumeName`);
+        const targetVolumeName = readVolumeName(target.volumeName, `${fieldName}.target.volumeName`);
+        if (sourceVolumeName === targetVolumeName) {
+            return fail(`${fieldName}.target.volumeName must differ from its source`);
+        }
+        return {
+            id,
+            type: 'volume',
+            source: {
+                snapshotId: readScopedId(source.snapshotId, `${fieldName}.source.snapshotId`),
+                volumeName: sourceVolumeName,
+                mountPath: readMountPath(source.mountPath, `${fieldName}.source.mountPath`),
+            },
+            target: {
+                volumeName: targetVolumeName,
+                mountPath: readMountPath(target.mountPath, `${fieldName}.target.mountPath`),
+            },
+        };
+    }
+    if (mapping.type === 'database') {
+        const source = readRecord(mapping.source, `${fieldName}.source`);
+        const target = readRecord(mapping.target, `${fieldName}.target`);
+        assertExactKeys(source, ['snapshotId', 'resourceName', 'databaseName'], `${fieldName}.source`);
+        assertExactKeys(target, ['resourceName', 'databaseName'], `${fieldName}.target`);
+        const sourceResourceName = readResourceName(source.resourceName, `${fieldName}.source.resourceName`);
+        const sourceDatabaseName = readDatabaseName(source.databaseName, `${fieldName}.source.databaseName`);
+        const targetResourceName = readResourceName(target.resourceName, `${fieldName}.target.resourceName`);
+        const targetDatabaseName = readDatabaseName(target.databaseName, `${fieldName}.target.databaseName`);
+        if (sourceResourceName === targetResourceName ||
+            sourceDatabaseName === targetDatabaseName) {
+            return fail(`${fieldName}.target database namespace must differ from its source`);
+        }
+        return {
+            id,
+            type: 'database',
+            source: {
+                snapshotId: readScopedId(source.snapshotId, `${fieldName}.source.snapshotId`),
+                resourceName: sourceResourceName,
+                databaseName: sourceDatabaseName,
+            },
+            target: {
+                resourceName: targetResourceName,
+                databaseName: targetDatabaseName,
+            },
+        };
+    }
+    if (mapping.type === 'objectstorage') {
+        const source = readRecord(mapping.source, `${fieldName}.source`);
+        const target = readRecord(mapping.target, `${fieldName}.target`);
+        assertExactKeys(source, ['snapshotId', 'resourceName', 'bucketName'], `${fieldName}.source`);
+        assertExactKeys(target, ['resourceName', 'bucketName'], `${fieldName}.target`);
+        const sourceResourceName = readResourceName(source.resourceName, `${fieldName}.source.resourceName`);
+        const sourceBucketName = readBucketName(source.bucketName, `${fieldName}.source.bucketName`);
+        const targetResourceName = readResourceName(target.resourceName, `${fieldName}.target.resourceName`);
+        const targetBucketName = readBucketName(target.bucketName, `${fieldName}.target.bucketName`);
+        if (sourceResourceName === targetResourceName ||
+            sourceBucketName === targetBucketName) {
+            return fail(`${fieldName}.target objectstorage namespace must differ from its source`);
+        }
+        return {
+            id,
+            type: 'objectstorage',
+            source: {
+                snapshotId: readScopedId(source.snapshotId, `${fieldName}.source.snapshotId`),
+                resourceName: sourceResourceName,
+                bucketName: sourceBucketName,
+            },
+            target: {
+                resourceName: targetResourceName,
+                bucketName: targetBucketName,
+            },
+        };
+    }
+    return fail(`${fieldName}.type is unsupported`);
+};
+export const normalizeIsolatedRestoreResourceMappings = (valueArg) => {
+    const entries = readDenseArray(valueArg, 'resourceMappings', 1, isolatedRestoreContractLimits.maximumResourceMappings);
+    const mappings = entries.map(normalizeMapping);
+    const mappingIds = new Set();
+    const sourceSnapshotIds = new Set();
+    const targetAuthorities = new Set();
+    const targetVolumeMountPaths = new Set();
+    for (const mapping of mappings) {
+        if (mappingIds.has(mapping.id)) {
+            return fail(`resourceMappings contains duplicate id ${mapping.id}`);
+        }
+        mappingIds.add(mapping.id);
+        if (sourceSnapshotIds.has(mapping.source.snapshotId)) {
+            return fail(`resourceMappings contains duplicate source snapshot ${mapping.source.snapshotId}`);
+        }
+        sourceSnapshotIds.add(mapping.source.snapshotId);
+        if (mapping.type === 'volume') {
+            if (targetVolumeMountPaths.has(mapping.target.mountPath)) {
+                return fail(`resourceMappings contains duplicate target volume mount path ${mapping.target.mountPath}`);
+            }
+            targetVolumeMountPaths.add(mapping.target.mountPath);
+        }
+        const targetAuthority = mapping.type === 'volume'
+            ? `volume:${mapping.target.volumeName}`
+            : mapping.type === 'database'
+                ? `database:${mapping.target.resourceName}:${mapping.target.databaseName}`
+                : `objectstorage:${mapping.target.resourceName}:${mapping.target.bucketName}`;
+        if (targetAuthorities.has(targetAuthority)) {
+            return fail(`resourceMappings contains duplicate target authority ${targetAuthority}`);
+        }
+        targetAuthorities.add(targetAuthority);
+    }
+    return deepFreeze(mappings);
+};
+export const normalizeIsolatedRestoreArchiveManifest = (valueArg) => {
+    const manifest = readRecord(valueArg, 'archiveManifest');
+    assertExactKeys(manifest, ['version', 'backupId', 'createdAt', 'objects', 'totalSize'], 'archiveManifest');
+    if (manifest.version !== 1) {
+        return fail('archiveManifest.version must be 1');
+    }
+    const objectEntries = readDenseArray(manifest.objects, 'archiveManifest.objects', 1, isolatedRestoreContractLimits.maximumArchiveObjects);
+    const paths = new Set();
+    let calculatedTotalSize = 0;
+    const objects = objectEntries.map((objectArg, indexArg) => {
+        const fieldName = `archiveManifest.objects[${indexArg}]`;
+        const object = readRecord(objectArg, fieldName);
+        assertExactKeys(object, ['path', 'size', 'sha256'], fieldName);
+        const path = readRepositoryPath(object.path, `${fieldName}.path`);
+        if (paths.has(path)) {
+            return fail(`archiveManifest.objects contains duplicate path ${path}`);
+        }
+        paths.add(path);
+        const size = readSafeInteger(object.size, `${fieldName}.size`, 0, isolatedRestoreContractLimits.maximumArchiveObjectBytes);
+        if (!Number.isSafeInteger(calculatedTotalSize + size) ||
+            calculatedTotalSize + size >
+                isolatedRestoreContractLimits.maximumArchiveTotalBytes) {
+            return fail('archiveManifest object sizes exceed the versioned total-size limit');
+        }
+        calculatedTotalSize += size;
+        return {
+            path,
+            size,
+            sha256: readSha256(object.sha256, `${fieldName}.sha256`),
+        };
+    });
+    const parityStylesByGroup = new Map();
+    for (const object of objects) {
+        const parityMatch = /^packs\/parity\/([a-f0-9]{2})\/([a-f0-9]{32})(?:\.([0-9]{1,2}))?\.par$/.exec(object.path);
+        if (!parityMatch) {
+            continue;
+        }
+        const group = `${parityMatch[1]}/${parityMatch[2]}`;
+        const style = parityMatch[3] === undefined ? 'unnumbered' : 'numbered';
+        const previousStyle = parityStylesByGroup.get(group);
+        if (previousStyle && previousStyle !== style) {
+            return fail(`archiveManifest parity group ${group} mixes numbered and unnumbered shards`);
+        }
+        parityStylesByGroup.set(group, style);
+    }
+    for (const path of paths) {
+        let slashIndex = path.indexOf('/');
+        while (slashIndex >= 0) {
+            const ancestor = path.slice(0, slashIndex);
+            if (paths.has(ancestor)) {
+                return fail(`archiveManifest path ${path} conflicts with object ancestor ${ancestor}`);
+            }
+            slashIndex = path.indexOf('/', slashIndex + 1);
+        }
+    }
+    const totalSize = readSafeInteger(manifest.totalSize, 'archiveManifest.totalSize', 0, isolatedRestoreContractLimits.maximumArchiveTotalBytes);
+    if (totalSize !== calculatedTotalSize) {
+        return fail('archiveManifest.totalSize must equal the sum of object sizes');
+    }
+    return deepFreeze({
+        version: 1,
+        backupId: readScopedId(manifest.backupId, 'archiveManifest.backupId'),
+        createdAt: readSafeInteger(manifest.createdAt, 'archiveManifest.createdAt', 0),
+        objects,
+        totalSize,
+    });
+};
+export const normalizeIsolatedRestoreGrantClaims = (valueArg) => {
+    const claims = readRecord(valueArg, 'restore grant claims');
+    assertExactKeys(claims, [
+        'grantVersion',
+        'iss',
+        'aud',
+        'sub',
+        'jti',
+        'authorizationId',
+        'tenantId',
+        'clusterId',
+        'targetNodeName',
+        'restoreId',
+        'sourceBackupId',
+        'sourceServiceId',
+        'scratchNamespaceId',
+        'stagingArchiveId',
+        'operation',
+        'resourceMappingsSha256',
+        'archiveManifestSha256',
+        'iat',
+        'nbf',
+        'exp',
+    ], 'restore grant claims');
+    if (claims.grantVersion !== 1) {
+        return fail('grantVersion must be 1');
+    }
+    if (typeof claims.operation !== 'string' ||
+        !isolatedRestoreGrantOperations.includes(claims.operation)) {
+        return fail('operation is unsupported');
+    }
+    const iat = readSafeInteger(claims.iat, 'iat', 1);
+    const nbf = readSafeInteger(claims.nbf, 'nbf', 1);
+    const exp = readSafeInteger(claims.exp, 'exp', 1);
+    if (exp <= iat || exp <= nbf) {
+        return fail('exp must be later than both iat and nbf');
+    }
+    const normalizedClaims = {
+        grantVersion: 1,
+        iss: readConfiguredString(claims.iss, 'iss'),
+        aud: readConfiguredString(claims.aud, 'aud'),
+        sub: readIdentifier(claims.sub, 'sub'),
+        jti: readIdentifier(claims.jti, 'jti'),
+        authorizationId: readIdentifier(claims.authorizationId, 'authorizationId'),
+        tenantId: readIdentifier(claims.tenantId, 'tenantId'),
+        clusterId: readIdentifier(claims.clusterId, 'clusterId'),
+        targetNodeName: readIdentifier(claims.targetNodeName, 'targetNodeName'),
+        restoreId: readScopedId(claims.restoreId, 'restoreId'),
+        sourceBackupId: readScopedId(claims.sourceBackupId, 'sourceBackupId'),
+        sourceServiceId: readScopedId(claims.sourceServiceId, 'sourceServiceId'),
+        scratchNamespaceId: readScopedId(claims.scratchNamespaceId, 'scratchNamespaceId'),
+        stagingArchiveId: readScopedId(claims.stagingArchiveId, 'stagingArchiveId'),
+        operation: claims.operation,
+        resourceMappingsSha256: readSha256(claims.resourceMappingsSha256, 'resourceMappingsSha256'),
+        archiveManifestSha256: readSha256(claims.archiveManifestSha256, 'archiveManifestSha256'),
+        iat,
+        nbf,
+        exp,
+    };
+    if (normalizedClaims.scratchNamespaceId === normalizedClaims.sourceServiceId) {
+        return fail('scratchNamespaceId must differ from sourceServiceId');
+    }
+    if (normalizedClaims.stagingArchiveId === normalizedClaims.sourceBackupId) {
+        return fail('stagingArchiveId must differ from sourceBackupId');
+    }
+    return deepFreeze(normalizedClaims);
+};
+const normalizeControlMutationRequest = (valueArg, fieldNameArg) => {
+    const request = readRecord(valueArg, fieldNameArg);
+    assertExactKeys(request, ['restoreGrant', 'expectedRevision'], fieldNameArg);
+    return assertControlJsonLimit({
+        restoreGrant: readCompactRestoreGrant(request.restoreGrant),
+        expectedRevision: readSafeInteger(request.expectedRevision, `${fieldNameArg}.expectedRevision`, 0),
+    }, fieldNameArg);
+};
+export const normalizeIsolatedRestoreControlPrepareRequest = (valueArg) => {
+    const request = readRecord(valueArg, 'prepare request');
+    assertExactKeys(request, ['restoreGrant', 'expectedRevision', 'resourceMappings', 'archiveManifest'], 'prepare request');
+    return assertControlJsonLimit({
+        restoreGrant: readCompactRestoreGrant(request.restoreGrant),
+        expectedRevision: readSafeInteger(request.expectedRevision, 'prepare request.expectedRevision', 0),
+        resourceMappings: normalizeIsolatedRestoreResourceMappings(request.resourceMappings),
+        archiveManifest: normalizeIsolatedRestoreArchiveManifest(request.archiveManifest),
+    }, 'prepare request');
+};
+export const normalizeIsolatedRestoreControlWriteRequest = (valueArg) => {
+    const request = readRecord(valueArg, 'write request');
+    assertExactKeys(request, [
+        'restoreGrant',
+        'expectedRevision',
+        'path',
+        'size',
+        'sha256',
+        'offset',
+        'chunkSha256',
+        'contentsBase64',
+    ], 'write request');
+    const size = readSafeInteger(request.size, 'write request.size', 0, isolatedRestoreContractLimits.maximumArchiveObjectBytes);
+    const offset = readSafeInteger(request.offset, 'write request.offset', 0, size);
+    const contentsBase64 = assertCanonicalBase64(request.contentsBase64, 'write request.contentsBase64');
+    const contents = decodeCanonicalBase64(contentsBase64, 'write request.contentsBase64');
+    if (contents.byteLength > isolatedRestoreContractLimits.maximumWriteChunkBytes) {
+        return fail('write request decoded chunk exceeds the versioned chunk limit');
+    }
+    if (size === 0) {
+        if (offset !== 0 || contents.byteLength !== 0) {
+            return fail('write request for an empty object must contain one empty chunk at offset 0');
+        }
+    }
+    else if (contents.byteLength === 0 ||
+        offset >= size ||
+        offset + contents.byteLength > size) {
+        return fail('write request chunk does not fit within the immutable object descriptor');
+    }
+    return assertControlJsonLimit({
+        restoreGrant: readCompactRestoreGrant(request.restoreGrant),
+        expectedRevision: readSafeInteger(request.expectedRevision, 'write request.expectedRevision', 0),
+        path: readRepositoryPath(request.path, 'write request.path'),
+        size,
+        sha256: readSha256(request.sha256, 'write request.sha256'),
+        offset,
+        chunkSha256: readSha256(request.chunkSha256, 'write request.chunkSha256'),
+        contentsBase64,
+    }, 'write request');
+};
+export const normalizeIsolatedRestoreControlExecuteRequest = (valueArg) => {
+    return normalizeControlMutationRequest(valueArg, 'execute request');
+};
+export const normalizeIsolatedRestoreControlCleanupRequest = (valueArg) => {
+    return normalizeControlMutationRequest(valueArg, 'cleanup request');
+};
+export const normalizeIsolatedRestoreControlStatusRequest = (valueArg) => {
+    const request = readRecord(valueArg, 'status request');
+    assertExactKeys(request, ['restoreGrant'], 'status request');
+    return assertControlJsonLimit({ restoreGrant: readCompactRestoreGrant(request.restoreGrant) }, 'status request');
+};
+const canonicalizeJson = (valueArg) => {
+    const ancestors = new Set();
+    const visit = (currentValueArg, fieldNameArg) => {
+        if (currentValueArg === null) {
+            return 'null';
+        }
+        if (typeof currentValueArg === 'boolean') {
+            return currentValueArg ? 'true' : 'false';
+        }
+        if (typeof currentValueArg === 'string') {
+            assertUnicodeScalarString(currentValueArg, fieldNameArg);
+            return JSON.stringify(currentValueArg);
+        }
+        if (typeof currentValueArg === 'number') {
+            if (!Number.isSafeInteger(currentValueArg) ||
+                Object.is(currentValueArg, -0)) {
+                return fail(`${fieldNameArg} must contain safe integers only`);
+            }
+            return String(currentValueArg);
+        }
+        if (typeof currentValueArg !== 'object') {
+            return fail(`${fieldNameArg} contains a non-JSON value`);
+        }
+        if (ancestors.has(currentValueArg)) {
+            return fail(`${fieldNameArg} contains a cycle`);
+        }
+        ancestors.add(currentValueArg);
+        try {
+            if (Array.isArray(currentValueArg)) {
+                return `[${currentValueArg
+                    .map((entryArg, indexArg) => visit(entryArg, `${fieldNameArg}[${indexArg}]`))
+                    .join(',')}]`;
+            }
+            const record = readRecord(currentValueArg, fieldNameArg);
+            const keys = Object.keys(record).sort((leftArg, rightArg) => {
+                return leftArg < rightArg ? -1 : leftArg > rightArg ? 1 : 0;
+            });
+            return `{${keys
+                .map((keyArg) => {
+                assertUnicodeScalarString(keyArg, `${fieldNameArg} key`);
+                return `${JSON.stringify(keyArg)}:${visit(record[keyArg], `${fieldNameArg}.${keyArg}`)}`;
+            })
+                .join(',')}}`;
+        }
+        finally {
+            ancestors.delete(currentValueArg);
+        }
+    };
+    return visit(valueArg, 'canonical JSON input');
+};
+export const canonicalizeIsolatedRestoreResourceMappings = (valueArg) => {
+    return canonicalizeJson(normalizeIsolatedRestoreResourceMappings(valueArg));
+};
+export const canonicalizeIsolatedRestoreArchiveManifest = (valueArg) => {
+    return canonicalizeJson(normalizeIsolatedRestoreArchiveManifest(valueArg));
+};
+export const canonicalizeIsolatedRestoreGrantClaims = (valueArg) => {
+    return canonicalizeJson(normalizeIsolatedRestoreGrantClaims(valueArg));
+};
+export const normalizeIsolatedRestoreAuthorityProjection = (valueArg) => {
+    const authority = readRecord(valueArg, 'restore authority projection');
+    assertExactKeys(authority, [
+        'version',
+        'iss',
+        'aud',
+        'sub',
+        'authorizationId',
+        'tenantId',
+        'clusterId',
+        'targetNodeName',
+        'restoreId',
+        'sourceBackupId',
+        'sourceServiceId',
+        'scratchNamespaceId',
+        'stagingArchiveId',
+        'resourceMappingsSha256',
+        'archiveManifestSha256',
+    ], 'restore authority projection');
+    if (authority.version !== 1) {
+        return fail('restore authority projection.version must be 1');
+    }
+    const normalized = {
+        version: 1,
+        iss: readConfiguredString(authority.iss, 'restore authority projection.iss'),
+        aud: readConfiguredString(authority.aud, 'restore authority projection.aud'),
+        sub: readIdentifier(authority.sub, 'restore authority projection.sub'),
+        authorizationId: readIdentifier(authority.authorizationId, 'restore authority projection.authorizationId'),
+        tenantId: readIdentifier(authority.tenantId, 'restore authority projection.tenantId'),
+        clusterId: readIdentifier(authority.clusterId, 'restore authority projection.clusterId'),
+        targetNodeName: readIdentifier(authority.targetNodeName, 'restore authority projection.targetNodeName'),
+        restoreId: readScopedId(authority.restoreId, 'restore authority projection.restoreId'),
+        sourceBackupId: readScopedId(authority.sourceBackupId, 'restore authority projection.sourceBackupId'),
+        sourceServiceId: readScopedId(authority.sourceServiceId, 'restore authority projection.sourceServiceId'),
+        scratchNamespaceId: readScopedId(authority.scratchNamespaceId, 'restore authority projection.scratchNamespaceId'),
+        stagingArchiveId: readScopedId(authority.stagingArchiveId, 'restore authority projection.stagingArchiveId'),
+        resourceMappingsSha256: readSha256(authority.resourceMappingsSha256, 'restore authority projection.resourceMappingsSha256'),
+        archiveManifestSha256: readSha256(authority.archiveManifestSha256, 'restore authority projection.archiveManifestSha256'),
+    };
+    if (normalized.scratchNamespaceId === normalized.sourceServiceId) {
+        return fail('restore authority projection scratchNamespaceId must differ from sourceServiceId');
+    }
+    if (normalized.stagingArchiveId === normalized.sourceBackupId) {
+        return fail('restore authority projection stagingArchiveId must differ from sourceBackupId');
+    }
+    return deepFreeze(normalized);
+};
+export const createIsolatedRestoreAuthorityProjection = (claimsArg) => {
+    const claims = normalizeIsolatedRestoreGrantClaims(claimsArg);
+    return normalizeIsolatedRestoreAuthorityProjection({
+        version: 1,
+        iss: claims.iss,
+        aud: claims.aud,
+        sub: claims.sub,
+        authorizationId: claims.authorizationId,
+        tenantId: claims.tenantId,
+        clusterId: claims.clusterId,
+        targetNodeName: claims.targetNodeName,
+        restoreId: claims.restoreId,
+        sourceBackupId: claims.sourceBackupId,
+        sourceServiceId: claims.sourceServiceId,
+        scratchNamespaceId: claims.scratchNamespaceId,
+        stagingArchiveId: claims.stagingArchiveId,
+        resourceMappingsSha256: claims.resourceMappingsSha256,
+        archiveManifestSha256: claims.archiveManifestSha256,
+    });
+};
+export const canonicalizeIsolatedRestoreAuthorityProjection = (valueArg) => {
+    return canonicalizeJson(normalizeIsolatedRestoreAuthorityProjection(valueArg));
+};
+const createSha256 = async (contentsArg) => {
+    const subtle = globalThis.crypto?.subtle;
+    if (!subtle) {
+        return fail('Web Crypto SHA-256 is unavailable in this runtime');
+    }
+    const digest = await subtle.digest('SHA-256', new Uint8Array(contentsArg));
+    return Array.from(new Uint8Array(digest), (byteArg) => byteArg.toString(16).padStart(2, '0')).join('');
+};
+const createCanonicalJsonSha256 = async (canonicalJsonArg) => {
+    return createSha256(new TextEncoder().encode(canonicalJsonArg));
+};
+export const createIsolatedRestoreBytesSha256 = async (contentsArg) => {
+    if (!(contentsArg instanceof Uint8Array)) {
+        return fail('contents must be a Uint8Array');
+    }
+    return createSha256(contentsArg);
+};
+export const createIsolatedRestoreResourceMappingsSha256 = async (valueArg) => {
+    return createCanonicalJsonSha256(canonicalizeIsolatedRestoreResourceMappings(valueArg));
+};
+export const createIsolatedRestoreArchiveManifestSha256 = async (valueArg) => {
+    return createCanonicalJsonSha256(canonicalizeIsolatedRestoreArchiveManifest(valueArg));
+};
+export const createIsolatedRestoreGrantClaimsSha256 = async (valueArg) => {
+    return createCanonicalJsonSha256(canonicalizeIsolatedRestoreGrantClaims(valueArg));
+};
+export const createIsolatedRestoreAuthoritySha256 = async (valueArg) => {
+    return createCanonicalJsonSha256(canonicalizeIsolatedRestoreAuthorityProjection(valueArg));
+};
+const requireVerifiedIsolatedRestoreGrant = (grantArg) => {
+    if (!grantArg ||
+        typeof grantArg !== 'object' ||
+        !verifiedIsolatedRestoreGrantCompacts.has(grantArg)) {
+        return fail('restore grant must be a runtime-branded result of verifyIsolatedRestoreGrant');
+    }
+    return grantArg;
+};
+/**
+ * Invokes the caller's cryptographic verifier for exactly `compact`, retains
+ * that bearer in module-private storage, and brands the immutable claims
+ * projection. Binding helpers reject claims supplied without this operation
+ * and reject any control body carrying another compact JWT.
+ */
+export const verifyIsolatedRestoreGrant = async (compactArg, verifierArg) => {
+    const compact = readCompactRestoreGrant(compactArg);
+    if (typeof verifierArg !== 'function') {
+        return fail('restore grant verifier must be a function');
+    }
+    const claims = normalizeIsolatedRestoreGrantClaims(await verifierArg(compact));
+    const grant = deepFreeze({ claims });
+    verifiedIsolatedRestoreGrantCompacts.set(grant, compact);
+    return grant;
+};
+export const assertIsolatedRestoreGrantOperation = (grantArg, expectedOperationArg) => {
+    if (!isolatedRestoreGrantOperations.includes(expectedOperationArg)) {
+        return fail('expected operation is unsupported');
+    }
+    const grant = requireVerifiedIsolatedRestoreGrant(grantArg);
+    if (grant.claims.operation !== expectedOperationArg) {
+        return fail(`restore grant operation ${grant.claims.operation} does not authorize ${expectedOperationArg}`);
+    }
+    return grant.claims;
+};
+const assertControlRequestUsesVerifiedGrant = (grantArg, compactArg) => {
+    const grant = requireVerifiedIsolatedRestoreGrant(grantArg);
+    if (compactArg !== verifiedIsolatedRestoreGrantCompacts.get(grant)) {
+        fail('control request restoreGrant does not match the verified compact JWT');
+    }
+};
+const assertPlanRelationships = (claimsArg, mappingsArg, manifestArg) => {
+    if (manifestArg.backupId !== claimsArg.sourceBackupId) {
+        fail('archiveManifest.backupId does not match grant sourceBackupId');
+    }
+    const paths = new Set(manifestArg.objects.map((objectArg) => objectArg.path));
+    if (!paths.has('config.json')) {
+        fail('archiveManifest must contain config.json');
+    }
+    for (const mapping of mappingsArg) {
+        const requiredSnapshotPath = `snapshots/${mapping.source.snapshotId}.json`;
+        if (!paths.has(requiredSnapshotPath)) {
+            fail(`archiveManifest does not contain required object ${requiredSnapshotPath}`);
+        }
+    }
+};
+export const bindIsolatedRestoreGrantToPlan = async (grantArg, expectedOperationArg, resourceMappingsArg, archiveManifestArg) => {
+    const grant = requireVerifiedIsolatedRestoreGrant(grantArg);
+    const claims = assertIsolatedRestoreGrantOperation(grant, expectedOperationArg);
+    const resourceMappings = normalizeIsolatedRestoreResourceMappings(resourceMappingsArg);
+    const archiveManifest = normalizeIsolatedRestoreArchiveManifest(archiveManifestArg);
+    assertPlanRelationships(claims, resourceMappings, archiveManifest);
+    const [resourceMappingsSha256, archiveManifestSha256] = await Promise.all([
+        createIsolatedRestoreResourceMappingsSha256(resourceMappings),
+        createIsolatedRestoreArchiveManifestSha256(archiveManifest),
+    ]);
+    if (resourceMappingsSha256 !== claims.resourceMappingsSha256) {
+        return fail('resourceMappings digest does not match the restore grant');
+    }
+    if (archiveManifestSha256 !== claims.archiveManifestSha256) {
+        return fail('archiveManifest digest does not match the restore grant');
+    }
+    const authority = createIsolatedRestoreAuthorityProjection(claims);
+    const authoritySha256 = await createIsolatedRestoreAuthoritySha256(authority);
+    return deepFreeze({
+        authority,
+        authoritySha256,
+        claims,
+        resourceMappings,
+        archiveManifest,
+    });
+};
+export const bindIsolatedRestorePrepareRequestToGrant = async (grantArg, requestArg) => {
+    const grant = requireVerifiedIsolatedRestoreGrant(grantArg);
+    const normalizedRequest = normalizeIsolatedRestoreControlPrepareRequest(requestArg);
+    assertControlRequestUsesVerifiedGrant(grant, normalizedRequest.restoreGrant);
+    const plan = await bindIsolatedRestoreGrantToPlan(grant, 'prepare', normalizedRequest.resourceMappings, normalizedRequest.archiveManifest);
+    const request = {
+        expectedRevision: normalizedRequest.expectedRevision,
+        resourceMappings: plan.resourceMappings,
+        archiveManifest: plan.archiveManifest,
+    };
+    return deepFreeze({
+        authority: plan.authority,
+        authoritySha256: plan.authoritySha256,
+        claims: plan.claims,
+        request,
+    });
+};
+const bindSanitizedControlRequestToGrant = async (grantArg, expectedOperationArg, compactArg, requestArg, resourceMappingsArg, archiveManifestArg) => {
+    const grant = requireVerifiedIsolatedRestoreGrant(grantArg);
+    assertControlRequestUsesVerifiedGrant(grant, compactArg);
+    const plan = await bindIsolatedRestoreGrantToPlan(grant, expectedOperationArg, resourceMappingsArg, archiveManifestArg);
+    return deepFreeze({
+        authority: plan.authority,
+        authoritySha256: plan.authoritySha256,
+        claims: plan.claims,
+        request: requestArg,
+        plan,
+    });
+};
+export const bindIsolatedRestoreExecuteRequestToGrant = async (grantArg, requestArg, resourceMappingsArg, archiveManifestArg) => {
+    const normalizedRequest = normalizeIsolatedRestoreControlExecuteRequest(requestArg);
+    const request = {
+        expectedRevision: normalizedRequest.expectedRevision,
+    };
+    return bindSanitizedControlRequestToGrant(grantArg, 'execute', normalizedRequest.restoreGrant, request, resourceMappingsArg, archiveManifestArg);
+};
+export const bindIsolatedRestoreCleanupRequestToGrant = async (grantArg, requestArg, resourceMappingsArg, archiveManifestArg) => {
+    const normalizedRequest = normalizeIsolatedRestoreControlCleanupRequest(requestArg);
+    const request = {
+        expectedRevision: normalizedRequest.expectedRevision,
+    };
+    return bindSanitizedControlRequestToGrant(grantArg, 'cleanup', normalizedRequest.restoreGrant, request, resourceMappingsArg, archiveManifestArg);
+};
+export const bindIsolatedRestoreStatusRequestToGrant = async (grantArg, requestArg, resourceMappingsArg, archiveManifestArg) => {
+    const normalizedRequest = normalizeIsolatedRestoreControlStatusRequest(requestArg);
+    const request = {};
+    return bindSanitizedControlRequestToGrant(grantArg, 'status', normalizedRequest.restoreGrant, request, resourceMappingsArg, archiveManifestArg);
+};
+export const bindIsolatedRestoreWriteRequestToGrant = async (grantArg, requestArg, resourceMappingsArg, archiveManifestArg) => {
+    const grant = requireVerifiedIsolatedRestoreGrant(grantArg);
+    const request = normalizeIsolatedRestoreControlWriteRequest(requestArg);
+    assertControlRequestUsesVerifiedGrant(grant, request.restoreGrant);
+    const plan = await bindIsolatedRestoreGrantToPlan(grant, 'write-object', resourceMappingsArg, archiveManifestArg);
+    const descriptor = plan.archiveManifest.objects.find((objectArg) => objectArg.path === request.path);
+    if (!descriptor) {
+        return fail(`write request path ${request.path} is absent from the immutable manifest`);
+    }
+    if (descriptor.size !== request.size || descriptor.sha256 !== request.sha256) {
+        return fail(`write request descriptor for ${request.path} does not match the immutable manifest`);
+    }
+    const contents = decodeCanonicalBase64(request.contentsBase64, 'write request.contentsBase64');
+    const actualChunkSha256 = await createIsolatedRestoreBytesSha256(contents);
+    if (actualChunkSha256 !== request.chunkSha256) {
+        return fail(`write request chunk checksum mismatch for ${request.path}`);
+    }
+    const sanitizedRequest = {
+        expectedRevision: request.expectedRevision,
+        path: request.path,
+        size: request.size,
+        sha256: request.sha256,
+        offset: request.offset,
+        chunkSha256: request.chunkSha256,
+        contentsBase64: request.contentsBase64,
+    };
+    const bound = deepFreeze({
+        authority: plan.authority,
+        authoritySha256: plan.authoritySha256,
+        claims: plan.claims,
+        request: sanitizedRequest,
+        descriptor,
+        chunk: {
+            contentsBase64: request.contentsBase64,
+            decodedSize: contents.byteLength,
+            sha256: actualChunkSha256,
+        },
+        endsAtObjectSize: request.offset + contents.byteLength === descriptor.size,
+    });
+    verifiedIsolatedRestoreWriteBindings.add(bound);
+    return bound;
+};
+const requireBoundWriteRequest = (bindingArg) => {
+    if (!bindingArg ||
+        typeof bindingArg !== 'object' ||
+        !verifiedIsolatedRestoreWriteBindings.has(bindingArg)) {
+        return fail('write binding was not produced by bindIsolatedRestoreWriteRequestToGrant');
+    }
+    return bindingArg;
+};
+/** Returns a fresh caller-owned copy; verified bindings never expose mutable bytes. */
+export const decodeIsolatedRestoreBoundWriteChunk = (bindingArg) => {
+    const binding = requireBoundWriteRequest(bindingArg);
+    return decodeCanonicalBase64(binding.chunk.contentsBase64, 'verified write chunk.contentsBase64');
+};
+const createDurableChunkReceiptPayload = (receiptArg) => {
+    return {
+        version: 1,
+        authority: receiptArg.authority,
+        authoritySha256: receiptArg.authoritySha256,
+        descriptor: receiptArg.descriptor,
+        offset: receiptArg.offset,
+        decodedSize: receiptArg.decodedSize,
+        chunkSha256: receiptArg.chunkSha256,
+    };
+};
+const createDurableChunkReceiptSha256 = async (payloadArg) => {
+    return createCanonicalJsonSha256(canonicalizeJson(payloadArg));
+};
+export const normalizeIsolatedRestoreDurableChunkReceipt = (valueArg) => {
+    const receipt = readRecord(valueArg, 'durable chunk receipt');
+    assertExactKeys(receipt, [
+        'version',
+        'authority',
+        'authoritySha256',
+        'descriptor',
+        'offset',
+        'decodedSize',
+        'chunkSha256',
+        'receiptSha256',
+    ], 'durable chunk receipt');
+    if (receipt.version !== 1) {
+        return fail('durable chunk receipt.version must be 1');
+    }
+    const authority = normalizeIsolatedRestoreAuthorityProjection(receipt.authority);
+    const descriptorRecord = readRecord(receipt.descriptor, 'durable chunk receipt.descriptor');
+    assertExactKeys(descriptorRecord, ['path', 'size', 'sha256'], 'durable chunk receipt.descriptor');
+    const descriptor = deepFreeze({
+        path: readRepositoryPath(descriptorRecord.path, 'durable chunk receipt.descriptor.path'),
+        size: readSafeInteger(descriptorRecord.size, 'durable chunk receipt.descriptor.size', 0, isolatedRestoreContractLimits.maximumArchiveObjectBytes),
+        sha256: readSha256(descriptorRecord.sha256, 'durable chunk receipt.descriptor.sha256'),
+    });
+    const offset = readSafeInteger(receipt.offset, 'durable chunk receipt.offset', 0, descriptor.size);
+    const decodedSize = readSafeInteger(receipt.decodedSize, 'durable chunk receipt.decodedSize', 0, isolatedRestoreContractLimits.maximumWriteChunkBytes);
+    if (descriptor.size === 0) {
+        if (offset !== 0 || decodedSize !== 0) {
+            return fail('durable chunk receipt for an empty object must describe one empty range at offset 0');
+        }
+    }
+    else if (decodedSize === 0 ||
+        offset >= descriptor.size ||
+        offset + decodedSize > descriptor.size) {
+        return fail('durable chunk receipt range does not fit its immutable descriptor');
+    }
+    return deepFreeze({
+        version: 1,
+        authority,
+        authoritySha256: readSha256(receipt.authoritySha256, 'durable chunk receipt.authoritySha256'),
+        descriptor,
+        offset,
+        decodedSize,
+        chunkSha256: readSha256(receipt.chunkSha256, 'durable chunk receipt.chunkSha256'),
+        receiptSha256: readSha256(receipt.receiptSha256, 'durable chunk receipt.receiptSha256'),
+    });
+};
+/**
+ * Rehydrates a trusted-store receipt and verifies both consistency digests.
+ * This does not replace verification of the grant that originally produced it.
+ */
+export const verifyIsolatedRestoreDurableChunkReceipt = async (valueArg) => {
+    const receipt = normalizeIsolatedRestoreDurableChunkReceipt(valueArg);
+    const authoritySha256 = await createIsolatedRestoreAuthoritySha256(receipt.authority);
+    if (authoritySha256 !== receipt.authoritySha256) {
+        return fail('durable chunk receipt authority checksum mismatch');
+    }
+    const receiptSha256 = await createDurableChunkReceiptSha256(createDurableChunkReceiptPayload(receipt));
+    if (receiptSha256 !== receipt.receiptSha256) {
+        return fail('durable chunk receipt checksum mismatch');
+    }
+    return receipt;
+};
+/**
+ * Creates a bearer-free receipt only from a runtime-verified write binding.
+ * Persist the result in authenticated/trusted Corestore state for recovery.
+ */
+export const createIsolatedRestoreDurableChunkReceipt = async (bindingArg) => {
+    const binding = requireBoundWriteRequest(bindingArg);
+    const payload = {
+        version: 1,
+        authority: binding.authority,
+        authoritySha256: binding.authoritySha256,
+        descriptor: binding.descriptor,
+        offset: binding.request.offset,
+        decodedSize: binding.chunk.decodedSize,
+        chunkSha256: binding.chunk.sha256,
+    };
+    const receiptSha256 = await createDurableChunkReceiptSha256(payload);
+    return deepFreeze({ ...payload, receiptSha256 });
+};
+/**
+ * Rehydrates ordered trusted-store receipts and verifies them against one
+ * defensive snapshot of the complete staged file. Per-range and full-file
+ * SHA-256 checks bind the resulting proof to authority, object, and receipt set.
+ */
+export const verifyIsolatedRestoreDurableCompletedObject = async (receiptsArg, contentsArg) => {
+    if (!(contentsArg instanceof Uint8Array)) {
+        return fail('durable completed object contents must be a Uint8Array');
+    }
+    if (contentsArg.byteLength >
+        isolatedRestoreContractLimits.maximumArchiveObjectBytes) {
+        return fail(`durable completed object snapshot exceeds the ${isolatedRestoreContractLimits.maximumArchiveObjectBytes}-byte object limit`);
+    }
+    const receiptEntries = readDenseArray(receiptsArg, 'durable completed object receipts', 1, isolatedRestoreContractLimits.maximumObjectChunks);
+    const contentsSnapshot = new Uint8Array(contentsArg);
+    const first = await verifyIsolatedRestoreDurableChunkReceipt(receiptEntries[0]);
+    if (first.descriptor.size === 0 && receiptEntries.length !== 1) {
+        return fail('durable completed object for an empty descriptor must contain exactly one receipt');
+    }
+    const receipts = [first];
+    for (let index = 1; index < receiptEntries.length; index++) {
+        receipts.push(await verifyIsolatedRestoreDurableChunkReceipt(receiptEntries[index]));
+    }
+    const authority = first.authority;
+    const authoritySha256 = first.authoritySha256;
+    const authorityCanonicalJson = canonicalizeIsolatedRestoreAuthorityProjection(authority);
+    const descriptor = first.descriptor;
+    if (contentsSnapshot.byteLength !== descriptor.size) {
+        return fail(`durable completed object snapshot contains ${contentsSnapshot.byteLength} of ${descriptor.size} bytes`);
+    }
+    let expectedOffset = 0;
+    for (const receipt of receipts) {
+        if (receipt.authoritySha256 !== authoritySha256 ||
+            canonicalizeIsolatedRestoreAuthorityProjection(receipt.authority) !==
+                authorityCanonicalJson) {
+            return fail('durable completed object receipts do not share one stable authority');
+        }
+        if (receipt.descriptor.path !== descriptor.path ||
+            receipt.descriptor.size !== descriptor.size ||
+            receipt.descriptor.sha256 !== descriptor.sha256) {
+            return fail('durable completed object receipts do not share one immutable descriptor');
+        }
+        if (receipt.offset !== expectedOffset) {
+            return fail(`durable completed object receipts are not contiguous at offset ${expectedOffset}`);
+        }
+        const rangeEnd = receipt.offset + receipt.decodedSize;
+        const rangeSha256 = await createIsolatedRestoreBytesSha256(contentsSnapshot.subarray(receipt.offset, rangeEnd));
+        if (rangeSha256 !== receipt.chunkSha256) {
+            return fail(`durable completed object chunk checksum mismatch at offset ${receipt.offset}`);
+        }
+        expectedOffset = rangeEnd;
+    }
+    if (expectedOffset !== descriptor.size) {
+        return fail(`durable completed object receipts cover ${expectedOffset} of ${descriptor.size} bytes`);
+    }
+    const sha256 = await createIsolatedRestoreBytesSha256(contentsSnapshot);
+    if (sha256 !== descriptor.sha256) {
+        return fail(`durable completed object checksum mismatch for ${descriptor.path}`);
+    }
+    const receiptSetSha256 = await createCanonicalJsonSha256(canonicalizeJson(receipts));
+    const proofPayload = {
+        version: 1,
+        authority,
+        authoritySha256,
+        descriptor,
+        chunkCount: receipts.length,
+        contiguousBytes: expectedOffset,
+        sha256,
+        receiptSetSha256,
+    };
+    const proofSha256 = await createCanonicalJsonSha256(canonicalizeJson(proofPayload));
+    return deepFreeze({ ...proofPayload, proofSha256 });
+};
+/**
+ * Process-local completion convenience for runtime-branded chunks. It does not
+ * survive restart. Enterprise/Corestore workflows must persist durable chunk
+ * receipts and call verifyIsolatedRestoreDurableCompletedObject after recovery.
+ * Chunks must share one authority and descriptor, cover [0, size) contiguously,
+ * and hash to the complete manifest descriptor.
+ */
+export const bindIsolatedRestoreCompletedObject = async (bindingsArg) => {
+    const entries = readDenseArray(bindingsArg, 'completed object chunks', 1, isolatedRestoreContractLimits.maximumObjectChunks);
+    const first = requireBoundWriteRequest(entries[0]);
+    const authority = first.authority;
+    const authoritySha256 = first.authoritySha256;
+    const authorityCanonicalJson = canonicalizeIsolatedRestoreAuthorityProjection(authority);
+    const descriptor = first.descriptor;
+    if (descriptor.size === 0 && entries.length !== 1) {
+        return fail('completed object for an empty descriptor must contain exactly one chunk');
+    }
+    const completeContents = new Uint8Array(descriptor.size);
+    let expectedOffset = 0;
+    for (const entry of entries) {
+        const binding = requireBoundWriteRequest(entry);
+        if (binding.authoritySha256 !== authoritySha256 ||
+            canonicalizeIsolatedRestoreAuthorityProjection(binding.authority) !==
+                authorityCanonicalJson) {
+            return fail('completed object chunks do not share one stable authority');
+        }
+        if (binding.descriptor.path !== descriptor.path ||
+            binding.descriptor.size !== descriptor.size ||
+            binding.descriptor.sha256 !== descriptor.sha256) {
+            return fail('completed object chunks do not share one immutable descriptor');
+        }
+        if (binding.request.offset !== expectedOffset) {
+            return fail(`completed object chunks are not contiguous at offset ${expectedOffset}`);
+        }
+        const contents = decodeIsolatedRestoreBoundWriteChunk(binding);
+        completeContents.set(contents, expectedOffset);
+        expectedOffset += contents.byteLength;
+    }
+    if (expectedOffset !== descriptor.size) {
+        return fail(`completed object chunks cover ${expectedOffset} of ${descriptor.size} bytes`);
+    }
+    const sha256 = await createIsolatedRestoreBytesSha256(completeContents);
+    if (sha256 !== descriptor.sha256) {
+        return fail(`completed object checksum mismatch for ${descriptor.path}`);
+    }
+    const completed = deepFreeze({
+        authority,
+        authoritySha256,
+        descriptor,
+        chunkCount: entries.length,
+        contiguousBytes: expectedOffset,
+        sha256,
+    });
+    completedIsolatedRestoreObjects.add(completed);
+    return completed;
+};
+export const assertIsolatedRestoreCompletedObject = (completedArg) => {
+    if (!completedArg ||
+        typeof completedArg !== 'object' ||
+        !completedIsolatedRestoreObjects.has(completedArg)) {
+        return fail('completed object must be produced by bindIsolatedRestoreCompletedObject');
+    }
+    return completedArg;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"isolatedrestore.js","sourceRoot":"","sources":["../../ts/data/isolatedrestore.ts"],"names":[],"mappings":"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"}