@serve.zone/interfaces 20.0.0 → 20.1.0

package/dist_ts/platform/storagemigration.js

@@ -0,0 +1,1554 @@
+import { canonicalizeStrictJson, createCanonicalJsonSha256Hex, deepFreezeValue, strictCanonicalJsonRules, } from '../private/canonicaljson.js';
+export const storageMigrationContractLimits = Object.freeze({
+    version: 1,
+    maximumControlJsonBytes: 256 * 1024,
+    maximumConfiguredStringBytes: 2048,
+    maximumIssueMessageBytes: 4096,
+    maximumAbortReasonBytes: 4096,
+    maximumEnvironmentKeyBytes: 256,
+    maximumSecretPathBytes: 2048,
+});
+export const storageMigrationCanonicalJsonRules = strictCanonicalJsonRules;
+export class StorageMigrationContractError extends Error {
+    constructor(reasonArg) {
+        super(`storage migration contract error: ${reasonArg}`);
+        this.name = 'StorageMigrationContractError';
+    }
+}
+const fail = (reasonArg) => {
+    throw new StorageMigrationContractError(reasonArg);
+};
+const utf8ByteLength = (valueArg) => {
+    return new TextEncoder().encode(valueArg).byteLength;
+};
+/**
+ * Enforce this against Content-Length and the running request byte count
+ * before buffering or decoding a storage-migration control body.
+ */
+export const assertStorageMigrationControlIngressByteLength = (valueArg) => {
+    return readSafeInteger(valueArg, 'storage migration raw control ingress byte length', 0, storageMigrationContractLimits.maximumControlJsonBytes);
+};
+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') ||
+            descriptor.value === undefined) {
+            return fail(`${fieldNameArg} must contain enumerable JSON data properties only`);
+        }
+    }
+    return record;
+};
+const readDenseArray = (valueArg, fieldNameArg, minimumLengthArg, maximumLengthArg) => {
+    if (!Array.isArray(valueArg) ||
+        Object.getPrototypeOf(valueArg) !== Array.prototype) {
+        return 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') ||
+            descriptor.value === undefined) {
+            return fail(`${fieldNameArg} must contain enumerable JSON data entries only`);
+        }
+    }
+    for (const key of Reflect.ownKeys(valueArg)) {
+        if (key === 'length')
+            continue;
+        if (typeof key !== 'string' ||
+            !/^(?:0|[1-9][0-9]*)$/.test(key) ||
+            Number(key) >= valueArg.length) {
+            return fail(`${fieldNameArg} must not contain extra properties`);
+        }
+    }
+    return valueArg;
+};
+const assertKeys = (recordArg, requiredKeysArg, optionalKeysArg, fieldNameArg) => {
+    const actualKeys = Object.keys(recordArg).sort();
+    const allowedKeys = new Set([...requiredKeysArg, ...optionalKeysArg]);
+    if (requiredKeysArg.some((keyArg) => !Object.hasOwn(recordArg, keyArg)) ||
+        actualKeys.some((keyArg) => !allowedKeys.has(keyArg))) {
+        fail(`${fieldNameArg} does not match its exact versioned schema`);
+    }
+};
+const assertExactKeys = (recordArg, expectedKeysArg, fieldNameArg) => {
+    assertKeys(recordArg, expectedKeysArg, [], fieldNameArg);
+};
+const readString = (valueArg, fieldNameArg, maximumBytesArg = storageMigrationContractLimits.maximumConfiguredStringBytes) => {
+    if (typeof valueArg !== 'string' ||
+        valueArg.length === 0 ||
+        utf8ByteLength(valueArg) > maximumBytesArg ||
+        /[\u0000-\u001f\u007f]/u.test(valueArg)) {
+        return fail(`${fieldNameArg} must be a bounded non-empty JSON string`);
+    }
+    for (let index = 0; index < valueArg.length; index++) {
+        const codeUnit = valueArg.charCodeAt(index);
+        if (codeUnit >= 0xd800 && codeUnit <= 0xdbff) {
+            const following = valueArg.charCodeAt(index + 1);
+            if (following < 0xdc00 || following > 0xdfff) {
+                return fail(`${fieldNameArg} contains an unpaired UTF-16 surrogate`);
+            }
+            index++;
+        }
+        else if (codeUnit >= 0xdc00 && codeUnit <= 0xdfff) {
+            return fail(`${fieldNameArg} contains an unpaired UTF-16 surrogate`);
+        }
+    }
+    return valueArg;
+};
+const canonicalIdPattern = /^[A-Za-z0-9][A-Za-z0-9._:@-]{0,191}$/;
+const environmentKeyPattern = /^[A-Z_][A-Z0-9_]{0,255}$/;
+const sha256Pattern = /^[a-f0-9]{64}$/;
+const capacityPattern = /^[1-9][0-9]*(?:KiB|MiB|GiB|TiB)$/;
+const readIdentifier = (valueArg, fieldNameArg) => {
+    if (typeof valueArg !== 'string' || !canonicalIdPattern.test(valueArg)) {
+        return fail(`${fieldNameArg} must be a canonical identifier`);
+    }
+    return valueArg;
+};
+const readSha256 = (valueArg, fieldNameArg) => {
+    if (typeof valueArg !== 'string' || !sha256Pattern.test(valueArg)) {
+        return fail(`${fieldNameArg} must be a bare lowercase 64-hex SHA-256 digest`);
+    }
+    return valueArg;
+};
+const readSafeInteger = (valueArg, fieldNameArg, minimumArg, maximumArg = Number.MAX_SAFE_INTEGER) => {
+    if (typeof valueArg !== 'number' ||
+        !Number.isSafeInteger(valueArg) ||
+        Object.is(valueArg, -0) ||
+        valueArg < minimumArg ||
+        valueArg > maximumArg) {
+        return fail(`${fieldNameArg} must be a safe integer between ${minimumArg} and ${maximumArg}`);
+    }
+    return valueArg;
+};
+const readBoolean = (valueArg, fieldNameArg) => {
+    if (typeof valueArg !== 'boolean') {
+        return fail(`${fieldNameArg} must be a boolean`);
+    }
+    return valueArg;
+};
+const readLiteral = (valueArg, allowedArg, fieldNameArg) => {
+    if (typeof valueArg !== 'string' ||
+        !allowedArg.includes(valueArg)) {
+        return fail(`${fieldNameArg} is outside the supported versioned values`);
+    }
+    return valueArg;
+};
+const canonicalize = (valueArg) => {
+    return canonicalizeStrictJson(valueArg, fail);
+};
+const createCanonicalSha256 = async (valueArg) => {
+    return createCanonicalJsonSha256Hex(canonicalize(valueArg), fail);
+};
+const assertControlJsonLimit = (valueArg, fieldNameArg) => {
+    const json = JSON.stringify(valueArg);
+    if (typeof json !== 'string' ||
+        utf8ByteLength(json) > storageMigrationContractLimits.maximumControlJsonBytes) {
+        return fail(`${fieldNameArg} exceeds the control JSON byte limit`);
+    }
+    return deepFreezeValue(valueArg);
+};
+const normalizePolicy = (valueArg, fieldNameArg) => {
+    const value = readRecord(valueArg, fieldNameArg);
+    assertExactKeys(value, ['classId', 'revision'], fieldNameArg);
+    return {
+        classId: readIdentifier(value.classId, `${fieldNameArg}.classId`),
+        revision: readIdentifier(value.revision, `${fieldNameArg}.revision`),
+    };
+};
+const normalizeRequirement = (valueArg, fieldNameArg) => {
+    const value = readRecord(valueArg, fieldNameArg);
+    assertKeys(value, [], [
+        'performanceTier',
+        'durability',
+        'topology',
+        'hardQuota',
+        'snapshots',
+        'backup',
+        'encryptedInTransit',
+    ], fieldNameArg);
+    if (Object.keys(value).length === 0) {
+        return fail(`${fieldNameArg} must not be empty`);
+    }
+    return {
+        ...(Object.hasOwn(value, 'performanceTier')
+            ? {
+                performanceTier: readLiteral(value.performanceTier, ['standard', 'highIops', 'capacity'], `${fieldNameArg}.performanceTier`),
+            }
+            : {}),
+        ...(Object.hasOwn(value, 'durability')
+            ? {
+                durability: readLiteral(value.durability, ['ephemeral', 'persistent'], `${fieldNameArg}.durability`),
+            }
+            : {}),
+        ...(Object.hasOwn(value, 'topology')
+            ? {
+                topology: readLiteral(value.topology, ['singleNode', 'multiNode'], `${fieldNameArg}.topology`),
+            }
+            : {}),
+        ...(Object.hasOwn(value, 'hardQuota')
+            ? {
+                hardQuota: value.hardQuota === true
+                    ? true
+                    : fail(`${fieldNameArg}.hardQuota must be true when present`),
+            }
+            : {}),
+        ...(Object.hasOwn(value, 'snapshots')
+            ? {
+                snapshots: readLiteral(value.snapshots, ['portable', 'native'], `${fieldNameArg}.snapshots`),
+            }
+            : {}),
+        ...(Object.hasOwn(value, 'backup')
+            ? {
+                backup: value.backup === true
+                    ? true
+                    : fail(`${fieldNameArg}.backup must be true when present`),
+            }
+            : {}),
+        ...(Object.hasOwn(value, 'encryptedInTransit')
+            ? {
+                encryptedInTransit: value.encryptedInTransit === true
+                    ? true
+                    : fail(`${fieldNameArg}.encryptedInTransit must be true when present`),
+            }
+            : {}),
+    };
+};
+const normalizeStorageClass = (valueArg, fieldNameArg) => {
+    const value = readRecord(valueArg, fieldNameArg);
+    assertKeys(value, ['kind', 'purpose'], ['required', 'preferred'], fieldNameArg);
+    if (value.kind !== 'objectStorage') {
+        return fail(`${fieldNameArg}.kind must be objectStorage`);
+    }
+    return {
+        kind: 'objectStorage',
+        purpose: readLiteral(value.purpose, ['runtime', 'database', 'registry', 'backup'], `${fieldNameArg}.purpose`),
+        ...(Object.hasOwn(value, 'required')
+            ? {
+                required: normalizeRequirement(value.required, `${fieldNameArg}.required`),
+            }
+            : {}),
+        ...(Object.hasOwn(value, 'preferred')
+            ? {
+                preferred: normalizeRequirement(value.preferred, `${fieldNameArg}.preferred`),
+            }
+            : {}),
+    };
+};
+const readCapacityQuantity = (valueArg, fieldNameArg) => {
+    if (typeof valueArg !== 'string' || !capacityPattern.test(valueArg)) {
+        return fail(`${fieldNameArg} must be a canonical base-2 capacity quantity`);
+    }
+    const numericPart = valueArg.replace(/(?:KiB|MiB|GiB|TiB)$/, '');
+    if (!Number.isSafeInteger(Number(numericPart))) {
+        return fail(`${fieldNameArg} exceeds the safe integer quantity range`);
+    }
+    return valueArg;
+};
+const capacityQuantityBytes = (valueArg) => {
+    const units = {
+        KiB: 1024n,
+        MiB: 1024n ** 2n,
+        GiB: 1024n ** 3n,
+        TiB: 1024n ** 4n,
+    };
+    const unit = valueArg.slice(-3);
+    return BigInt(valueArg.slice(0, -3)) * units[unit];
+};
+const normalizeCapacityRequest = (valueArg, fieldNameArg) => {
+    const value = readRecord(valueArg, fieldNameArg);
+    assertKeys(value, ['request'], ['limit'], fieldNameArg);
+    const request = readCapacityQuantity(value.request, `${fieldNameArg}.request`);
+    const limit = Object.hasOwn(value, 'limit')
+        ? readCapacityQuantity(value.limit, `${fieldNameArg}.limit`)
+        : undefined;
+    if (limit && capacityQuantityBytes(limit) < capacityQuantityBytes(request)) {
+        return fail(`${fieldNameArg}.limit must be at least request`);
+    }
+    return {
+        request,
+        ...(limit ? { limit } : {}),
+    };
+};
+const normalizeResolvedCapacity = (valueArg, fieldNameArg) => {
+    const value = readRecord(valueArg, fieldNameArg);
+    assertKeys(value, [], ['requested', 'granted', 'limit'], fieldNameArg);
+    if (Object.keys(value).length === 0) {
+        return fail(`${fieldNameArg} must not be empty`);
+    }
+    const requested = Object.hasOwn(value, 'requested')
+        ? readCapacityQuantity(value.requested, `${fieldNameArg}.requested`)
+        : undefined;
+    const granted = Object.hasOwn(value, 'granted')
+        ? readCapacityQuantity(value.granted, `${fieldNameArg}.granted`)
+        : undefined;
+    const limit = Object.hasOwn(value, 'limit')
+        ? readCapacityQuantity(value.limit, `${fieldNameArg}.limit`)
+        : undefined;
+    if (requested &&
+        granted &&
+        capacityQuantityBytes(granted) < capacityQuantityBytes(requested)) {
+        return fail(`${fieldNameArg}.granted must be at least requested`);
+    }
+    if (requested &&
+        limit &&
+        capacityQuantityBytes(limit) < capacityQuantityBytes(requested)) {
+        return fail(`${fieldNameArg}.limit must be at least requested`);
+    }
+    if (granted &&
+        limit &&
+        capacityQuantityBytes(limit) < capacityQuantityBytes(granted)) {
+        return fail(`${fieldNameArg}.limit must be at least granted`);
+    }
+    return {
+        ...(requested ? { requested } : {}),
+        ...(granted ? { granted } : {}),
+        ...(limit ? { limit } : {}),
+    };
+};
+const readEnvironmentKey = (valueArg, fieldNameArg) => {
+    if (typeof valueArg !== 'string' ||
+        utf8ByteLength(valueArg) >
+            storageMigrationContractLimits.maximumEnvironmentKeyBytes ||
+        !environmentKeyPattern.test(valueArg)) {
+        return fail(`${fieldNameArg} must be a canonical environment key`);
+    }
+    return valueArg;
+};
+const normalizeDelivery = (valueArg, fieldNameArg) => {
+    const value = readRecord(valueArg, fieldNameArg);
+    if (value.type === 'environment') {
+        assertExactKeys(value, ['type', 'keys'], fieldNameArg);
+        const keys = readRecord(value.keys, `${fieldNameArg}.keys`);
+        assertKeys(keys, ['endpoint', 'bucket', 'region', 'accessKeyId', 'secretAccessKey'], ['sessionToken'], `${fieldNameArg}.keys`);
+        const normalizedKeys = {
+            endpoint: readEnvironmentKey(keys.endpoint, `${fieldNameArg}.keys.endpoint`),
+            bucket: readEnvironmentKey(keys.bucket, `${fieldNameArg}.keys.bucket`),
+            region: readEnvironmentKey(keys.region, `${fieldNameArg}.keys.region`),
+            accessKeyId: readEnvironmentKey(keys.accessKeyId, `${fieldNameArg}.keys.accessKeyId`),
+            secretAccessKey: readEnvironmentKey(keys.secretAccessKey, `${fieldNameArg}.keys.secretAccessKey`),
+            ...(Object.hasOwn(keys, 'sessionToken')
+                ? {
+                    sessionToken: readEnvironmentKey(keys.sessionToken, `${fieldNameArg}.keys.sessionToken`),
+                }
+                : {}),
+        };
+        if (new Set(Object.values(normalizedKeys)).size !==
+            Object.keys(normalizedKeys).length) {
+            return fail(`${fieldNameArg}.keys values must be distinct`);
+        }
+        return { type: 'environment', keys: normalizedKeys };
+    }
+    if (value.type === 'secretFile') {
+        assertExactKeys(value, ['type', 'targetPath', 'format'], fieldNameArg);
+        const targetPath = readString(value.targetPath, `${fieldNameArg}.targetPath`, storageMigrationContractLimits.maximumSecretPathBytes);
+        if (!targetPath.startsWith('/run/secrets/') ||
+            targetPath.includes('\\') ||
+            targetPath.split('/').some((segmentArg) => segmentArg === '.' || segmentArg === '..')) {
+            return fail(`${fieldNameArg}.targetPath must be a canonical path below /run/secrets`);
+        }
+        if (value.format !== 'servezone-object-storage-v1') {
+            return fail(`${fieldNameArg}.format is unsupported`);
+        }
+        return {
+            type: 'secretFile',
+            targetPath,
+            format: 'servezone-object-storage-v1',
+        };
+    }
+    return fail(`${fieldNameArg}.type is unsupported`);
+};
+const normalizeCredentials = (valueArg, fieldNameArg) => {
+    const value = readRecord(valueArg, fieldNameArg);
+    assertKeys(value, ['secretBundleId', 'accessKeyIdKey', 'secretAccessKeyKey'], ['sessionTokenKey'], fieldNameArg);
+    const result = {
+        secretBundleId: readIdentifier(value.secretBundleId, `${fieldNameArg}.secretBundleId`),
+        accessKeyIdKey: readIdentifier(value.accessKeyIdKey, `${fieldNameArg}.accessKeyIdKey`),
+        secretAccessKeyKey: readIdentifier(value.secretAccessKeyKey, `${fieldNameArg}.secretAccessKeyKey`),
+        ...(Object.hasOwn(value, 'sessionTokenKey')
+            ? {
+                sessionTokenKey: readIdentifier(value.sessionTokenKey, `${fieldNameArg}.sessionTokenKey`),
+            }
+            : {}),
+    };
+    const keyNames = [
+        result.accessKeyIdKey,
+        result.secretAccessKeyKey,
+        ...(result.sessionTokenKey ? [result.sessionTokenKey] : []),
+    ];
+    if (new Set(keyNames).size !== keyNames.length) {
+        return fail(`${fieldNameArg} credential key references must be distinct`);
+    }
+    return result;
+};
+const normalizeObjectStorageProtection = (valueArg, fieldNameArg) => {
+    const value = readRecord(valueArg, fieldNameArg);
+    assertKeys(value, [], ['backup', 'versioning', 'retentionDays'], fieldNameArg);
+    if (Object.keys(value).length === 0) {
+        return fail(`${fieldNameArg} must not be empty`);
+    }
+    return {
+        ...(Object.hasOwn(value, 'backup')
+            ? {
+                backup: value.backup === 'required'
+                    ? 'required'
+                    : fail(`${fieldNameArg}.backup must be required`),
+            }
+            : {}),
+        ...(Object.hasOwn(value, 'versioning')
+            ? {
+                versioning: value.versioning === 'required'
+                    ? 'required'
+                    : fail(`${fieldNameArg}.versioning must be required`),
+            }
+            : {}),
+        ...(Object.hasOwn(value, 'retentionDays')
+            ? {
+                retentionDays: readSafeInteger(value.retentionDays, `${fieldNameArg}.retentionDays`, 1, 365_000),
+            }
+            : {}),
+    };
+};
+const normalizeObjectStorageRequest = (valueArg, fieldNameArg) => {
+    const value = readRecord(valueArg, fieldNameArg);
+    assertKeys(value, [
+        'id',
+        'kind',
+        'storageClass',
+        'accessMode',
+        'reclaimPolicy',
+        'delivery',
+    ], ['capacity', 'protection'], fieldNameArg);
+    if (value.kind !== 'objectStorage') {
+        return fail(`${fieldNameArg}.kind must be objectStorage`);
+    }
+    return {
+        id: readIdentifier(value.id, `${fieldNameArg}.id`),
+        kind: 'objectStorage',
+        storageClass: readIdentifier(value.storageClass, `${fieldNameArg}.storageClass`),
+        accessMode: readLiteral(value.accessMode, ['readOnly', 'readWrite'], `${fieldNameArg}.accessMode`),
+        reclaimPolicy: readLiteral(value.reclaimPolicy, ['retain', 'delete'], `${fieldNameArg}.reclaimPolicy`),
+        delivery: normalizeDelivery(value.delivery, `${fieldNameArg}.delivery`),
+        ...(Object.hasOwn(value, 'capacity')
+            ? {
+                capacity: normalizeCapacityRequest(value.capacity, `${fieldNameArg}.capacity`),
+            }
+            : {}),
+        ...(Object.hasOwn(value, 'protection')
+            ? {
+                protection: normalizeObjectStorageProtection(value.protection, `${fieldNameArg}.protection`),
+            }
+            : {}),
+    };
+};
+const normalizeCapabilities = (valueArg, fieldNameArg) => {
+    const value = readRecord(valueArg, fieldNameArg);
+    assertExactKeys(value, [
+        'performanceTier',
+        'durability',
+        'topology',
+        'hardQuota',
+        'snapshots',
+        'backup',
+        'encryptedInTransit',
+    ], fieldNameArg);
+    return {
+        performanceTier: readLiteral(value.performanceTier, ['standard', 'highIops', 'capacity'], `${fieldNameArg}.performanceTier`),
+        durability: readLiteral(value.durability, ['ephemeral', 'persistent'], `${fieldNameArg}.durability`),
+        topology: readLiteral(value.topology, ['singleNode', 'multiNode'], `${fieldNameArg}.topology`),
+        hardQuota: readBoolean(value.hardQuota, `${fieldNameArg}.hardQuota`),
+        snapshots: readLiteral(value.snapshots, ['none', 'portable', 'native'], `${fieldNameArg}.snapshots`),
+        backup: readBoolean(value.backup, `${fieldNameArg}.backup`),
+        encryptedInTransit: readBoolean(value.encryptedInTransit, `${fieldNameArg}.encryptedInTransit`),
+    };
+};
+const normalizeConnection = (valueArg, fieldNameArg) => {
+    const value = readRecord(valueArg, fieldNameArg);
+    assertExactKeys(value, ['endpoint', 'bucket', 'region'], fieldNameArg);
+    return {
+        endpoint: readString(value.endpoint, `${fieldNameArg}.endpoint`),
+        bucket: readIdentifier(value.bucket, `${fieldNameArg}.bucket`),
+        region: readIdentifier(value.region, `${fieldNameArg}.region`),
+    };
+};
+const normalizeObjectStorageBinding = (valueArg, expectedStatusArg, fieldNameArg) => {
+    const value = readRecord(valueArg, fieldNameArg);
+    assertKeys(value, [
+        'schemaVersion',
+        'id',
+        'serviceId',
+        'requestId',
+        'requestDigest',
+        'kind',
+        'generation',
+        'observedGeneration',
+        'status',
+        'policy',
+        'capabilities',
+        'resourceRef',
+        'accessMode',
+        'connection',
+        'credentials',
+        'delivery',
+        'versioning',
+    ], ['capacity', 'createdAt', 'updatedAt', 'retentionDays'], fieldNameArg);
+    if (value.schemaVersion !== 1) {
+        return fail(`${fieldNameArg}.schemaVersion must be 1`);
+    }
+    if (value.kind !== 'objectStorage') {
+        return fail(`${fieldNameArg}.kind must be objectStorage`);
+    }
+    if (value.status !== expectedStatusArg) {
+        return fail(`${fieldNameArg}.status must be ${expectedStatusArg}`);
+    }
+    const generation = readSafeInteger(value.generation, `${fieldNameArg}.generation`, 1);
+    const observedGeneration = readSafeInteger(value.observedGeneration, `${fieldNameArg}.observedGeneration`, 0, generation);
+    if (expectedStatusArg === 'ready' && observedGeneration !== generation) {
+        return fail(`${fieldNameArg}.observedGeneration must equal generation when ready`);
+    }
+    const createdAt = Object.hasOwn(value, 'createdAt')
+        ? readSafeInteger(value.createdAt, `${fieldNameArg}.createdAt`, 1)
+        : undefined;
+    const updatedAt = Object.hasOwn(value, 'updatedAt')
+        ? readSafeInteger(value.updatedAt, `${fieldNameArg}.updatedAt`, 1)
+        : undefined;
+    if (createdAt && updatedAt && updatedAt < createdAt) {
+        return fail(`${fieldNameArg}.updatedAt must not precede createdAt`);
+    }
+    return {
+        schemaVersion: 1,
+        id: readIdentifier(value.id, `${fieldNameArg}.id`),
+        serviceId: readIdentifier(value.serviceId, `${fieldNameArg}.serviceId`),
+        requestId: readIdentifier(value.requestId, `${fieldNameArg}.requestId`),
+        requestDigest: readSha256(value.requestDigest, `${fieldNameArg}.requestDigest`),
+        kind: 'objectStorage',
+        generation,
+        observedGeneration,
+        status: expectedStatusArg,
+        policy: normalizePolicy(value.policy, `${fieldNameArg}.policy`),
+        capabilities: normalizeCapabilities(value.capabilities, `${fieldNameArg}.capabilities`),
+        resourceRef: readIdentifier(value.resourceRef, `${fieldNameArg}.resourceRef`),
+        ...(Object.hasOwn(value, 'capacity')
+            ? {
+                capacity: normalizeResolvedCapacity(value.capacity, `${fieldNameArg}.capacity`),
+            }
+            : {}),
+        accessMode: readLiteral(value.accessMode, ['readOnly', 'readWrite'], `${fieldNameArg}.accessMode`),
+        connection: normalizeConnection(value.connection, `${fieldNameArg}.connection`),
+        credentials: normalizeCredentials(value.credentials, `${fieldNameArg}.credentials`),
+        delivery: normalizeDelivery(value.delivery, `${fieldNameArg}.delivery`),
+        versioning: readBoolean(value.versioning, `${fieldNameArg}.versioning`),
+        ...(Object.hasOwn(value, 'retentionDays')
+            ? {
+                retentionDays: readSafeInteger(value.retentionDays, `${fieldNameArg}.retentionDays`, 1, 365_000),
+            }
+            : {}),
+        ...(createdAt ? { createdAt } : {}),
+        ...(updatedAt ? { updatedAt } : {}),
+    };
+};
+const normalizeTarget = (valueArg, fieldNameArg) => {
+    const value = readRecord(valueArg, fieldNameArg);
+    assertExactKeys(value, ['policy', 'storageClass', 'request', 'credentials'], fieldNameArg);
+    return {
+        policy: normalizePolicy(value.policy, `${fieldNameArg}.policy`),
+        storageClass: normalizeStorageClass(value.storageClass, `${fieldNameArg}.storageClass`),
+        request: normalizeObjectStorageRequest(value.request, `${fieldNameArg}.request`),
+        credentials: normalizeCredentials(value.credentials, `${fieldNameArg}.credentials`),
+    };
+};
+const normalizeMigrationOwner = (valueArg, fieldNameArg) => {
+    const value = readRecord(valueArg, fieldNameArg);
+    assertExactKeys(value, ['migrationId', 'migrationDigest'], fieldNameArg);
+    return {
+        migrationId: readIdentifier(value.migrationId, `${fieldNameArg}.migrationId`),
+        migrationDigest: readSha256(value.migrationDigest, `${fieldNameArg}.migrationDigest`),
+    };
+};
+export const normalizeStorageBindingMigrationOwner = (valueArg) => {
+    return assertControlJsonLimit(normalizeMigrationOwner(valueArg, 'storage binding migration owner'), 'storage binding migration owner');
+};
+const normalizeUnfencedSnapshotShape = (valueArg, fieldNameArg) => {
+    const value = readRecord(valueArg, fieldNameArg);
+    assertExactKeys(value, [
+        'schemaVersion',
+        'binding',
+        'recordRevision',
+        'snapshotDigest',
+        'capturedAt',
+    ], fieldNameArg);
+    if (value.schemaVersion !== 1) {
+        return fail(`${fieldNameArg}.schemaVersion must be 1`);
+    }
+    return {
+        schemaVersion: 1,
+        binding: normalizeObjectStorageBinding(value.binding, 'ready', `${fieldNameArg}.binding`),
+        recordRevision: readSafeInteger(value.recordRevision, `${fieldNameArg}.recordRevision`, 1),
+        snapshotDigest: readSha256(value.snapshotDigest, `${fieldNameArg}.snapshotDigest`),
+        capturedAt: readSafeInteger(value.capturedAt, `${fieldNameArg}.capturedAt`, 1),
+    };
+};
+const normalizeFencedSnapshotShape = (valueArg, fieldNameArg) => {
+    const value = readRecord(valueArg, fieldNameArg);
+    assertExactKeys(value, [
+        'schemaVersion',
+        'binding',
+        'recordRevision',
+        'snapshotDigest',
+        'capturedAt',
+        'activeMigration',
+    ], fieldNameArg);
+    if (value.schemaVersion !== 1) {
+        return fail(`${fieldNameArg}.schemaVersion must be 1`);
+    }
+    return {
+        schemaVersion: 1,
+        binding: normalizeObjectStorageBinding(value.binding, 'ready', `${fieldNameArg}.binding`),
+        recordRevision: readSafeInteger(value.recordRevision, `${fieldNameArg}.recordRevision`, 1),
+        snapshotDigest: readSha256(value.snapshotDigest, `${fieldNameArg}.snapshotDigest`),
+        capturedAt: readSafeInteger(value.capturedAt, `${fieldNameArg}.capturedAt`, 1),
+        activeMigration: normalizeMigrationOwner(value.activeMigration, `${fieldNameArg}.activeMigration`),
+    };
+};
+const createUnfencedSnapshotDigestPayload = (snapshotArg) => ({
+    schemaVersion: 1,
+    binding: snapshotArg.binding,
+    recordRevision: snapshotArg.recordRevision,
+    capturedAt: snapshotArg.capturedAt,
+});
+const createFencedSnapshotDigestPayload = (snapshotArg) => ({
+    schemaVersion: 1,
+    binding: snapshotArg.binding,
+    recordRevision: snapshotArg.recordRevision,
+    capturedAt: snapshotArg.capturedAt,
+    activeMigration: snapshotArg.activeMigration,
+});
+export const canonicalizeUnfencedObjectStorageBindingControlSnapshotPayload = (valueArg) => {
+    const value = readRecord(valueArg, 'unfenced object-storage control snapshot digest payload');
+    assertExactKeys(value, ['schemaVersion', 'binding', 'recordRevision', 'capturedAt'], 'unfenced object-storage control snapshot digest payload');
+    const normalized = normalizeUnfencedSnapshotShape({
+        ...value,
+        snapshotDigest: '0'.repeat(64),
+    }, 'unfenced object-storage control snapshot digest payload');
+    return canonicalize(createUnfencedSnapshotDigestPayload(normalized));
+};
+export const canonicalizeFencedObjectStorageBindingControlSnapshotPayload = (valueArg) => {
+    const value = readRecord(valueArg, 'fenced object-storage control snapshot digest payload');
+    assertExactKeys(value, [
+        'schemaVersion',
+        'binding',
+        'recordRevision',
+        'capturedAt',
+        'activeMigration',
+    ], 'fenced object-storage control snapshot digest payload');
+    const normalized = normalizeFencedSnapshotShape({
+        ...value,
+        snapshotDigest: '0'.repeat(64),
+    }, 'fenced object-storage control snapshot digest payload');
+    return canonicalize(createFencedSnapshotDigestPayload(normalized));
+};
+export const createUnfencedObjectStorageBindingControlSnapshotSha256 = async (valueArg) => {
+    return createCanonicalJsonSha256Hex(canonicalizeUnfencedObjectStorageBindingControlSnapshotPayload(valueArg), fail);
+};
+export const createFencedObjectStorageBindingControlSnapshotSha256 = async (valueArg) => {
+    return createCanonicalJsonSha256Hex(canonicalizeFencedObjectStorageBindingControlSnapshotPayload(valueArg), fail);
+};
+export const normalizeUnfencedObjectStorageBindingControlSnapshot = async (valueArg) => {
+    const normalized = normalizeUnfencedSnapshotShape(valueArg, 'unfenced object-storage control snapshot');
+    const actualDigest = await createCanonicalSha256(createUnfencedSnapshotDigestPayload(normalized));
+    if (normalized.snapshotDigest !== actualDigest) {
+        return fail('unfenced object-storage control snapshot.snapshotDigest does not match its canonical payload');
+    }
+    return assertControlJsonLimit(normalized, 'unfenced object-storage control snapshot');
+};
+export const normalizeFencedObjectStorageBindingControlSnapshot = async (valueArg) => {
+    const normalized = normalizeFencedSnapshotShape(valueArg, 'fenced object-storage control snapshot');
+    const actualDigest = await createCanonicalSha256(createFencedSnapshotDigestPayload(normalized));
+    if (normalized.snapshotDigest !== actualDigest) {
+        return fail('fenced object-storage control snapshot.snapshotDigest does not match its canonical payload');
+    }
+    return assertControlJsonLimit(normalized, 'fenced object-storage control snapshot');
+};
+export const normalizeObjectStorageMigrationTarget = (valueArg) => {
+    return assertControlJsonLimit(normalizeTarget(valueArg, 'object-storage migration target'), 'object-storage migration target');
+};
+export const normalizeStagedObjectStorageBinding = (valueArg) => {
+    return assertControlJsonLimit(normalizeObjectStorageBinding(valueArg, 'provisioning', 'staged object-storage binding'), 'staged object-storage binding');
+};
+export const normalizeActiveObjectStorageBinding = (valueArg) => {
+    return assertControlJsonLimit(normalizeObjectStorageBinding(valueArg, 'ready', 'active object-storage binding'), 'active object-storage binding');
+};
+export const canonicalizeObjectStorageMigrationTargetRequest = (valueArg) => {
+    return canonicalize(normalizeObjectStorageRequest(valueArg, 'object-storage migration target request'));
+};
+export const createObjectStorageMigrationTargetRequestSha256 = async (valueArg) => {
+    return createCanonicalJsonSha256Hex(canonicalizeObjectStorageMigrationTargetRequest(valueArg), fail);
+};
+export const canonicalizeObjectStorageMigrationBinding = (valueArg) => {
+    const value = readRecord(valueArg, 'object-storage migration binding');
+    const status = readLiteral(value.status, ['provisioning', 'ready'], 'object-storage migration binding.status');
+    return canonicalize(normalizeObjectStorageBinding(value, status, 'object-storage migration binding'));
+};
+export const createObjectStorageMigrationBindingSha256 = async (valueArg) => {
+    return createCanonicalJsonSha256Hex(canonicalizeObjectStorageMigrationBinding(valueArg), fail);
+};
+const assertTargetIdentity = async (targetArg, sourceBindingArg, fieldNameArg) => {
+    if (targetArg.request.id !== sourceBindingArg.requestId) {
+        fail(`${fieldNameArg}.request.id must equal the source binding requestId`);
+    }
+    if (targetArg.request.storageClass.length === 0) {
+        fail(`${fieldNameArg}.request.storageClass must not be empty`);
+    }
+    const required = targetArg.storageClass.required;
+    if (required?.durability === 'ephemeral') {
+        fail(`${fieldNameArg}.storageClass cannot request ephemeral migration storage`);
+    }
+};
+const normalizePrepareRequestShape = (valueArg) => {
+    const value = readRecord(valueArg, 'object-storage migration prepare request');
+    assertExactKeys(value, [
+        'schemaVersion',
+        'migrationId',
+        'sourceControlSnapshot',
+        'workloadGeneration',
+        'target',
+    ], 'object-storage migration prepare request');
+    if (value.schemaVersion !== 1) {
+        return fail('object-storage migration prepare request.schemaVersion must be 1');
+    }
+    return {
+        schemaVersion: 1,
+        migrationId: readIdentifier(value.migrationId, 'object-storage migration prepare request.migrationId'),
+        sourceControlSnapshot: normalizeUnfencedSnapshotShape(value.sourceControlSnapshot, 'object-storage migration prepare request.sourceControlSnapshot'),
+        workloadGeneration: readSafeInteger(value.workloadGeneration, 'object-storage migration prepare request.workloadGeneration', 1),
+        target: normalizeTarget(value.target, 'object-storage migration prepare request.target'),
+    };
+};
+export const normalizeObjectStorageMigrationPrepareRequest = async (valueArg) => {
+    const normalized = normalizePrepareRequestShape(valueArg);
+    await normalizeUnfencedObjectStorageBindingControlSnapshot(normalized.sourceControlSnapshot);
+    await assertTargetIdentity(normalized.target, normalized.sourceControlSnapshot.binding, 'object-storage migration prepare request.target');
+    return assertControlJsonLimit(normalized, 'object-storage migration prepare request');
+};
+export const canonicalizeObjectStorageMigrationPrepareRequest = async (valueArg) => {
+    return canonicalize(await normalizeObjectStorageMigrationPrepareRequest(valueArg));
+};
+export const createObjectStorageMigrationSha256 = async (valueArg) => {
+    return createCanonicalJsonSha256Hex(await canonicalizeObjectStorageMigrationPrepareRequest(valueArg), fail);
+};
+const normalizeProgress = (valueArg, fieldNameArg) => {
+    const value = readRecord(valueArg, fieldNameArg);
+    assertKeys(value, ['objectsCopied', 'logicalBytesCopied', 'updatedAt'], [
+        'physicalBytesCopied',
+        'objectsTotal',
+        'logicalBytesTotal',
+        'physicalBytesTotal',
+    ], fieldNameArg);
+    const objectsCopied = readSafeInteger(value.objectsCopied, `${fieldNameArg}.objectsCopied`, 0);
+    const logicalBytesCopied = readSafeInteger(value.logicalBytesCopied, `${fieldNameArg}.logicalBytesCopied`, 0);
+    const physicalBytesCopied = Object.hasOwn(value, 'physicalBytesCopied')
+        ? readSafeInteger(value.physicalBytesCopied, `${fieldNameArg}.physicalBytesCopied`, 0)
+        : undefined;
+    const objectsTotal = Object.hasOwn(value, 'objectsTotal')
+        ? readSafeInteger(value.objectsTotal, `${fieldNameArg}.objectsTotal`, 0)
+        : undefined;
+    const logicalBytesTotal = Object.hasOwn(value, 'logicalBytesTotal')
+        ? readSafeInteger(value.logicalBytesTotal, `${fieldNameArg}.logicalBytesTotal`, 0)
+        : undefined;
+    const physicalBytesTotal = Object.hasOwn(value, 'physicalBytesTotal')
+        ? readSafeInteger(value.physicalBytesTotal, `${fieldNameArg}.physicalBytesTotal`, 0)
+        : undefined;
+    if (objectsTotal !== undefined && objectsCopied > objectsTotal) {
+        return fail(`${fieldNameArg}.objectsCopied exceeds objectsTotal`);
+    }
+    if (logicalBytesTotal !== undefined &&
+        logicalBytesCopied > logicalBytesTotal) {
+        return fail(`${fieldNameArg}.logicalBytesCopied exceeds logicalBytesTotal`);
+    }
+    if (physicalBytesTotal !== undefined &&
+        physicalBytesCopied !== undefined &&
+        physicalBytesCopied > physicalBytesTotal) {
+        return fail(`${fieldNameArg}.physicalBytesCopied exceeds physicalBytesTotal`);
+    }
+    return {
+        objectsCopied,
+        logicalBytesCopied,
+        ...(physicalBytesCopied !== undefined ? { physicalBytesCopied } : {}),
+        ...(objectsTotal !== undefined ? { objectsTotal } : {}),
+        ...(logicalBytesTotal !== undefined ? { logicalBytesTotal } : {}),
+        ...(physicalBytesTotal !== undefined ? { physicalBytesTotal } : {}),
+        updatedAt: readSafeInteger(value.updatedAt, `${fieldNameArg}.updatedAt`, 1),
+    };
+};
+const normalizeIssue = (valueArg, kindArg, fieldNameArg) => {
+    const value = readRecord(valueArg, fieldNameArg);
+    assertExactKeys(value, ['code', 'message', 'retryable', 'observedAt', 'allowedRecoveryActions'], fieldNameArg);
+    const entries = readDenseArray(value.allowedRecoveryActions, `${fieldNameArg}.allowedRecoveryActions`, 1, 2);
+    const allowed = kindArg === 'pre'
+        ? ['retry', 'abort']
+        : ['retry', 'rollForward'];
+    const actions = entries.map((entryArg, indexArg) => readLiteral(entryArg, allowed, `${fieldNameArg}.allowedRecoveryActions[${indexArg}]`));
+    if (new Set(actions).size !== actions.length) {
+        return fail(`${fieldNameArg}.allowedRecoveryActions must be distinct`);
+    }
+    const retryable = readBoolean(value.retryable, `${fieldNameArg}.retryable`);
+    if (retryable !== actions.includes('retry')) {
+        return fail(`${fieldNameArg}.retryable must match whether retry is an allowed action`);
+    }
+    return {
+        code: readIdentifier(value.code, `${fieldNameArg}.code`),
+        message: readString(value.message, `${fieldNameArg}.message`, storageMigrationContractLimits.maximumIssueMessageBytes),
+        retryable,
+        observedAt: readSafeInteger(value.observedAt, `${fieldNameArg}.observedAt`, 1),
+        allowedRecoveryActions: actions,
+    };
+};
+const normalizeMutationFence = (valueArg, fieldNameArg) => {
+    if (valueArg.schemaVersion !== 1) {
+        return fail(`${fieldNameArg}.schemaVersion must be 1`);
+    }
+    return {
+        schemaVersion: 1,
+        migrationId: readIdentifier(valueArg.migrationId, `${fieldNameArg}.migrationId`),
+        migrationDigest: readSha256(valueArg.migrationDigest, `${fieldNameArg}.migrationDigest`),
+        expectedMigrationRevision: readSafeInteger(valueArg.expectedMigrationRevision, `${fieldNameArg}.expectedMigrationRevision`, 1),
+        mutationId: readIdentifier(valueArg.mutationId, `${fieldNameArg}.mutationId`),
+    };
+};
+export const normalizeStorageMigrationMutationFence = (valueArg) => {
+    const fieldName = 'storage migration mutation fence';
+    const value = readRecord(valueArg, fieldName);
+    assertExactKeys(value, [
+        'schemaVersion',
+        'migrationId',
+        'migrationDigest',
+        'expectedMigrationRevision',
+        'mutationId',
+    ], fieldName);
+    return assertControlJsonLimit(normalizeMutationFence(value, fieldName), fieldName);
+};
+const normalizeQuiesceRequestShape = (valueArg) => {
+    const fieldName = 'object-storage migration consumer quiesce request';
+    const value = readRecord(valueArg, fieldName);
+    assertExactKeys(value, [
+        'schemaVersion',
+        'migrationId',
+        'migrationDigest',
+        'expectedMigrationRevision',
+        'mutationId',
+        'sourceRecordRevision',
+        'sourceControlSnapshotDigest',
+        'candidateDigest',
+        'workloadGeneration',
+        'persistedStagingDigest',
+        'persistedStagingRevision',
+        'consumerStoppedAt',
+    ], fieldName);
+    return {
+        ...normalizeMutationFence(value, fieldName),
+        sourceRecordRevision: readSafeInteger(value.sourceRecordRevision, `${fieldName}.sourceRecordRevision`, 1),
+        sourceControlSnapshotDigest: readSha256(value.sourceControlSnapshotDigest, `${fieldName}.sourceControlSnapshotDigest`),
+        candidateDigest: readSha256(value.candidateDigest, `${fieldName}.candidateDigest`),
+        workloadGeneration: readSafeInteger(value.workloadGeneration, `${fieldName}.workloadGeneration`, 1),
+        persistedStagingDigest: readSha256(value.persistedStagingDigest, `${fieldName}.persistedStagingDigest`),
+        persistedStagingRevision: readSafeInteger(value.persistedStagingRevision, `${fieldName}.persistedStagingRevision`, 1),
+        consumerStoppedAt: readSafeInteger(value.consumerStoppedAt, `${fieldName}.consumerStoppedAt`, 1),
+    };
+};
+const createPersistedStagingDigestPayload = (requestArg) => ({
+    schemaVersion: 1,
+    migrationId: requestArg.migrationId,
+    migrationDigest: requestArg.migrationDigest,
+    expectedMigrationRevision: requestArg.expectedMigrationRevision,
+    mutationId: requestArg.mutationId,
+    sourceRecordRevision: requestArg.sourceRecordRevision,
+    sourceControlSnapshotDigest: requestArg.sourceControlSnapshotDigest,
+    candidateDigest: requestArg.candidateDigest,
+    workloadGeneration: requestArg.workloadGeneration,
+    persistedStagingRevision: requestArg.persistedStagingRevision,
+    consumerStoppedAt: requestArg.consumerStoppedAt,
+});
+export const createObjectStorageMigrationPersistedStagingSha256 = async (valueArg) => {
+    const value = readRecord(valueArg, 'persisted staging digest payload');
+    assertExactKeys(value, [
+        'schemaVersion',
+        'migrationId',
+        'migrationDigest',
+        'expectedMigrationRevision',
+        'mutationId',
+        'sourceRecordRevision',
+        'sourceControlSnapshotDigest',
+        'candidateDigest',
+        'workloadGeneration',
+        'persistedStagingRevision',
+        'consumerStoppedAt',
+    ], 'persisted staging digest payload');
+    const request = normalizeQuiesceRequestShape({
+        ...value,
+        persistedStagingDigest: '0'.repeat(64),
+    });
+    return createCanonicalSha256(createPersistedStagingDigestPayload(request));
+};
+export const normalizeObjectStorageMigrationConsumerQuiesceRequest = async (valueArg) => {
+    const normalized = normalizeQuiesceRequestShape(valueArg);
+    const actualDigest = await createCanonicalSha256(createPersistedStagingDigestPayload(normalized));
+    if (normalized.persistedStagingDigest !== actualDigest) {
+        return fail('object-storage migration consumer quiesce request.persistedStagingDigest does not match its canonical payload');
+    }
+    return assertControlJsonLimit(normalized, 'object-storage migration consumer quiesce request');
+};
+const normalizeActivationRequestShape = (valueArg) => {
+    const fieldName = 'object-storage migration consumer activation request';
+    const value = readRecord(valueArg, fieldName);
+    assertExactKeys(value, [
+        'schemaVersion',
+        'migrationId',
+        'migrationDigest',
+        'expectedMigrationRevision',
+        'mutationId',
+        'candidateDigest',
+        'activeBindingDigest',
+        'workloadGeneration',
+        'persistedActivationDigest',
+        'persistedActivationRevision',
+        'consumerStartedAt',
+    ], fieldName);
+    return {
+        ...normalizeMutationFence(value, fieldName),
+        candidateDigest: readSha256(value.candidateDigest, `${fieldName}.candidateDigest`),
+        activeBindingDigest: readSha256(value.activeBindingDigest, `${fieldName}.activeBindingDigest`),
+        workloadGeneration: readSafeInteger(value.workloadGeneration, `${fieldName}.workloadGeneration`, 1),
+        persistedActivationDigest: readSha256(value.persistedActivationDigest, `${fieldName}.persistedActivationDigest`),
+        persistedActivationRevision: readSafeInteger(value.persistedActivationRevision, `${fieldName}.persistedActivationRevision`, 1),
+        consumerStartedAt: readSafeInteger(value.consumerStartedAt, `${fieldName}.consumerStartedAt`, 1),
+    };
+};
+const createPersistedActivationDigestPayload = (requestArg) => ({
+    schemaVersion: 1,
+    migrationId: requestArg.migrationId,
+    migrationDigest: requestArg.migrationDigest,
+    expectedMigrationRevision: requestArg.expectedMigrationRevision,
+    mutationId: requestArg.mutationId,
+    candidateDigest: requestArg.candidateDigest,
+    activeBindingDigest: requestArg.activeBindingDigest,
+    workloadGeneration: requestArg.workloadGeneration,
+    persistedActivationRevision: requestArg.persistedActivationRevision,
+    consumerStartedAt: requestArg.consumerStartedAt,
+});
+export const createObjectStorageMigrationPersistedActivationSha256 = async (valueArg) => {
+    const value = readRecord(valueArg, 'persisted activation digest payload');
+    assertExactKeys(value, [
+        'schemaVersion',
+        'migrationId',
+        'migrationDigest',
+        'expectedMigrationRevision',
+        'mutationId',
+        'candidateDigest',
+        'activeBindingDigest',
+        'workloadGeneration',
+        'persistedActivationRevision',
+        'consumerStartedAt',
+    ], 'persisted activation digest payload');
+    const request = normalizeActivationRequestShape({
+        ...value,
+        persistedActivationDigest: '0'.repeat(64),
+    });
+    return createCanonicalSha256(createPersistedActivationDigestPayload(request));
+};
+export const normalizeObjectStorageMigrationConsumerActivationRequest = async (valueArg) => {
+    const normalized = normalizeActivationRequestShape(valueArg);
+    const actualDigest = await createCanonicalSha256(createPersistedActivationDigestPayload(normalized));
+    if (normalized.persistedActivationDigest !== actualDigest) {
+        return fail('object-storage migration consumer activation request.persistedActivationDigest does not match its canonical payload');
+    }
+    return assertControlJsonLimit(normalized, 'object-storage migration consumer activation request');
+};
+const normalizeQuiesceEvidence = async (valueArg, fieldNameArg) => {
+    const value = readRecord(valueArg, fieldNameArg);
+    assertExactKeys(value, ['request', 'acceptedMigrationRevision', 'acceptedAt'], fieldNameArg);
+    const request = await normalizeObjectStorageMigrationConsumerQuiesceRequest(value.request);
+    const acceptedMigrationRevision = readSafeInteger(value.acceptedMigrationRevision, `${fieldNameArg}.acceptedMigrationRevision`, 1);
+    if (acceptedMigrationRevision <= request.expectedMigrationRevision) {
+        return fail(`${fieldNameArg}.acceptedMigrationRevision must advance the requested revision`);
+    }
+    const acceptedAt = readSafeInteger(value.acceptedAt, `${fieldNameArg}.acceptedAt`, request.consumerStoppedAt);
+    return { request, acceptedMigrationRevision, acceptedAt };
+};
+const normalizeActivationEvidence = async (valueArg, fieldNameArg) => {
+    const value = readRecord(valueArg, fieldNameArg);
+    assertExactKeys(value, ['request', 'acceptedMigrationRevision', 'acceptedAt'], fieldNameArg);
+    const request = await normalizeObjectStorageMigrationConsumerActivationRequest(value.request);
+    const acceptedMigrationRevision = readSafeInteger(value.acceptedMigrationRevision, `${fieldNameArg}.acceptedMigrationRevision`, 1);
+    if (acceptedMigrationRevision <= request.expectedMigrationRevision) {
+        return fail(`${fieldNameArg}.acceptedMigrationRevision must advance the requested revision`);
+    }
+    const acceptedAt = readSafeInteger(value.acceptedAt, `${fieldNameArg}.acceptedAt`, request.consumerStartedAt);
+    return { request, acceptedMigrationRevision, acceptedAt };
+};
+export const normalizeStorageMigrationConsumerQuiesceEvidence = async (valueArg) => {
+    return assertControlJsonLimit(await normalizeQuiesceEvidence(valueArg, 'storage migration consumer quiesce evidence'), 'storage migration consumer quiesce evidence');
+};
+export const normalizeStorageMigrationConsumerActivationEvidence = async (valueArg) => {
+    return assertControlJsonLimit(await normalizeActivationEvidence(valueArg, 'storage migration consumer activation evidence'), 'storage migration consumer activation evidence');
+};
+export const normalizeObjectStorageMigrationAbortRequest = (valueArg) => {
+    const fieldName = 'object-storage migration abort request';
+    const value = readRecord(valueArg, fieldName);
+    assertExactKeys(value, [
+        'schemaVersion',
+        'migrationId',
+        'migrationDigest',
+        'expectedMigrationRevision',
+        'mutationId',
+        'reason',
+    ], fieldName);
+    return assertControlJsonLimit({
+        ...normalizeMutationFence(value, fieldName),
+        reason: readString(value.reason, `${fieldName}.reason`, storageMigrationContractLimits.maximumAbortReasonBytes),
+    }, fieldName);
+};
+export const normalizeObjectStorageMigrationResumeRequest = (valueArg) => {
+    const fieldName = 'object-storage migration resume request';
+    const value = readRecord(valueArg, fieldName);
+    assertExactKeys(value, [
+        'schemaVersion',
+        'migrationId',
+        'migrationDigest',
+        'expectedMigrationRevision',
+        'mutationId',
+        'action',
+    ], fieldName);
+    return assertControlJsonLimit({
+        ...normalizeMutationFence(value, fieldName),
+        action: readLiteral(value.action, ['retry', 'abort', 'rollForward'], `${fieldName}.action`),
+    }, fieldName);
+};
+export const normalizeObjectStorageMigrationCleanupRequest = (valueArg) => {
+    const fieldName = 'object-storage migration cleanup request';
+    const value = readRecord(valueArg, fieldName);
+    assertExactKeys(value, [
+        'schemaVersion',
+        'migrationId',
+        'migrationDigest',
+        'expectedMigrationRevision',
+        'mutationId',
+    ], fieldName);
+    return assertControlJsonLimit(normalizeMutationFence(value, fieldName), fieldName);
+};
+const assertCapabilitiesSatisfyTarget = (bindingArg, targetArg, fieldNameArg) => {
+    const required = targetArg.storageClass.required;
+    const capabilities = bindingArg.capabilities;
+    if (required) {
+        for (const key of [
+            'performanceTier',
+            'durability',
+            'topology',
+            'snapshots',
+        ]) {
+            const requirement = required[key];
+            if (requirement !== undefined && capabilities[key] !== requirement) {
+                fail(`${fieldNameArg}.capabilities.${key} does not satisfy target requirements`);
+            }
+        }
+        for (const key of [
+            'hardQuota',
+            'backup',
+            'encryptedInTransit',
+        ]) {
+            if (required[key] === true && capabilities[key] !== true) {
+                fail(`${fieldNameArg}.capabilities.${key} does not satisfy target requirements`);
+            }
+        }
+    }
+};
+const assertCandidateIdentity = async (candidateArg, sourceArg, targetArg, fieldNameArg) => {
+    if (candidateArg.id !== sourceArg.id ||
+        candidateArg.serviceId !== sourceArg.serviceId ||
+        candidateArg.requestId !== sourceArg.requestId) {
+        fail(`${fieldNameArg} must preserve binding, service, and request identity`);
+    }
+    if (candidateArg.requestId !== targetArg.request.id) {
+        fail(`${fieldNameArg}.requestId must equal target.request.id`);
+    }
+    const targetRequestDigest = await createObjectStorageMigrationTargetRequestSha256(targetArg.request);
+    if (candidateArg.requestDigest !== targetRequestDigest) {
+        fail(`${fieldNameArg}.requestDigest does not match target.request`);
+    }
+    if (canonicalize(candidateArg.policy) !== canonicalize(targetArg.policy) ||
+        canonicalize(candidateArg.credentials) !==
+            canonicalize(targetArg.credentials) ||
+        canonicalize(candidateArg.delivery) !==
+            canonicalize(targetArg.request.delivery)) {
+        fail(`${fieldNameArg} does not match the target policy and delivery intent`);
+    }
+    if (candidateArg.accessMode !== targetArg.request.accessMode) {
+        fail(`${fieldNameArg}.accessMode does not match target.request.accessMode`);
+    }
+    if (candidateArg.resourceRef === sourceArg.resourceRef) {
+        fail(`${fieldNameArg}.resourceRef must differ from the source resource`);
+    }
+    if (candidateArg.generation <= sourceArg.generation) {
+        fail(`${fieldNameArg}.generation must advance the source generation`);
+    }
+    if (targetArg.request.capacity) {
+        if (candidateArg.capacity?.requested !== targetArg.request.capacity.request ||
+            candidateArg.capacity?.limit !== targetArg.request.capacity.limit) {
+            fail(`${fieldNameArg}.capacity must preserve the target request bounds`);
+        }
+    }
+    if (targetArg.request.protection?.backup === 'required' &&
+        candidateArg.capabilities.backup !== true) {
+        fail(`${fieldNameArg}.capabilities.backup does not satisfy target protection`);
+    }
+    if (targetArg.request.capacity?.limit !== undefined &&
+        candidateArg.capabilities.hardQuota !== true) {
+        fail(`${fieldNameArg}.capabilities.hardQuota is required by target capacity.limit`);
+    }
+    if (targetArg.request.protection?.versioning === 'required' &&
+        candidateArg.versioning !== true) {
+        fail(`${fieldNameArg}.versioning does not satisfy target protection`);
+    }
+    if (targetArg.request.protection?.retentionDays !== undefined &&
+        (candidateArg.retentionDays ?? 0) <
+            targetArg.request.protection.retentionDays) {
+        fail(`${fieldNameArg}.retentionDays does not satisfy target protection`);
+    }
+    assertCapabilitiesSatisfyTarget(candidateArg, targetArg, fieldNameArg);
+};
+const assertActiveMatchesCandidate = (activeArg, candidateArg, fieldNameArg) => {
+    const immutableKeys = [
+        'schemaVersion',
+        'id',
+        'serviceId',
+        'requestId',
+        'requestDigest',
+        'kind',
+        'generation',
+        'policy',
+        'capabilities',
+        'resourceRef',
+        'capacity',
+        'accessMode',
+        'connection',
+        'credentials',
+        'delivery',
+        'versioning',
+        'retentionDays',
+        'createdAt',
+    ];
+    for (const key of immutableKeys) {
+        if (canonicalize(activeArg[key] ?? null) !== canonicalize(candidateArg[key] ?? null)) {
+            fail(`${fieldNameArg}.${key} must match the issued candidate`);
+        }
+    }
+};
+const normalizeSourceEvidence = async (valueArg, fieldNameArg) => {
+    const value = readRecord(valueArg, fieldNameArg);
+    assertExactKeys(value, ['preparationSnapshot', 'fencedSnapshot'], fieldNameArg);
+    const preparationSnapshot = await normalizeUnfencedObjectStorageBindingControlSnapshot(value.preparationSnapshot);
+    const fencedSnapshot = await normalizeFencedObjectStorageBindingControlSnapshot(value.fencedSnapshot);
+    if (fencedSnapshot.recordRevision <= preparationSnapshot.recordRevision ||
+        fencedSnapshot.capturedAt < preparationSnapshot.capturedAt) {
+        return fail(`${fieldNameArg}.fencedSnapshot must be captured at a later record revision`);
+    }
+    if (canonicalize(fencedSnapshot.binding) !==
+        canonicalize(preparationSnapshot.binding)) {
+        return fail(`${fieldNameArg}.fencedSnapshot.binding must exactly preserve the prepared source binding`);
+    }
+    return {
+        preparationSnapshot,
+        fencedSnapshot,
+    };
+};
+export const normalizeStorageMigrationSourceEvidence = async (valueArg) => {
+    return assertControlJsonLimit(await normalizeSourceEvidence(valueArg, 'storage migration source evidence'), 'storage migration source evidence');
+};
+const assertEvidenceFence = (fenceArg, migrationIdArg, migrationDigestArg, migrationRevisionArg, fieldNameArg) => {
+    if (fenceArg.migrationId !== migrationIdArg ||
+        fenceArg.migrationDigest !== migrationDigestArg) {
+        fail(`${fieldNameArg} does not match the migration identity`);
+    }
+    if (fenceArg.expectedMigrationRevision >= migrationRevisionArg) {
+        fail(`${fieldNameArg}.expectedMigrationRevision must precede status revision`);
+    }
+};
+const statusBaseRequiredKeys = [
+    'schemaVersion',
+    'migrationId',
+    'migrationDigest',
+    'migrationRevision',
+    'bindingId',
+    'serviceId',
+    'requestId',
+    'workloadGeneration',
+    'target',
+    'source',
+    'createdAt',
+    'updatedAt',
+    'phase',
+    'bindingFenceActive',
+    'candidateIssued',
+    'commitPointCrossed',
+    'destinationBindingStartAuthorized',
+    'authority',
+    'consumerAction',
+];
+const assertFieldValue = (recordArg, keyArg, expectedArg, fieldNameArg) => {
+    if (recordArg[keyArg] !== expectedArg) {
+        fail(`${fieldNameArg}.${keyArg} must be ${String(expectedArg)}`);
+    }
+};
+export const normalizeObjectStorageMigrationStatus = async (valueArg) => {
+    const fieldName = 'object-storage migration status';
+    const value = readRecord(valueArg, fieldName);
+    const phase = readLiteral(value.phase, [
+        'preparing',
+        'transferring',
+        'awaitingConsumerQuiesce',
+        'finalizing',
+        'committing',
+        'readyToStart',
+        'cleanupPending',
+        'complete',
+        'aborting',
+        'aborted',
+    ], `${fieldName}.phase`);
+    const candidateIssued = readBoolean(value.candidateIssued, `${fieldName}.candidateIssued`);
+    const phaseRequired = [];
+    const phaseOptional = ['progress'];
+    if (phase !== 'complete' && phase !== 'aborted') {
+        phaseOptional.push('issue');
+    }
+    if (['awaitingConsumerQuiesce', 'finalizing', 'committing', 'readyToStart',
+        'cleanupPending', 'complete'].includes(phase)) {
+        phaseRequired.push('candidateBinding', 'candidateDigest');
+    }
+    else if ((phase === 'aborting' || phase === 'aborted') &&
+        candidateIssued) {
+        phaseRequired.push('candidateDigest');
+    }
+    if (['finalizing', 'committing', 'readyToStart', 'cleanupPending', 'complete']
+        .includes(phase)) {
+        phaseRequired.push('consumerQuiesceEvidence');
+    }
+    else if ((phase === 'aborting' || phase === 'aborted') &&
+        candidateIssued) {
+        phaseOptional.push('consumerQuiesceEvidence');
+    }
+    if (phase === 'cleanupPending' || phase === 'complete') {
+        phaseRequired.push('consumerActivationEvidence');
+    }
+    if (phase === 'readyToStart' ||
+        phase === 'cleanupPending' ||
+        phase === 'complete' ||
+        phase === 'aborted') {
+        phaseRequired.push('activeBinding', 'activeBindingDigest');
+    }
+    if (phase === 'complete' || phase === 'aborted') {
+        phaseRequired.push('terminalAt');
+    }
+    assertKeys(value, [...statusBaseRequiredKeys, ...phaseRequired], phaseOptional, fieldName);
+    if (value.schemaVersion !== 1) {
+        return fail(`${fieldName}.schemaVersion must be 1`);
+    }
+    const migrationId = readIdentifier(value.migrationId, `${fieldName}.migrationId`);
+    const migrationDigest = readSha256(value.migrationDigest, `${fieldName}.migrationDigest`);
+    const migrationRevision = readSafeInteger(value.migrationRevision, `${fieldName}.migrationRevision`, 1);
+    const bindingId = readIdentifier(value.bindingId, `${fieldName}.bindingId`);
+    const serviceId = readIdentifier(value.serviceId, `${fieldName}.serviceId`);
+    const requestId = readIdentifier(value.requestId, `${fieldName}.requestId`);
+    const workloadGeneration = readSafeInteger(value.workloadGeneration, `${fieldName}.workloadGeneration`, 1);
+    const target = normalizeTarget(value.target, `${fieldName}.target`);
+    const source = await normalizeSourceEvidence(value.source, `${fieldName}.source`);
+    const sourceBinding = source.preparationSnapshot.binding;
+    if (bindingId !== sourceBinding.id ||
+        serviceId !== sourceBinding.serviceId ||
+        requestId !== sourceBinding.requestId ||
+        target.request.id !== requestId) {
+        return fail(`${fieldName} identity must match source and target bindings`);
+    }
+    await assertTargetIdentity(target, sourceBinding, `${fieldName}.target`);
+    const recomputedMigrationDigest = await createObjectStorageMigrationSha256({
+        schemaVersion: 1,
+        migrationId,
+        sourceControlSnapshot: source.preparationSnapshot,
+        workloadGeneration,
+        target,
+    });
+    if (migrationDigest !== recomputedMigrationDigest ||
+        source.fencedSnapshot.activeMigration.migrationId !== migrationId ||
+        source.fencedSnapshot.activeMigration.migrationDigest !== migrationDigest) {
+        return fail(`${fieldName}.migrationDigest and fenced owner must match canonical prepare intent`);
+    }
+    const createdAt = readSafeInteger(value.createdAt, `${fieldName}.createdAt`, 1);
+    const updatedAt = readSafeInteger(value.updatedAt, `${fieldName}.updatedAt`, createdAt);
+    const progress = Object.hasOwn(value, 'progress')
+        ? normalizeProgress(value.progress, `${fieldName}.progress`)
+        : undefined;
+    if (progress && (progress.updatedAt < createdAt || progress.updatedAt > updatedAt)) {
+        return fail(`${fieldName}.progress.updatedAt must be within status time bounds`);
+    }
+    const preIssuePhase = [
+        'preparing',
+        'transferring',
+        'awaitingConsumerQuiesce',
+        'finalizing',
+        'aborting',
+    ].includes(phase);
+    const issue = Object.hasOwn(value, 'issue')
+        ? normalizeIssue(value.issue, preIssuePhase ? 'pre' : 'post', `${fieldName}.issue`)
+        : undefined;
+    if (issue && (issue.observedAt < createdAt || issue.observedAt > updatedAt)) {
+        return fail(`${fieldName}.issue.observedAt must be within status time bounds`);
+    }
+    const expectedByPhase = {
+        preparing: [true, false, false, false, 'source', 'wait'],
+        transferring: [true, false, false, false, 'source', 'wait'],
+        awaitingConsumerQuiesce: [
+            true, true, false, false, 'source', 'stageCandidateAndStop',
+        ],
+        finalizing: [true, true, false, false, 'source', 'wait'],
+        committing: [true, true, true, false, 'transitioning', 'wait'],
+        readyToStart: [true, true, true, true, 'destination', 'startDestination'],
+        cleanupPending: [true, true, true, true, 'destination', 'none'],
+        complete: [false, true, true, true, 'destination', 'none'],
+        aborting: [true, candidateIssued, false, false, 'source', 'wait'],
+        aborted: [false, candidateIssued, false, false, 'source', 'startSource'],
+    };
+    const expected = expectedByPhase[phase];
+    assertFieldValue(value, 'bindingFenceActive', expected[0], fieldName);
+    assertFieldValue(value, 'candidateIssued', expected[1], fieldName);
+    assertFieldValue(value, 'commitPointCrossed', expected[2], fieldName);
+    assertFieldValue(value, 'destinationBindingStartAuthorized', expected[3], fieldName);
+    assertFieldValue(value, 'authority', expected[4], fieldName);
+    assertFieldValue(value, 'consumerAction', expected[5], fieldName);
+    let candidateBinding;
+    let candidateDigest;
+    if (Object.hasOwn(value, 'candidateBinding')) {
+        candidateBinding = normalizeObjectStorageBinding(value.candidateBinding, 'provisioning', `${fieldName}.candidateBinding`);
+        candidateDigest = readSha256(value.candidateDigest, `${fieldName}.candidateDigest`);
+        const recomputedCandidateDigest = await createObjectStorageMigrationBindingSha256(candidateBinding);
+        if (candidateDigest !== recomputedCandidateDigest) {
+            return fail(`${fieldName}.candidateDigest does not match candidateBinding`);
+        }
+        await assertCandidateIdentity(candidateBinding, sourceBinding, target, `${fieldName}.candidateBinding`);
+    }
+    else if (Object.hasOwn(value, 'candidateDigest')) {
+        candidateDigest = readSha256(value.candidateDigest, `${fieldName}.candidateDigest`);
+    }
+    const quiesceEvidence = Object.hasOwn(value, 'consumerQuiesceEvidence')
+        ? await normalizeQuiesceEvidence(value.consumerQuiesceEvidence, `${fieldName}.consumerQuiesceEvidence`)
+        : undefined;
+    if (quiesceEvidence) {
+        assertEvidenceFence(quiesceEvidence.request, migrationId, migrationDigest, migrationRevision, `${fieldName}.consumerQuiesceEvidence.request`);
+        if (quiesceEvidence.acceptedMigrationRevision > migrationRevision ||
+            quiesceEvidence.request.sourceRecordRevision !==
+                source.fencedSnapshot.recordRevision ||
+            quiesceEvidence.request.sourceControlSnapshotDigest !==
+                source.fencedSnapshot.snapshotDigest ||
+            quiesceEvidence.request.candidateDigest !== candidateDigest ||
+            quiesceEvidence.request.workloadGeneration !== workloadGeneration ||
+            quiesceEvidence.acceptedAt < createdAt ||
+            quiesceEvidence.acceptedAt > updatedAt) {
+            return fail(`${fieldName}.consumerQuiesceEvidence does not match status`);
+        }
+    }
+    let activeBinding;
+    let activeBindingDigest;
+    if (Object.hasOwn(value, 'activeBinding')) {
+        activeBinding = normalizeObjectStorageBinding(value.activeBinding, 'ready', `${fieldName}.activeBinding`);
+        activeBindingDigest = readSha256(value.activeBindingDigest, `${fieldName}.activeBindingDigest`);
+        const recomputedActiveDigest = await createObjectStorageMigrationBindingSha256(activeBinding);
+        if (activeBindingDigest !== recomputedActiveDigest) {
+            return fail(`${fieldName}.activeBindingDigest does not match activeBinding`);
+        }
+        if (phase === 'aborted') {
+            if (canonicalize(activeBinding) !== canonicalize(sourceBinding)) {
+                return fail(`${fieldName}.activeBinding must be the exact source binding after abort`);
+            }
+        }
+        else {
+            if (!candidateBinding) {
+                return fail(`${fieldName}.activeBinding requires candidateBinding`);
+            }
+            assertActiveMatchesCandidate(activeBinding, candidateBinding, `${fieldName}.activeBinding`);
+        }
+    }
+    const activationEvidence = Object.hasOwn(value, 'consumerActivationEvidence')
+        ? await normalizeActivationEvidence(value.consumerActivationEvidence, `${fieldName}.consumerActivationEvidence`)
+        : undefined;
+    if (activationEvidence) {
+        assertEvidenceFence(activationEvidence.request, migrationId, migrationDigest, migrationRevision, `${fieldName}.consumerActivationEvidence.request`);
+        if (activationEvidence.acceptedMigrationRevision > migrationRevision ||
+            activationEvidence.request.candidateDigest !== candidateDigest ||
+            activationEvidence.request.activeBindingDigest !== activeBindingDigest ||
+            activationEvidence.request.workloadGeneration !== workloadGeneration ||
+            !quiesceEvidence ||
+            activationEvidence.request.expectedMigrationRevision <
+                quiesceEvidence.acceptedMigrationRevision ||
+            activationEvidence.request.consumerStartedAt <
+                quiesceEvidence.acceptedAt ||
+            activationEvidence.acceptedAt < createdAt ||
+            activationEvidence.acceptedAt > updatedAt) {
+            return fail(`${fieldName}.consumerActivationEvidence does not match status`);
+        }
+    }
+    const terminalAt = Object.hasOwn(value, 'terminalAt')
+        ? readSafeInteger(value.terminalAt, `${fieldName}.terminalAt`, createdAt)
+        : undefined;
+    if (terminalAt !== undefined && terminalAt > updatedAt) {
+        return fail(`${fieldName}.terminalAt must not exceed updatedAt`);
+    }
+    const normalized = {
+        schemaVersion: 1,
+        migrationId,
+        migrationDigest,
+        migrationRevision,
+        bindingId,
+        serviceId,
+        requestId,
+        workloadGeneration,
+        target,
+        source,
+        ...(progress ? { progress } : {}),
+        createdAt,
+        updatedAt,
+        phase,
+        bindingFenceActive: expected[0],
+        candidateIssued: expected[1],
+        ...(candidateBinding ? { candidateBinding } : {}),
+        ...(candidateDigest ? { candidateDigest } : {}),
+        ...(quiesceEvidence ? { consumerQuiesceEvidence: quiesceEvidence } : {}),
+        ...(activationEvidence
+            ? { consumerActivationEvidence: activationEvidence }
+            : {}),
+        commitPointCrossed: expected[2],
+        destinationBindingStartAuthorized: expected[3],
+        authority: expected[4],
+        consumerAction: expected[5],
+        ...(activeBinding ? { activeBinding } : {}),
+        ...(activeBindingDigest ? { activeBindingDigest } : {}),
+        ...(terminalAt !== undefined ? { terminalAt } : {}),
+        ...(issue ? { issue } : {}),
+    };
+    return assertControlJsonLimit(normalized, fieldName);
+};
+const assertCurrentMutationFence = (requestArg, statusArg, fieldNameArg) => {
+    if (requestArg.migrationId !== statusArg.migrationId ||
+        requestArg.migrationDigest !== statusArg.migrationDigest) {
+        fail(`${fieldNameArg} does not match current migration identity`);
+    }
+    if (requestArg.expectedMigrationRevision !== statusArg.migrationRevision) {
+        fail(`${fieldNameArg}.expectedMigrationRevision is stale`);
+    }
+};
+export const bindObjectStorageMigrationConsumerQuiesceRequest = async (requestArg, statusArg) => {
+    const request = await normalizeObjectStorageMigrationConsumerQuiesceRequest(requestArg);
+    const status = await normalizeObjectStorageMigrationStatus(statusArg);
+    if (status.phase !== 'awaitingConsumerQuiesce') {
+        return fail('consumer quiesce request is accepted only while awaiting consumer quiescence');
+    }
+    assertCurrentMutationFence(request, status, 'consumer quiesce request');
+    if (request.sourceRecordRevision !== status.source.fencedSnapshot.recordRevision ||
+        request.sourceControlSnapshotDigest !==
+            status.source.fencedSnapshot.snapshotDigest ||
+        request.candidateDigest !== status.candidateDigest ||
+        request.workloadGeneration !== status.workloadGeneration) {
+        return fail('consumer quiesce request does not match the current fences');
+    }
+    return request;
+};
+export const bindObjectStorageMigrationConsumerActivationRequest = async (requestArg, statusArg) => {
+    const request = await normalizeObjectStorageMigrationConsumerActivationRequest(requestArg);
+    const status = await normalizeObjectStorageMigrationStatus(statusArg);
+    if (status.phase !== 'readyToStart' ||
+        status.consumerAction !== 'startDestination' ||
+        status.destinationBindingStartAuthorized !== true) {
+        return fail('consumer activation request is accepted only for an authorized ready-to-start destination');
+    }
+    assertCurrentMutationFence(request, status, 'consumer activation request');
+    if (request.candidateDigest !== status.candidateDigest ||
+        request.activeBindingDigest !== status.activeBindingDigest ||
+        request.workloadGeneration !== status.workloadGeneration ||
+        request.consumerStartedAt <
+            status.consumerQuiesceEvidence.request.consumerStoppedAt) {
+        return fail('consumer activation request does not match destination fences');
+    }
+    return request;
+};
+export const bindObjectStorageMigrationAbortRequest = async (requestArg, statusArg) => {
+    const request = normalizeObjectStorageMigrationAbortRequest(requestArg);
+    const status = await normalizeObjectStorageMigrationStatus(statusArg);
+    if (status.bindingFenceActive !== true ||
+        status.commitPointCrossed !== false ||
+        ![
+            'preparing',
+            'transferring',
+            'awaitingConsumerQuiesce',
+            'finalizing',
+            'aborting',
+        ].includes(status.phase)) {
+        return fail('abort request is forbidden after the migration commit point');
+    }
+    assertCurrentMutationFence(request, status, 'abort request');
+    return request;
+};
+export const bindObjectStorageMigrationResumeRequest = async (requestArg, statusArg) => {
+    const request = normalizeObjectStorageMigrationResumeRequest(requestArg);
+    const status = await normalizeObjectStorageMigrationStatus(statusArg);
+    if (status.bindingFenceActive !== true) {
+        return fail('resume request requires a live nonterminal migration binding fence');
+    }
+    assertCurrentMutationFence(request, status, 'resume request');
+    const issue = 'issue' in status ? status.issue : undefined;
+    if (!issue) {
+        return fail('resume request requires a current migration issue');
+    }
+    if (!issue.allowedRecoveryActions.some((actionArg) => actionArg === request.action)) {
+        return fail('resume request action is not advertised by the current issue');
+    }
+    return request;
+};
+export const bindObjectStorageMigrationCleanupRequest = async (requestArg, statusArg) => {
+    const request = normalizeObjectStorageMigrationCleanupRequest(requestArg);
+    const status = await normalizeObjectStorageMigrationStatus(statusArg);
+    if (status.phase !== 'cleanupPending' ||
+        !status.consumerActivationEvidence) {
+        return fail('cleanup request is accepted only after destination activation acknowledgement');
+    }
+    assertCurrentMutationFence(request, status, 'cleanup request');
+    return request;
+};
+export const normalizeStorageMigrationProgress = (valueArg) => {
+    return assertControlJsonLimit(normalizeProgress(valueArg, 'storage migration progress'), 'storage migration progress');
+};
+export const normalizeStorageMigrationPreCutoverIssue = (valueArg) => {
+    return assertControlJsonLimit(normalizeIssue(valueArg, 'pre', 'storage migration pre-cutover issue'), 'storage migration pre-cutover issue');
+};
+export const normalizeStorageMigrationPostCutoverIssue = (valueArg) => {
+    return assertControlJsonLimit(normalizeIssue(valueArg, 'post', 'storage migration post-cutover issue'), 'storage migration post-cutover issue');
+};
+export { storageMigrationCanonicalDigestGoldenVectors, } from './storagemigration.golden.js';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storagemigration.js","sourceRoot":"","sources":["../../ts/platform/storagemigration.ts"],"names":[],"mappings":"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"}