@happyvertical/smrt-svelte 0.51.39 → 0.53.0

package/dist/web/list-surface.svelte.js

@@ -0,0 +1,309 @@
+/**
+ * `useListSurface` — mount a page's rendered list on the nearest
+ * `<Provider webmcp>` data-surface registry in one call.
+ *
+ * A thin convenience over {@link mountListDataSurface} that owns the whole
+ * lifecycle (descriptor, controller, identity-keyed re-mount, context
+ * updates, destroy) and adds what a bare mount does not:
+ *
+ * - the visible rows, projected to the declared columns and capped, are
+ *   published as `state.rows`, so an agent reading the surface sees what the
+ *   person sees even on a page with no server catalog surface;
+ * - a `find` control (when any column is `searchable`) looks rows up by text:
+ *   payload `{ text }` (or a bare string) keeps the rows whose searchable
+ *   columns contain it, case-insensitively, across ALL rows — not only the
+ *   published first page — and publishes them as `state.rows` with
+ *   `state.find = { text, matches }`. An empty text clears it. It narrows
+ *   only what the agent reads; the page's own list is unchanged.
+ *
+ * - sorting (when `sort` and `onSort` are given): the current order is
+ *   published as `state.sort` and in the table snapshot, `sortable` columns
+ *   are declared sortable, and a `set-sorting` control
+ *   (`{ sorting: [{ columnId, direction }] }`, one rule) calls `onSort` — the
+ *   same path the page's own column headers take, so a server-paginated
+ *   list re-queries in that order (see `list-sort` in
+ *   `@happyvertical/smrt-ui/data`).
+ *
+ * Otherwise a read-only mirror: no remote filter/page/selection commands are
+ * accepted (the page's own controls stay the source of truth); `refresh` is
+ * honoured when supplied. Only declared columns leave the page: never declare
+ * a secret (tokens, keys), and mark names/emails the person can see as
+ * `personal`. No-op without a WebMCP Provider. Call during component init.
+ */
+import { createDataTableController, } from '@happyvertical/smrt-ui/data';
+import { onDestroy } from 'svelte';
+import { mountListDataSurface, } from './list-data-surface.svelte.js';
+import { tryGetWebMcpUiContext } from './webmcp-ui-context.js';
+function sortEnabled(options) {
+    return (typeof options.onSort === 'function' &&
+        options.columns.some((column) => column.sortable));
+}
+const DEFAULT_MAX_ROWS = 50;
+const MAX_QUERY_ROWS = 300;
+const MAX_FIND_TEXT = 200;
+function toJsonPrimitive(value) {
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value === 'string' || typeof value === 'boolean')
+        return value;
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? value : null;
+    if (value instanceof Date)
+        return Number.isNaN(value.getTime()) ? null : value.toISOString();
+    return null;
+}
+/** Project rows to the declared columns only; everything else is dropped. */
+export function projectListRows(rows, columns, maxRows = DEFAULT_MAX_ROWS) {
+    return rows.slice(0, maxRows).map((row) => {
+        const projected = {};
+        for (const column of columns) {
+            projected[column.id] = toJsonPrimitive(row[column.id]);
+        }
+        return projected;
+    });
+}
+function normalizeText(value) {
+    return value.normalize('NFKD').toLowerCase().replace(/\s+/g, ' ').trim();
+}
+/** Rows whose searchable columns contain `text` (case- and accent-insensitive). */
+export function findListRows(rows, columns, text) {
+    const wanted = normalizeText(text);
+    if (!wanted)
+        return [...rows];
+    const searchable = columns.filter((column) => column.searchable);
+    return rows.filter((row) => searchable.some((column) => {
+        const value = row[column.id];
+        return ((typeof value === 'string' || typeof value === 'number') &&
+            normalizeText(String(value))
+                .replace(/\p{M}/gu, '')
+                .includes(wanted.replace(/\p{M}/gu, '')));
+    }));
+}
+/** The descriptor {@link useListSurface} mounts. */
+export function listSurfaceDescriptor(options) {
+    const rowKey = options.columns.find((column) => column.rowKey)?.id ??
+        options.columns[0]?.id ??
+        'id';
+    const searchableIds = options.columns
+        .filter((column) => column.searchable)
+        .map((column) => column.id);
+    const sortableIds = sortEnabled(options)
+        ? options.columns
+            .filter((column) => column.sortable)
+            .map((column) => column.id)
+        : [];
+    const columns = options.columns.map((column) => ({
+        id: column.id,
+        label: column.label,
+        ...(column.description ? { description: column.description } : {}),
+        ...(column.sensitivity ? { sensitivity: column.sensitivity } : {}),
+        capabilities: [
+            'read',
+            ...(column.searchable ? ['search'] : []),
+            ...(sortableIds.includes(column.id) ? ['sort'] : []),
+        ],
+        ...(sortableIds.includes(column.id)
+            ? { operators: { sort: ['asc', 'desc'] } }
+            : {}),
+        ...(column.id === rowKey
+            ? { role: 'row-key' }
+            : column.status
+                ? { role: 'status' }
+                : {}),
+    }));
+    const searchLabels = options.columns
+        .filter((column) => column.searchable)
+        .map((column) => column.label.toLowerCase());
+    return {
+        version: 1,
+        identity: {
+            kind: options.kind ?? 'list',
+            surfaceId: options.surfaceId,
+            ...(options.subject ? { subject: options.subject } : {}),
+        },
+        schemaVersion: 1,
+        label: options.label,
+        description: options.description,
+        rowKey,
+        columns,
+        query: {
+            modes: ['rows'],
+            projectableColumnIds: columns.map((column) => column.id),
+            ...(searchableIds.length > 0
+                ? { searchableColumnIds: searchableIds }
+                : {}),
+            filterableColumnIds: [],
+            sortableColumnIds: sortableIds,
+        },
+        controls: [
+            ...(options.refresh ? [{ id: 'refresh', label: 'Refresh' }] : []),
+            ...(sortableIds.length > 0
+                ? [
+                    {
+                        id: 'set-sorting',
+                        label: 'Sort',
+                        description: `Re-order the list the way its column headers do. Payload: { sorting: [{ columnId, direction: 'asc' | 'desc' }] } with exactly one rule; sortable columns: ${sortableIds.join(', ')}. The current order is state.sort.`,
+                    },
+                ]
+                : []),
+            ...(searchableIds.length > 0
+                ? [
+                    {
+                        id: 'find',
+                        label: 'Find',
+                        description: `Look rows up by ${searchLabels.join(' or ')}. Payload: { text } — rows containing it (any case) are published in state.rows; empty text clears.`,
+                    },
+                ]
+                : []),
+        ],
+        actions: [],
+        // Constant: a mount publishes its descriptor once, so a row count
+        // captured here would cap the surface for the life of the mount.
+        limits: {
+            maxQueryRows: MAX_QUERY_ROWS,
+            maxQueryBytes: 1_000_000,
+            maxSelectionSize: MAX_QUERY_ROWS,
+        },
+    };
+}
+function findTextFromPayload(payload) {
+    const raw = typeof payload === 'string'
+        ? payload
+        : payload && typeof payload === 'object' && !Array.isArray(payload)
+            ? ['text', 'q', 'query', 'search', 'title']
+                .map((key) => payload[key])
+                .find((value) => typeof value === 'string')
+            : undefined;
+    if (typeof raw !== 'string' || raw.length > MAX_FIND_TEXT)
+        return null;
+    return raw;
+}
+function surfaceContext(options, findText) {
+    const visible = findText
+        ? findListRows(options.rows, options.columns, findText)
+        : options.rows;
+    const rows = projectListRows(visible, options.columns, options.maxRows);
+    return {
+        ...(options.context ?? {}),
+        ...(options.sort
+            ? {
+                sort: {
+                    columnId: options.sort.columnId,
+                    direction: options.sort.direction,
+                },
+            }
+            : {}),
+        rowCount: options.rows.length,
+        rows,
+        rowsTruncated: visible.length > rows.length,
+        find: findText ? { text: findText, matches: visible.length } : undefined,
+    };
+}
+export function useListSurface(getOptions, registry) {
+    const uiContext = tryGetWebMcpUiContext();
+    let handle = null;
+    let mountedKey = null;
+    let mountedRegistry = null;
+    let latest = null;
+    let controller = null;
+    let findText = '';
+    const sortingOf = (options) => options.sort
+        ? [{ columnId: options.sort.columnId, direction: options.sort.direction }]
+        : [];
+    const teardown = () => {
+        handle?.destroy();
+        handle = null;
+        controller = null;
+        mountedKey = null;
+        mountedRegistry = null;
+        findText = '';
+    };
+    $effect(() => {
+        const options = getOptions();
+        const resolved = registry ??
+            (uiContext?.enabled ? uiContext.dataSurfaceRegistry : undefined);
+        latest = options;
+        if (!resolved || !options) {
+            teardown();
+            return;
+        }
+        // Re-mount on identity change: SvelteKit reuses a page component across
+        // a param-only navigation, and a mount keeps its first subject.
+        const key = JSON.stringify([
+            options.surfaceId,
+            options.kind ?? 'list',
+            options.subject ?? null,
+            options.columns.map((column) => [
+                column.id,
+                column.searchable === true,
+                column.sortable === true,
+            ]),
+            Boolean(options.refresh),
+            sortEnabled(options),
+        ]);
+        if (key !== mountedKey || resolved !== mountedRegistry) {
+            teardown();
+            const context = surfaceContext(options, '');
+            delete context.find;
+            const sortable = sortEnabled(options);
+            const columnIds = options.columns.map((column) => column.id);
+            const mountedController = sortable
+                ? createDataTableController({
+                    columnIds,
+                    // Controlled: the page's `sort` is the source of truth; an agent's
+                    // command is only a proposal until `onSort` applies it.
+                    state: {
+                        ...createDataTableController({ columnIds }).getState(),
+                        sorting: sortingOf(options),
+                    },
+                })
+                : createDataTableController({ columnIds });
+            controller = mountedController;
+            handle = mountListDataSurface({
+                registry: resolved,
+                descriptor: listSurfaceDescriptor(options),
+                controller: mountedController,
+                context: context,
+                acceptsTableCommand: (command) => sortable &&
+                    command.type === 'setSorting' &&
+                    command.sorting.length === 1,
+                ...(sortable
+                    ? {
+                        applyControlledState: async (next) => {
+                            const rule = next.sorting[0];
+                            if (!rule || !latest?.onSort)
+                                return undefined;
+                            const result = await latest.onSort({
+                                columnId: rule.columnId,
+                                direction: rule.direction,
+                            });
+                            return result === false ? undefined : next;
+                        },
+                    }
+                    : {}),
+                ...(options.refresh ? { refresh: options.refresh } : {}),
+                onControl: (controlId, payload) => {
+                    if (controlId !== 'find' || !latest || !handle)
+                        return false;
+                    const text = findTextFromPayload(payload);
+                    if (text === null)
+                        return false;
+                    findText = text.trim();
+                    handle.update(surfaceContext(latest, findText));
+                    return true;
+                },
+            });
+            mountedKey = key;
+            mountedRegistry = resolved;
+            return;
+        }
+        if (controller?.isControlled()) {
+            controller.replaceState({
+                ...controller.getState(),
+                sorting: sortingOf(options),
+            });
+        }
+        handle?.update(surfaceContext(options, findText));
+    });
+    onDestroy(teardown);
+}

