@tstdl/base 0.93.181 → 0.93.183

package/authentication/tests/totp.login.test.js

@@ -1,213 +0,0 @@
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from 'vitest';
-import { ActorType, Auditor } from '../../audit/index.js';
-import { importKey } from '../../cryptography/index.js';
-import { generateTotpToken } from '../../cryptography/totp.js';
-import { clearTenantData, setupIntegrationTest } from '../../testing/index.js';
-import { currentTimestampSeconds } from '../../utils/date-time.js';
-import { AuthenticationService } from '../server/authentication.service.js';
-import { SubjectService } from '../server/subject.service.js';
-import { DefaultAuthenticationAncillaryService } from './authentication.test-ancillary-service.js';
-describe('TOTP Login', () => {
-    let injector;
-    let database;
-    let authenticationService;
-    let subjectService;
-    let auditor;
-    const schema = 'authentication';
-    const tenantId = crypto.randomUUID();
-    const password = crypto.randomUUID();
-    beforeAll(async () => {
-        ({ injector, database } = await setupIntegrationTest({
-            modules: { authentication: true },
-            authentication: {
-                ancillaryService: DefaultAuthenticationAncillaryService,
-            },
-        }));
-        authenticationService = await injector.resolveAsync(AuthenticationService);
-        subjectService = await injector.resolveAsync(SubjectService);
-        auditor = injector.resolve(Auditor);
-    });
-    afterAll(async () => {
-        await injector?.dispose();
-    });
-    beforeEach(async () => {
-        await clearTenantData(database, schema, ['used_totp_tokens', 'totp_recovery_code', 'totp', 'password', 'session', 'user', 'service_account', 'system_account', 'subject'], tenantId);
-    });
-    test('loginVerifyTotp should fail if the same token is used twice (replay attack)', async () => {
-        const user = await subjectService.createUser({
-            tenantId,
-            email: 'replay-totp@example.com',
-            firstName: 'Replay',
-            lastName: 'Totp',
-        });
-        await authenticationService.setPassword(user, password);
-        const userAuditor = auditor.with({ actor: user.id, actorType: ActorType.Subject });
-        await authenticationService.initEnrollTotp(tenantId, user.id, userAuditor);
-        const totpEntry = await authenticationService.tryGetTotp(tenantId, user.id);
-        const secretKey = await importKey('raw-secret', totpEntry.secret, { name: 'HMAC', hash: authenticationService.getTotpOptions().codeHashAlgorithm }, false, ['sign']);
-        const enrollmentToken = await generateTotpToken(secretKey, { ...authenticationService.getTotpOptions(), timestamp: currentTimestampSeconds() - 30 });
-        await authenticationService.completeEnrollTotp(tenantId, user.id, enrollmentToken, userAuditor);
-        const loginResult1 = await authenticationService.login({ tenantId, subject: user.id }, password, undefined, auditor);
-        const loginResult2 = await authenticationService.login({ tenantId, subject: user.id }, password, undefined, auditor);
-        const challengeToken1 = loginResult1.challengeToken;
-        const challengeToken2 = loginResult2.challengeToken;
-        const totpToken = await generateTotpToken(secretKey, authenticationService.getTotpOptions());
-        // First use: success
-        const verifyResult1 = await authenticationService.loginVerifyTotp(challengeToken1, totpToken, auditor);
-        expect(verifyResult1.type).toBe('success');
-        // Second use (replay): fail
-        await expect(authenticationService.loginVerifyTotp(challengeToken2, totpToken, auditor)).rejects.toThrow();
-    });
-    test('login should return success if TOTP is not enabled', async () => {
-        const user = await subjectService.createUser({
-            tenantId,
-            email: 'no-totp@example.com',
-            firstName: 'No',
-            lastName: 'Totp',
-        });
-        await authenticationService.setPassword(user, password);
-        const result = await authenticationService.login({ tenantId, subject: user.id }, password, undefined, auditor);
-        expect(result.type).toBe('success');
-    });
-    test('login should return totp challenge if TOTP is enabled', async () => {
-        const user = await subjectService.createUser({
-            tenantId,
-            email: 'with-totp@example.com',
-            firstName: 'With',
-            lastName: 'Totp',
-        });
-        await authenticationService.setPassword(user, password);
-        const userAuditor = auditor.with({ actor: user.id, actorType: ActorType.Subject });
-        await authenticationService.initEnrollTotp(tenantId, user.id, userAuditor);
-        const totpEntry = await authenticationService.tryGetTotp(tenantId, user.id);
-        const secretKey = await importKey('raw-secret', totpEntry.secret, { name: 'HMAC', hash: authenticationService.getTotpOptions().codeHashAlgorithm }, false, ['sign']);
-        const token = await generateTotpToken(secretKey, { ...authenticationService.getTotpOptions(), timestamp: currentTimestampSeconds() - 30 });
-        await authenticationService.completeEnrollTotp(tenantId, user.id, token, userAuditor);
-        const result = await authenticationService.login({ tenantId, subject: user.id }, password, undefined, auditor);
-        expect(result.type).toBe('totp');
-        if (result.type !== 'totp') {
-            throw new Error('Expected TOTP result');
-        }
-        expect(result.challengeToken).toBeDefined();
-    });
-    test('loginVerifyTotp should return success with valid token', async () => {
-        const user = await subjectService.createUser({
-            tenantId,
-            email: 'verify-totp@example.com',
-            firstName: 'Verify',
-            lastName: 'Totp',
-        });
-        await authenticationService.setPassword(user, password);
-        const userAuditor = auditor.with({ actor: user.id, actorType: ActorType.Subject });
-        await authenticationService.initEnrollTotp(tenantId, user.id, userAuditor);
-        const totpEntry = await authenticationService.tryGetTotp(tenantId, user.id);
-        const secretKey = await importKey('raw-secret', totpEntry.secret, { name: 'HMAC', hash: authenticationService.getTotpOptions().codeHashAlgorithm }, false, ['sign']);
-        const enrollmentToken = await generateTotpToken(secretKey, { ...authenticationService.getTotpOptions(), timestamp: currentTimestampSeconds() - 30 });
-        await authenticationService.completeEnrollTotp(tenantId, user.id, enrollmentToken, userAuditor);
-        const loginResult = await authenticationService.login({ tenantId, subject: user.id }, password, undefined, auditor, true);
-        expect(loginResult.type).toBe('totp');
-        if (loginResult.type !== 'totp') {
-            throw new Error('Expected TOTP result');
-        }
-        const challengeToken = loginResult.challengeToken;
-        const totpToken = await generateTotpToken(secretKey, authenticationService.getTotpOptions());
-        const verifyResult = await authenticationService.loginVerifyTotp(challengeToken, totpToken, auditor);
-        expect(verifyResult.type).toBe('success');
-        expect(verifyResult.result.remember).toBe(true);
-    });
-    test('loginVerifyTotp should fail with recovery code (decoupled)', async () => {
-        const user = await subjectService.createUser({
-            tenantId,
-            email: 'verify-recovery-fail@example.com',
-            firstName: 'Verify',
-            lastName: 'RecoveryFail',
-        });
-        await authenticationService.setPassword(user, password);
-        const userAuditor = auditor.with({ actor: user.id, actorType: ActorType.Subject });
-        await authenticationService.initEnrollTotp(tenantId, user.id, userAuditor);
-        const totpEntry = await authenticationService.tryGetTotp(tenantId, user.id);
-        const secretKey = await importKey('raw-secret', totpEntry.secret, { name: 'HMAC', hash: authenticationService.getTotpOptions().codeHashAlgorithm }, false, ['sign']);
-        const enrollmentToken = await generateTotpToken(secretKey, { ...authenticationService.getTotpOptions(), timestamp: currentTimestampSeconds() - 30 });
-        const { recoveryCodes } = await authenticationService.completeEnrollTotp(tenantId, user.id, enrollmentToken, userAuditor);
-        const loginResult = await authenticationService.login({ tenantId, subject: user.id }, password, undefined, auditor);
-        expect(loginResult.type).toBe('totp');
-        if (loginResult.type !== 'totp') {
-            throw new Error('Expected TOTP result');
-        }
-        const challengeToken = loginResult.challengeToken;
-        await expect(authenticationService.loginVerifyTotp(challengeToken, recoveryCodes[0], auditor)).rejects.toThrow();
-    });
-    test('loginRecovery should return success with valid recovery code', async () => {
-        const user = await subjectService.createUser({
-            tenantId,
-            email: 'verify-recovery-success@example.com',
-            firstName: 'Verify',
-            lastName: 'RecoverySuccess',
-        });
-        await authenticationService.setPassword(user, password);
-        const userAuditor = auditor.with({ actor: user.id, actorType: ActorType.Subject });
-        await authenticationService.initEnrollTotp(tenantId, user.id, userAuditor);
-        const totpEntry = await authenticationService.tryGetTotp(tenantId, user.id);
-        const secretKey = await importKey('raw-secret', totpEntry.secret, { name: 'HMAC', hash: authenticationService.getTotpOptions().codeHashAlgorithm }, false, ['sign']);
-        const enrollmentToken = await generateTotpToken(secretKey, { ...authenticationService.getTotpOptions(), timestamp: currentTimestampSeconds() - 30 });
-        const { recoveryCodes } = await authenticationService.completeEnrollTotp(tenantId, user.id, enrollmentToken, userAuditor);
-        const loginResult = await authenticationService.login({ tenantId, subject: user.id }, password, undefined, auditor);
-        expect(loginResult.type).toBe('totp');
-        if (loginResult.type !== 'totp') {
-            throw new Error('Expected TOTP result');
-        }
-        const challengeToken = loginResult.challengeToken;
-        const verifyResult = await authenticationService.loginRecovery(challengeToken, recoveryCodes[0], auditor);
-        expect(verifyResult.type).toBe('success');
-        expect(verifyResult.lowRecoveryCodesWarning).toBe(false);
-    });
-    test('loginRecovery should return success and lowRecoveryCodesWarning when few codes remain', async () => {
-        const user = await subjectService.createUser({
-            tenantId,
-            email: 'verify-recovery-warning@example.com',
-            firstName: 'Verify',
-            lastName: 'RecoveryWarning',
-        });
-        await authenticationService.setPassword(user, password);
-        const userAuditor = auditor.with({ actor: user.id, actorType: ActorType.Subject });
-        await authenticationService.initEnrollTotp(tenantId, user.id, userAuditor);
-        const totpEntry = await authenticationService.tryGetTotp(tenantId, user.id);
-        const secretKey = await importKey('raw-secret', totpEntry.secret, { name: 'HMAC', hash: authenticationService.getTotpOptions().codeHashAlgorithm }, false, ['sign']);
-        const enrollmentToken = await generateTotpToken(secretKey, { ...authenticationService.getTotpOptions(), timestamp: currentTimestampSeconds() - 30 });
-        const { recoveryCodes } = await authenticationService.completeEnrollTotp(tenantId, user.id, enrollmentToken, userAuditor);
-        // Use 7 codes to leave 3 unused (assuming 10 total)
-        for (let i = 0; i < 7; i++) {
-            const loginResult = await authenticationService.login({ tenantId, subject: user.id }, password, undefined, auditor);
-            const challengeToken = loginResult.challengeToken;
-            await authenticationService.loginRecovery(challengeToken, recoveryCodes[i], auditor);
-        }
-        // Next use should trigger warning
-        const loginResult = await authenticationService.login({ tenantId, subject: user.id }, password, undefined, auditor);
-        const challengeToken = loginResult.challengeToken;
-        const verifyResult = await authenticationService.loginRecovery(challengeToken, recoveryCodes[7], auditor);
-        expect(verifyResult.type).toBe('success');
-        expect(verifyResult.lowRecoveryCodesWarning).toBe(true);
-    });
-    test('loginVerifyTotp should fail with invalid token', async () => {
-        const user = await subjectService.createUser({
-            tenantId,
-            email: 'verify-fail@example.com',
-            firstName: 'Verify',
-            lastName: 'Fail',
-        });
-        await authenticationService.setPassword(user, password);
-        const userAuditor = auditor.with({ actor: user.id, actorType: ActorType.Subject });
-        await authenticationService.initEnrollTotp(tenantId, user.id, userAuditor);
-        const totpEntry = await authenticationService.tryGetTotp(tenantId, user.id);
-        const secretKey = await importKey('raw-secret', totpEntry.secret, { name: 'HMAC', hash: authenticationService.getTotpOptions().codeHashAlgorithm }, false, ['sign']);
-        const enrollmentToken = await generateTotpToken(secretKey, { ...authenticationService.getTotpOptions(), timestamp: currentTimestampSeconds() - 30 });
-        await authenticationService.completeEnrollTotp(tenantId, user.id, enrollmentToken, userAuditor);
-        const loginResult = await authenticationService.login({ tenantId, subject: user.id }, password, undefined, auditor);
-        expect(loginResult.type).toBe('totp');
-        if (loginResult.type !== 'totp') {
-            throw new Error('Expected TOTP result');
-        }
-        const challengeToken = loginResult.challengeToken;
-        await expect(authenticationService.loginVerifyTotp(challengeToken, '000000', auditor)).rejects.toThrow();
-    });
-});

