@happyvertical/smrt-svelte 0.43.10 → 0.44.0

package/dist/web/__tests__/view-intent.svelte.test.js

@@ -0,0 +1,201 @@
+/**
+ * The Svelte binding for declarative view intents (#2588).
+ *
+ * The contract, registry, and compilation are covered in
+ * `@happyvertical/smrt-web` (`src/intents.test.ts`). What is proven HERE is
+ * the binding: that a declared intent reaches WebMCP through the shared
+ * `useWebMcpTool` lifecycle and the Provider's exposure policy, and that
+ * executing it moves only mounted registry state.
+ */
+import { createDataSurfaceRegistry } from '@happyvertical/smrt-ui/data';
+import { createControlInteractionRegistry } from '@happyvertical/smrt-ui/forms';
+import { render } from '@testing-library/svelte';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+const registerBespokeSpy = vi.hoisted(() => vi.fn());
+vi.mock('@happyvertical/smrt-web', async (importOriginal) => {
+    const actual = await importOriginal();
+    registerBespokeSpy.mockImplementation(actual.registerWebMcpBespokeTool);
+    return { ...actual, registerWebMcpBespokeTool: registerBespokeSpy };
+});
+import Fixture from './view-intent.fixture.svelte';
+import { clearNotesIntent, nextPageIntent, revealNotesIntent, stageNotesIntent, } from './view-intent.intents.js';
+import ProviderFixture from './view-intent-provider.fixture.svelte';
+function installModelContext() {
+    const registered = [];
+    document.modelContext = {
+        async registerTool(tool, options) {
+            registered.push({ ...tool, signal: options?.signal });
+        },
+    };
+    return registered;
+}
+/**
+ * A Provider that enables the UI adapter also registers the six fixed
+ * `smrt_ui_*` tools into the same array, so every Provider-mounted assertion
+ * selects by NAME rather than by index or length — the pattern
+ * `webmcp-composed.integration.svelte.test.ts` already established.
+ */
+function toolNamed(registered, name) {
+    return registered.find((tool) => tool.name === name);
+}
+function mountedControlRegistry() {
+    const registry = createControlInteractionRegistry();
+    let value = 'before';
+    registry.register({
+        identity: { formId: 'order-form', controlId: 'notes' },
+        metadata: { kind: 'text', label: 'Notes', readable: true, writable: true },
+        getValue: () => value,
+        setValue: (next) => {
+            value = String(next);
+        },
+    });
+    return registry;
+}
+afterEach(() => {
+    document.modelContext = undefined;
+    registerBespokeSpy.mockClear();
+    vi.restoreAllMocks();
+});
+describe('useViewIntent', () => {
+    it('registers a declared intent on mount and deregisters on unmount', async () => {
+        const registered = installModelContext();
+        const view = render(Fixture, {
+            props: {
+                intent: revealNotesIntent,
+                identity: { formId: 'order-form', controlId: 'notes' },
+                controlRegistry: mountedControlRegistry(),
+            },
+        });
+        await vi.waitFor(() => expect(registered).toHaveLength(1));
+        expect(registered[0].name).toBe('fixture_reveal_notes');
+        expect(registered[0].annotations).toMatchObject({
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+            untrustedContentHint: true,
+        });
+        expect(registered[0].signal?.aborted).toBe(false);
+        view.unmount();
+        expect(registered[0].signal?.aborted).toBe(true);
+    });
+    it('routes through registerWebMcpBespokeTool, never document.modelContext directly', async () => {
+        installModelContext();
+        render(Fixture, {
+            props: {
+                intent: revealNotesIntent,
+                identity: { formId: 'order-form', controlId: 'notes' },
+                controlRegistry: mountedControlRegistry(),
+            },
+        });
+        await vi.waitFor(() => expect(registerBespokeSpy).toHaveBeenCalledTimes(1));
+        expect(registerBespokeSpy.mock.calls[0][0]).toMatchObject({
+            name: 'fixture_reveal_notes',
+        });
+    });
+    it('resolves the mounted registries from the nearest Provider', async () => {
+        const registered = installModelContext();
+        const registry = mountedControlRegistry();
+        render(ProviderFixture, {
+            props: {
+                intent: revealNotesIntent,
+                identity: { formId: 'order-form', controlId: 'notes' },
+                providerRegistry: registry,
+            },
+        });
+        await vi.waitFor(() => expect(toolNamed(registered, 'fixture_reveal_notes')).toBeDefined());
+    });
+    it("applies the Provider's effects policy to an intent", async () => {
+        const registered = installModelContext();
+        // `clearNotesIntent` declares no capability, so it classifies
+        // fail-closed as destructive and a read-only Provider excludes it.
+        render(ProviderFixture, {
+            props: {
+                intent: clearNotesIntent,
+                identity: { formId: 'order-form', controlId: 'notes' },
+                providerRegistry: mountedControlRegistry(),
+                effects: ['read'],
+            },
+        });
+        await vi.waitFor(() => expect(registerBespokeSpy).toHaveBeenCalledTimes(1));
+        expect(registerBespokeSpy.mock.calls[0][1]).toEqual({ effects: ['read'] });
+        // The six fixed `smrt_ui_*` tools register alongside it; only the intent
+        // must be absent.
+        expect(toolNamed(registered, 'fixture_clear_notes')).toBeUndefined();
+    });
+    it('executes by dispatching one agent-sourced registry command', async () => {
+        const registered = installModelContext();
+        const registry = mountedControlRegistry();
+        const executeSpy = vi.spyOn(registry, 'execute');
+        const fetchSpy = vi.spyOn(globalThis, 'fetch');
+        render(ProviderFixture, {
+            props: {
+                intent: stageNotesIntent,
+                identity: { formId: 'order-form', controlId: 'notes' },
+                providerRegistry: registry,
+                effects: ['read', 'write'],
+            },
+        });
+        await vi.waitFor(() => expect(toolNamed(registered, 'fixture_stage_notes')).toBeDefined());
+        const tool = toolNamed(registered, 'fixture_stage_notes');
+        if (!tool)
+            throw new Error('intent tool was not registered');
+        await tool.execute({ value: 'after' });
+        expect(fetchSpy).not.toHaveBeenCalled();
+        const staged = executeSpy.mock.calls.find(([command]) => command.action === 'stage');
+        if (!staged)
+            throw new Error('intent did not dispatch a stage command');
+        expect(staged[0]).toEqual({
+            action: 'stage',
+            identity: { formId: 'order-form', controlId: 'notes' },
+            value: 'after',
+        });
+        // Agent-staged values stay proposals: the command is dispatched as
+        // `source: 'agent'`, so StagedControlReview and the local-gesture
+        // requirement apply unchanged.
+        expect(staged[1]).toEqual({ source: 'agent' });
+    });
+    it('binds a data-surface intent to a mounted surface identity', async () => {
+        const registered = installModelContext();
+        const registry = createDataSurfaceRegistry();
+        const executeSpy = vi.spyOn(registry, 'execute');
+        render(Fixture, {
+            props: {
+                intent: nextPageIntent,
+                identity: { surfaceId: 'orders-table', kind: 'table' },
+                dataSurfaceRegistry: registry,
+            },
+        });
+        await vi.waitFor(() => expect(registered).toHaveLength(1));
+        expect(registered[0].name).toBe('fixture_next_page');
+        // Nothing is mounted under that identity, so the intent reports
+        // not_found rather than inventing a command.
+        expect(JSON.parse(String(await registered[0].execute({})))).toEqual({
+            ok: false,
+            reason: 'not_found',
+        });
+        expect(executeSpy).not.toHaveBeenCalled();
+    });
+    it('is a no-op with no Provider and no explicit registry', async () => {
+        const registered = installModelContext();
+        render(Fixture, {
+            props: {
+                intent: revealNotesIntent,
+                identity: { formId: 'order-form', controlId: 'notes' },
+            },
+        });
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(registered).toHaveLength(0);
+        expect(registerBespokeSpy).not.toHaveBeenCalled();
+    });
+    it('rejects an identity that does not match the declared target registry', () => {
+        installModelContext();
+        expect(() => render(Fixture, {
+            props: {
+                intent: revealNotesIntent,
+                identity: { surfaceId: 'orders-table', kind: 'table' },
+                controlRegistry: mountedControlRegistry(),
+            },
+        })).toThrow(/needs a \{ formId, controlId \} identity/);
+    });
+});

