@harborclient/sdk 1.0.0 → 1.0.2

package/dist/http/substitute.test.js

@@ -1,93 +0,0 @@
-import { describe, expect, it } from '@jest/globals';
-import { resolveAuthVariables, substituteKeyValueRows, substituteVariables } from './substitute.js';
-describe('substituteVariables', () => {
-    it('replaces known placeholders', () => {
-        expect(substituteVariables('{{host}}/api', { host: 'https://example.com' })).toBe('https://example.com/api');
-    });
-    it('allows whitespace inside braces', () => {
-        expect(substituteVariables('{{ host }}/api', { host: 'https://example.com' })).toBe('https://example.com/api');
-    });
-    it('supports dotted and hyphenated keys', () => {
-        expect(substituteVariables('{{api.base}}-{{api-key}}', {
-            'api.base': 'https://example.com',
-            'api-key': 'secret'
-        })).toBe('https://example.com-secret');
-    });
-    it('replaces multiple placeholders in one string', () => {
-        expect(substituteVariables('{{scheme}}://{{host}}/{{path}}', {
-            scheme: 'https',
-            host: 'example.com',
-            path: 'users'
-        })).toBe('https://example.com/users');
-    });
-    it('leaves unknown placeholders unchanged', () => {
-        expect(substituteVariables('{{missing}}/api', { host: 'https://example.com' })).toBe('{{missing}}/api');
-    });
-    it('replaces with empty string when variable is defined as empty', () => {
-        expect(substituteVariables('prefix{{token}}suffix', { token: '' })).toBe('prefixsuffix');
-    });
-    it('returns text unchanged when there are no placeholders', () => {
-        expect(substituteVariables('plain text', { host: 'https://example.com' })).toBe('plain text');
-    });
-    it('resolves dynamic variables when not in the runtime map', () => {
-        const result = substituteVariables('prefix{{$timestamp}}suffix', {});
-        expect(result).not.toContain('{{');
-        expect(result).toMatch(/^prefix\d+suffix$/);
-    });
-    it('prefers runtime variables over dynamic variables', () => {
-        expect(substituteVariables('{{$timestamp}}', { $timestamp: 'fixed' })).toBe('fixed');
-    });
-});
-describe('resolveAuthVariables', () => {
-    const auth = {
-        type: 'basic',
-        basic: {
-            username: '{{user}}',
-            password: '{{pass}}'
-        },
-        bearer: {
-            token: '{{token}}'
-        }
-    };
-    it('substitutes basic and bearer credential fields', () => {
-        const substitute = (text) => text.replace('{{user}}', 'alice').replace('{{pass}}', 'secret').replace('{{token}}', 'tok');
-        expect(resolveAuthVariables(auth, substitute)).toEqual({
-            type: 'basic',
-            basic: {
-                username: 'alice',
-                password: 'secret'
-            },
-            bearer: {
-                token: 'tok'
-            }
-        });
-    });
-    it('preserves auth type and structure', () => {
-        const substitute = (text) => text;
-        const resolved = resolveAuthVariables(auth, substitute);
-        expect(resolved.type).toBe('basic');
-        expect(resolved.basic).toEqual(auth.basic);
-        expect(resolved.bearer).toEqual(auth.bearer);
-    });
-});
-describe('substituteKeyValueRows', () => {
-    it('substitutes values while preserving row metadata', () => {
-        const rows = [
-            { key: 'Accept', value: '{{accept}}', enabled: true },
-            { key: 'X-Api-Key', value: 'static', enabled: false }
-        ];
-        expect(substituteKeyValueRows(rows, { accept: 'application/json' })).toEqual([
-            { key: 'Accept', value: 'application/json', enabled: true },
-            { key: 'X-Api-Key', value: 'static', enabled: false }
-        ]);
-    });
-    it('leaves unknown placeholders in row values', () => {
-        const rows = [{ key: 'Host', value: '{{host}}', enabled: true }];
-        expect(substituteKeyValueRows(rows, {})).toEqual([
-            { key: 'Host', value: '{{host}}', enabled: true }
-        ]);
-    });
-    it('returns an empty array for no rows', () => {
-        expect(substituteKeyValueRows([], { host: 'example.com' })).toEqual([]);
-    });
-});