package/authentication/tests/totp.recovery-codes.test.d.ts

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

package/authentication/tests/totp.recovery-codes.test.js

@@ -1,97 +0,0 @@
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from 'vitest';
-import { ActorType, Auditor } from '../../audit/index.js';
-import { importKey } from '../../cryptography/index.js';
-import { generateTotpToken } from '../../cryptography/totp.js';
-import { clearTenantData, setupIntegrationTest } from '../../testing/index.js';
-import { currentTimestampSeconds } from '../../utils/date-time.js';
-import { AuthenticationService } from '../server/authentication.service.js';
-import { SubjectService } from '../server/subject.service.js';
-import { DefaultAuthenticationAncillaryService } from './authentication.test-ancillary-service.js';
-describe('TOTP Recovery Codes Regeneration', () => {
-    let injector;
-    let database;
-    let authenticationService;
-    let subjectService;
-    let auditor;
-    const schema = 'authentication';
-    const tenantId = crypto.randomUUID();
-    beforeAll(async () => {
-        ({ injector, database } = await setupIntegrationTest({
-            modules: { authentication: true },
-            authentication: {
-                ancillaryService: DefaultAuthenticationAncillaryService,
-            },
-        }));
-        authenticationService = await injector.resolveAsync(AuthenticationService);
-        subjectService = await injector.resolveAsync(SubjectService);
-        auditor = injector.resolve(Auditor);
-    });
-    afterAll(async () => {
-        await injector?.dispose();
-    });
-    beforeEach(async () => {
-        await clearTenantData(database, schema, ['used_totp_tokens', 'totp_recovery_code', 'totp', 'password', 'session', 'user', 'service_account', 'system_account', 'subject'], tenantId);
-    });
-    test('regenerateRecoveryCodes should replace existing codes after valid TOTP verification', async () => {
-        const user = await subjectService.createUser({
-            tenantId,
-            email: 'regen-totp@example.com',
-            firstName: 'Regen',
-            lastName: 'Totp',
-        });
-        const userAuditor = auditor.with({ actor: user.id, actorType: ActorType.Subject });
-        await authenticationService.initEnrollTotp(tenantId, user.id, userAuditor);
-        const totpEntry = (await authenticationService.tryGetTotp(tenantId, user.id));
-        const secretKey = await importKey('raw-secret', totpEntry.secret, { name: 'HMAC', hash: authenticationService.getTotpOptions().codeHashAlgorithm }, false, ['sign']);
-        const token = await generateTotpToken(secretKey, authenticationService.getTotpOptions());
-        const { recoveryCodes: originalCodes } = await authenticationService.completeEnrollTotp(tenantId, user.id, token, userAuditor);
-        // Verify original codes work (using disableTotp for now as it uses recovery codes currently)
-        // Actually we just want to ensure regeneration works.
-        const regenToken = await generateTotpToken(secretKey, { ...authenticationService.getTotpOptions(), timestamp: currentTimestampSeconds() + 30 });
-        const { recoveryCodes: newCodes } = await authenticationService.regenerateRecoveryCodes(tenantId, user.id, regenToken, userAuditor);
-        expect(newCodes).toHaveLength(10);
-        expect(newCodes).not.toEqual(originalCodes);
-        // Verify old code fails (should fail standard TOTP verification fallback later, but for now let's just check they are replaced)
-        // We can't easily check database content directly here without more boilerplate, but the logic should handle it.
-    });
-    test('regenerateRecoveryCodes should fail with invalid TOTP token', async () => {
-        const user = await subjectService.createUser({
-            tenantId,
-            email: 'regen-fail@example.com',
-            firstName: 'Regen',
-            lastName: 'Fail',
-        });
-        const userAuditor = auditor.with({ actor: user.id, actorType: ActorType.Subject });
-        await authenticationService.initEnrollTotp(tenantId, user.id, userAuditor);
-        const totpEntry = (await authenticationService.tryGetTotp(tenantId, user.id));
-        const secretKey = await importKey('raw-secret', totpEntry.secret, { name: 'HMAC', hash: authenticationService.getTotpOptions().codeHashAlgorithm }, false, ['sign']);
-        const token = await generateTotpToken(secretKey, authenticationService.getTotpOptions());
-        await authenticationService.completeEnrollTotp(tenantId, user.id, token, userAuditor);
-        await expect(authenticationService.regenerateRecoveryCodes(tenantId, user.id, '000000', userAuditor)).rejects.toThrow();
-    });
-    test('regenerateRecoveryCodes should optionally invalidate other sessions', async () => {
-        const user = await subjectService.createUser({
-            tenantId,
-            email: 'regen-invalidate@example.com',
-            firstName: 'Regen',
-            lastName: 'Invalidate',
-        });
-        const userAuditor = auditor.with({ actor: user.id, actorType: ActorType.Subject });
-        await authenticationService.initEnrollTotp(tenantId, user.id, userAuditor);
-        const totpEntry = (await authenticationService.tryGetTotp(tenantId, user.id));
-        const secretKey = await importKey('raw-secret', totpEntry.secret, { name: 'HMAC', hash: authenticationService.getTotpOptions().codeHashAlgorithm }, false, ['sign']);
-        const token = await generateTotpToken(secretKey, authenticationService.getTotpOptions());
-        await authenticationService.completeEnrollTotp(tenantId, user.id, token, userAuditor);
-        // Create some sessions
-        const session1 = await authenticationService.loginAlreadyValidatedSubject(user, undefined, userAuditor, false);
-        const session2 = await authenticationService.loginAlreadyValidatedSubject(user, undefined, userAuditor, false);
-        const regenToken = await generateTotpToken(secretKey, { ...authenticationService.getTotpOptions(), timestamp: currentTimestampSeconds() + 30 });
-        // We need to pass the current session id to NOT invalidate it if we were implementing it for "invalidateOtherSessions"
-        // But the spec says "invalidateOtherSessions", usually it means all except current.
-        // In this test context, we don't have a "current" session in the service call yet, unless we fork the auditor or similar.
-        // Let's see how AuthenticationService handles session invalidation.
-        await authenticationService.regenerateRecoveryCodes(tenantId, user.id, regenToken, userAuditor, { invalidateOtherSessions: true });
-        // Check sessions (should be invalidated)
-        // This part might need adjustment based on how invalidateAllOtherSessions is implemented in the service.
-    });
-});