package/dist/web/step-surface.svelte.d.ts

@@ -0,0 +1,17 @@
+/**
+ * `useStepSurface` — mount a wizard or other multi-step flow on the nearest
+ * `<Provider webmcp>` data-surface registry, so an agent can read where the
+ * person is and move the flow with `next` / `back` / `go-to`. A step whose
+ * forward button saves or creates something (`nextWrites`) is never pressed
+ * by an agent: `next` calls `showNext` (reveal + highlight the button) and
+ * the person presses it. See `registerStepSurface` in
+ * `@happyvertical/smrt-ui/data`.
+ *
+ * Handlers are read at command time, so pass the page's own functions — the
+ * ones its buttons call. A no-op without a WebMCP Provider. Call during
+ * component init.
+ */
+import { type DataSurfaceRegistry, type StepSurfaceOptions } from '@happyvertical/smrt-ui/data';
+export type UseStepSurfaceOptions = Omit<StepSurfaceOptions, 'registry'>;
+export declare function useStepSurface(getOptions: () => UseStepSurfaceOptions | null, registry?: DataSurfaceRegistry): void;
+//# sourceMappingURL=step-surface.svelte.d.ts.map

package/dist/web/step-surface.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-surface.svelte.d.ts","sourceRoot":"","sources":["../../src/web/step-surface.svelte.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EACL,KAAK,mBAAmB,EAGxB,KAAK,kBAAkB,EACxB,MAAM,6BAA6B,CAAC;AAIrC,MAAM,MAAM,qBAAqB,GAAG,IAAI,CAAC,kBAAkB,EAAE,UAAU,CAAC,CAAC;AAEzE,wBAAgB,cAAc,CAC5B,UAAU,EAAE,MAAM,qBAAqB,GAAG,IAAI,EAC9C,QAAQ,CAAC,EAAE,mBAAmB,GAC7B,IAAI,CA2CN"}