package/dist/pluginDatabaseApi.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=pluginDatabaseApi.test.d.ts.map

package/dist/pluginDatabaseApi.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pluginDatabaseApi.test.d.ts","sourceRoot":"","sources":["../src/pluginDatabaseApi.test.ts"],"names":[],"mappings":""}

package/dist/pluginDatabaseApi.test.js

@@ -1,65 +0,0 @@
-import { describe, expect, it, jest } from '@jest/globals';
-import { createPluginDatabaseApi } from './runtime/pluginDatabaseApi.js';
-/**
- * Builds a mock database backend for unit tests.
- */
-function createMockBackend() {
-    return {
-        query: jest.fn(async () => undefined),
-        exec: jest.fn(async () => undefined),
-        beginTransaction: jest.fn(async () => 'txn-1'),
-        endTransaction: jest.fn(async () => undefined)
-    };
-}
-describe('createPluginDatabaseApi', () => {
-    it('forwards get, all, and run with the correct query modes', async () => {
-        const backend = createMockBackend();
-        backend.query
-            .mockResolvedValueOnce({ id: 1 })
-            .mockResolvedValueOnce([{ id: 1 }, { id: 2 }])
-            .mockResolvedValueOnce({ changes: 1, lastInsertRowid: 42 });
-        const db = createPluginDatabaseApi(backend);
-        await expect(db.get('SELECT 1', [1])).resolves.toEqual({ id: 1 });
-        await expect(db.all('SELECT *', [2])).resolves.toEqual([{ id: 1 }, { id: 2 }]);
-        await expect(db.run('INSERT INTO t VALUES (?)', [3])).resolves.toEqual({
-            changes: 1,
-            lastInsertRowid: 42
-        });
-        expect(backend.query).toHaveBeenNthCalledWith(1, 'get', 'SELECT 1', [1], undefined);
-        expect(backend.query).toHaveBeenNthCalledWith(2, 'all', 'SELECT *', [2], undefined);
-        expect(backend.query).toHaveBeenNthCalledWith(3, 'run', 'INSERT INTO t VALUES (?)', [3], undefined);
-    });
-    it('forwards exec unchanged', async () => {
-        const backend = createMockBackend();
-        const db = createPluginDatabaseApi(backend);
-        await db.exec('CREATE TABLE t (id INTEGER)');
-        expect(backend.exec).toHaveBeenCalledWith('CREATE TABLE t (id INTEGER)');
-    });
-    it('commits successful transactions and passes txnId to tx helpers', async () => {
-        const backend = createMockBackend();
-        backend.query.mockResolvedValue({ changes: 1, lastInsertRowid: 1 });
-        const db = createPluginDatabaseApi(backend);
-        const result = await db.transaction(async (tx) => {
-            await tx.run('INSERT INTO t VALUES (?)', [1]);
-            await tx.all('SELECT * FROM t');
-            return 'done';
-        });
-        expect(result).toBe('done');
-        expect(backend.beginTransaction).toHaveBeenCalledTimes(1);
-        expect(backend.endTransaction).toHaveBeenCalledWith('txn-1', 'commit');
-        expect(backend.query).toHaveBeenCalledWith('run', 'INSERT INTO t VALUES (?)', [1], 'txn-1');
-        expect(backend.query).toHaveBeenCalledWith('all', 'SELECT * FROM t', undefined, 'txn-1');
-    });
-    it('rolls back failed transactions', async () => {
-        const backend = createMockBackend();
-        const db = createPluginDatabaseApi(backend);
-        const boom = new Error('boom');
-        await expect(db.transaction(async (tx) => {
-            await tx.run('INSERT INTO t VALUES (?)', [1]);
-            throw boom;
-        })).rejects.toThrow(boom);
-        expect(backend.beginTransaction).toHaveBeenCalledTimes(1);
-        expect(backend.endTransaction).toHaveBeenCalledWith('txn-1', 'rollback');
-        expect(backend.endTransaction).not.toHaveBeenCalledWith('txn-1', 'commit');
-    });
-});

