@happyvertical/smrt-svelte 0.53.1 → 0.53.2

package/dist/hooks/__tests__/stt-ownership-harness.svelte.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stt-ownership-harness.svelte.d.ts","sourceRoot":"","sources":["../../../src/hooks/__tests__/stt-ownership-harness.svelte.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAE3E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAIxD,UAAU,KAAK;IACb,OAAO,EAAE,mBAAmB,CAAC;IAC7B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,YAAY,KAAK,IAAI,CAAC;IACvC,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,YAAY,KAAK,IAAI,CAAC;IACvC,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAiCD,QAAA,MAAM,mBAAmB,2CAAwC,CAAC;AAClE,KAAK,mBAAmB,GAAG,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAClE,eAAe,mBAAmB,CAAC"}

package/dist/hooks/__tests__/useSTT-ownership.test.js

@@ -1,102 +0,0 @@
-/**
- * R4 regression (T2 #1403): useSTT()/useTTS() attach onDestroy to the
- * Provider-level *singleton* manager. Before the fix, unmounting ANY hook
- * consumer that found the manager listening would call stopListening() —
- * aborting a recording another consumer had started. The fix tracks per-hook
- * ownership: a consumer only stops the singleton if it started the session.
- */
-import { render } from '@testing-library/svelte';
-import { tick } from 'svelte';
-import { describe, expect, it, vi } from 'vitest';
-import Harness from './stt-ownership-harness.svelte';
-/**
- * Minimal fake manager exposing only what useSTT touches. `isListening`
- * flips true once any consumer calls startListening().
- */
-function makeFakeManager() {
-    const listening = { value: false };
-    const startListening = vi.fn(async () => {
-        listening.value = true;
-    });
-    const stopListening = vi.fn(async () => {
-        listening.value = false;
-    });
-    const manager = {
-        startListening,
-        stopListening,
-        initializeSTT: vi.fn(async () => ({})),
-        get state() {
-            return {
-                ai: {
-                    stt: {
-                        get isListening() {
-                            return listening.value;
-                        },
-                    },
-                },
-            };
-        },
-    };
-    return { manager, startListening, stopListening, listening };
-}
-describe('useSTT per-hook ownership (R4)', () => {
-    it("unmounting a non-owning consumer does not stop another consumer's recording", async () => {
-        const { manager, startListening, stopListening } = makeFakeManager();
-        let sttA;
-        const { rerender, unmount } = render(Harness, {
-            props: {
-                manager,
-                showA: true,
-                showB: true,
-                onReadyA: (s) => {
-                    sttA = s;
-                },
-            },
-        });
-        // Consumer A starts the shared listening session.
-        await sttA?.start();
-        await tick();
-        expect(startListening).toHaveBeenCalledTimes(1);
-        // Unmount consumer B (which never started). It must NOT stop A's session.
-        await rerender({ manager, showA: true, showB: false });
-        await tick();
-        expect(stopListening).not.toHaveBeenCalled();
-        // Now unmount everything: the owning consumer A stops its own session.
-        unmount();
-        await tick();
-        expect(stopListening).toHaveBeenCalledTimes(1);
-    });
-    it('an owning consumer stops the session it started on unmount', async () => {
-        const { manager, startListening, stopListening } = makeFakeManager();
-        let sttA;
-        const { unmount } = render(Harness, {
-            props: {
-                manager,
-                showA: true,
-                showB: false,
-                onReadyA: (s) => {
-                    sttA = s;
-                },
-            },
-        });
-        await sttA?.start();
-        await tick();
-        expect(startListening).toHaveBeenCalledTimes(1);
-        unmount();
-        await tick();
-        expect(stopListening).toHaveBeenCalledTimes(1);
-    });
-    it('a consumer that never started does not stop a session on unmount', async () => {
-        const { manager, stopListening, listening } = makeFakeManager();
-        // Simulate the singleton already listening (started elsewhere).
-        listening.value = true;
-        const { unmount } = render(Harness, {
-            props: { manager, showA: true, showB: false },
-        });
-        await tick();
-        // Consumer A never called start(); unmounting must leave the session alone.
-        unmount();
-        await tick();
-        expect(stopListening).not.toHaveBeenCalled();
-    });
-});

package/dist/i18n/__tests__/server.spec.js

