deepspace 0.6.2 → 0.7.0

package/features/ai-chat/src/ChatPanel.tsx

@@ -7,6 +7,7 @@
  */
 
 import {
+  memo,
   useState,
   useRef,
   useEffect,
@@ -179,6 +180,12 @@ function useStreamingChat(
       if (isLoadingRef.current) return
       setError(null)
       lastSendRef.current = { content }
+      // Claim the in-flight slot BEFORE any await. The auto-create below is a
+      // real network round-trip; setting the guard only after it would let a
+      // second send() slip through with chatId still null and create a second
+      // chat (double-create race, orphaning the first turn).
+      isLoadingRef.current = true
+      setIsLoading(true)
 
       let activeChatId = chatId
       if (!activeChatId) {
@@ -198,6 +205,8 @@ function useStreamingChat(
           onChatCreated?.(activeChatId)
         } catch (err) {
           setError(err instanceof Error ? err : new Error(String(err)))
+          isLoadingRef.current = false
+          setIsLoading(false)
           return
         }
       }
@@ -209,8 +218,6 @@ function useStreamingChat(
       const userMsg: InFlightMessage = { id: userMessageId, role: 'user', content, parts: [], forChatId: activeChatId }
       const asstMsg: InFlightMessage = { id: assistantId, role: 'assistant', content: '', parts: [], forChatId: activeChatId }
       setInFlight([userMsg, asstMsg])
-      isLoadingRef.current = true
-      setIsLoading(true)
       abortRef.current = new AbortController()
 
       try {
@@ -506,15 +513,24 @@ export function ChatPanel({
     orderDir: 'asc',
   })
 
-  const messages: RenderMessage[] = useMemo(() => {
-    const persisted: RenderMessage[] = persistedRecords.map((r) => ({
-      id: r.recordId,
-      role: r.data.role,
-      content: r.data.content ?? '',
-      parts: r.data.parts,
-    }))
-    const persistedIds = new Set(persisted.map((m) => m.id))
+  // Persisted rows change only when the WS query delivers; mapping them (and
+  // building the id Set) in their own memos keeps that O(history) work out of
+  // the per-token recompute below AND keeps row object identities stable
+  // across streamed chunks, which is what lets memo(MessageTurn) skip
+  // re-rendering (and re-parsing markdown for) every finished turn.
+  const persisted: RenderMessage[] = useMemo(
+    () =>
+      persistedRecords.map((r) => ({
+        id: r.recordId,
+        role: r.data.role,
+        content: r.data.content ?? '',
+        parts: r.data.parts,
+      })),
+    [persistedRecords],
+  )
+  const persistedIds = useMemo(() => new Set(persisted.map((m) => m.id)), [persisted])
 
+  const messages: RenderMessage[] = useMemo(() => {
     const tail = inFlight.filter((m) => {
       // Only render in-flight items that belong to the chat we're currently
       // viewing. Prevents the previous chat's bubbles from leaking through
@@ -530,7 +546,7 @@ export function ChatPanel({
       return true
     })
     return [...persisted, ...tail]
-  }, [persistedRecords, inFlight, chatId])
+  }, [persisted, persistedIds, inFlight, chatId])
 
   const [input, setInput] = useState('')
 
@@ -550,8 +566,12 @@ export function ChatPanel({
   useEffect(() => {
     const el = scrollRef.current
     if (!el || !stickToBottomRef.current) return
-    el.scrollTo({ top: el.scrollHeight, behavior: 'smooth' })
-  }, [messages])
+    // While streaming, chunks arrive faster than a smooth scroll completes —
+    // each restart leaves the view lagging the newest text and pays an extra
+    // animation. Jump instantly during the stream; ease only for discrete
+    // changes (history load, completed turn).
+    el.scrollTo({ top: el.scrollHeight, behavior: isLoading ? 'auto' : 'smooth' })
+  }, [messages, isLoading])
 
   // Auto-grow textarea, capped at 200px.
   useEffect(() => {
@@ -578,6 +598,10 @@ export function ChatPanel({
   }
 
   function onKeyDown(e: KeyboardEvent<HTMLTextAreaElement>) {
+    // IME composition: the Enter that COMMITS a CJK composition fires keydown
+    // with isComposing=true (keyCode 229 on older WebKit) — it must confirm
+    // the text, not send the half-composed message.
+    if (e.nativeEvent.isComposing || e.keyCode === 229) return
     if (e.key === 'Enter' && !e.shiftKey) {
       e.preventDefault()
       submit()
@@ -728,7 +752,12 @@ interface MessageTurnProps {
   isStreaming: boolean
 }
 
-function MessageTurn({ role, content, parts, isStreaming }: MessageTurnProps) {
+// memo: every streamed chunk and composer keystroke re-renders ChatPanel and
+// with it the whole turn list. Finished turns receive referentially stable
+// props (see the `persisted` memo), so memo lets them skip the re-render —
+// and with it a full ReactMarkdown re-parse per turn per chunk. Only the
+// actively streaming row's props change, so only it re-renders.
+const MessageTurn = memo(function MessageTurn({ role, content, parts, isStreaming }: MessageTurnProps) {
   const orderedParts: MessagePart[] = useMemo(() => {
     if (Array.isArray(parts) && parts.length > 0) {
       const cast = parts as MessagePart[]
@@ -804,9 +833,9 @@ function MessageTurn({ role, content, parts, isStreaming }: MessageTurnProps) {
                          [&_td]:border [&_td]:border-border [&_td]:px-2 [&_td]:py-1"
             >
               <ReactMarkdown
-                remarkPlugins={[remarkGfm, remarkBreaks]}
-                rehypePlugins={[rehypeHighlight]}
-                components={{ pre: CodeBlock, a: ExternalLink }}
+                remarkPlugins={REMARK_PLUGINS}
+                rehypePlugins={REHYPE_PLUGINS}
+                components={MARKDOWN_COMPONENTS}
               >
                 {text}
               </ReactMarkdown>
@@ -822,7 +851,7 @@ function MessageTurn({ role, content, parts, isStreaming }: MessageTurnProps) {
       {isStreaming && <LiveIndicator />}
     </div>
   )
-}
+})
 
 // ----- Empty state --------------------------------------------------------
 
@@ -943,6 +972,15 @@ const ExternalLink: Components['a'] = ({ children, href, node: _node, ...props }
   )
 }
 
+// Module-level so ReactMarkdown's props stay referentially stable across
+// renders — inline literals would defeat memo(MessageTurn) and re-run the
+// remark/rehype parse for every finished turn on every streamed chunk.
+// (Defined after CodeBlock/ExternalLink: they are const components, so an
+// earlier literal would hit their temporal dead zone at module init.)
+const REMARK_PLUGINS = [remarkGfm, remarkBreaks]
+const REHYPE_PLUGINS = [rehypeHighlight]
+const MARKDOWN_COMPONENTS = { pre: CodeBlock, a: ExternalLink }
+
 function ToolRow({ inv }: { inv: ToolInvocation }) {
   const done = inv.state === 'result'
   const failed = done && inv.result?.success === false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepspace",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "engines": {
     "node": ">=22.15.0"
   },

package/dist/testing.d.ts

@@ -1,115 +0,0 @@
-import * as _playwright_test from '@playwright/test';
-import { BrowserContext, Page, Browser } from '@playwright/test';
-export { expect } from '@playwright/test';
-
-interface MultiplayerUser {
-    context: BrowserContext;
-    page: Page;
-    email: string;
-    name: string;
-    /** Test account user ID, if known from the accounts registry. */
-    userId?: string;
-}
-/**
- * Fixture function signature. Pass either a count (`users(2)`) or an
- * array of account names (`users(['Alice', 'Bob'])`). Returns one entry
- * per requested user.
- */
-type UsersFixture = (selector: number | string[], options?: {
-    label?: string;
-}) => Promise<MultiplayerUser[]>;
-interface MultiplayerFixtures {
-    users: UsersFixture;
-}
-declare const test: _playwright_test.TestType<_playwright_test.PlaywrightTestArgs & _playwright_test.PlaywrightTestOptions & MultiplayerFixtures, _playwright_test.PlaywrightWorkerArgs & _playwright_test.PlaywrightWorkerOptions>;
-
-/**
- * Account-credential plumbing for the testing module.
- *
- * Reads test accounts from `~/.deepspace/test-accounts.json` (the same
- * file `deepspace test-accounts create` writes). Each account has at
- * minimum `{email, password}`; `name` and `label` are optional.
- *
- * Used by the multi-user Playwright fixture in `./fixtures.ts` and is
- * also exported standalone in case suites want to do their own
- * orchestration.
- */
-interface TestAccount {
-    email: string;
-    password: string;
-    name?: string;
-    label?: string | null;
-    id?: string;
-    userId?: string;
-    createdAt?: number;
-}
-/**
- * Load all test accounts the developer has created. Returns an empty
- * array if the file doesn't exist yet.
- */
-declare function loadAllTestAccounts(): TestAccount[];
-/**
- * Pick `count` test accounts from the local registry, optionally
- * filtered by `label`. Order-stable: sorted by `createdAt` ascending so
- * the first test account you created is always the first one returned.
- *
- * Throws with a helpful message if not enough accounts exist.
- */
-declare function pickTestAccounts(count: number, options?: {
-    label?: string;
-}): TestAccount[];
-/**
- * Find a single account by name. Used by `users(['Alice', 'Bob'])`.
- * Throws if not found.
- */
-declare function findTestAccountByName(name: string): TestAccount;
-
-/**
- * Per-account `storageState` cache for Playwright.
- *
- * Better Auth applies a per-IP rate limit on `/api/auth/sign-in/email`
- * (~5 sign-ins / 60s / endpoint). A multiplayer suite that spins up
- * 5+ users per spec would hit the limit and start failing in non-obvious
- * ways. This module signs each account in *once*, persists the
- * resulting browser cookies + storage to disk, and reuses the file on
- * subsequent runs.
- *
- * Cache layout:
- *   ~/.deepspace/playwright-states/<sha256(email)>.json
- *
- * Validity: a cached file is reused if Playwright successfully loads it
- * AND the resulting context produces a non-anonymous session on the
- * target app. If validation fails, we fall back to a fresh sign-in and
- * overwrite the cache.
- */
-
-interface EnsureStorageStateOptions {
-    /** Max age of a cached state file before we re-sign-in. Default 7 days. */
-    maxAgeMs?: number;
-    /** Force a fresh sign-in even if the cache is fresh. */
-    force?: boolean;
-}
-/**
- * Ensure a Playwright `storageState` file exists for `account` and
- * return its path. Signs in once if the cache is missing, stale, or
- * `force: true`.
- */
-declare function ensureStorageState(browser: Browser, account: {
-    email: string;
-    password: string;
-}, baseURL: string, options?: EnsureStorageStateOptions): Promise<string>;
-/**
- * Convenience: open a fresh `BrowserContext` for `account` using the
- * cached storage state (signing in if needed). The caller is responsible
- * for closing the context.
- */
-declare function newSignedInContext(browser: Browser, account: {
-    email: string;
-    password: string;
-}, baseURL: string, options?: EnsureStorageStateOptions): Promise<BrowserContext>;
-/** Read a cached storageState file (mostly for debugging). */
-declare function readCachedState(email: string): unknown | null;
-/** Where the cache for `email` lives. Useful for diagnostics. */
-declare function getStatePathForEmail(email: string): string;
-
-export { type EnsureStorageStateOptions, type MultiplayerUser, type TestAccount, type UsersFixture, ensureStorageState, findTestAccountByName, getStatePathForEmail, loadAllTestAccounts, newSignedInContext, pickTestAccounts, readCachedState, test };