package/authentication/tests/totp.status.test.d.ts

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

package/authentication/tests/totp.status.test.js

@@ -1,72 +0,0 @@
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from 'vitest';
-import { ActorType, Auditor } from '../../audit/index.js';
-import { importKey } from '../../cryptography/index.js';
-import { generateTotpToken } from '../../cryptography/totp.js';
-import { clearTenantData, setupIntegrationTest } from '../../testing/index.js';
-import { AuthenticationService } from '../server/authentication.service.js';
-import { SubjectService } from '../server/subject.service.js';
-import { DefaultAuthenticationAncillaryService } from './authentication.test-ancillary-service.js';
-describe('TOTP Status', () => {
-    let injector;
-    let database;
-    let authenticationService;
-    let subjectService;
-    let auditor;
-    const schema = 'authentication';
-    const tenantId = crypto.randomUUID();
-    beforeAll(async () => {
-        ({ injector, database } = await setupIntegrationTest({
-            modules: { authentication: true },
-            authentication: {
-                ancillaryService: DefaultAuthenticationAncillaryService,
-            },
-        }));
-        authenticationService = await injector.resolveAsync(AuthenticationService);
-        subjectService = await injector.resolveAsync(SubjectService);
-        auditor = injector.resolve(Auditor);
-    });
-    afterAll(async () => {
-        await injector?.dispose();
-    });
-    beforeEach(async () => {
-        await clearTenantData(database, schema, ['used_totp_tokens', 'totp_recovery_code', 'totp', 'password', 'session', 'user', 'service_account', 'system_account', 'subject'], tenantId);
-    });
-    test('getTotpStatus should return false when TOTP is not enrolled', async () => {
-        const user = await subjectService.createUser({
-            tenantId,
-            email: 'no-totp@example.com',
-            firstName: 'No',
-            lastName: 'Totp',
-        });
-        const status = await authenticationService.getTotpStatus(tenantId, user.id);
-        expect(status.active).toBe(false);
-    });
-    test('getTotpStatus should return false when TOTP enrollment is pending', async () => {
-        const user = await subjectService.createUser({
-            tenantId,
-            email: 'pending-totp@example.com',
-            firstName: 'Pending',
-            lastName: 'Totp',
-        });
-        const userAuditor = auditor.with({ actor: user.id, actorType: ActorType.Subject });
-        await authenticationService.initEnrollTotp(tenantId, user.id, userAuditor);
-        const status = await authenticationService.getTotpStatus(tenantId, user.id);
-        expect(status.active).toBe(false);
-    });
-    test('getTotpStatus should return true when TOTP is active', async () => {
-        const user = await subjectService.createUser({
-            tenantId,
-            email: 'active-totp@example.com',
-            firstName: 'Active',
-            lastName: 'Totp',
-        });
-        const userAuditor = auditor.with({ actor: user.id, actorType: ActorType.Subject });
-        await authenticationService.initEnrollTotp(tenantId, user.id, userAuditor);
-        const totpEntry = (await authenticationService.tryGetTotp(tenantId, user.id));
-        const secretKey = await importKey('raw-secret', totpEntry.secret, { name: 'HMAC', hash: authenticationService.getTotpOptions().codeHashAlgorithm }, false, ['sign']);
-        const token = await generateTotpToken(secretKey, authenticationService.getTotpOptions());
-        await authenticationService.completeEnrollTotp(tenantId, user.id, token, userAuditor);
-        const status = await authenticationService.getTotpStatus(tenantId, user.id);
-        expect(status.active).toBe(true);
-    });
-});

