deepspace 0.26.0 → 0.26.2

package/features/messaging/src/hooks/useChatChannel.ts

@@ -1,10 +1,10 @@
 /**
- * useChatChannel — Find or create a default chat channel, and auto-join.
+ * useChatChannel — Find or create a default public chat channel.
  *
- * Encapsulates all channel logic so consuming components never need to
- * know about the channels collection. On first mount (when no channel
- * exists yet) it creates a "general" public channel automatically and
- * joins the current user.
+ * Encapsulates default-channel discovery so consuming components never need
+ * to know about the channels collection. On first mount, a member or admin
+ * creates the "general" public channel when none exists. Channel membership
+ * remains optional and is not used as a read-access gate.
  *
  * Usage:
  *   const { channelId, status } = useChatChannel()
@@ -13,9 +13,8 @@
  */
 
 import { useEffect, useRef } from 'react'
-import { useUser } from 'deepspace'
+import { useUser, isWriterRole } from 'deepspace'
 import { useChannels } from 'deepspace'
-import { useChannelMembers } from 'deepspace'
 import type { Channel } from 'deepspace'
 import type { RecordData } from 'deepspace'
 
@@ -24,7 +23,10 @@ const DEFAULT_CHANNEL_NAME = 'general'
 export function useChatChannel(channelName: string = DEFAULT_CHANNEL_NAME) {
   const { user } = useUser()
   const { channels, status, create } = useChannels()
-  const hasInitialized = useRef(false)
+  // Keyed by channel name, not a boolean: the same mounted hook can be
+  // repointed at another channel, which needs its own one-shot create.
+  const initializedFor = useRef<string | null>(null)
+  const canCreateChannel = isWriterRole(user?.role)
 
   // Nothing enforces name uniqueness server-side, so two first visitors can
   // race the one-shot init below and BOTH create the default channel. With a
@@ -43,32 +45,25 @@ export function useChatChannel(channelName: string = DEFAULT_CHANNEL_NAME) {
         a.createdAt.localeCompare(b.createdAt) || a.recordId.localeCompare(b.recordId),
     )[0]
 
-  const { isMember, join, status: membersStatus } = useChannelMembers(defaultChannel?.recordId)
-
   // One-shot initialization: create the default channel if it doesn't exist.
   useEffect(() => {
-    if (!user || status !== 'ready' || hasInitialized.current) return
-    hasInitialized.current = true
+    if (!canCreateChannel || status !== 'ready' || initializedFor.current === channelName) return
+    initializedFor.current = channelName
 
     if (!defaultChannel) {
-      create({
+      void create({
         name: channelName,
-        type: 'public',
         description: 'Default chat channel',
+      }).catch(() => {
+        // A not-ready write already reaches RecordProvider.onWriteError. Allow
+        // a later ready render to retry instead of leaving initialization stuck.
+        initializedFor.current = null
       })
     }
-  }, [user, status, defaultChannel, create, channelName])
-
-  // Wait for the members query to be ready before auto-joining.
-  useEffect(() => {
-    if (!user || !defaultChannel || isMember || membersStatus !== 'ready') return
-    join()
-  }, [user, defaultChannel, isMember, membersStatus, join])
+  }, [canCreateChannel, status, defaultChannel, create, channelName])
 
   return {
     channelId: defaultChannel?.recordId,
     status,
-    isMember,
-    join,
   }
 }

package/features/messaging/src/messaging-schema.ts

@@ -11,7 +11,6 @@ import {
   MESSAGES_SCHEMA,
   REACTIONS_SCHEMA,
   CHANNEL_MEMBERS_SCHEMA,
-  CHANNEL_INVITATIONS_SCHEMA,
   READ_RECEIPTS_SCHEMA,
 } from 'deepspace/schema'
 
@@ -20,6 +19,5 @@ export const messagingSchemas: CollectionSchema[] = [
   MESSAGES_SCHEMA,
   REACTIONS_SCHEMA,
   CHANNEL_MEMBERS_SCHEMA,
-  CHANNEL_INVITATIONS_SCHEMA,
   READ_RECEIPTS_SCHEMA,
 ]

package/features/search-bar/feature.json

@@ -2,39 +2,28 @@
   "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 focused UI and search-model modules for inline or overlay search, ranking, keyboard navigation, grouped results, async search, highlighting, and optional recent searches. It does not add a route or demo page; import the installed modules into the page you are building.",
