reqon-dsl 0.2.0 → 0.4.0

package/dist/interpreter/http.test.js

@@ -1,299 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { HttpClient, BearerAuthProvider, OAuth2AuthProvider } from './http.js';
-describe('HttpClient', () => {
-    let originalFetch;
-    beforeEach(() => {
-        originalFetch = globalThis.fetch;
-        vi.useFakeTimers();
-    });
-    afterEach(() => {
-        globalThis.fetch = originalFetch;
-        vi.useRealTimers();
-    });
-    describe('buildUrl', () => {
-        it('constructs URL with base and path', async () => {
-            const client = new HttpClient({ baseUrl: 'https://api.example.com' });
-            let capturedUrl = '';
-            globalThis.fetch = vi.fn(async (url) => {
-                capturedUrl = url.toString();
-                return new Response(JSON.stringify({}), { status: 200 });
-            });
-            await client.request({ method: 'GET', path: '/users' });
-            expect(capturedUrl).toBe('https://api.example.com/users');
-        });
-        it('handles trailing slash on base URL', async () => {
-            const client = new HttpClient({ baseUrl: 'https://api.example.com/' });
-            let capturedUrl = '';
-            globalThis.fetch = vi.fn(async (url) => {
-                capturedUrl = url.toString();
-                return new Response(JSON.stringify({}), { status: 200 });
-            });
-            await client.request({ method: 'GET', path: '/users' });
-            expect(capturedUrl).toBe('https://api.example.com/users');
-        });
-        it('handles path without leading slash', async () => {
-            const client = new HttpClient({ baseUrl: 'https://api.example.com' });
-            let capturedUrl = '';
-            globalThis.fetch = vi.fn(async (url) => {
-                capturedUrl = url.toString();
-                return new Response(JSON.stringify({}), { status: 200 });
-            });
-            await client.request({ method: 'GET', path: 'users' });
-            expect(capturedUrl).toBe('https://api.example.com/users');
-        });
-        it('adds query parameters to URL', async () => {
-            const client = new HttpClient({ baseUrl: 'https://api.example.com' });
-            let capturedUrl = '';
-            globalThis.fetch = vi.fn(async (url) => {
-                capturedUrl = url.toString();
-                return new Response(JSON.stringify({}), { status: 200 });
-            });
-            await client.request({
-                method: 'GET',
-                path: '/users',
-                query: { page: '1', limit: '10' },
-            });
-            expect(capturedUrl).toBe('https://api.example.com/users?page=1&limit=10');
-        });
-    });
-    describe('headers', () => {
-        it('sets default Content-Type and Accept headers', async () => {
-            const client = new HttpClient({ baseUrl: 'https://api.example.com' });
-            let capturedHeaders = {};
-            globalThis.fetch = vi.fn(async (_url, init) => {
-                capturedHeaders = Object.fromEntries(Object.entries(init?.headers || {}));
-                return new Response(JSON.stringify({}), { status: 200 });
-            });
-            await client.request({ method: 'GET', path: '/users' });
-            expect(capturedHeaders['Content-Type']).toBe('application/json');
-            expect(capturedHeaders['Accept']).toBe('application/json');
-        });
-        it('merges config headers', async () => {
-            const client = new HttpClient({
-                baseUrl: 'https://api.example.com',
-                headers: { 'X-Custom': 'value' },
-            });
-            let capturedHeaders = {};
-            globalThis.fetch = vi.fn(async (_url, init) => {
-                capturedHeaders = Object.fromEntries(Object.entries(init?.headers || {}));
-                return new Response(JSON.stringify({}), { status: 200 });
-            });
-            await client.request({ method: 'GET', path: '/users' });
-            expect(capturedHeaders['X-Custom']).toBe('value');
-        });
-        it('request headers override config headers', async () => {
-            const client = new HttpClient({
-                baseUrl: 'https://api.example.com',
-                headers: { 'X-Custom': 'config' },
-            });
-            let capturedHeaders = {};
-            globalThis.fetch = vi.fn(async (_url, init) => {
-                capturedHeaders = Object.fromEntries(Object.entries(init?.headers || {}));
-                return new Response(JSON.stringify({}), { status: 200 });
-            });
-            await client.request({
-                method: 'GET',
-                path: '/users',
-                headers: { 'X-Custom': 'request' },
-            });
-            expect(capturedHeaders['X-Custom']).toBe('request');
-        });
-        it('adds Authorization header when auth provider is set', async () => {
-            const auth = new BearerAuthProvider('test-token');
-            const client = new HttpClient({
-                baseUrl: 'https://api.example.com',
-                auth,
-            });
-            let capturedHeaders = {};
-            globalThis.fetch = vi.fn(async (_url, init) => {
-                capturedHeaders = Object.fromEntries(Object.entries(init?.headers || {}));
-                return new Response(JSON.stringify({}), { status: 200 });
-            });
-            await client.request({ method: 'GET', path: '/users' });
-            expect(capturedHeaders['Authorization']).toBe('Bearer test-token');
-        });
-    });
-    describe('calculateDelay', () => {
-        it('calculates exponential backoff delay', async () => {
-            const client = new HttpClient({ baseUrl: 'https://api.example.com' });
-            const delays = [];
-            let callCount = 0;
-            globalThis.fetch = vi.fn(async () => {
-                callCount++;
-                if (callCount < 3) {
-                    throw new Error('Network error');
-                }
-                return new Response(JSON.stringify({}), { status: 200 });
-            });
-            const requestPromise = client.request({ method: 'GET', path: '/users' }, { maxAttempts: 3, backoff: 'exponential', initialDelay: 1000 });
-            // First retry delay: ~1000ms (1000 * 2^0)
-            await vi.advanceTimersByTimeAsync(1000);
-            // Second retry delay: ~2000ms (1000 * 2^1)
-            await vi.advanceTimersByTimeAsync(2000);
-            await requestPromise;
-            expect(callCount).toBe(3);
-        });
-        it('calculates linear backoff delay', async () => {
-            const client = new HttpClient({ baseUrl: 'https://api.example.com' });
-            let callCount = 0;
-            globalThis.fetch = vi.fn(async () => {
-                callCount++;
-                if (callCount < 3) {
-                    throw new Error('Network error');
-                }
-                return new Response(JSON.stringify({}), { status: 200 });
-            });
-            const requestPromise = client.request({ method: 'GET', path: '/users' }, { maxAttempts: 3, backoff: 'linear', initialDelay: 1000 });
-            // Advance through all retries with buffer for jitter
-            await vi.advanceTimersByTimeAsync(5000);
-            await requestPromise;
-            expect(callCount).toBe(3);
-        });
-        it('calculates constant backoff delay', async () => {
-            const client = new HttpClient({ baseUrl: 'https://api.example.com' });
-            let callCount = 0;
-            globalThis.fetch = vi.fn(async () => {
-                callCount++;
-                if (callCount < 3) {
-                    throw new Error('Network error');
-                }
-                return new Response(JSON.stringify({}), { status: 200 });
-            });
-            const requestPromise = client.request({ method: 'GET', path: '/users' }, { maxAttempts: 3, backoff: 'constant', initialDelay: 1000 });
-            // Both retries should use ~1000ms
-            await vi.advanceTimersByTimeAsync(1100);
-            await vi.advanceTimersByTimeAsync(1100);
-            await requestPromise;
-            expect(callCount).toBe(3);
-        });
-    });
-    describe('retry behavior', () => {
-        it('retries on 5xx server errors', async () => {
-            const client = new HttpClient({ baseUrl: 'https://api.example.com' });
-            let callCount = 0;
-            globalThis.fetch = vi.fn(async () => {
-                callCount++;
-                if (callCount < 2) {
-                    return new Response(JSON.stringify({ error: 'Server error' }), { status: 500 });
-                }
-                return new Response(JSON.stringify({ data: 'success' }), { status: 200 });
-            });
-            const requestPromise = client.request({ method: 'GET', path: '/users' }, { maxAttempts: 3, backoff: 'constant', initialDelay: 100 });
-            await vi.advanceTimersByTimeAsync(150);
-            const result = await requestPromise;
-            expect(callCount).toBe(2);
-            expect(result.status).toBe(200);
-        });
-        it('respects Retry-After header on 429', async () => {
-            const client = new HttpClient({ baseUrl: 'https://api.example.com' });
-            let callCount = 0;
-            globalThis.fetch = vi.fn(async () => {
-                callCount++;
-                if (callCount < 2) {
-                    const headers = new Headers();
-                    headers.set('Retry-After', '5'); // 5 seconds
-                    return new Response(JSON.stringify({}), { status: 429, headers });
-                }
-                return new Response(JSON.stringify({ data: 'success' }), { status: 200 });
-            });
-            const requestPromise = client.request({ method: 'GET', path: '/users' }, { maxAttempts: 3, backoff: 'exponential', initialDelay: 1000 });
-            // Should wait 5 seconds as specified in Retry-After
-            await vi.advanceTimersByTimeAsync(5000);
-            const result = await requestPromise;
-            expect(callCount).toBe(2);
-            expect(result.status).toBe(200);
-        });
-        it('throws after max retry attempts', async () => {
-            const client = new HttpClient({ baseUrl: 'https://api.example.com' });
-            globalThis.fetch = vi.fn(async () => {
-                throw new Error('Network error');
-            });
-            const requestPromise = client.request({ method: 'GET', path: '/users' }, { maxAttempts: 3, backoff: 'constant', initialDelay: 100 });
-            // Advance through all retries (need more time for async operations)
-            await vi.advanceTimersByTimeAsync(500);
-            await expect(requestPromise).rejects.toThrow('Network error');
-        });
-    });
-    describe('response handling', () => {
-        it('parses JSON response body', async () => {
-            const client = new HttpClient({ baseUrl: 'https://api.example.com' });
-            const responseData = { id: 1, name: 'Test' };
-            globalThis.fetch = vi.fn(async () => {
-                return new Response(JSON.stringify(responseData), { status: 200 });
-            });
-            const result = await client.request({
-                method: 'GET',
-                path: '/users/1',
-            });
-            expect(result.data).toEqual(responseData);
-        });
-        it('returns response headers', async () => {
-            const client = new HttpClient({ baseUrl: 'https://api.example.com' });
-            globalThis.fetch = vi.fn(async () => {
-                const headers = new Headers();
-                headers.set('X-Total-Count', '100');
-                return new Response(JSON.stringify({}), { status: 200, headers });
-            });
-            const result = await client.request({ method: 'GET', path: '/users' });
-            expect(result.headers['x-total-count']).toBe('100');
-        });
-        it('sends request body as JSON', async () => {
-            const client = new HttpClient({ baseUrl: 'https://api.example.com' });
-            let capturedBody;
-            globalThis.fetch = vi.fn(async (_url, init) => {
-                capturedBody = init?.body;
-                return new Response(JSON.stringify({}), { status: 201 });
-            });
-            await client.request({
-                method: 'POST',
-                path: '/users',
-                body: { name: 'Test', email: 'test@example.com' },
-            });
-            expect(capturedBody).toBe(JSON.stringify({ name: 'Test', email: 'test@example.com' }));
-        });
-    });
-});
-describe('BearerAuthProvider', () => {
-    it('returns the configured token', async () => {
-        const provider = new BearerAuthProvider('my-token');
-        const token = await provider.getToken();
-        expect(token).toBe('my-token');
-    });
-});
-describe('OAuth2AuthProvider', () => {
-    it('returns the access token', async () => {
-        const provider = new OAuth2AuthProvider({
-            accessToken: 'access-token',
-        });
-        const token = await provider.getToken();
-        expect(token).toBe('access-token');
-    });
-    it('throws when refreshToken called without required config', async () => {
-        const provider = new OAuth2AuthProvider({
-            accessToken: 'access-token',
-        });
-        await expect(provider.refreshToken()).rejects.toThrow('Cannot refresh token: missing refresh token or endpoint');
-    });
-    it('refreshes token using token endpoint', async () => {
-        const originalFetch = globalThis.fetch;
-        const provider = new OAuth2AuthProvider({
-            accessToken: 'old-token',
-            refreshToken: 'refresh-token',
-            tokenEndpoint: 'https://auth.example.com/token',
-            clientId: 'client-id',
-            clientSecret: 'client-secret',
-        });
-        globalThis.fetch = vi.fn(async () => {
-            return new Response(JSON.stringify({
-                access_token: 'new-token',
-                refresh_token: 'new-refresh-token',
-            }), { status: 200 });
-        });
-        const newToken = await provider.refreshToken();
-        expect(newToken).toBe('new-token');
-        // Token should be updated internally
-        const currentToken = await provider.getToken();
-        expect(currentToken).toBe('new-token');
-        globalThis.fetch = originalFetch;
-    });
-});