package/cancellation/tests/coverage.test.d.ts

@@ -1 +0,0 @@
-import '../../polyfills.js';

package/cancellation/tests/coverage.test.js

@@ -1,49 +0,0 @@
-import '../../polyfills.js';
-import { describe, expect, it, vi } from 'vitest';
-import * as core from '../../core.js';
-import { CancellationToken, sourcesToAbortSignal } from '../token.js';
-describe('Cancellation Coverage Extra', () => {
-    it('should hit dev mode branch (true)', () => {
-        vi.spyOn(core, 'isDevMode').mockReturnValue(true);
-        const token = new CancellationToken();
-        expect(token.isSet).toBe(false);
-    });
-    it('should hit dev mode branch (false)', () => {
-        vi.spyOn(core, 'isDevMode').mockReturnValue(false);
-        const token = new CancellationToken();
-        expect(token.isSet).toBe(false);
-    });
-    it('should hit throw: true branch in wait', async () => {
-        const token = new CancellationToken();
-        token.set('reason');
-        await expect(token.wait({ throw: true })).rejects.toThrow();
-    });
-    it('should hit waitThrow', async () => {
-        const token = new CancellationToken();
-        token.set('reason');
-        await expect(token.waitThrow()).rejects.toThrow();
-    });
-    it('should hit signals.length == 1 branch', () => {
-        const controller = new AbortController();
-        const signal = sourcesToAbortSignal(controller.signal);
-        expect(signal).toBe(controller.signal);
-    });
-    it('should hit signals.length > 1 branch', () => {
-        const controller1 = new AbortController();
-        const controller2 = new AbortController();
-        const signal = sourcesToAbortSignal([controller1.signal, controller2.signal]);
-        expect(signal).not.toBe(controller1.signal);
-        expect(signal).not.toBe(controller2.signal);
-    });
-    it('should hit sourcesToAbortSignal error branch', () => {
-        expect(() => sourcesToAbortSignal([])).toThrow('At least one cancellation source must be provided');
-    });
-    it('should hit unsubscribe branch in subscribe', () => {
-        const token = new CancellationToken();
-        const next = vi.fn();
-        const subscription = token.subscribe({ next });
-        subscription.unsubscribe();
-        token.set();
-        expect(next).not.toHaveBeenCalled();
-    });
-});