+  "description": "Inline local search with lightweight ranking and highlighting",
+  "details": "A controlled InlineSearch component and a small local ranking hook. The feature does not own overlays, persistence, history, networking, navigation, or app state.",
   "files": [
     {
       "src": "src/search-model.ts",
       "dest": "src/components/search/search-model.ts"
     },
     {
-      "src": "src/SearchOverlay.tsx",
-      "dest": "src/components/search/SearchOverlay.tsx"
+      "src": "src/InlineSearch.tsx",
+      "dest": "src/components/search/InlineSearch.tsx"
     }
   ],
   "requires": [],
   "instructions": [
-    "Installs src/components/search/SearchOverlay.tsx for UI and src/components/search/search-model.ts for ranking, async search, highlighting, and recent-history behavior. It adds no route.",
-    "Import InlineSearch, SearchOverlay, or SearchResultList from @/components/search/SearchOverlay; import useSearchIndex, useAsyncSearch, or getHighlightedParts from @/components/search/search-model.",
-    "Use InlineSearch + useSearchIndex for in-page filtering (lists, feeds, tables, pickers, RecordRoom records); use SearchOverlay for global/command-style search.",
-    "Use the raw SearchInput primitive only for a bare input with no result list, ranking, keyboard navigation, or selection handling."
+    "Import InlineSearch from @/components/search/InlineSearch and useSearchIndex from @/components/search/search-model.",
+    "Keep source data, async fetching, navigation, and persistence in the page that owns the search experience."
   ],
   "agentNotes": [
-    "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."
+    "Use this feature for local list, feed, table, picker, or RecordRoom filtering. Build a product-specific overlay only when the app actually needs one."
   ],
   "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."
+    "Call useSearchIndex in the page, map results to SearchItem[], and pass the controlled query and selection handler to InlineSearch."
   ],
-  "example": "import { InlineSearch } from '@/components/search/SearchOverlay'\nimport { useSearchIndex } from '@/components/search/search-model'\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/>"
+  "example": "import { InlineSearch } from '@/components/search/InlineSearch'\nimport { useSearchIndex } from '@/components/search/search-model'\n\nconst results = useSearchIndex({ items: posts, query, getText: (post) => [post.title, post.body] })\n\n<InlineSearch query={query} onQueryChange={setQuery} items={results.map((post) => ({ id: post.id, title: post.title, description: post.body }))} onSelect={(item) => openPost(item.id)} />"
 }

package/features/search-bar/src/InlineSearch.tsx

@@ -0,0 +1,101 @@
+import type { ReactNode } from 'react'
+import { EmptyState, SearchInput, cn } from '@/components/ui'
+import { Loader2 } from 'lucide-react'
+import { getHighlightedParts } from './search-model'
+
+export interface SearchItem {
+  id: string
+  title: string
+  subtitle?: string
+  description?: string
+  meta?: ReactNode
+  disabled?: boolean
+}
+
+export interface InlineSearchProps<T extends SearchItem = SearchItem> {
+  query: string
+  onQueryChange: (query: string) => void
+  items: T[]
+  onSelect: (item: T) => void
+  placeholder?: string
+  label?: string
+  loading?: boolean
+  error?: string | null
+  emptyTitle?: string
+  className?: string
+}
+
+/** A small, controlled search input and result list for one page section. */
+export function InlineSearch<T extends SearchItem = SearchItem>({
+  query,
+  onQueryChange,
+  items,
+  onSelect,
+  placeholder = 'Search...',
+  label,
+  loading = false,
+  error = null,
+  emptyTitle = 'No matches',
+  className,
+}: InlineSearchProps<T>) {
+  return (
+    <section className={cn('space-y-2', className)}>
+      {label && <label className="text-sm font-medium text-foreground">{label}</label>}
+      <SearchInput
+        value={query}
+        onChange={(event) => onQueryChange(event.target.value)}
+        onClear={() => onQueryChange('')}
+        placeholder={placeholder}
+        aria-label={label ?? placeholder}
+      />
+
+      {loading ? (
+        <div className="flex items-center gap-2 p-3 text-sm text-muted-foreground">
+          <Loader2 className="size-4 animate-spin" /> Searching...
+        </div>
+      ) : error ? (
+        <p role="alert" className="p-3 text-sm text-destructive">
+          {error}
+        </p>
+      ) : items.length === 0 ? (
+        <EmptyState title={emptyTitle} description="Try another search term." />
+      ) : (
+        <ul className="max-h-80 overflow-y-auto rounded-lg border border-border bg-card">
+          {items.map((item) => (
+            <li key={item.id}>
+              <button
+                type="button"
+                disabled={item.disabled}
+                onClick={() => onSelect(item)}
+                className="flex w-full items-start justify-between gap-3 border-b border-border p-3 text-left last:border-b-0 hover:bg-muted/60 disabled:cursor-not-allowed disabled:opacity-50"
+              >
+                <span className="min-w-0">
+                  <span className="block text-sm font-medium text-foreground">
+                    <HighlightedText text={item.title} query={query} />
+                  </span>
+                  {item.subtitle && (
+                    <span className="mt-0.5 block text-xs text-muted-foreground">
+                      <HighlightedText text={item.subtitle} query={query} />
+                    </span>
+                  )}
+                  {item.description && (
+                    <span className="mt-1 line-clamp-2 block text-sm text-muted-foreground">
+                      {item.description}
+                    </span>
+                  )}
+                </span>
+                {item.meta}
+              </button>
+            </li>
+          ))}
+        </ul>
+      )}
+    </section>
+  )
+}
+
+function HighlightedText({ text, query }: { text: string; query: string }) {
+  return getHighlightedParts(text, query).map((part, index) =>
+    part.match ? <mark key={index}>{part.text}</mark> : <span key={index}>{part.text}</span>,
+  )
+}

