@tstdl/base 0.93.182 → 0.93.183

package/circuit-breaker/tests/circuit-breaker.test.js

@@ -1,116 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it } from 'vitest';
-import { CircuitBreakerState } from '../../circuit-breaker/index.js';
-import { CircuitBreakerProvider } from '../../circuit-breaker/provider.js';
-import { setupIntegrationTest } from '../../testing/index.js';
-import { timeout } from '../../utils/timing.js';
-describe('Circuit Breaker (Standalone) Tests', () => {
-    let injector;
-    let provider;
-    beforeAll(async () => {
-        ({ injector } = (await setupIntegrationTest({ modules: { circuitBreaker: true } })));
-        provider = injector.resolve(CircuitBreakerProvider);
-    });
-    afterAll(async () => {
-        await injector.dispose();
-    });
-    it('should start in Closed state', async () => {
-        const breaker = provider.provide(`cb-init-${Date.now()}`, { threshold: 2, resetTimeout: 1000 });
-        const result = await breaker.check();
-        expect(result.allowed).toBe(true);
-        expect(result.state).toBe(CircuitBreakerState.Closed);
-    });
-    it('should trip to Open after threshold failures', async () => {
-        const breaker = provider.provide(`cb-trip-${Date.now()}`, { threshold: 2, resetTimeout: 1000 });
-        // 1. First Failure
-        await breaker.recordFailure();
-        let result = await breaker.check();
-        expect(result.state).toBe(CircuitBreakerState.Closed);
-        // 2. Second Failure (Threshold Reached)
-        await breaker.recordFailure();
-        result = await breaker.check();
-        expect(result.allowed).toBe(false);
-        expect(result.state).toBe(CircuitBreakerState.Open);
-    });
-    it('should reset to Closed on success', async () => {
-        const breaker = provider.provide(`cb-reset-${Date.now()}`, { threshold: 2, resetTimeout: 1000 });
-        // Trip it
-        await breaker.recordFailure();
-        await breaker.recordFailure();
-        expect((await breaker.check()).state).toBe(CircuitBreakerState.Open);
-        // Record Success
-        await breaker.recordSuccess();
-        const result = await breaker.check();
-        expect(result.allowed).toBe(true);
-        expect(result.state).toBe(CircuitBreakerState.Closed);
-    });
-    it('should transition to Half-Open (Probe) after timeout', async () => {
-        const timeoutMs = 200;
-        const breaker = provider.provide(`cb-probe-${Date.now()}`, { threshold: 1, resetTimeout: timeoutMs });
-        // Trip it
-        await breaker.recordFailure();
-        expect((await breaker.check()).state).toBe(CircuitBreakerState.Open);
-        // Wait for timeout
-        await timeout(timeoutMs + 50);
-        // First check should be the Probe
-        const probe = await breaker.check();
-        expect(probe.allowed).toBe(true);
-        expect(probe.state).toBe(CircuitBreakerState.HalfOpen);
-        expect(probe.isProbe).toBe(true);
-        // Subsequent check should be allowed but not the probe
-        const subsequent = await breaker.check();
-        expect(subsequent.allowed).toBe(true);
-        expect(subsequent.state).toBe(CircuitBreakerState.HalfOpen);
-        expect(subsequent.isProbe).toBe(false);
-        // Another check should also be allowed
-        const third = await breaker.check();
-        expect(third.allowed).toBe(true);
-        expect(third.state).toBe(CircuitBreakerState.HalfOpen);
-        expect(third.isProbe).toBe(false);
-    });
-    it('should close if Probe succeeds', async () => {
-        const timeoutMs = 100;
-        const breaker = provider.provide(`cb-probe-success-${Date.now()}`, { threshold: 1, resetTimeout: timeoutMs });
-        // Trip and Probe
-        await breaker.recordFailure();
-        await timeout(timeoutMs + 50);
-        await breaker.check(); // Probe triggered
-        // Probe succeeds
-        await breaker.recordSuccess();
-        const result = await breaker.check();
-        expect(result.state).toBe(CircuitBreakerState.Closed);
-    });
-    it('should reopen if Probe fails', async () => {
-        const timeoutMs = 100;
-        const breaker = provider.provide(`cb-probe-fail-${Date.now()}`, { threshold: 1, resetTimeout: timeoutMs });
-        // Trip and Probe
-        await breaker.recordFailure();
-        await timeout(timeoutMs + 50);
-        await breaker.check(); // Probe triggered (State: HalfOpen)
-        // Probe fails
-        await breaker.recordFailure();
-        // Should be Open again
-        const result = await breaker.check();
-        expect(result.allowed).toBe(false);
-        expect(result.state).toBe(CircuitBreakerState.Open);
-    });
-    it('should trip to Open after threshold failures via recordFailures', async () => {
-        const breaker = provider.provide(`cb-bulk-trip-${Date.now()}`, { threshold: 5, resetTimeout: 1000 });
-        // 1. Bulk Failure (Threshold Not Reached)
-        await breaker.recordFailures(3);
-        let result = await breaker.check();
-        expect(result.state).toBe(CircuitBreakerState.Closed);
-        // 2. Bulk Failure (Threshold Reached)
-        await breaker.recordFailures(2);
-        result = await breaker.check();
-        expect(result.allowed).toBe(false);
-        expect(result.state).toBe(CircuitBreakerState.Open);
-    });
-    it('should trip to Open after threshold failures via single large recordFailures', async () => {
-        const breaker = provider.provide(`cb-single-bulk-trip-${Date.now()}`, { threshold: 5, resetTimeout: 1000 });
-        // Single large bulk failure exceeding threshold
-        await breaker.recordFailures(10);
-        const result = await breaker.check();
-        expect(result.allowed).toBe(false);
-        expect(result.state).toBe(CircuitBreakerState.Open);
-    });
-});

