@happyvertical/smrt-svelte 0.43.4 → 0.43.6

package/dist/web/__tests__/webmcp-composed.integration.svelte.test.js

@@ -0,0 +1,247 @@
+/**
+ * Mounted UI half of the application composition fixture (#2523).
+ *
+ * A real Provider owns a Form and DataTable at once. This catches lifecycle
+ * mistakes that isolated registry tests miss: controls must be discoverable,
+ * the DataSurface must be present, and an agent stage request must not apply a
+ * value without a human gesture.
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { APIGenerator, field, ObjectRegistry, SmrtCollection, SmrtObject, smrt, } from '@happyvertical/smrt-core';
+import { ManifestGenerator } from '@happyvertical/smrt-core/scanner';
+import { getTestDatabase } from '@happyvertical/smrt-core/testing';
+import { ManifestAdapter, OxcScanner } from '@happyvertical/smrt-scanner';
+import { createDataSurfaceRegistry } from '@happyvertical/smrt-ui/data';
+import { svelte } from '@sveltejs/vite-plugin-svelte';
+import { render } from '@testing-library/svelte';
+import { tick } from 'svelte';
+import { createServer } from 'vite';
+import { afterAll, afterEach, beforeAll, describe, expect, it, vi, } from 'vitest';
+import { buildWebMcpToolDefinitions } from '../../../../core/src/vite-plugin/web-collections.js';
+import Fixture from './webmcp-composed.fixture.svelte';
+import SsrFixture from './webmcp-ssr.fixture.svelte';
+let WebMcpComposedFixtureItem = class WebMcpComposedFixtureItem extends SmrtObject {
+    name = '';
+};
+__decorate([
+    field({ type: 'text' })
+], WebMcpComposedFixtureItem.prototype, "name", void 0);
+WebMcpComposedFixtureItem = __decorate([
+    smrt({ api: { include: ['get'] } })
+], WebMcpComposedFixtureItem);
+class WebMcpComposedFixtureItemCollection extends SmrtCollection {
+    static _itemClass = WebMcpComposedFixtureItem;
+}
+ObjectRegistry.registerCollection('WebMcpComposedFixtureItem', WebMcpComposedFixtureItemCollection);
+afterEach(() => {
+    delete document.modelContext;
+});
+describe('composed Provider WebMCP surface (#2523)', () => {
+    let generatedReadDefinition;
+    let generatedRowId = '';
+    let db;
+    let handler;
+    const baseUrl = 'http://fixture.local/api/v1';
+    beforeAll(async () => {
+        const scanner = new OxcScanner({
+            cwd: process.cwd(),
+            include: ['src/web/__tests__/webmcp-composed.integration.svelte.test.ts'],
+            exclude: [],
+            followImports: true,
+            baseClasses: ['SmrtObject', 'SmrtCollection'],
+            includeStaticMethods: true,
+        });
+        const { results, resolved } = await scanner.scanAndResolve();
+        const manifest = new ManifestAdapter().toManifest(resolved, {
+            packageName: '@fixture/smrt-svelte',
+            typeAliases: results.typeAliases,
+        });
+        new ManifestGenerator().applyGenerationPasses(manifest, {
+            packageName: '@fixture/smrt-svelte',
+        });
+        const generated = buildWebMcpToolDefinitions(manifest).find((definition) => definition.className === 'WebMcpComposedFixtureItem' &&
+            definition.action === 'get');
+        if (!generated)
+            throw new Error('scanner did not emit the fixture get tool');
+        generatedReadDefinition = generated;
+        db = await getTestDatabase({
+            type: 'sqlite',
+            url: ':memory:',
+            classes: ['WebMcpComposedFixtureItem'],
+        });
+        const collection = await WebMcpComposedFixtureItemCollection.create({ db });
+        const row = await collection.create({ name: 'generated read' });
+        generatedRowId = row.id;
+        const api = new APIGenerator({
+            basePath: '/api/v1',
+            authMiddleware: () => async (request) => {
+                if (request.headers.get('authorization') !== 'Bearer fixture-user') {
+                    return new Response('auth required', { status: 401 });
+                }
+                return request;
+            },
+        }, { db });
+        api.registerCollection('webmcpcomposedfixtureitems', collection);
+        handler = api.generateHandler();
+    });
+    afterAll(async () => {
+        await db?.close?.();
+    });
+    function authenticatedFetch() {
+        return (async (input, init) => {
+            const requestUrl = new URL(String(input), `${baseUrl}/`);
+            const headers = new Headers(init?.headers);
+            headers.set('authorization', 'Bearer fixture-user');
+            return handler(new Request(requestUrl, { ...init, headers }));
+        });
+    }
+    it('keeps the composed UI render safe without browser modelContext support', async () => {
+        const dataSurfaceRegistry = createDataSurfaceRegistry();
+        const view = render(Fixture, { props: { dataSurfaceRegistry } });
+        await tick();
+        expect(dataSurfaceRegistry.list()).toHaveLength(1);
+        view.unmount();
+        expect(dataSurfaceRegistry.list()).toEqual([]);
+    });
+    it('renders the Provider composition through the server runtime', async () => {
+        const vite = await createServer({
+            appType: 'custom',
+            configFile: false,
+            plugins: [svelte()],
+            root: process.cwd(),
+            server: { middlewareMode: true },
+        });
+        const originalDocument = globalThis.document;
+        try {
+            delete globalThis.document;
+            const { default: ssrFixture } = await vite.ssrLoadModule('/src/web/__tests__/webmcp-ssr.fixture.svelte');
+            const { render: renderSsr } = await vite.ssrLoadModule('svelte/server');
+            const result = renderSsr(ssrFixture);
+            expect(result.body).toContain('webmcp-ssr-fixture');
+        }
+        finally {
+            if (originalDocument === undefined) {
+                delete globalThis.document;
+            }
+            else {
+                globalThis.document = originalDocument;
+            }
+            await vite.close();
+        }
+    });
+    it('registers the mounted Form and DataTable together and preserves consent', async () => {
+        const registered = [];
+        document.modelContext = {
+            async registerTool(tool, options) {
+                registered.push({ ...tool, signal: options?.signal });
+            },
+        };
+        const dataSurfaceRegistry = createDataSurfaceRegistry();
+        const fetchFn = authenticatedFetch();
+        const generatedDefinitions = [generatedReadDefinition];
+        const view = render(Fixture, {
+            props: {
+                dataSurfaceRegistry,
+                generatedDefinitions,
+                fetchFn,
+            },
+        });
+        await tick();
+        await tick();
+        await vi.waitFor(() => expect(registered.map((tool) => tool.name)).toContain(generatedReadDefinition.name));
+        expect(registered.map((tool) => tool.name)).toEqual(expect.arrayContaining([
+            'smrt_ui_list_form_controls',
+            'smrt_ui_inspect_form_control',
+            'smrt_ui_execute_form_control',
+            'smrt_ui_list_data_surfaces',
+            'smrt_ui_inspect_data_surface',
+            'smrt_ui_execute_data_surface_control',
+            'fixture_component_preview',
+            generatedReadDefinition.name,
+        ]));
+        expect(registered).toHaveLength(8);
+        expect(dataSurfaceRegistry.list()).toHaveLength(1);
+        const titleInput = view.container.querySelector('input[name="title"]');
+        expect(titleInput?.value).toBe('');
+        const listControls = registered.find((tool) => tool.name === 'smrt_ui_list_form_controls');
+        if (!listControls)
+            throw new Error('list form-controls tool was not registered');
+        expect(JSON.parse(await listControls.execute({}))).toMatchObject({
+            ok: true,
+            result: [{ identity: { formId: 'fixture-form', controlId: 'title' } }],
+        });
+        const executeForm = registered.find((tool) => tool.name === 'smrt_ui_execute_form_control');
+        if (!executeForm)
+            throw new Error('execute form-control tool was not registered');
+        const staged = JSON.parse(await executeForm.execute({
+            action: 'stage',
+            identity: { formId: 'fixture-form', controlId: 'title' },
+            value: 'agent proposal',
+        }));
+        expect(staged).toMatchObject({ result: { ok: true, action: 'stage' } });
+        expect(titleInput?.value).toBe('');
+        const applied = JSON.parse(await executeForm.execute({
+            action: 'apply',
+            identity: { formId: 'fixture-form', controlId: 'title' },
+        }));
+        expect(applied).toMatchObject({
+            result: { ok: false, reason: 'human_confirmation_required' },
+        });
+        expect(titleInput?.value).toBe('');
+        const generated = registered.find((tool) => tool.name === generatedReadDefinition.name);
+        if (!generated)
+            throw new Error('generated Provider tool was not registered');
+        expect(JSON.parse(await generated.execute({ id: generatedRowId }))).toMatchObject({ name: 'generated read' });
+        const bespoke = registered.find((tool) => tool.name === 'fixture_component_preview');
+        if (!bespoke)
+            throw new Error('bespoke component tool was not registered');
+        expect(JSON.parse(await bespoke.execute({}))).toEqual({
+            ok: true,
+            source: 'bespoke-component',
+        });
+        await view.rerender({
+            dataSurfaceRegistry,
+            generatedDefinitions,
+            fetchFn,
+            showChild: false,
+        });
+        await tick();
+        await tick();
+        expect(dataSurfaceRegistry.list()).toEqual([]);
+        const firstRegistration = registered.slice();
+        expect(firstRegistration
+            .filter((tool) => !tool.signal?.aborted)
+            .map((tool) => tool.name)).toEqual([
+            'smrt_ui_list_form_controls',
+            'smrt_ui_inspect_form_control',
+            'smrt_ui_execute_form_control',
+            'smrt_ui_list_data_surfaces',
+            'smrt_ui_inspect_data_surface',
+            'smrt_ui_execute_data_surface_control',
+            generatedReadDefinition.name,
+        ]);
+        await view.rerender({
+            dataSurfaceRegistry,
+            generatedDefinitions,
+            fetchFn,
+            showChild: true,
+        });
+        await tick();
+        await tick();
+        await vi.waitFor(() => expect(registered).toHaveLength(9));
+        expect(dataSurfaceRegistry.list()).toHaveLength(1);
+        const secondBespoke = registered.filter((tool) => tool.name === 'fixture_component_preview')[1];
+        if (!secondBespoke)
+            throw new Error('remounted bespoke tool was not registered');
+        expect(secondBespoke.name).toBe('fixture_component_preview');
+        expect(secondBespoke.signal?.aborted).toBe(false);
+        expect(registered.filter((tool) => tool.name === 'fixture_component_preview')).toHaveLength(2);
+        view.unmount();
+        expect(registered.every((tool) => tool.signal?.aborted)).toBe(true);
+    });
+});

package/dist/web/__tests__/webmcp-ssr.fixture.svelte

@@ -0,0 +1,13 @@
+<script lang="ts">
+import { createDataSurfaceRegistry } from '@happyvertical/smrt-ui/data';
+import Provider from '../../Provider.svelte';
+import Child from './webmcp-composed.child.fixture.svelte';
+
+const dataSurfaceRegistry = createDataSurfaceRegistry();
+</script>
+
+<Provider webmcp={{ definitions: [], basePath: '/api', effects: ['read'] }}>
+  <div data-testid="webmcp-ssr-fixture">
+    <Child {dataSurfaceRegistry} />
+  </div>
+</Provider>

package/dist/web/__tests__/webmcp-ssr.fixture.svelte.d.ts

@@ -0,0 +1,19 @@
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const WebmcpSsr: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type WebmcpSsr = InstanceType<typeof WebmcpSsr>;
+export default WebmcpSsr;
+//# sourceMappingURL=webmcp-ssr.fixture.svelte.d.ts.map

package/dist/web/__tests__/webmcp-ssr.fixture.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webmcp-ssr.fixture.svelte.d.ts","sourceRoot":"","sources":["../../../src/web/__tests__/webmcp-ssr.fixture.svelte.ts"],"names":[],"mappings":"AAuBA,UAAU,kCAAkC,CAAC,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,EAAE,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,EAAE,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,EAAE,OAAO,GAAG,EAAE,EAAE,QAAQ,GAAG,MAAM;IACpM,KAAK,OAAO,EAAE,OAAO,QAAQ,EAAE,2BAA2B,CAAC,KAAK,CAAC,GAAG,OAAO,QAAQ,EAAE,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,GAAG;QAAE,UAAU,CAAC,EAAE,QAAQ,CAAA;KAAE,GAAG,OAAO,CAAC;IACjK,CAAC,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,KAAK,CAAA;KAAC,GAAG,OAAO,GAAG;QAAE,IAAI,CAAC,EAAE,GAAG,CAAC;QAAC,GAAG,CAAC,EAAE,GAAG,CAAA;KAAE,CAAC;IACtG,YAAY,CAAC,EAAE,QAAQ,CAAC;CAC3B;AAKD,QAAA,MAAM,SAAS;;kBAA+E,CAAC;AAC7E,KAAK,SAAS,GAAG,YAAY,CAAC,OAAO,SAAS,CAAC,CAAC;AAClD,eAAe,SAAS,CAAC"}

package/dist/web/__tests__/webmcp-ui.test.js

@@ -114,7 +114,7 @@ describe('registerWebMcpUiTools', () => {
         const identity = { formId: 'profile', controlId: 'name' };
         expect((await parse(execute.execute({ action: 'stage', identity, value: 'Grace' }))).result).toMatchObject({ ok: true, action: 'stage' });
         expect(value).toBe('Ada');
-        expect((await parse(execute.execute({ action: 'apply', identity }))).result).toMatchObject({ ok: false, reason: 'consent_required' });
+        expect((await parse(execute.execute({ action: 'apply', identity }))).result).toMatchObject({ ok: false, reason: 'human_confirmation_required' });
         expect(value).toBe('Ada');
         expect(await parse(execute.execute({
             action: 'apply',
@@ -123,6 +123,70 @@ describe('registerWebMcpUiTools', () => {
         }))).toEqual({ ok: false, reason: 'invalid_request', details: 'confirmed' });
         expect(value).toBe('Ada');
     });
+    it('returns the canonical values staged by general form-control tools', async () => {
+        const browser = modelContext();
+        const controls = createControlInteractionRegistry();
+        const identities = {
+            checkbox: { formId: 'base', controlId: 'enabled' },
+            number: { formId: 'base', controlId: 'count' },
+            option: { formId: 'base', controlId: 'role' },
+        };
+        controls.register({
+            identity: identities.checkbox,
+            metadata: { kind: 'checkbox' },
+            getValue: () => false,
+            setValue: () => undefined,
+            prepareValue: (next) => {
+                if (typeof next !== 'boolean')
+                    throw new Error('staged_value_invalid');
+                return next;
+            },
+        });
+        controls.register({
+            identity: identities.number,
+            metadata: { kind: 'number' },
+            getValue: () => 0,
+            setValue: () => undefined,
+            prepareValue: (next) => Number(next),
+        });
+        controls.register({
+            identity: identities.option,
+            metadata: {
+                kind: 'listbox',
+                options: [{ value: 1, label: 'Admin' }],
+            },
+            getValue: () => 1,
+            setValue: () => undefined,
+            prepareValue: (next) => {
+                if (String(next) !== '1')
+                    throw new Error('staged_value_invalid');
+                return 1;
+            },
+        });
+        registerWebMcpUiTools({
+            controlRegistry: controls,
+            dataSurfaceRegistry: createDataSurfaceRegistry(),
+            document: browser.document,
+        });
+        const execute = findTool(browser.registered, 'smrt_ui_execute_form_control');
+        expect(await parse(execute.execute({
+            action: 'stage',
+            identity: identities.checkbox,
+            value: {},
+        }))).toMatchObject({
+            ok: true,
+            result: { ok: false, reason: 'execution_failed' },
+        });
+        expect(controls.get(identities.checkbox)?.state.staged).toBeUndefined();
+        for (const [identity, value, staged] of [
+            [identities.number, '42', 42],
+            [identities.option, '1', 1],
+        ]) {
+            const response = await parse(execute.execute({ action: 'stage', identity, value }));
+            expect(response).toMatchObject({ ok: true, result: { ok: true } });
+            expect(response.result.snapshot.state.staged.value).toEqual(staged);
+        }
+    });
     it('keeps secret values redacted from list, inspect, and execute responses', async () => {
         const browser = modelContext();
         const controls = createControlInteractionRegistry();
@@ -188,38 +252,86 @@ describe('registerWebMcpUiTools', () => {
         expect(result).toEqual({ ok: false, reason: 'execution_failed' });
         expect(JSON.stringify(result)).not.toContain('customer 4711');
     });
-    it('redacts secret values from an injected registry even when its flags are inconsistent', async () => {
-        const browser = modelContext();
-        const snapshot = {
-            identity: { formId: 'injected', controlId: 'secret' },
-            metadata: { kind: 'password', sensitivity: 'secret' },
-            state: {
-                value: 'injected-secret-value',
-                valueRedacted: false,
-                stagedValue: 'injected-staged-secret',
-                stagedValueRedacted: false,
-            },
-        };
-        const controls = {
-            register: () => () => { },
-            unregister: () => { },
-            list: () => [snapshot],
-            get: () => snapshot,
-            execute: async (command) => ({
-                ok: true,
-                action: command.action,
-                identity: command.identity,
-                snapshot,
-            }),
-            subscribe: () => () => { },
-        };
-        registerWebMcpUiTools({
-            controlRegistry: controls,
-            dataSurfaceRegistry: createDataSurfaceRegistry(),
-            document: browser.document,
-        });
-        const list = await parse(findTool(browser.registered, 'smrt_ui_list_form_controls').execute({}));
-        expect(JSON.stringify(list)).not.toContain('injected-secret');
+    it('redacts sensitive injected snapshots and result text despite inconsistent flags', async () => {
+        for (const sensitivity of ['secret', 'sensitive']) {
+            const marker = `injected-${sensitivity}-value`;
+            const browser = modelContext();
+            const snapshot = {
+                identity: { formId: 'injected', controlId: sensitivity },
+                metadata: {
+                    kind: 'password',
+                    sensitivity,
+                    capabilities: ['discard'],
+                },
+                state: {
+                    value: marker,
+                    valueRedacted: false,
+                    stagedValue: `${marker}-staged`,
+                    stagedValueRedacted: false,
+                    validationMessage: `${marker} validation`,
+                    staged: {
+                        value: `${marker}-nested`,
+                        valueRedacted: false,
+                        provenance: { source: 'agent' },
+                        stagedAt: 1,
+                        revision: 1,
+                        stale: false,
+                        validationMessage: `${marker} nested validation`,
+                    },
+                },
+            };
+            const controls = {
+                register: () => () => { },
+                unregister: () => { },
+                list: () => [snapshot],
+                get: () => snapshot,
+                execute: async (command) => ({
+                    ok: false,
+                    action: command.action,
+                    identity: command.identity,
+                    reason: `${marker} reason`,
+                    validationMessage: `${marker} result validation`,
+                    snapshot,
+                }),
+                subscribe: () => () => { },
+            };
+            registerWebMcpUiTools({
+                controlRegistry: controls,
+                dataSurfaceRegistry: createDataSurfaceRegistry(),
+                document: browser.document,
+            });
+            const identity = { formId: 'injected', controlId: sensitivity };
+            const list = await parse(findTool(browser.registered, 'smrt_ui_list_form_controls').execute({}));
+            const inspect = await parse(findTool(browser.registered, 'smrt_ui_inspect_form_control').execute({
+                identity,
+            }));
+            const executed = await parse(findTool(browser.registered, 'smrt_ui_execute_form_control').execute({
+                action: 'focus',
+                identity,
+            }));
+            expect(JSON.stringify([list, inspect, executed])).not.toContain(marker);
+            for (const result of [
+                list.result[0],
+                inspect.result,
+                executed.result.snapshot,
+            ]) {
+                expect(result.metadata.capabilities).toEqual(['discard']);
+                expect(result.state).toMatchObject({
+                    valueRedacted: true,
+                    stagedValueRedacted: true,
+                    staged: {
+                        valueRedacted: true,
+                    },
+                });
+                expect(result.state).not.toHaveProperty('value');
+                expect(result.state).not.toHaveProperty('stagedValue');
+                expect(result.state).not.toHaveProperty('validationMessage');
+                expect(result.state.staged).not.toHaveProperty('value');
+                expect(result.state.staged).not.toHaveProperty('validationMessage');
+            }
+            expect(executed.result.reason).toBe('execution_failed');
+            expect(executed.result).not.toHaveProperty('validationMessage');
+        }
     });
     it('filters hidden columns and preserves surface revision and replay failures', async () => {
         const browser = modelContext();
@@ -407,4 +519,68 @@ describe('registerWebMcpUiTools', () => {
         expect(() => registerWebMcpUiTools({ ...registries, document })).not.toThrow();
         expect(calls).toBe(6);
     });
+    it('observes asynchronous host rejection, aborts tools, and releases only its own lock', async () => {
+        let rejectFirstRegistration;
+        const signals = [];
+        let calls = 0;
+        const document = {
+            modelContext: {
+                registerTool(_tool, options) {
+                    calls += 1;
+                    if (options?.signal)
+                        signals.push(options.signal);
+                    if (calls === 1) {
+                        return new Promise((_resolve, reject) => {
+                            rejectFirstRegistration = reject;
+                        });
+                    }
+                },
+            },
+        };
+        const registries = {
+            controlRegistry: createControlInteractionRegistry(),
+            dataSurfaceRegistry: createDataSurfaceRegistry(),
+        };
+        const disposeFirst = registerWebMcpUiTools({ ...registries, document });
+        disposeFirst();
+        const disposeReplacement = registerWebMcpUiTools({
+            ...registries,
+            document,
+        });
+        rejectFirstRegistration?.(new Error('late host collision'));
+        await Promise.resolve();
+        await Promise.resolve();
+        expect(signals.slice(0, 6).every((signal) => signal.aborted)).toBe(true);
+        expect(signals.slice(6).every((signal) => !signal.aborted)).toBe(true);
+        expect(() => registerWebMcpUiTools({ ...registries, document })).toThrow('already registered');
+        disposeReplacement();
+        expect(() => registerWebMcpUiTools({ ...registries, document })).not.toThrow();
+    });
+    it('releases an active prefix when asynchronous host registration fails', async () => {
+        const signals = [];
+        let rejectRegistration;
+        const document = {
+            modelContext: {
+                registerTool(_tool, options) {
+                    if (options?.signal)
+                        signals.push(options.signal);
+                    if (!rejectRegistration) {
+                        return new Promise((_resolve, reject) => {
+                            rejectRegistration = reject;
+                        });
+                    }
+                },
+            },
+        };
+        const registries = {
+            controlRegistry: createControlInteractionRegistry(),
+            dataSurfaceRegistry: createDataSurfaceRegistry(),
+        };
+        registerWebMcpUiTools({ ...registries, document });
+        rejectRegistration?.(new Error('host collision'));
+        await Promise.resolve();
+        await Promise.resolve();
+        expect(signals.every((signal) => signal.aborted)).toBe(true);
+        expect(() => registerWebMcpUiTools({ ...registries, document })).not.toThrow();
+    });
 });

package/dist/web/__tests__/webmcp.test.js

@@ -30,6 +30,26 @@ describe('useWebMcpTool', () => {
         view.unmount();
         expect(registered[1].signal?.aborted).toBe(true);
     });
+    it('observes asynchronous host rejection and aborts the failed registration', async () => {
+        let rejectRegistration;
+        let signal;
+        document.modelContext = {
+            registerTool(_tool, options) {
+                signal = options?.signal;
+                return new Promise((_resolve, reject) => {
+                    rejectRegistration = reject;
+                });
+            },
+        };
+        const view = render(Harness);
+        await tick();
+        expect(signal?.aborted).toBe(false);
+        rejectRegistration?.(new Error('host collision'));
+        await Promise.resolve();
+        await Promise.resolve();
+        expect(signal?.aborted).toBe(true);
+        view.unmount();
+    });
     it('is a no-op when WebMCP is unavailable', async () => {
         const view = render(Harness);
         await tick();

package/dist/web/webmcp-ui.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webmcp-ui.d.ts","sourceRoot":"","sources":["../../src/web/webmcp-ui.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,mBAAmB,EAGzB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAIV,0BAA0B,EAE3B,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AA6CzD,MAAM,WAAW,4BAA4B;IAC3C,eAAe,EAAE,0BAA0B,CAAC;IAC5C,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,sEAAsE;IACtE,QAAQ,CAAC,EAAE;QAAE,YAAY,CAAC,EAAE,sBAAsB,CAAA;KAAE,CAAC;CACtD;AAED,UAAU,sBAAsB;IAC9B,YAAY,CACV,IAAI,EAAE,cAAc,EACpB,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GACjC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB;AA4eD,4EAA4E;AAC5E,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,4BAA4B,GACpC,MAAM,IAAI,CA+CZ"}
+{"version":3,"file":"webmcp-ui.d.ts","sourceRoot":"","sources":["../../src/web/webmcp-ui.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,mBAAmB,EAGzB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAKV,0BAA0B,EAE3B,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AA8CzD,MAAM,WAAW,4BAA4B;IAC3C,eAAe,EAAE,0BAA0B,CAAC;IAC5C,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,sEAAsE;IACtE,QAAQ,CAAC,EAAE;QAAE,YAAY,CAAC,EAAE,sBAAsB,CAAA;KAAE,CAAC;CACtD;AAED,UAAU,sBAAsB;IAC9B,YAAY,CACV,IAAI,EAAE,cAAc,EACpB,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GACjC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB;AA6fD,4EAA4E;AAC5E,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,4BAA4B,GACpC,MAAM,IAAI,CAoDZ"}