@xh/hoist 86.2.0 → 86.3.0

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;
     }
 

package/mcp/formatters/typescript.ts

@@ -11,7 +11,7 @@
  */
 import {z} from 'zod';
 import type {MemberInfo, MemberIndexEntry, SymbolEntry, SymbolDetail} from '../data/ts-registry.js';
-import {resolveRepoRoot} from '../util/paths.js';
+import {resolveRepoRootPosix, toPosixPath} from '../util/paths.js';
 
 /** Remove blank lines from a JSDoc string to produce more compact output. */
 function collapseJsDoc(jsDoc: string): string {
@@ -31,8 +31,12 @@ export function truncateType(typeStr: string): string {
 
 /** Convert an absolute file path to a repo-relative path. */
 export function toRelativePath(filePath: string): string {
-    const root = resolveRepoRoot();
-    return filePath.startsWith(root) ? filePath.slice(root.length + 1) : filePath;
+    // Symbol filePaths originate from ts-morph (forward slashes on all platforms);
+    // compare in POSIX form so the repo-root prefix strips correctly on Windows,
+    // where `resolveRepoRoot()` would otherwise yield a backslash path.
+    const root = resolveRepoRootPosix();
+    const posix = toPosixPath(filePath);
+    return posix.startsWith(root) ? posix.slice(root.length + 1) : posix;
 }
 
 /**

package/mcp/util/paths.ts

@@ -39,6 +39,27 @@ export function resolveRepoRoot(): string {
     return repoRoot;
 }
 
+/** Convert a filesystem path to POSIX (forward-slash) form. */
+export function toPosixPath(p: string): string {
+    return p.replace(/\\/g, '/');
+}
+
+/**
+ * Repo root in POSIX (forward-slash) form, matching ts-morph's `getFilePath()`
+ * convention, which always reports forward slashes on every platform.
+ *
+ * On Windows, {@link resolveRepoRoot} returns a backslash path (e.g.
+ * `D:\hoist-react`) while ts-morph reports `D:/hoist-react/...`; comparing or
+ * slicing the two directly fails, silently filtering out every source file and
+ * yielding an empty symbol index. Use this whenever comparing against or
+ * slicing a ts-morph source-file path (see `data/ts-registry.ts` and
+ * `formatters/typescript.ts`). Filesystem access that stays within Node's
+ * `path` APIs should keep using {@link resolveRepoRoot}.
+ */
+export function resolveRepoRootPosix(): string {
+    return toPosixPath(resolveRepoRoot());
+}
+
 /**
  * Resolve the `@xh/hoist` library version from the repo root `package.json`.
  *

package/mobile/cmp/grid/impl/ColChooserModel.ts

@@ -4,7 +4,7 @@
  *
  * Copyright © 2026 Extremely Heavy Industries Inc.
  */
-import {GridModel} from '@xh/hoist/cmp/grid';
+import {GridModel, IColChooserModel} from '@xh/hoist/cmp/grid';
 import {HoistModel, HSide, XH} from '@xh/hoist/core';
 import '@xh/hoist/mobile/register';
 import {bindable, action, makeObservable, observable} from '@xh/hoist/mobx';
@@ -17,7 +17,7 @@ import {clone, find, sortBy} from 'lodash';
  * It is not necessary to manually create instances of this class within an application.
  * @internal
  */
-export class ColChooserModel extends HoistModel {
+export class ColChooserModel extends HoistModel implements IColChooserModel {
     override xhImpl = true;
 
     gridModel: GridModel;

package/mobile/cmp/input/SegmentedControl.ts

@@ -85,6 +85,7 @@ export const [SegmentedControl, segmentedControl] = hoistCmp.withFactory<Segment
 interface NormalizedOption extends SegmentedControlOption {
     label: string;
     intent?: Intent;
+    testId?: string;
     _key: string;
 }
 
@@ -97,13 +98,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 {
@@ -168,7 +170,8 @@ const cmp = hoistCmp.factory<SegmentedControlModel>(({model, className, ...props
 
     const buttons = model.normalizedOptions.map(opt => {
         const optIntent = opt.intent ?? defaultIntent,
-            selected = opt._key === selectedKey;
+            selected = opt._key === selectedKey,
+            optTestId = opt.testId ?? (testId ? `${testId}-${String(opt.value)}` : null);
         // Wrap the label so it can truncate with an ellipsis when the segment is too narrow,
         // rather than hard-clipping mid-character. Pass null for icon-only options so the Button
         // renders the icon alone (an empty span would suppress that).
@@ -187,7 +190,8 @@ const cmp = hoistCmp.factory<SegmentedControlModel>(({model, className, ...props
                 selected && 'xh-segmented-control-option--selected',
                 optIntent && `xh-segmented-control-option--${optIntent}`
             ),
-            onClick: () => model.onValueChange(opt._key)
+            onClick: () => model.onValueChange(opt._key),
+            testId: optTestId
         });
     });