gdc-common-utils-ts 1.0.4 → 1.0.7

package/__tests__/CryptographyService.test.ts

@@ -1,194 +0,0 @@
-// Copyright 2025 Antifraud Services Inc. under the Apache License, Version 2.0.
-
-import { randomBytes, createHash, randomUUID } from 'crypto';
-import { CryptographyService } from '../src/CryptographyService';
-import type { ICryptoHelper } from '../src/interfaces/ICryptoHelper';
-import { Content } from '../src/utils/content';
-import { MlDsaPrivKeySizeLevel2, MlDsaPubKeySizeLevel2 } from '../src/interfaces/MlDsa';
-import { Kyber512PKBytes } from '../src/interfaces/MlKem';
-
-const cryptoHelper: ICryptoHelper = {
-  async getRandomBytes(byteCount: number): Promise<Uint8Array> {
-    return randomBytes(byteCount);
-  },
-  async digestString(data: string, algorithm: string): Promise<string> {
-    const normalized = String(algorithm).replace('-', '').toLowerCase();
-    return createHash(normalized).update(data).digest('hex');
-  },
-  randomUUID(): string {
-    return randomUUID();
-  },
-};
-
-describe('CryptographyService (PQC)', () => {
-  const service = new CryptographyService(cryptoHelper);
-
-  it('generates ML-KEM key pairs and encapsulates/decapsulates', async () => {
-    const { publicJWKey, secretKeyBytes } = await service.generateKeyPairMlKem();
-    expect(publicJWKey?.x).toBeDefined();
-    expect(publicJWKey?.kid).toBeDefined();
-    expect(secretKeyBytes.length).toBeGreaterThan(0);
-
-    const recipientPublicKeyBytes = Content.base64ToBytes(publicJWKey.x);
-    const cekSeedBytes = await cryptoHelper.getRandomBytes(32);
-    const { derivedCekBytes, encapsulatedCekBytes } = await service.encapsulate(
-      cekSeedBytes,
-      secretKeyBytes,
-      recipientPublicKeyBytes
-    );
-    const derivedFromDecap = await service.decapsulate(encapsulatedCekBytes, secretKeyBytes);
-
-    expect(derivedCekBytes.length).toBeGreaterThan(0);
-    expect(derivedFromDecap.length).toBe(derivedCekBytes.length);
-    expect(Buffer.from(derivedFromDecap).equals(Buffer.from(derivedCekBytes))).toBe(true);
-  });
-
-  it('generates deterministic ML-KEM key pairs with a seed', async () => {
-    const seed = new Uint8Array(64).fill(7);
-    const first = await service.generateKeyPairMlKem(seed, 'ML-KEM-512');
-    const second = await service.generateKeyPairMlKem(seed, 'ML-KEM-512');
-    expect(first.publicJWKey.x).toBe(second.publicJWKey.x);
-    expect(first.publicJWKey.kid).toBe(second.publicJWKey.kid);
-    expect(first.secretKeyBytes.length).toBeGreaterThan(0);
-    expect(Content.base64ToBytes(first.publicJWKey.x).length).toBe(Kyber512PKBytes);
-  });
-
-  it('generates ML-DSA key pairs with expected sizes', async () => {
-    const seed = new Uint8Array(32).fill(3);
-    const { publicJWKey, secretKeyBytes } = await service.generateKeyPairMlDsa(seed, 'ML-DSA-44');
-    expect(publicJWKey.alg).toBe('ML-DSA-44');
-    expect(secretKeyBytes.length).toBeGreaterThanOrEqual(MlDsaPrivKeySizeLevel2);
-    expect(Content.base64ToBytes(publicJWKey.pub).length).toBe(MlDsaPubKeySizeLevel2);
-  });
-
-  it('signs and verifies with ML-DSA', async () => {
-    const { publicJWKey, secretKeyBytes } = await service.generateKeyPairMlDsa(undefined, 'ML-DSA-44');
-    const payload = Content.stringToBytesUTF8('test-payload');
-
-    const signature = await service.signBytes(payload, secretKeyBytes, 'ML-DSA-44');
-    const verified = await service.verifyBytes(signature, payload, publicJWKey);
-    expect(verified).toBe(true);
-
-    const tampered = Content.stringToBytesUTF8('test-payload-tampered');
-    const verifiedTampered = await service.verifyBytes(signature, tampered, publicJWKey);
-    expect(verifiedTampered).toBe(false);
-  });
-
-  it('signs JWS objects and verifies compact + detached forms', async () => {
-    const { publicJWKey, secretKeyBytes } = await service.generateKeyPairMlDsa(undefined, 'ML-DSA-44');
-    const protectedHeader = { alg: 'ML-DSA-44', typ: 'JWT' };
-    const payload = { sub: '123', aud: 'test' };
-
-    const jws = await service.signDataJws(payload, protectedHeader, secretKeyBytes);
-    const compact = `${jws.protected}.${jws.payload}.${jws.signature}`;
-    const verified = await service.verifyJws(compact, publicJWKey);
-    expect(verified).toBe(true);
-
-    const detached = `${jws.protected}..${jws.signature}`;
-    const payloadBytes = Content.stringToBytesUTF8(JSON.stringify(payload));
-    expect(await service.verifyDetachedJws(payloadBytes, detached, publicJWKey)).toBe(true);
-  });
-
-  it('throws on invalid detached JWS format', async () => {
-    await expect(service.verifyDetachedJws(new Uint8Array([1]), 'not-detached', { kty: 'AKP', alg: 'ML-DSA-44', pub: 'AA' }))
-      .rejects.toThrow(/Detached JWS format/);
-  });
-
-  it('throws on missing alg in headers for signing and verification', async () => {
-    const { publicJWKey, secretKeyBytes } = await service.generateKeyPairMlDsa(undefined, 'ML-DSA-44');
-    await expect(service.signDataJws({ a: 1 }, {}, secretKeyBytes)).rejects.toThrow(/alg/);
-
-    const missingAlg = { ...publicJWKey };
-    delete (missingAlg as any).alg;
-    await expect(service.verifyBytes(new Uint8Array([1]), new Uint8Array([2]), missingAlg as any)).rejects.toThrow(/alg/);
-  });
-
-  it('encrypts and decrypts JWE objects (zip + no zip)', async () => {
-    const recipient = await service.generateKeyPairMlKem(undefined, 'ML-KEM-768');
-    const recipientPrivate = { ...recipient.publicJWKey, dBytes: recipient.secretKeyBytes };
-
-    const payload = { msg: 'hello' };
-    const headerNoZip = { typ: 'JWE', kid: recipient.publicJWKey.kid };
-    const jwe = await service.encryptJwe(payload, headerNoZip, recipientPrivate, [recipient.publicJWKey]);
-    const decrypted = await service.decryptJwe(jwe, recipientPrivate);
-    expect(Content.bytesToStringUTF8(decrypted.decryptedBytes)).toBe(JSON.stringify(payload));
-
-    const headerZip = { typ: 'JWE', zip: 'DEF', kid: recipient.publicJWKey.kid };
-    const jweZip = await service.encryptJwe(payload, headerZip, recipientPrivate, [recipient.publicJWKey]);
-    const decryptedZip = await service.decryptJwe(jweZip, recipientPrivate);
-    expect(Content.bytesToStringUTF8(decryptedZip.decryptedBytes)).toBe(JSON.stringify(payload));
-  });
-
-  it('encrypts and decrypts compact JWE', async () => {
-    const recipient = await service.generateKeyPairMlKem(undefined, 'ML-KEM-768');
-    const recipientPrivate = { ...recipient.publicJWKey, dBytes: recipient.secretKeyBytes };
-
-    const payload = 'hello-compact';
-    const protectedHeader = { typ: 'JWE', zip: 'DEF' };
-    const compact = await service.encryptJweToCompact(payload, protectedHeader, recipientPrivate, recipient.publicJWKey);
-    const parsed = service.parseCompactJwe(compact);
-    const decrypted = await service.decryptJwe(parsed, recipientPrivate);
-    expect(Content.bytesToStringUTF8(decrypted.decryptedBytes)).toBe(payload);
-  });
-
-  it('rejects multiple recipients in encryptJwe', async () => {
-    const recipient = await service.generateKeyPairMlKem(undefined, 'ML-KEM-768');
-    const recipientPrivate = { ...recipient.publicJWKey, dBytes: recipient.secretKeyBytes };
-    await expect(
-      service.encryptJwe({ a: 1 }, { typ: 'JWE' }, recipientPrivate, [recipient.publicJWKey, recipient.publicJWKey])
-    ).rejects.toThrow(/single recipient/);
-  });
-
-  it('parses and rejects malformed compact structures', async () => {
-    expect(() => service.parseCompactJws('a.b')).toThrow(/Compact JWS/);
-    expect(() => service.parseCompactJwe('a.b.c')).toThrow(/Compact JWE/);
-  });
-
-  it('parses compact JWS into structured data', async () => {
-    const { publicJWKey, secretKeyBytes } = await service.generateKeyPairMlDsa(undefined, 'ML-DSA-44');
-    const jws = await service.signDataJws({ sub: 'abc' }, { alg: 'ML-DSA-44' }, secretKeyBytes);
-    const compact = `${jws.protected}.${jws.payload}.${jws.signature}`;
-    const parsed = service.parseCompactJws(compact);
-    expect(parsed.payload).toEqual({ sub: 'abc' });
-    expect(parsed.protected).toEqual({ alg: 'ML-DSA-44' });
-    expect(await service.verifyJws(compact, publicJWKey)).toBe(true);
-  });
-
-  it('parses JWS JSON serialization', async () => {
-    const { secretKeyBytes } = await service.generateKeyPairMlDsa(undefined, 'ML-DSA-44');
-    const jws = await service.signDataJws({ sub: 'json' }, { alg: 'ML-DSA-44' }, secretKeyBytes);
-    const jwsJson = JSON.stringify({
-      payload: jws.payload,
-      signatures: [{ protected: jws.protected, signature: jws.signature }],
-    });
-    const parsed = service.parseCompactJws(jwsJson);
-    expect(parsed.payload).toBe(jws.payload);
-    expect(parsed.protected).toBe(jws.protected);
-    expect(parsed.signature).toBe(jws.signature);
-  });
-
-  it('extracts recipient kids from JWE objects', async () => {
-    const recipient = await service.generateKeyPairMlKem(undefined, 'ML-KEM-768');
-    const recipientPrivate = { ...recipient.publicJWKey, dBytes: recipient.secretKeyBytes };
-    const jwe = await service.encryptJwe({ a: 1 }, { typ: 'JWE', kid: recipient.publicJWKey.kid }, recipientPrivate, [recipient.publicJWKey]);
-    expect(service.getRecipientKidsFromJwe(jwe)).toEqual([recipient.publicJWKey.kid]);
-    expect(service.getRecipientKidsFromJwe({} as any)).toEqual([]);
-  });
-
-  it('parses JWE JSON serialization', async () => {
-    const recipient = await service.generateKeyPairMlKem(undefined, 'ML-KEM-768');
-    const recipientPrivate = { ...recipient.publicJWKey, dBytes: recipient.secretKeyBytes };
-    const jwe = await service.encryptJwe({ msg: 'json' }, { typ: 'JWE', kid: recipient.publicJWKey.kid }, recipientPrivate, [recipient.publicJWKey]);
-    const parsed = service.parseCompactJwe(JSON.stringify(jwe));
-    const decrypted = await service.decryptJwe(parsed, recipientPrivate);
-    expect(Content.bytesToStringUTF8(decrypted.decryptedBytes)).toBe(JSON.stringify({ msg: 'json' }));
-  });
-
-  it('computes JWK thumbprints for EC keys', async () => {
-    const ecJwk = { kty: 'EC', crv: 'P-256', x: 'AA', y: 'BB' };
-    const thumbprint = await (service as any)._computeJwkThumbprint(ecJwk, 'SHA-384');
-    const thumbprint2 = await (service as any)._computeJwkThumbprint(ecJwk, 'SHA-384');
-    expect(thumbprint).toBe(thumbprint2);
-    expect(thumbprint.length).toBeGreaterThan(0);
-  });
-});

