@thinkwise/testwise 0.2.62 → 0.2.99

package/helpers/PathResolver.ts

@@ -1,7 +1,29 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
+/**
+ * Locates the root directory of the **consumer project** (the project that has
+ * `@thinkwise/testwise` installed as a dependency) at runtime.
+ *
+ * **Why this exists:** Testwise runs from inside `node_modules` but needs to
+ * read and write files that belong to the consuming project (e.g.
+ * `registeredSubjects.json`, `Testwise.json`). Simply using `process.cwd()`
+ * is unreliable when scripts are invoked from sub-directories. This class
+ * walks up the directory tree looking for the first `package.json` whose
+ * `name` is NOT `@thinkwise/testwise`, which is guaranteed to be the consumer
+ * project root.
+ *
+ * **How to use it:** Inject it into any pipeline helper that needs to write
+ * to the consumer project. `PipelinePaths` already does this — you rarely
+ * need to instantiate `PathResolver` directly.
+ */
 export class PathResolver {
+  /**
+   * Walks up the directory tree from `process.cwd()` to find the nearest `package.json`
+   * whose `name` is not `@thinkwise/testwise`, returning that directory as the consumer
+   * project root. Falls back to `process.cwd()` if no such package is found.
+   * @returns Absolute path to the consumer project's root directory.
+   */
   public getConsumerRootDirectory(): string {
     let directory = process.cwd();
     let lastDir = '';

package/helpers/Poll.ts

@@ -1,5 +1,17 @@
-import type { PollOptions } from '../types/PollTypes.ts';
+import type { PollOptions } from '../types/PollTypes.js';
 
+/**
+ * Repeatedly calls `fn` at a configurable interval until the optional `predicate` returns
+ * truthy or the `timeout` is exceeded, at which point it throws.
+ * `onTick` is called with the last value and elapsed time after each failing attempt.
+ * @param fn - The async or sync function to poll.
+ * @param opts.timeout - Maximum wait time in milliseconds (default `10 000`).
+ * @param opts.interval - Polling interval in milliseconds (default `200`).
+ * @param opts.predicate - Returns `true` when the result is acceptable (default: truthy check).
+ * @param opts.onTick - Called after each failing attempt with the last value and elapsed ms.
+ * @returns The first value for which `predicate` returns `true`.
+ * @throws If `timeout` is exceeded before `predicate` returns `true`.
+ */
 export async function pollUntil<T>(fn: () => Promise<T> | T, opts: PollOptions<T> = {}): Promise<T> {
   const timeout = opts.timeout ?? 10_000;
   const interval = opts.interval ?? 200;

package/helpers/RegexHelper.ts

@@ -1,10 +1,22 @@
-// Escapes characters with special meaning in regexes.
+/**
+ * Escapes all characters with special meaning in regular expressions so that `input`
+ * can be safely embedded inside a `RegExp` constructor without unintended pattern matching.
+ * @param input - The raw string to escape.
+ * @returns The escaped string.
+ */
 export function escapeRegex(input: string): string {
   return input.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
-// Exact match, case-insensitive, Unicode-safe.
-// By default trims the input; set trim=false for truly literal.
+/**
+ * Builds a case-insensitive, Unicode-safe `RegExp` that exactly matches `input`.
+ * Optionally trims leading/trailing whitespace and collapses internal whitespace runs
+ * to a single space to match typical UI text normalization.
+ * @param input - The text to match exactly.
+ * @param opts.trim - Trim leading/trailing whitespace before matching (default `true`).
+ * @param opts.collapseWhitespace - Collapse runs of whitespace to a single space (default `false`).
+ * @returns A case-insensitive `RegExp` anchored with `^` and `$`.
+ */
 export function exactTextRegex(input: string, opts?: { trim?: boolean; collapseWhitespace?: boolean }) {
   const { trim = true, collapseWhitespace = false } = opts ?? {};
   let s = trim ? input.trim() : input;

package/helpers/SubjectNavigator.ts

@@ -0,0 +1,57 @@
+import type { Page } from '@playwright/test';
+import { FlightTracker } from './FlightTracker.js';
+
+/**
+ * Navigates the browser to a Thinkwise subject deep-link URL and waits for
+ * the application to fully settle before returning control to the test.
+ *
+ * **Why this exists:** Calling `page.goto()` directly does not account for
+ * the asynchronous XHR requests that the Thinkwise app fires after a navigation
+ * event. Tests that act immediately after a bare `goto` frequently encounter
+ * loading spinners, empty grids, or incomplete form data. `SubjectNavigator`
+ * wraps navigation in a `FlightTracker` session so the test only continues
+ * once the network is truly idle.
+ *
+ * **How to use it:** You typically don't call this directly — it is used
+ * internally by the generated subject class `goTo()` methods. If you need
+ * to navigate imperatively in a test, prefer `page.subject.MySubjectClass.goTo()`.
+ *
+ * @example
+ * // Inside a generated subject class:
+ * const navigator = new SubjectNavigator(page);
+ * await navigator.navigateTo('subjects/Employee/Editable1/Main');
+ */
+export class SubjectNavigator {
+  private readonly _page: Page;
+
+  constructor(page: Page) {
+    this._page = page;
+  }
+
+  public async navigateTo(url: string): Promise<void> {
+    const flightTracker = new FlightTracker();
+
+    const onRequest = (request: import('@playwright/test').Request) => {
+      flightTracker.handleRequestStarted(request.url(), request.resourceType());
+    };
+    const onResponse = (response: import('@playwright/test').Response) => {
+      flightTracker.handleRequestFinished(response.request().url());
+    };
+    const onRequestFailed = (request: import('@playwright/test').Request) => {
+      flightTracker.handleRequestFailed(request.url());
+    };
+
+    this._page.on('request', onRequest);
+    this._page.on('response', onResponse);
+    this._page.on('requestfailed', onRequestFailed);
+
+    try {
+      await this._page.goToDeepLink(url);
+      await flightTracker.waitForNavigationToSettle();
+    } finally {
+      this._page.off('request', onRequest);
+      this._page.off('response', onResponse);
+      this._page.off('requestfailed', onRequestFailed);
+    }
+  }
+}

package/helpers/UserSimulationHelper.ts

@@ -2,6 +2,20 @@ import type { Page } from '@playwright/test';
 import { testwiseConfig } from '../services/ConfigBuilder.js';
 import { pollUntil } from './Poll.js';
 
+/**
+ * Simulates switching the active user identity in the Thinkwise application
+ * at runtime, without logging out and back in. Useful for testing
+ * role-based access control (RBAC) and user-specific workflows.
+ *
+ * Exposed on the page fixture via `UserSimulation` as `page.simulateUser()`,
+ * `page.getSimulatedUser()`, and `page.stopSimulation()`. You do not
+ * instantiate `UserSimulationHelper` directly in tests.
+ *
+ * @example
+ * await page.simulateUser('john.doe@example.com');
+ * // ... assert behaviour for this user ...
+ * await page.stopSimulation();
+ */
 export class UserSimulationHelper {
   private _page: Page;
   private _serviceUrl: string;

package/helpers/index.ts

@@ -1,3 +1,4 @@
 export * from './LoginHelper.js';
 export * from './PathResolver.js';
 export * from './RegexHelper.js';
+export * from './SubjectNavigator.js';

package/index.ts

@@ -17,6 +17,7 @@ export * from './components/index.js';
 export * from './controls/index.js';
 export * from './enums/index.js';
 export * from './helpers/index.js';
+export * from './mcp/index.js';
 export * from './page-extensions/index.js';
 export * from './page-overrides/index.js';
 export * from './services/index.js';

package/interfaces/IComponentObjects.ts

@@ -1,6 +1,18 @@
 import type { Locator } from '@playwright/test';
 
+/**
+ * Base contract that every `*Objects` class in `components/` and `controls/`
+ * must implement.
+ *
+ * **Why this exists:** Each component is split into two files — a `<Name>.ts`
+ * (public API with interaction methods) and a `<Name>Objects.ts` (raw locator
+ * accessors). `IComponentObjects` enforces that every `Objects` class exposes
+ * the two locators that all Thinkwise screens share: the scoped `context`
+ * locator and the page-level `mainHeader` locator used for presence checks.
+ */
 export interface IComponentObjects {
+  /** The scoped Playwright `Locator` that roots all locator lookups for this component instance. */
   context: Locator;
+  /** Locator for `main header` — used as a presence anchor to confirm the screen has rendered. */
   mainHeader: Locator;
 }

package/interfaces/IComponentSchemaMeta.ts

@@ -0,0 +1,17 @@
+import type { SubjectComponents } from '../types/Components.js';
+
+/** Metadata for a single property within a generated component schema. */
+export interface IComponentPropertyMeta {
+  colId: string;
+  elementType: string;
+}
+
+/**
+ * The full meta file that SchemaGenerator writes alongside each `.json`
+ * schema file, and that SubjectComponentGenerator reads back to drive code
+ * generation.
+ */
+export interface IComponentSchemaMeta {
+  componentType: SubjectComponents;
+  properties: Record<string, IComponentPropertyMeta>;
+}

package/interfaces/IProperty.ts

@@ -1,4 +1,17 @@
+/**
+ * Describes a single field or column on a Thinkwise screen, as returned by
+ * the Indicium API and stored in `seed-data/subjects.json`.
+ *
+ * The `control_type` drives which Testwise control helper gets generated for
+ * the property (e.g. `"field"` → `InputFieldControl`, `"lookup"` → `LookupDropdown`).
+ */
 export interface IProperty {
+  /** The field or column identifier as defined in the Thinkwise model (e.g. `"employee_id"`). */
   col: string;
+  /**
+   * The Thinkwise UI control type for this property.
+   * Drives the control class suffix appended in generated subject components.
+   * Common values: `"field"`, `"lookup"`, `"dropdown"`, `"checkbox"`, `"date_picker"`, `"combo_box"`.
+   */
   control_type: string;
 }

package/interfaces/IRegisteredSubjects.ts

@@ -1,5 +1,17 @@
+/**
+ * Describes a subject that has been registered in the consumer project's
+ * `registeredSubjects.json` file.
+ *
+ * The `SubjectRegistration` pipeline step reads generated subject classes and
+ * writes an entry here for each one. The `SubjectRegistry` page-extension
+ * reads this file at test startup to make all subjects available on
+ * `page.subject.<ClassName>`.
+ */
 export interface IRegisteredSubjects {
+  /** Thinkwise subject identifier (e.g. `"Employee"`). */
   subject: string;
+  /** Optional variant discriminator when the same subject has multiple variants (e.g. `"Editable1"`). */
   variant?: string;
+  /** Screen type context — `"Main"`, `"Popup"`, `"Zoom"`, or `"Detail"`. */
   screen_type: string;
 }

package/interfaces/ISeedSubjectDraft.ts

@@ -0,0 +1,17 @@
+import type { IProperty } from './IProperty.js';
+
+/**
+ * Represents a subject as it is built from the Indicium API before properties
+ * are fully populated. `properties` is optional here because it is assigned
+ * after the initial object is constructed during the build phase.
+ *
+ * Once written to `subjects.json` and read back via `DataRetriever`, the data
+ * is typed as the narrower `ISubject` (which requires `properties`).
+ */
+export interface ISeedSubjectDraft {
+  subject: string;
+  variant: string;
+  screentype_context: string;
+  screentype_id: string;
+  properties?: IProperty[];
+}

package/interfaces/ISubject.ts

@@ -1,9 +1,22 @@
 import type { IProperty } from './IProperty.js';
 
+/**
+ * Represents a single Thinkwise subject as stored in `seed-data/subjects.json`
+ * after the `ModelDataBuilder` pipeline step fetches it from the Indicium API.
+ *
+ * Each subject maps to one screen variant in the Thinkwise application. The
+ * `SubjectClassModelBuilder` reads these records and turns them into generated
+ * TypeScript subject classes under `test-artifacts/subjects/`.
+ */
 export interface ISubject {
+  /** Internal Thinkwise subject identifier (e.g. `"Employee"`). */
   subject: string;
+  /** Subject variant, used to distinguish multiple configurations of the same subject (e.g. `"Editable1"`). */
   variant: string;
+  /** Human-readable screen context: `"Main"`, `"Popup"`, `"Zoom"`, or `"Detail"`. */
   screentype_context: string;
+  /** Thinkwise screen type identifier used to look up the correct screen schema file. */
   screentype_id: string;
+  /** All field/column properties available on this screen. */
   properties: IProperty[];
 }

package/interfaces/ISubjectDetail.ts

@@ -0,0 +1,12 @@
+/** Screen context variants produced by the artifact-builder pipeline. */
+export type ScreenContext = 'Main' | 'Popup' | 'Zoom' | 'Detail';
+
+/**
+ * Describes a single generated subject class that the SubjectRegistration
+ * step registers in the SubjectRegistry.
+ */
+export interface ISubjectDetail {
+  subject: string;
+  variant?: string;
+  screen: ScreenContext;
+}

package/mcp/ArtifactResolver.ts

@@ -0,0 +1,296 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { PipelinePaths } from '../artifact-builder/helpers/PipelinePaths.js';
+import type { ScreenContext } from '../interfaces/ISubjectDetail.js';
+
+/** All known screen context suffixes, ordered longest-first to avoid prefix clashes. */
+const screenContexts: ScreenContext[] = ['Detail', 'Popup', 'Main', 'Zoom'];
+
+/** Describes a single generated subject class discovered in the test-artifacts directory. */
+export interface SubjectArtifactInfo {
+  /** PascalCase subject folder name (e.g. `"CustomerOrder"`). */
+  subject: string;
+  /** Exact generated class name (e.g. `"CustomerOrderMain"`). */
+  className: string;
+  /** Screen context encoded in the class name. */
+  screenContext: ScreenContext;
+  /**
+   * Module specifier that importing code should use, relative to the consumer
+   * project root (e.g. `"@thinkwise/testwise/test-artifacts/subjects/CustomerOrder/CustomerOrderMain.js"`).
+   */
+  importPath: string;
+}
+
+/** Describes a single field or column on a screen interface. */
+export interface ScreenFieldInfo {
+  /** camelCase property name as it appears on the screen interface (e.g. `"customerName"`, `"orderDate"`). */
+  propertyName: string;
+  /**
+   * Testwise control type suffix indicating which control helper to use
+   * (e.g. `"Field"`, `"Lookup"`, `"Dropdown"`, `"DatePicker"`, `"Checkbox"`, `"Textarea"`, `"ComboBox"`).
+   * Derived from the property name suffix in the generated interface.
+   */
+  controlType: string;
+  /** The component this field belongs to — `"Form"` or `"Grid"`. */
+  componentType: 'Form' | 'Grid';
+}
+
+/** Describes a single typed component property on a generated subject class. */
+export interface ComponentInfo {
+  /** camelCase property name as declared on the subject class (e.g. `"grid"`, `"actionBar"`). */
+  propertyName: string;
+  /** Testwise component class name (e.g. `"Grid"`, `"ActionBar"`, `"Form"`). */
+  componentType: string;
+}
+
+/**
+ * Runtime service that reads the generated test-artifact files to answer
+ * questions about available subjects, their screen-context variants, and the
+ * components exposed on each subject class.
+ *
+ * Intended to be used by the `@thinkwise/testwise-mcp` server so that AI
+ * tooling can discover the correct class names and component properties before
+ * generating test code — without having to guess or hallucinate names.
+ */
+/**
+ * Runtime service that reads the generated test-artifact files to answer
+ * questions about available subjects, their screen-context variants, and the
+ * components exposed on each subject class.
+ *
+ * **What it does:** The `@thinkwise/testwise-mcp` MCP server calls these
+ * methods to surface information to AI tooling (e.g. GitHub Copilot agents)
+ * so the AI can write correct Testwise tests without guessing class names,
+ * property names, or field names.
+ *
+ * **How to use it (as a consumer of the MCP server):** You don't call this
+ * class directly — use the MCP tools:
+ * - `list_subjects()` — all available subject folder names
+ * - `list_artifacts(subject?, screenContext?)` — exact class names + import paths
+ * - `get_components(subject, screenContext)` — component properties on a class
+ * - `get_screen_interface(subject, screenContext)` — field/column names + control types
+ *
+ * **For contributors:** This class is intentionally side-effect-free — it
+ * only reads files and never writes anything. Do not add browser-interaction
+ * logic here.
+ *
+ * @example
+ * // Used internally by the MCP server:
+ * const resolver = new ArtifactResolver();
+ * const subjects = resolver.listSubjects();
+ * const artifacts = resolver.listArtifacts('Employee', 'Main');
+ */
+export class ArtifactResolver {
+  private readonly _paths: PipelinePaths;
+
+  constructor(paths?: PipelinePaths) {
+    this._paths = paths ?? new PipelinePaths();
+  }
+
+  /**
+   * Returns all subject folder names (PascalCase) that have been generated
+   * into the test-artifacts directory.
+   *
+   * @example
+   * resolver.listSubjects();
+   * // → ["CustomerOrder", "Product", "Employee"]
+   */
+  public listSubjects(): string[] {
+    const subjectsDir = this._paths.subjects;
+
+    if (!fs.existsSync(subjectsDir)) return [];
+
+    return fs.readdirSync(subjectsDir).filter((entry) => fs.statSync(path.join(subjectsDir, entry)).isDirectory());
+  }
+
+  /**
+   * Returns all artifacts for the given subject, optionally filtered to a
+   * specific screen context.
+   *
+   * When `subject` is omitted every generated artifact is returned.
+   *
+   * @example
+   * // All screen contexts for one subject
+   * resolver.listArtifacts('CustomerOrder');
+   * // → [{ className: "CustomerOrderMain", screenContext: "Main", ... }, ...]
+   *
+   * @example
+   * // One specific artifact
+   * resolver.listArtifacts('CustomerOrder', 'Main');
+   * // → [{ className: "CustomerOrderMain", screenContext: "Main", ... }]
+   */
+  public listArtifacts(subject?: string, screenContext?: ScreenContext): SubjectArtifactInfo[] {
+    const subjects = subject ? [subject] : this.listSubjects();
+    const results: SubjectArtifactInfo[] = [];
+
+    for (const subjectName of subjects) {
+      const subjectDir = path.join(this._paths.subjects, subjectName);
+
+      if (!fs.existsSync(subjectDir)) continue;
+
+      const files = fs.readdirSync(subjectDir).filter((f) => f.endsWith('.ts') && f !== 'index.ts');
+
+      for (const file of files) {
+        const className = file.replace('.ts', '');
+        const context = this.inferScreenContext(className);
+
+        if (!context) continue;
+        if (screenContext && context !== screenContext) continue;
+
+        results.push({
+          subject: subjectName,
+          className,
+          screenContext: context,
+          importPath: `@thinkwise/testwise/test-artifacts/subjects/${subjectName}/${className}.js`
+        });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Returns the typed component properties declared on the generated subject
+   * class for the given subject + screen context combination.
+   *
+   * @example
+   * resolver.getComponents('CustomerOrder', 'Main');
+   * // → [
+   * //   { propertyName: "grid",      componentType: "Grid"      },
+   * //   { propertyName: "actionBar", componentType: "ActionBar" },
+   * //   { propertyName: "filterForm",componentType: "FilterForm"},
+   * // ]
+   */
+  public getComponents(subject: string, screenContext: ScreenContext): ComponentInfo[] {
+    const artifacts = this.listArtifacts(subject, screenContext);
+
+    if (artifacts.length === 0) return [];
+
+    const filePath = path.join(this._paths.subjects, subject, `${artifacts[0].className}.ts`);
+
+    if (!fs.existsSync(filePath)) return [];
+
+    return this.parseComponentProperties(fs.readFileSync(filePath, 'utf-8'));
+  }
+
+  /**
+   * Returns all fields and columns declared on the generated screen interface
+   * for the given subject + screen context combination.
+   *
+   * The interface lives in `test-artifacts/screens/` and contains every field
+   * name, column name, and control type for the screen — enough for an AI to
+   * write a complete, accurate test without inspecting a live browser.
+   *
+   * @example
+   * resolver.getScreenInterface('CustomerOrder', 'Main');
+   * // → [
+   * //   { propertyName: "customerName", controlType: "Field",      componentType: "Form" },
+   * //   { propertyName: "orderDate",    controlType: "DatePicker",  componentType: "Form" },
+   * //   { propertyName: "status",       controlType: "Lookup",      componentType: "Form" },
+   * //   { propertyName: "orderId",      controlType: "Column",      componentType: "Grid" },
+   * // ]
+   */
+  public getScreenInterface(subject: string, screenContext: ScreenContext): ScreenFieldInfo[] {
+    const artifacts = this.listArtifacts(subject, screenContext);
+    if (artifacts.length === 0) return [];
+
+    // Component files live in Components/ subfolder under the subject folder
+    const componentsDir = path.join(this._paths.subjects, subject, 'Components');
+    if (!fs.existsSync(componentsDir)) return [];
+
+    const results: ScreenFieldInfo[] = [];
+    const componentFiles = fs.readdirSync(componentsDir).filter((f) => f.endsWith('.ts'));
+
+    for (const file of componentFiles) {
+      const content = fs.readFileSync(path.join(componentsDir, file), 'utf-8');
+      const interfaceName = file.replace('.ts', '');
+      const fields = this.parseScreenInterface(content, interfaceName);
+      results.push(...fields);
+    }
+
+    return results;
+  }
+
+  // ── Private helpers ────────────────────────────────────────────────────────
+
+  private inferScreenContext(className: string): ScreenContext | undefined {
+    for (const ctx of screenContexts) {
+      if (className.endsWith(ctx)) return ctx;
+    }
+    return undefined;
+  }
+
+  /**
+   * Parses component properties from a generated subject class.
+   *
+   * Generated classes declare properties without `public`:
+   *   actionBarVXE6V0YT: ActionBar;
+   *   gridQT3UL7F8: EmployeeGrid;
+   */
+  private parseComponentProperties(content: string): ComponentInfo[] {
+    const results: ComponentInfo[] = [];
+
+    // Match class-body property declarations: "  name: Type;" (no public keyword)
+    // Excludes private fields (_name), constructor, and method declarations
+    const propertyRegex = /^\s{4}(\w+)\s*:\s*(\w+)\s*;/gm;
+
+    for (let match = propertyRegex.exec(content); match !== null; match = propertyRegex.exec(content)) {
+      const propertyName = match[1];
+      const componentType = match[2];
+
+      if (propertyName.startsWith('_')) continue;
+      if (['string', 'number', 'boolean', 'Page', 'Locator'].includes(componentType)) continue;
+
+      results.push({ propertyName, componentType });
+    }
+
+    return results;
+  }
+
+  /**
+   * Parses fields/columns from the Components/ subfolder files for a subject.
+   *
+   * Generated component files (e.g. EmployeeGrid.ts, EmployeeForm.ts) declare
+   * getters like:
+   *   public get firstNameColumn(): IGridColumnControl { ... }
+   *   public get firstNameField(): IInputFieldControl { ... }
+   */
+  private parseScreenInterface(content: string, interfaceName: string): ScreenFieldInfo[] {
+    const results: ScreenFieldInfo[] = [];
+
+    // Match readonly interface members: "  readonly bioColumn: IGridColumnControl;"
+    const interfaceRegex = /^\s+readonly\s+(\w+)\s*:\s*(I?\w+Control)\s*;/gm;
+    for (let match = interfaceRegex.exec(content); match !== null; match = interfaceRegex.exec(content)) {
+      const propertyName = match[1];
+      const rawType = match[2];
+      const controlType = this.inferControlType(rawType, propertyName);
+      const componentType = interfaceName.toLowerCase().includes('grid') ? 'Grid' : 'Form';
+      results.push({ propertyName, controlType, componentType: componentType as 'Form' | 'Grid' });
+    }
+
+    return results;
+  }
+
+  private inferControlType(rawType: string, propertyName: string): string {
+    const typeMap: Record<string, string> = {
+      IGridColumnControl: 'Column',
+      GridColumnControl: 'Column',
+      IInputFieldControl: 'Field',
+      InputFieldControl: 'Field',
+      ILookupDropdown: 'Lookup',
+      LookupDropdown: 'Lookup',
+      IFormComboBox: 'ComboBox',
+      FormComboBox: 'ComboBox',
+      IDateControl: 'DatePicker',
+      DateControl: 'DatePicker',
+      ICheckboxControl: 'Checkbox',
+      CheckboxControl: 'Checkbox',
+      ITextareaControl: 'Textarea',
+      TextareaControl: 'Textarea'
+    };
+
+    if (typeMap[rawType]) return typeMap[rawType];
+
+    const suffixMatch = propertyName.match(/(Field|Lookup|Dropdown|DatePicker|Checkbox|Textarea|ComboBox|Column)$/i);
+    return suffixMatch ? suffixMatch[1] : rawType;
+  }
+}

package/mcp/index.ts

@@ -0,0 +1,2 @@
+export type { ComponentInfo, ScreenFieldInfo, SubjectArtifactInfo } from './ArtifactResolver.js';
+export { ArtifactResolver } from './ArtifactResolver.js';