package/dist/runtime/index.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=index.test.d.ts.map

package/dist/runtime/index.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../src/runtime/index.test.ts"],"names":[],"mappings":""}

package/dist/runtime/index.test.js

@@ -1,41 +0,0 @@
-import { describe, expect, it, jest } from '@jest/globals';
-import { defineTheme, registerTheme } from './index.js';
-/**
- * Builds a minimal plugin context mock for registerTheme tests.
- */
-function createMockPluginContext() {
-    const disposable = { dispose: jest.fn() };
-    const registerMock = jest.fn(() => disposable);
-    const subscriptions = [];
-    return {
-        subscriptions,
-        themes: { register: registerMock },
-        registerMock
-    };
-}
-describe('registerTheme', () => {
-    it('registers the theme, pushes the disposable onto subscriptions, and returns it', () => {
-        const hc = createMockPluginContext();
-        const theme = {
-            id: 'solarized',
-            title: 'Solarized Dark',
-            type: 'dark',
-            colors: { surface: '#002b36' }
-        };
-        const disposable = registerTheme(hc, theme);
-        expect(hc.registerMock).toHaveBeenCalledWith(theme);
-        expect(hc.subscriptions).toHaveLength(1);
-        expect(hc.subscriptions[0]).toBe(disposable);
-    });
-});
-describe('defineTheme', () => {
-    it('returns the theme argument unchanged', () => {
-        const theme = {
-            id: 'nord',
-            title: 'Nord',
-            type: 'dark',
-            stylesheet: 'dist/theme.css'
-        };
-        expect(defineTheme(theme)).toBe(theme);
-    });
-});

package/dist/runtime/index.test.ts

@@ -1,53 +0,0 @@
-import { describe, expect, it, jest } from '@jest/globals';
-import type { PluginContext, ThemeContribution } from '../types';
-import { defineTheme, registerTheme } from './index.js';
-
-/**
- * Builds a minimal plugin context mock for registerTheme tests.
- */
-function createMockPluginContext(): PluginContext & {
-  registerMock: jest.MockedFunction<PluginContext['themes']['register']>;
-} {
-  const disposable = { dispose: jest.fn() };
-  const registerMock = jest.fn(() => disposable);
-  const subscriptions: PluginContext['subscriptions'] = [];
-
-  return {
-    subscriptions,
-    themes: { register: registerMock },
-    registerMock
-  } as unknown as PluginContext & {
-    registerMock: jest.MockedFunction<PluginContext['themes']['register']>;
-  };
-}
-
-describe('registerTheme', () => {
-  it('registers the theme, pushes the disposable onto subscriptions, and returns it', () => {
-    const hc = createMockPluginContext();
-    const theme: ThemeContribution = {
-      id: 'solarized',
-      title: 'Solarized Dark',
-      type: 'dark',
-      colors: { surface: '#002b36' }
-    };
-
-    const disposable = registerTheme(hc, theme);
-
-    expect(hc.registerMock).toHaveBeenCalledWith(theme);
-    expect(hc.subscriptions).toHaveLength(1);
-    expect(hc.subscriptions[0]).toBe(disposable);
-  });
-});
-
-describe('defineTheme', () => {
-  it('returns the theme argument unchanged', () => {
-    const theme: ThemeContribution = {
-      id: 'nord',
-      title: 'Nord',
-      type: 'dark',
-      stylesheet: 'dist/theme.css'
-    };
-
-    expect(defineTheme(theme)).toBe(theme);
-  });
-});

package/dist/runtime-utils.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=runtime-utils.test.d.ts.map

package/dist/runtime-utils.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"runtime-utils.test.d.ts","sourceRoot":"","sources":["../src/runtime-utils.test.ts"],"names":[],"mappings":""}