package/features/search-bar/src/__tests__/search-model.test.tsx

@@ -0,0 +1,38 @@
+import { renderToStaticMarkup } from 'react-dom/server'
+import { describe, expect, it } from 'vitest'
+import { getHighlightedParts, useSearchIndex } from '../search-model'
+
+const items = [
+  { id: 'middle', title: 'Notes about sheep' },
+  { id: 'exact', title: 'Sheep' },
+  { id: 'prefix', title: 'Sheep counter' },
+]
+
+function ranked(query: string, limit?: number) {
+  let result = items
+  function Probe() {
+    result = useSearchIndex({ items, query, getText: (item) => [item.title], limit })
+    return null
+  }
+  renderToStaticMarkup(<Probe />)
+  return result
+}
+
+describe('inline search model', () => {
+  it('ranks exact and prefix matches before contained matches', () => {
+    expect(ranked('sheep').map((item) => item.id)).toEqual(['exact', 'prefix', 'middle'])
+  })
+
+  it('applies the result limit to searches and empty queries', () => {
+    expect(ranked('sheep', 2)).toHaveLength(2)
+    expect(ranked('', 2)).toEqual(items.slice(0, 2))
+  })
+
+  it('highlights every case-insensitive match without dropping text', () => {
+    expect(getHighlightedParts('Sheep sheep', 'sheep')).toEqual([
+      { text: 'Sheep', match: true },
+      { text: ' ', match: false },
+      { text: 'sheep', match: true },
+    ])
+  })
+})

package/features/search-bar/src/search-model.ts