package/dist/web/step-surface.svelte.js

@@ -0,0 +1,56 @@
+/**
+ * `useStepSurface` — mount a wizard or other multi-step flow on the nearest
+ * `<Provider webmcp>` data-surface registry, so an agent can read where the
+ * person is and move the flow with `next` / `back` / `go-to`. A step whose
+ * forward button saves or creates something (`nextWrites`) is never pressed
+ * by an agent: `next` calls `showNext` (reveal + highlight the button) and
+ * the person presses it. See `registerStepSurface` in
+ * `@happyvertical/smrt-ui/data`.
+ *
+ * Handlers are read at command time, so pass the page's own functions — the
+ * ones its buttons call. A no-op without a WebMCP Provider. Call during
+ * component init.
+ */
+import { registerStepSurface, } from '@happyvertical/smrt-ui/data';
+import { onDestroy } from 'svelte';
+import { tryGetWebMcpUiContext } from './webmcp-ui-context.js';
+export function useStepSurface(getOptions, registry) {
+    const uiContext = tryGetWebMcpUiContext();
+    let handle = null;
+    let mountedKey = null;
+    let mountedRegistry = null;
+    const teardown = () => {
+        handle?.destroy();
+        handle = null;
+        mountedKey = null;
+        mountedRegistry = null;
+    };
+    $effect(() => {
+        const options = getOptions();
+        const resolved = registry ??
+            (uiContext?.enabled ? uiContext.dataSurfaceRegistry : undefined);
+        if (!resolved || !options) {
+            teardown();
+            return;
+        }
+        const key = JSON.stringify([options.surfaceId, options.subject ?? null]);
+        if (key !== mountedKey || resolved !== mountedRegistry) {
+            teardown();
+            handle = registerStepSurface({ ...options, registry: resolved });
+            mountedKey = key;
+            mountedRegistry = resolved;
+            return;
+        }
+        handle?.update({
+            steps: options.steps,
+            current: options.current,
+            next: options.next,
+            nextWrites: options.nextWrites ?? false,
+            showNext: options.showNext,
+            back: options.back,
+            goTo: options.goTo,
+            state: options.state,
+        });
+    });
+    onDestroy(teardown);
+}

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

