@xh/hoist 86.2.0 → 86.4.0

package/desktop/cmp/grid/impl/filter/headerfilter/custom/CustomTabModel.ts

@@ -5,12 +5,18 @@
  * Copyright © 2026 Extremely Heavy Industries Inc.
  */
 import {HoistModel, XH} from '@xh/hoist/core';
-import {CompoundFilterOperator, FilterLike} from '@xh/hoist/data';
+import {
+    CompoundFilterOperator,
+    FieldFilter,
+    FieldFilterOperator,
+    FieldFilterSpec,
+    FilterLike
+} from '@xh/hoist/data';
 import {action, bindable, computed, makeObservable, observable} from '@xh/hoist/mobx';
-import {compact, isEmpty} from 'lodash';
+import {compact, first, flatMap, forEach, groupBy, isArray, isEmpty, uniq} from 'lodash';
 import {HeaderFilterModel} from '../HeaderFilterModel';
 
-import {CustomRowModel} from './CustomRowModel';
+import {CustomRowModel, usesMultiValueInput} from './CustomRowModel';
 
 export class CustomTabModel extends HoistModel {
     override xhImpl = true;
@@ -23,11 +29,16 @@ export class CustomTabModel extends HoistModel {
     /** Filter config output by this model. */
     @computed.struct
     get filter(): FilterLike {
-        const {op, rowModels} = this,
-            filters = compact(rowModels.map(it => it.value));
-        if (isEmpty(filters)) return null;
-        if (filters.length > 1) return {filters, op};
-        return filters;
+        const {op, rowModels} = this;
+
+        // Null rowModels flags an unrepresentable filter - emit it unchanged so commit is a no-op.
+        if (!rowModels) return this.columnCompoundFilter ?? this.columnFilters;
+
+        const specs = compact(rowModels.map(it => it.value));
+        if (isEmpty(specs)) return null;
+
+        const filters = this.collapseToArrayFilters(specs, op);
+        return filters.length > 1 ? {filters, op} : first(filters);
     }
 
     get fieldSpec() {
@@ -42,6 +53,10 @@ export class CustomTabModel extends HoistModel {
         return this.headerFilterModel.columnFilters;
     }
 
+    get columnCompoundFilter() {
+        return this.headerFilterModel.columnCompoundFilter;
+    }
+
     constructor(headerFilterModel: HeaderFilterModel) {
         super();
         makeObservable(this);
@@ -74,13 +89,27 @@ export class CustomTabModel extends HoistModel {
     //-------------------
     @action
     private doSyncWithFilter() {
-        const {columnFilters} = this,
-            rowModels = [];
+        const {columnCompoundFilter} = this,
+            op = this.deriveOp();
+        this.op = op;
+
+        if (!this.isRepresentable) {
+            this.logWarn('Filter cannot be edited in the custom tab; leaving it unchanged');
+            this.rowModels = null;
+            return;
+        }
 
-        // Create rows based on filter.
-        columnFilters.forEach(filter => {
-            const {op, value} = filter;
-            rowModels.push(new CustomRowModel(this, op, value));
+        // Expand a multi-value clause destined for a single-value input into one row per value
+        // (joined under the tab op); the multi-select input holds the array directly as one row.
+        const rowModels = [],
+            children = (columnCompoundFilter?.filters ?? this.columnFilters) as FieldFilter[];
+        children.forEach(filter => {
+            const {op: fieldOp, value} = filter;
+            if (this.needsExpansion(filter)) {
+                value.forEach(v => rowModels.push(new CustomRowModel(this, fieldOp, v)));
+            } else {
+                rowModels.push(new CustomRowModel(this, fieldOp, value));
+            }
         });
 
         // Add an empty pending row
@@ -90,4 +119,58 @@ export class CustomTabModel extends HoistModel {
 
         this.rowModels = rowModels;
     }
+
+    // Whether a multi-value clause must be expanded to one row per value (vs held by a multi-select).
+    private needsExpansion({op, value}: FieldFilter): boolean {
+        return isArray(value) && value.length > 1 && !usesMultiValueInput(this.fieldSpec, op);
+    }
+
+    // The op a multi-value clause joins under: `=`-family => OR, negated => AND.
+    private mergeOpFor(op: FieldFilterOperator): CompoundFilterOperator {
+        return FieldFilter.INCLUDE_LIKE_OPERATORS.includes(op) ? 'OR' : 'AND';
+    }
+
+    // Op joining the tab's rows
+    private deriveOp(): CompoundFilterOperator {
+        const {columnCompoundFilter, columnFilters} = this;
+        if (columnCompoundFilter) return columnCompoundFilter.op;
+
+        const arrayFilter = columnFilters.find(f => this.needsExpansion(f));
+        return arrayFilter ? this.mergeOpFor(arrayFilter.op) : 'AND';
+    }
+
+    // Filter must be representable as a flat set of rows with a single op
+    private get isRepresentable(): boolean {
+        const {columnCompoundFilter} = this,
+            op = this.deriveOp(),
+            children = columnCompoundFilter?.filters ?? this.columnFilters;
+        return children.every(
+            f =>
+                FieldFilter.isFieldFilter(f) &&
+                (!this.needsExpansion(f) || op === this.mergeOpFor(f.op))
+        );
+    }
+
+    // Inverse of the expand in `doSyncWithFilter`: collapse same-field/op rows into one multi-value FieldFilter
+    private collapseToArrayFilters(
+        specs: FieldFilterSpec[],
+        op: CompoundFilterOperator
+    ): FieldFilterSpec[] {
+        const ret: FieldFilterSpec[] = [];
+        forEach(groupBy(specs, 'op'), (groupSpecs, groupOp: FieldFilterOperator) => {
+            const canMerge =
+                groupSpecs.length > 1 &&
+                FieldFilter.ARRAY_OPERATORS.includes(groupOp) &&
+                op === this.mergeOpFor(groupOp);
+
+            if (canMerge) {
+                const {field} = groupSpecs[0],
+                    value = uniq(flatMap(groupSpecs, it => it.value));
+                ret.push({field, op: groupOp, value});
+            } else {
+                ret.push(...groupSpecs);
+            }
+        });
+        return ret;
+    }
 }

package/desktop/cmp/input/SegmentedControl.ts

@@ -80,6 +80,7 @@ export const [SegmentedControl, segmentedControl] = hoistCmp.withFactory<Segment
 interface NormalizedOption extends SegmentedControlOption {
     label: string;
     intent?: Intent;
+    testId?: string;
     _key: string;
 }
 
@@ -92,13 +93,14 @@ class SegmentedControlModel extends HoistInputModel {
         return options.map((o: any, idx: number) => {
             const key = String(idx);
             if (isObject(o)) {
-                const {label, value, icon, disabled, intent} = o as SegmentedControlOption;
+                const {label, value, icon, disabled, intent, testId} = o as SegmentedControlOption;
                 return {
                     value: this.toInternal(value),
                     label: label ?? (icon ? '' : String(value)),
                     icon,
                     disabled,
                     intent,
+                    testId,
                     _key: key
                 };
             } else {
@@ -163,13 +165,15 @@ const cmp = hoistCmp.factory<SegmentedControlModel>(({model, className, ...props
     // applied via a per-button className that our SCSS keys its solid/hint coloring off of.
     const defaultIntent = intent && intent !== 'none' ? intent : null,
         bpOptions = model.normalizedOptions.map(opt => {
-            const optIntent = opt.intent ?? defaultIntent;
+            const optIntent = opt.intent ?? defaultIntent,
+                optTestId = opt.testId ?? (testId ? `${testId}-${String(opt.value)}` : null);
             return {
                 value: opt._key,
                 label: opt.label,
                 icon: opt.icon,
                 disabled: opt.disabled,
-                className: optIntent ? `xh-segmented-control-option--${optIntent}` : null
+                className: optIntent ? `xh-segmented-control-option--${optIntent}` : null,
+                ...(optTestId ? {[TEST_ID]: optTestId} : null)
             };
         });
 

package/desktop/cmp/input/Select.ts

@@ -31,7 +31,7 @@ import {debouncePromise, wait} from '@xh/hoist/promise';
 import {elemWithin, getTestId, mergeDeep, TEST_ID, throwIf, withDefault} from '@xh/hoist/utils/js';
 import {createObservableRef, getLayoutProps} from '@xh/hoist/utils/react';
 import classNames from 'classnames';
-import {castArray, escapeRegExp, isEmpty, isEqual, isNil, isPlainObject, keyBy} from 'lodash';
+import {castArray, escapeRegExp, isEmpty, isEqual, isNil, isPlainObject, unionWith} from 'lodash';
 import {ReactElement, ReactNode} from 'react';
 import {components} from 'react-select';
 import {calcWindowedMenuWidth} from './impl/CalcWindowedMenuWidth';
@@ -191,6 +191,15 @@ export interface SelectProps extends HoistProps, HoistInputProps, LayoutProps {
 
     /** Field on provided options for sourcing each option's value (default `value`). */
     valueField?: string;
+
+    /**
+     * Function to generate a `SelectOption` for a (non-null) selected value not present in the
+     * current options list. Return null to fall back to the default value-as-label behavior.
+     *
+     * Useful with queryFn-based selects, readonly forms, or any case where options may not be
+     * loaded when a value is set, ensuring the value renders with its proper label.
+     */
+    generateOptionFn?: (value: any) => SelectOption;
 }
 
 /**
@@ -437,7 +446,8 @@ class SelectInputModel extends HoistInputModel {
 
     // Convert external value into option object(s). Options created if missing - this takes the
     // external value from the model, and we will respect that even if we don't know about it.
-    // (Exception for a null value, which we will only accept if explicitly present in options.)
+    // (Exception for a null value, which is never synthesized - accepted only if provided via
+    // options.)
     override toInternal(external) {
         if (this.multiMode) {
             if (external == null || isEqual(external, this.emptyValue)) external = []; // avoid [null]
@@ -457,7 +467,10 @@ class SelectInputModel extends HoistInputModel {
             }
         }
 
-        return createIfNotFound ? this.valueToOption(value) : null;
+        if (!createIfNotFound) return null;
+
+        // Value not among options - let the app generate an option for it, else synthesize one.
+        return this.componentProps.generateOptionFn?.(value) ?? this.valueToOption(value);
     }
 
     override toExternal(internal) {
@@ -481,11 +494,11 @@ class SelectInputModel extends HoistInputModel {
     // Normalize / clone a single source value into a normalized option object. Supports Strings
     // and Objects. Objects are validated/defaulted to ensure a label+value or label+options sublist,
     // with other fields brought along to support Selects emitting value objects with ad hoc properties.
-    private toOption(src, depth) {
+    private toOption(src, depth): SelectOption {
         return isPlainObject(src) ? this.objectToOption(src, depth) : this.valueToOption(src);
     }
 
-    private objectToOption(src, depth) {
+    private objectToOption(src, depth): SelectOption {
         const {componentProps} = this,
             labelField = withDefault(componentProps.labelField, 'label'),
             valueField = withDefault(componentProps.valueField, 'value');
@@ -508,7 +521,7 @@ class SelectInputModel extends HoistInputModel {
               };
     }
 
-    private valueToOption(src) {
+    private valueToOption(src): SelectOption {
         return {label: src != null ? src.toString() : '-null-', value: src};
     }
 
@@ -521,13 +534,9 @@ class SelectInputModel extends HoistInputModel {
 
         // Carry forward and add to any existing internalOpts to allow our value
         // converters to continue all selected values in multiMode.
-        const matchesByVal = keyBy(matchOpts, 'value'),
-            newOpts = [...matchOpts];
-        this.internalOptions.forEach(currOpt => {
-            const matchOpt = matchesByVal[currOpt.value];
-            if (!matchOpt) newOpts.push(currOpt); // avoiding dupes
-        });
-        this.internalOptions = newOpts;
+        this.internalOptions = unionWith(matchOpts, this.internalOptions, (a, b) =>
+            isEqual(a.value, b.value)
+        );
 
         // But only return the matching options back to the combo.
         return matchOpts;
@@ -544,8 +553,7 @@ class SelectInputModel extends HoistInputModel {
     // Option Rendering
     //----------------------
     formatOptionLabel = (opt, params) => {
-        // Always display the standard label string in the value container (context == 'value').
-        // If we need to expose customization here, we could consider a dedicated prop.
+        // Display the standard label string in the value container (context == 'value').
         if (params.context !== 'menu') {
             return opt.label;
         }
@@ -561,7 +569,7 @@ class SelectInputModel extends HoistInputModel {
             return div(opt.label);
         }
 
-        return castArray(this.externalValue).includes(opt.value)
+        return castArray(this.externalValue).some(v => isEqual(v, opt.value))
             ? hbox({
                   items: [
                       div({

package/docs/routing.md

@@ -150,10 +150,12 @@ numeric-only parameters). See the
 ### Conditional Route Exclusion
 
 Routes support an `omit` property (a Hoist extension, not part of Router5) that allows
-declarative exclusion of routes at registration time. This is useful for role-gated sections:
+declarative exclusion of routes at registration time. This is useful for role-gated sections.
+`getRoutes()` returns `HoistRoute[]` - Hoist's `Route` type extended with the optional `omit` key -
+so the property type-checks without any cast:
 
 ```typescript
-override getRoutes() {
+override getRoutes(): HoistRoute[] {
     return [{
         name: 'default',
         path: '/app',

package/docs/upgrade-notes/v86-upgrade-notes.md

@@ -221,7 +221,21 @@ grep -rn "fileChooser\|FileChooser" client-app/src/
 | `minSize` (prop) | `FileChooserModel` config `minFileSize` |
 | `enableMulti` / `enableAddMulti` (props) | `FileChooserModel` config `maxFiles` (set `1` for single-file; omit for unlimited) |
 | `showFileGrid` (prop) | Removed - default display is a grid; customize via the `fileDisplay` content prop |
-| `targetText` (prop) | `FileChooserModel` config `emptyDisplayPrompt` (+ `emptyDisplayHint`), or replace via the `emptyDisplay` content prop |
+| `targetText` (prop) | **Preferred:** `FileChooserModel` config `emptyDisplayPrompt` (+ `emptyDisplayHint`). Use the `emptyDisplay` content prop only for a fully custom layout. |
+
+> **`emptyDisplay` and `fileDisplay` switch on file *presence*; v85's `targetText` did not.**
+> In v85 the drop target that rendered `targetText` was **always visible** - even with files
+> selected - and the file grid (if enabled) sat alongside it. v86 has no always-visible text slot:
+> `emptyDisplay` renders **only when no files are selected**, and `fileDisplay` (defaulting to the
+> grid/card) renders **only when files are present**. There is therefore no mechanical mapping for a
+> `targetText` - you must decide which presence-state its content belonged to:
+> - A drop prompt ("Drag and drop files here") is empty-state content - set it as
+>   `emptyDisplayPrompt` (a plain string, preferred - keeps Hoist's icon, styling, and the
+>   auto-generated constraints hint). When files exist, the grid/`fileDisplay` takes over.
+> - A message that only makes sense once a file is chosen (e.g. "Ready to upload") belongs in
+>   `fileDisplay`, which replaces the default grid - so set it only if you don't need that grid.
+> - If your `targetText` varied on an **app flag** rather than on file presence, preserve that flag
+>   *inside* the slot you choose - do not let the empty/file switch silently stand in for it.
 
 Before (v85 - config as component props, model takes no args):
 ```typescript
@@ -283,17 +297,68 @@ constructor() {
 }
 ```
 
-**If your `targetText` was a React element** (not a plain string) - e.g. a `placeholder(...)` or a
-custom layout - move it to the `emptyDisplay` content prop rather than `emptyDisplayPrompt`.
-`emptyDisplayPrompt` accepts a `ReactNode` and is fine for a styled message, but `emptyDisplay`
-replaces the entire empty-state content, which is the closer match for a fully custom `targetText`:
+**Prefer the styled text prompt over rebuilding the UI.** Most `targetText` values were a string or
+a simple `placeholder(Icon.upload(), '...')` - which is exactly what the default empty display
+already renders. Map these to `emptyDisplayPrompt` (a plain string on the model), optionally with
+`emptyDisplayHint`: you keep Hoist's upload icon, styling, and the auto-generated summary of accepted
+types and size/count limits. This holds even when `targetText` was a `placeholder(...)` element -
+collapse it back to the prompt string rather than reaching for a content prop.
 
 ```typescript
-// Before (v85)
+// Before (v85) - a plain-text or simple-placeholder targetText
+fileChooser({model, targetText: 'Drop loan docs here'})
 fileChooser({model, targetText: placeholder(Icon.upload(), 'Drop loan docs here')})
 
-// After (v86)
-fileChooser({model, emptyDisplay: placeholder(Icon.upload(), 'Drop loan docs here')})
+// After (v86) - map targetText to a styled prompt on the model; icon, styling, and the constraints
+// hint come for free, and the component render needs no change
+new FileChooserModel({emptyDisplayPrompt: 'Drop loan docs here'});
+```
+
+Reserve the `emptyDisplay` / `fileDisplay` content props for layouts the prompt/hint genuinely can't
+express. Note they are **not** interchangeable targets for a `targetText`: `emptyDisplay` renders
+only when empty and `fileDisplay` only when files are present, so content meant for the
+file-populated state must go to `fileDisplay` - never `emptyDisplay`.
+
+**If your `targetText` was conditional** - a ternary or computed expression - work out what the
+condition actually tracked before migrating, because v86 already switches content on file presence.
+
+In the common case the condition tracked *file presence* (a flag toggled as files are added and
+removed). v86's built-in switch replaces it directly: the no-file prompt becomes `emptyDisplayPrompt`
+and the flag is dropped. The plain drop text needs no content prop at all - only the custom "ready"
+affirmation, meant for the file-populated state, uses `fileDisplay` (which overrides the default
+grid). `enableMulti` moves to `maxFiles` on the model:
+
+```typescript
+// Before (v85) - targetText always visible, toggled by a presence-derived flag
+fileChooser({
+    model,
+    enableMulti: !singleDoc,
+    targetText: hasFile
+        ? placeholder(Icon.check({intent: 'success'}), 'Ready to upload')
+        : placeholder(Icon.upload(), 'Drag and drop files here')
+})
+
+// After (v86) - the presence switch is built in, so the flag is no longer needed
+this.chooserModel = new FileChooserModel({
+    maxFiles: singleDoc ? 1 : null,
+    emptyDisplayPrompt: 'Drag and drop files here'
+});
+fileChooser({
+    model: this.chooserModel,
+    fileDisplay: placeholder(Icon.check({intent: 'success'}), 'Ready to upload')
+})
+```
+
+The trap is a condition that is **independent of file presence** (e.g. an "uploads open" flag). Its
+branches are *not* an empty/file pair, so splitting them across `emptyDisplay` / `fileDisplay` would
+drop the condition and silently re-key the content onto presence. Keep such a flag *inside* the slot
+its content belongs to - here, still on the styled prompt:
+
+```typescript
+// independent flag - preserved on the styled prompt (model config), not mapped onto presence
+new FileChooserModel({
+    emptyDisplayPrompt: acceptingUploads ? 'Drag and drop files here' : 'Uploads are closed'
+});
 ```
 
 ### 4. Remove Deleted Mobile `DateInput` Props

package/kit/react-dropzone/index.ts

@@ -8,5 +8,6 @@ import {elementFactory} from '@xh/hoist/core';
 import Dropzone from 'react-dropzone';
 
 export {Dropzone};
+export {ErrorCode} from 'react-dropzone';
 export type {Accept, FileRejection, FileWithPath} from 'react-dropzone';
 export const dropzone = elementFactory(Dropzone);

package/mcp/README.md

@@ -725,6 +725,18 @@ The `resolveDocPath()` utility in `util/paths.ts` validates that resolved paths
 repository root. It rejects paths containing `..` segments. Always use this function when resolving
 file paths from external input.
 
+### Path Separators (Cross-Platform)
+
+ts-morph's `SourceFile.getFilePath()` always returns **forward-slash** paths on every platform
+(e.g. `D:/hoist-react/cmp/grid/GridModel.ts` on Windows), whereas `resolveRepoRoot()` returns a
+native path from Node's `path` module -- **backslash-separated** on Windows (`D:\hoist-react`).
+Comparing or slicing one against the other (e.g. `filePath.startsWith(repoRoot + '/')`) silently
+fails on Windows, filtering out every source file and yielding an empty symbol index. When
+comparing against or slicing a ts-morph path, use `resolveRepoRootPosix()` (and `toPosixPath()` for
+any incoming file-path argument) from `util/paths.ts` rather than `resolveRepoRoot()`. Filesystem
+access that stays within Node's `path`/`fs` APIs (e.g. the doc registry, the index cache) can keep
+using `resolveRepoRoot()`, since those are separator-consistent on both sides.
+
 ### Registry Sync
 
 The doc registry is hardcoded, not filesystem-scanned. When documentation files are added or

package/mcp/data/ts-registry.spec.ts

@@ -0,0 +1,156 @@
+/**
+ * Test harness for the TypeScript symbol registry's cross-platform path handling.
+ * Run with:
+ *   npx tsx mcp/data/ts-registry.spec.ts
+ *
+ * The hoist-react repo has no general test framework configured, so this script
+ * is a self-contained, exit-coded driver. It guards the path normalization the
+ * symbol index depends on: ts-morph's `getFilePath()` reports forward-slash paths
+ * on every platform, while Node's `path` reports backslashes on Windows. The two
+ * must be reconciled (to POSIX form) before comparison - a regression silently
+ * filters out every source file and empties the entire symbol index on Windows.
+ * See the "Path Separators (Cross-Platform)" pitfall in mcp/README.md.
+ *
+ * Two layers:
+ *  - Synthetic path-helper cases (`toPosixPath`, `resolveRepoRootPosix`,
+ *    `toRelativePath`, and the exact index-guard comparison) - these simulate a
+ *    Windows path explicitly, so they are meaningful on any host OS, including
+ *    Linux/macOS CI.
+ *  - Live index integration - exercises `searchSymbols` / `getSymbolDetail` /
+ *    `getMembers` against the real hoist-react sources to prove symbols resolve
+ *    end-to-end (and that repo-relative `--file` disambiguation works).
+ *
+ * Run after every change to ts-registry.ts, index-cache.ts, or util/paths.ts.
+ */
+import {resolveRepoRoot, resolveRepoRootPosix, toPosixPath} from '../util/paths.js';
+import {toRelativePath} from '../formatters/typescript.js';
+import {searchSymbols, getSymbolDetail, getMembers} from './ts-registry.js';
+
+// Suppress info logs during test run; we only want test output. (Warns still print.)
+process.env.HOIST_MCP_QUIET = '1';
+
+//---------------------------------------------------------------------
+// Minimal assertion helpers (match the exit-coded style of the sibling
+// doc-id-resolver.spec.ts).
+//---------------------------------------------------------------------
+
+let passed = 0;
+let failed = 0;
+const failures: string[] = [];
+
+function ok(label: string, cond: boolean, detail?: string): void {
+    if (cond) {
+        passed++;
+        console.log(`  PASS  ${label}`);
+    } else {
+        failed++;
+        failures.push(detail ? `${label} -- ${detail}` : label);
+        console.log(`  FAIL  ${label}`);
+        if (detail) console.log(`        ${detail}`);
+    }
+}
+
+function eq(label: string, actual: unknown, expected: unknown): void {
+    ok(
+        label,
+        actual === expected,
+        `got ${JSON.stringify(actual)}, expected ${JSON.stringify(expected)}`
+    );
+}
+
+//---------------------------------------------------------------------
+// Synthetic path-helper cases (host-OS-independent).
+//---------------------------------------------------------------------
+
+console.log('toPosixPath cases:');
+eq(
+    'converts backslashes',
+    toPosixPath('D:\\hoist-react\\core\\XH.ts'),
+    'D:/hoist-react/core/XH.ts'
+);
+eq('leaves forward slashes untouched', toPosixPath('/repo/core/XH.ts'), '/repo/core/XH.ts');
+eq('normalizes mixed separators', toPosixPath('a\\b/c\\d'), 'a/b/c/d');
+eq('is idempotent', toPosixPath(toPosixPath('D:\\a\\b')), 'D:/a/b');
+
+console.log('\nresolveRepoRootPosix cases:');
+const rootPosix = resolveRepoRootPosix();
+ok('has no backslashes', !rootPosix.includes('\\'), `got "${rootPosix}"`);
+eq('equals toPosixPath(resolveRepoRoot())', rootPosix, toPosixPath(resolveRepoRoot()));
+
+console.log('\nIndex-guard regression cases (simulated Windows paths):');
+// The exact scenario that broke: on Windows, resolveRepoRoot() yields a
+// backslash path while ts-morph yields forward slashes. Assert the naive guard
+// fails and the POSIX-normalized guard succeeds - regardless of the host OS.
+const winRootNative = 'D:\\hoist-react'; // what resolveRepoRoot() returns on Windows
+const winFile = 'D:/hoist-react/cmp/grid/GridModel.ts'; // what ts-morph getFilePath() returns on Windows
+ok(
+    'naive backslash-root comparison fails (the original bug)',
+    !winFile.startsWith(winRootNative + '/')
+);
+ok(
+    'posix-normalized root comparison succeeds (the fix)',
+    winFile.startsWith(toPosixPath(winRootNative) + '/')
+);
+eq(
+    'relative slice under posix root is correct',
+    winFile.slice(toPosixPath(winRootNative).length + 1),
+    'cmp/grid/GridModel.ts'
+);
+
+console.log('\ntoRelativePath cases:');
+const sampleRel = 'cmp/grid/GridModel.ts';
+eq('strips a posix absolute path', toRelativePath(`${rootPosix}/${sampleRel}`), sampleRel);
+// A backslash absolute path (same root) must still strip AND normalize to posix.
+const backslashAbs = `${rootPosix.replace(/\//g, '\\')}\\cmp\\grid\\GridModel.ts`;
+eq('strips + normalizes a backslash absolute path', toRelativePath(backslashAbs), sampleRel);
+
+//---------------------------------------------------------------------
+// Live index integration (needs the real hoist-react sources; builds or
+// loads the cached index on first query).
+//---------------------------------------------------------------------
+
+console.log('\nLive index cases:');
+
+const results = await searchSymbols('GridModel', {limit: 5});
+const gm = results.find(r => r.name === 'GridModel' && r.kind === 'class');
+ok('searchSymbols("GridModel") finds the class', !!gm, `got ${results.length} results`);
+if (gm) {
+    eq('GridModel resolves to cmp/grid/GridModel.ts', toRelativePath(gm.filePath), sampleRel);
+    eq('GridModel sourcePackage is cmp/grid', gm.sourcePackage, 'cmp/grid');
+}
+
+const detail = await getSymbolDetail('GridModel');
+ok(
+    'getSymbolDetail("GridModel") resolves',
+    !!detail && detail.kind === 'class',
+    `got ${JSON.stringify(detail && {name: detail.name, kind: detail.kind})}`
+);
+
+const members = await getMembers('GridModel');
+ok(
+    'getMembers("GridModel") returns members',
+    !!members && members.members.length > 0,
+    `count=${members?.members.length ?? 0}`
+);
+
+// --file disambiguation (the secondary Windows bug): a repo-relative path passed
+// to findIndexEntry must resolve to the matching entry. `View` exists in both
+// cmp/viewmanager and data/cube; the path selects the data/cube one.
+const view = await getSymbolDetail('View', 'data/cube/View.ts');
+ok(
+    'getSymbolDetail("View", "data/cube/View.ts") disambiguates by repo-relative path',
+    !!view && toRelativePath(view.filePath) === 'data/cube/View.ts',
+    `relPath=${view ? toRelativePath(view.filePath) : 'null'}`
+);
+
+//---------------------------------------------------------------------
+// Tally
+//---------------------------------------------------------------------
+
+console.log(`\nTotal: ${passed} passed, ${failed} failed.`);
+
+if (failed > 0) {
+    console.log('\nFailure details:');
+    for (const f of failures) console.log(`  - ${f}`);
+    process.exit(1);
+}

package/mcp/data/ts-registry.ts

@@ -24,7 +24,7 @@ import type {
 import {resolve} from 'node:path';
 
 import {log} from '../util/logger.js';
-import {resolveRepoRoot} from '../util/paths.js';
+import {resolveRepoRoot, resolveRepoRootPosix, toPosixPath} from '../util/paths.js';
 import {computeFingerprint, loadCache, writeCache} from './index-cache.js';
 
 //------------------------------------------------------------------
@@ -295,7 +295,9 @@ function buildSymbolIndex(proj: Project): {
 } {
     const index = new Map<string, SymbolEntry[]>();
     const mIndex = new Map<string, MemberIndexEntry[]>();
-    const repoRoot = resolveRepoRoot();
+    // POSIX form: compared against ts-morph `getFilePath()`, which always uses
+    // forward slashes even on Windows.
+    const repoRoot = resolveRepoRootPosix();
 
     const counts = {total: 0, exported: 0, byKind: {} as Record<string, number>};
     let memberCount = 0;
@@ -549,7 +551,7 @@ function buildSymbolIndex(proj: Project): {
     // Index Promise prototype extensions from promise/Promise.ts
     const promiseFile = proj.getSourceFile(sf => sf.getFilePath().endsWith('/promise/Promise.ts'));
     if (promiseFile) {
-        indexPromiseExtensions(promiseFile, index, mIndex, resolveRepoRoot());
+        indexPromiseExtensions(promiseFile, index, mIndex, resolveRepoRootPosix());
     }
 
     // Populate `memberNames` on symbol entries for every member-indexed owner
@@ -799,7 +801,8 @@ function ensureProject(): Project {
  * JSDoc).
  */
 function enrichMemberIndexFromImplements(proj: Project): void {
-    const repoRoot = resolveRepoRoot();
+    // POSIX form: compared against ts-morph `getFilePath()` (see buildSymbolIndex).
+    const repoRoot = resolveRepoRootPosix();
 
     for (const sourceFile of proj.getSourceFiles()) {
         const filePath = sourceFile.getFilePath();
@@ -1374,8 +1377,12 @@ function findIndexEntry(name: string, filePath?: string): SymbolEntry | null {
 
     if (filePath) {
         // Resolve relative paths against repo root -- search results display repo-relative
-        // paths, so callers will typically pass those rather than absolute paths.
-        const resolved = filePath.startsWith('/') ? filePath : resolve(resolveRepoRoot(), filePath);
+        // paths, so callers will typically pass those rather than absolute paths. Normalize
+        // to POSIX so the comparison matches entry.filePath (ts-morph forward slashes) on
+        // Windows, and recognize Windows drive-letter absolutes (e.g. `D:/...`) as absolute.
+        const posix = toPosixPath(filePath);
+        const isAbsolute = posix.startsWith('/') || /^[a-zA-Z]:\//.test(posix);
+        const resolved = isAbsolute ? posix : toPosixPath(resolve(resolveRepoRoot(), posix));
         return exact.find(e => e.filePath === resolved) ?? null;
     }