package/dist/interpreter/progress.test.d.ts

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

package/dist/interpreter/progress.test.js

@@ -1,216 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { MissionExecutor } from './executor.js';
-function createTestProgram(stages) {
-    const actions = stages.map((name) => ({
-        type: 'ActionDefinition',
-        name,
-        steps: [],
-    }));
-    const pipeline = {
-        type: 'PipelineDefinition',
-        stages: stages.map((action) => ({ action })),
-    };
-    const mission = {
-        type: 'MissionDefinition',
-        name: 'TestMission',
-        sources: [],
-        stores: [],
-        schemas: [],
-        actions,
-        pipeline,
-    };
-    return {
-        type: 'ReqonProgram',
-        statements: [mission],
-    };
-}
-describe('Progress Callbacks', () => {
-    describe('onExecutionStart', () => {
-        it('is called when execution begins', async () => {
-            const onExecutionStart = vi.fn();
-            const executor = new MissionExecutor({
-                progress: { onExecutionStart },
-            });
-            await executor.execute(createTestProgram(['StepA', 'StepB']));
-            expect(onExecutionStart).toHaveBeenCalledOnce();
-            expect(onExecutionStart).toHaveBeenCalledWith(expect.objectContaining({
-                mission: 'TestMission',
-                stageCount: 2,
-                isResume: false,
-            }));
-        });
-        it('includes executionId from ephemeral execution', async () => {
-            const onExecutionStart = vi.fn();
-            const executor = new MissionExecutor({
-                progress: { onExecutionStart },
-            });
-            await executor.execute(createTestProgram(['StepA']));
-            expect(onExecutionStart).toHaveBeenCalledWith(expect.objectContaining({
-                executionId: 'ephemeral',
-            }));
-        });
-        it('includes executionId when persistence enabled', async () => {
-            const onExecutionStart = vi.fn();
-            const executor = new MissionExecutor({
-                persistState: true,
-                dataDir: '.reqon-test-progress',
-                progress: { onExecutionStart },
-            });
-            await executor.execute(createTestProgram(['StepA']));
-            expect(onExecutionStart).toHaveBeenCalledWith(expect.objectContaining({
-                executionId: expect.stringMatching(/^exec_/),
-            }));
-        });
-        it('includes metadata if provided', async () => {
-            const onExecutionStart = vi.fn();
-            const executor = new MissionExecutor({
-                metadata: { tenant: 'acme', userId: '123' },
-                progress: { onExecutionStart },
-            });
-            await executor.execute(createTestProgram(['StepA']));
-            expect(onExecutionStart).toHaveBeenCalledWith(expect.objectContaining({
-                metadata: { tenant: 'acme', userId: '123' },
-            }));
-        });
-    });
-    describe('onExecutionComplete', () => {
-        it('is called when execution finishes successfully', async () => {
-            const onExecutionComplete = vi.fn();
-            const executor = new MissionExecutor({
-                progress: { onExecutionComplete },
-            });
-            await executor.execute(createTestProgram(['StepA', 'StepB']));
-            expect(onExecutionComplete).toHaveBeenCalledOnce();
-            expect(onExecutionComplete).toHaveBeenCalledWith(expect.objectContaining({
-                mission: 'TestMission',
-                success: true,
-                stagesCompleted: 2,
-                stagesFailed: 0,
-                errors: [],
-            }));
-        });
-        it('includes duration', async () => {
-            const onExecutionComplete = vi.fn();
-            const executor = new MissionExecutor({
-                progress: { onExecutionComplete },
-            });
-            await executor.execute(createTestProgram(['StepA']));
-            const event = onExecutionComplete.mock.calls[0][0];
-            expect(event.duration).toBeGreaterThanOrEqual(0);
-        });
-    });
-    describe('onStageStart', () => {
-        it('is called for each stage', async () => {
-            const onStageStart = vi.fn();
-            const executor = new MissionExecutor({
-                progress: { onStageStart },
-            });
-            await executor.execute(createTestProgram(['StepA', 'StepB', 'StepC']));
-            expect(onStageStart).toHaveBeenCalledTimes(3);
-        });
-        it('includes stage index and name', async () => {
-            const events = [];
-            const executor = new MissionExecutor({
-                progress: {
-                    onStageStart: (e) => events.push(e),
-                },
-            });
-            await executor.execute(createTestProgram(['Fetch', 'Process', 'Store']));
-            expect(events[0]).toMatchObject({
-                stageIndex: 0,
-                stageName: 'Fetch',
-                totalStages: 3,
-            });
-            expect(events[1]).toMatchObject({
-                stageIndex: 1,
-                stageName: 'Process',
-                totalStages: 3,
-            });
-            expect(events[2]).toMatchObject({
-                stageIndex: 2,
-                stageName: 'Store',
-                totalStages: 3,
-            });
-        });
-    });
-    describe('onStageComplete', () => {
-        it('is called for each stage', async () => {
-            const onStageComplete = vi.fn();
-            const executor = new MissionExecutor({
-                progress: { onStageComplete },
-            });
-            await executor.execute(createTestProgram(['StepA', 'StepB']));
-            expect(onStageComplete).toHaveBeenCalledTimes(2);
-        });
-        it('includes success status and duration', async () => {
-            const events = [];
-            const executor = new MissionExecutor({
-                progress: {
-                    onStageComplete: (e) => events.push(e),
-                },
-            });
-            await executor.execute(createTestProgram(['StepA']));
-            expect(events[0]).toMatchObject({
-                stageIndex: 0,
-                stageName: 'StepA',
-                success: true,
-            });
-            expect(events[0].duration).toBeGreaterThanOrEqual(0);
-            expect(events[0].error).toBeUndefined();
-        });
-    });
-    describe('callback order', () => {
-        it('fires callbacks in correct order', async () => {
-            const callOrder = [];
-            const executor = new MissionExecutor({
-                progress: {
-                    onExecutionStart: () => callOrder.push('execStart'),
-                    onExecutionComplete: () => callOrder.push('execComplete'),
-                    onStageStart: (e) => callOrder.push(`stageStart:${e.stageName}`),
-                    onStageComplete: (e) => callOrder.push(`stageComplete:${e.stageName}`),
-                },
-            });
-            await executor.execute(createTestProgram(['A', 'B']));
-            expect(callOrder).toEqual([
-                'execStart',
-                'stageStart:A',
-                'stageComplete:A',
-                'stageStart:B',
-                'stageComplete:B',
-                'execComplete',
-            ]);
-        });
-    });
-    describe('real-time UI example', () => {
-        it('can build a progress tracker', async () => {
-            const progressLog = [];
-            const executor = new MissionExecutor({
-                progress: {
-                    onExecutionStart: (e) => {
-                        progressLog.push(`Starting ${e.mission} (${e.stageCount} stages)`);
-                    },
-                    onStageStart: (e) => {
-                        const pct = Math.round((e.stageIndex / e.totalStages) * 100);
-                        progressLog.push(`[${pct}%] Running ${e.stageName}...`);
-                    },
-                    onStageComplete: (e) => {
-                        const pct = Math.round(((e.stageIndex + 1) / e.totalStages) * 100);
-                        progressLog.push(`[${pct}%] ${e.stageName} ${e.success ? 'done' : 'failed'}`);
-                    },
-                    onExecutionComplete: (e) => {
-                        progressLog.push(`Finished: ${e.success ? 'SUCCESS' : 'FAILED'} in ${e.duration}ms`);
-                    },
-                },
-            });
-            await executor.execute(createTestProgram(['Fetch', 'Process', 'Store']));
-            expect(progressLog[0]).toBe('Starting TestMission (3 stages)');
-            expect(progressLog[1]).toBe('[0%] Running Fetch...');
-            expect(progressLog[2]).toBe('[33%] Fetch done');
-            expect(progressLog[3]).toBe('[33%] Running Process...');
-            expect(progressLog[4]).toBe('[67%] Process done');
-            expect(progressLog[5]).toBe('[67%] Running Store...');
-            expect(progressLog[6]).toBe('[100%] Store done');
-            expect(progressLog[7]).toMatch(/^Finished: SUCCESS in \d+ms$/);
-        });
-    });
-});