@@ -1,4 +1,4 @@
-import { useEffect, useMemo, useRef, useState } from 'react'
+import { useMemo } from 'react'
 
 export interface HighlightedPart {
   text: string
@@ -12,6 +12,7 @@ export interface UseSearchIndexOptions<T> {
   limit?: number
 }
 
+/** Rank a local list without owning app state, persistence, or networking. */
 export function useSearchIndex<T>({
   items,
   query,
@@ -58,154 +59,6 @@ export function getHighlightedParts(text: string, query: string): HighlightedPar
   return parts.length > 0 ? parts : [{ text, match: false }]
 }
 
-export interface UseAsyncSearchOptions<T> {
-  query: string
-  search: (query: string) => Promise<T[]>
-  minLength?: number
-  delayMs?: number
-}
-
-export function useAsyncSearch<T>({
-  query,
-  search,
-  minLength = 2,
-  delayMs = 250,
-}: UseAsyncSearchOptions<T>) {
-  const [items, setItems] = useState<T[]>([])
-  const [loading, setLoading] = useState(false)
-  const [error, setError] = useState<string | null>(null)
-  const requestId = useRef(0)
-
-  useEffect(() => {
-    const trimmed = query.trim()
-    const currentRequest = ++requestId.current
-    const requiredLength = Number.isFinite(minLength) ? Math.max(0, Math.floor(minLength)) : 2
-    const waitMs = Number.isFinite(delayMs)
-      ? Math.min(60_000, Math.max(0, Math.floor(delayMs)))
-      : 250
-
-    if (trimmed.length < requiredLength) {
-      setItems([])
-      setLoading(false)
-      setError(null)
-      return
-    }
-
-    setLoading(true)
-    setError(null)
-
-    const timer = window.setTimeout(() => {
-      void search(trimmed)
-        .then((results) => {
-          if (requestId.current !== currentRequest) return
-          setItems(results)
-          setError(null)
-        })
-        .catch((searchError) => {
-          if (requestId.current !== currentRequest) return
-          setItems([])
-          setError(searchError instanceof Error ? searchError.message : 'Search failed')
-        })
-        .finally(() => {
-          if (requestId.current === currentRequest) setLoading(false)
-        })
-    }, waitMs)
-
-    return () => {
-      window.clearTimeout(timer)
-      if (requestId.current === currentRequest) requestId.current += 1
-    }
-  }, [delayMs, minLength, query, search])
-
-  return { items, loading, error }
-}
-
-export type RecentSearchEntry = { kind: 'item'; itemId: string } | { kind: 'query'; query: string }
-
-export function createRecentStorageKey(
-  title: string,
-  placeholder: string,
-  triggerLabel: string,
-): string {
-  const scope =
-    [title, placeholder, triggerLabel].map((value) => value.trim().toLowerCase()).find(Boolean) ??
-    'search'
-  const normalizedScope = scope.replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '') || 'search'
-  return `deepspace:search-bar:recent:${normalizedScope}`
-}
-
-export function readRecentSearches(storageKey: string, maxItems: number): RecentSearchEntry[] {
-  try {
-    const parsed: unknown = JSON.parse(window.localStorage.getItem(storageKey) ?? '[]')
-    if (!Array.isArray(parsed)) return []
-    return parsed.filter(isRecentSearchEntry).slice(0, normalizeLimit(maxItems))
-  } catch {
-    return []
-  }
-}
-
-export function rememberRecentItem(
-  storageKey: string,
-  itemId: string,
-  maxItems: number,
-): RecentSearchEntry[] {
-  if (!itemId) return readRecentSearches(storageKey, maxItems)
-  return rememberRecent(
-    storageKey,
-    { kind: 'item', itemId },
-    (entry) => entry.kind === 'item' && entry.itemId === itemId,
-    maxItems,
-  )
-}
-
-export function rememberRecentQuery(
-  storageKey: string,
-  rawQuery: string,
-  maxItems: number,
-): RecentSearchEntry[] {
-  const query = rawQuery.trim()
-  const normalizedQuery = normalize(query)
-  if (!normalizedQuery) return readRecentSearches(storageKey, maxItems)
-  return rememberRecent(
-    storageKey,
-    { kind: 'query', query },
-    (entry) => entry.kind === 'query' && normalize(entry.query) === normalizedQuery,
-    maxItems,
-  )
-}
-
-function rememberRecent(
-  storageKey: string,
-  recent: RecentSearchEntry,
-  matches: (entry: RecentSearchEntry) => boolean,
-  maxItems: number,
-): RecentSearchEntry[] {
-  const next = [
-    recent,
-    ...readRecentSearches(storageKey, maxItems).filter((entry) => !matches(entry)),
-  ].slice(0, normalizeLimit(maxItems))
-
-  try {
-    window.localStorage.setItem(storageKey, JSON.stringify(next))
-  } catch {
-    // Persistence is optional; search continues with the in-memory result.
-  }
-  return next
-}
-
-function isRecentSearchEntry(value: unknown): value is RecentSearchEntry {
-  if (!value || typeof value !== 'object') return false
-  const candidate = value as Partial<RecentSearchEntry>
-  if (candidate.kind === 'item') return typeof candidate.itemId === 'string' && !!candidate.itemId
-  return (
-    candidate.kind === 'query' && typeof candidate.query === 'string' && !!candidate.query.trim()
-  )
-}
-
-function normalizeLimit(value: number): number {
-  return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0
-}
-
 function normalize(value: string): string {
   return value.trim().toLowerCase()
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepspace",
-  "version": "0.26.0",
+  "version": "0.26.2",
   "engines": {
     "node": ">=22.15.0 <23 || >=24 <25 || >=26 <27"
   },