@harborclient/sdk 0.7.0 → 1.0.1

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,104 +0,0 @@
-import { afterEach, describe, expect, it, jest } from '@jest/globals';
-import { byteLength, 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
-        });
-    });
-});

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/utilities.test.d.ts

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

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

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

package/dist/utilities.test.js

@@ -1,16 +0,0 @@
-import { describe, expect, it } from '@jest/globals';
-import { methodColorClass, statusColorClass } from './ui/tokens.js';
-import { formatRelativeTime, formatHeaders } from './ui/format.js';
-describe('method and status color helpers', () => {
-    it('return host classes', () => {
-        expect(methodColorClass('GET')).toBe('text-method-get');
-        expect(statusColorClass(200)).toBe('bg-success');
-        expect(statusColorClass(404)).toBe('bg-danger');
-    });
-});
-describe('format helpers', () => {
-    it('produce readable output', () => {
-        expect(formatHeaders({ Accept: 'application/json' })).toBe('Accept: application/json');
-        expect(formatRelativeTime(Date.now() - 10_000)).toMatch(/ago|just now/);
-    });
-});

package/dist/variables/dynamic.test.d.ts

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

package/dist/variables/dynamic.test.d.ts.map

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

package/dist/variables/dynamic.test.js

@@ -1,60 +0,0 @@
-import { describe, expect, it } from '@jest/globals';
-import { DYNAMIC_VARIABLE_CATEGORIES, DYNAMIC_VARIABLE_NAMES, DYNAMIC_VARIABLES, getDynamicVariableDescription, isDynamicVariable, resolveDynamicVariable } from './dynamic.js';
-describe('dynamicVariables', () => {
-    it('registers all Postman-style dynamic variable names with $ prefix', () => {
-        expect(DYNAMIC_VARIABLE_NAMES.length).toBeGreaterThan(100);
-        for (const name of DYNAMIC_VARIABLE_NAMES) {
-            expect(name.startsWith('$')).toBe(true);
-        }
-    });
-    it('generates a non-empty value for every registered dynamic variable', () => {
-        for (const name of DYNAMIC_VARIABLE_NAMES) {
-            const value = resolveDynamicVariable(name);
-            expect(value).toBeDefined();
-            expect(value.length).toBeGreaterThan(0);
-        }
-    });
-    it('isDynamicVariable and getDynamicVariableDescription reflect the registry', () => {
-        expect(isDynamicVariable('$guid')).toBe(true);
-        expect(isDynamicVariable('$randomFirstName')).toBe(true);
-        expect(isDynamicVariable('host')).toBe(false);
-        expect(isDynamicVariable('$unknownDynamic')).toBe(false);
-        expect(getDynamicVariableDescription('$guid')).toBe(DYNAMIC_VARIABLES.$guid.description);
-        expect(getDynamicVariableDescription('host')).toBeUndefined();
-    });
-    it('resolveDynamicVariable returns undefined for unknown keys', () => {
-        expect(resolveDynamicVariable('$notARealVariable')).toBeUndefined();
-    });
-    it('$guid and $randomUUID produce uuid-v4 shaped values', () => {
-        const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-        expect(resolveDynamicVariable('$guid')).toMatch(uuidPattern);
-        expect(resolveDynamicVariable('$randomUUID')).toMatch(uuidPattern);
-    });
-    it('$timestamp returns a numeric unix seconds string', () => {
-        const value = resolveDynamicVariable('$timestamp');
-        expect(value).toMatch(/^\d+$/);
-        const seconds = Number(value);
-        expect(seconds).toBeGreaterThan(1_500_000_000);
-        expect(seconds).toBeLessThanOrEqual(Math.floor(Date.now() / 1000));
-    });
-    it('$isoTimestamp returns an ISO-8601 UTC string', () => {
-        const value = resolveDynamicVariable('$isoTimestamp');
-        expect(value).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
-        expect(() => new Date(value).toISOString()).not.toThrow();
-    });
-    it('generates fresh values on each resolve call for random variables', () => {
-        const first = resolveDynamicVariable('$randomInt');
-        const second = resolveDynamicVariable('$randomInt');
-        expect(first).toMatch(/^\d+$/);
-        expect(second).toMatch(/^\d+$/);
-    });
-    it('lists every dynamic variable exactly once across documentation categories', () => {
-        const categorized = DYNAMIC_VARIABLE_CATEGORIES.flatMap((category) => category.keys);
-        const unique = new Set(categorized);
-        expect(categorized.length).toBe(DYNAMIC_VARIABLE_NAMES.length);
-        expect(unique.size).toBe(DYNAMIC_VARIABLE_NAMES.length);
-        for (const name of DYNAMIC_VARIABLE_NAMES) {
-            expect(unique.has(name)).toBe(true);
-        }
-    });
-});

package/dist/variables/tokens.test.d.ts

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

package/dist/variables/tokens.test.d.ts.map

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