package/dist/runtime-utils.test.js

@@ -1,177 +0,0 @@
-import { afterEach, describe, expect, it, jest } from '@jest/globals';
-import { byteLength, createLogger, randomId, truncateBody, truncateToBytes } from './runtime-utils.js';
-const originalTextEncoder = globalThis.TextEncoder;
-const originalCrypto = globalThis.crypto;
-afterEach(() => {
-    globalThis.TextEncoder = originalTextEncoder;
-    globalThis.crypto = originalCrypto;
-    jest.restoreAllMocks();
-});
-function withoutTextEncoder(run) {
-    // @ts-expect-error — exercise manual UTF-8 fallback used in SES main runtime
-    globalThis.TextEncoder = undefined;
-    return run();
-}
-describe('randomId', () => {
-    it('returns a UUID when crypto.randomUUID is available', () => {
-        const spy = jest
-            .spyOn(globalThis.crypto, 'randomUUID')
-            .mockReturnValue('00000000-0000-4000-8000-000000000000');
-        expect(randomId()).toBe('00000000-0000-4000-8000-000000000000');
-        spy.mockRestore();
-    });
-    it('falls back to a prefixed id when randomUUID is unavailable', () => {
-        // @ts-expect-error — exercise SES main-runtime fallback
-        globalThis.crypto = undefined;
-        expect(randomId('req')).toMatch(/^req-\d+-[a-z0-9]+$/);
-    });
-    it('uses the default prefix in the fallback path', () => {
-        // @ts-expect-error — exercise SES main-runtime fallback
-        globalThis.crypto = undefined;
-        expect(randomId()).toMatch(/^id-\d+-[a-z0-9]+$/);
-    });
-});
-describe('byteLength', () => {
-    it('counts ASCII as one byte per character', () => {
-        expect(byteLength('abc')).toBe(3);
-        expect(byteLength('')).toBe(0);
-    });
-    it('counts two-byte UTF-8 characters', () => {
-        expect(byteLength('é')).toBe(2);
-    });
-    it('counts three-byte UTF-8 characters', () => {
-        expect(byteLength('中')).toBe(3);
-    });
-    it('counts surrogate pairs as four bytes', () => {
-        expect(byteLength('😀')).toBe(4);
-    });
-    it('matches TextEncoder when the manual fallback is used', () => {
-        const samples = ['plain', 'é', '中', '😀', 'mix é 中 😀'];
-        for (const sample of samples) {
-            const encodedLength = new originalTextEncoder().encode(sample).length;
-            withoutTextEncoder(() => {
-                expect(byteLength(sample)).toBe(encodedLength);
-            });
-        }
-    });
-});
-describe('truncateToBytes', () => {
-    it('returns the original string when it fits', () => {
-        expect(truncateToBytes('hello', 10)).toBe('hello');
-        expect(truncateToBytes('é', 2)).toBe('é');
-    });
-    it('truncates multibyte text without splitting code units', () => {
-        expect(truncateToBytes('éé', 2)).toBe('é');
-        expect(truncateToBytes('abc', 2)).toBe('ab');
-    });
-    it('returns an empty string when maxBytes is zero', () => {
-        expect(truncateToBytes('hello', 0)).toBe('');
-    });
-    it('excludes an incomplete surrogate pair in the manual fallback', () => {
-        withoutTextEncoder(() => {
-            expect(truncateToBytes('a😀b', 2)).toBe('a');
-        });
-    });
-    it('does not split multibyte characters in the manual fallback', () => {
-        withoutTextEncoder(() => {
-            expect(truncateToBytes('mix é end', 5)).toBe('mix ');
-            expect(truncateToBytes('中文字', 3)).toBe('中');
-        });
-    });
-});
-describe('truncateBody', () => {
-    it('returns the body unchanged when within the byte limit', () => {
-        expect(truncateBody('{"ok":true}', 100)).toEqual({
-            body: '{"ok":true}',
-            truncated: false
-        });
-    });
-    it('truncates and appends the default suffix when over the limit', () => {
-        const body = 'x'.repeat(20);
-        const maxBytes = 10;
-        const result = truncateBody(body, maxBytes);
-        expect(result.truncated).toBe(true);
-        expect(result.body.endsWith(`[truncated — body exceeded ${maxBytes} bytes]`)).toBe(true);
-        expect(byteLength(result.body.replace(/\n\n\[truncated — body exceeded \d+ bytes\]$/, ''))).toBeLessThanOrEqual(maxBytes);
-    });
-    it('uses a custom suffix when provided', () => {
-        const result = truncateBody('0123456789', 5, '…');
-        expect(result).toEqual({
-            body: '01234…',
-            truncated: true
-        });
-    });
-});
-describe('createLogger', () => {
-    it('prefixes messages with [pluginId]', () => {
-        const logSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
-        const logger = createLogger('my-plugin');
-        logger.info('hello');
-        expect(logSpy).toHaveBeenCalledWith('[my-plugin]', 'hello');
-        logSpy.mockRestore();
-    });
-    it('filters messages below the active level', () => {
-        const logSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
-        const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
-        const logger = createLogger('my-plugin', { level: 'warn' });
-        logger.debug('hidden');
-        logger.info('hidden');
-        logger.warn('visible');
-        expect(logSpy).not.toHaveBeenCalled();
-        expect(warnSpy).toHaveBeenCalledTimes(1);
-        expect(warnSpy).toHaveBeenCalledWith('[my-plugin]', 'visible');
-        logSpy.mockRestore();
-        warnSpy.mockRestore();
-    });
-    it('updates the active level via setLevel', () => {
-        const logSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
-        const logger = createLogger('my-plugin');
-        logger.info('before');
-        logger.setLevel('silent');
-        logger.info('after');
-        expect(logSpy).toHaveBeenCalledTimes(1);
-        expect(logSpy).toHaveBeenCalledWith('[my-plugin]', 'before');
-        logSpy.mockRestore();
-    });
-    it('suppresses all output at silent level', () => {
-        const logSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
-        const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
-        const logger = createLogger('my-plugin', { level: 'silent' });
-        logger.debug('a');
-        logger.info('b');
-        logger.warn('c');
-        logger.error('d');
-        expect(logSpy).not.toHaveBeenCalled();
-        expect(errorSpy).not.toHaveBeenCalled();
-        logSpy.mockRestore();
-        errorSpy.mockRestore();
-    });
-    it('routes warn and error through console.warn and console.error when available', () => {
-        const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
-        const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
-        const logger = createLogger('my-plugin', { level: 'debug' });
-        logger.warn('warned');
-        logger.error('failed');
-        expect(warnSpy).toHaveBeenCalledWith('[my-plugin]', 'warned');
-        expect(errorSpy).toHaveBeenCalledWith('[my-plugin]', 'failed');
-        warnSpy.mockRestore();
-        errorSpy.mockRestore();
-    });
-    it('falls back to console.log when console.warn and console.error are unavailable', () => {
-        const logSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
-        const originalWarn = console.warn;
-        const originalError = console.error;
-        // @ts-expect-error — exercise SES main-runtime fallback
-        console.warn = undefined;
-        // @ts-expect-error — exercise SES main-runtime fallback
-        console.error = undefined;
-        const logger = createLogger('my-plugin', { level: 'debug' });
-        logger.warn('warned');
-        logger.error('failed');
-        expect(logSpy).toHaveBeenCalledWith('[my-plugin]', 'warned');
-        expect(logSpy).toHaveBeenCalledWith('[my-plugin]', 'failed');
-        console.warn = originalWarn;
-        console.error = originalError;
-        logSpy.mockRestore();
-    });
-});

