@happyvertical/smrt-svelte 0.51.5 → 0.51.7

package/dist/components/workspace/README.md

@@ -35,6 +35,31 @@ identity and action content belongs in `topLeftCorner` / `topRightCorner`,
 wrapped in `ShellCorner side="left"` or `ShellCorner side="right"` so it follows
 the corresponding shell track as that edge expands and collapses.
 
+## AssistantDock recipe (#2904)
+
+`ShellDockTool` also hosts `@happyvertical/smrt-chat/svelte`'s `AssistantDock`
+— a route-aware assistant surface. This package has no runtime dependency on
+`@happyvertical/smrt-chat` (only a devDependency, for tests); the composition
+below is intentionally application code, not a `workspace/` export:
+
+```svelte
+<script lang="ts">
+  import { ShellDockTool } from '@happyvertical/smrt-svelte/workspace';
+  import { AssistantDock } from '@happyvertical/smrt-chat/svelte';
+</script>
+
+<ShellDockTool id="assistant" label="Assistant" icon="bot">
+  {#snippet render()}
+    <AssistantDock {transport} {registry} />
+  {/snippet}
+</ShellDockTool>
+```
+
+`registry` is the same `DataSurfaceRegistry` instance mounted routes register
+their descriptors on. See
+[`docs/assistant-dock.md`](../../../../../docs/assistant-dock.md) for the full
+design.
+
 ## Migration
 
 See [MIGRATION.md](./MIGRATION.md) for the first-generation workspace migration

package/dist/web/__tests__/assistant-dock.integration.svelte.test.js

