@peac/transport-grpc 0.12.6

package/tests/a2a-carrier.test.ts

@@ -0,0 +1,208 @@
+import { describe, it, expect } from 'vitest';
+import type { PeacEvidenceCarrier } from '@peac/kernel';
+import {
+  A2AGrpcCarrierAdapter,
+  createGrpcCarrierMeta,
+  validateOwnMetadataKeys,
+  GRPC_MAX_CARRIER_SIZE,
+  GrpcMetadataKeys,
+  addReceiptToMetadata,
+  extractReceiptTypeFromMetadata,
+  GRPC_TRANSPORT_VERSION,
+} from '../src/index.js';
+
+const VALID_REF = 'sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855';
+
+const VALID_CARRIER: PeacEvidenceCarrier = {
+  receipt_ref: VALID_REF as PeacEvidenceCarrier['receipt_ref'],
+  receipt_jws: 'eyJhbGciOiJFZERTQSIsImtpZCI6InRlc3QifQ.eyJpc3MiOiJ0ZXN0In0.dGVzdA',
+};
+
+describe('A2AGrpcCarrierAdapter', () => {
+  const adapter = new A2AGrpcCarrierAdapter();
+
+  describe('attach + extract round-trip', () => {
+    it('round-trips: attach then extract returns receipt JWS', () => {
+      const metadata: Record<string, string | string[] | undefined> = {};
+      const attached = adapter.attach(metadata, [VALID_CARRIER]);
+
+      const extracted = adapter.extract(attached);
+      expect(extracted).not.toBeNull();
+      expect(extracted!.receipts).toHaveLength(1);
+      expect(extracted!.receipts[0].receipt_jws).toBe(VALID_CARRIER.receipt_jws);
+    });
+
+    it('computes real SHA-256 receipt_ref (not a placeholder)', () => {
+      const metadata: Record<string, string | string[] | undefined> = {};
+      adapter.attach(metadata, [VALID_CARRIER]);
+
+      const extracted = adapter.extract(metadata);
+      expect(extracted).not.toBeNull();
+      const ref = extracted!.receipts[0].receipt_ref;
+      expect(ref).toMatch(/^sha256:[0-9a-f]{64}$/);
+      expect(ref).not.toBe('sha256:' + '0'.repeat(64));
+    });
+
+    it('uses first carrier when multiple provided', () => {
+      const second: PeacEvidenceCarrier = {
+        receipt_ref: VALID_REF as PeacEvidenceCarrier['receipt_ref'],
+        receipt_jws: 'eyJzZWNvbmQifQ.eyJ0ZXN0In0.c2Vjb25k',
+      };
+      const metadata: Record<string, string | string[] | undefined> = {};
+      adapter.attach(metadata, [VALID_CARRIER, second]);
+
+      expect(metadata[GrpcMetadataKeys.RECEIPT]).toBe(VALID_CARRIER.receipt_jws);
+    });
+  });
+
+  describe('extract', () => {
+    it('returns null when no receipt in metadata', () => {
+      expect(adapter.extract({})).toBeNull();
+    });
+
+    it('returns null when receipt key is undefined', () => {
+      expect(adapter.extract({ [GrpcMetadataKeys.RECEIPT]: undefined })).toBeNull();
+    });
+
+    it('extracts from string metadata value', () => {
+      const metadata = { [GrpcMetadataKeys.RECEIPT]: VALID_CARRIER.receipt_jws! };
+      const result = adapter.extract(metadata);
+      expect(result).not.toBeNull();
+      expect(result!.receipts[0].receipt_jws).toBe(VALID_CARRIER.receipt_jws);
+    });
+
+    it('extracts first value from array metadata', () => {
+      const metadata = { [GrpcMetadataKeys.RECEIPT]: [VALID_CARRIER.receipt_jws!] };
+      const result = adapter.extract(metadata);
+      expect(result).not.toBeNull();
+      expect(result!.receipts[0].receipt_jws).toBe(VALID_CARRIER.receipt_jws);
+    });
+
+    it('returns grpc transport meta with 8 KiB default', () => {
+      const metadata = { [GrpcMetadataKeys.RECEIPT]: VALID_CARRIER.receipt_jws! };
+      const result = adapter.extract(metadata);
+      expect(result!.meta.transport).toBe('grpc');
+      expect(result!.meta.format).toBe('embed');
+      expect(result!.meta.max_size).toBe(8_192);
+    });
+
+    it('rejects binary metadata key (peac-receipt-bin)', () => {
+      const metadata = {
+        [GrpcMetadataKeys.RECEIPT]: VALID_CARRIER.receipt_jws!,
+        'peac-receipt-bin': 'binary-data',
+      };
+      const result = adapter.extract(metadata);
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('attach', () => {
+    it('returns metadata unchanged when no carriers', () => {
+      const metadata = { existing: 'value' };
+      const result = adapter.attach(metadata, []);
+      expect(result).toBe(metadata);
+      expect(result[GrpcMetadataKeys.RECEIPT]).toBeUndefined();
+    });
+
+    it('throws on carrier exceeding 8 KiB size limit', () => {
+      const oversized: PeacEvidenceCarrier = {
+        receipt_ref: VALID_REF as PeacEvidenceCarrier['receipt_ref'],
+        receipt_jws: 'x'.repeat(10_000),
+      };
+      expect(() => adapter.attach({}, [oversized])).toThrow(/constraint violation/i);
+    });
+
+    it('sets receipt type metadata key', () => {
+      const metadata: Record<string, string | string[] | undefined> = {};
+      adapter.attach(metadata, [VALID_CARRIER]);
+      expect(metadata[GrpcMetadataKeys.RECEIPT_TYPE]).toBe('interaction-record+jwt');
+    });
+  });
+
+  describe('validateConstraints', () => {
+    it('returns valid for well-formed carrier within 8 KiB', () => {
+      const meta = createGrpcCarrierMeta();
+      const result = adapter.validateConstraints(VALID_CARRIER, meta);
+      expect(result.valid).toBe(true);
+      expect(result.violations).toHaveLength(0);
+    });
+
+    it('returns invalid for oversized carrier', () => {
+      const oversized: PeacEvidenceCarrier = {
+        receipt_ref: VALID_REF as PeacEvidenceCarrier['receipt_ref'],
+        receipt_jws: 'x'.repeat(10_000),
+      };
+      const meta = createGrpcCarrierMeta();
+      const result = adapter.validateConstraints(oversized, meta);
+      expect(result.valid).toBe(false);
+      expect(result.violations.length).toBeGreaterThan(0);
+    });
+
+    it('passes with explicit larger size override for valid carrier', () => {
+      const meta = createGrpcCarrierMeta({ max_size: 65_536 });
+      const result = adapter.validateConstraints(VALID_CARRIER, meta);
+      expect(result.valid).toBe(true);
+    });
+  });
+});
+
+describe('createGrpcCarrierMeta()', () => {
+  it('creates default grpc meta with 8 KiB limit', () => {
+    const meta = createGrpcCarrierMeta();
+    expect(meta.transport).toBe('grpc');
+    expect(meta.format).toBe('embed');
+    expect(meta.max_size).toBe(8_192);
+  });
+
+  it('accepts overrides', () => {
+    const meta = createGrpcCarrierMeta({ format: 'reference', max_size: 65_536 });
+    expect(meta.transport).toBe('grpc');
+    expect(meta.format).toBe('reference');
+    expect(meta.max_size).toBe(65_536);
+  });
+});
+
+describe('GRPC_MAX_CARRIER_SIZE', () => {
+  it('is 8 KiB (HTTP/2 header budget)', () => {
+    expect(GRPC_MAX_CARRIER_SIZE).toBe(8_192);
+  });
+});
+
+describe('validateOwnMetadataKeys()', () => {
+  it('validates all PEAC metadata key constants are ASCII-safe', () => {
+    const invalid = validateOwnMetadataKeys();
+    expect(invalid).toHaveLength(0);
+  });
+});
+
+describe('addReceiptToMetadata() Wire 0.2 default', () => {
+  it('defaults receipt type to interaction-record+jwt (Wire 0.2)', () => {
+    const metadata: Record<string, string | string[]> = {};
+    addReceiptToMetadata(metadata, 'eyJ...');
+    expect(metadata[GrpcMetadataKeys.RECEIPT]).toBe('eyJ...');
+    expect(metadata[GrpcMetadataKeys.RECEIPT_TYPE]).toBe('interaction-record+jwt');
+  });
+
+  it('accepts explicit Wire 0.1 receipt type', () => {
+    const metadata: Record<string, string | string[]> = {};
+    addReceiptToMetadata(metadata, 'eyJ...', 'peac-receipt/0.1');
+    expect(metadata[GrpcMetadataKeys.RECEIPT_TYPE]).toBe('peac-receipt/0.1');
+  });
+});
+
+describe('extractReceiptTypeFromMetadata()', () => {
+  it('extracts string receipt type', () => {
+    const metadata = { [GrpcMetadataKeys.RECEIPT_TYPE]: 'interaction-record+jwt' };
+    expect(extractReceiptTypeFromMetadata(metadata)).toBe('interaction-record+jwt');
+  });
+
+  it('returns null when absent', () => {
+    expect(extractReceiptTypeFromMetadata({})).toBeNull();
+  });
+});
+
+describe('GRPC_TRANSPORT_VERSION', () => {
+  it('reports 0.12.6', () => {
+    expect(GRPC_TRANSPORT_VERSION).toBe('0.12.6');
+  });
+});

package/tests/status-parity.test.ts

@@ -0,0 +1,361 @@
+/**
+ * gRPC Transport Status Code Parity Tests
+ *
+ * Verifies that gRPC status codes map correctly to/from HTTP status codes
+ * and PEAC error codes.
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  GrpcStatus,
+  httpStatusToGrpc,
+  grpcStatusToHttp,
+  peacErrorToGrpc,
+  createGrpcError,
+  extractReceiptFromMetadata,
+  addReceiptToMetadata,
+  createSuccessResult,
+  createFailureResult,
+  getStatusName,
+  GrpcMetadataKeys,
+  GRPC_TRANSPORT_VERSION,
+} from '../src/index.js';
+
+describe('gRPC Transport', () => {
+  describe('version', () => {
+    it('should export correct version', () => {
+      expect(GRPC_TRANSPORT_VERSION).toBe('0.12.6');
+    });
+  });
+
+  describe('GrpcStatus constants', () => {
+    it('should define all standard gRPC status codes', () => {
+      expect(GrpcStatus.OK).toBe(0);
+      expect(GrpcStatus.CANCELLED).toBe(1);
+      expect(GrpcStatus.UNKNOWN).toBe(2);
+      expect(GrpcStatus.INVALID_ARGUMENT).toBe(3);
+      expect(GrpcStatus.DEADLINE_EXCEEDED).toBe(4);
+      expect(GrpcStatus.NOT_FOUND).toBe(5);
+      expect(GrpcStatus.ALREADY_EXISTS).toBe(6);
+      expect(GrpcStatus.PERMISSION_DENIED).toBe(7);
+      expect(GrpcStatus.RESOURCE_EXHAUSTED).toBe(8);
+      expect(GrpcStatus.FAILED_PRECONDITION).toBe(9);
+      expect(GrpcStatus.ABORTED).toBe(10);
+      expect(GrpcStatus.OUT_OF_RANGE).toBe(11);
+      expect(GrpcStatus.UNIMPLEMENTED).toBe(12);
+      expect(GrpcStatus.INTERNAL).toBe(13);
+      expect(GrpcStatus.UNAVAILABLE).toBe(14);
+      expect(GrpcStatus.DATA_LOSS).toBe(15);
+      expect(GrpcStatus.UNAUTHENTICATED).toBe(16);
+    });
+  });
+
+  describe('httpStatusToGrpc', () => {
+    it('should map success statuses to OK', () => {
+      expect(httpStatusToGrpc(200)).toBe(GrpcStatus.OK);
+      expect(httpStatusToGrpc(201)).toBe(GrpcStatus.OK);
+      expect(httpStatusToGrpc(204)).toBe(GrpcStatus.OK);
+    });
+
+    it('should map 400 to INVALID_ARGUMENT', () => {
+      expect(httpStatusToGrpc(400)).toBe(GrpcStatus.INVALID_ARGUMENT);
+    });
+
+    it('should map 401 to UNAUTHENTICATED', () => {
+      expect(httpStatusToGrpc(401)).toBe(GrpcStatus.UNAUTHENTICATED);
+    });
+
+    it('should map 402 to FAILED_PRECONDITION', () => {
+      expect(httpStatusToGrpc(402)).toBe(GrpcStatus.FAILED_PRECONDITION);
+    });
+
+    it('should map 403 to PERMISSION_DENIED', () => {
+      expect(httpStatusToGrpc(403)).toBe(GrpcStatus.PERMISSION_DENIED);
+    });
+
+    it('should map 404 to NOT_FOUND', () => {
+      expect(httpStatusToGrpc(404)).toBe(GrpcStatus.NOT_FOUND);
+    });
+
+    it('should map 409 to ABORTED', () => {
+      expect(httpStatusToGrpc(409)).toBe(GrpcStatus.ABORTED);
+    });
+
+    it('should map 429 to RESOURCE_EXHAUSTED', () => {
+      expect(httpStatusToGrpc(429)).toBe(GrpcStatus.RESOURCE_EXHAUSTED);
+    });
+
+    it('should map 499 to CANCELLED', () => {
+      expect(httpStatusToGrpc(499)).toBe(GrpcStatus.CANCELLED);
+    });
+
+    it('should map 500 to INTERNAL', () => {
+      expect(httpStatusToGrpc(500)).toBe(GrpcStatus.INTERNAL);
+    });
+
+    it('should map 501 to UNIMPLEMENTED', () => {
+      expect(httpStatusToGrpc(501)).toBe(GrpcStatus.UNIMPLEMENTED);
+    });
+
+    it('should map 503 to UNAVAILABLE', () => {
+      expect(httpStatusToGrpc(503)).toBe(GrpcStatus.UNAVAILABLE);
+    });
+
+    it('should map 504 to DEADLINE_EXCEEDED', () => {
+      expect(httpStatusToGrpc(504)).toBe(GrpcStatus.DEADLINE_EXCEEDED);
+    });
+
+    it('should map unknown 4xx to INVALID_ARGUMENT', () => {
+      expect(httpStatusToGrpc(418)).toBe(GrpcStatus.INVALID_ARGUMENT);
+      expect(httpStatusToGrpc(422)).toBe(GrpcStatus.INVALID_ARGUMENT);
+    });
+
+    it('should map unknown 5xx to INTERNAL', () => {
+      expect(httpStatusToGrpc(502)).toBe(GrpcStatus.INTERNAL);
+      expect(httpStatusToGrpc(599)).toBe(GrpcStatus.INTERNAL);
+    });
+  });
+
+  describe('grpcStatusToHttp', () => {
+    it('should map OK to 200', () => {
+      expect(grpcStatusToHttp(GrpcStatus.OK)).toBe(200);
+    });
+
+    it('should map CANCELLED to 499', () => {
+      expect(grpcStatusToHttp(GrpcStatus.CANCELLED)).toBe(499);
+    });
+
+    it('should map INVALID_ARGUMENT to 400', () => {
+      expect(grpcStatusToHttp(GrpcStatus.INVALID_ARGUMENT)).toBe(400);
+    });
+
+    it('should map UNAUTHENTICATED to 401', () => {
+      expect(grpcStatusToHttp(GrpcStatus.UNAUTHENTICATED)).toBe(401);
+    });
+
+    it('should map FAILED_PRECONDITION to 402', () => {
+      expect(grpcStatusToHttp(GrpcStatus.FAILED_PRECONDITION)).toBe(402);
+    });
+
+    it('should map PERMISSION_DENIED to 403', () => {
+      expect(grpcStatusToHttp(GrpcStatus.PERMISSION_DENIED)).toBe(403);
+    });
+
+    it('should map NOT_FOUND to 404', () => {
+      expect(grpcStatusToHttp(GrpcStatus.NOT_FOUND)).toBe(404);
+    });
+
+    it('should map ABORTED to 409', () => {
+      expect(grpcStatusToHttp(GrpcStatus.ABORTED)).toBe(409);
+    });
+
+    it('should map RESOURCE_EXHAUSTED to 429', () => {
+      expect(grpcStatusToHttp(GrpcStatus.RESOURCE_EXHAUSTED)).toBe(429);
+    });
+
+    it('should map INTERNAL to 500', () => {
+      expect(grpcStatusToHttp(GrpcStatus.INTERNAL)).toBe(500);
+    });
+
+    it('should map UNIMPLEMENTED to 501', () => {
+      expect(grpcStatusToHttp(GrpcStatus.UNIMPLEMENTED)).toBe(501);
+    });
+
+    it('should map UNAVAILABLE to 503', () => {
+      expect(grpcStatusToHttp(GrpcStatus.UNAVAILABLE)).toBe(503);
+    });
+
+    it('should map DEADLINE_EXCEEDED to 504', () => {
+      expect(grpcStatusToHttp(GrpcStatus.DEADLINE_EXCEEDED)).toBe(504);
+    });
+  });
+
+  describe('peacErrorToGrpc - HTTP status parity', () => {
+    describe('402 Payment Required -> FAILED_PRECONDITION', () => {
+      it('should map E_RECEIPT_MISSING', () => {
+        expect(peacErrorToGrpc('E_RECEIPT_MISSING')).toBe(GrpcStatus.FAILED_PRECONDITION);
+      });
+
+      it('should map E_RECEIPT_INVALID', () => {
+        expect(peacErrorToGrpc('E_RECEIPT_INVALID')).toBe(GrpcStatus.FAILED_PRECONDITION);
+      });
+
+      it('should map E_RECEIPT_EXPIRED', () => {
+        expect(peacErrorToGrpc('E_RECEIPT_EXPIRED')).toBe(GrpcStatus.FAILED_PRECONDITION);
+      });
+    });
+
+    describe('401 Unauthorized -> UNAUTHENTICATED', () => {
+      it('should map E_TAP_SIGNATURE_MISSING', () => {
+        expect(peacErrorToGrpc('E_TAP_SIGNATURE_MISSING')).toBe(GrpcStatus.UNAUTHENTICATED);
+      });
+
+      it('should map E_TAP_SIGNATURE_INVALID', () => {
+        expect(peacErrorToGrpc('E_TAP_SIGNATURE_INVALID')).toBe(GrpcStatus.UNAUTHENTICATED);
+      });
+
+      it('should map E_TAP_TIME_INVALID', () => {
+        expect(peacErrorToGrpc('E_TAP_TIME_INVALID')).toBe(GrpcStatus.UNAUTHENTICATED);
+      });
+
+      it('should map E_TAP_KEY_NOT_FOUND', () => {
+        expect(peacErrorToGrpc('E_TAP_KEY_NOT_FOUND')).toBe(GrpcStatus.UNAUTHENTICATED);
+      });
+
+      it('should map E_TAP_REPLAY_PROTECTION_REQUIRED', () => {
+        expect(peacErrorToGrpc('E_TAP_REPLAY_PROTECTION_REQUIRED')).toBe(
+          GrpcStatus.UNAUTHENTICATED
+        );
+      });
+    });
+
+    describe('400 Bad Request -> INVALID_ARGUMENT', () => {
+      it('should map E_TAP_WINDOW_TOO_LARGE', () => {
+        expect(peacErrorToGrpc('E_TAP_WINDOW_TOO_LARGE')).toBe(GrpcStatus.INVALID_ARGUMENT);
+      });
+
+      it('should map E_TAP_TAG_UNKNOWN', () => {
+        expect(peacErrorToGrpc('E_TAP_TAG_UNKNOWN')).toBe(GrpcStatus.INVALID_ARGUMENT);
+      });
+
+      it('should map E_TAP_ALGORITHM_INVALID', () => {
+        expect(peacErrorToGrpc('E_TAP_ALGORITHM_INVALID')).toBe(GrpcStatus.INVALID_ARGUMENT);
+      });
+    });
+
+    describe('403 Forbidden -> PERMISSION_DENIED', () => {
+      it('should map E_ISSUER_NOT_ALLOWED', () => {
+        expect(peacErrorToGrpc('E_ISSUER_NOT_ALLOWED')).toBe(GrpcStatus.PERMISSION_DENIED);
+      });
+    });
+
+    describe('409 Conflict -> ABORTED', () => {
+      it('should map E_TAP_NONCE_REPLAY', () => {
+        expect(peacErrorToGrpc('E_TAP_NONCE_REPLAY')).toBe(GrpcStatus.ABORTED);
+      });
+    });
+
+    describe('500 Internal -> INTERNAL', () => {
+      it('should map E_CONFIG_ISSUER_ALLOWLIST_REQUIRED', () => {
+        expect(peacErrorToGrpc('E_CONFIG_ISSUER_ALLOWLIST_REQUIRED')).toBe(GrpcStatus.INTERNAL);
+      });
+
+      it('should map E_INTERNAL_ERROR', () => {
+        expect(peacErrorToGrpc('E_INTERNAL_ERROR')).toBe(GrpcStatus.INTERNAL);
+      });
+    });
+
+    describe('unknown errors', () => {
+      it('should default to INTERNAL for unknown errors', () => {
+        expect(peacErrorToGrpc('E_UNKNOWN_ERROR')).toBe(GrpcStatus.INTERNAL);
+      });
+    });
+  });
+
+  describe('createGrpcError', () => {
+    it('should create error with correct code', () => {
+      const error = createGrpcError('E_RECEIPT_MISSING', 'Receipt required');
+      expect(error.code).toBe(GrpcStatus.FAILED_PRECONDITION);
+      expect(error.message).toBe('Receipt required');
+      expect(error.peacCode).toBe('E_RECEIPT_MISSING');
+    });
+
+    it('should include details if provided', () => {
+      const error = createGrpcError('E_TAP_NONCE_REPLAY', 'Replay detected', { nonce: 'abc123' });
+      expect(error.details).toEqual({ nonce: 'abc123' });
+    });
+  });
+
+  describe('metadata utilities', () => {
+    describe('extractReceiptFromMetadata', () => {
+      it('should extract string receipt', () => {
+        const metadata = { [GrpcMetadataKeys.RECEIPT]: 'eyJ...' };
+        expect(extractReceiptFromMetadata(metadata)).toBe('eyJ...');
+      });
+
+      it('should extract first element from array', () => {
+        const metadata = { [GrpcMetadataKeys.RECEIPT]: ['eyJ...', 'eyK...'] };
+        expect(extractReceiptFromMetadata(metadata)).toBe('eyJ...');
+      });
+
+      it('should return null if not present', () => {
+        const metadata = {};
+        expect(extractReceiptFromMetadata(metadata)).toBeNull();
+      });
+
+      it('should return null for undefined', () => {
+        const metadata = { [GrpcMetadataKeys.RECEIPT]: undefined };
+        expect(extractReceiptFromMetadata(metadata)).toBeNull();
+      });
+
+      it('should return null for empty array', () => {
+        const metadata = { [GrpcMetadataKeys.RECEIPT]: [] };
+        expect(extractReceiptFromMetadata(metadata)).toBeNull();
+      });
+    });
+
+    describe('addReceiptToMetadata', () => {
+      it('should add receipt and type', () => {
+        const metadata: Record<string, string | string[]> = {};
+        addReceiptToMetadata(metadata, 'eyJ...');
+        expect(metadata[GrpcMetadataKeys.RECEIPT]).toBe('eyJ...');
+        expect(metadata[GrpcMetadataKeys.RECEIPT_TYPE]).toBe('interaction-record+jwt');
+      });
+    });
+  });
+
+  describe('verification results', () => {
+    describe('createSuccessResult', () => {
+      it('should create success without receipt ID', () => {
+        const result = createSuccessResult();
+        expect(result.ok).toBe(true);
+        expect(result.status).toBe(GrpcStatus.OK);
+        expect(result.error).toBeUndefined();
+        expect(result.receiptId).toBeUndefined();
+      });
+
+      it('should create success with receipt ID', () => {
+        const result = createSuccessResult('rid_12345');
+        expect(result.ok).toBe(true);
+        expect(result.status).toBe(GrpcStatus.OK);
+        expect(result.receiptId).toBe('rid_12345');
+      });
+    });
+
+    describe('createFailureResult', () => {
+      it('should create failure result', () => {
+        const error = createGrpcError('E_RECEIPT_MISSING', 'No receipt');
+        const result = createFailureResult(error);
+        expect(result.ok).toBe(false);
+        expect(result.status).toBe(GrpcStatus.FAILED_PRECONDITION);
+        expect(result.error).toBe(error);
+      });
+    });
+  });
+
+  describe('getStatusName', () => {
+    it('should return correct names', () => {
+      expect(getStatusName(GrpcStatus.OK)).toBe('OK');
+      expect(getStatusName(GrpcStatus.UNAUTHENTICATED)).toBe('UNAUTHENTICATED');
+      expect(getStatusName(GrpcStatus.FAILED_PRECONDITION)).toBe('FAILED_PRECONDITION');
+      expect(getStatusName(GrpcStatus.PERMISSION_DENIED)).toBe('PERMISSION_DENIED');
+      expect(getStatusName(GrpcStatus.ABORTED)).toBe('ABORTED');
+      expect(getStatusName(GrpcStatus.INTERNAL)).toBe('INTERNAL');
+    });
+
+    it('should return UNKNOWN for invalid codes', () => {
+      expect(getStatusName(99 as never)).toBe('UNKNOWN');
+    });
+  });
+
+  describe('metadata keys', () => {
+    it('should define standard keys', () => {
+      expect(GrpcMetadataKeys.RECEIPT).toBe('peac-receipt');
+      expect(GrpcMetadataKeys.RECEIPT_TYPE).toBe('peac-receipt-type');
+      expect(GrpcMetadataKeys.TAP_SIGNATURE).toBe('peac-tap-signature');
+      expect(GrpcMetadataKeys.TAP_SIGNATURE_INPUT).toBe('peac-tap-signature-input');
+      expect(GrpcMetadataKeys.ERROR_CODE).toBe('peac-error-code');
+      expect(GrpcMetadataKeys.REQUEST_ID).toBe('peac-request-id');
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "emitDeclarationOnly": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsup.config.ts

@@ -0,0 +1,19 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['cjs', 'esm'],
+  dts: false,
+  outDir: 'dist',
+  sourcemap: true,
+  clean: false,
+  splitting: false,
+  treeshake: true,
+  minify: false,
+  target: 'es2022',
+  platform: 'node',
+  external: [/^[^./]/],
+  outExtension({ format }) {
+    return { js: format === 'cjs' ? '.cjs' : '.mjs' };
+  },
+});

package/vitest.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest.config.d.ts","sourceRoot":"","sources":["vitest.config.ts"],"names":[],"mappings":";AAEA,wBAMG"}

package/vitest.config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest.config.js","sourceRoot":"","sources":["vitest.config.ts"],"names":[],"mappings":";;AAAA,0CAA6C;AAE7C,kBAAe,IAAA,qBAAY,EAAC;IAC1B,IAAI,EAAE;QACJ,IAAI,EAAE,GAAG;QACT,OAAO,EAAE,CAAC,oBAAoB,CAAC;QAC/B,WAAW,EAAE,KAAK;KACnB;CACF,CAAC,CAAC"}

package/vitest.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    root: '.',
+    include: ['tests/**/*.test.ts'],
+    testTimeout: 10000,
+  },
+});