deepspace 0.4.1 → 0.4.2

package/dist/testing.d.ts

@@ -0,0 +1,115 @@
+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 };

package/features/file-attachments/feature.json

@@ -27,6 +27,7 @@
     "@codemirror/lang-javascript": "^6.2.2",
     "@codemirror/theme-one-dark": "^6.1.2",
     "papaparse": "^5.4.1",
+    "@types/papaparse": "^5.3.0",
     "docx-preview": "^0.3.5",
     "exceljs": "^4.4.0",
     "pdfjs-dist": "^4.7.76"

package/features/file-attachments/src/useFilePreview.ts

@@ -413,7 +413,7 @@ async function loadPdfJs(): Promise<typeof import('pdfjs-dist')> {
   pdfjsLoadPromise = (async () => {
     const [pdfjsLib, workerModule] = await Promise.all([
       import('pdfjs-dist'),
-      // @ts-expect-error — Vite's `?worker` suffix yields a Worker constructor.
+      // Vite's `?worker` suffix yields a Worker constructor (typed via vite/client).
       import('pdfjs-dist/build/pdf.worker.min.mjs?worker'),
     ])
     const PdfWorker = (workerModule as { default: new () => Worker }).default

package/features/integration-test/src/IntegrationTestPage.tsx

@@ -40,6 +40,7 @@ interface JsonSchemaProperty {
   minLength?: number
   maxLength?: number
   items?: JsonSchemaProperty
+  properties?: Record<string, JsonSchemaProperty>
 }
 
 type Catalog = Record<string, CatalogEntry[]>

package/features/integration-test/src/integration.spec.ts

@@ -1,16 +1,25 @@
-import { test, expect } from '@playwright/test'
-import { signUp } from './helpers/auth'
+/**
+ * Integration proxy E2E — drives the /integration-test page to exercise
+ * the authenticated billing + proxy flow end to end.
+ *
+ * Public email/password sign-up is disabled, so the authenticated test
+ * signs in as a pre-created test account via the `users` fixture (from
+ * deepspace/testing), which handles sign-in caching, context creation,
+ * and cleanup. Create at least one test account first:
+ *   npx deepspace test-accounts create --email integ@deepspace.test --password TestPass123! --name "Integration Tester"
+ */
+import { test, expect } from 'deepspace/testing'
 
 async function waitForApp(page: import('@playwright/test').Page) {
   await page.waitForSelector('[data-testid="app-navigation"]', { timeout: 15000 })
 }
 
 test.describe('Integration API', () => {
-  test('authenticated user can call OpenAI via integration proxy', async ({ page }) => {
-    await signUp(page, `integ-${Date.now()}@test.local`, { name: 'Integration Tester' })
-    await waitForApp(page)
+  test('authenticated user can call OpenAI via integration proxy', async ({ users }) => {
+    const [{ page }] = await users(1)
 
     await page.goto('/integration-test')
+    await waitForApp(page)
     await page.waitForSelector('[data-testid="integration-submit"]', { timeout: 10000 })
 
     // Default is openai/chat-completion — click submit

package/features/messaging/src/components/chat/MessageList.tsx

@@ -235,7 +235,7 @@ export function MessageList({ channelId, onStartDM }: MessageListProps) {
           if (actionSheet) setEditingMessageId(actionSheet.messageId)
         }}
         onDelete={() => {
-          if (actionSheet) remove(actionSheet.messageId)
+          if (actionSheet) softDelete(actionSheet.messageId)
         }}
         onReply={() => {
           if (actionSheet) setThreadMessageId(actionSheet.messageId)

package/features/presence-test/src/PresenceTestPage.tsx

@@ -95,7 +95,7 @@ export default function PresenceTestPage() {
                 </span>
               </div>
               <div className="text-xs text-muted-foreground space-x-2">
-                {peer.state.cursor && (
+                {!!peer.state.cursor && (
                   <span data-testid={`presence-peer-cursor-${peer.userId}`}>
                     cursor: {(peer.state.cursor as { x: number; y: number }).x},{(peer.state.cursor as { x: number; y: number }).y}
                   </span>

package/features/search-bar/feature.json

@@ -0,0 +1,34 @@
+{
+  "id": "search-bar",
+  "name": "Search Bar",
+  "category": "data",
+  "description": "Drop-in InlineSearch/SearchOverlay for app search; use instead of raw SearchInput when showing or filtering results",
+  "details": "Use this before hand-rolling search over local arrays, feeds, tables, pickers, or RecordRoom records. Installs a component-only search toolkit with lightweight InlineSearch + useSearchIndex for simple in-page filtering, plus SearchOverlay for global/command search, keyboard navigation, grouped results, loading/error/empty states, click selection, optional Enter-to-submit query navigation, opt-in match highlighting, overlay-only recent result and query searches, and a debounced async-search helper. It does not add a route or demo page; import the installed component into the page you are building.",
+  "files": [
+    {
+      "src": "src/SearchOverlay.tsx",
+      "dest": "src/components/search/SearchOverlay.tsx"
+    }
+  ],
+  "requires": [],
+  "instructions": [
+    "Run npx deepspace add search-bar before building any search UI that filters records or displays results; it only installs src/components/search/SearchOverlay.tsx and does not add app routes.",
+    "Prefer InlineSearch + useSearchIndex for simple page, feed, table, list, picker, or RecordRoom filtering instead of composing SearchInput manually.",
+    "Use the raw SearchInput primitive only when you need a bare input with no result list, ranking, keyboard navigation, empty state, or selection handling.",
+    "Use InlineSearch when search belongs to a specific page section and results should appear beneath that input.",
+    "Use SearchOverlay when search is temporary, global, command-like, includes recent searches, submits partial text to a search-results page, or should interrupt the current workflow.",
+    "Pass onSearchSubmit when pressing Enter should navigate to or render a full search-results page for the typed query; result clicks still call onSelect.",
+    "Ask the user which placement they prefer only when both overlay and inline search are plausible and the page context does not make the placement obvious.",
+    "Use SearchOverlay's recentStorageKey, maxRecentItems, and showRecentSearches props when recent selections or submitted text queries should appear before the user types; keep recent searches off inline controls unless the surrounding UI has room for them.",
+    "Use getHighlightedParts with renderTitle, renderSubtitle, or renderDescription when matching text should be highlighted; leave highlighting to app-specific renderers so colors, emphasis, and density match the local design."
+  ],
+  "patterns": [
+    "For local feed/list filtering, keep the source array in the page, derive results with useSearchIndex, map results to SearchItem[], and render InlineSearch where the user expects to search.",
+    "For RecordRoom data, call useQuery in the page and pass records mapped to SearchItem[] into InlineSearch or SearchOverlay.",
+    "For overlay search that previews matching items but routes Enter to a results page, pass onSearchSubmit={(query) => navigate(`/search?q=${encodeURIComponent(query)}`)} and keep onSelect for direct result clicks.",
+    "Keep selections app-specific: create or update records in the onSelect handler only after the user explicitly chooses a result.",
+    "Use mocked or debounced async providers during prototyping before wiring live integration calls.",
+    "For privacy-sensitive search contexts, set showRecentSearches={false} or use a scoped recentStorageKey per page or account context."
+  ],
+  "example": "import { InlineSearch, useSearchIndex } from './components/search/SearchOverlay'\n\nconst results = useSearchIndex({\n  items: posts,\n  query,\n  getText: (post) => [post.title, post.body, post.authorName],\n})\n\n<InlineSearch\n  query={query}\n  onQueryChange={setQuery}\n  items={results.map((post) => ({\n    id: post.id,\n    title: post.title,\n    subtitle: post.authorName,\n    description: post.body,\n  }))}\n  onSelect={(item) => openPost(item.id)}\n  placeholder=\"Search posts...\"\n/>"
+}