package/dist/web/__tests__/webmcp-composed.child.fixture.svelte

@@ -20,6 +20,17 @@ useWebMcpTool(() => ({
   execute: () => JSON.stringify({ ok: true, source: 'bespoke-component' }),
 }));
 
+// No `annotations`: fail-closed classifies this destructive (#2586), so it
+// must be excluded under the Provider's default read-only exposure policy
+// and must never reach document.modelContext.registerTool.
+useWebMcpTool(() => ({
+  name: 'fixture_component_unannotated',
+  description: 'A bespoke tool with no declared effect.',
+  inputSchema: { type: 'object', properties: {} },
+  execute: () =>
+    JSON.stringify({ ok: true, source: 'bespoke-component-unannotated' }),
+}));
+
 const tableDescriptor: DataSurfaceDescriptor = {
   version: 1,
   identity: { surfaceId: 'fixture-items', kind: 'table' },

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

@@ -1 +1 @@
-{"version":3,"file":"webmcp-composed.child.fixture.svelte.d.ts","sourceRoot":"","sources":["../../../src/web/__tests__/webmcp-composed.child.fixture.svelte.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAStE,KAAK,gBAAgB,GAAI;IAAE,mBAAmB,EAAE,mBAAmB,CAAA;CAAE,CAAC;AAyDvE,QAAA,MAAM,cAAc,sDAAwC,CAAC;AAC7D,KAAK,cAAc,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AACxD,eAAe,cAAc,CAAC"}
+{"version":3,"file":"webmcp-composed.child.fixture.svelte.d.ts","sourceRoot":"","sources":["../../../src/web/__tests__/webmcp-composed.child.fixture.svelte.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAStE,KAAK,gBAAgB,GAAI;IAAE,mBAAmB,EAAE,mBAAmB,CAAA;CAAE,CAAC;AAoEvE,QAAA,MAAM,cAAc,sDAAwC,CAAC;AAC7D,KAAK,cAAc,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AACxD,eAAe,cAAc,CAAC"}

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

@@ -204,6 +204,10 @@ describe('composed Provider WebMCP surface (#2523)', () => {
             ok: true,
             source: 'bespoke-component',
         });
+        // #2586: a bespoke tool with no declared effect classifies destructive
+        // and is excluded under the Provider's default read-only policy — it
+        // must never reach document.modelContext.registerTool.
+        expect(registered.some((tool) => tool.name === 'fixture_component_unannotated')).toBe(false);
         await view.rerender({
             dataSurfaceRegistry,
             generatedDefinitions,

package/dist/web/__tests__/webmcp-effects-reactivity.child.fixture.svelte

@@ -0,0 +1,16 @@
+<script lang="ts">
+import { useWebMcpTool } from '../webmcp.svelte.js';
+
+// Declared destructive so it registers only under a Provider policy that
+// explicitly allows `destructive` — used to prove a later Provider policy
+// change is observed by `useWebMcpTool`'s effect (#2586 F2).
+useWebMcpTool(() => ({
+  name: 'reactivity_destructive_tool',
+  description: 'Destructive bespoke tool for Provider effects reactivity',
+  inputSchema: { type: 'object', properties: {} },
+  annotations: { readOnlyHint: false, destructiveHint: true },
+  execute: () => 'destroyed',
+}));
+</script>
+
+<span>reactivity-destructive-tool</span>

package/dist/web/__tests__/webmcp-effects-reactivity.child.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 WebmcpEffectsReactivity: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type WebmcpEffectsReactivity = InstanceType<typeof WebmcpEffectsReactivity>;
+export default WebmcpEffectsReactivity;
+//# sourceMappingURL=webmcp-effects-reactivity.child.fixture.svelte.d.ts.map

package/dist/web/__tests__/webmcp-effects-reactivity.child.fixture.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webmcp-effects-reactivity.child.fixture.svelte.d.ts","sourceRoot":"","sources":["../../../src/web/__tests__/webmcp-effects-reactivity.child.fixture.svelte.ts"],"names":[],"mappings":"AAwBA,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,uBAAuB;;kBAA+E,CAAC;AAC3F,KAAK,uBAAuB,GAAG,YAAY,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAC9E,eAAe,uBAAuB,CAAC"}

package/dist/web/__tests__/webmcp-effects-reactivity.fixture.svelte

@@ -0,0 +1,11 @@
+<script lang="ts">
+import type { WebMcpToolEffect } from '@happyvertical/smrt-web';
+import Provider from '../../Provider.svelte';
+import ReactivityChild from './webmcp-effects-reactivity.child.fixture.svelte';
+
+let { effects }: { effects: readonly WebMcpToolEffect[] } = $props();
+</script>
+
+<Provider webmcp={{ definitions: [], effects }}>
+  <ReactivityChild />
+</Provider>

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

@@ -0,0 +1,8 @@
+import type { WebMcpToolEffect } from '@happyvertical/smrt-web';
+type $$ComponentProps = {
+    effects: readonly WebMcpToolEffect[];
+};
+declare const WebmcpEffectsReactivity: import("svelte").Component<$$ComponentProps, {}, "">;
+type WebmcpEffectsReactivity = ReturnType<typeof WebmcpEffectsReactivity>;
+export default WebmcpEffectsReactivity;
+//# sourceMappingURL=webmcp-effects-reactivity.fixture.svelte.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"webmcp-effects-reactivity.fixture.svelte.d.ts","sourceRoot":"","sources":["../../../src/web/__tests__/webmcp-effects-reactivity.fixture.svelte.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAI/D,KAAK,gBAAgB,GAAI;IAAE,OAAO,EAAE,SAAS,gBAAgB,EAAE,CAAA;CAAE,CAAC;AAenE,QAAA,MAAM,uBAAuB,sDAAwC,CAAC;AACtE,KAAK,uBAAuB,GAAG,UAAU,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAC1E,eAAe,uBAAuB,CAAC"}

package/dist/web/__tests__/webmcp-harness-reactive-samename.svelte

@@ -0,0 +1,20 @@
+<script lang="ts">
+import { useWebMcpTool } from '../webmcp.svelte.js';
+
+// Same registered NAME on every render; only `description` changes, so each
+// prop change still replaces the spec object and reruns useWebMcpTool's
+// effect (#2586 F2's reactive `bespokeContext.effects` read applies to any
+// reactive spec, not only one driven by Provider policy) while exercising
+// same-name re-registration serialization.
+let { version = 1 }: { version?: number } = $props();
+
+useWebMcpTool(() => ({
+  name: 'harness_reactive_tool',
+  description: `Reactive tool v${version}`,
+  inputSchema: { type: 'object' },
+  annotations: { readOnlyHint: true },
+  execute: () => String(version),
+}));
+</script>
+
+<span>{version}</span>

package/dist/web/__tests__/webmcp-harness-reactive-samename.svelte.d.ts

@@ -0,0 +1,7 @@
+type $$ComponentProps = {
+    version?: number;
+};
+declare const WebmcpHarnessReactiveSamename: import("svelte").Component<$$ComponentProps, {}, "">;
+type WebmcpHarnessReactiveSamename = ReturnType<typeof WebmcpHarnessReactiveSamename>;
+export default WebmcpHarnessReactiveSamename;
+//# sourceMappingURL=webmcp-harness-reactive-samename.svelte.d.ts.map

package/dist/web/__tests__/webmcp-harness-reactive-samename.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webmcp-harness-reactive-samename.svelte.d.ts","sourceRoot":"","sources":["../../../src/web/__tests__/webmcp-harness-reactive-samename.svelte.ts"],"names":[],"mappings":"AAKC,KAAK,gBAAgB,GAAI;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAwB/C,QAAA,MAAM,6BAA6B,sDAAwC,CAAC;AAC5E,KAAK,6BAA6B,GAAG,UAAU,CAAC,OAAO,6BAA6B,CAAC,CAAC;AACtF,eAAe,6BAA6B,CAAC"}

package/dist/web/__tests__/webmcp-harness-unannotated.svelte

@@ -0,0 +1,14 @@
+<script lang="ts">
+import { useWebMcpTool } from '../webmcp.svelte.js';
+
+// No `annotations`: fail-closed classifies this destructive, so it must be
+// excluded under the registrar's default read-only exposure policy (#2586).
+useWebMcpTool(() => ({
+  name: 'harness_tool_unannotated',
+  description: 'A lifecycle test tool with no declared effect',
+  inputSchema: { type: 'object' },
+  execute: () => 'unannotated',
+}));
+</script>
+
+<span>unannotated</span>

package/dist/web/__tests__/webmcp-harness-unannotated.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 WebmcpHarnessUnannotated: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type WebmcpHarnessUnannotated = InstanceType<typeof WebmcpHarnessUnannotated>;
+export default WebmcpHarnessUnannotated;
+//# sourceMappingURL=webmcp-harness-unannotated.svelte.d.ts.map

package/dist/web/__tests__/webmcp-harness-unannotated.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webmcp-harness-unannotated.svelte.d.ts","sourceRoot":"","sources":["../../../src/web/__tests__/webmcp-harness-unannotated.svelte.ts"],"names":[],"mappings":"AAsBA,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,wBAAwB;;kBAA+E,CAAC;AAC5F,KAAK,wBAAwB,GAAG,YAAY,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAChF,eAAe,wBAAwB,CAAC"}

package/dist/web/__tests__/webmcp-harness.svelte

@@ -7,6 +7,10 @@ useWebMcpTool(() => ({
   name: `harness_tool_${version}`,
   description: 'A lifecycle test tool',
   inputSchema: { type: 'object' },
+  // Declared read-only so this lifecycle fixture registers under the
+  // registrar's default read-only exposure policy (#2586). An undeclared
+  // bespoke tool is excluded by default — see the "unannotated" test below.
+  annotations: { readOnlyHint: true },
   execute: () => String(version),
 }));
 </script>

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

@@ -1 +1 @@
-{"version":3,"file":"webmcp-harness.svelte.d.ts","sourceRoot":"","sources":["../../../src/web/__tests__/webmcp-harness.svelte.ts"],"names":[],"mappings":"AAKC,KAAK,gBAAgB,GAAI;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAkB/C,QAAA,MAAM,aAAa,sDAAwC,CAAC;AAC5D,KAAK,aAAa,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC;AACtD,eAAe,aAAa,CAAC"}
+{"version":3,"file":"webmcp-harness.svelte.d.ts","sourceRoot":"","sources":["../../../src/web/__tests__/webmcp-harness.svelte.ts"],"names":[],"mappings":"AAKC,KAAK,gBAAgB,GAAI;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAsB/C,QAAA,MAAM,aAAa,sDAAwC,CAAC;AAC5D,KAAK,aAAa,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC;AACtD,eAAe,aAAa,CAAC"}

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

@@ -1,7 +1,45 @@
 import { render } from '@testing-library/svelte';
 import { tick } from 'svelte';
-import { afterEach, describe, expect, it } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+// Wrap the registrar in a spy so a test can observe *which* policy each
+// `useWebMcpTool` effect run handed it, including runs the policy excludes
+// before they ever reach document.modelContext.registerTool (#2599).
+const registerBespokeSpy = vi.hoisted(() => vi.fn());
+vi.mock('@happyvertical/smrt-web', async (importOriginal) => {
+    const actual = await importOriginal();
+    registerBespokeSpy.mockImplementation(actual.registerWebMcpBespokeTool);
+    return { ...actual, registerWebMcpBespokeTool: registerBespokeSpy };
+});
+import EffectsReactivity from './webmcp-effects-reactivity.fixture.svelte';
 import Harness from './webmcp-harness.svelte';
+import HarnessReactiveSameName from './webmcp-harness-reactive-samename.svelte';
+import HarnessUnannotated from './webmcp-harness-unannotated.svelte';
+/**
+ * Mimics a host that rejects a duplicate tool name while it still considers
+ * an earlier registration of that name live, and only forgets that name one
+ * microtask after the earlier registration's abort signal fires — modeling
+ * a host that does not process deregistration perfectly synchronously with
+ * `AbortController.abort()`.
+ */
+function installCollisionAwareModelContext() {
+    const registered = [];
+    const liveNames = new Set();
+    document.modelContext = {
+        async registerTool(tool, options) {
+            if (liveNames.has(tool.name)) {
+                throw new Error(`host collision: ${tool.name}`);
+            }
+            liveNames.add(tool.name);
+            registered.push({ name: tool.name, signal: options?.signal });
+            options?.signal?.addEventListener('abort', () => {
+                void Promise.resolve().then(() => {
+                    liveNames.delete(tool.name);
+                });
+            });
+        },
+    };
+    return { registered, liveNames };
+}
 function installModelContext() {
     const registered = [];
     document.modelContext = {
@@ -13,18 +51,19 @@ function installModelContext() {
 }
 afterEach(() => {
     delete document.modelContext;
+    registerBespokeSpy.mockClear();
 });
 describe('useWebMcpTool', () => {
     it('registers on mount, aborts on spec changes, and aborts on unmount', async () => {
         const registered = installModelContext();
         const view = render(Harness, { props: { version: 1 } });
-        await tick();
-        expect(registered).toHaveLength(1);
+        // Registration now routes through a dynamically imported registrar
+        // (#2586), so it lands one or more microtasks after mount.
+        await vi.waitFor(() => expect(registered).toHaveLength(1));
         expect(registered[0].name).toBe('harness_tool_1');
         expect(registered[0].signal?.aborted).toBe(false);
         await view.rerender({ version: 2 });
-        await tick();
-        expect(registered).toHaveLength(2);
+        await vi.waitFor(() => expect(registered).toHaveLength(2));
         expect(registered[0].signal?.aborted).toBe(true);
         expect(registered[1].name).toBe('harness_tool_2');
         view.unmount();
@@ -42,12 +81,10 @@ describe('useWebMcpTool', () => {
             },
         };
         const view = render(Harness);
-        await tick();
+        await vi.waitFor(() => expect(signal).toBeDefined());
         expect(signal?.aborted).toBe(false);
         rejectRegistration?.(new Error('host collision'));
-        await Promise.resolve();
-        await Promise.resolve();
-        expect(signal?.aborted).toBe(true);
+        await vi.waitFor(() => expect(signal?.aborted).toBe(true));
         view.unmount();
     });
     it('is a no-op when WebMCP is unavailable', async () => {
@@ -56,4 +93,94 @@ describe('useWebMcpTool', () => {
         expect(view.container).toHaveTextContent('1');
         view.unmount();
     });
+    it('excludes an undeclared tool under the default read-only exposure policy', async () => {
+        const registered = installModelContext();
+        const view = render(HarnessUnannotated);
+        // No Provider ancestor: the hook falls back to the registrar's default
+        // read-only policy. An undeclared spec classifies destructive (#2586)
+        // and must never reach document.modelContext.registerTool.
+        await tick();
+        await tick();
+        await tick();
+        expect(registered).toHaveLength(0);
+        view.unmount();
+        expect(registered).toHaveLength(0);
+    });
+    it('disposes a registered destructive bespoke tool when a Provider policy tightens from destructive to read (#2586 F2)', async () => {
+        const registered = installModelContext();
+        const view = render(EffectsReactivity, {
+            props: { effects: ['destructive'] },
+        });
+        await vi.waitFor(() => expect(registered.map((tool) => tool.name)).toContain('reactivity_destructive_tool'));
+        expect(registered).toHaveLength(1);
+        const first = registered[0];
+        expect(first.signal?.aborted).toBe(false);
+        // `bespokeContext.effects` is read synchronously at the top of the
+        // `$effect` body (the F2 fix), so this Provider policy change is
+        // tracked as a dependency and re-runs the effect: the previously
+        // registered destructive tool is torn down, and re-registration under
+        // the new read-only policy is excluded before it ever reaches
+        // document.modelContext.registerTool again.
+        await view.rerender({ effects: ['read'] });
+        await vi.waitFor(() => expect(first.signal?.aborted).toBe(true));
+        expect(registered).toHaveLength(1);
+        view.unmount();
+    });
+    it('serializes same-name re-registration across rapid reactive reruns without a host collision', async () => {
+        const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        const { registered, liveNames } = installCollisionAwareModelContext();
+        const view = render(HarnessReactiveSameName, { props: { version: 1 } });
+        await vi.waitFor(() => expect(registered.length).toBeGreaterThan(0));
+        // Three reactive reruns in quick succession, all under the SAME tool
+        // name. Without serializing against the previous run's registration
+        // settling, a new run's registration attempt can reach the host before
+        // it has processed the previous run's abort, producing a host
+        // collision — this must never happen.
+        await view.rerender({ version: 2 });
+        await view.rerender({ version: 3 });
+        await view.rerender({ version: 4 });
+        await vi.waitFor(() => {
+            const live = registered.filter((tool) => !tool.signal?.aborted);
+            expect(live).toHaveLength(1);
+            expect(live[0]?.name).toBe('harness_reactive_tool');
+        });
+        expect(liveNames.has('harness_reactive_tool')).toBe(true);
+        expect(warnSpy).not.toHaveBeenCalled();
+        view.unmount();
+        warnSpy.mockRestore();
+    });
+    it('registers a previously-excluded bespoke tool when a Provider policy loosens to permit it (#2599)', async () => {
+        const registered = installModelContext();
+        const view = render(EffectsReactivity, {
+            props: { effects: ['read'] },
+        });
+        // The bespoke tool's static factory declares `destructiveHint: true` and
+        // has no rune dependencies of its own, so under a read-only Provider
+        // policy the registrar classifies it destructive and excludes it before
+        // it ever reaches document.modelContext.registerTool. Wait for that
+        // first evaluation to actually happen under the read-only policy — the
+        // registrar is reached through a dynamic import, so without this the
+        // policy change below could race ahead of the first evaluation and the
+        // test would pass even if the effect never re-ran.
+        await vi.waitFor(() => expect(registerBespokeSpy).toHaveBeenCalledTimes(1));
+        expect(registerBespokeSpy.mock.calls[0][1]).toEqual({
+            effects: ['read'],
+        });
+        expect(registered).toHaveLength(0);
+        // `bespokeContext.effects` is read synchronously at the top of the
+        // `$effect` body, so this Provider policy change is tracked as a
+        // dependency and re-runs the effect even though the component's own
+        // factory never changed: the registrar is consulted again under the
+        // loosened policy and the tool newly registers.
+        await view.rerender({ effects: ['destructive'] });
+        await vi.waitFor(() => expect(registerBespokeSpy).toHaveBeenCalledTimes(2));
+        expect(registerBespokeSpy.mock.calls[1][1]).toEqual({
+            effects: ['destructive'],
+        });
+        await vi.waitFor(() => expect(registered.map((tool) => tool.name)).toContain('reactivity_destructive_tool'));
+        expect(registered).toHaveLength(1);
+        expect(registered[0].signal?.aborted).toBe(false);
+        view.unmount();
+        expect(registered[0].signal?.aborted).toBe(true);
+    });
 });

package/dist/web/view-intent.svelte.d.ts

@@ -0,0 +1,64 @@
+import type { DataSurfaceRegistry } from '@happyvertical/smrt-ui/data';
+import type { ControlInteractionRegistry } from '@happyvertical/smrt-ui/forms';
+import type { ViewIntent, ViewIntentControlIdentity, ViewIntentDataSurfaceIdentity, WebMcpToolEffect } from '@happyvertical/smrt-web';
+/**
+ * The mounted registry identity an intent addresses. Both members carry the
+ * optional `subject`, so a rich form can bind an intent to the right record
+ * when several controls share a `formId`/`controlId`.
+ */
+export type ViewIntentIdentity = ViewIntentControlIdentity | ViewIntentDataSurfaceIdentity;
+export interface UseViewIntentOptions {
+    /**
+     * The mounted identity this intent is bound to for the component's
+     * lifetime. Shape must match the intent's declared target registry:
+     * `{ formId, controlId, subject? }` for a control intent,
+     * `{ surfaceId, kind, subject? }` for a data-surface intent.
+     */
+    identity: ViewIntentIdentity;
+    /**
+     * `effects` exposure-policy fallback, used only when no Provider ancestor
+     * supplies an explicit `webmcp.effects` policy — see
+     * {@link useWebMcpTool}. A Provider's explicit policy always wins.
+     */
+    effects?: readonly WebMcpToolEffect[];
+    /** Override the Provider's control registry (tests, nested hosts). */
+    controlRegistry?: ControlInteractionRegistry;
+    /** Override the Provider's data-surface registry. */
+    dataSurfaceRegistry?: DataSurfaceRegistry;
+}
+/**
+ * Bind a declared view intent (#2588) to this component's mounted registry
+ * identity, for exactly this component's lifetime.
+ *
+ * Svelte is the FIRST binding, not the only one: the declaration contract,
+ * the registry, and the compilation to a browser tool all live in
+ * `@happyvertical/smrt-web` with no Svelte dependency. This file is the thin
+ * part — it resolves the mounted registries from the nearest Provider and
+ * hands the compiled spec to {@link useWebMcpTool}, which already owns the
+ * WebMCP lifecycle: the synchronous Provider policy read, the `options.effects`
+ * fallback, serialized same-name re-registration across effect reruns, and
+ * the lazy `@happyvertical/smrt-web` import.
+ *
+ * Registration therefore goes through `registerWebMcpBespokeTool`, so an
+ * intent is subject to the same fail-closed exposure policy as a generated
+ * model tool. Execution dispatches exactly one registry command with
+ * `source: 'agent'` — `StagedControlReview` stays on the path, agent-staged
+ * values remain proposals, and there is no path to REST.
+ *
+ * Declare the intent itself at module scope in a `.ts` sidecar
+ * (`Foo.intents.ts`) so #2591's scanner can emit it; import it here.
+ *
+ * With no Provider ancestor and no explicit registry override, this is a
+ * silent no-op — an intent with nothing mounted to dispatch to registers
+ * nothing, the same way every WebMCP entry point no-ops off-WebMCP. Because
+ * the registries are resolved INSIDE the tool factory, a Provider that
+ * enables `webmcp.ui` after this component initializes, or that swaps a
+ * registry, re-runs the effect and registers the intent against the current
+ * one rather than staying stuck on what was there at init.
+ *
+ * @throws if `identity` does not match the intent's declared target registry,
+ * or contradicts an identity the declaration pinned — both are author errors,
+ * not environment differences.
+ */
+export declare function useViewIntent(intent: ViewIntent, options: UseViewIntentOptions): void;
+//# sourceMappingURL=view-intent.svelte.d.ts.map

package/dist/web/view-intent.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view-intent.svelte.d.ts","sourceRoot":"","sources":["../../src/web/view-intent.svelte.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AACvE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AAC/E,OAAO,KAAK,EACV,UAAU,EAEV,yBAAyB,EACzB,6BAA6B,EAC7B,gBAAgB,EACjB,MAAM,yBAAyB,CAAC;AASjC;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAC1B,yBAAyB,GACzB,6BAA6B,CAAC;AAElC,MAAM,WAAW,oBAAoB;IACnC;;;;;OAKG;IACH,QAAQ,EAAE,kBAAkB,CAAC;IAC7B;;;;OAIG;IACH,OAAO,CAAC,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACtC,sEAAsE;IACtE,eAAe,CAAC,EAAE,0BAA0B,CAAC;IAC7C,qDAAqD;IACrD,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;CAC3C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,oBAAoB,GAC5B,IAAI,CA8BN"}