@@ -1,57 +0,0 @@
-/**
- * Integration coverage for the server snapshot builder (S13 #1418): it seeds the
- * languages registry from smrt-svelte's English defaults and resolves them into
- * a template dictionary the client renders synchronously. Exercises the real
- * `@happyvertical/smrt-languages` resolver (no DB → code-default layer only).
- *
- * `server.ts` imports the languages package root, whose `__smrt-register__`
- * manifest side-effect throws under vitest's source-alias (it resolves
- * `manifest.json` via the dev-server URL, not a file). That manifest is the
- * ObjectRegistry's, unrelated to string resolution (which uses the separate
- * LanguageRegistry), so we record-not-throw via SMRT_STRICT_REGISTRY=false set
- * before a dynamic import of the module under test.
- */
-import { afterEach, beforeAll, describe, expect, it, vi } from 'vitest';
-let buildI18nSnapshot;
-let defineMessages;
-let clearRegisteredMessages;
-beforeAll(async () => {
-    vi.stubEnv('SMRT_STRICT_REGISTRY', 'false');
-    ({ buildI18nSnapshot } = await import('../server.js'));
-    ({ defineMessages, clearRegisteredMessages } = await import('@happyvertical/smrt-ui/i18n'));
-});
-afterEach(() => {
-    clearRegisteredMessages();
-});
-describe('buildI18nSnapshot', () => {
-    it('resolves registered English defaults into a template dictionary', async () => {
-        defineMessages({
-            'ui.snapshot_test.empty': 'No data available',
-            'ui.snapshot_test.range': 'Showing {count} of {total}',
-        });
-        const snapshot = await buildI18nSnapshot({ locale: 'en' });
-        expect(snapshot.locale).toBe('en');
-        expect(snapshot.messages['ui.snapshot_test.empty']).toBe('No data available');
-        // Templates are shipped un-rendered; the client interpolates at call time.
-        expect(snapshot.messages['ui.snapshot_test.range']).toBe('Showing {count} of {total}');
-    });
-    it('honors an explicit key subset', async () => {
-        defineMessages({
-            'ui.snapshot_test.a': 'Alpha',
-            'ui.snapshot_test.b': 'Beta',
-        });
-        const snapshot = await buildI18nSnapshot({
-            locale: 'en',
-            keys: ['ui.snapshot_test.a'],
-        });
-        expect(snapshot.messages['ui.snapshot_test.a']).toBe('Alpha');
-        expect(snapshot.messages['ui.snapshot_test.b']).toBeUndefined();
-    });
-    it('includes Board defaults when only the server snapshot entrypoint is imported', async () => {
-        const snapshot = await buildI18nSnapshot({
-            locale: 'en',
-            keys: ['ui.board.move_failed'],
-        });
-        expect(snapshot.messages['ui.board.move_failed']).toBe('Could not move {card}. The board was restored.');
-    });
-});

package/dist/internal/logger.test.js

@@ -1,54 +0,0 @@
-/**
- * Regression coverage for the "process is not defined" hydration killer.
- *
- * `internal/logger` is browser-reachable through Provider and the form
- * components, and `@happyvertical/logger`'s `createLogger()` eagerly reads
- * `process.env` (HAVE_LOGGER_LEVEL). Constructing the logger at module scope
- * therefore threw during Vite dev pre-bundle evaluation in browsers and killed
- * client-side hydration for every consuming app.
- *
- * vite-node's module runner itself needs `process.platform` to load inline
- * modules, so the test cannot delete `process` outright the way a real browser
- * lacks it. Stubbing it to an object without a usable `env` reproduces the
- * same failure mode: the pre-fix module init still blows up at import time
- * (`Object.keys(process.env)`), and the fixed guard must route to the plain
- * console logger.
- */
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-describe('internal/logger', () => {
-    beforeEach(() => {
-        vi.resetModules();
-    });
-    afterEach(() => {
-        vi.unstubAllGlobals();
-        vi.restoreAllMocks();
-    });
-    it('imports and logs without a usable process.env (browser)', async () => {
-        vi.stubGlobal('process', {});
-        const { logger } = await import('./logger.js');
-        const warn = vi.spyOn(console, 'warn').mockImplementation(() => { });
-        logger.warn('mic permission denied');
-        expect(warn).toHaveBeenCalledTimes(1);
-        expect(warn.mock.calls[0][0]).toContain('mic permission denied');
-    });
-    it('filters below the warn level in the browser fallback', async () => {
-        vi.stubGlobal('process', {});
-        const { logger } = await import('./logger.js');
-        const debug = vi.spyOn(console, 'debug').mockImplementation(() => { });
-        const info = vi.spyOn(console, 'info').mockImplementation(() => { });
-        const error = vi.spyOn(console, 'error').mockImplementation(() => { });
-        logger.debug('below threshold');
-        logger.info('below threshold');
-        logger.error('stt init failed');
-        expect(debug).not.toHaveBeenCalled();
-        expect(info).not.toHaveBeenCalled();
-        expect(error).toHaveBeenCalledTimes(1);
-    });
-    it('logs through the env-aware logger when process exists (node/SSR)', async () => {
-        const { logger } = await import('./logger.js');
-        const warn = vi.spyOn(console, 'warn').mockImplementation(() => { });
-        logger.warn('stt init failed', { adapter: 'whisper-cpp' });
-        expect(warn).toHaveBeenCalledTimes(1);
-        expect(warn.mock.calls[0][0]).toContain('stt init failed');
-    });
-});