package/cancellation/tests/leak.test.d.ts

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

package/cancellation/tests/leak.test.js

@@ -1,35 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { CancellationSignal, CancellationToken } from '../token.js';
-describe('CancellationToken Memory Leak', () => {
-    it('should not leak when using inherit and disposing', () => {
-        const parent = new CancellationToken();
-        for (let i = 0; i < 1000; i++) {
-            const child = parent.inherit(new CancellationToken());
-            child.dispose();
-        }
-        expect(parent.isSet).toBe(false);
-    });
-    it('should follow parent signal', () => {
-        const parent = new CancellationToken();
-        const child = new CancellationToken(parent);
-        expect(child.isSet).toBe(false);
-        parent.set();
-        expect(child.isSet).toBe(true);
-    });
-    it('should not affect parent when child is set', () => {
-        const parent = new CancellationToken();
-        const child = new CancellationToken(parent);
-        expect(parent.isSet).toBe(false);
-        child.set();
-        expect(parent.isSet).toBe(false);
-        expect(child.isSet).toBe(true);
-    });
-    it('should clean up when disposed', () => {
-        const parent = new CancellationToken();
-        const signal = CancellationSignal.from(parent);
-        expect(signal.isSet).toBe(false);
-        signal.dispose();
-        expect(signal.isSet).toBe(true);
-        expect(parent.isSet).toBe(false);
-    });
-});