@@ -0,0 +1,204 @@
+// @vitest-environment jsdom
+/**
+ * AssistantDock conformance-style integration test (#2904).
+ *
+ * Mirrors `data-surface-conformance.integration.svelte.test.ts` in this
+ * directory: a real `DataSurfaceRegistry` and a real
+ * `createAssistantDockController`/`AssistantDock` are composed together;
+ * only the chat transport and the action client are in-process test doubles
+ * (`createInMemoryAssistantTransport`, and a thin `actionClient` adapter over
+ * the registry's own `execute()`), matching that file's stated scope of
+ * faking only the transport boundary.
+ *
+ * Scope note (disclosed deviation from the original test plan): the action
+ * preview/apply path here is driven directly through
+ * `createAssistantDockController` rather than by having a fake model reply
+ * trigger it through the rendered `AssistantDock` DOM — `AssistantDock` has
+ * no built-in "parse this assistant message as an action proposal" step (no
+ * such parsing is specified anywhere in #2904's binding decisions), so the
+ * host application is expected to call `controller.previewAction(...)` from
+ * its own message-rendering logic. This test still exercises the full
+ * dock (registry discovery, rendering, send/poll) through the DOM, and
+ * separately proves the action pathway (preview → confirm → apply → registry
+ * "command" event) end-to-end against the real registry.
+ */
+import { AssistantDock, createAssistantDockController, createInMemoryAssistantTransport, } from '@happyvertical/smrt-chat/svelte';
+import { createDataSurfaceRegistry, } from '@happyvertical/smrt-ui/data-surface';
+import { render, screen, waitFor } from '@testing-library/svelte';
+import { describe, expect, it } from 'vitest';
+const identity = {
+    surfaceId: 'assistant-dock-orders',
+    kind: 'table',
+    subject: { type: 'tenant', id: 'tenant-a' },
+};
+const descriptor = {
+    version: 1,
+    identity,
+    schemaVersion: 1,
+    label: 'Orders',
+    rowKey: 'id',
+    columns: [
+        {
+            id: 'id',
+            label: 'ID',
+            capabilities: ['read', 'project'],
+            role: 'row-key',
+        },
+    ],
+    query: {
+        modes: ['rows'],
+        projectableColumnIds: ['id'],
+        searchableColumnIds: [],
+        filterableColumnIds: [],
+        sortableColumnIds: [],
+    },
+    actions: [
+        {
+            id: 'archive',
+            label: 'Archive',
+            selectionScopes: ['explicit-ids'],
+            requiresConfirmation: true,
+        },
+    ],
+    controls: [{ id: 'data-surface.action.archive', label: 'Archive' }],
+    limits: { maxQueryRows: 100, maxQueryBytes: 100_000, maxSelectionSize: 100 },
+};
+function mountRegistryWithOneSurface() {
+    const registry = createDataSurfaceRegistry();
+    let revision = 1;
+    const state = { archived: false };
+    const unregister = registry.register({
+        descriptor,
+        getSnapshot: () => ({
+            version: 1,
+            descriptor,
+            revision,
+            state: { archived: state.archived },
+        }),
+        execute: async (command) => {
+            // A minimal real mutation: the "archive" action flips `archived` and
+            // bumps the snapshot revision, which is what makes the registry emit a
+            // 'command' event other mounted UI can react to.
+            state.archived = true;
+            revision += 1;
+            return {
+                version: 1,
+                commandId: command.commandId,
+                identity: command.identity,
+                ok: true,
+                revision,
+            };
+        },
+    });
+    return { registry, unregister, state: () => state.archived };
+}
+describe('AssistantDock integration (#2904)', () => {
+    it('fails closed and shows the no-surfaces notice with an empty registry', async () => {
+        const registry = createDataSurfaceRegistry();
+        const transport = createInMemoryAssistantTransport();
+        render(AssistantDock, { props: { transport, registry } });
+        await waitFor(() => {
+            expect(screen.getByText(/No data surfaces are mounted on this route/i)).toBeInTheDocument();
+        });
+    });
+    it('discovers a mounted surface via the registry and renders a sent conversation', async () => {
+        const { registry } = mountRegistryWithOneSurface();
+        const transport = createInMemoryAssistantTransport({
+            respond: (_threadId, userMessage) => ({
+                id: 'assistant-1',
+                threadId: userMessage.threadId,
+                content: 'Archived the order.',
+                role: 'assistant',
+                createdAt: new Date(),
+            }),
+        });
+        render(AssistantDock, { props: { transport, registry } });
+        await waitFor(() => {
+            expect(screen.queryByText(/No data surfaces are mounted on this route/i)).not.toBeInTheDocument();
+        });
+        const thread = await transport.createThread('Order question');
+        // Drive the same controller the component owns internally by exercising
+        // the transport directly (the composer's own send() path is covered at
+        // the unit level in packages/chat); here we assert the descriptor is
+        // visible to a controller built against this exact registry instance.
+        const controller = createAssistantDockController({ transport, registry });
+        await controller.openThread(thread.id);
+        // Cycle-3 second final finding 1: an attached file must round-trip onto
+        // the sent message, not just the message text — this is the surface
+        // that previously rendered nothing for message.attachments.
+        await controller.send('please archive this order', [
+            { id: 'att-1', name: 'order-details.pdf' },
+        ]);
+        await waitFor(() => {
+            expect(controller.messages.some((m) => m.content === 'Archived the order.')).toBe(true);
+        });
+        const sentMessage = controller.messages.find((m) => m.content === 'please archive this order');
+        expect(sentMessage?.attachments).toEqual([
+            { id: 'att-1', name: 'order-details.pdf' },
+        ]);
+        expect(controller.surfaces).toHaveLength(1);
+        expect(controller.surfaces[0].surfaceId).toBe('assistant-dock-orders');
+        controller.dispose();
+    });
+    it('drives preview → confirm → apply through the real registry and fires its "command" event', async () => {
+        const { registry, state } = mountRegistryWithOneSurface();
+        const events = [];
+        registry.subscribe((event) => events.push(event));
+        const actionClient = {
+            async preview(request) {
+                // A preview never mutates: assert the surface is untouched.
+                expect(state()).toBe(false);
+                return {
+                    version: 1,
+                    requestId: request.requestId,
+                    identity: request.identity,
+                    actionId: request.actionId,
+                    phase: 'preview',
+                    ok: true,
+                    confirmationToken: 'token-1',
+                };
+            },
+            async apply(request) {
+                const result = await registry.execute({
+                    version: 1,
+                    commandId: request.requestId,
+                    identity: request.identity,
+                    expectedRevision: 1,
+                    controlId: `data-surface.action.${request.actionId}`,
+                });
+                return {
+                    version: 1,
+                    requestId: request.requestId,
+                    identity: request.identity,
+                    actionId: request.actionId,
+                    phase: 'apply',
+                    ok: result.ok,
+                    reason: result.ok ? undefined : result.reason,
+                };
+            },
+        };
+        const controller = createAssistantDockController({
+            transport: createInMemoryAssistantTransport(),
+            registry,
+            actionClient,
+        });
+        const requestId = 'archive-req-1';
+        await controller.previewAction({
+            version: 1,
+            requestId,
+            identity,
+            actionId: 'archive',
+            phase: 'preview',
+            selection: { scope: 'explicit-ids', rowIds: ['order-1'] },
+        });
+        expect(controller.actions.get(requestId)?.status).toBe('previewed');
+        expect(state()).toBe(false); // preview never mutated the surface
+        // applyAction now takes only requestId — it reuses the idempotencyKey
+        // minted once by previewAction (binding decision #2904, build phase 2).
+        await controller.applyAction(requestId);
+        expect(controller.actions.get(requestId)?.status).toBe('applied');
+        expect(state()).toBe(true);
+        expect(events.some((e) => e.type === 'command')).toBe(true);
+        controller.dispose();
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@happyvertical/smrt-svelte",
-  "version": "0.51.5",
+  "version": "0.51.7",
   "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.5",
-    "@happyvertical/smrt-types": "0.51.5",
-    "@happyvertical/smrt-ui": "0.51.5",
-    "@happyvertical/smrt-web": "0.51.5",
+    "@happyvertical/smrt-languages": "0.51.7",
+    "@happyvertical/smrt-types": "0.51.7",
+    "@happyvertical/smrt-ui": "0.51.7",
+    "@happyvertical/smrt-web": "0.51.7",
     "@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.5",
-    "@happyvertical/smrt-chat": "0.51.5",
-    "@happyvertical/smrt-content": "0.51.5",
-    "@happyvertical/smrt-core": "0.51.5",
-    "@happyvertical/smrt-reports": "0.51.5",
-    "@happyvertical/smrt-scanner": "0.51.5",
-    "@happyvertical/smrt-tenancy": "0.51.5",
-    "@happyvertical/smrt-users": "0.51.5",
+    "@happyvertical/smrt-agents": "0.51.7",
+    "@happyvertical/smrt-chat": "0.51.7",
+    "@happyvertical/smrt-content": "0.51.7",
+    "@happyvertical/smrt-core": "0.51.7",
+    "@happyvertical/smrt-reports": "0.51.7",
+    "@happyvertical/smrt-scanner": "0.51.7",
+    "@happyvertical/smrt-tenancy": "0.51.7",
+    "@happyvertical/smrt-users": "0.51.7",
     "@sveltejs/package": "^2.5.8",
     "@sveltejs/vite-plugin-svelte": "^7.1.2",
     "@testing-library/jest-dom": "^6.9.1",