@xh/hoist 82.0.0 → 82.0.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 82.0.1 - 2026-02-28
+
+### 🐞 Bug Fixes
+
+* Fixed a CSS issue causing desktop submenus to clip.
+
+### ⚙️ Technical
+
+* Enhanced the MCP server's `hoist-search-symbols` tool to also search public members (properties,
+  methods, accessors) of 18 key framework classes. The TypeScript index is now built asynchronously
+  after server startup so the first tool call doesn't pay the initialization cost.
+
 ## 82.0.0 - 2026-02-27
 
 Note that a server-side upgrade to `hoist-core >= 36.3` is recommended to support new Admin Metrics

package/kit/blueprint/styles.scss

@@ -80,12 +80,6 @@
     0 20px 25px -5px rgba(0, 0, 0, 0.1),
     0 10px 15px -3px rgba(0, 0, 0, 0.1);
 
-  // Clip content children to the popover's rounded corners so square-edged inner
-  // elements (e.g. scrollable lists) don't poke through at the border-radius.
-  .bp6-popover-content {
-    overflow: hidden;
-  }
-
   // Arrow border matches the popover border; arrow fill matches the popover background.
   .bp6-popover-arrow-border {
     fill: var(--xh-popup-border-color);

package/mcp/README.md

@@ -85,12 +85,14 @@ curated metadata (title, description, category, search keywords) that cannot be
 from filenames alone. The metadata is aligned with the `docs/README.md` index tables. The
 tradeoff is manual maintenance -- see [Maintaining the MCP Server](#maintaining-the-mcp-server).
 
-**Lazy TypeScript initialization with eager indexing.** Parsing hoist-react's ~700 TypeScript files
-with ts-morph is expensive. The `Project` is created lazily on first TypeScript tool invocation
-(not at server startup), keeping cold start fast. Once created, a lightweight symbol index
-(name-to-location map) is built eagerly using AST-level methods (`getClasses()`,
-`getInterfaces()`, etc.) rather than full type resolution. Detailed symbol information (signatures,
-JSDoc, members) is extracted on-demand from individual source files.
+**Eager async TypeScript initialization.** Parsing hoist-react's ~700 TypeScript files with ts-morph
+is expensive (~2-3s). After the server connects, `beginInitialization()` kicks off index building
+asynchronously so it runs in the background while the client sets up. If a tool call arrives before
+init completes, `ensureInitialized()` awaits the in-flight work. In practice, the index is
+typically ready before the first tool invocation. The symbol and member indexes are built using
+AST-level methods (`getClasses()`, `getInterfaces()`, etc.) rather than full type resolution.
+Detailed symbol information (signatures, JSDoc, full member lists) is extracted on-demand from
+individual source files.
 
 **Resources for nouns, tools for verbs.** Following MCP protocol design guidance: resources serve
 passive, addressable content (individual docs by URI), while tools handle dynamic computation
@@ -214,17 +216,24 @@ Verify the MCP server is running and responsive. Takes no parameters.
 
 #### `hoist-search-symbols`
 
-Search for TypeScript classes, interfaces, types, and functions by name.
+Search for TypeScript classes, interfaces, types, and functions by name. Also searches public
+members (properties, methods, accessors) of key framework classes, returning results in two sections:
+matching symbols and matching members with their owning class and role description.
 
 | Parameter | Type | Required | Description |
 |-----------|------|----------|-------------|
-| `query` | string | Yes | Symbol name or partial name (e.g. `"GridModel"`, `"Store"`) |
-| `kind` | enum | No | Filter: `class`, `interface`, `type`, `function`, `const`, `enum` |
+| `query` | string | Yes | Symbol or member name to search for (e.g. `"GridModel"`, `"lastLoadCompleted"`, `"setSortBy"`) |
+| `kind` | enum | No | Filter symbols by kind: `class`, `interface`, `type`, `function`, `const`, `enum`. Does not affect member results. |
 | `exported` | boolean | No | Exported symbols only. Default: `true` |
-| `limit` | number | No | Max results, 1-50. Default: 20 |
+| `limit` | number | No | Max symbol results, 1-50. Default: 20. Member results have a separate cap of 15. |
 
-**Note:** The TypeScript index is built lazily on first invocation (typically under 5 seconds).
-Subsequent calls are fast.
+**Member-indexed classes:** HoistBase, HoistModel, HoistService, XHApi, GridModel, Column, Store,
+StoreRecord, StoreSelectionModel, Field, RecordAction, Cube, CubeField, View, FormModel,
+BaseFieldModel, FieldModel, TabContainerModel. Only public members are indexed (private members and
+those prefixed with `_` are excluded).
+
+**Note:** The TypeScript index is built asynchronously after server startup (~2-3s). It is typically
+ready before the first tool call. Subsequent calls are fast in-memory lookups.
 
 #### `hoist-get-symbol`
 
@@ -373,6 +382,26 @@ const TOP_LEVEL_PACKAGES = [
 ];
 ```
 
+### Member-Indexed Classes
+
+**File:** `mcp/data/ts-registry.ts` (constant `MEMBER_INDEXED_CLASSES`)
+
+This map lists classes whose public members are indexed for search by member name via
+`hoist-search-symbols`. Each entry maps a class name to a brief role description shown alongside
+member search results (e.g. "base class for all application models").
+
+**When to update:**
+- A new key base class is added to the framework and should have its members searchable
+- A member-indexed class is renamed or removed
+- The role description of a class should be clarified
+
+**Current value:**
+```
+HoistBase, HoistModel, HoistService, XHApi, GridModel, Column, Store,
+StoreRecord, StoreSelectionModel, Field, RecordAction, Cube, CubeField,
+View, FormModel, BaseFieldModel, FieldModel, TabContainerModel
+```
+
 ### Prompt Documentation Section References
 
 **Files:** `mcp/prompts/grid.ts`, `mcp/prompts/form.ts`, `mcp/prompts/tabs.ts`
@@ -429,6 +458,7 @@ were replaced, or if `makeObservable` were no longer required.
 | Add/rename/remove a documentation file | `mcp/data/doc-registry.ts`, `docs/README.md` |
 | Add upgrade notes for a new major version | `mcp/data/doc-registry.ts`, `docs/README.md` |
 | Add/rename/remove a top-level package | `mcp/data/ts-registry.ts` |
+| Add/rename/remove a member-indexed class | `mcp/data/ts-registry.ts` (constant `MEMBER_INDEXED_CLASSES`) |
 | Rename a section header in a component README | Check `mcp/prompts/grid.ts`, `form.ts`, `tabs.ts` |
 | Rename a key class or remove a key member | Check `mcp/prompts/grid.ts`, `form.ts`, `tabs.ts` |
 | Change a fundamental coding convention | `mcp/prompts/util.ts` |

package/mcp/data/ts-registry.ts

@@ -6,12 +6,15 @@
  * information. This module is consumed by the three TypeScript MCP tools:
  * hoist-search-symbols, hoist-get-symbol, and hoist-get-members.
  *
- * The ts-morph Project is created lazily (on first invocation, not at server
- * startup) to avoid cold start delays. Once created, a lightweight symbol
- * index is eagerly built using AST-level methods for fast search without
- * per-query AST traversal. Detailed symbol info is extracted on-demand.
+ * Initialization is kicked off asynchronously after server startup via
+ * `beginInitialization()`, so the index is typically ready before the first
+ * tool call arrives. If a tool call arrives before init completes,
+ * `ensureInitialized()` awaits the in-flight init. Once created, a
+ * lightweight symbol index and parallel member index are built using
+ * AST-level methods for fast search without per-query AST traversal.
+ * Detailed symbol info is extracted on-demand.
  */
-import {Project, Node, SyntaxKind} from 'ts-morph';
+import {Project, Node, Scope, SyntaxKind} from 'ts-morph';
 import type {ClassDeclaration, SourceFile} from 'ts-morph';
 import {resolve} from 'node:path';
 
@@ -61,12 +64,27 @@ export interface MemberInfo {
     returnType?: string;
 }
 
+/** Lightweight index entry for a class member, enabling search by member name. */
+export interface MemberIndexEntry {
+    name: string;
+    memberKind: 'property' | 'method' | 'accessor';
+    ownerName: string;
+    ownerDescription: string;
+    filePath: string;
+    sourcePackage: string;
+    isStatic: boolean;
+    type: string;
+    jsDoc: string;
+    decorators: string[];
+}
+
 //------------------------------------------------------------------
 // Module state (lazy initialization)
 //------------------------------------------------------------------
 
 let project: Project | null = null;
 let symbolIndex: Map<string, SymbolEntry[]> | null = null;
+let memberIndex: Map<string, MemberIndexEntry[]> | null = null;
 
 //------------------------------------------------------------------
 // Package derivation
@@ -92,6 +110,43 @@ const TOP_LEVEL_PACKAGES = [
     'icon'
 ];
 
+/**
+ * Classes whose public members are indexed for search by member name.
+ * Values are brief role descriptions shown in search results to clarify
+ * how the class fits into the framework hierarchy.
+ */
+const MEMBER_INDEXED_CLASSES = new Map([
+    // Core framework base classes
+    ['HoistBase', 'base class for all Hoist objects (models, services, stores)'],
+    ['HoistModel', 'base class for all application models'],
+    ['HoistService', 'base class for all application services'],
+    ['XHApi', 'singleton (XH) providing global framework services'],
+
+    // Grid
+    ['GridModel', 'model backing all grid components'],
+    ['Column', 'column configuration for grids'],
+
+    // Data
+    ['Store', 'in-memory data store used by grids and other data components'],
+    ['StoreRecord', 'individual record within a Store'],
+    ['StoreSelectionModel', 'selection state manager for Store, used by grids'],
+    ['Field', 'metadata for a data field within a Store or Cube'],
+    ['RecordAction', 'reusable action for grid context menus and action columns'],
+
+    // Cube
+    ['Cube', 'multi-dimensional data store with aggregation and views'],
+    ['CubeField', 'field with aggregation metadata for use within a Cube'],
+    ['View', 'live or snapshot view of aggregated Cube data'],
+
+    // Form
+    ['FormModel', 'model for form state, field values, and validation'],
+    ['BaseFieldModel', 'base class for FieldModel — holds value, validation, and dirty tracking'],
+    ['FieldModel', 'model for a single form field (extends BaseFieldModel)'],
+
+    // Tabs
+    ['TabContainerModel', 'model for tabbed container with routing and refresh support']
+]);
+
 /**
  * Derive the source package from a file's absolute path.
  * e.g. `/repo/core/HoistBase.ts` maps to `core`,
@@ -134,18 +189,68 @@ function addToIndex(index: Map<string, SymbolEntry[]>, entry: SymbolEntry): void
     }
 }
 
+/** Add a member entry to the member index, keyed by lowercase member name. */
+function addToMemberIndex(index: Map<string, MemberIndexEntry[]>, entry: MemberIndexEntry): void {
+    const key = entry.name.toLowerCase();
+    const existing = index.get(key);
+    if (existing) {
+        existing.push(entry);
+    } else {
+        index.set(key, [entry]);
+    }
+}
+
+/**
+ * Check if a member should be excluded from the index as private/internal.
+ * Excludes members with the `private` keyword or names starting with `_`.
+ */
+function isPrivateMember(member: MemberInfo, cls: ClassDeclaration): boolean {
+    if (member.name.startsWith('_')) return true;
+
+    // Check for explicit `private` keyword on the AST node
+    try {
+        const node =
+            cls.getProperty(member.name) ??
+            cls.getGetAccessor(member.name) ??
+            cls.getMethod(member.name) ??
+            cls.getStaticProperty(member.name) ??
+            cls.getStaticMethod(member.name);
+        if (node) {
+            const scope = (node as unknown as {getScope?: () => string}).getScope?.();
+            if (scope === Scope.Private) return true;
+        }
+    } catch {
+        // If we can't determine scope, keep the member (assume public)
+    }
+
+    return false;
+}
+
+/** Format a method's parameter list and return type as a compact type string. */
+function formatMethodType(member: MemberInfo): string {
+    const params = (member.parameters ?? []).map(p => `${p.name}: ${p.type}`).join(', ');
+    const ret = member.returnType ?? 'void';
+    return `(${params}) => ${ret}`;
+}
+
 /**
  * Build the symbol index by scanning all source files using AST-level methods.
+ * Also builds a parallel member index for classes in MEMBER_INDEXED_CLASSES.
  *
  * Uses getClasses(), getInterfaces(), getTypeAliases(), getFunctions(),
  * getEnums(), and getVariableStatements() -- NOT getExportedDeclarations(),
  * which triggers full type binding and is ~1000x slower.
  */
-function buildSymbolIndex(proj: Project): Map<string, SymbolEntry[]> {
+function buildSymbolIndex(proj: Project): {
+    symbols: Map<string, SymbolEntry[]>;
+    members: Map<string, MemberIndexEntry[]>;
+} {
     const index = new Map<string, SymbolEntry[]>();
+    const mIndex = new Map<string, MemberIndexEntry[]>();
     const repoRoot = resolveRepoRoot();
 
     const counts = {total: 0, exported: 0, byKind: {} as Record<string, number>};
+    let memberCount = 0;
 
     for (const sourceFile of proj.getSourceFiles()) {
         const filePath = sourceFile.getFilePath();
@@ -182,6 +287,33 @@ function buildSymbolIndex(proj: Project): Map<string, SymbolEntry[]> {
             counts.total++;
             if (entry.isExported) counts.exported++;
             counts.byKind['class'] = (counts.byKind['class'] || 0) + 1;
+
+            // Index public members for curated framework classes
+            const ownerDescription = MEMBER_INDEXED_CLASSES.get(name);
+            if (ownerDescription) {
+                try {
+                    const members = extractClassMembers(sourceFile, name);
+                    for (const m of members) {
+                        if (isPrivateMember(m, cls)) continue;
+                        const mEntry: MemberIndexEntry = {
+                            name: m.name,
+                            memberKind: m.kind,
+                            ownerName: name,
+                            ownerDescription,
+                            filePath,
+                            sourcePackage: pkg,
+                            isStatic: m.isStatic,
+                            type: m.kind === 'method' ? formatMethodType(m) : m.type,
+                            jsDoc: m.jsDoc.split('\n')[0],
+                            decorators: m.decorators
+                        };
+                        addToMemberIndex(mIndex, mEntry);
+                        memberCount++;
+                    }
+                } catch (e) {
+                    log.warn(`Failed to index members for ${name}: ${e}`);
+                }
+            }
         }
 
         // Interfaces
@@ -280,21 +412,22 @@ function buildSymbolIndex(proj: Project): Map<string, SymbolEntry[]> {
     log.info(
         `Symbol index built: ${counts.total} total symbols (${counts.exported} exported) -- ${kindSummary}`
     );
+    log.info(
+        `Member index built: ${memberCount} public members across ${MEMBER_INDEXED_CLASSES.size} classes`
+    );
 
-    return index;
+    return {symbols: index, members: mIndex};
 }
 
 //------------------------------------------------------------------
 // Public API
 //------------------------------------------------------------------
 
-/**
- * Ensure the ts-morph Project and symbol index are initialized.
- *
- * Creates the Project lazily on first call, then eagerly builds the symbol
- * index. Subsequent calls return immediately. Safe to call multiple times.
- */
-export function ensureInitialized(): void {
+/** Promise for in-flight initialization, used to coordinate eager and on-demand init. */
+let initPromise: Promise<void> | null = null;
+
+/** Synchronous init — heavy lifting, runs on a microtask when kicked off eagerly. */
+function doInitialize(): void {
     if (project) return;
 
     const startMs = Date.now();
@@ -305,7 +438,9 @@ export function ensureInitialized(): void {
     });
     project.resolveSourceFileDependencies();
 
-    symbolIndex = buildSymbolIndex(project);
+    const result = buildSymbolIndex(project);
+    symbolIndex = result.symbols;
+    memberIndex = result.members;
 
     const elapsed = Date.now() - startMs;
     log.info(`TypeScript registry initialized in ${elapsed}ms`);
@@ -314,17 +449,44 @@ export function ensureInitialized(): void {
     }
 }
 
+/**
+ * Begin TypeScript registry initialization in the background.
+ *
+ * Call this after server startup to warm the index asynchronously, so the
+ * first tool invocation doesn't pay the full init cost. Safe to call
+ * multiple times — subsequent calls are no-ops.
+ */
+export function beginInitialization(): void {
+    if (project || initPromise) return;
+    initPromise = Promise.resolve().then(() => {
+        doInitialize();
+        initPromise = null;
+    });
+}
+
+/**
+ * Ensure the ts-morph Project and symbol index are initialized.
+ *
+ * If {@link beginInitialization} was called, awaits the in-flight init.
+ * Otherwise initializes synchronously. Safe to call multiple times.
+ */
+export async function ensureInitialized(): Promise<void> {
+    if (project) return;
+    if (initPromise) return initPromise;
+    doInitialize();
+}
+
 /**
  * Search the symbol index by query string.
  *
  * Supports case-insensitive substring matching against symbol names.
  * Optionally filter by kind and/or export status.
  */
-export function searchSymbols(
+export async function searchSymbols(
     query: string,
     options?: {kind?: SymbolKind; exported?: boolean; limit?: number}
-): SymbolEntry[] {
-    ensureInitialized();
+): Promise<SymbolEntry[]> {
+    await ensureInitialized();
 
     const queryLower = query.toLowerCase().trim();
     if (!queryLower) return [];
@@ -358,6 +520,44 @@ export function searchSymbols(
     return results.slice(0, limit);
 }
 
+/**
+ * Search the member index by query string.
+ *
+ * Supports case-insensitive substring matching against member names.
+ * Only searches members of classes in MEMBER_INDEXED_CLASSES.
+ */
+export async function searchMembers(
+    query: string,
+    options?: {limit?: number}
+): Promise<MemberIndexEntry[]> {
+    await ensureInitialized();
+
+    const queryLower = query.toLowerCase().trim();
+    if (!queryLower) return [];
+
+    const limit = options?.limit ?? 15;
+    const results: MemberIndexEntry[] = [];
+
+    for (const [key, entries] of memberIndex!) {
+        if (!key.includes(queryLower)) continue;
+        results.push(...entries);
+    }
+
+    // Sort: exact matches first, then alphabetically by member name, then by owner
+    results.sort((a, b) => {
+        const aExact = a.name.toLowerCase() === queryLower ? 0 : 1;
+        const bExact = b.name.toLowerCase() === queryLower ? 0 : 1;
+        if (aExact !== bExact) return aExact - bExact;
+
+        const nameCompare = a.name.localeCompare(b.name);
+        if (nameCompare !== 0) return nameCompare;
+
+        return a.ownerName.localeCompare(b.ownerName);
+    });
+
+    return results.slice(0, limit);
+}
+
 /**
  * Get detailed information about a specific symbol.
  *
@@ -365,8 +565,11 @@ export function searchSymbols(
  * If filePath is provided, filters to that specific file. If multiple matches
  * and no filePath, returns the first exported match.
  */
-export function getSymbolDetail(name: string, filePath?: string): SymbolDetail | null {
-    ensureInitialized();
+export async function getSymbolDetail(
+    name: string,
+    filePath?: string
+): Promise<SymbolDetail | null> {
+    await ensureInitialized();
 
     const entry = findIndexEntry(name, filePath);
     if (!entry) return null;
@@ -384,11 +587,11 @@ export function getSymbolDetail(name: string, filePath?: string): SymbolDetail |
  *
  * Returns null for symbol kinds other than class or interface.
  */
-export function getMembers(
+export async function getMembers(
     name: string,
     filePath?: string
-): {symbol: SymbolDetail; members: MemberInfo[]} | null {
-    ensureInitialized();
+): Promise<{symbol: SymbolDetail; members: MemberInfo[]} | null> {
+    await ensureInitialized();
 
     const entry = findIndexEntry(name, filePath);
     if (!entry) return null;

package/mcp/prompts/form.ts

@@ -82,8 +82,8 @@ export async function buildFormPrompt(args: {
     //------------------------------------------------------------------
     // Type information
     //------------------------------------------------------------------
-    const formModelSummary = formatSymbolSummary('FormModel');
-    const formModelMembers = formatKeyMembers('FormModel', [
+    const formModelSummary = await formatSymbolSummary('FormModel');
+    const formModelMembers = await formatKeyMembers('FormModel', [
         'fields',
         'values',
         'isValid',
@@ -92,7 +92,7 @@ export async function buildFormPrompt(args: {
         'reset',
         'getData'
     ]);
-    const fieldModelSummary = formatSymbolSummary('FieldModel');
+    const fieldModelSummary = await formatSymbolSummary('FieldModel');
 
     //------------------------------------------------------------------
     // Build adaptive code template

package/mcp/prompts/grid.ts

@@ -66,8 +66,8 @@ export async function buildGridPrompt(args: {
     //------------------------------------------------------------------
     // Type information
     //------------------------------------------------------------------
-    const gridModelSummary = formatSymbolSummary('GridModel');
-    const gridModelMembers = formatKeyMembers('GridModel', [
+    const gridModelSummary = await formatSymbolSummary('GridModel');
+    const gridModelMembers = await formatKeyMembers('GridModel', [
         'store',
         'columns',
         'sortBy',
@@ -76,7 +76,7 @@ export async function buildGridPrompt(args: {
         'emptyText',
         'onRowDoubleClicked'
     ]);
-    const columnSummary = formatSymbolSummary('Column');
+    const columnSummary = await formatSymbolSummary('Column');
 
     //------------------------------------------------------------------
     // Build adaptive code template

package/mcp/prompts/tabs.ts

@@ -78,8 +78,8 @@ export async function buildTabsPrompt(args: {
     //------------------------------------------------------------------
     // Type information
     //------------------------------------------------------------------
-    const tabContainerModelSummary = formatSymbolSummary('TabContainerModel');
-    const tabContainerModelMembers = formatKeyMembers('TabContainerModel', [
+    const tabContainerModelSummary = await formatSymbolSummary('TabContainerModel');
+    const tabContainerModelMembers = await formatKeyMembers('TabContainerModel', [
         'tabs',
         'activeTabId',
         'route',

package/mcp/prompts/util.ts

@@ -7,7 +7,7 @@
  * to compose structured, context-rich prompt responses.
  */
 import {buildRegistry, loadDocContent, type DocEntry} from '../data/doc-registry.js';
-import {ensureInitialized, getSymbolDetail, getMembers} from '../data/ts-registry.js';
+import {getSymbolDetail, getMembers} from '../data/ts-registry.js';
 import {resolveRepoRoot} from '../util/paths.js';
 
 //------------------------------------------------------------------
@@ -88,9 +88,8 @@ export function extractSection(markdown: string, sectionName: string): string {
  *
  * @returns A formatted markdown block, or a "not found" message.
  */
-export function formatSymbolSummary(name: string): string {
-    ensureInitialized();
-    const detail = getSymbolDetail(name);
+export async function formatSymbolSummary(name: string): Promise<string> {
+    const detail = await getSymbolDetail(name);
     if (!detail) return `(Symbol '${name}' not found)`;
 
     const lines: string[] = [
@@ -120,9 +119,11 @@ export function formatSymbolSummary(name: string): string {
  *
  * @returns The formatted member list as a string.
  */
-export function formatKeyMembers(symbolName: string, memberNames?: string[]): string {
-    ensureInitialized();
-    const result = getMembers(symbolName);
+export async function formatKeyMembers(
+    symbolName: string,
+    memberNames?: string[]
+): Promise<string> {
+    const result = await getMembers(symbolName);
     if (!result) return `(Symbol '${symbolName}' not found or has no members)`;
 
     let {members} = result;

package/mcp/server.ts

@@ -5,6 +5,7 @@ import {registerDocResources} from './resources/docs.js';
 import {registerDocTools} from './tools/docs.js';
 import {registerTsTools} from './tools/typescript.js';
 import {registerPrompts} from './prompts/index.js';
+import {beginInitialization} from './data/ts-registry.js';
 
 const server = new McpServer({
     name: 'hoist-react',
@@ -20,3 +21,7 @@ const transport = new StdioServerTransport();
 await server.connect(transport);
 
 log.info('Server started, awaiting MCP client connection via stdio');
+
+// Warm the TypeScript symbol and member indexes in the background so the
+// first tool invocation doesn't pay the full initialization cost.
+beginInitialization();

package/mcp/tools/typescript.ts

@@ -9,11 +9,12 @@ import type {McpServer} from '@modelcontextprotocol/sdk/server/mcp.js';
 import {z} from 'zod';
 
 import {
-    ensureInitialized,
     searchSymbols,
+    searchMembers,
     getSymbolDetail,
     getMembers,
-    type MemberInfo
+    type MemberInfo,
+    type MemberIndexEntry
 } from '../data/ts-registry.js';
 import {resolveRepoRoot} from '../util/paths.js';
 
@@ -58,6 +59,24 @@ function formatMember(member: MemberInfo): string {
     return lines.join('\n');
 }
 
+/**
+ * Format a MemberIndexEntry as a readable line for search results.
+ * e.g. `1. [accessor] lastLoadCompleted: Date (on HoistModel — base class for all application models)`
+ *      `    Timestamp of most recent successful load completion`
+ */
+function formatMemberIndexEntry(entry: MemberIndexEntry, index: number): string {
+    const lines: string[] = [];
+    const staticPrefix = entry.isStatic ? 'static ' : '';
+    const typeStr = truncateType(entry.type);
+    lines.push(
+        `${index}. [${entry.memberKind}] ${staticPrefix}${entry.name}: ${typeStr} (on ${entry.ownerName} \u2014 ${entry.ownerDescription})`
+    );
+    if (entry.jsDoc) {
+        lines.push(`    ${entry.jsDoc}`);
+    }
+    return lines.join('\n');
+}
+
 /**
  * Register all TypeScript symbol exploration tools on the given MCP server.
  *
@@ -74,12 +93,12 @@ export function registerTsTools(server: McpServer): void {
         {
             title: 'Search Hoist TypeScript Symbols',
             description:
-                'Search for TypeScript classes, interfaces, types, and functions across the hoist-react framework by name. Returns matching symbols with their kind, source file, and package. Use this to find symbols before getting detailed information.',
+                'Search for TypeScript classes, interfaces, types, and functions across the hoist-react framework by name. Also searches public members (properties, methods, accessors) of key framework classes like HoistModel, GridModel, Store, and others. Returns matching symbols and members with their kind, source, and context.',
             inputSchema: z.object({
                 query: z
                     .string()
                     .describe(
-                        'Symbol name or partial name to search for (e.g. "GridModel", "Store", "Panel")'
+                        'Symbol or member name to search for (e.g. "GridModel", "Store", "lastLoadCompleted", "setSortBy")'
                     ),
                 kind: z
                     .enum(['class', 'interface', 'type', 'function', 'const', 'enum'])
@@ -99,26 +118,47 @@ export function registerTsTools(server: McpServer): void {
             }
         },
         async ({query, kind, exported, limit}) => {
-            ensureInitialized();
-            const results = searchSymbols(query, {
+            const symbolLimit = limit ?? 20;
+            const symbolResults = await searchSymbols(query, {
                 kind,
                 exported: exported ?? true,
-                limit: limit ?? 20
+                limit: symbolLimit
             });
 
-            let text: string;
-            if (results.length === 0) {
-                text = `No symbols found matching '${query}'. Try a broader search term.`;
-            } else {
-                const lines = [`Found ${results.length} symbols matching '${query}':\n`];
-                results.forEach((result, i) => {
+            // Search members with a separate cap; if no symbols match, give
+            // members more room so the query is still useful.
+            const memberLimit = symbolResults.length === 0 ? symbolLimit : 15;
+            const memberResults = await searchMembers(query, {limit: memberLimit});
+
+            const lines: string[] = [];
+
+            if (symbolResults.length > 0) {
+                lines.push(`Symbols (${symbolResults.length} matches):\n`);
+                symbolResults.forEach((result, i) => {
                     lines.push(
                         `${i + 1}. [${result.kind}] ${result.name} (package: ${result.sourcePackage}, file: ${toRelativePath(result.filePath)}, exported: ${result.isExported ? 'yes' : 'no'})`
                     );
                 });
-                text = lines.join('\n');
             }
 
+            if (memberResults.length > 0) {
+                if (lines.length > 0) lines.push('');
+                lines.push(`Members of key classes (${memberResults.length} matches):\n`);
+                memberResults.forEach((m, i) => {
+                    lines.push(formatMemberIndexEntry(m, i + 1));
+                });
+            }
+
+            if (lines.length > 0) {
+                lines.push('');
+                lines.push('Tip: Use hoist-get-members to see all members of a specific class.');
+            }
+
+            const text =
+                lines.length > 0
+                    ? lines.join('\n')
+                    : `No symbols or members found matching '${query}'. Try a broader search term.`;
+
             return {content: [{type: 'text' as const, text}]};
         }
     );
@@ -151,8 +191,7 @@ export function registerTsTools(server: McpServer): void {
             }
         },
         async ({name, filePath}) => {
-            ensureInitialized();
-            const detail = getSymbolDetail(name, filePath);
+            const detail = await getSymbolDetail(name, filePath);
 
             let text: string;
             if (!detail) {
@@ -225,8 +264,7 @@ export function registerTsTools(server: McpServer): void {
             }
         },
         async ({name, filePath}) => {
-            ensureInitialized();
-            const result = getMembers(name, filePath);
+            const result = await getMembers(name, filePath);
 
             let text: string;
             if (!result) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xh/hoist",
-  "version": "82.0.0",
+  "version": "82.0.1",
   "description": "Hoist add-on for building and deploying React Applications.",
   "repository": {
     "type": "git",