@happyvertical/smrt-svelte 0.43.2 → 0.43.4

package/dist/provider-webmcp.test.js

@@ -0,0 +1,244 @@
+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' }),
+        }));
+    });
+});

package/dist/web/__tests__/provider-ui-registry.fixture.svelte

@@ -0,0 +1,43 @@
+<script lang="ts">
+import type {
+  ControlInteractionEvent,
+  ControlInteractionRegistry,
+} from '@happyvertical/smrt-ui/forms';
+import Form from '../../components/forms/Form.svelte';
+import TextInput from '../../components/forms/TextInput.svelte';
+import Provider from '../../Provider.svelte';
+
+let {
+  providerRegistry,
+  explicitRegistry,
+  enableUi = true,
+  onSharedInteraction,
+  onSiblingInteraction,
+  showSibling = true,
+}: {
+  providerRegistry: ControlInteractionRegistry;
+  explicitRegistry: ControlInteractionRegistry;
+  enableUi?: boolean;
+  onSharedInteraction?: (event: ControlInteractionEvent) => void;
+  onSiblingInteraction?: (event: ControlInteractionEvent) => void;
+  showSibling?: boolean;
+} = $props();
+</script>
+
+<Provider
+  webmcp={enableUi
+    ? { ui: { controlRegistry: providerRegistry } }
+    : { definitions: [] }}
+>
+  <Form formId="shared-form" oninteraction={onSharedInteraction}>
+    <TextInput name="shared-name" label="Shared name" />
+  </Form>
+  {#if showSibling}
+    <Form formId="sibling-form" oninteraction={onSiblingInteraction}>
+      <TextInput name="sibling-name" label="Sibling name" />
+    </Form>
+  {/if}
+  <Form formId="explicit-form" interactionRegistry={explicitRegistry}>
+    <TextInput name="explicit-name" label="Explicit name" />
+  </Form>
+</Provider>

package/dist/web/__tests__/provider-ui-registry.fixture.svelte.d.ts

@@ -0,0 +1,13 @@
+import type { ControlInteractionEvent, ControlInteractionRegistry } from '@happyvertical/smrt-ui/forms';
+type $$ComponentProps = {
+    providerRegistry: ControlInteractionRegistry;
+    explicitRegistry: ControlInteractionRegistry;
+    enableUi?: boolean;
+    onSharedInteraction?: (event: ControlInteractionEvent) => void;
+    onSiblingInteraction?: (event: ControlInteractionEvent) => void;
+    showSibling?: boolean;
+};
+declare const ProviderUiRegistry: import("svelte").Component<$$ComponentProps, {}, "">;
+type ProviderUiRegistry = ReturnType<typeof ProviderUiRegistry>;
+export default ProviderUiRegistry;
+//# sourceMappingURL=provider-ui-registry.fixture.svelte.d.ts.map

package/dist/web/__tests__/provider-ui-registry.fixture.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-ui-registry.fixture.svelte.d.ts","sourceRoot":"","sources":["../../../src/web/__tests__/provider-ui-registry.fixture.svelte.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,uBAAuB,EACvB,0BAA0B,EAC3B,MAAM,8BAA8B,CAAC;AAKrC,KAAK,gBAAgB,GAAI;IACxB,gBAAgB,EAAE,0BAA0B,CAAC;IAC7C,gBAAgB,EAAE,0BAA0B,CAAC;IAC7C,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,mBAAmB,CAAC,EAAE,CAAC,KAAK,EAAE,uBAAuB,KAAK,IAAI,CAAC;IAC/D,oBAAoB,CAAC,EAAE,CAAC,KAAK,EAAE,uBAAuB,KAAK,IAAI,CAAC;IAChE,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAmCF,QAAA,MAAM,kBAAkB,sDAAwC,CAAC;AACjE,KAAK,kBAAkB,GAAG,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAChE,eAAe,kBAAkB,CAAC"}

package/dist/web/__tests__/provider-ui-registry.test.js

@@ -0,0 +1,235 @@
+import { createControlInteractionRegistry } from '@happyvertical/smrt-ui/forms';
+import { render } from '@testing-library/svelte';
+import { tick } from 'svelte';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import Fixture from './provider-ui-registry.fixture.svelte';
+afterEach(() => {
+    delete document.modelContext;
+});
+describe('Provider WebMCP UI registry context', () => {
+    it('aggregates descendant forms while preserving explicit registry overrides', async () => {
+        const providerRegistry = createControlInteractionRegistry();
+        const explicitRegistry = createControlInteractionRegistry();
+        const signals = [];
+        const names = [];
+        document.modelContext = {
+            async registerTool(tool, options) {
+                names.push(tool.name);
+                if (options?.signal)
+                    signals.push(options.signal);
+            },
+        };
+        const view = render(Fixture, {
+            props: { providerRegistry, explicitRegistry },
+        });
+        await tick();
+        expect(names).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',
+        ]);
+        expect(providerRegistry.list().map((entry) => entry.identity)).toEqual([
+            { formId: 'shared-form', controlId: 'shared-name' },
+            { formId: 'sibling-form', controlId: 'sibling-name' },
+        ]);
+        expect(explicitRegistry.list().map((entry) => entry.identity)).toEqual([
+            { formId: 'explicit-form', controlId: 'explicit-name' },
+        ]);
+        view.unmount();
+        expect(providerRegistry.list()).toEqual([]);
+        expect(explicitRegistry.list()).toEqual([]);
+        expect(signals).toHaveLength(6);
+        expect(signals.every((signal) => signal.aborted)).toBe(true);
+    });
+    it('keeps form interaction callbacks scoped when forms share a Provider registry', async () => {
+        const providerRegistry = createControlInteractionRegistry();
+        const onSharedInteraction = vi.fn();
+        const onSiblingInteraction = vi.fn();
+        const view = render(Fixture, {
+            props: {
+                providerRegistry,
+                explicitRegistry: createControlInteractionRegistry(),
+                onSharedInteraction,
+                onSiblingInteraction,
+            },
+        });
+        await tick();
+        onSharedInteraction.mockClear();
+        onSiblingInteraction.mockClear();
+        await providerRegistry.execute({
+            action: 'stage',
+            identity: { formId: 'sibling-form', controlId: 'sibling-name' },
+            value: 'private sibling value',
+        });
+        expect(onSharedInteraction).not.toHaveBeenCalled();
+        expect(onSiblingInteraction).toHaveBeenCalled();
+        expect(onSiblingInteraction.mock.calls.every(([event]) => event.identity.formId === 'sibling-form')).toBe(true);
+        view.unmount();
+    });
+    it('moves mounted controls when the Provider registry changes', async () => {
+        const firstRegistry = createControlInteractionRegistry();
+        const secondRegistry = createControlInteractionRegistry();
+        const explicitRegistry = createControlInteractionRegistry();
+        const view = render(Fixture, {
+            props: { providerRegistry: firstRegistry, explicitRegistry },
+        });
+        await tick();
+        expect(firstRegistry.list()).toHaveLength(2);
+        await view.rerender({
+            providerRegistry: secondRegistry,
+            explicitRegistry,
+        });
+        await tick();
+        expect(firstRegistry.list()).toEqual([]);
+        expect(secondRegistry.list()).toHaveLength(2);
+        view.unmount();
+    });
+    it('preserves staged sibling state when another field unmounts', async () => {
+        const providerRegistry = createControlInteractionRegistry();
+        const explicitRegistry = createControlInteractionRegistry();
+        const view = render(Fixture, {
+            props: { providerRegistry, explicitRegistry },
+        });
+        await tick();
+        await providerRegistry.execute({
+            action: 'stage',
+            identity: { formId: 'shared-form', controlId: 'shared-name' },
+            value: 'keep staged',
+        });
+        await view.rerender({
+            providerRegistry,
+            explicitRegistry,
+            showSibling: false,
+        });
+        await tick();
+        expect(providerRegistry.get({
+            formId: 'shared-form',
+            controlId: 'shared-name',
+        })?.state.stagedValue).toBe('keep staged');
+        view.unmount();
+    });
+    it('retries a shared identity after the existing registration unmounts', async () => {
+        const providerRegistry = createControlInteractionRegistry();
+        const unregisterExisting = providerRegistry.register({
+            identity: { formId: 'shared-form', controlId: 'shared-name' },
+            metadata: { kind: 'text', label: 'Existing' },
+            getValue: () => 'existing value',
+        });
+        const view = render(Fixture, {
+            props: {
+                providerRegistry,
+                explicitRegistry: createControlInteractionRegistry(),
+            },
+        });
+        await tick();
+        expect(providerRegistry.get({
+            formId: 'shared-form',
+            controlId: 'shared-name',
+        })?.state.value).toBe('existing value');
+        unregisterExisting();
+        await tick();
+        expect(providerRegistry.get({
+            formId: 'shared-form',
+            controlId: 'shared-name',
+        })?.metadata.label).toBe('Shared name');
+        view.unmount();
+        expect(providerRegistry.get({
+            formId: 'shared-form',
+            controlId: 'shared-name',
+        })).toBeUndefined();
+    });
+    it('recovers after its shared identity is displaced and removed', async () => {
+        const providerRegistry = createControlInteractionRegistry();
+        const view = render(Fixture, {
+            props: {
+                providerRegistry,
+                explicitRegistry: createControlInteractionRegistry(),
+            },
+        });
+        await tick();
+        const unregisterReplacement = providerRegistry.register({
+            identity: { formId: 'shared-form', controlId: 'shared-name' },
+            metadata: { kind: 'text', label: 'Replacement' },
+            getValue: () => 'replacement value',
+        });
+        await tick();
+        expect(providerRegistry.get({
+            formId: 'shared-form',
+            controlId: 'shared-name',
+        })?.state.value).toBe('replacement value');
+        unregisterReplacement();
+        await tick();
+        expect(providerRegistry.get({
+            formId: 'shared-form',
+            controlId: 'shared-name',
+        })?.metadata.label).toBe('Shared name');
+        view.unmount();
+    });
+    it('contains duplicate Provider prefixes without crashing the app', async () => {
+        const names = [];
+        document.modelContext = {
+            async registerTool(tool) {
+                names.push(tool.name);
+            },
+        };
+        const first = render(Fixture, {
+            props: {
+                providerRegistry: createControlInteractionRegistry(),
+                explicitRegistry: createControlInteractionRegistry(),
+            },
+        });
+        await tick();
+        const second = render(Fixture, {
+            props: {
+                providerRegistry: createControlInteractionRegistry(),
+                explicitRegistry: createControlInteractionRegistry(),
+            },
+        });
+        await tick();
+        expect(names).toHaveLength(6);
+        second.unmount();
+        first.unmount();
+    });
+    it('isolates throwing interaction observers from registry command outcomes', async () => {
+        const providerRegistry = createControlInteractionRegistry();
+        const view = render(Fixture, {
+            props: {
+                providerRegistry,
+                explicitRegistry: createControlInteractionRegistry(),
+                onSiblingInteraction: () => {
+                    throw new Error('observer failed');
+                },
+            },
+        });
+        await tick();
+        await expect(providerRegistry.execute({
+            action: 'stage',
+            identity: { formId: 'sibling-form', controlId: 'sibling-name' },
+            value: 'still staged',
+        })).resolves.toMatchObject({ ok: true, action: 'stage' });
+        view.unmount();
+    });
+    it('preserves legacy object configs that did not opt into UI tools', async () => {
+        const names = [];
+        const providerRegistry = createControlInteractionRegistry();
+        document.modelContext = {
+            async registerTool(tool) {
+                names.push(tool.name);
+            },
+        };
+        const view = render(Fixture, {
+            props: {
+                providerRegistry,
+                explicitRegistry: createControlInteractionRegistry(),
+                enableUi: false,
+            },
+        });
+        await tick();
+        expect(names).toEqual([]);
+        expect(providerRegistry.list()).toEqual([]);
+        view.unmount();
+    });
+});

