@serve.zone/interfaces 27.3.0 → 27.4.0

package/ts/runtime.corestore.databaseexportpackage.ts

@@ -0,0 +1,862 @@
+import * as plugins from './plugins.runtime.js';
+
+import {
+  canonicalizeStrictJson,
+  deepFreezeValue,
+} from './private/canonicaljson.js';
+import type {
+  ICorestoreDatabaseAllocationReference,
+  ICorestoreDatabaseBackupReceipt,
+} from './runtime.corestore.js';
+import {
+  corestoreDatabaseBackupRuntimeLimits,
+  encodeCorestoreDatabaseBackupReceipt,
+  normalizeCorestoreDatabaseAllocationReference,
+  normalizeCorestoreDatabaseBackupReceipt,
+} from './runtime.corestore.js';
+
+export const corestoreDatabaseExportPackageRuntimeLimits = Object.freeze({
+  maximumControlBytes: corestoreDatabaseBackupRuntimeLimits.maximumControlBytes,
+  maximumInputBytes: corestoreDatabaseBackupRuntimeLimits.maximumSnapshotOriginalBytes,
+  maximumClosureBytes: corestoreDatabaseBackupRuntimeLimits.maximumClosureBytes,
+  maximumPackageAttemptIdLength: 128,
+} as const);
+
+export type TCorestoreDatabaseExportPackageCodecErrorCode =
+  | 'INVALID_DATA'
+  | 'INVALID_SCHEMA'
+  | 'INVALID_VALUE'
+  | 'LIMIT_EXCEEDED'
+  | 'CROSS_FIELD_MISMATCH'
+  | 'ATTEMPT_CONFLICT';
+
+export class CorestoreDatabaseExportPackageCodecError extends Error {
+  public readonly code: TCorestoreDatabaseExportPackageCodecErrorCode;
+  public readonly path: string;
+
+  public constructor(
+    codeArg: TCorestoreDatabaseExportPackageCodecErrorCode,
+    pathArg: string,
+  ) {
+    super(`${codeArg}:${pathArg}`);
+    this.name = 'CorestoreDatabaseExportPackageCodecError';
+    this.code = codeArg;
+    this.path = pathArg;
+  }
+}
+
+export interface ICorestoreDatabaseExportPackageInputIdentityV1 {
+  format: 'smartdb.database.export.v1';
+  databaseName: string;
+  byteLength: number;
+  sha256: string;
+  lineFeedTerminator: 'single-lf';
+}
+
+export interface ICorestoreDatabaseExportPackageApprovedBackupIdentityV1 {
+  backupId: string;
+  sourceServiceId: string;
+  snapshotId: string;
+  backupReceiptSha256: string;
+}
+
+export interface ICorestoreDatabaseExportPackageAllocationAbsentExpectationV1 {
+  expectation: 'absent';
+}
+
+export interface ICorestoreDatabaseExportPackageAllocationExactExpectationV1 {
+  expectation: 'exact';
+  allocation: ICorestoreDatabaseAllocationReference;
+}
+
+export type TCorestoreDatabaseExportPackageAllocationExpectationV1 =
+  | ICorestoreDatabaseExportPackageAllocationAbsentExpectationV1
+  | ICorestoreDatabaseExportPackageAllocationExactExpectationV1;
+
+export interface ICorestoreDatabaseExportPackageRequestV1 {
+  schemaVersion: 1;
+  kind: 'corestore-database-export-package-request';
+  packageAttemptId: string;
+  packageBackupId: string;
+  input: ICorestoreDatabaseExportPackageInputIdentityV1;
+  approvedSourceBackup: ICorestoreDatabaseExportPackageApprovedBackupIdentityV1;
+  completeOutputReceiptSha256: string;
+  allocationExpectation: TCorestoreDatabaseExportPackageAllocationExpectationV1;
+}
+
+export interface ICorestoreDatabaseExportPackageCompletionV1 {
+  schemaVersion: 1;
+  kind: 'corestore-database-export-package-completion';
+  packageAttemptId: string;
+  requestSha256: string;
+  completedAt: number;
+  receipt: ICorestoreDatabaseBackupReceipt;
+  receiptSha256: string;
+  closureByteLength: number;
+  closureSha256: string;
+}
+
+export interface ICorestoreDatabaseExportPackageResponseV1 {
+  schemaVersion: 1;
+  kind: 'corestore-database-export-package-response';
+  completion: ICorestoreDatabaseExportPackageCompletionV1;
+  replayed: boolean;
+}
+
+export interface ICorestoreDatabaseExportPackageReleaseRequestV1 {
+  schemaVersion: 1;
+  kind: 'corestore-database-export-package-release-request';
+  packageAttemptId: string;
+  requestSha256: string;
+  completionSha256: string;
+  callerFsyncedClosureByteLength: number;
+  callerFsyncedClosureSha256: string;
+  callerFsyncedReceiptByteLength: number;
+  callerFsyncedReceiptSha256: string;
+  callerFsyncedAt: number;
+}
+
+export interface ICorestoreDatabaseExportPackageReleaseCompletionV1 {
+  schemaVersion: 1;
+  kind: 'corestore-database-export-package-release-completion';
+  packageAttemptId: string;
+  requestSha256: string;
+  completionSha256: string;
+  releaseRequestSha256: string;
+  releasedAt: number;
+}
+
+export interface ICorestoreDatabaseExportPackageReleaseResponseV1 {
+  schemaVersion: 1;
+  kind: 'corestore-database-export-package-release-response';
+  release: ICorestoreDatabaseExportPackageReleaseCompletionV1;
+  replayed: boolean;
+}
+
+export type TCorestoreDatabaseExportPackageRequestReuse =
+  | 'different-attempt'
+  | 'exact-replay';
+
+const inputIdentityKeys = [
+  'format',
+  'databaseName',
+  'byteLength',
+  'sha256',
+  'lineFeedTerminator',
+] as const;
+const approvedBackupIdentityKeys = [
+  'backupId',
+  'sourceServiceId',
+  'snapshotId',
+  'backupReceiptSha256',
+] as const;
+const requestKeys = [
+  'schemaVersion',
+  'kind',
+  'packageAttemptId',
+  'packageBackupId',
+  'input',
+  'approvedSourceBackup',
+  'completeOutputReceiptSha256',
+  'allocationExpectation',
+] as const;
+const completionKeys = [
+  'schemaVersion',
+  'kind',
+  'packageAttemptId',
+  'requestSha256',
+  'completedAt',
+  'receipt',
+  'receiptSha256',
+  'closureByteLength',
+  'closureSha256',
+] as const;
+const responseKeys = ['schemaVersion', 'kind', 'completion', 'replayed'] as const;
+const releaseRequestKeys = [
+  'schemaVersion',
+  'kind',
+  'packageAttemptId',
+  'requestSha256',
+  'completionSha256',
+  'callerFsyncedClosureByteLength',
+  'callerFsyncedClosureSha256',
+  'callerFsyncedReceiptByteLength',
+  'callerFsyncedReceiptSha256',
+  'callerFsyncedAt',
+] as const;
+const releaseCompletionKeys = [
+  'schemaVersion',
+  'kind',
+  'packageAttemptId',
+  'requestSha256',
+  'completionSha256',
+  'releaseRequestSha256',
+  'releasedAt',
+] as const;
+const releaseResponseKeys = ['schemaVersion', 'kind', 'release', 'replayed'] as const;
+
+const identifierPattern = /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,255}$/;
+const packageAttemptIdPattern = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+const sha256Pattern = /^[a-f0-9]{64}$/;
+
+const fail = (
+  codeArg: TCorestoreDatabaseExportPackageCodecErrorCode,
+  pathArg: string,
+): never => {
+  throw new CorestoreDatabaseExportPackageCodecError(codeArg, pathArg);
+};
+
+const normalizeAllocationReference = (
+  valueArg: unknown,
+  pathArg: string,
+): ICorestoreDatabaseAllocationReference => {
+  try {
+    return normalizeCorestoreDatabaseAllocationReference(
+      valueArg,
+    ) as ICorestoreDatabaseAllocationReference;
+  } catch {
+    return fail('INVALID_VALUE', pathArg);
+  }
+};
+
+const normalizeBackupReceipt = (
+  valueArg: unknown,
+  pathArg: string,
+): ICorestoreDatabaseBackupReceipt => {
+  try {
+    return normalizeCorestoreDatabaseBackupReceipt(valueArg) as ICorestoreDatabaseBackupReceipt;
+  } catch {
+    return fail('INVALID_VALUE', pathArg);
+  }
+};
+
+const readRecord = (valueArg: unknown, pathArg: string): Record<string, unknown> => {
+  if (!valueArg || typeof valueArg !== 'object' || Array.isArray(valueArg)) {
+    return fail('INVALID_DATA', pathArg);
+  }
+  const prototype = Object.getPrototypeOf(valueArg);
+  if (prototype !== Object.prototype && prototype !== null) {
+    return fail('INVALID_DATA', pathArg);
+  }
+  const value = valueArg as Record<string, unknown>;
+  for (const key of Reflect.ownKeys(value)) {
+    if (typeof key !== 'string') return fail('INVALID_DATA', pathArg);
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor || !descriptor.enumerable || !Object.hasOwn(descriptor, 'value')) {
+      return fail('INVALID_DATA', pathArg);
+    }
+  }
+  return value;
+};
+
+const assertExactKeys = (
+  valueArg: Record<string, unknown>,
+  keysArg: readonly string[],
+  pathArg: string,
+): void => {
+  const actual = Object.keys(valueArg).sort();
+  const expected = [...keysArg].sort();
+  if (actual.length !== expected.length
+    || actual.some((keyArg, indexArg) => keyArg !== expected[indexArg])) {
+    fail('INVALID_SCHEMA', pathArg);
+  }
+};
+
+const readIdentifier = (valueArg: unknown, pathArg: string): string => {
+  if (typeof valueArg !== 'string' || !identifierPattern.test(valueArg)) {
+    return fail('INVALID_VALUE', pathArg);
+  }
+  return valueArg;
+};
+
+const readPackageAttemptId = (valueArg: unknown, pathArg: string): string => {
+  if (typeof valueArg !== 'string' || !packageAttemptIdPattern.test(valueArg)) {
+    return fail('INVALID_VALUE', pathArg);
+  }
+  return valueArg;
+};
+
+const readSha256 = (valueArg: unknown, pathArg: string): string => {
+  if (typeof valueArg !== 'string' || !sha256Pattern.test(valueArg)) {
+    return fail('INVALID_VALUE', pathArg);
+  }
+  return valueArg;
+};
+
+const readInteger = (
+  valueArg: unknown,
+  pathArg: string,
+  minimumArg: number,
+  maximumArg = Number.MAX_SAFE_INTEGER,
+): number => {
+  if (typeof valueArg !== 'number'
+    || !Number.isSafeInteger(valueArg)
+    || Object.is(valueArg, -0)
+    || valueArg < minimumArg
+    || valueArg > maximumArg) {
+    return fail('INVALID_VALUE', pathArg);
+  }
+  return valueArg;
+};
+
+const readBoolean = (valueArg: unknown, pathArg: string): boolean => {
+  if (typeof valueArg !== 'boolean') return fail('INVALID_VALUE', pathArg);
+  return valueArg;
+};
+
+const canonicalize = (valueArg: unknown, pathArg: string): string => canonicalizeStrictJson(
+  valueArg,
+  () => fail('INVALID_DATA', pathArg),
+  pathArg,
+);
+
+const finalize = <T>(valueArg: T, pathArg: string): Readonly<T> => {
+  const canonical = canonicalize(valueArg, pathArg);
+  if (Buffer.byteLength(canonical, 'utf8')
+    > corestoreDatabaseExportPackageRuntimeLimits.maximumControlBytes) {
+    return fail('LIMIT_EXCEEDED', pathArg);
+  }
+  return deepFreezeValue(valueArg);
+};
+
+const encodeNormalized = (valueArg: unknown, pathArg: string): Uint8Array => (
+  Buffer.from(canonicalize(valueArg, pathArg), 'utf8')
+);
+
+const digestBytes = (valueArg: Uint8Array): string => plugins.crypto
+  .createHash('sha256')
+  .update(new Uint8Array(valueArg))
+  .digest('hex');
+
+const canonicalEqual = (leftArg: unknown, rightArg: unknown, pathArg: string): boolean => (
+  canonicalize(leftArg, `${pathArg}.left`) === canonicalize(rightArg, `${pathArg}.right`)
+);
+
+const normalizeInputIdentityInternal = (
+  valueArg: unknown,
+  pathArg: string,
+): ICorestoreDatabaseExportPackageInputIdentityV1 => {
+  const value = readRecord(valueArg, pathArg);
+  assertExactKeys(value, inputIdentityKeys, pathArg);
+  if (value.format !== 'smartdb.database.export.v1'
+    || value.lineFeedTerminator !== 'single-lf') {
+    fail('INVALID_VALUE', `${pathArg}.format`);
+  }
+  return {
+    format: 'smartdb.database.export.v1',
+    databaseName: readIdentifier(value.databaseName, `${pathArg}.databaseName`),
+    byteLength: readInteger(
+      value.byteLength,
+      `${pathArg}.byteLength`,
+      1,
+      corestoreDatabaseExportPackageRuntimeLimits.maximumInputBytes,
+    ),
+    sha256: readSha256(value.sha256, `${pathArg}.sha256`),
+    lineFeedTerminator: 'single-lf',
+  };
+};
+
+export const normalizeCorestoreDatabaseExportPackageInputIdentity = (
+  valueArg: unknown,
+): Readonly<ICorestoreDatabaseExportPackageInputIdentityV1> => finalize(
+  normalizeInputIdentityInternal(valueArg, 'databaseExportPackageInput'),
+  'databaseExportPackageInput',
+);
+
+const normalizeApprovedBackupIdentityInternal = (
+  valueArg: unknown,
+  pathArg: string,
+): ICorestoreDatabaseExportPackageApprovedBackupIdentityV1 => {
+  const value = readRecord(valueArg, pathArg);
+  assertExactKeys(value, approvedBackupIdentityKeys, pathArg);
+  return {
+    backupId: readIdentifier(value.backupId, `${pathArg}.backupId`),
+    sourceServiceId: readIdentifier(value.sourceServiceId, `${pathArg}.sourceServiceId`),
+    snapshotId: readIdentifier(value.snapshotId, `${pathArg}.snapshotId`),
+    backupReceiptSha256: readSha256(
+      value.backupReceiptSha256,
+      `${pathArg}.backupReceiptSha256`,
+    ),
+  };
+};
+
+export const normalizeCorestoreDatabaseExportPackageApprovedBackupIdentity = (
+  valueArg: unknown,
+): Readonly<ICorestoreDatabaseExportPackageApprovedBackupIdentityV1> => finalize(
+  normalizeApprovedBackupIdentityInternal(valueArg, 'databaseExportPackageApprovedBackup'),
+  'databaseExportPackageApprovedBackup',
+);
+
+const normalizeAllocationExpectationInternal = (
+  valueArg: unknown,
+  pathArg: string,
+): TCorestoreDatabaseExportPackageAllocationExpectationV1 => {
+  const value = readRecord(valueArg, pathArg);
+  if (value.expectation === 'absent') {
+    assertExactKeys(value, ['expectation'], pathArg);
+    return { expectation: 'absent' };
+  }
+  if (value.expectation !== 'exact') {
+    fail('INVALID_VALUE', `${pathArg}.expectation`);
+  }
+  assertExactKeys(value, ['expectation', 'allocation'], pathArg);
+  return {
+    expectation: 'exact',
+    allocation: normalizeAllocationReference(
+      value.allocation,
+      `${pathArg}.allocation`,
+    ),
+  };
+};
+
+export const normalizeCorestoreDatabaseExportPackageAllocationExpectation = (
+  valueArg: unknown,
+): Readonly<TCorestoreDatabaseExportPackageAllocationExpectationV1> => finalize(
+  normalizeAllocationExpectationInternal(valueArg, 'databaseExportPackageAllocationExpectation'),
+  'databaseExportPackageAllocationExpectation',
+);
+
+export const normalizeCorestoreDatabaseExportPackageRequest = (
+  valueArg: unknown,
+): Readonly<ICorestoreDatabaseExportPackageRequestV1> => {
+  const value = readRecord(valueArg, 'databaseExportPackageRequest');
+  assertExactKeys(value, requestKeys, 'databaseExportPackageRequest');
+  if (value.schemaVersion !== 1
+    || value.kind !== 'corestore-database-export-package-request') {
+    fail('INVALID_VALUE', 'databaseExportPackageRequest.kind');
+  }
+  return finalize({
+    schemaVersion: 1,
+    kind: 'corestore-database-export-package-request',
+    packageAttemptId: readPackageAttemptId(
+      value.packageAttemptId,
+      'databaseExportPackageRequest.packageAttemptId',
+    ),
+    packageBackupId: readIdentifier(
+      value.packageBackupId,
+      'databaseExportPackageRequest.packageBackupId',
+    ),
+    input: normalizeInputIdentityInternal(value.input, 'databaseExportPackageRequest.input'),
+    approvedSourceBackup: normalizeApprovedBackupIdentityInternal(
+      value.approvedSourceBackup,
+      'databaseExportPackageRequest.approvedSourceBackup',
+    ),
+    completeOutputReceiptSha256: readSha256(
+      value.completeOutputReceiptSha256,
+      'databaseExportPackageRequest.completeOutputReceiptSha256',
+    ),
+    allocationExpectation: normalizeAllocationExpectationInternal(
+      value.allocationExpectation,
+      'databaseExportPackageRequest.allocationExpectation',
+    ),
+  } satisfies ICorestoreDatabaseExportPackageRequestV1, 'databaseExportPackageRequest');
+};
+
+export const encodeCorestoreDatabaseExportPackageRequest = (
+  valueArg: unknown,
+): Uint8Array => encodeNormalized(
+  normalizeCorestoreDatabaseExportPackageRequest(valueArg),
+  'databaseExportPackageRequest',
+);
+
+export const computeCorestoreDatabaseExportPackageRequestSha256 = async (
+  valueArg: unknown,
+): Promise<string> => digestBytes(encodeCorestoreDatabaseExportPackageRequest(valueArg));
+
+const digestCorestoreDatabaseExportPackageRequest = (valueArg: unknown): string => digestBytes(
+  encodeCorestoreDatabaseExportPackageRequest(valueArg),
+);
+
+export const classifyCorestoreDatabaseExportPackageRequestReuse = (
+  persistedRequestArg: unknown,
+  candidateRequestArg: unknown,
+): TCorestoreDatabaseExportPackageRequestReuse => {
+  const persisted = normalizeCorestoreDatabaseExportPackageRequest(persistedRequestArg);
+  const candidate = normalizeCorestoreDatabaseExportPackageRequest(candidateRequestArg);
+  if (persisted.packageAttemptId !== candidate.packageAttemptId) return 'different-attempt';
+  if (!canonicalEqual(persisted, candidate, 'databaseExportPackageRequest.reuse')) {
+    fail('ATTEMPT_CONFLICT', 'databaseExportPackageRequest.packageAttemptId');
+  }
+  return 'exact-replay';
+};
+
+export const normalizeCorestoreDatabaseExportPackageCompletion = (
+  valueArg: unknown,
+): Readonly<ICorestoreDatabaseExportPackageCompletionV1> => {
+  const value = readRecord(valueArg, 'databaseExportPackageCompletion');
+  assertExactKeys(value, completionKeys, 'databaseExportPackageCompletion');
+  if (value.schemaVersion !== 1
+    || value.kind !== 'corestore-database-export-package-completion') {
+    fail('INVALID_VALUE', 'databaseExportPackageCompletion.kind');
+  }
+  const receipt = normalizeBackupReceipt(
+    value.receipt,
+    'databaseExportPackageCompletion.receipt',
+  );
+  const receiptSha256 = readSha256(
+    value.receiptSha256,
+    'databaseExportPackageCompletion.receiptSha256',
+  );
+  const closureByteLength = readInteger(
+    value.closureByteLength,
+    'databaseExportPackageCompletion.closureByteLength',
+    1,
+    corestoreDatabaseExportPackageRuntimeLimits.maximumClosureBytes,
+  );
+  const closureSha256 = readSha256(
+    value.closureSha256,
+    'databaseExportPackageCompletion.closureSha256',
+  );
+  if (receiptSha256 !== digestBytes(encodeCorestoreDatabaseBackupReceipt(receipt))
+    || closureByteLength !== receipt.closure.archiveBytes
+    || closureSha256 !== receipt.closure.sha256) {
+    fail('CROSS_FIELD_MISMATCH', 'databaseExportPackageCompletion.receipt');
+  }
+  const completedAt = readInteger(
+    value.completedAt,
+    'databaseExportPackageCompletion.completedAt',
+    receipt.createdAt,
+  );
+  return finalize({
+    schemaVersion: 1,
+    kind: 'corestore-database-export-package-completion',
+    packageAttemptId: readPackageAttemptId(
+      value.packageAttemptId,
+      'databaseExportPackageCompletion.packageAttemptId',
+    ),
+    requestSha256: readSha256(
+      value.requestSha256,
+      'databaseExportPackageCompletion.requestSha256',
+    ),
+    completedAt,
+    receipt,
+    receiptSha256,
+    closureByteLength,
+    closureSha256,
+  } satisfies ICorestoreDatabaseExportPackageCompletionV1, 'databaseExportPackageCompletion');
+};
+
+export const normalizeCorestoreDatabaseExportPackageCompletionForRequest = (
+  completionArg: unknown,
+  requestArg: unknown,
+): Readonly<ICorestoreDatabaseExportPackageCompletionV1> => {
+  const request = normalizeCorestoreDatabaseExportPackageRequest(requestArg);
+  const completion = normalizeCorestoreDatabaseExportPackageCompletion(completionArg);
+  const receiptAllocation = completion.receipt.snapshot.databaseAllocation;
+  const allocationMatches = request.allocationExpectation.expectation === 'absent'
+    ? receiptAllocation === undefined
+    : receiptAllocation !== undefined
+      && canonicalEqual(
+        receiptAllocation,
+        request.allocationExpectation.allocation,
+        'databaseExportPackageCompletion.receipt.snapshot.databaseAllocation',
+      );
+  if (completion.packageAttemptId !== request.packageAttemptId
+    || completion.requestSha256 !== digestCorestoreDatabaseExportPackageRequest(request)
+    || completion.receipt.backupId !== request.packageBackupId
+    || completion.receipt.sourceServiceId !== request.approvedSourceBackup.sourceServiceId
+    || completion.receipt.snapshot.databaseName !== request.input.databaseName
+    || completion.receipt.snapshot.originalSize !== request.input.byteLength
+    || !allocationMatches) {
+    fail('CROSS_FIELD_MISMATCH', 'databaseExportPackageCompletion.request');
+  }
+  return completion;
+};
+
+export const encodeCorestoreDatabaseExportPackageCompletion = (
+  valueArg: unknown,
+): Uint8Array => encodeNormalized(
+  normalizeCorestoreDatabaseExportPackageCompletion(valueArg),
+  'databaseExportPackageCompletion',
+);
+
+export const computeCorestoreDatabaseExportPackageCompletionSha256 = async (
+  valueArg: unknown,
+): Promise<string> => digestBytes(encodeCorestoreDatabaseExportPackageCompletion(valueArg));
+
+const digestCorestoreDatabaseExportPackageCompletion = (valueArg: unknown): string => digestBytes(
+  encodeCorestoreDatabaseExportPackageCompletion(valueArg),
+);
+
+export const normalizeCorestoreDatabaseExportPackageResponse = (
+  valueArg: unknown,
+): Readonly<ICorestoreDatabaseExportPackageResponseV1> => {
+  const value = readRecord(valueArg, 'databaseExportPackageResponse');
+  assertExactKeys(value, responseKeys, 'databaseExportPackageResponse');
+  if (value.schemaVersion !== 1
+    || value.kind !== 'corestore-database-export-package-response') {
+    fail('INVALID_VALUE', 'databaseExportPackageResponse.kind');
+  }
+  return finalize({
+    schemaVersion: 1,
+    kind: 'corestore-database-export-package-response',
+    completion: normalizeCorestoreDatabaseExportPackageCompletion(
+      value.completion,
+    ) as ICorestoreDatabaseExportPackageCompletionV1,
+    replayed: readBoolean(value.replayed, 'databaseExportPackageResponse.replayed'),
+  } satisfies ICorestoreDatabaseExportPackageResponseV1, 'databaseExportPackageResponse');
+};
+
+export const normalizeCorestoreDatabaseExportPackageResponseForRequest = (
+  responseArg: unknown,
+  requestArg: unknown,
+): Readonly<ICorestoreDatabaseExportPackageResponseV1> => {
+  const response = normalizeCorestoreDatabaseExportPackageResponse(responseArg);
+  normalizeCorestoreDatabaseExportPackageCompletionForRequest(
+    response.completion,
+    requestArg,
+  );
+  return response;
+};
+
+export const encodeCorestoreDatabaseExportPackageResponse = (
+  valueArg: unknown,
+): Uint8Array => encodeNormalized(
+  normalizeCorestoreDatabaseExportPackageResponse(valueArg),
+  'databaseExportPackageResponse',
+);
+
+export const computeCorestoreDatabaseExportPackageResponseSha256 = async (
+  valueArg: unknown,
+): Promise<string> => digestBytes(encodeCorestoreDatabaseExportPackageResponse(valueArg));
+
+export const normalizeCorestoreDatabaseExportPackageReleaseRequest = (
+  valueArg: unknown,
+): Readonly<ICorestoreDatabaseExportPackageReleaseRequestV1> => {
+  const value = readRecord(valueArg, 'databaseExportPackageReleaseRequest');
+  assertExactKeys(value, releaseRequestKeys, 'databaseExportPackageReleaseRequest');
+  if (value.schemaVersion !== 1
+    || value.kind !== 'corestore-database-export-package-release-request') {
+    fail('INVALID_VALUE', 'databaseExportPackageReleaseRequest.kind');
+  }
+  return finalize({
+    schemaVersion: 1,
+    kind: 'corestore-database-export-package-release-request',
+    packageAttemptId: readPackageAttemptId(
+      value.packageAttemptId,
+      'databaseExportPackageReleaseRequest.packageAttemptId',
+    ),
+    requestSha256: readSha256(
+      value.requestSha256,
+      'databaseExportPackageReleaseRequest.requestSha256',
+    ),
+    completionSha256: readSha256(
+      value.completionSha256,
+      'databaseExportPackageReleaseRequest.completionSha256',
+    ),
+    callerFsyncedClosureByteLength: readInteger(
+      value.callerFsyncedClosureByteLength,
+      'databaseExportPackageReleaseRequest.callerFsyncedClosureByteLength',
+      1,
+      corestoreDatabaseExportPackageRuntimeLimits.maximumClosureBytes,
+    ),
+    callerFsyncedClosureSha256: readSha256(
+      value.callerFsyncedClosureSha256,
+      'databaseExportPackageReleaseRequest.callerFsyncedClosureSha256',
+    ),
+    callerFsyncedReceiptByteLength: readInteger(
+      value.callerFsyncedReceiptByteLength,
+      'databaseExportPackageReleaseRequest.callerFsyncedReceiptByteLength',
+      1,
+      corestoreDatabaseExportPackageRuntimeLimits.maximumControlBytes,
+    ),
+    callerFsyncedReceiptSha256: readSha256(
+      value.callerFsyncedReceiptSha256,
+      'databaseExportPackageReleaseRequest.callerFsyncedReceiptSha256',
+    ),
+    callerFsyncedAt: readInteger(
+      value.callerFsyncedAt,
+      'databaseExportPackageReleaseRequest.callerFsyncedAt',
+      1,
+    ),
+  } satisfies ICorestoreDatabaseExportPackageReleaseRequestV1,
+  'databaseExportPackageReleaseRequest');
+};
+
+export const normalizeCorestoreDatabaseExportPackageReleaseRequestForCompletion = (
+  releaseRequestArg: unknown,
+  requestArg: unknown,
+  completionArg: unknown,
+): Readonly<ICorestoreDatabaseExportPackageReleaseRequestV1> => {
+  const request = normalizeCorestoreDatabaseExportPackageRequest(requestArg);
+  const completion = normalizeCorestoreDatabaseExportPackageCompletionForRequest(
+    completionArg,
+    request,
+  );
+  const releaseRequest = normalizeCorestoreDatabaseExportPackageReleaseRequest(
+    releaseRequestArg,
+  );
+  const receiptBytes = encodeCorestoreDatabaseBackupReceipt(completion.receipt);
+  if (releaseRequest.packageAttemptId !== request.packageAttemptId
+    || releaseRequest.requestSha256 !== digestCorestoreDatabaseExportPackageRequest(request)
+    || releaseRequest.completionSha256
+      !== digestCorestoreDatabaseExportPackageCompletion(completion)
+    || releaseRequest.callerFsyncedClosureByteLength !== completion.closureByteLength
+    || releaseRequest.callerFsyncedClosureSha256 !== completion.closureSha256
+    || releaseRequest.callerFsyncedReceiptByteLength !== receiptBytes.byteLength
+    || releaseRequest.callerFsyncedReceiptSha256 !== completion.receiptSha256
+    || releaseRequest.callerFsyncedAt < completion.completedAt) {
+    fail('CROSS_FIELD_MISMATCH', 'databaseExportPackageReleaseRequest.completion');
+  }
+  return releaseRequest;
+};
+
+export const encodeCorestoreDatabaseExportPackageReleaseRequest = (
+  valueArg: unknown,
+): Uint8Array => encodeNormalized(
+  normalizeCorestoreDatabaseExportPackageReleaseRequest(valueArg),
+  'databaseExportPackageReleaseRequest',
+);
+
+export const computeCorestoreDatabaseExportPackageReleaseRequestSha256 = async (
+  valueArg: unknown,
+): Promise<string> => digestBytes(encodeCorestoreDatabaseExportPackageReleaseRequest(valueArg));
+
+const digestCorestoreDatabaseExportPackageReleaseRequest = (valueArg: unknown): string => (
+  digestBytes(encodeCorestoreDatabaseExportPackageReleaseRequest(valueArg))
+);
+
+export const classifyCorestoreDatabaseExportPackageReleaseRequestReuse = (
+  persistedRequestArg: unknown,
+  candidateRequestArg: unknown,
+): TCorestoreDatabaseExportPackageRequestReuse => {
+  const persisted = normalizeCorestoreDatabaseExportPackageReleaseRequest(persistedRequestArg);
+  const candidate = normalizeCorestoreDatabaseExportPackageReleaseRequest(candidateRequestArg);
+  if (persisted.packageAttemptId !== candidate.packageAttemptId) return 'different-attempt';
+  if (!canonicalEqual(persisted, candidate, 'databaseExportPackageReleaseRequest.reuse')) {
+    fail('ATTEMPT_CONFLICT', 'databaseExportPackageReleaseRequest.packageAttemptId');
+  }
+  return 'exact-replay';
+};
+
+export const normalizeCorestoreDatabaseExportPackageReleaseCompletion = (
+  valueArg: unknown,
+): Readonly<ICorestoreDatabaseExportPackageReleaseCompletionV1> => {
+  const value = readRecord(valueArg, 'databaseExportPackageReleaseCompletion');
+  assertExactKeys(value, releaseCompletionKeys, 'databaseExportPackageReleaseCompletion');
+  if (value.schemaVersion !== 1
+    || value.kind !== 'corestore-database-export-package-release-completion') {
+    fail('INVALID_VALUE', 'databaseExportPackageReleaseCompletion.kind');
+  }
+  return finalize({
+    schemaVersion: 1,
+    kind: 'corestore-database-export-package-release-completion',
+    packageAttemptId: readPackageAttemptId(
+      value.packageAttemptId,
+      'databaseExportPackageReleaseCompletion.packageAttemptId',
+    ),
+    requestSha256: readSha256(
+      value.requestSha256,
+      'databaseExportPackageReleaseCompletion.requestSha256',
+    ),
+    completionSha256: readSha256(
+      value.completionSha256,
+      'databaseExportPackageReleaseCompletion.completionSha256',
+    ),
+    releaseRequestSha256: readSha256(
+      value.releaseRequestSha256,
+      'databaseExportPackageReleaseCompletion.releaseRequestSha256',
+    ),
+    releasedAt: readInteger(
+      value.releasedAt,
+      'databaseExportPackageReleaseCompletion.releasedAt',
+      1,
+    ),
+  } satisfies ICorestoreDatabaseExportPackageReleaseCompletionV1,
+  'databaseExportPackageReleaseCompletion');
+};
+
+export const normalizeCorestoreDatabaseExportPackageReleaseCompletionForRequest = (
+  releaseCompletionArg: unknown,
+  releaseRequestArg: unknown,
+  requestArg: unknown,
+  completionArg: unknown,
+): Readonly<ICorestoreDatabaseExportPackageReleaseCompletionV1> => {
+  const request = normalizeCorestoreDatabaseExportPackageRequest(requestArg);
+  const completion = normalizeCorestoreDatabaseExportPackageCompletionForRequest(
+    completionArg,
+    request,
+  );
+  const releaseRequest = normalizeCorestoreDatabaseExportPackageReleaseRequestForCompletion(
+    releaseRequestArg,
+    request,
+    completion,
+  );
+  const releaseCompletion = normalizeCorestoreDatabaseExportPackageReleaseCompletion(
+    releaseCompletionArg,
+  );
+  if (releaseCompletion.packageAttemptId !== request.packageAttemptId
+    || releaseCompletion.requestSha256 !== digestCorestoreDatabaseExportPackageRequest(request)
+    || releaseCompletion.completionSha256
+      !== digestCorestoreDatabaseExportPackageCompletion(completion)
+    || releaseCompletion.releaseRequestSha256
+      !== digestCorestoreDatabaseExportPackageReleaseRequest(releaseRequest)
+    || releaseCompletion.releasedAt < releaseRequest.callerFsyncedAt) {
+    fail('CROSS_FIELD_MISMATCH', 'databaseExportPackageReleaseCompletion.request');
+  }
+  return releaseCompletion;
+};
+
+export const encodeCorestoreDatabaseExportPackageReleaseCompletion = (
+  valueArg: unknown,
+): Uint8Array => encodeNormalized(
+  normalizeCorestoreDatabaseExportPackageReleaseCompletion(valueArg),
+  'databaseExportPackageReleaseCompletion',
+);
+
+export const computeCorestoreDatabaseExportPackageReleaseCompletionSha256 = async (
+  valueArg: unknown,
+): Promise<string> => digestBytes(
+  encodeCorestoreDatabaseExportPackageReleaseCompletion(valueArg),
+);
+
+export const normalizeCorestoreDatabaseExportPackageReleaseResponse = (
+  valueArg: unknown,
+): Readonly<ICorestoreDatabaseExportPackageReleaseResponseV1> => {
+  const value = readRecord(valueArg, 'databaseExportPackageReleaseResponse');
+  assertExactKeys(value, releaseResponseKeys, 'databaseExportPackageReleaseResponse');
+  if (value.schemaVersion !== 1
+    || value.kind !== 'corestore-database-export-package-release-response') {
+    fail('INVALID_VALUE', 'databaseExportPackageReleaseResponse.kind');
+  }
+  return finalize({
+    schemaVersion: 1,
+    kind: 'corestore-database-export-package-release-response',
+    release: normalizeCorestoreDatabaseExportPackageReleaseCompletion(
+      value.release,
+    ) as ICorestoreDatabaseExportPackageReleaseCompletionV1,
+    replayed: readBoolean(value.replayed, 'databaseExportPackageReleaseResponse.replayed'),
+  } satisfies ICorestoreDatabaseExportPackageReleaseResponseV1,
+  'databaseExportPackageReleaseResponse');
+};
+
+export const normalizeCorestoreDatabaseExportPackageReleaseResponseForRequest = (
+  responseArg: unknown,
+  releaseRequestArg: unknown,
+  requestArg: unknown,
+  completionArg: unknown,
+): Readonly<ICorestoreDatabaseExportPackageReleaseResponseV1> => {
+  const response = normalizeCorestoreDatabaseExportPackageReleaseResponse(responseArg);
+  normalizeCorestoreDatabaseExportPackageReleaseCompletionForRequest(
+    response.release,
+    releaseRequestArg,
+    requestArg,
+    completionArg,
+  );
+  return response;
+};
+
+export const encodeCorestoreDatabaseExportPackageReleaseResponse = (
+  valueArg: unknown,
+): Uint8Array => encodeNormalized(
+  normalizeCorestoreDatabaseExportPackageReleaseResponse(valueArg),
+  'databaseExportPackageReleaseResponse',
+);
+
+export const computeCorestoreDatabaseExportPackageReleaseResponseSha256 = async (
+  valueArg: unknown,
+): Promise<string> => digestBytes(encodeCorestoreDatabaseExportPackageReleaseResponse(valueArg));
+
+export {
+  corestoreDatabaseExportPackageGoldenVectors,
+} from './runtime.corestore.databaseexportpackage.golden.js';