package/dist/signing/signing.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=signing.test.d.ts.map

package/dist/signing/signing.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"signing.test.d.ts","sourceRoot":"","sources":["../../src/signing/signing.test.ts"],"names":[],"mappings":""}

package/dist/signing/signing.test.js

@@ -1,100 +0,0 @@
-import { describe, expect, it } from '@jest/globals';
-import { writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { signPlugin } from './sign.js';
-import { createTestPluginDir, createTestSigningKeys } from './testFixtures.js';
-import { verifyPlugin } from './verify.js';
-describe('signPlugin', () => {
-    it('writes signature.json for a valid plugin directory', async () => {
-        const keys = createTestSigningKeys();
-        const fixture = createTestPluginDir();
-        try {
-            const result = await signPlugin({
-                pluginDir: fixture.pluginDir,
-                privateKeyPem: keys.privateKeyPem,
-                keyId: 'test-key'
-            });
-            expect(result.signature.pluginId).toBe('com.example.test-plugin');
-            expect(result.signature.pluginVersion).toBe('1.0.0');
-            expect(result.signature.keyId).toBe('test-key');
-            expect(result.signature.files.map((file) => file.path)).toEqual([
-                'dist/renderer.js',
-                'manifest.json'
-            ]);
-            const verification = await verifyPlugin({
-                pluginDir: fixture.pluginDir,
-                trustedPublicKeysPem: [keys.publicKeyPem]
-            });
-            expect(verification.status).toBe('valid');
-        }
-        finally {
-            fixture.cleanup();
-        }
-    });
-    it('rejects invalid private keys', async () => {
-        const fixture = createTestPluginDir();
-        try {
-            await expect(signPlugin({
-                pluginDir: fixture.pluginDir,
-                privateKeyPem: 'not-a-key'
-            })).rejects.toThrow(/invalid ed25519 private key/i);
-        }
-        finally {
-            fixture.cleanup();
-        }
-    });
-});
-describe('verifyPlugin', () => {
-    it('returns unsigned when signature.json is absent', async () => {
-        const fixture = createTestPluginDir();
-        try {
-            const result = await verifyPlugin({
-                pluginDir: fixture.pluginDir,
-                trustedPublicKeysPem: [createTestSigningKeys().publicKeyPem]
-            });
-            expect(result.status).toBe('unsigned');
-        }
-        finally {
-            fixture.cleanup();
-        }
-    });
-    it('returns invalid when a signed file is tampered with', async () => {
-        const keys = createTestSigningKeys();
-        const fixture = createTestPluginDir();
-        try {
-            await signPlugin({
-                pluginDir: fixture.pluginDir,
-                privateKeyPem: keys.privateKeyPem
-            });
-            writeFileSync(join(fixture.pluginDir, 'dist', 'renderer.js'), 'export function activate() { return 1; }');
-            const result = await verifyPlugin({
-                pluginDir: fixture.pluginDir,
-                trustedPublicKeysPem: [keys.publicKeyPem]
-            });
-            expect(result.status).toBe('invalid');
-            expect(result.error).toMatch(/signed inventory/i);
-        }
-        finally {
-            fixture.cleanup();
-        }
-    });
-    it('returns invalid when verified with the wrong public key', async () => {
-        const keys = createTestSigningKeys();
-        const otherKeys = createTestSigningKeys();
-        const fixture = createTestPluginDir();
-        try {
-            await signPlugin({
-                pluginDir: fixture.pluginDir,
-                privateKeyPem: keys.privateKeyPem
-            });
-            const result = await verifyPlugin({
-                pluginDir: fixture.pluginDir,
-                trustedPublicKeysPem: [otherKeys.publicKeyPem]
-            });
-            expect(result.status).toBe('invalid');
-        }
-        finally {
-            fixture.cleanup();
-        }
-    });
-});

package/dist/storage/cappedList.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=cappedList.test.d.ts.map

package/dist/storage/cappedList.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cappedList.test.d.ts","sourceRoot":"","sources":["../../src/storage/cappedList.test.ts"],"names":[],"mappings":""}

package/dist/storage/cappedList.test.js

@@ -1,11 +0,0 @@
-import { describe, expect, it } from '@jest/globals';
-import { mergeById } from './cappedList.js';
-describe('mergeById', () => {
-    it('dedupes and caps newest-first', () => {
-        const merged = mergeById([{ id: 'b' }, { id: 'a' }], [{ id: 'a' }, { id: 'c' }], {
-            cap: 3,
-            idOf: (entry) => entry.id
-        });
-        expect(merged.map((entry) => entry.id)).toEqual(['b', 'a', 'c']);
-    });
-});

package/dist/storage/validate.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=validate.test.d.ts.map

package/dist/storage/validate.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"validate.test.d.ts","sourceRoot":"","sources":["../../src/storage/validate.test.ts"],"names":[],"mappings":""}