package/dist/provider-mode.test.js

@@ -1,86 +0,0 @@
-import { render, screen, waitFor } from '@testing-library/svelte';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import Harness from './__tests__/provider-mode-harness.svelte';
-import { createAppState, SmrtAppStateManager, } from './state/app-state.svelte.js';
-let initializationModes;
-let manager;
-const capture = (state) => {
-    manager = state;
-};
-beforeEach(() => {
-    initializationModes = [];
-    vi.stubGlobal('SpeechRecognition', class {
-    });
-    const initialize = SmrtAppStateManager.prototype.initialize;
-    vi.spyOn(SmrtAppStateManager.prototype, 'initialize').mockImplementation(function () {
-        const result = initialize.call(this);
-        // Inspect the real initialization boundary before a later reactive effect
-        // can hide a transient auto-enabled mode.
-        initializationModes.push(this.state.mode);
-        return result;
-    });
-    vi.spyOn(SmrtAppStateManager.prototype, 'initializeSTT').mockResolvedValue({});
-});
-afterEach(() => {
-    vi.restoreAllMocks();
-    vi.unstubAllGlobals();
-});
-describe('Provider voice opt-in', () => {
-    it('keeps defaults in standard mode even with speech capabilities', async () => {
-        render(Harness, { props: { capture } });
-        await waitFor(() => expect(manager.state.initialized).toBe(true));
-        expect(manager.state.capabilities?.stt.browserSpeechAPI).toBe(true);
-        expect(manager.state.mode).toBe('default');
-        expect(initializationModes).toEqual(['default']);
-        expect(manager.initializeSTT).not.toHaveBeenCalled();
-    });
-    it('honors explicit default before initialization despite auto-detection opt-in', async () => {
-        render(Harness, {
-            props: { capture, mode: 'default', autoEnableSmrt: true },
-        });
-        await waitFor(() => expect(manager.state.initialized).toBe(true));
-        expect(initializationModes).toEqual(['default']);
-        expect(manager.state.modeSource).toBe('explicit');
-        expect(manager.initializeSTT).not.toHaveBeenCalled();
-    });
-    it('preserves explicit smrt mode and reactive mode updates', async () => {
-        const view = render(Harness, { props: { capture, mode: 'smrt' } });
-        await waitFor(() => expect(manager.state.initialized).toBe(true));
-        expect(initializationModes).toEqual(['smrt']);
-        expect(manager.state.modeSource).toBe('explicit');
-        await view.rerender({ capture, mode: 'default' });
-        expect(screen.getByRole('status', { name: 'App mode' })).toHaveTextContent('default');
-    });
-    it('retains auto-detection behind the explicit flag', async () => {
-        render(Harness, { props: { capture, autoEnableSmrt: true } });
-        await waitFor(() => expect(manager.state.initialized).toBe(true));
-        expect(manager.state.mode).toBe('smrt');
-        expect(manager.state.modeSource).toBe('auto');
-    });
-    it('does not auto-enable when capabilities are unavailable', async () => {
-        vi.stubGlobal('SpeechRecognition', undefined);
-        const capability = await import('./browser-ai/capabilities/detector.js');
-        vi.spyOn(capability, 'canEnableSmrtMode').mockReturnValue(false);
-        render(Harness, { props: { capture, autoEnableSmrt: true } });
-        await waitFor(() => expect(manager.state.initialized).toBe(true));
-        expect(manager.state.mode).toBe('default');
-    });
-    it('standalone state also requires explicit opt-in and respects initial session preferences', async () => {
-        const standard = createAppState();
-        await standard.initialize();
-        expect(standard.state.mode).toBe('default');
-        const auto = createAppState({
-            session: { preferences: { autoEnableSmrt: true } },
-        });
-        await auto.initialize();
-        expect(auto.state.mode).toBe('smrt');
-        const explicit = createAppState({
-            initialMode: 'default',
-            session: { preferences: { autoEnableSmrt: true } },
-        });
-        await explicit.initialize();
-        expect(explicit.state.mode).toBe('default');
-        expect(explicit.state.modeSource).toBe('explicit');
-        await Promise.all([standard.dispose(), auto.dispose(), explicit.dispose()]);
-    });
-});