package/__tests__/bundle.test.ts

@@ -1,29 +0,0 @@
-// Copyright 2025 Antifraud Services Inc. under the Apache License, Version 2.0.
-
-import { extractResources, getNextLink } from '../src/utils/bundle';
-
-describe('bundle utils', () => {
-  it('extracts resources from FHIR bundle entry', () => {
-    const bundle = {
-      entry: [{ resource: { id: 'r1' } }, { resource: { id: 'r2' } }],
-    };
-    expect(extractResources(bundle)).toEqual([{ id: 'r1' }, { id: 'r2' }]);
-  });
-
-  it('extracts resources from JSON:API data', () => {
-    const bundle = {
-      data: [{ resource: { id: 'r1' } }, { id: 'r2' }],
-    };
-    expect(extractResources(bundle)).toEqual([{ id: 'r1' }, { id: 'r2' }]);
-  });
-
-  it('returns resource fallback when bundle is a resource', () => {
-    const bundle = { resourceType: 'Patient', id: 'p1' };
-    expect(extractResources(bundle)).toEqual([bundle]);
-  });
-
-  it('reads next link', () => {
-    const bundle = { link: [{ relation: 'next', url: 'https://next' }] };
-    expect(getNextLink(bundle)).toBe('https://next');
-  });
-});