package/cryptography/tests/cryptography.test.d.ts

@@ -1 +0,0 @@
-export {};

package/cryptography/tests/cryptography.test.js

@@ -1,175 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import { encodeUtf8 } from '../../utils/encoding.js';
-import { decrypt, deriveBytes, digest, encrypt, generateEcdsaKey, generateHmacKey, generatePbkdf2Key, generateSymmetricKey, importEcdsaKey, importHkdfKey, importHmacKey, importPbkdf2Key, importSymmetricKey, sign, verify } from '../cryptography.js';
-describe('Cryptography Utilities', () => {
-    test('encrypt and decrypt with AES-GCM (string)', async () => {
-        const key = await generateSymmetricKey({ name: 'AES-GCM', length: 256 });
-        const data = 'Hello World';
-        const iv = globalThis.crypto.getRandomValues(new Uint8Array(12));
-        const algorithm = { name: 'AES-GCM', iv };
-        const encryptionResult = encrypt(algorithm, key, data);
-        const encryptedBuffer = await encryptionResult.toBuffer();
-        const decryptionResult = decrypt(algorithm, key, encryptedBuffer);
-        const decryptedText = await decryptionResult.toUtf8();
-        expect(decryptedText).toBe(data);
-        expect(await encryptionResult.toHex()).toBeTypeOf('string');
-        expect(await encryptionResult.toBase64()).toBeTypeOf('string');
-        expect(await encryptionResult.toBase64Url()).toBeTypeOf('string');
-        expect(await encryptionResult.toZBase32()).toBeTypeOf('string');
-    });
-    test('encrypt and decrypt with AES-CBC (Uint8Array)', async () => {
-        const key = await generateSymmetricKey({ name: 'AES-CBC', length: 256 });
-        const data = new Uint8Array([1, 2, 3, 4, 5]);
-        const iv = globalThis.crypto.getRandomValues(new Uint8Array(16));
-        const algorithm = { name: 'AES-CBC', iv };
-        const encryptionResult = encrypt(algorithm, key, data);
-        const encryptedBuffer = await encryptionResult.toBuffer();
-        const decryptionResult = decrypt(algorithm, key, encryptedBuffer);
-        const decryptedBuffer = await decryptionResult.toBuffer();
-        expect(new Uint8Array(decryptedBuffer)).toEqual(data);
-    });
-    test('digest with SHA-256', async () => {
-        const data = 'Hello World';
-        const result = digest('SHA-256', data);
-        const hex = await result.toHex();
-        // SHA-256 of "Hello World"
-        expect(hex).toBe('a591a6d40bf420404a011733cfb7b190d62c65bf0bcda32b57b277d9ad9f146e');
-        const bufferResult = digest('SHA-256', encodeUtf8(data));
-        expect(await bufferResult.toHex()).toBe(hex);
-    });
-    test('sign and verify with HMAC', async () => {
-        const key = await generateHmacKey('SHA-256');
-        const data = 'Hello World';
-        const algorithm = { name: 'HMAC', hash: 'SHA-256' };
-        const signatureResult = sign(algorithm, key, data);
-        const signature = await signatureResult.toBuffer();
-        // Test with mixed string/binary
-        expect(await verify(algorithm, key, signature, data)).toBe(true);
-        expect(await verify(algorithm, key, new Uint8Array(signature), encodeUtf8(data))).toBe(true);
-        const isInvalid = await verify(algorithm, key, signature, 'Wrong Data');
-        expect(isInvalid).toBe(false);
-        const isInvalidSignature = await verify(algorithm, key, new Uint8Array(signature.byteLength), data);
-        expect(isInvalidSignature).toBe(false);
-    });
-    test('import and export HMAC key (raw)', async () => {
-        const rawKey = encodeUtf8('my-secret-key');
-        const key = await importHmacKey('raw-secret', 'SHA-256', rawKey, true);
-        expect(key.algorithm.name).toBe('HMAC');
-        expect(key.algorithm.hash.name).toBe('SHA-256');
-        const exportedKey = await globalThis.crypto.subtle.exportKey('raw', key);
-        expect(new Uint8Array(exportedKey)).toEqual(rawKey);
-        // Test import with string
-        const keyFromString = await importHmacKey('raw-secret', 'SHA-256', encodeUtf8('my-secret-key'));
-        expect(keyFromString.algorithm.name).toBe('HMAC');
-    });
-    test('import HMAC key (JWK)', async () => {
-        const jwk = {
-            kty: 'oct',
-            k: 'bXktc2VjcmV0LWtleQ', // "my-secret-key" in base64url
-            alg: 'HS256',
-            ext: true,
-        };
-        const key = await importHmacKey('jwk', 'SHA-256', jwk, true);
-        expect(key.algorithm.name).toBe('HMAC');
-        const exportedKey = await globalThis.crypto.subtle.exportKey('raw', key);
-        expect(new Uint8Array(exportedKey)).toEqual(encodeUtf8('my-secret-key'));
-    });
-    test('import symmetric key (raw)', async () => {
-        const rawKey = globalThis.crypto.getRandomValues(new Uint8Array(32));
-        const key = await importSymmetricKey('raw-secret', { name: 'AES-GCM', length: 256 }, rawKey, true);
-        expect(key.algorithm.name).toBe('AES-GCM');
-        expect(key.algorithm.length).toBe(256);
-        const exportedKey = await globalThis.crypto.subtle.exportKey('raw', key);
-        expect(new Uint8Array(exportedKey)).toEqual(rawKey);
-        // Test import with encoded string (exactly 32 chars)
-        const keyFromString = await importSymmetricKey('raw-secret', { name: 'AES-GCM', length: 256 }, encodeUtf8('01234567890123456789012345678901'));
-        expect(keyFromString.algorithm.name).toBe('AES-GCM');
-    });
-    test('import symmetric key (JWK)', async () => {
-        const jwk = {
-            kty: 'oct',
-            k: 'AAECAwQFBgcICQoLDA0ODw', // [0, 1, ..., 15]
-            alg: 'A128GCM',
-            ext: true,
-        };
-        const key = await importSymmetricKey('jwk', { name: 'AES-GCM', length: 128 }, jwk, true);
-        expect(key.algorithm.name).toBe('AES-GCM');
-        const exportedJwk = await globalThis.crypto.subtle.exportKey('jwk', key);
-        expect(exportedJwk.k).toBe(jwk.k);
-    });
-    test('sign and verify with ECDSA', async () => {
-        const keyPair = await generateEcdsaKey('P-256');
-        const data = 'Hello World';
-        const algorithm = { name: 'ECDSA', hash: 'SHA-256' };
-        const signatureResult = sign(algorithm, keyPair.privateKey, data);
-        const signature = await signatureResult.toBuffer();
-        const isValid = await verify(algorithm, keyPair.publicKey, signature, data);
-        expect(isValid).toBe(true);
-    });
-    test('import ECDSA public key (SPKI)', async () => {
-        const keyPair = await generateEcdsaKey('P-256', true);
-        const spki = await globalThis.crypto.subtle.exportKey('spki', keyPair.publicKey);
-        const importedKey = await importEcdsaKey('spki', 'P-256', spki);
-        expect(importedKey.type).toBe('public');
-        expect(importedKey.algorithm.name).toBe('ECDSA');
-    });
-    test('import ECDSA public key (JWK)', async () => {
-        const keyPair = await generateEcdsaKey('P-256', true);
-        const jwk = await globalThis.crypto.subtle.exportKey('jwk', keyPair.publicKey);
-        const importedKey = await importEcdsaKey('jwk', 'P-256', jwk);
-        expect(importedKey.type).toBe('public');
-        expect(importedKey.algorithm.name).toBe('ECDSA');
-    });
-    test('import HKDF key', async () => {
-        const baseKeyMaterial = encodeUtf8('base-secret');
-        const baseKey = await importHkdfKey('raw', baseKeyMaterial);
-        expect(baseKey.algorithm.name).toBe('HKDF');
-        // Test import with string
-        const keyFromString = await importHkdfKey('raw', encodeUtf8('base-secret'));
-        expect(keyFromString.algorithm.name).toBe('HKDF');
-    });
-    test('PBKDF2 derivation', async () => {
-        const baseKey = await generatePbkdf2Key();
-        const salt = globalThis.crypto.getRandomValues(new Uint8Array(16));
-        const algorithm = {
-            name: 'PBKDF2',
-            salt,
-            iterations: 1000,
-            hash: 'SHA-256',
-        };
-        const derivedBytes = await deriveBytes(algorithm, baseKey, 32);
-        expect(derivedBytes.byteLength).toBe(32);
-        const importedKey = await importPbkdf2Key('raw-secret', encodeUtf8('password'));
-        const derivedBytes2 = await deriveBytes(algorithm, importedKey, 32);
-        expect(derivedBytes2.byteLength).toBe(32);
-        // Test import with string
-        const keyFromString = await importPbkdf2Key('raw-secret', encodeUtf8('password'));
-        expect(keyFromString.algorithm.name).toBe('PBKDF2');
-    });
-    test('CryptionResult helper methods', async () => {
-        const data = 'Hello World';
-        const result = digest('SHA-256', data);
-        expect(await result.toBuffer()).toBeInstanceOf(ArrayBuffer);
-        expect(await result.toHex()).toBeTypeOf('string');
-        expect(await result.toBase64()).toBeTypeOf('string');
-        expect(await result.toBase64Url()).toBeTypeOf('string');
-        expect(await result.toZBase32()).toBeTypeOf('string');
-        const key = await generateHmacKey('SHA-256');
-        const signResult = sign({ name: 'HMAC', hash: 'SHA-256' }, key, data);
-        expect(await signResult.toHex()).toBeTypeOf('string');
-        expect(await signResult.toBase64()).toBeTypeOf('string');
-        expect(await signResult.toBase64Url()).toBeTypeOf('string');
-        expect(await signResult.toZBase32()).toBeTypeOf('string');
-        const symKey = await generateSymmetricKey({ name: 'AES-GCM', length: 256 });
-        const iv = globalThis.crypto.getRandomValues(new Uint8Array(12));
-        const encResult = encrypt({ name: 'AES-GCM', iv }, symKey, data);
-        const encrypted = await encResult.toBuffer();
-        expect(await encResult.toHex()).toBeTypeOf('string');
-        const decResult = decrypt({ name: 'AES-GCM', iv }, symKey, encrypted);
-        expect(await decResult.toHex()).toBeTypeOf('string');
-        expect(await decResult.toBase64()).toBeTypeOf('string');
-        expect(await decResult.toBase64Url()).toBeTypeOf('string');
-        expect(await decResult.toZBase32()).toBeTypeOf('string');
-        expect(await decResult.toUtf8()).toBe(data);
-    });
-});

