@happyvertical/smrt-svelte 0.51.4 → 0.51.6

package/dist/web/list-data-surface.svelte.d.ts

@@ -0,0 +1,133 @@
+/**
+ * `mountListDataSurface` (#2906) — a one-liner to register an existing,
+ * hand-rolled list component as a mounted {@link DataSurfaceDescriptor}
+ * without adopting the `DataTable` component.
+ *
+ * `registerContentListDataSurface` in `@happyvertical/smrt-content/svelte`
+ * proves the pattern: mirror a headless `DataTableController` into the
+ * registry, translate visible commands back into controller dispatches, and
+ * bump a monotonic revision whenever the controller or app-owned context
+ * state changes. That logic is entangled with ContentList's view-mode
+ * concept and `packages/content` has no dependency on this package, so this
+ * module is a same-behavior PORT of that translation/registration logic —
+ * not a shared import — generalized off the view-mode concept so any custom
+ * list markup can register in one call instead of hand-mirroring the
+ * registry contract (the exact duplication that motivated this issue: an
+ * application page manually driving a headless `DataTableController` and
+ * calling `registry.register` itself). The two copies must be kept in sync
+ * by hand until they are unified behind a shared implementation in
+ * `@happyvertical/smrt-ui/data` (both packages already depend on it) —
+ * tracked as a follow-up (#2917). They are NOT currently identical: this
+ * copy denies a controlled controller's table command that fails to settle
+ * (see `applyControlledState` below), calls `registry.register` before
+ * subscribing to the controller to avoid leaking a subscription on a
+ * throwing register, and ignores `update()` once `destroy()` has run so a
+ * late-resolving page callback cannot resurrect this identity's entry in the
+ * registry-scoped revision map after a later mount has taken it over;
+ * `registerContentListDataSurface` predates all three fixes. #2917 should
+ * adopt them rather than treat this copy as the odd one out.
+ *
+ * Call during component initialization (top level of `<script>`, or inside
+ * an `$effect`); `destroy()` unregisters and unsubscribes, so tearing it down
+ * on unmount is the caller's responsibility, exactly like
+ * `registerContentListDataSurface`. Nothing here touches `window` or
+ * `document` at module scope, so it is safe under `ssr = false` SPAs and
+ * during SSR (the registry itself is a plain in-memory object).
+ */
+import type { DataSurfaceDescriptor, DataSurfaceJsonValue, DataSurfaceRegistry, DataTableCommand, DataTableControlledStateApplier, DataTableController } from '@happyvertical/smrt-ui/data';
+/**
+ * Arbitrary, JSON-safe application state folded into every snapshot.
+ *
+ * `table` is reserved: the mounted controller's own snapshot is always
+ * published under that key, so a context carrying it is rejected at mount
+ * and on every `update()` rather than silently discarded. The registry's own
+ * boundary-safe check further rejects transport-reserved keys such as
+ * `token`, `where`, or `tenantId` — see `boundarySafeObject` in
+ * `@happyvertical/smrt-ui/data`.
+ */
+export type ListDataSurfaceContext = Readonly<Record<string, DataSurfaceJsonValue>>;
+/**
+ * A {@link ListDataSurfaceContext} update: same shape, but a key may also be
+ * `undefined` to delete it from the published state (see
+ * {@link ListDataSurfaceHandle.update}). Kept distinct from
+ * `ListDataSurfaceContext` itself so the initial `context` option — which
+ * has no delete affordance — stays exactly JSON-safe.
+ */
+export type ListDataSurfaceContextPatch = Readonly<Record<string, DataSurfaceJsonValue | undefined>>;
+export interface ListDataSurfaceControlResult {
+    ok: boolean;
+}
+export interface MountListDataSurfaceOptions {
+    registry: DataSurfaceRegistry;
+    descriptor: DataSurfaceDescriptor;
+    /** The headless controller the page already mirrors search/filters/sort/page/selection from. */
+    controller: DataTableController;
+    /** App-owned state (freshness, fingerprints, …) folded into `state` alongside the table snapshot. */
+    context?: ListDataSurfaceContext;
+    /** Carries the mounted identity's monotonic revision across re-registration. */
+    initialRevision?: number;
+    onRevision?: (revision: number) => void;
+    /**
+     * App-owned constraints that must hold before a visible table command is
+     * acknowledged. Returning false denies the command rather than publishing
+     * a transient state a later effect would correct.
+     */
+    acceptsTableCommand?: (command: DataTableCommand) => boolean;
+    /**
+     * REQUIRED when `controller` is controlled (`controller.isControlled()`):
+     * a controlled controller's `dispatch()` only proposes state via its
+     * `onStateChange` callback — it never applies it or notifies subscribers,
+     * so without this the registry would acknowledge `ok: true` while nothing
+     * actually changed. Mirrors `DataTable`'s own controlled-table contract
+     * (`DataTableDataSurfaceOptions.applyControlledState`): settle the
+     * candidate state (typically by awaiting whatever the page's
+     * `onStateChange` triggered) and return the state that was actually
+     * applied, or `undefined` to deny. The command is denied whenever the
+     * controller's post-settle state does not match what was applied.
+     */
+    applyControlledState?: DataTableControlledStateApplier;
+    /** Non-table visible commands (`refresh`/`retry`/`focus`/`reveal`/`highlight`) the page implements. */
+    refresh?: () => boolean | Promise<boolean>;
+    retry?: () => boolean | Promise<boolean>;
+    focus?: () => void;
+    reveal?: () => void;
+    highlight?: () => void;
+    /**
+     * Escape hatch for custom controls beyond the fixed set above — a page can
+     * expose any additional `controlId` its markup understands, PROVIDED it is
+     * not one of `DATA_TABLE_SURFACE_CONTROL_IDS` (`@happyvertical/smrt-ui/data`,
+     * e.g. `set-filters`, `reset`, `set-page`): those ids are always
+     * intercepted first (translated and dispatched to `controller`, or denied
+     * outright if the payload fails to translate — see `TABLE_CONTROL_IDS`
+     * below) and never reach `onControl`, even if a descriptor declares one of
+     * them with a custom label. A descriptor control id must avoid that set to
+     * be reachable here. Only invoked when the command's `controlId` is
+     * neither a fixed control (`refresh`/`retry`/`focus`/`reveal`/`highlight`
+     * — a fixed control with no matching callback is denied directly, never
+     * forwarded here) nor a table-control id. Returning `false`/`{ ok: false }`
+     * denies the command; returning `true`, `{ ok: true }`, or nothing
+     * (`void`) is treated as success. A thrown error propagates out of
+     * `execute` and the registry reports it as `execution_failed` — it is
+     * never silently treated as success.
+     */
+    onControl?: (controlId: string, payload: DataSurfaceJsonValue | undefined) => boolean | void | ListDataSurfaceControlResult | Promise<boolean | void | ListDataSurfaceControlResult>;
+}
+export interface ListDataSurfaceHandle {
+    /**
+     * Merge new app-owned context state over what is already published,
+     * bumping the revision if the result changed. Keys `next` does not
+     * mention are retained; pass a key explicitly as `undefined` to drop it.
+     */
+    update(context: ListDataSurfaceContextPatch): void;
+    /** Unsubscribe from the controller and unregister from the registry. */
+    destroy(): void;
+}
+/**
+ * Register an existing, headless-controller-backed list as a mounted
+ * `DataSurfaceDescriptor`. Mirrors `registerContentListDataSurface`'s
+ * contract (stable identity independent of any view-mode churn, monotonic
+ * per-identity revision, visible-command translation) without requiring the
+ * ContentList view-mode concept, so any custom list can adopt it directly.
+ */
+export declare function mountListDataSurface(options: MountListDataSurfaceOptions): ListDataSurfaceHandle;
+//# sourceMappingURL=list-data-surface.svelte.d.ts.map