@@ -7,6 +7,13 @@ export interface WebMcpUiContext {
 }
 export declare function setWebMcpUiContext(context: WebMcpUiContext): void;
 export declare function tryGetWebMcpUiContext(): WebMcpUiContext | null;
+/**
+ * The nearest Provider's mounted-UI registries, or `null` when there is no
+ * Provider or its WebMCP UI is off (#2915). Use this to fall back to a local
+ * registry instead of catching {@link useWebMcpUi}'s throw. Call during
+ * component initialization, like any context read.
+ */
+export declare function tryUseWebMcpUi(): 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

@@ -1 +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"}
+{"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;;;;;GAKG;AACH,wBAAgB,cAAc,IAAI,eAAe,GAAG,IAAI,CAGvD;AAED,2EAA2E;AAC3E,wBAAgB,WAAW,IAAI,eAAe,CAQ7C"}

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

@@ -6,6 +6,16 @@ export function setWebMcpUiContext(context) {
 export function tryGetWebMcpUiContext() {
     return getContext(WEBMCP_UI_CONTEXT_KEY) ?? null;
 }
+/**
+ * The nearest Provider's mounted-UI registries, or `null` when there is no
+ * Provider or its WebMCP UI is off (#2915). Use this to fall back to a local
+ * registry instead of catching {@link useWebMcpUi}'s throw. Call during
+ * component initialization, like any context read.
+ */
+export function tryUseWebMcpUi() {
+    const context = tryGetWebMcpUiContext();
+    return context?.enabled ? context : null;
+}
 /** Return the mounted-UI registries owned by the nearest SMRT Provider. */
 export function useWebMcpUi() {
     const context = tryGetWebMcpUiContext();

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

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

package/dist/web/webmcp-ui.js

@@ -1,5 +1,6 @@
 import { DATA_SURFACE_IDENTIFIER_MAX_LENGTH, DATA_SURFACE_MAX_REQUEST_BYTES, } from '@happyvertical/smrt-ui/data';
-import { reserveWebMcpToolNames, } from '@happyvertical/smrt-web/webmcp-tool-names';
+import { WEBMCP_TOOL_EFFECT } from '@happyvertical/smrt-web/webmcp-page-tools';
+import { markWebMcpProposalTool, reserveWebMcpToolNames, } from '@happyvertical/smrt-web/webmcp-tool-names';
 const CONTROL_ACTIONS = new Set([
     'focus',
     'reveal',
@@ -315,7 +316,7 @@ function tools(prefix, controlRegistry, dataSurfaceRegistry) {
         })),
         {
             name: `${prefix}execute_form_control`,
-            description: 'Execute an allowed command on a mounted SMRT form control. Agent mutations are consent-gated.',
+            description: 'Execute an allowed command on a mounted SMRT form control. Agent mutations are consent-gated. An agent never moves keyboard focus: `focus` scrolls the control into view and highlights it.',
             inputSchema: {
                 type: 'object',
                 required: ['action', 'identity'],
@@ -490,7 +491,19 @@ export function registerWebMcpUiTools(options) {
     };
     try {
         for (const tool of specs) {
-            const registration = modelContext.registerTool(tool, {
+            // The in-page tool registry (#2908) reads the resolved effect from this
+            // stamp. The two execute tools are `write`, not destructive: an agent
+            // can only stage values or change visible state; apply, clear, and undo
+            // need a separate human-confirmed path, so their mutations are
+            // proposals. Their browser annotations are unchanged. The proposal
+            // brand is what lets the in-page assistant run those writes without a
+            // confirmation step; the tool-name lock's `ui` label never does.
+            const stamped = Object.assign({
+                [WEBMCP_TOOL_EFFECT]: tool.annotations?.readOnlyHint
+                    ? 'read'
+                    : 'write',
+            }, tool, { execute: markWebMcpProposalTool(tool.execute) });
+            const registration = modelContext.registerTool(stamped, {
                 signal: controller.signal,
             });
             if (registration) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@happyvertical/smrt-svelte",
-  "version": "0.51.39",
+  "version": "0.53.0",
   "smrtJsdoc": "strict",
   "description": "Svelte 5 components for SMRT user management - auth, users, tenants, roles, permissions, groups",
   "type": "module",
@@ -126,12 +126,12 @@
     "access": "public"
   },
   "dependencies": {
-    "@happyvertical/logger": "^0.96.0",
-    "@happyvertical/smrt-languages": "0.51.39",
-    "@happyvertical/smrt-mcp-apps": "0.51.39",
-    "@happyvertical/smrt-types": "0.51.39",
-    "@happyvertical/smrt-ui": "0.51.39",
-    "@happyvertical/smrt-web": "0.51.39",
+    "@happyvertical/logger": "^0.98.0",
+    "@happyvertical/smrt-languages": "0.53.0",
+    "@happyvertical/smrt-mcp-apps": "0.53.0",
+    "@happyvertical/smrt-types": "0.53.0",
+    "@happyvertical/smrt-ui": "0.53.0",
+    "@happyvertical/smrt-web": "0.53.0",
     "@tanstack/db": "^0.6.14",
     "@tanstack/svelte-db": "^0.1.91",
     "esm-env": "^1.2.2"
@@ -143,7 +143,7 @@
     "@xenova/transformers": "^2.17.2",
     "bitgpu": "^0.19.1",
     "chrono-node": "^2.10.1",
-    "svelte": "^5.57.1"
+    "svelte": "^5.57.0"
   },
   "peerDependenciesMeta": {
     "@huggingface/transformers": {
@@ -166,14 +166,14 @@
     }
   },
   "devDependencies": {
-    "@happyvertical/smrt-agents": "0.51.39",
-    "@happyvertical/smrt-chat": "0.51.39",
-    "@happyvertical/smrt-content": "0.51.39",
-    "@happyvertical/smrt-core": "0.51.39",
-    "@happyvertical/smrt-reports": "0.51.39",
-    "@happyvertical/smrt-scanner": "0.51.39",
-    "@happyvertical/smrt-tenancy": "0.51.39",
-    "@happyvertical/smrt-users": "0.51.39",
+    "@happyvertical/smrt-agents": "0.53.0",
+    "@happyvertical/smrt-chat": "0.53.0",
+    "@happyvertical/smrt-content": "0.53.0",
+    "@happyvertical/smrt-core": "0.53.0",
+    "@happyvertical/smrt-reports": "0.53.0",
+    "@happyvertical/smrt-scanner": "0.53.0",
+    "@happyvertical/smrt-tenancy": "0.53.0",
+    "@happyvertical/smrt-users": "0.53.0",
     "@sveltejs/package": "^2.5.8",
     "@sveltejs/vite-plugin-svelte": "^7.3.0",
     "@testing-library/jest-dom": "^7.0.1",
@@ -192,7 +192,7 @@
     "dev": "svelte-package -i src --watch",
     "check": "pnpm exec svelte-check --tsconfig ./tsconfig.svelte.json",
     "test": "pnpm run test:unit && pnpm run test:conformance",
-    "test:unit": "vitest run --exclude src/web/__tests__/data-surface-conformance.integration.svelte.test.ts && node --test scripts/ensure-conformance-build.test.mjs",
+    "test:unit": "vitest run --exclude src/web/__tests__/data-surface-conformance.integration.svelte.test.ts && node --test scripts/*.test.mjs",
     "test:conformance": "node scripts/ensure-conformance-build.mjs && SMRT_SVELTE_PUBLISHED_ENTRY=1 vitest run src/web/__tests__/data-surface-conformance.integration.svelte.test.ts",
     "typecheck:conformance": "tsc --noEmit -p ./tsconfig.conformance.json",
     "typecheck": "tsc --noEmit && pnpm run typecheck:conformance && node ../../scripts/svelte-check-a11y.mjs --tsconfig ./tsconfig.svelte.json",