package/cryptography/tests/jwt.test.d.ts

@@ -1 +0,0 @@
-export {};

package/cryptography/tests/jwt.test.js

@@ -1,54 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import { InvalidTokenError } from '../../errors/invalid-token.error.js';
-import { generateKmacKey, generateSymmetricKey } from '../cryptography.js';
-import { createJwtTokenString, parseAndValidateJwtTokenString, parseJwtTokenString } from '../jwt.js';
-describe('JWT Utilities', () => {
-    test('create, parse and validate JWT', async () => {
-        const key = await generateKmacKey('KMAC256');
-        const token = {
-            header: { alg: 'KMAC256', typ: 'JWT' },
-            payload: { sub: '1234567890', name: 'John Doe', iat: 1516239022 },
-        };
-        const tokenString = await createJwtTokenString(token, key);
-        expect(tokenString).toBeTypeOf('string');
-        expect(tokenString.split('.').length).toBe(3);
-        const parsed = parseJwtTokenString(tokenString);
-        expect(parsed.token.payload).toEqual(token.payload);
-        const validated = await parseAndValidateJwtTokenString(tokenString, 'KMAC256', key);
-        expect(validated.payload).toEqual(token.payload);
-    });
-    test('fail on invalid signature', async () => {
-        const key = await generateKmacKey('KMAC256');
-        const otherKey = await generateKmacKey('KMAC256');
-        const token = {
-            header: { alg: 'KMAC256', typ: 'JWT' },
-            payload: { sub: '1234567890' },
-        };
-        const tokenString = await createJwtTokenString(token, key);
-        await expect(parseAndValidateJwtTokenString(tokenString, 'KMAC256', otherKey)).rejects.toThrow(InvalidTokenError);
-    });
-    test('fail on disallowed algorithm', async () => {
-        const key = await generateKmacKey('KMAC256');
-        const token = {
-            header: { alg: 'KMAC256', typ: 'JWT' },
-            payload: { sub: '1234567890' },
-        };
-        const tokenString = await createJwtTokenString(token, key);
-        await expect(parseAndValidateJwtTokenString(tokenString, 'KMAC128', key)).rejects.toThrow(InvalidTokenError);
-    });
-    test('fail on malformed token', () => {
-        expect(() => parseJwtTokenString('a.b')).toThrow('Invalid token format');
-        expect(() => parseJwtTokenString('')).toThrow('Missing authorization token');
-    });
-    test('fail on generic error in parseAndValidateJwtTokenString', async () => {
-        const key = await generateKmacKey('KMAC256');
-        const token = {
-            header: { alg: 'KMAC256', typ: 'JWT' },
-            payload: { sub: '1234567890' },
-        };
-        const tokenString = await createJwtTokenString(token, key);
-        // Use an incompatible key type to trigger a generic error in Web Crypto
-        const aesKey = await generateSymmetricKey({ name: 'AES-GCM', length: 256 });
-        await expect(parseAndValidateJwtTokenString(tokenString, 'KMAC256', aesKey)).rejects.toThrow('Invalid token');
-    });
-});