package/dist/web/list-data-surface.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-data-surface.svelte.d.ts","sourceRoot":"","sources":["../../src/web/list-data-surface.svelte.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,KAAK,EACV,qBAAqB,EAErB,oBAAoB,EACpB,mBAAmB,EAGnB,gBAAgB,EAChB,+BAA+B,EAC/B,mBAAmB,EAEpB,MAAM,6BAA6B,CAAC;AAOrC;;;;;;;;;GASG;AACH,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAC3C,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CACrC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,2BAA2B,GAAG,QAAQ,CAChD,MAAM,CAAC,MAAM,EAAE,oBAAoB,GAAG,SAAS,CAAC,CACjD,CAAC;AAEF,MAAM,WAAW,4BAA4B;IAC3C,EAAE,EAAE,OAAO,CAAC;CACb;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,EAAE,mBAAmB,CAAC;IAC9B,UAAU,EAAE,qBAAqB,CAAC;IAClC,gGAAgG;IAChG,UAAU,EAAE,mBAAmB,CAAC;IAChC,qGAAqG;IACrG,OAAO,CAAC,EAAE,sBAAsB,CAAC;IACjC,gFAAgF;IAChF,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC;IAC7D;;;;;;;;;;;OAWG;IACH,oBAAoB,CAAC,EAAE,+BAA+B,CAAC;IACvD,uGAAuG;IACvG,OAAO,CAAC,EAAE,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC3C,KAAK,CAAC,EAAE,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACzC,KAAK,CAAC,EAAE,MAAM,IAAI,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;IACvB;;;;;;;;;;;;;;;;;OAiBG;IACH,SAAS,CAAC,EAAE,CACV,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,oBAAoB,GAAG,SAAS,KAEvC,OAAO,GACP,IAAI,GACJ,4BAA4B,GAC5B,OAAO,CAAC,OAAO,GAAG,IAAI,GAAG,4BAA4B,CAAC,CAAC;CAC5D;AAED,MAAM,WAAW,qBAAqB;IACpC;;;;OAIG;IACH,MAAM,CAAC,OAAO,EAAE,2BAA2B,GAAG,IAAI,CAAC;IACnD,wEAAwE;IACxE,OAAO,IAAI,IAAI,CAAC;CACjB;AAuID;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,2BAA2B,GACnC,qBAAqB,CAuKvB"}

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