package/dist/web/__tests__/remote-query-harness.svelte

@@ -0,0 +1,27 @@
+<script lang="ts">
+import type {
+  SmrtWebCollection,
+  SmrtWebQueryTransport,
+} from '@happyvertical/smrt-web';
+import {
+  type RemoteQueryBinding,
+  remoteQuery,
+} from '../remote-query.svelte.js';
+
+interface Props {
+  collection: SmrtWebCollection<Record<string, unknown>>;
+  transport: SmrtWebQueryTransport;
+  onReady: (view: RemoteQueryBinding<Record<string, unknown>>) => void;
+}
+
+const props: Props = $props();
+// The harness intentionally creates one binding for its component lifetime.
+// svelte-ignore state_referenced_locally
+const view = remoteQuery(props.collection, props.transport);
+// svelte-ignore state_referenced_locally
+props.onReady(view);
+</script>
+
+<output data-testid="remote-query-state">
+  {view.request?.requestId ?? 'none'}:{view.rows.map((row) => row.id).join(',')}
+</output>

package/dist/web/__tests__/remote-query-harness.svelte.d.ts

@@ -0,0 +1,11 @@
+import type { SmrtWebCollection, SmrtWebQueryTransport } from '@happyvertical/smrt-web';
+import { type RemoteQueryBinding } from '../remote-query.svelte.js';
+interface Props {
+    collection: SmrtWebCollection<Record<string, unknown>>;
+    transport: SmrtWebQueryTransport;
+    onReady: (view: RemoteQueryBinding<Record<string, unknown>>) => void;
+}
+declare const RemoteQueryHarness: import("svelte").Component<Props, {}, "">;
+type RemoteQueryHarness = ReturnType<typeof RemoteQueryHarness>;
+export default RemoteQueryHarness;
+//# sourceMappingURL=remote-query-harness.svelte.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"remote-query-harness.svelte.d.ts","sourceRoot":"","sources":["../../../src/web/__tests__/remote-query-harness.svelte.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,iBAAiB,EACjB,qBAAqB,EACtB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,KAAK,kBAAkB,EAExB,MAAM,2BAA2B,CAAC;AAGnC,UAAU,KAAK;IACb,UAAU,EAAE,iBAAiB,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACvD,SAAS,EAAE,qBAAqB,CAAC;IACjC,OAAO,EAAE,CAAC,IAAI,EAAE,kBAAkB,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,KAAK,IAAI,CAAC;CACtE;AAoBD,QAAA,MAAM,kBAAkB,2CAAwC,CAAC;AACjE,KAAK,kBAAkB,GAAG,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAChE,eAAe,kBAAkB,CAAC"}