package/cancellation/tests/token.test.d.ts

@@ -1 +0,0 @@
-import '../../polyfills.js';

package/cancellation/tests/token.test.js

@@ -1,136 +0,0 @@
-import '../../polyfills.js';
-import { firstValueFrom, from } from 'rxjs';
-import { describe, expect, it, vi } from 'vitest';
-import { CancellationSignal, CancellationToken } from '../token.js';
-describe('CancellationToken', () => {
-    it('should be unset by default', () => {
-        const token = new CancellationToken();
-        expect(token.isSet).toBe(false);
-        expect(token.isUnset).toBe(true);
-    });
-    it('should be set when set() is called', () => {
-        const token = new CancellationToken();
-        token.set('reason');
-        expect(token.isSet).toBe(true);
-        expect(token.isUnset).toBe(false);
-        expect(token.reason).toBeInstanceOf(Error);
-        expect(token.reason.message).toBe('Operation cancelled');
-        expect(token.reason.cause).toBe('reason');
-    });
-    it('should fork a new token', () => {
-        const parent = new CancellationToken();
-        const child = parent.fork();
-        expect(child).toBeInstanceOf(CancellationToken);
-        expect(child.isSet).toBe(false);
-        parent.set();
-        expect(child.isSet).toBe(true);
-    });
-    it('should support multiple parents', () => {
-        const parent1 = new CancellationToken();
-        const parent2 = new CancellationToken();
-        const child = new CancellationToken([parent1, parent2]);
-        expect(child.isSet).toBe(false);
-        parent2.set();
-        expect(child.isSet).toBe(true);
-    });
-    it('should support single parent', () => {
-        const parent = new CancellationToken();
-        const child = new CancellationToken(parent);
-        expect(child.isSet).toBe(false);
-        parent.set();
-        expect(child.isSet).toBe(true);
-    });
-    it('should support AbortController as a source', () => {
-        const controller = new AbortController();
-        const signal = CancellationSignal.from(controller);
-        expect(signal.isSet).toBe(false);
-        controller.abort();
-        expect(signal.isSet).toBe(true);
-    });
-    it('should support AbortSignal as a source', () => {
-        const controller = new AbortController();
-        const signal = CancellationSignal.from(controller.signal);
-        expect(signal.isSet).toBe(false);
-        controller.abort();
-        expect(signal.isSet).toBe(true);
-    });
-    it('should wait for cancellation (resolve)', async () => {
-        const token = new CancellationToken();
-        setTimeout(() => token.set(), 10);
-        await token.wait();
-        expect(token.isSet).toBe(true);
-    });
-    it('should wait and throw (waitThrow)', async () => {
-        const token = new CancellationToken();
-        setTimeout(() => token.set('foo'), 10);
-        await expect(token.waitThrow()).rejects.toThrow('Operation cancelled');
-    });
-    it('should resolve immediately if already set', async () => {
-        const token = new CancellationToken();
-        token.set();
-        await token.wait();
-        expect(token.isSet).toBe(true);
-    });
-    it('should throw immediately if already set with waitThrow', async () => {
-        const token = new CancellationToken();
-        token.set();
-        await expect(token.waitThrow()).rejects.toThrow();
-    });
-    it('should throw immediately if already set', async () => {
-        const token = new CancellationToken();
-        token.set();
-        expect(() => token.throwIfSet()).toThrow();
-    });
-    it('should not throw if not set', () => {
-        const token = new CancellationToken();
-        expect(() => token.throwIfSet()).not.toThrow();
-    });
-    it('should support timeouts', async () => {
-        const token = new CancellationToken();
-        const timedSignal = token.withTimeout(10);
-        expect(timedSignal.isSet).toBe(false);
-        await timedSignal.wait();
-        expect(timedSignal.isSet).toBe(true);
-        expect(token.isSet).toBe(false);
-    });
-    it('should be observable', async () => {
-        const token = new CancellationToken();
-        const promise = firstValueFrom(from(token));
-        token.set();
-        await promise;
-    });
-    it('should support subscribe', () => {
-        const token = new CancellationToken();
-        const next = vi.fn();
-        const complete = vi.fn();
-        const subscription = token.subscribe({ next, complete });
-        token.set();
-        expect(next).toHaveBeenCalled();
-        expect(complete).toHaveBeenCalled();
-        subscription.unsubscribe();
-    });
-    it('should support Symbol.observable', () => {
-        const token = new CancellationToken();
-        const result = token[Symbol.observable]();
-        expect(result).toBe(token);
-    });
-    it('should return self as signal', () => {
-        const token = new CancellationToken();
-        expect(token.signal).toBe(token);
-    });
-    it('should handle subscribe when already set', () => {
-        const token = new CancellationToken();
-        token.set();
-        const next = vi.fn();
-        token.subscribe({ next });
-        expect(next).toHaveBeenCalled();
-    });
-    it('should support unsubscribe', () => {
-        const token = new CancellationToken();
-        const next = vi.fn();
-        const subscription = token.subscribe({ next });
-        subscription.unsubscribe();
-        token.set();
-        expect(next).not.toHaveBeenCalled();
-    });
-});

package/circuit-breaker/tests/circuit-breaker.test.d.ts

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