package/dist/interpreter/schema-matcher.test.d.ts

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

package/dist/interpreter/schema-matcher.test.js

@@ -1,122 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { matchesSchema, findMatchingSchema } from './schema-matcher.js';
-describe('Schema Matcher', () => {
-    describe('matchesSchema', () => {
-        const userSchema = {
-            type: 'SchemaDefinition',
-            name: 'User',
-            fields: [
-                {
-                    type: 'FieldDefinition',
-                    name: 'id',
-                    fieldType: { type: 'PrimitiveType', name: 'int' },
-                },
-                {
-                    type: 'FieldDefinition',
-                    name: 'name',
-                    fieldType: { type: 'PrimitiveType', name: 'string' },
-                },
-                {
-                    type: 'FieldDefinition',
-                    name: 'email',
-                    fieldType: { type: 'PrimitiveType', name: 'string' },
-                    optional: true,
-                },
-            ],
-        };
-        it('matches valid object with all required fields', () => {
-            const value = { id: 1, name: 'Alice' };
-            expect(matchesSchema(value, userSchema)).toBe(true);
-        });
-        it('matches valid object with optional field', () => {
-            const value = { id: 1, name: 'Alice', email: 'alice@example.com' };
-            expect(matchesSchema(value, userSchema)).toBe(true);
-        });
-        it('matches object with extra fields (open schema)', () => {
-            const value = { id: 1, name: 'Alice', extra: 'ignored' };
-            expect(matchesSchema(value, userSchema)).toBe(true);
-        });
-        it('rejects object missing required field', () => {
-            const value = { id: 1 }; // missing 'name'
-            expect(matchesSchema(value, userSchema)).toBe(false);
-        });
-        it('rejects wrong type for field', () => {
-            const value = { id: 'not-a-number', name: 'Alice' };
-            expect(matchesSchema(value, userSchema)).toBe(false);
-        });
-        it('rejects null value', () => {
-            expect(matchesSchema(null, userSchema)).toBe(false);
-        });
-        it('rejects primitive value', () => {
-            expect(matchesSchema('string', userSchema)).toBe(false);
-        });
-        it('allows null for optional fields', () => {
-            const value = { id: 1, name: 'Alice', email: null };
-            expect(matchesSchema(value, userSchema)).toBe(true);
-        });
-    });
-    describe('findMatchingSchema', () => {
-        const successSchema = {
-            type: 'SchemaDefinition',
-            name: 'SuccessResponse',
-            fields: [
-                {
-                    type: 'FieldDefinition',
-                    name: 'data',
-                    fieldType: { type: 'ReferenceType', path: { type: 'QualifiedName', parts: ['object'] } },
-                },
-                {
-                    type: 'FieldDefinition',
-                    name: 'status',
-                    fieldType: { type: 'PrimitiveType', name: 'string' },
-                },
-            ],
-        };
-        const errorSchema = {
-            type: 'SchemaDefinition',
-            name: 'ErrorResponse',
-            fields: [
-                {
-                    type: 'FieldDefinition',
-                    name: 'error',
-                    fieldType: { type: 'PrimitiveType', name: 'string' },
-                },
-                {
-                    type: 'FieldDefinition',
-                    name: 'code',
-                    fieldType: { type: 'PrimitiveType', name: 'int' },
-                },
-            ],
-        };
-        const schemas = new Map([
-            ['SuccessResponse', successSchema],
-            ['ErrorResponse', errorSchema],
-        ]);
-        it('finds matching schema in order', () => {
-            const successValue = { data: { id: 1 }, status: 'ok' };
-            const result = findMatchingSchema(successValue, schemas, ['SuccessResponse', 'ErrorResponse']);
-            expect(result).toBe('SuccessResponse');
-        });
-        it('finds second schema if first does not match', () => {
-            const errorValue = { error: 'Not found', code: 404 };
-            const result = findMatchingSchema(errorValue, schemas, ['SuccessResponse', 'ErrorResponse']);
-            expect(result).toBe('ErrorResponse');
-        });
-        it('returns undefined if no schema matches', () => {
-            const value = { random: 'value' };
-            const result = findMatchingSchema(value, schemas, ['SuccessResponse', 'ErrorResponse']);
-            expect(result).toBeUndefined();
-        });
-        it('handles wildcard pattern', () => {
-            const value = { random: 'value' };
-            const result = findMatchingSchema(value, schemas, ['SuccessResponse', 'ErrorResponse', '_']);
-            expect(result).toBe('_');
-        });
-        it('respects schema order (first match wins)', () => {
-            // Create a schema that matches both
-            const ambiguousValue = { data: {}, status: 'ok', error: 'msg', code: 500 };
-            const result = findMatchingSchema(ambiguousValue, schemas, ['SuccessResponse', 'ErrorResponse']);
-            expect(result).toBe('SuccessResponse'); // First match wins
-        });
-    });
-});

package/dist/lexer/lexer.d.ts

@@ -1,24 +0,0 @@
-import { type ReqonToken } from './tokens.js';
-export declare class ReqonLexer {
-    private source;
-    private pos;
-    private line;
-    private column;
-    constructor(source: string);
-    tokenize(): ReqonToken[];
-    private nextToken;
-    private readString;
-    private readNumber;
-    private readIdentifier;
-    private readOperator;
-    private skipWhitespace;
-    private skipLineComment;
-    private makeToken;
-    private peek;
-    private peekNext;
-    private advance;
-    private isAtEnd;
-    private isDigit;
-    private isAlpha;
-    private isAlphaNumeric;
-}