@@ -0,0 +1,308 @@
+/**
+ * `mountListDataSurface` (#2906) — a one-liner to register an existing,
+ * hand-rolled list component as a mounted {@link DataSurfaceDescriptor}
+ * without adopting the `DataTable` component.
+ *
+ * `registerContentListDataSurface` in `@happyvertical/smrt-content/svelte`
+ * proves the pattern: mirror a headless `DataTableController` into the
+ * registry, translate visible commands back into controller dispatches, and
+ * bump a monotonic revision whenever the controller or app-owned context
+ * state changes. That logic is entangled with ContentList's view-mode
+ * concept and `packages/content` has no dependency on this package, so this
+ * module is a same-behavior PORT of that translation/registration logic —
+ * not a shared import — generalized off the view-mode concept so any custom
+ * list markup can register in one call instead of hand-mirroring the
+ * registry contract (the exact duplication that motivated this issue: an
+ * application page manually driving a headless `DataTableController` and
+ * calling `registry.register` itself). The two copies must be kept in sync
+ * by hand until they are unified behind a shared implementation in
+ * `@happyvertical/smrt-ui/data` (both packages already depend on it) —
+ * tracked as a follow-up (#2917). They are NOT currently identical: this
+ * copy denies a controlled controller's table command that fails to settle
+ * (see `applyControlledState` below), calls `registry.register` before
+ * subscribing to the controller to avoid leaking a subscription on a
+ * throwing register, and ignores `update()` once `destroy()` has run so a
+ * late-resolving page callback cannot resurrect this identity's entry in the
+ * registry-scoped revision map after a later mount has taken it over;
+ * `registerContentListDataSurface` predates all three fixes. #2917 should
+ * adopt them rather than treat this copy as the odd one out.
+ *
+ * Call during component initialization (top level of `<script>`, or inside
+ * an `$effect`); `destroy()` unregisters and unsubscribes, so tearing it down
+ * on unmount is the caller's responsibility, exactly like
+ * `registerContentListDataSurface`. Nothing here touches `window` or
+ * `document` at module scope, so it is safe under `ssr = false` SPAs and
+ * during SSR (the registry itself is a plain in-memory object).
+ */
+import { DATA_TABLE_SURFACE_CONTROL_IDS, dataTableCommandFromDataSurfaceCommand, dataTableRowIdKey, } from '@happyvertical/smrt-ui/data';
+const revisionsByRegistry = new WeakMap();
+function identityKey(descriptor) {
+    const { identity } = descriptor;
+    return JSON.stringify([
+        identity.kind,
+        identity.surfaceId,
+        identity.subject?.type,
+        identity.subject?.id,
+    ]);
+}
+function selectionReference(selection) {
+    if (selection.scope === 'page')
+        return { scope: 'current-page' };
+    if (selection.scope === 'allMatching') {
+        return {
+            scope: 'all-matching',
+            queryFingerprint: selection.queryFingerprint,
+        };
+    }
+    return selection.rowIds.length > 0
+        ? { scope: 'explicit-ids', rowIds: selection.rowIds }
+        : null;
+}
+const RESERVED_CONTEXT_KEYS = ['table'];
+/**
+ * A command declaring a `controlId` from the canonical
+ * `DATA_TABLE_SURFACE_CONTROL_IDS` (`@happyvertical/smrt-ui/data`) that still
+ * fails to translate (an unparseable payload — e.g. `set-filters` with a
+ * non-array `filters`) must be denied directly, never forwarded to
+ * `onControl`: the descriptor and `acceptsTableCommand` gate never ran for
+ * it, so treating it as a generic custom control would let an `onControl`
+ * catch-all silently acknowledge a table mutation that was never applied.
+ * Sourced from the same upstream enumeration `dataTableCommandFromDataSurfaceCommand`
+ * is derived from — never a local copy of the id list — so an upstream
+ * addition to that switch is covered here automatically.
+ */
+const TABLE_CONTROL_IDS = new Set(DATA_TABLE_SURFACE_CONTROL_IDS);
+function assertNoReservedContextKeys(context) {
+    for (const key of RESERVED_CONTEXT_KEYS) {
+        if (key in context) {
+            throw new TypeError(`ListDataSurfaceContext must not use the reserved key "${key}" — the mounted controller's own snapshot is always published under it.`);
+        }
+    }
+}
+function allowsFilterOperator(column, operator) {
+    if (!column)
+        return false;
+    const canonical = column.operators?.filter;
+    const alias = column.filterOperators;
+    if (canonical && alias)
+        return canonical.includes(operator) && alias.includes(operator);
+    return canonical?.includes(operator) ?? alias?.includes(operator) ?? false;
+}
+function commandAllowed(command, descriptor, controller) {
+    const readable = new Set(descriptor.columns
+        .filter((column) => column.capabilities.includes('read'))
+        .map((column) => column.id));
+    const filterable = new Set(descriptor.query.filterableColumnIds ?? []);
+    const sortable = new Set(descriptor.query.sortableColumnIds ?? []);
+    switch (command.type) {
+        case 'setFilters':
+            return command.filters.every((filter) => {
+                const column = descriptor.columns.find((candidate) => candidate.id === filter.columnId);
+                return (filterable.has(filter.columnId) &&
+                    allowsFilterOperator(column, filter.operator));
+            });
+        case 'setSorting':
+            return command.sorting.every((sort) => sortable.has(sort.columnId));
+        case 'toggleSorting':
+            return sortable.has(command.columnId);
+        case 'setSelectedRows':
+            return command.rowIds.length <= descriptor.limits.maxSelectionSize;
+        case 'toggleRowSelection': {
+            const selection = controller.snapshot().state.selection;
+            if (selection.scope === 'allMatching')
+                return false;
+            const selected = selection.rowIds.some((rowId) => dataTableRowIdKey(rowId) === dataTableRowIdKey(command.rowId));
+            return (selected || selection.rowIds.length < descriptor.limits.maxSelectionSize);
+        }
+        case 'setPageSize':
+            return (command.pageSize === null ||
+                (Number.isSafeInteger(command.pageSize) && command.pageSize > 0));
+        case 'setColumnOrder':
+            return command.columnIds.every((columnId) => readable.has(columnId));
+        case 'setColumnVisibility':
+            return command.columns.every((column) => readable.has(column.columnId));
+        default:
+            return true;
+    }
+}
+/** `undefined` (a `void` return) means the handler ran and succeeded. */
+function normalizeControlResult(result) {
+    if (result === undefined)
+        return { ok: true };
+    if (typeof result === 'boolean')
+        return { ok: result };
+    return { ok: result.ok };
+}
+/**
+ * Register an existing, headless-controller-backed list as a mounted
+ * `DataSurfaceDescriptor`. Mirrors `registerContentListDataSurface`'s
+ * contract (stable identity independent of any view-mode churn, monotonic
+ * per-identity revision, visible-command translation) without requiring the
+ * ContentList view-mode concept, so any custom list can adopt it directly.
+ */
+export function mountListDataSurface(options) {
+    let revisions = revisionsByRegistry.get(options.registry);
+    if (!revisions) {
+        revisions = new Map();
+        revisionsByRegistry.set(options.registry, revisions);
+    }
+    const key = identityKey(options.descriptor);
+    const previousRevision = revisions.get(key);
+    let revision = Math.max(options.initialRevision ?? 0, previousRevision === undefined ? 0 : previousRevision + 1);
+    // Do NOT commit `revision` to the shared per-identity map, or subscribe to
+    // the controller, until `registry.register` below succeeds. Both a bad
+    // descriptor (duplicate identity, unknown column/control ids, …) and a
+    // reserved context key throw synchronously; committing shared state first
+    // would leave an orphaned controller subscriber writing a phantom revision
+    // counter for an identity this call never actually owns.
+    let context = { ...(options.context ?? {}) };
+    assertNoReservedContextKeys(context);
+    let contextSignature = JSON.stringify(context);
+    const advanceRevision = () => {
+        revision += 1;
+        revisions.set(key, revision);
+        options.onRevision?.(revision);
+    };
+    let destroyed = false;
+    const updateContext = (next) => {
+        // A page callback captured before unmount (e.g. an async `refresh` that
+        // calls `handle.update()` after its promise resolves) must not resurrect
+        // this identity's entry in the registry-scoped, cross-mount `revisions`
+        // map after `destroy()` — doing so would corrupt the monotonic revision
+        // a LATER, unrelated mount of the same identity seeds from.
+        if (destroyed)
+            return;
+        // Genuinely "fold in": keys already published that `next` does not
+        // mention are retained, matching this function's own documented
+        // contract. A caller that wants a key gone passes it explicitly as
+        // `undefined`; the registry rejects a literal `undefined` value (it is
+        // not JSON-safe), so that case deletes the key outright instead.
+        const draft = {
+            ...context,
+            ...next,
+        };
+        for (const patchKey of Object.keys(next)) {
+            if (next[patchKey] === undefined)
+                delete draft[patchKey];
+        }
+        const merged = draft;
+        assertNoReservedContextKeys(merged);
+        // `merged` may still carry a transport-reserved key (`tenantId`, `token`,
+        // `where`, …) that only the registry's own boundary-safety check knows
+        // about (`FORBIDDEN_BOUNDARY_KEYS` in `@happyvertical/smrt-ui/data`,
+        // in-repo upstream — no local copy of that list here). Validate eagerly
+        // by forcing the same read `registry.register` already performed at
+        // mount, so a bad key throws synchronously at THIS call site instead of
+        // being committed and only failing later on an unrelated `inspect()`/
+        // `execute()` call against the now-poisoned surface. Roll back on
+        // failure so the surface is left exactly as it was.
+        const previousContext = context;
+        context = merged;
+        try {
+            options.registry.inspect(options.descriptor.identity);
+        }
+        catch (error) {
+            context = previousContext;
+            throw error;
+        }
+        const signature = JSON.stringify(merged);
+        if (signature !== contextSignature) {
+            advanceRevision();
+            contextSignature = signature;
+        }
+    };
+    const unregister = options.registry.register({
+        descriptor: options.descriptor,
+        getSnapshot: () => {
+            const table = options.controller.snapshot();
+            return {
+                revision,
+                state: {
+                    ...context,
+                    table: table,
+                },
+                selection: selectionReference(table.state.selection),
+            };
+        },
+        execute: async (command) => {
+            const tableCommand = dataTableCommandFromDataSurfaceCommand(command);
+            if (tableCommand) {
+                if (!commandAllowed(tableCommand, options.descriptor, options.controller) ||
+                    options.acceptsTableCommand?.(tableCommand) === false)
+                    return { ok: false };
+                const transition = options.controller.dispatch(tableCommand);
+                if (options.controller.isControlled() && transition.changed) {
+                    // A controlled controller's dispatch() only proposed state via
+                    // onStateChange — it never applied it. Settle it (or deny) exactly
+                    // like DataTable's own controlled-table contract.
+                    const settled = await options.applyControlledState?.(transition.next.state, tableCommand);
+                    if (settled)
+                        options.controller.replaceState(settled);
+                    if (JSON.stringify(options.controller.getState()) !==
+                        JSON.stringify(transition.next.state)) {
+                        return { ok: false };
+                    }
+                }
+                return;
+            }
+            switch (command.controlId) {
+                case 'refresh':
+                    if (!options.refresh)
+                        return { ok: false };
+                    if ((await options.refresh()) === false)
+                        return { ok: false };
+                    return;
+                case 'retry':
+                    if (!options.retry)
+                        return { ok: false };
+                    if ((await options.retry()) === false)
+                        return { ok: false };
+                    return;
+                case 'focus':
+                    if (!options.focus)
+                        return { ok: false };
+                    options.focus();
+                    return;
+                case 'reveal':
+                    if (!options.reveal)
+                        return { ok: false };
+                    options.reveal();
+                    return;
+                case 'highlight':
+                    if (!options.highlight)
+                        return { ok: false };
+                    options.highlight();
+                    return;
+                default: {
+                    // A declared table-control id that failed to translate (e.g. an
+                    // unparseable payload) must be denied directly — it never reached
+                    // `commandAllowed`/`acceptsTableCommand`, so treating it as a
+                    // generic custom control would let `onControl` silently
+                    // acknowledge a table mutation that was never applied.
+                    if (TABLE_CONTROL_IDS.has(command.controlId))
+                        return { ok: false };
+                    if (!options.onControl)
+                        return { ok: false };
+                    const result = normalizeControlResult(await options.onControl(command.controlId, command.payload));
+                    return result.ok ? undefined : { ok: false };
+                }
+            }
+        },
+    });
+    // Registration succeeded — now, and only now, commit the shared per-identity
+    // revision and subscribe to the controller (see the note above).
+    revisions.set(key, revision);
+    const unsubscribe = options.controller.subscribe((transition) => {
+        if (transition.changed)
+            advanceRevision();
+    });
+    options.onRevision?.(revision);
+    return {
+        update: updateContext,
+        destroy() {
+            destroyed = true;
+            unsubscribe();
+            unregister();
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@happyvertical/smrt-svelte",
-  "version": "0.51.4",
+  "version": "0.51.6",
   "smrtJsdoc": "strict",
   "description": "Svelte 5 components for SMRT user management - auth, users, tenants, roles, permissions, groups",
   "type": "module",
@@ -121,10 +121,10 @@
   },
   "dependencies": {
     "@happyvertical/logger": "^0.89.11",
-    "@happyvertical/smrt-languages": "0.51.4",
-    "@happyvertical/smrt-types": "0.51.4",
-    "@happyvertical/smrt-ui": "0.51.4",
-    "@happyvertical/smrt-web": "0.51.4",
+    "@happyvertical/smrt-languages": "0.51.6",
+    "@happyvertical/smrt-types": "0.51.6",
+    "@happyvertical/smrt-ui": "0.51.6",
+    "@happyvertical/smrt-web": "0.51.6",
     "@tanstack/db": "^0.6.14",
     "@tanstack/svelte-db": "^0.1.91",
     "esm-env": "^1.2.2"
@@ -155,14 +155,14 @@
     }
   },
   "devDependencies": {
-    "@happyvertical/smrt-agents": "0.51.4",
-    "@happyvertical/smrt-chat": "0.51.4",
-    "@happyvertical/smrt-content": "0.51.4",
-    "@happyvertical/smrt-core": "0.51.4",
-    "@happyvertical/smrt-reports": "0.51.4",
-    "@happyvertical/smrt-scanner": "0.51.4",
-    "@happyvertical/smrt-tenancy": "0.51.4",
-    "@happyvertical/smrt-users": "0.51.4",
+    "@happyvertical/smrt-agents": "0.51.6",
+    "@happyvertical/smrt-chat": "0.51.6",
+    "@happyvertical/smrt-content": "0.51.6",
+    "@happyvertical/smrt-core": "0.51.6",
+    "@happyvertical/smrt-reports": "0.51.6",
+    "@happyvertical/smrt-scanner": "0.51.6",
+    "@happyvertical/smrt-tenancy": "0.51.6",
+    "@happyvertical/smrt-users": "0.51.6",
     "@sveltejs/package": "^2.5.8",
     "@sveltejs/vite-plugin-svelte": "^7.1.2",
     "@testing-library/jest-dom": "^6.9.1",