package/dist/web/__tests__/remote-query.svelte.test.js

@@ -0,0 +1,100 @@
+import { createSmrtCollection, } from '@happyvertical/smrt-web';
+import { flushSync, mount, unmount } from 'svelte';
+import { describe, expect, it, vi } from 'vitest';
+import Harness from './remote-query-harness.svelte';
+const definition = {
+    name: 'remote-query-svelte-products',
+    className: 'Product',
+    endpoint: '/products',
+    idField: 'id',
+    actions: ['list'],
+    fields: { name: { type: 'text' } },
+};
+const request = {
+    version: 1,
+    requestId: 'svelte-request',
+    mode: 'rows',
+    page: { kind: 'offset', offset: 0, limit: 10 },
+};
+function envelope(received, name) {
+    return {
+        version: 1,
+        requestId: received.requestId,
+        queryFingerprint: 'dq1_svelte_products',
+        identityField: 'id',
+        rows: [{ id: name, name }],
+        page: { kind: 'offset', offset: 0, limit: 10, hasMore: false },
+        total: { kind: 'exact', value: 1 },
+        freshness: { state: 'fresh' },
+        warnings: [],
+        truncated: false,
+    };
+}
+function mountView(collection, transport) {
+    const target = document.createElement('div');
+    document.body.appendChild(target);
+    let view = undefined;
+    const component = mount(Harness, {
+        target,
+        props: {
+            collection: collection,
+            transport,
+            onReady: (next) => {
+                view = next;
+            },
+        },
+    });
+    return {
+        target,
+        view,
+        teardown: () => {
+            unmount(component);
+            target.remove();
+        },
+    };
+}
+describe('remoteQuery', () => {
+    it('renders request and rows reactively through the Svelte binding', async () => {
+        const collection = createSmrtCollection(definition, {
+            fetchers: { list: async () => [], create: async () => ({}) },
+        });
+        const mounted = mountView(collection, {
+            query: async (received) => envelope(received, 'Ada'),
+        });
+        await mounted.view.execute(request);
+        flushSync();
+        expect(mounted.target.textContent).toContain('svelte-request:Ada');
+        mounted.teardown();
+        await collection.cleanup();
+    });
+    it('disposes an in-flight refresh and live subscription when unmounted', async () => {
+        let calls = 0;
+        let unsubscribed = false;
+        const collection = createSmrtCollection(definition, {
+            fetchers: { list: async () => [], create: async () => ({}) },
+        });
+        const mounted = mountView(collection, {
+            query: async (received, options) => {
+                calls += 1;
+                if (calls === 1)
+                    return envelope(received, 'initial');
+                return await new Promise((_resolve, reject) => {
+                    options?.signal?.addEventListener('abort', () => reject(options.signal?.reason), { once: true });
+                });
+            },
+            subscribe: () => ({
+                unsubscribe: () => {
+                    unsubscribed = true;
+                },
+            }),
+        });
+        await mounted.view.execute(request);
+        mounted.view.subscribeLive();
+        const refresh = mounted.view.refresh();
+        await vi.waitFor(() => expect(calls).toBe(2));
+        mounted.teardown();
+        await expect(refresh).rejects.toMatchObject({ name: 'AbortError' });
+        expect(unsubscribed).toBe(true);
+        await collection.cleanup();
+    });
+});