package/__tests__/content.test.ts

@@ -1,72 +0,0 @@
-// src/__tests__/unit/utils/convert.test.ts
-
-import { Content } from '../src/utils/content.js';
-
-describe("Content Class - Conversion Utilities", () => {
-
-    describe("Base58 Conversions", () => {
-        it("should encode and decode a string to/from Base58", () => {
-            const testString = "Hello world!";
-            const testBytes = Content.stringToBytesUTF8(testString);
-
-            // Encode
-            const encoded = Content.bytesToBase58(testBytes);
-            expect(encoded).toBe("2NEpo7TZRhna7vSvL");
-
-            // Decode
-            const decodedBytes = Content.base58ToBytes(encoded);
-            const decodedString = Content.bytesToStringUTF8(decodedBytes);
-
-            expect(decodedString).toBe(testString);
-        });
-    });
-
-    describe("Base64URL Conversions", () => {
-        it("should encode and decode bytes to/from raw Base64URL", () => {
-            const testString = "some important data!?";
-            const testBytes = Content.stringToBytesUTF8(testString);
-
-            // Encode
-            const encoded = Content.bytesToRawBase64UrlSafe(testBytes);
-            expect(encoded).toBe("c29tZSBpbXBvcnRhbnQgZGF0YSE_");
-
-            // Decode
-            const decodedBytes = Content.base64ToBytes(encoded);
-            expect(decodedBytes).toEqual(testBytes);
-        });
-    });
-
-    describe("Object Serialization", () => {
-        it("should serialize and deserialize an object to/from raw Base64URL", () => {
-            const testObject = {
-                id: "12345",
-                aud: ["did:web:example.com"],
-                exp: 1678886400,
-                verified: true,
-            };
-
-            // Serialize
-            const encoded = Content.objectToRawBase64UrlSafe(testObject);
-
-            // Deserialize
-            const decodedObject = Content.base64UrlSafeToJSON(encoded);
-
-            expect(decodedObject).toEqual(testObject);
-        });
-    });
-
-    describe("Array Utilities", () => {
-        it("should correctly compare two identical arrays of primitives", () => {
-            const arr1 = [1, 2, "hello", true, null];
-            const arr2 = [1, 2, "hello", true, null];
-            expect(Content.arrayCompare(arr1, arr2)).toBe(true);
-        });
-
-        it("should correctly identify two different arrays", () => {
-            const arr1 = [1, 2, 5];
-            const arr2 = [1, 2, 9];
-            expect(Content.arrayCompare(arr1, arr2)).toBe(false);
-        });
-    });
-});
-