package/cryptography/tests/modern.test.d.ts

@@ -1 +0,0 @@
-export {};

package/cryptography/tests/modern.test.js

@@ -1,105 +0,0 @@
-import { encodeUtf8 } from '../../utils/encoding.js';
-import { describe, expect, test } from 'vitest';
-import { decrypt, deriveBytes, encrypt, generateAsymmetricKey, generateSymmetricKey, getPublicKey, importKey, importSymmetricKey, sign, supports, verify } from '../cryptography.js';
-describe('Modern Cryptography Features', () => {
-    test('SubtleCrypto.supports', async () => {
-        expect(await supports('generateKey', { name: 'AES-GCM', length: 256 })).toBe(true);
-        expect(await supports('sign', { name: 'HMAC', hash: 'SHA-256' })).toBe(true);
-    });
-    test('KMAC128 signing and verification', async () => {
-        const isSupported = await supports('generateKey', { name: 'KMAC128' });
-        if (!isSupported) {
-            throw new Error('KMAC128 not supported in this environment');
-        }
-        const key = await importSymmetricKey('raw-secret', { name: 'KMAC128' }, encodeUtf8('my-secret-key-128bits'));
-        const data = 'Hello KMAC';
-        const algorithm = { name: 'KMAC128', length: 128, outputLength: 32 };
-        const signatureResult = sign(algorithm, key, data);
-        const signature = await signatureResult.toBuffer();
-        expect(await verify(algorithm, key, signature, data)).toBe(true);
-    });
-    test('KMAC256 signing and verification', async () => {
-        const isSupported = await supports('generateKey', { name: 'KMAC256' });
-        console.log('KMAC256 supported:', isSupported);
-        if (!isSupported) {
-            return;
-        }
-        const key = await importSymmetricKey('raw-secret', { name: 'KMAC256' }, encodeUtf8('my-secret-key-256bits-long-enough-for-kmac256'));
-        const data = 'Hello KMAC256';
-        const algorithm = { name: 'KMAC256', length: 256, outputLength: 64 };
-        const signatureResult = sign(algorithm, key, data);
-        const signature = await signatureResult.toBuffer();
-        expect(await verify(algorithm, key, signature, data)).toBe(true);
-    });
-    test('Argon2id derivation', async () => {
-        const isSupported = await supports('importKey', 'Argon2id');
-        if (!isSupported) {
-            throw new Error('Argon2id not supported in this environment');
-        }
-        const password = 'my-password';
-        const salt = globalThis.crypto.getRandomValues(new Uint8Array(16));
-        const key = await importKey('raw-secret', encodeUtf8(password), { name: 'Argon2id' }, false, ['deriveBits']);
-        const argon2Params = {
-            name: 'Argon2id',
-            nonce: salt,
-            memory: 8,
-            parallelism: 1,
-            passes: 1,
-        };
-        const derivedBits = await deriveBytes(argon2Params, key, 32);
-        expect(derivedBits.byteLength).toBe(32);
-    });
-    test('ML-DSA-44 signing and verification', async () => {
-        const isSupported = await supports('generateKey', 'ML-DSA-44');
-        if (!isSupported) {
-            throw new Error('ML-DSA-44 not supported in this environment');
-        }
-        const keyPair = await generateAsymmetricKey({ name: 'ML-DSA-44', namedCurve: 'ML-DSA-44' }, true, ['sign', 'verify']);
-        const data = 'Hello ML-DSA';
-        const algorithm = { name: 'ML-DSA-44' };
-        const signatureResult = sign(algorithm, keyPair.privateKey, data);
-        const signature = await signatureResult.toBuffer();
-        expect(await verify(algorithm, keyPair.publicKey, signature, data)).toBe(true);
-    });
-    test('ChaCha20-Poly1305 encryption and decryption', async () => {
-        const isSupported = await supports('generateKey', { name: 'ChaCha20-Poly1305' });
-        if (!isSupported) {
-            throw new Error('ChaCha20-Poly1305 not supported in this environment');
-        }
-        const key = await generateSymmetricKey({ name: 'ChaCha20-Poly1305', length: 256 });
-        const data = 'Hello ChaCha20';
-        const nonce = globalThis.crypto.getRandomValues(new Uint8Array(12));
-        const algorithm = { name: 'ChaCha20-Poly1305', iv: nonce };
-        const encryptionResult = encrypt(algorithm, key, data);
-        const encryptedBuffer = await encryptionResult.toBuffer();
-        const decryptionResult = decrypt(algorithm, key, encryptedBuffer);
-        const decryptedText = await decryptionResult.toUtf8();
-        expect(decryptedText).toBe(data);
-    });
-    test('AES-OCB encryption and decryption', async () => {
-        const isSupported = await supports('generateKey', { name: 'AES-OCB', length: 256 });
-        if (!isSupported) {
-            throw new Error('AES-OCB not supported in this environment');
-        }
-        const key = await generateSymmetricKey({ name: 'AES-OCB', length: 256 });
-        const data = 'Hello AES-OCB';
-        const iv = globalThis.crypto.getRandomValues(new Uint8Array(12));
-        const algorithm = { name: 'AES-OCB', iv };
-        const encryptionResult = encrypt(algorithm, key, data);
-        const encryptedBuffer = await encryptionResult.toBuffer();
-        const decryptionResult = decrypt(algorithm, key, encryptedBuffer);
-        const decryptedText = await decryptionResult.toUtf8();
-        expect(decryptedText).toBe(data);
-    });
-    test('getPublicKey from private key', async () => {
-        const isSupported = await supports('getPublicKey', 'Ed25519'); // getPublicKey support is often generic but checking Ed25519
-        if (!isSupported) {
-            // Fallback check if getPublicKey is supported but supports doesn't report it well for Ed25519
-            throw new Error('getPublicKey not supported in this environment');
-        }
-        const keyPair = await generateAsymmetricKey({ name: 'Ed25519', namedCurve: 'Ed25519' }, true, ['sign', 'verify']);
-        const publicKey = await getPublicKey(keyPair.privateKey, ['verify']);
-        expect(publicKey.type).toBe('public');
-        expect(publicKey.algorithm.name).toBe('Ed25519');
-    });
-});

