@happyvertical/smrt-svelte 0.43.2 → 0.43.4

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

@@ -0,0 +1,410 @@
+import { createDataSurfaceRegistry, } from '@happyvertical/smrt-ui/data';
+import { createControlInteractionRegistry, } from '@happyvertical/smrt-ui/forms';
+import { describe, expect, it, vi } from 'vitest';
+import { registerWebMcpUiTools } from '../webmcp-ui.js';
+function modelContext() {
+    const registered = [];
+    const signals = [];
+    const document = {
+        modelContext: {
+            async registerTool(tool, options) {
+                registered.push(tool);
+                if (options?.signal)
+                    signals.push(options.signal);
+            },
+        },
+    };
+    return { document, registered, signals };
+}
+function parse(value) {
+    return Promise.resolve(value).then((result) => JSON.parse(result));
+}
+function findTool(tools, name) {
+    const tool = tools.find((candidate) => candidate.name === name);
+    if (!tool)
+        throw new Error(`Missing tool: ${name}`);
+    return tool;
+}
+function descriptor() {
+    return {
+        version: 1,
+        identity: { surfaceId: 'content', kind: 'table' },
+        schemaVersion: 1,
+        label: 'Content',
+        rowKey: 'id',
+        columns: [
+            {
+                id: 'id',
+                label: 'ID',
+                capabilities: ['read', 'project'],
+            },
+            {
+                id: 'internal',
+                label: 'Internal',
+                visibility: 'hidden',
+                capabilities: ['read', 'project'],
+            },
+        ],
+        query: {
+            modes: ['rows'],
+            projectableColumnIds: ['id', 'internal'],
+        },
+        controls: [{ id: 'next-page', label: 'Next page' }],
+        actions: [],
+        limits: { maxQueryRows: 50, maxQueryBytes: 10_000, maxSelectionSize: 10 },
+    };
+}
+describe('registerWebMcpUiTools', () => {
+    it('registers one fixed tool set and resolves mounted controls dynamically', async () => {
+        const browser = modelContext();
+        const controls = createControlInteractionRegistry();
+        const surfaces = createDataSurfaceRegistry();
+        const dispose = registerWebMcpUiTools({
+            controlRegistry: controls,
+            dataSurfaceRegistry: surfaces,
+            document: browser.document,
+        });
+        expect(browser.registered.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',
+        ]);
+        expect(browser.registered).toHaveLength(6);
+        const list = findTool(browser.registered, 'smrt_ui_list_form_controls');
+        expect(await parse(list.execute({}))).toEqual({ ok: true, result: [] });
+        let value = 'Ada';
+        const unregister = controls.register({
+            identity: { formId: 'profile', controlId: 'name' },
+            metadata: { kind: 'text', label: 'Name' },
+            getValue: () => value,
+            setValue: (next) => {
+                value = String(next);
+            },
+            focus: vi.fn(),
+        });
+        expect((await parse(list.execute({}))).result).toHaveLength(1);
+        expect(browser.registered).toHaveLength(6);
+        unregister();
+        expect(await parse(list.execute({}))).toEqual({ ok: true, result: [] });
+        dispose();
+        expect(browser.signals).toHaveLength(6);
+        expect(browser.signals.every((signal) => signal.aborted)).toBe(true);
+    });
+    it('uses agent consent semantics and cannot be tricked into confirmation', async () => {
+        const browser = modelContext();
+        const controls = createControlInteractionRegistry();
+        let value = 'Ada';
+        controls.register({
+            identity: { formId: 'profile', controlId: 'name' },
+            metadata: { kind: 'text', label: 'Name' },
+            getValue: () => value,
+            setValue: (next) => {
+                value = String(next);
+            },
+        });
+        registerWebMcpUiTools({
+            controlRegistry: controls,
+            dataSurfaceRegistry: createDataSurfaceRegistry(),
+            document: browser.document,
+        });
+        const execute = findTool(browser.registered, 'smrt_ui_execute_form_control');
+        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(value).toBe('Ada');
+        expect(await parse(execute.execute({
+            action: 'apply',
+            identity,
+            confirmed: true,
+        }))).toEqual({ ok: false, reason: 'invalid_request', details: 'confirmed' });
+        expect(value).toBe('Ada');
+    });
+    it('keeps secret values redacted from list, inspect, and execute responses', async () => {
+        const browser = modelContext();
+        const controls = createControlInteractionRegistry();
+        controls.register({
+            identity: { formId: 'account', controlId: 'password' },
+            metadata: {
+                kind: 'password',
+                label: 'Password',
+                sensitivity: 'secret',
+            },
+            getValue: () => 'never-serialize-this',
+            setValue: () => { },
+            getState: () => ({
+                valid: false,
+                validationMessage: 'never-serialize-this is invalid',
+            }),
+            focus: () => {
+                throw new Error('never-serialize-this cannot be focused');
+            },
+        });
+        registerWebMcpUiTools({
+            controlRegistry: controls,
+            dataSurfaceRegistry: createDataSurfaceRegistry(),
+            document: browser.document,
+        });
+        const list = findTool(browser.registered, 'smrt_ui_list_form_controls');
+        const inspect = findTool(browser.registered, 'smrt_ui_inspect_form_control');
+        const execute = findTool(browser.registered, 'smrt_ui_execute_form_control');
+        const listed = await parse(list.execute({ formId: 'account' }));
+        const inspected = await parse(inspect.execute({
+            identity: { formId: 'account', controlId: 'password' },
+        }));
+        const executed = await parse(execute.execute({
+            action: 'focus',
+            identity: { formId: 'account', controlId: 'password' },
+        }));
+        expect(JSON.stringify([listed, inspected, executed])).not.toContain('never-serialize-this');
+        expect(listed.result[0].state.valueRedacted).toBe(true);
+        expect(inspected.result.state.valueRedacted).toBe(true);
+        expect(executed.result.snapshot.state.valueRedacted).toBe(true);
+        expect(executed.result.snapshot.state).not.toHaveProperty('validationMessage');
+        expect(executed.result.reason).toBe('execution_failed');
+    });
+    it('does not expose host error messages that mimic public failures', async () => {
+        const browser = modelContext();
+        const controls = createControlInteractionRegistry();
+        controls.register({
+            identity: { formId: 'profile', controlId: 'unstable' },
+            metadata: { kind: 'text', label: 'Unstable' },
+            getValue: () => {
+                throw new Error('not_found: private customer 4711');
+            },
+        });
+        registerWebMcpUiTools({
+            controlRegistry: controls,
+            dataSurfaceRegistry: createDataSurfaceRegistry(),
+            document: browser.document,
+        });
+        const inspect = findTool(browser.registered, 'smrt_ui_inspect_form_control');
+        const result = await parse(inspect.execute({
+            identity: { formId: 'profile', controlId: 'unstable' },
+        }));
+        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('filters hidden columns and preserves surface revision and replay failures', async () => {
+        const browser = modelContext();
+        const surfaces = createDataSurfaceRegistry();
+        let revision = 2;
+        let page = 1;
+        surfaces.register({
+            descriptor: descriptor(),
+            getSnapshot: () => ({
+                revision,
+                state: {
+                    page,
+                    internal: 'never-serialize-this',
+                    table: {
+                        version: 3,
+                        state: {
+                            filters: [
+                                { columnId: 'internal', value: 'nested-hidden-filter' },
+                                { columnId: 'id', value: ['internal'] },
+                            ],
+                            sorting: [{ columnId: 'internal', direction: 'asc' }],
+                            columnOrder: ['id', 'internal'],
+                        },
+                    },
+                },
+            }),
+            execute: (_command) => {
+                page += 1;
+                revision += 1;
+            },
+        });
+        registerWebMcpUiTools({
+            controlRegistry: createControlInteractionRegistry(),
+            dataSurfaceRegistry: surfaces,
+            document: browser.document,
+        });
+        const list = findTool(browser.registered, 'smrt_ui_list_data_surfaces');
+        const inspect = findTool(browser.registered, 'smrt_ui_inspect_data_surface');
+        const execute = findTool(browser.registered, 'smrt_ui_execute_data_surface_control');
+        const identity = { surfaceId: 'content', kind: 'table' };
+        expect((await parse(list.execute({}))).result[0].columns).toHaveLength(1);
+        const snapshot = (await parse(inspect.execute({ identity }))).result;
+        expect(snapshot.descriptor.query.projectableColumnIds).toEqual(['id']);
+        expect(snapshot.state).not.toHaveProperty('internal');
+        expect(JSON.stringify(snapshot)).not.toContain('nested-hidden-filter');
+        expect(snapshot.state.table.state.columnOrder).toEqual(['id']);
+        expect(snapshot.state.table.state.filters).toEqual([
+            { columnId: 'id', value: ['internal'] },
+        ]);
+        const hiddenRowKeyDescriptor = descriptor();
+        hiddenRowKeyDescriptor.rowKey = 'internal';
+        const hiddenRowKeySurfaces = createDataSurfaceRegistry();
+        hiddenRowKeySurfaces.register({
+            descriptor: hiddenRowKeyDescriptor,
+            getSnapshot: () => ({
+                revision: 0,
+                state: {
+                    table: {
+                        state: {
+                            selection: {
+                                scope: 'explicit',
+                                rowIds: ['nested-private-row-id'],
+                            },
+                            selectedRowIds: ['nested-private-row-id'],
+                            expandedRowIds: ['nested-private-row-id'],
+                        },
+                    },
+                },
+                selection: { scope: 'explicit-ids', rowIds: ['private-row-id'] },
+            }),
+        });
+        const hiddenRowKeyBrowser = modelContext();
+        registerWebMcpUiTools({
+            controlRegistry: createControlInteractionRegistry(),
+            dataSurfaceRegistry: hiddenRowKeySurfaces,
+            document: hiddenRowKeyBrowser.document,
+        });
+        const hiddenRowKeyList = await parse(findTool(hiddenRowKeyBrowser.registered, 'smrt_ui_list_data_surfaces').execute({}));
+        expect(hiddenRowKeyList.result[0]).not.toHaveProperty('rowKey');
+        const hiddenRowKeyInspect = await parse(findTool(hiddenRowKeyBrowser.registered, 'smrt_ui_inspect_data_surface').execute({ identity }));
+        expect(hiddenRowKeyInspect.result.selection).toBeNull();
+        expect(JSON.stringify(hiddenRowKeyInspect)).not.toContain('private-row-id');
+        expect(JSON.stringify(hiddenRowKeyInspect)).not.toContain('nested-private-row-id');
+        const command = {
+            version: 1,
+            commandId: 'page-1',
+            identity,
+            expectedRevision: 2,
+            controlId: 'next-page',
+        };
+        const completed = (await parse(execute.execute(command))).result;
+        expect(completed).toMatchObject({
+            ok: true,
+            revision: 3,
+        });
+        expect(completed.snapshot.descriptor.columns).toHaveLength(1);
+        expect(completed.snapshot.state).not.toHaveProperty('internal');
+        expect((await parse(execute.execute(command))).result).toMatchObject({
+            ok: true,
+            revision: 3,
+        });
+        expect((await parse(execute.execute({ ...command, controlId: 'different-control' }))).result).toMatchObject({ ok: false, reason: 'idempotency_conflict' });
+        const stale = (await parse(execute.execute({ ...command, commandId: 'page-2' }))).result;
+        expect(stale).toMatchObject({ ok: false, reason: 'stale_revision' });
+        expect(stale.snapshot.descriptor.columns).toHaveLength(1);
+    });
+    it('rejects invalid and oversized requests with distinct failures', async () => {
+        const browser = modelContext();
+        const controls = createControlInteractionRegistry();
+        registerWebMcpUiTools({
+            controlRegistry: controls,
+            dataSurfaceRegistry: createDataSurfaceRegistry(),
+            document: browser.document,
+        });
+        const inspect = findTool(browser.registered, 'smrt_ui_inspect_form_control');
+        expect(await parse(inspect.execute({ identity: { formId: '', controlId: 'name' } }))).toEqual({
+            ok: false,
+            reason: 'invalid_identifier',
+            details: 'formId',
+        });
+        expect(await parse(inspect.execute({ payload: 'x'.repeat(100_001) }))).toEqual({ ok: false, reason: 'limit_exceeded' });
+        controls.register({
+            identity: { formId: 'broken', controlId: 'value' },
+            metadata: { kind: 'text' },
+            getValue: () => {
+                throw new Error('private host detail');
+            },
+        });
+        const list = findTool(browser.registered, 'smrt_ui_list_form_controls');
+        const failed = await parse(list.execute({ formId: 'broken' }));
+        expect(failed).toEqual({ ok: false, reason: 'execution_failed' });
+        expect(JSON.stringify(failed)).not.toContain('private host detail');
+    });
+    it('locks a prefix atomically, permits distinct prefixes, and no-ops without WebMCP', () => {
+        const browser = modelContext();
+        const registries = {
+            controlRegistry: createControlInteractionRegistry(),
+            dataSurfaceRegistry: createDataSurfaceRegistry(),
+        };
+        const dispose = registerWebMcpUiTools({
+            ...registries,
+            document: browser.document,
+        });
+        expect(() => registerWebMcpUiTools({ ...registries, document: browser.document })).toThrow('already registered');
+        expect(browser.registered).toHaveLength(6);
+        const disposeOther = registerWebMcpUiTools({
+            ...registries,
+            prefix: 'other_',
+            document: browser.document,
+        });
+        expect(browser.registered).toHaveLength(12);
+        disposeOther();
+        dispose();
+        expect(() => registerWebMcpUiTools({
+            ...registries,
+            document: {},
+        })).not.toThrow();
+    });
+    it('aborts every partial registration and releases the lock when a host rejects a tool', () => {
+        const signals = [];
+        let calls = 0;
+        const document = {
+            modelContext: {
+                registerTool(_tool, options) {
+                    calls += 1;
+                    if (options?.signal)
+                        signals.push(options.signal);
+                    if (calls === 3)
+                        throw new Error('host collision');
+                },
+            },
+        };
+        const registries = {
+            controlRegistry: createControlInteractionRegistry(),
+            dataSurfaceRegistry: createDataSurfaceRegistry(),
+        };
+        expect(() => registerWebMcpUiTools({ ...registries, document })).toThrow('host collision');
+        expect(signals.every((signal) => signal.aborted)).toBe(true);
+        calls = 0;
+        document.modelContext.registerTool = (_tool, options) => {
+            calls += 1;
+            if (options?.signal)
+                signals.push(options.signal);
+        };
+        expect(() => registerWebMcpUiTools({ ...registries, document })).not.toThrow();
+        expect(calls).toBe(6);
+    });
+});

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

@@ -5,7 +5,7 @@ import Harness from './webmcp-harness.svelte';
 function installModelContext() {
     const registered = [];
     document.modelContext = {
-        registerTool(tool, options) {
+        async registerTool(tool, options) {
             registered.push({ name: tool.name, signal: options?.signal });
         },
     };

package/dist/web/index.d.ts

@@ -16,5 +16,9 @@
  */
 export { type ActivityFeedHandle, type ActivityFeedMap, type ActivityFeedOptions, activityFeed, type ShellActivityInput, } from './activity-feed.svelte.js';
 export { type LiveCollection, type LiveCollectionMutation, type LiveCollectionOptions, type LiveCollectionStatus, liveCollection, } from './live-collection.svelte.js';
+export { type RemoteQueryBinding, remoteQuery, } from './remote-query.svelte.js';
 export { type UpdateAvailableView, type UseUpdateAvailableOptions, useUpdateAvailable, } from './update-available.svelte.js';
+export type { WebMcpProviderConfig, WebMcpUiProviderConfig, } from './webmcp-provider.js';
+export { type RegisterWebMcpUiToolsOptions, registerWebMcpUiTools, } from './webmcp-ui.js';
+export { useWebMcpUi, type WebMcpUiContext, } from './webmcp-ui-context.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/web/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/web/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,YAAY,EACZ,KAAK,kBAAkB,GACxB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,cAAc,GACf,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,yBAAyB,EAC9B,kBAAkB,GACnB,MAAM,8BAA8B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/web/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,YAAY,EACZ,KAAK,kBAAkB,GACxB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,cAAc,GACf,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,KAAK,kBAAkB,EACvB,WAAW,GACZ,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,yBAAyB,EAC9B,kBAAkB,GACnB,MAAM,8BAA8B,CAAC;AACtC,YAAY,EACV,oBAAoB,EACpB,sBAAsB,GACvB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,KAAK,4BAA4B,EACjC,qBAAqB,GACtB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,WAAW,EACX,KAAK,eAAe,GACrB,MAAM,wBAAwB,CAAC"}

package/dist/web/index.js

@@ -16,4 +16,7 @@
  */
 export { activityFeed, } from './activity-feed.svelte.js';
 export { liveCollection, } from './live-collection.svelte.js';
+export { remoteQuery, } from './remote-query.svelte.js';
 export { useUpdateAvailable, } from './update-available.svelte.js';
+export { registerWebMcpUiTools, } from './webmcp-ui.js';
+export { useWebMcpUi, } from './webmcp-ui-context.js';

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

@@ -0,0 +1,26 @@
+import { type SmrtWebCollection, type SmrtWebDataQueryRequest, type SmrtWebDataQueryResult, type SmrtWebQueryLiveSubscription, type SmrtWebQueryRunOptions, type SmrtWebQueryState, type SmrtWebQueryTransport } from '@happyvertical/smrt-web';
+export interface RemoteQueryBinding<TData extends object = object> {
+    readonly rows: ReadonlyArray<TData>;
+    readonly page: SmrtWebQueryState<TData>['page'];
+    readonly total: SmrtWebQueryState<TData>['total'];
+    readonly loading: boolean;
+    readonly refreshing: boolean;
+    readonly stale: boolean;
+    readonly error: unknown;
+    readonly lastUpdated: number | undefined;
+    readonly request: SmrtWebDataQueryRequest | undefined;
+    execute(request: SmrtWebDataQueryRequest, options?: SmrtWebQueryRunOptions): Promise<SmrtWebDataQueryResult>;
+    refresh(options?: Omit<SmrtWebQueryRunOptions, 'mode' | 'force'>): Promise<SmrtWebDataQueryResult | undefined>;
+    retry(): Promise<SmrtWebDataQueryResult | undefined>;
+    subscribeLive(): SmrtWebQueryLiveSubscription | undefined;
+    dispose(): void;
+}
+/**
+ * Bind a canonical remote query to Svelte 5 state. The binding is query
+ * shaped: rows are only the requested page and never the entire collection.
+ * Call during component initialization so cleanup follows the component.
+ */
+export declare function remoteQuery<TData extends object>(collection: SmrtWebCollection<TData>, transport: SmrtWebQueryTransport, options?: {
+    staleTimeMs?: number;
+}): RemoteQueryBinding<TData>;
+//# sourceMappingURL=remote-query.svelte.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"remote-query.svelte.d.ts","sourceRoot":"","sources":["../../src/web/remote-query.svelte.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,iBAAiB,EACtB,KAAK,uBAAuB,EAC5B,KAAK,sBAAsB,EAE3B,KAAK,4BAA4B,EACjC,KAAK,sBAAsB,EAC3B,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC3B,MAAM,yBAAyB,CAAC;AAEjC,MAAM,WAAW,kBAAkB,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM;IAC/D,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC;IACpC,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC;IAChD,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC;IAClD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IACzC,QAAQ,CAAC,OAAO,EAAE,uBAAuB,GAAG,SAAS,CAAC;IACtD,OAAO,CACL,OAAO,EAAE,uBAAuB,EAChC,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,sBAAsB,CAAC,CAAC;IACnC,OAAO,CACL,OAAO,CAAC,EAAE,IAAI,CAAC,sBAAsB,EAAE,MAAM,GAAG,OAAO,CAAC,GACvD,OAAO,CAAC,sBAAsB,GAAG,SAAS,CAAC,CAAC;IAC/C,KAAK,IAAI,OAAO,CAAC,sBAAsB,GAAG,SAAS,CAAC,CAAC;IACrD,aAAa,IAAI,4BAA4B,GAAG,SAAS,CAAC;IAC1D,OAAO,IAAI,IAAI,CAAC;CACjB;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,SAAS,MAAM,EAC9C,UAAU,EAAE,iBAAiB,CAAC,KAAK,CAAC,EACpC,SAAS,EAAE,qBAAqB,EAChC,OAAO,CAAC,EAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,GACjC,kBAAkB,CAAC,KAAK,CAAC,CAwD3B"}

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

@@ -0,0 +1,57 @@
+import { createSmrtWebQuery, } from '@happyvertical/smrt-web';
+/**
+ * Bind a canonical remote query to Svelte 5 state. The binding is query
+ * shaped: rows are only the requested page and never the entire collection.
+ * Call during component initialization so cleanup follows the component.
+ */
+export function remoteQuery(collection, transport, options) {
+    const query = createSmrtWebQuery(collection, transport, options);
+    let snapshot = $state(query.state);
+    let activeRequest = $state(query.request);
+    const unsubscribe = query.subscribe((next) => {
+        snapshot = next;
+        activeRequest = query.request;
+    });
+    $effect(() => () => {
+        unsubscribe();
+        query.dispose();
+    });
+    const binding = {
+        get rows() {
+            return snapshot.rows;
+        },
+        get page() {
+            return snapshot.page;
+        },
+        get total() {
+            return snapshot.total;
+        },
+        get loading() {
+            return snapshot.loading;
+        },
+        get refreshing() {
+            return snapshot.refreshing;
+        },
+        get stale() {
+            return snapshot.stale;
+        },
+        get error() {
+            return snapshot.error;
+        },
+        get lastUpdated() {
+            return snapshot.lastUpdated;
+        },
+        get request() {
+            return activeRequest;
+        },
+        execute: (request, runOptions) => query.execute(request, runOptions),
+        refresh: (runOptions) => query.refresh(runOptions),
+        retry: () => query.retry(),
+        subscribeLive: () => query.subscribeLive(),
+        dispose: () => {
+            unsubscribe();
+            query.dispose();
+        },
+    };
+    return binding;
+}

package/dist/web/webmcp-provider.d.ts

@@ -0,0 +1,23 @@
+import type { DataSurfaceRegistry } from '@happyvertical/smrt-ui/data';
+import type { ControlInteractionRegistry } from '@happyvertical/smrt-ui/forms';
+import type { RegisterWebMcpToolsOptions, SmrtWebClient, WebMcpExposurePolicy, WebMcpRegistrationDefinition } from '@happyvertical/smrt-web';
+export interface WebMcpUiProviderConfig {
+    controlRegistry?: ControlInteractionRegistry;
+    dataSurfaceRegistry?: DataSurfaceRegistry;
+    /** Document-global namespace prefix. @default 'smrt_ui_' */
+    prefix?: string;
+}
+export interface WebMcpProviderConfig extends WebMcpExposurePolicy {
+    definitions?: readonly WebMcpRegistrationDefinition[];
+    client?: SmrtWebClient;
+    basePath?: string;
+    fetchFn?: typeof fetch;
+    scope?: string;
+    filter?: RegisterWebMcpToolsOptions['filter'];
+    filterTool?: RegisterWebMcpToolsOptions['filterTool'];
+    resolveFetchers?: RegisterWebMcpToolsOptions['resolveFetchers'];
+    resolveToolFetchers?: RegisterWebMcpToolsOptions['resolveToolFetchers'];
+    /** Fixed browser-native tools over the mounted form/data registries. */
+    ui?: false | WebMcpUiProviderConfig;
+}
+//# sourceMappingURL=webmcp-provider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"webmcp-provider.d.ts","sourceRoot":"","sources":["../../src/web/webmcp-provider.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,0BAA0B,EAC1B,aAAa,EACb,oBAAoB,EACpB,4BAA4B,EAC7B,MAAM,yBAAyB,CAAC;AAEjC,MAAM,WAAW,sBAAsB;IACrC,eAAe,CAAC,EAAE,0BAA0B,CAAC;IAC7C,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;IAC1C,4DAA4D;IAC5D,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,oBAAqB,SAAQ,oBAAoB;IAChE,WAAW,CAAC,EAAE,SAAS,4BAA4B,EAAE,CAAC;IACtD,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,KAAK,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,0BAA0B,CAAC,QAAQ,CAAC,CAAC;IAC9C,UAAU,CAAC,EAAE,0BAA0B,CAAC,YAAY,CAAC,CAAC;IACtD,eAAe,CAAC,EAAE,0BAA0B,CAAC,iBAAiB,CAAC,CAAC;IAChE,mBAAmB,CAAC,EAAE,0BAA0B,CAAC,qBAAqB,CAAC,CAAC;IACxE,wEAAwE;IACxE,EAAE,CAAC,EAAE,KAAK,GAAG,sBAAsB,CAAC;CACrC"}

package/dist/web/webmcp-provider.js

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

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

@@ -0,0 +1,12 @@
+import type { DataSurfaceRegistry } from '@happyvertical/smrt-ui/data';
+import type { ControlInteractionRegistry } from '@happyvertical/smrt-ui/forms';
+export interface WebMcpUiContext {
+    readonly enabled: boolean;
+    readonly controlRegistry: ControlInteractionRegistry;
+    readonly dataSurfaceRegistry: DataSurfaceRegistry;
+}
+export declare function setWebMcpUiContext(context: WebMcpUiContext): void;
+export declare function tryGetWebMcpUiContext(): WebMcpUiContext | null;
+/** Return the mounted-UI registries owned by the nearest SMRT Provider. */
+export declare function useWebMcpUi(): WebMcpUiContext;
+//# sourceMappingURL=webmcp-ui-context.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"webmcp-ui-context.d.ts","sourceRoot":"","sources":["../../src/web/webmcp-ui-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AACvE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AAK/E,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,eAAe,EAAE,0BAA0B,CAAC;IACrD,QAAQ,CAAC,mBAAmB,EAAE,mBAAmB,CAAC;CACnD;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI,CAEjE;AAED,wBAAgB,qBAAqB,IAAI,eAAe,GAAG,IAAI,CAE9D;AAED,2EAA2E;AAC3E,wBAAgB,WAAW,IAAI,eAAe,CAQ7C"}

package/dist/web/webmcp-ui-context.js

@@ -0,0 +1,16 @@
+import { getContext, setContext } from 'svelte';
+const WEBMCP_UI_CONTEXT_KEY = Symbol('smrt-webmcp-ui-context');
+export function setWebMcpUiContext(context) {
+    setContext(WEBMCP_UI_CONTEXT_KEY, context);
+}
+export function tryGetWebMcpUiContext() {
+    return getContext(WEBMCP_UI_CONTEXT_KEY) ?? null;
+}
+/** Return the mounted-UI registries owned by the nearest SMRT Provider. */
+export function useWebMcpUi() {
+    const context = tryGetWebMcpUiContext();
+    if (!context?.enabled) {
+        throw new Error('WebMCP UI context not found. Wrap this component with <Provider>.');
+    }
+    return context;
+}

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

@@ -0,0 +1,21 @@
+import { type DataSurfaceRegistry } from '@happyvertical/smrt-ui/data';
+import type { ControlInteractionRegistry } from '@happyvertical/smrt-ui/forms';
+import type { WebMcpToolSpec } from './webmcp.svelte.js';
+export interface RegisterWebMcpUiToolsOptions {
+    controlRegistry: ControlInteractionRegistry;
+    dataSurfaceRegistry: DataSurfaceRegistry;
+    prefix?: string;
+    /** Injectable browser document used by tests and non-window hosts. */
+    document?: {
+        modelContext?: WebMcpModelContextLike;
+    };
+}
+interface WebMcpModelContextLike {
+    registerTool(tool: WebMcpToolSpec, options?: {
+        signal?: AbortSignal;
+    }): void | Promise<void>;
+}
+/** Register the fixed browser-native adapter over mounted UI registries. */
+export declare function registerWebMcpUiTools(options: RegisterWebMcpUiToolsOptions): () => void;
+export {};
+//# sourceMappingURL=webmcp-ui.d.ts.map

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

@@ -0,0 +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"}