package/dist/storage/validate.test.js

@@ -1,78 +0,0 @@
-import { describe, expect, it } from '@jest/globals';
-import { arrayOf, asRecord, bool, isRecord, num, numArray, oneOf, recordOf, str, strArray } from './validate.js';
-describe('isRecord', () => {
-    it('accepts plain objects and rejects arrays and primitives', () => {
-        expect(isRecord({ a: 1 })).toBe(true);
-        expect(isRecord([])).toBe(false);
-        expect(isRecord(null)).toBe(false);
-        expect(isRecord('x')).toBe(false);
-    });
-});
-describe('asRecord', () => {
-    it('returns the record or null', () => {
-        const value = { key: 'v' };
-        expect(asRecord(value)).toBe(value);
-        expect(asRecord(null)).toBeNull();
-        expect(asRecord([1])).toBeNull();
-    });
-});
-describe('str', () => {
-    it('returns strings and falls back otherwise', () => {
-        expect(str('hello', '')).toBe('hello');
-        expect(str(42, 'fallback')).toBe('fallback');
-        expect(str(undefined, null)).toBeNull();
-    });
-});
-describe('num', () => {
-    it('returns finite numbers and falls back otherwise', () => {
-        expect(num(3, 0)).toBe(3);
-        expect(num(NaN, 0)).toBe(0);
-        expect(num(Infinity, 0)).toBe(0);
-        expect(num('3', null)).toBeNull();
-    });
-});
-describe('bool', () => {
-    it('returns booleans and falls back otherwise', () => {
-        expect(bool(true, false)).toBe(true);
-        expect(bool(false, true)).toBe(false);
-        expect(bool('true', true)).toBe(true);
-    });
-});
-describe('oneOf', () => {
-    it('accepts allowed literals and falls back otherwise', () => {
-        expect(oneOf('delay', ['interval', 'delay'], 'interval')).toBe('delay');
-        expect(oneOf('other', ['interval', 'delay'], 'interval')).toBe('interval');
-        expect(oneOf(1, ['interval', 'delay'], 'interval')).toBe('interval');
-    });
-});
-describe('numArray', () => {
-    it('filters to finite numbers', () => {
-        expect(numArray([1, NaN, 2, 'x', Infinity])).toEqual([1, 2]);
-        expect(numArray(null)).toEqual([]);
-    });
-});
-describe('strArray', () => {
-    it('filters to strings', () => {
-        expect(strArray(['a', 1, 'b'])).toEqual(['a', 'b']);
-        expect(strArray(undefined)).toEqual([]);
-    });
-});
-describe('arrayOf', () => {
-    it('filters through a guard', () => {
-        const isNum = (entry) => typeof entry === 'number' && Number.isFinite(entry);
-        expect(arrayOf([1, 'x', 2], isNum)).toEqual([1, 2]);
-        expect(arrayOf('nope', isNum)).toEqual([]);
-    });
-});
-describe('recordOf', () => {
-    it('keeps entries that pass the guard', () => {
-        const isNum = (entry) => typeof entry === 'number' && Number.isFinite(entry);
-        expect(recordOf({
-            a: 1,
-            b: 'x',
-            c: 2
-        }, isNum)).toEqual({ a: 1, c: 2 });
-        expect(recordOf([], isNum)).toEqual({});
-        expect(recordOf(null, isNum)).toEqual({});
-    });
-});