package/cryptography/tests/module.test.d.ts

@@ -1 +0,0 @@
-export {};

package/cryptography/tests/module.test.js

@@ -1,100 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import { runInInjectionContext } from '../../injector/inject.js';
-import { Injector } from '../../injector/injector.js';
-import { importKey } from '../cryptography.js';
-import { configureSecrets, injectDerivedBytes, injectDerivedCryptoKey, masterSecretAlgorithm, masterSecretKeyUsages } from '../module.js';
-describe('Secrets Module', () => {
-    test('configure and derive bytes', async () => {
-        const injector = new Injector('test');
-        const key = 'my-super-secret-key';
-        configureSecrets({ injector, key });
-        await runInInjectionContext(injector, async () => {
-            const derived = injectDerivedBytes('test-info', 32);
-            const sameDerived = injectDerivedBytes('test-info', 32);
-            const differentDerived = injectDerivedBytes('other-info', 32);
-            const bytes = await derived.getBytes();
-            expect(bytes.byteLength).toBe(32);
-            const sameBytes = await sameDerived.getBytes();
-            expect(new Uint8Array(bytes)).toEqual(new Uint8Array(sameBytes));
-            const differentBytes = await differentDerived.getBytes();
-            expect(new Uint8Array(bytes)).not.toEqual(new Uint8Array(differentBytes));
-        });
-    });
-    test('derive crypto key', async () => {
-        const injector = new Injector('test');
-        const key = 'my-super-secret-key';
-        configureSecrets({ injector, key });
-        await runInInjectionContext(injector, async () => {
-            const derived = injectDerivedCryptoKey('test-info', { name: 'HMAC', hash: 'SHA-256' }, ['sign']);
-            const cryptoKey = await derived.getKey();
-            expect(cryptoKey.type).toBe('secret');
-            expect(cryptoKey.algorithm.name).toBe('HMAC');
-            expect(cryptoKey.usages).toContain('sign');
-        });
-    });
-    test('fail when not configured', async () => {
-        const injector = new Injector('test');
-        await runInInjectionContext(injector, async () => {
-            // getBaseKeyFromInjector should throw if not configured
-            expect(() => injectDerivedBytes('test-info', 32)).toThrow('No secret key configured');
-        });
-    });
-    test('fail when requesting bytes from key-configured derived key', async () => {
-        const injector = new Injector('test');
-        configureSecrets({ injector, key: 'secret' });
-        await runInInjectionContext(injector, async () => {
-            const derived = injectDerivedCryptoKey('info', { name: 'HMAC', hash: 'SHA-256' }, ['sign']);
-            await expect(derived.getBytes()).rejects.toThrow('This key was not configured to derive bytes');
-        });
-    });
-    test('fail when requesting key from byte-configured derived key', async () => {
-        const injector = new Injector('test');
-        configureSecrets({ injector, key: 'secret' });
-        await runInInjectionContext(injector, async () => {
-            const derived = injectDerivedBytes('info', 32);
-            await expect(derived.getKey()).rejects.toThrow('This key was not configured to derive a CryptoKey');
-        });
-    });
-    test('hierarchical injector configuration', async () => {
-        const parentInjector = new Injector('parent');
-        const childInjector = parentInjector.fork('child');
-        const key = 'parent-key';
-        configureSecrets({ injector: parentInjector, key });
-        await runInInjectionContext(childInjector, async () => {
-            const derived = injectDerivedBytes('info', 32);
-            const bytes = await derived.getBytes();
-            expect(bytes.byteLength).toBe(32);
-        });
-    });
-    test('global injector configuration', async () => {
-        const key = 'global-key';
-        configureSecrets({ key }); // Registers on global Injector
-        const injector = new Injector('test');
-        await runInInjectionContext(injector, async () => {
-            const derived = injectDerivedBytes('info', 32);
-            const bytes = await derived.getBytes();
-            expect(bytes.byteLength).toBe(32);
-        });
-    });
-    test('configureSecrets with BufferSource', async () => {
-        const injector = new Injector('test');
-        const key = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6]);
-        configureSecrets({ injector, key });
-        await runInInjectionContext(injector, async () => {
-            const derived = injectDerivedBytes(new Uint8Array([1, 2, 3]), 32, { salt: new Uint8Array([4, 5, 6]) });
-            const bytes = await derived.getBytes();
-            expect(bytes.byteLength).toBe(32);
-        });
-    });
-    test('configureSecrets with CryptoKey', async () => {
-        const injector = new Injector('test');
-        const keyMaterial = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6]);
-        const cryptoKey = await importKey('raw-secret', keyMaterial, masterSecretAlgorithm, false, masterSecretKeyUsages);
-        configureSecrets({ injector, key: cryptoKey });
-        await runInInjectionContext(injector, async () => {
-            const derived = injectDerivedBytes('', 32, { salt: 'my-salt' });
-            const bytes = await derived.getBytes();
-            expect(bytes.byteLength).toBe(32);
-        });
-    });
-});

package/cryptography/tests/totp.test.d.ts

@@ -1 +0,0 @@
-export {};