package/dist/provider-webmcp.test.js

@@ -1,244 +0,0 @@
-import { render, waitFor } from '@testing-library/svelte';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { logger } from './internal/logger.js';
-const { registerWebMcpTools } = vi.hoisted(() => ({
-    registerWebMcpTools: vi.fn(),
-}));
-vi.mock('@happyvertical/smrt-web', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        registerWebMcpTools: (...args) => {
-            registerWebMcpTools(...args);
-            return actual.registerWebMcpTools(...args);
-        },
-    };
-});
-import Harness from './__tests__/provider-webmcp-harness.svelte';
-describe('Provider WebMCP policy', () => {
-    beforeEach(() => {
-        registerWebMcpTools.mockClear();
-        document.modelContext = undefined;
-    });
-    it('passes the same exposure policy to the framework-agnostic registrar', async () => {
-        const filter = vi.fn(() => true);
-        const filterTool = vi.fn(() => true);
-        const resolveFetchers = vi.fn();
-        const resolveToolFetchers = vi.fn();
-        const definitions = [];
-        render(Harness, {
-            props: {
-                webmcp: {
-                    definitions,
-                    effects: ['read', 'write'],
-                    namespace: 'workspace',
-                    maxTools: 12,
-                    basePath: '/api/v2',
-                    scope: 'tenant-a',
-                    filter,
-                    filterTool,
-                    resolveFetchers,
-                    resolveToolFetchers,
-                },
-            },
-        });
-        await waitFor(() => expect(registerWebMcpTools).toHaveBeenCalledOnce());
-        expect(registerWebMcpTools).toHaveBeenCalledWith(definitions, {
-            client: undefined,
-            basePath: '/api/v2',
-            fetchFn: undefined,
-            scope: 'tenant-a',
-            filter,
-            filterTool,
-            resolveFetchers,
-            resolveToolFetchers,
-            effects: ['read', 'write'],
-            namespace: 'workspace',
-            maxTools: 12,
-        });
-    });
-    it('registers the same real tool set as direct registration', async () => {
-        const definitions = [
-            {
-                name: 'reports',
-                objectRef: '@test/smrt-svelte:Report',
-                className: 'Report',
-                endpoint: '/reports',
-                idField: 'id',
-                actions: ['list', 'create'],
-                fields: {},
-                toolDescriptors: [
-                    {
-                        action: 'list',
-                        name: 'report_list',
-                        description: 'List reports',
-                        inputSchema: { type: 'object' },
-                        readOnly: true,
-                        effect: 'read',
-                        idempotent: true,
-                        openWorld: false,
-                    },
-                    {
-                        action: 'create',
-                        name: 'report_create',
-                        description: 'Create a report',
-                        inputSchema: { type: 'object' },
-                        readOnly: false,
-                        effect: 'write',
-                        idempotent: false,
-                        openWorld: false,
-                    },
-                ],
-            },
-            {
-                collection: 'audits',
-                objectRef: '@test/smrt-svelte:Audit',
-                className: 'Audit',
-                endpoint: '/audits',
-                idField: 'id',
-                idType: 'uuid',
-                relationships: [],
-                action: 'get',
-                name: 'audit_get',
-                description: 'Get an audit record',
-                inputSchema: { type: 'object' },
-                readOnly: true,
-                effect: 'read',
-                idempotent: true,
-                openWorld: false,
-                route: { method: 'GET', scope: 'item', path: [] },
-            },
-        ];
-        const resolveFetchers = (definition) => {
-            definition.actions.length = 0;
-            return {
-                list: async () => [],
-                create: async (data) => data,
-            };
-        };
-        const resolveToolFetchers = (definition) => {
-            definition.action = 'delete';
-            return { get: async () => ({ id: 'a1' }) };
-        };
-        const policy = {
-            definitions,
-            effects: ['read', 'write'],
-            namespace: 'workspace',
-            maxTools: 4,
-            filter: () => true,
-            filterTool: (tool) => tool.collection === 'audits',
-            resolveFetchers: vi.fn(resolveFetchers),
-            resolveToolFetchers: vi.fn(resolveToolFetchers),
-        };
-        const captured = [];
-        const installRegistry = () => {
-            captured.length = 0;
-            document.modelContext = {
-                async registerTool(tool) {
-                    captured.push({ name: tool.name, annotations: tool.annotations });
-                },
-            };
-        };
-        installRegistry();
-        const { registerWebMcpTools: directRegister } = await vi.importActual('@happyvertical/smrt-web');
-        directRegister(definitions, policy);
-        const direct = structuredClone(captured);
-        installRegistry();
-        render(Harness, { props: { webmcp: policy } });
-        await waitFor(() => expect(registerWebMcpTools).toHaveBeenCalledOnce());
-        expect(captured).toEqual(direct);
-        expect(captured.map((tool) => tool.name)).toEqual([
-            'workspace_report_list',
-            'workspace_report_create',
-            'workspace_audit_get',
-        ]);
-        expect(policy.resolveFetchers).toHaveBeenCalledTimes(2);
-        expect(policy.resolveToolFetchers).toHaveBeenCalledTimes(2);
-    });
-    it('defaults generated data tools to read-only exposure', async () => {
-        const captured = [];
-        document.modelContext = {
-            async registerTool(tool) {
-                captured.push(tool.name);
-            },
-        };
-        const definitions = [
-            {
-                name: 'reports',
-                objectRef: '@test/smrt-svelte:Report',
-                className: 'Report',
-                endpoint: '/reports',
-                idField: 'id',
-                actions: ['list', 'create'],
-                fields: {},
-                toolDescriptors: [
-                    {
-                        action: 'list',
-                        name: 'report_list',
-                        description: 'List reports',
-                        inputSchema: { type: 'object' },
-                        readOnly: true,
-                        effect: 'read',
-                        idempotent: true,
-                        openWorld: false,
-                    },
-                    {
-                        action: 'create',
-                        name: 'report_create',
-                        description: 'Create a report',
-                        inputSchema: { type: 'object' },
-                        readOnly: false,
-                        effect: 'write',
-                        idempotent: false,
-                        openWorld: false,
-                    },
-                ],
-            },
-        ];
-        render(Harness, { props: { webmcp: { definitions } } });
-        await waitFor(() => expect(registerWebMcpTools).toHaveBeenCalledOnce());
-        expect(captured).toEqual(['report_list']);
-    });
-    it('reports rejected generated data-tool policies without an unhandled rejection', async () => {
-        const warn = vi.spyOn(logger, 'warn').mockImplementation(() => { });
-        document.modelContext = { registerTool: vi.fn() };
-        render(Harness, {
-            props: { webmcp: { definitions: [], maxTools: -1 } },
-        });
-        await waitFor(() => expect(warn).toHaveBeenCalledWith('Provider: WebMCP data tool registration rejected', {
-            error: expect.objectContaining({
-                message: 'WebMCP maxTools must be a non-negative safe integer',
-            }),
-        }));
-    });
-    it('reports asynchronous browser registration rejection', async () => {
-        const warn = vi.spyOn(logger, 'warn').mockImplementation(() => { });
-        document.modelContext = {
-            registerTool: () => Promise.reject(new Error('browser rejected tool')),
-        };
-        const definitions = [
-            {
-                collection: 'audits',
-                objectRef: '@test/smrt-svelte:Audit',
-                className: 'Audit',
-                endpoint: '/audits',
-                idField: 'id',
-                idType: 'uuid',
-                relationships: [],
-                action: 'get',
-                name: 'audit_get',
-                description: 'Get an audit record',
-                inputSchema: { type: 'object' },
-                readOnly: true,
-                effect: 'read',
-                idempotent: true,
-                openWorld: false,
-                route: { method: 'GET', scope: 'item', path: [] },
-            },
-        ];
-        render(Harness, { props: { webmcp: { definitions } } });
-        await waitFor(() => expect(warn).toHaveBeenCalledWith('Provider: WebMCP data tool registration rejected', {
-            error: expect.objectContaining({ message: 'browser rejected tool' }),
-        }));
-    });
-});