package/__tests__/crypto-encode-decode.test.ts

@@ -1,52 +0,0 @@
-import { encodeJWT as encodeJWTEncode } from '../src/cryptoEncode.js';
-import { encodeJWT as encodeJWTDecode, decodeBase64Url, decodePayloadRequest } from '../src/cryptoDecode.js';
-
-function base64UrlEncode(str: string): string {
-  return Buffer.from(str)
-    .toString('base64')
-    .replace(/\+/g, '-')
-    .replace(/\//g, '_')
-    .replace(/=+$/, '');
-}
-
-describe('crypto encode/decode', () => {
-  it('encodes JWTs with alg none (cryptoEncode)', () => {
-    const header = { alg: 'none' };
-    const payload = { sub: '123' };
-    const token = encodeJWTEncode([], payload, [], header);
-    const parts = token.split('.');
-    expect(parts.length).toBe(3);
-    expect(decodeBase64Url(parts[0])).toBe(JSON.stringify(header));
-    expect(decodeBase64Url(parts[1])).toBe(JSON.stringify(payload));
-  });
-
-  it('encodes JWTs with alg none (cryptoDecode)', () => {
-    const header = { alg: 'none' };
-    const payload = { sub: '456' };
-    const token = encodeJWTDecode([], payload, [], header);
-    const parts = token.split('.');
-    expect(decodeBase64Url(parts[0])).toBe(JSON.stringify(header));
-    expect(decodeBase64Url(parts[1])).toBe(JSON.stringify(payload));
-  });
-
-  it('decodes payloads from authorization headers', () => {
-    const header = { alg: 'none' };
-    const payload = { a: 1 };
-    const token = `${base64UrlEncode(JSON.stringify(header))}.${base64UrlEncode(JSON.stringify(payload))}.`;
-    const decoded = decodePayloadRequest('tenant', undefined, `Bearer ${token}`);
-    expect(decoded).toBe(JSON.stringify(payload));
-  });
-
-  it('returns null when token is missing', () => {
-    const spy = jest.spyOn(console, 'error').mockImplementation(() => {});
-    expect(decodePayloadRequest('tenant', undefined, undefined)).toBeNull();
-    spy.mockRestore();
-  });
-
-  it('returns empty string for invalid payload JSON', () => {
-    const invalid = base64UrlEncode('not-json');
-    const spy = jest.spyOn(console, 'error').mockImplementation(() => {});
-    expect(decodeBase64Url(invalid)).toBe('');
-    spy.mockRestore();
-  });
-});

package/__tests__/crypto-hmac.test.ts

@@ -1,21 +0,0 @@
-import { computeHmacSha256, computeHmacSha256Base64Url } from '../src/hmac.js';
-
-describe('hmac utilities', () => {
-  it('computes HMAC-SHA3-256 bytes deterministically', async () => {
-    const key = new Uint8Array([1, 2, 3, 4]);
-    const message = 'hello';
-    const first = await computeHmacSha256(message, key);
-    const second = await computeHmacSha256(message, key);
-    expect(Array.from(first)).toEqual(Array.from(second));
-    expect(first.length).toBe(32);
-  });
-
-  it('computes base64url HMAC output consistently', async () => {
-    const key = new Uint8Array([9, 8, 7, 6]);
-    const message = 'hello';
-    const first = await computeHmacSha256Base64Url(message, key);
-    const second = await computeHmacSha256Base64Url(message, key);
-    expect(first).toBe(second);
-    expect(first.length).toBe(43);
-  });
-});

package/__tests__/did-generateServiceId.errors.test.ts

@@ -1,8 +0,0 @@
-import { generateServiceId } from '../src/utils/did.js';
-
-describe('generateServiceId (edge cases)', () => {
-  it('keeps action casing', () => {
-    const id = generateServiceId({ section: 'identity', format: 'openid', resourceType: 'device', action: '_DCR' });
-    expect(id).toBe('#identity:openid:device:_DCR');
-  });
-});

package/__tests__/did-generateServiceId.test.ts

@@ -1,18 +0,0 @@
-import { generateServiceId } from '../src/utils/did.js';
-
-describe('generateServiceId', () => {
-  it('builds #section:format:resourceType:action', () => {
-    const id = generateServiceId({
-      section: 'identity',
-      format: 'openid',
-      resourceType: 'Device',
-      action: '_dcr',
-    });
-    expect(id).toBe('#identity:openid:device:_dcr');
-  });
-
-  it('filters empty parts', () => {
-    const id = generateServiceId({ section: 'x', format: 'y', resourceType: '', action: '_batch' });
-    expect(id).toBe('#x:y:_batch');
-  });
-});

package/__tests__/models-clinical-sections.test.ts

@@ -1,32 +0,0 @@
-import {
-  clinicalSectionRegistry,
-  getClinicalSectionByCode,
-  loincI18nKey,
-  supportedClinicalSectionCodes,
-  clinicalSectionTitleEn,
-} from '../src/models/clinical-sections.js';
-
-describe('clinical sections', () => {
-  it('builds i18n keys from LOINC codes', () => {
-    expect(loincI18nKey('1234-5')).toBe('org.loinc.1234-5');
-  });
-
-  it('exposes supported section codes', () => {
-    const codes = Object.keys(clinicalSectionTitleEn);
-    expect(supportedClinicalSectionCodes.length).toBe(codes.length);
-    expect(supportedClinicalSectionCodes).toContain(codes[0]);
-  });
-
-  it('provides registry entries', () => {
-    const code = supportedClinicalSectionCodes[0];
-    const entry = clinicalSectionRegistry[code];
-    expect(entry.code).toBe(code);
-    expect(entry.i18nKey).toBe(loincI18nKey(code));
-  });
-
-  it('gets clinical section by code', () => {
-    const code = supportedClinicalSectionCodes[0];
-    expect(getClinicalSectionByCode(code)?.code).toBe(code);
-    expect(getClinicalSectionByCode('missing')).toBeUndefined();
-  });
-});

package/__tests__/models-multibase58.test.ts

@@ -1,33 +0,0 @@
-import {
-  decodeMultibase58btc,
-  decodeMultibase58btcToHex,
-  decodeMultibase58btcToUUID,
-  encodeHexToMultibase58btc,
-  encodeMultibase58btc,
-} from '../src/models/multibase58.js';
-
-describe('models multibase58', () => {
-  it('round-trips hex to multibase and back', () => {
-    const hex = '00112233445566778899aabbccddeeff';
-    const encoded = encodeHexToMultibase58btc(hex);
-    const decodedHex = decodeMultibase58btcToHex(encoded);
-    expect(decodedHex).toBe(hex);
-  });
-
-  it('decodes to UUID with hyphens', () => {
-    const hex = '00112233445566778899aabbccddeeff';
-    const encoded = encodeHexToMultibase58btc(hex);
-    expect(decodeMultibase58btcToUUID(encoded)).toBe('00112233-4455-6677-8899-aabbccddeeff');
-  });
-
-  it('encodes and decodes raw bytes', () => {
-    const bytes = new Uint8Array([9, 9, 9]);
-    const encoded = encodeMultibase58btc(bytes);
-    const decoded = decodeMultibase58btc(encoded);
-    expect(Array.from(decoded)).toEqual([9, 9, 9]);
-  });
-
-  it('throws for invalid hex input', () => {
-    expect(() => encodeHexToMultibase58btc('not-hex')).toThrow(/Invalid 16-byte hex string/);
-  });
-});

package/__tests__/multibase58.errors.test.ts

@@ -1,7 +0,0 @@
-import { decodeMultibase58btc } from '../src/utils/multibase58.js';
-
-describe('multibase58 (errors)', () => {
-  it('throws on empty string', () => {
-    expect(() => decodeMultibase58btc('')).toThrow();
-  });
-});

package/__tests__/multibase58.test.ts

@@ -1,28 +0,0 @@
-import {
-  decodeMultibase58btc,
-  decodeMultibase58btcToHex,
-  decodeMultibase58btcToUUID,
-  encodeHexToMultibase58btc,
-  encodeMultibase58btc,
-} from '../src/utils/multibase58.js';
-
-describe('multibase58', () => {
-  it('round-trips bytes', () => {
-    const bytes = new Uint8Array([1, 2, 3, 250, 251, 252]);
-    const encoded = encodeMultibase58btc(bytes);
-    expect(encoded.startsWith('z')).toBe(true);
-    const decoded = decodeMultibase58btc(encoded);
-    expect(Array.from(decoded)).toEqual(Array.from(bytes));
-  });
-
-  it('throws if prefix is missing', () => {
-    expect(() => decodeMultibase58btc('not-prefixed')).toThrow(/missing 'z' prefix/i);
-  });
-
-  it('round-trips hex to multibase and back', () => {
-    const hex = '00112233445566778899aabbccddeeff';
-    const encoded = encodeHexToMultibase58btc(hex);
-    expect(decodeMultibase58btcToHex(encoded)).toBe(hex);
-    expect(decodeMultibase58btcToUUID(encoded)).toBe('00112233-4455-6677-8899-aabbccddeeff');
-  });
-});

package/__tests__/multibasehash.test.ts

@@ -1,25 +0,0 @@
-// Copyright 2025 Antifraud Services Inc. under the Apache License, Version 2.0.
-
-import baseX from 'base-x';
-import { encodeMultibaseSha384 } from '../src/utils/multibasehash';
-
-const BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
-const base58btc = baseX(BASE58_ALPHABET);
-
-describe('encodeMultibaseSha384', () => {
-  it('returns a multibase base58btc string with SHA-384 prefix', () => {
-    const output = encodeMultibaseSha384('hello');
-    expect(output.startsWith('z')).toBe(true);
-
-    const decoded = base58btc.decode(output.slice(1));
-    expect(decoded[0]).toBe(0x15);
-    expect(decoded[1]).toBe(0x30);
-    expect(decoded.length).toBe(2 + 48);
-  });
-
-  it('is deterministic for same input', () => {
-    const a = encodeMultibaseSha384('same');
-    const b = encodeMultibaseSha384('same');
-    expect(a).toBe(b);
-  });
-});

package/__tests__/utils-actor.test.ts

@@ -1,46 +0,0 @@
-import { parseActorFromSub } from '../src/utils/actor.js';
-
-describe('parseActorFromSub', () => {
-  it('returns trimmed subject and minimal info for empty input', () => {
-    expect(parseActorFromSub('  ')).toEqual({ sub: '' });
-  });
-
-  it('parses did:web subject with organization, email, and role', () => {
-    const sub = 'did:web:api.acme.org:employee:doctor1@acme.org:ISCO-08|2211';
-    const parsed = parseActorFromSub(sub);
-    expect(parsed.sub).toBe(sub);
-    expect(parsed.organization).toBe('did:web:api.acme.org');
-    expect(parsed.identifier).toBe('doctor1@acme.org');
-    expect(parsed.role).toBe('ISCO-08|2211');
-  });
-
-  it('parses did:web subject with role and device uuid', () => {
-    const sub = 'did:web:api.acme.org:employee:doctor1@acme.org:ISCO-08|2211:550e8400-e29b-41d4-a716-446655440000';
-    const parsed = parseActorFromSub(sub);
-    expect(parsed.organization).toBe('did:web:api.acme.org');
-    expect(parsed.identifier).toBe('doctor1@acme.org');
-    expect(parsed.role).toBe('ISCO-08|2211');
-  });
-
-  it('parses family subject with role and device uuid', () => {
-    const sub = 'did:web:api.acme.org:family:zQmHash123:v3-RoleCode|CHILD:550e8400-e29b-41d4-a716-446655440000';
-    const parsed = parseActorFromSub(sub);
-    expect(parsed.organization).toBe('did:web:api.acme.org');
-    expect(parsed.identifier).toBe('zQmHash123');
-    expect(parsed.role).toBe('v3-RoleCode|CHILD');
-  });
-
-  it('parses family subject with ONESELF role and no device uuid', () => {
-    const sub = 'did:web:api.acme.org:family:zQmHash123:v3-RoleCode|ONESELF';
-    const parsed = parseActorFromSub(sub);
-    expect(parsed.organization).toBe('did:web:api.acme.org');
-    expect(parsed.identifier).toBe('zQmHash123');
-    expect(parsed.role).toBe('v3-RoleCode|ONESELF');
-  });
-
-  it('parses raw email subject', () => {
-    const parsed = parseActorFromSub('  User@Example.com ');
-    expect(parsed.sub).toBe('User@Example.com');
-    expect(parsed.identifier).toBe('user@example.com');
-  });
-});

package/__tests__/utils-base-convert.test.ts

@@ -1,57 +0,0 @@
-import {
-  base58ToBytes,
-  base64OrUrlSafeToBytes,
-  base64ToBase64Url,
-  base64UrlToBase64,
-  bytesToBase58,
-  bytesToBase64,
-  bytesToHexString,
-  bytesToRawBase64UrlSafe,
-  stringToBase64Url,
-  stringToStdBase64,
-} from '../src/utils/base-convert.js';
-import { stringToBytesUTF8, bytesToStringUTF8 } from '../src/utils/string-convert.js';
-
-function toArray(bytes: Uint8Array): number[] {
-  return Array.from(bytes);
-}
-
-describe('base-convert utilities', () => {
-  it('converts bytes to hex string', () => {
-    const hex = bytesToHexString(new Uint8Array([0, 15, 255]));
-    expect(hex).toBe('000fff');
-  });
-
-  it('round-trips base58 encoding', () => {
-    const bytes = stringToBytesUTF8('hello');
-    const encoded = bytesToBase58(bytes);
-    const decoded = base58ToBytes(encoded);
-    expect(toArray(decoded)).toEqual(toArray(bytes));
-  });
-
-  it('handles base64 and base64url conversions', () => {
-    const std = stringToStdBase64('hi');
-    expect(std).toBe('aGk=');
-    const url = stringToBase64Url('hi');
-    expect(url).toBe('aGk=');
-    expect(base64ToBase64Url('ab+/')).toBe('ab-_');
-    expect(base64UrlToBase64('ab-_')).toBe('ab+/');
-  });
-
-  it('decodes base64 or base64url into bytes', () => {
-    const withSlash = '//8='; // bytes [255, 255]
-    const fromBase64 = base64OrUrlSafeToBytes(withSlash);
-    expect(toArray(fromBase64)).toEqual([255, 255]);
-
-    const urlSafe = 'AQID'; // bytes [1,2,3]
-    const fromUrlSafe = base64OrUrlSafeToBytes(urlSafe);
-    expect(toArray(fromUrlSafe)).toEqual([1, 2, 3]);
-  });
-
-  it('encodes bytes to base64 and raw base64url', () => {
-    const bytes = stringToBytesUTF8('test');
-    expect(bytesToBase64(bytes)).toBe('dGVzdA==');
-    expect(bytesToRawBase64UrlSafe(bytes)).toBe('dGVzdA');
-    expect(bytesToStringUTF8(base64OrUrlSafeToBytes(bytesToRawBase64UrlSafe(bytes)))).toBe('test');
-  });
-});