@solidxai/core 0.1.13-beta.2 → 0.1.13-beta.21

package/src/testing/README.md

@@ -75,6 +75,57 @@ General step fields:
 - `timeoutMs` (optional): per-step timeout override
 - `spec` (optional): used by `test.spec` to identify the spec
 
+## Timeouts
+There are two independent timeout layers. They are easy to confuse, so note which one you want:
+
+**1. Engine timeouts** — `scenario.timeoutMs` and the top-level `step.timeoutMs`.
+These wrap execution in a `Promise.race` (`core/timeout.ts`). They are a hard upper bound
+on wall-clock time and do **not** cancel the underlying browser call, so the failure message
+only tells you the scenario or op that overran.
+
+**2. UI (Playwright) timeouts** — the run-wide default plus per-step `with.timeoutMs`.
+This is what governs how long `ui.expectVisible`, `ui.click`, `ui.fill` etc. wait for a
+selector. Playwright cancels the operation itself, so the error names the selector and the
+state it was waiting for. **If your UI steps are timing out, this is the knob to turn.**
+
+Resolution order for UI steps: `with.timeoutMs` → `--ui-timeout-ms` → `UI_TIMEOUT_MS` →
+`uiTestDefaultTimeoutMs` setting → `30000`.
+`ui.goto` uses the navigation timeout instead: `with.timeoutMs` → `--ui-navigation-timeout-ms`
+→ `UI_NAVIGATION_TIMEOUT_MS` → `uiTestNavigationTimeoutMs` setting → the resolved UI timeout.
+
+Raise the default for a whole run:
+```bash
+solid test run --module <module-name> --ui-timeout-ms 60000
+# or
+UI_TIMEOUT_MS=60000 solid test run --module <module-name>
+```
+
+Or set the installation-wide default under **Settings → Testing Settings** in the admin UI
+(`uiTestDefaultTimeoutMs` / `uiTestNavigationTimeoutMs`). Those rows are created by `solid seed`;
+until then the built-in `30000` applies. Flags and env vars still win, so CI keeps per-run control.
+
+The seeded value of those two settings can be provisioned from the environment with
+`COMMON_UI_TEST_DEFAULT_TIMEOUT_MS` and `COMMON_UI_TEST_NAVIGATION_TIMEOUT_MS` (the latter falls
+back to the former). Seeding is insert-only, so these apply on first seed only — afterwards the
+stored value wins and the setting must be changed in the admin UI. Values that are missing,
+non-numeric, or not positive fall back to `30000`.
+
+Note these are distinct from the run-time `UI_TIMEOUT_MS` / `UI_NAVIGATION_TIMEOUT_MS` vars,
+which override the setting on a per-run basis and are read every run.
+
+Or bump only the one slow step, leaving the rest of the suite strict:
+```json
+{
+  "then": {
+    "op": "ui.expectVisible",
+    "with": { "selector": "#report-grid", "timeoutMs": 90000 }
+  }
+}
+```
+
+Caution: a scenario-level `timeoutMs` lower than the UI timeout will fire first and mask the
+more useful Playwright error. Keep `defaults.timeoutMs` above your UI timeout.
+
 ## Interpolation
 Available tokens:
 - `${env:NAME}` (environment variables)
@@ -198,6 +249,7 @@ Description: Navigates the browser to a URL.
 
 Options in `with`:
 - `url` (required)
+- `timeoutMs` (optional, overrides the run-wide UI navigation timeout)
 
 ### **Op: `ui.expectUrl`**
 Description: Asserts the current page URL.
@@ -212,6 +264,7 @@ Description: Fills an input or editable element.
 Options in `with`:
 - `selector` (required)
 - `value` (required)
+- `timeoutMs` (optional, overrides the run-wide UI timeout)
 
 ### **Op: `ui.select`**
 Description: Selects an option in a select element.
@@ -219,12 +272,14 @@ Description: Selects an option in a select element.
 Options in `with`:
 - `selector` (required)
 - `value` (required)
+- `timeoutMs` (optional, overrides the run-wide UI timeout)
 
 ### **Op: `ui.click`**
 Description: Clicks an element located by selector.
 
 Options in `with`:
 - `selector` (required)
+- `timeoutMs` (optional, overrides the run-wide UI timeout)
 
 ### **Op: `ui.press`**
 Description: Presses a keyboard key on a focused element.
@@ -232,6 +287,7 @@ Description: Presses a keyboard key on a focused element.
 Options in `with`:
 - `selector` (required)
 - `key` (required)
+- `timeoutMs` (optional, overrides the run-wide UI timeout)
 
 ### **Op: `ui.waitForManual`**
 Description: Pauses a headed Playwright run so a human can interact with the live browser, then resumes when Enter is pressed in the terminal.
@@ -242,7 +298,7 @@ Options in `with`:
 - `waitForSelector` (optional, waits for a visible selector after resume)
 - `waitForUrlEquals` (optional, waits until the current URL exactly matches)
 - `waitForUrlContains` (optional, waits until the current URL contains a substring)
-- `timeoutMs` (optional, timeout for post-resume waits)
+- `timeoutMs` (optional, timeout for post-resume waits; defaults to the run-wide UI timeout)
 - `bringToFront` (optional, defaults to `true`)
 
 Notes:
@@ -269,6 +325,7 @@ Description: Waits for an element to be visible.
 
 Options in `with`:
 - `selector` (required)
+- `timeoutMs` (optional, overrides the run-wide UI timeout)
 
 ### **Op: `ui.expectText`**
 Description: Asserts the text content of an element.
@@ -277,6 +334,7 @@ Options in `with`:
 - `selector` (required)
 - `equals` (optional)
 - `contains` (optional)
+- `timeoutMs` (optional, overrides the run-wide UI timeout)
 
 ### **Op: `assert.equals`**
 Description: Asserts strict equality between two values.
@@ -388,7 +446,12 @@ await runFromMetadata({
   includeTags: ["smoke"],
   defaults: { timeoutMs: 30_000, retries: 1 },
   api: { baseUrl: "https://api.example.com" },
-  ui: { baseUrl: "https://app.example.com", headless: true }
+  ui: {
+    baseUrl: "https://app.example.com",
+    headless: true,
+    defaultTimeoutMs: 30_000,
+    navigationTimeoutMs: 45_000
+  }
 });
 ```
 
@@ -409,9 +472,18 @@ Lightweight existing-database workflow:
 
 For human-assisted OTP or third-party verification flows, use `ui.waitForManual` in a headed run so the browser remains interactive while the scenario is paused.
 
+Common `test run` flags (all pass through solidctl unchanged):
+- `--ui-base-url <url>` / `--api-base-url <url>`
+- `--headless [true|false]`
+- `--ui-timeout-ms <number>` — default wait for every UI step (see [Timeouts](#timeouts))
+- `--ui-navigation-timeout-ms <number>` — default wait for `ui.goto`
+- `--timeout-ms <number>` / `--retries <number>` — scenario-level guard and retry count
+- `--scenario-ids <ids>` / `--include-tags <tags>` / `--skip-scenario-ids <ids>`
+- `--no-progress` — disable the interactive test progress footer
+
 ## Add A New Step (SOP)
 1. Create a new `*.step.ts` in the right domain folder.
 2. Implement a `registerXSteps(registry)` function and `registry.register("op.name", handler)`.
 3. Validate required `step.with` fields and throw clear errors.
 4. Use adapters via `ctx.api` / `ctx.ui` and update `ctx.last` when helpful.
-5. Export and register it from the domain `index.ts`.
+5. Export and register it from the domain `index.ts`.

package/src/testing/adapters/ui/playwright-adapter.ts

@@ -6,9 +6,13 @@ function isAbsoluteUrl(url: string): boolean {
   return /^https?:\/\//i.test(url);
 }
 
+export const DEFAULT_UI_TIMEOUT_MS = 30_000;
+
 export class PlaywrightAdapter {
   private readonly baseUrl?: string;
   private readonly headless: boolean;
+  private readonly defaultTimeoutMs: number;
+  private readonly navigationTimeoutMs: number;
   private browser?: Browser;
   private context?: BrowserContext;
   public page?: Page;
@@ -16,16 +20,37 @@ export class PlaywrightAdapter {
   constructor(opts?: PlaywrightAdapterOptions) {
     this.baseUrl = opts?.baseUrl;
     this.headless = opts?.headless ?? true;
+    this.defaultTimeoutMs = opts?.defaultTimeoutMs ?? DEFAULT_UI_TIMEOUT_MS;
+    this.navigationTimeoutMs =
+      opts?.navigationTimeoutMs ?? this.defaultTimeoutMs;
   }
 
   isHeadless(): boolean {
     return this.headless;
   }
 
+  /**
+   * Resolves the timeout for a single Playwright call: an explicit per-step
+   * value wins, otherwise the run-wide default applies.
+   */
+  resolveTimeout(stepTimeoutMs?: number): number {
+    return typeof stepTimeoutMs === 'number' && Number.isFinite(stepTimeoutMs)
+      ? stepTimeoutMs
+      : this.defaultTimeoutMs;
+  }
+
+  resolveNavigationTimeout(stepTimeoutMs?: number): number {
+    return typeof stepTimeoutMs === 'number' && Number.isFinite(stepTimeoutMs)
+      ? stepTimeoutMs
+      : this.navigationTimeoutMs;
+  }
+
   async start(): Promise<void> {
     const { chromium } = await import('playwright');
     this.browser = await chromium.launch({ headless: this.headless });
     this.context = await this.browser.newContext();
+    this.context.setDefaultTimeout(this.defaultTimeoutMs);
+    this.context.setDefaultNavigationTimeout(this.navigationTimeoutMs);
     this.page = await this.context.newPage();
   }
 

package/src/testing/adapters/ui/ui.types.ts

@@ -1,4 +1,6 @@
 export interface PlaywrightAdapterOptions {
   headless?: boolean;
   baseUrl?: string;
+  defaultTimeoutMs?: number;
+  navigationTimeoutMs?: number;
 }

package/src/testing/reporter/console-reporter.ts

@@ -150,6 +150,10 @@ export class ConsoleReporter implements Reporter {
   private passedScenarios = 0;
   private failedScenarios = 0;
 
+  onRunStart(_args: { total: number }): void {
+    // Progress-aware reporters use this hook; the plain console reporter has no setup.
+  }
+
   onScenarioStart(scenario: { id: string; name?: string }): void {
     const label = scenario.name ? `${scenario.id} (${scenario.name})` : scenario.id;
     console.log(`\n▶ Scenario: ${label}`);

package/src/testing/reporter/progress-reporter.ts

@@ -0,0 +1,251 @@
+import * as readline from "readline";
+import type { StepPhase } from "../contracts/runtime-context.types";
+import type { OpStep, ScenarioSpec } from "../contracts/testing-metadata.types";
+import type { SolidTestSpecResult } from "../contracts/test-spec.types";
+import type { Reporter } from "./reporter.types";
+
+const ANSI_BOLD = "\u001b[1m";
+const ANSI_BOLD_OFF = "\u001b[22m";
+const ANSI_DIM = "\u001b[2m";
+const ANSI_GREEN = "\u001b[32m";
+const ANSI_COLOR_OFF = "\u001b[39m";
+const ANSI_RED = "\u001b[31m";
+const ANSI_INVERSE = "\u001b[7m";
+const ANSI_INVERSE_OFF = "\u001b[27m";
+
+export class ProgressReporter implements Reporter {
+  private startedAt = Date.now();
+  private total = 0;
+  private completed = 0;
+  private passed = 0;
+  private failed = 0;
+  private timer?: NodeJS.Timeout;
+  private rendered = false;
+
+  constructor(private readonly delegate: Reporter) {}
+
+  onRunStart(args: { total: number }): void {
+    this.total = args.total;
+    this.startedAt = Date.now();
+    this.completed = 0;
+    this.passed = 0;
+    this.failed = 0;
+    this.delegate.onRunStart?.(args);
+    this.startTimer();
+    this.renderFooter();
+  }
+
+  onScenarioStart(scenario: ScenarioSpec): void {
+    this.withFooterPaused(() => this.delegate.onScenarioStart(scenario));
+  }
+
+  onScenarioEnd(
+    scenario: ScenarioSpec,
+    result: { ok: boolean; error?: unknown; durationMs: number },
+  ): void {
+    this.completed += 1;
+    if (result.ok) {
+      this.passed += 1;
+    } else {
+      this.failed += 1;
+    }
+    this.withFooterPaused(() => this.delegate.onScenarioEnd(scenario, result));
+  }
+
+  onStepStart(args: {
+    scenarioId: string;
+    phase: StepPhase;
+    step: OpStep;
+  }): void {
+    this.withFooterPaused(() => this.delegate.onStepStart(args));
+  }
+
+  onStepEnd(args: {
+    scenarioId: string;
+    phase: StepPhase;
+    step: OpStep;
+    ok: boolean;
+    error?: unknown;
+    durationMs: number;
+  }): void {
+    this.withFooterPaused(() => this.delegate.onStepEnd(args));
+  }
+
+  onSpecResult(args: {
+    scenarioId: string;
+    specId: string;
+    stepName?: string;
+    result: SolidTestSpecResult;
+  }): void {
+    this.withFooterPaused(() => this.delegate.onSpecResult?.(args));
+  }
+
+  attach(args: {
+    scenarioId: string;
+    name: string;
+    contentType: string;
+    data: Buffer | string;
+  }): void {
+    this.withFooterPaused(() => this.delegate.attach?.(args));
+  }
+
+  onRunEnd(args: {
+    ok: boolean;
+    total: number;
+    passed: number;
+    failed: number;
+    durationMs: number;
+  }): void {
+    this.completed = args.passed + args.failed;
+    this.passed = args.passed;
+    this.failed = args.failed;
+    this.total = args.total;
+    this.stopTimer();
+    this.withFooterPaused(() => this.delegate.onRunEnd?.(args), false);
+  }
+
+  private startTimer(): void {
+    this.stopTimer();
+    if (!this.isInteractive()) {
+      return;
+    }
+    this.timer = setInterval(() => this.renderFooter(), 1_000);
+    this.timer.unref?.();
+  }
+
+  private stopTimer(): void {
+    if (!this.timer) {
+      return;
+    }
+    clearInterval(this.timer);
+    this.timer = undefined;
+  }
+
+  private withFooterPaused(callback: () => void, renderAfter = true): void {
+    this.clearFooter();
+    callback();
+    if (renderAfter) {
+      this.renderFooter();
+    }
+  }
+
+  private renderFooter(): void {
+    if (!this.isInteractive()) {
+      return;
+    }
+
+    const terminalWidth = process.stdout.columns || 80;
+    const elapsed = formatElapsed(Date.now() - this.startedAt);
+    const progressText = `${this.completed}/${this.total}`;
+    const resultText = `${ANSI_GREEN}${this.passed} passed${ANSI_COLOR_OFF}${ANSI_DIM} | ${ANSI_BOLD_OFF}${this.failed ? ANSI_RED : ANSI_DIM}${this.failed} failed${this.failed ? ANSI_COLOR_OFF : ANSI_BOLD_OFF}`;
+    const footer = [
+      `${ANSI_BOLD}Tests${ANSI_BOLD_OFF}: ${this.renderProgressBar(terminalWidth)} ${progressText}`,
+      `${ANSI_BOLD}Elapsed${ANSI_BOLD_OFF}: ${elapsed}`,
+      resultText,
+    ].join(`${ANSI_DIM} | ${ANSI_BOLD_OFF}`);
+
+    readline.clearLine(process.stdout, 0);
+    readline.cursorTo(process.stdout, 0);
+    process.stdout.write(truncateAnsiText(`${ANSI_INVERSE} ${footer} ${ANSI_INVERSE_OFF}`, terminalWidth));
+    this.rendered = true;
+  }
+
+  private clearFooter(): void {
+    if (!this.rendered || !this.isInteractive()) {
+      return;
+    }
+    readline.clearLine(process.stdout, 0);
+    readline.cursorTo(process.stdout, 0);
+    this.rendered = false;
+  }
+
+  private renderProgressBar(terminalWidth: number): string {
+    const width = terminalWidth >= 120 ? 30 : terminalWidth >= 90 ? 22 : 14;
+    const ratio = this.total > 0 ? Math.min(1, this.completed / this.total) : 0;
+    const filled = Math.round(width * ratio);
+    const empty = Math.max(0, width - filled);
+    return `[${ANSI_GREEN}${"=".repeat(filled)}${ANSI_COLOR_OFF}${" ".repeat(empty)}]`;
+  }
+
+  private isInteractive(): boolean {
+    return Boolean(process.stdout.isTTY || process.env.SOLIDCTL_TEST_PROGRESS === "1");
+  }
+}
+
+function formatElapsed(durationMs: number): string {
+  const totalSeconds = Math.max(0, Math.floor(durationMs / 1000));
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  if (minutes < 60) {
+    return `${minutes}:${seconds.toString().padStart(2, "0")}`;
+  }
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  return `${hours}:${remainingMinutes.toString().padStart(2, "0")}:${seconds.toString().padStart(2, "0")}`;
+}
+
+function truncateAnsiText(text: string, maxWidth: number): string {
+  if (maxWidth <= 0) {
+    return "";
+  }
+
+  let visibleWidth = 0;
+  let index = 0;
+  let output = "";
+  let hasEscape = false;
+
+  while (index < text.length) {
+    if (text[index] === "\u001b") {
+      const match = /\u001b\[[0-9;]*m/.exec(text.slice(index));
+      if (!match) {
+        break;
+      }
+      output += match[0];
+      hasEscape = true;
+      index += match[0].length;
+      continue;
+    }
+
+    if (visibleWidth >= maxWidth) {
+      break;
+    }
+
+    output += text[index];
+    visibleWidth += 1;
+    index += 1;
+  }
+
+  if (index < text.length && maxWidth >= 1) {
+    output = trimAnsiText(output, maxWidth - 1) + "…";
+  }
+
+  if (hasEscape && !output.endsWith(ANSI_INVERSE_OFF)) {
+    output += ANSI_INVERSE_OFF;
+  }
+
+  return output;
+}
+
+function trimAnsiText(text: string, maxWidth: number): string {
+  let visibleWidth = 0;
+  let index = 0;
+  let output = "";
+
+  while (index < text.length && visibleWidth < maxWidth) {
+    if (text[index] === "\u001b") {
+      const match = /\u001b\[[0-9;]*m/.exec(text.slice(index));
+      if (!match) {
+        break;
+      }
+      output += match[0];
+      index += match[0].length;
+      continue;
+    }
+
+    output += text[index];
+    visibleWidth += 1;
+    index += 1;
+  }
+
+  return output;
+}

package/src/testing/reporter/reporter.types.ts

@@ -3,6 +3,9 @@ import type { OpStep, ScenarioSpec } from "../contracts/testing-metadata.types";
 import type { SolidTestSpecResult } from "../contracts/test-spec.types";
 
 export interface Reporter {
+  onRunStart?(args: {
+    total: number;
+  }): void;
   onScenarioStart(scenario: ScenarioSpec): void;
   onScenarioEnd(
     scenario: ScenarioSpec,

package/src/testing/runner/run-from-metadata.ts

@@ -67,6 +67,7 @@ export async function runFromMetadata(opts: RunnerOptions): Promise<void> {
 
   const resources = new SimpleResourceStore();
   const reporter = opts.reporter ?? new ConsoleReporter();
+  reporter.onRunStart?.({ total: scenarios.length });
   const api = new ApiAdapter(opts.api);
   const { PlaywrightAdapter } = await import("../adapters/ui/playwright-adapter");
   const ui = new PlaywrightAdapter(opts.ui);

package/src/testing/steps/ui/actions.step.ts

@@ -2,8 +2,8 @@ import type { TestContext } from "../../contracts/runtime-context.types";
 import type { OpStep } from "../../contracts/testing-metadata.types";
 import { StepRegistry } from "../../core/step-registry";
 
-type ClickInput = { selector: string };
-type PressInput = { selector: string; key: string };
+type ClickInput = { selector: string; timeoutMs?: number };
+type PressInput = { selector: string; key: string; timeoutMs?: number };
 
 function requirePage(ctx: TestContext, op: string) {
   if (!ctx.ui || !ctx.ui.page) {
@@ -19,7 +19,9 @@ export function registerActionSteps(registry: StepRegistry): void {
     if (!input.selector) {
       throw new Error('Missing "selector" in step.with for op "ui.click"');
     }
-    await page.click(input.selector);
+    await page.click(input.selector, {
+      timeout: ctx.ui?.resolveTimeout(input.timeoutMs),
+    });
   });
 
   registry.register("ui.press", async (ctx: TestContext, step: OpStep) => {
@@ -31,6 +33,8 @@ export function registerActionSteps(registry: StepRegistry): void {
     if (!input.key) {
       throw new Error('Missing "key" in step.with for op "ui.press"');
     }
-    await page.press(input.selector, input.key);
+    await page.press(input.selector, input.key, {
+      timeout: ctx.ui?.resolveTimeout(input.timeoutMs),
+    });
   });
 }

package/src/testing/steps/ui/assertions.step.ts

@@ -2,8 +2,13 @@ import type { TestContext } from "../../contracts/runtime-context.types";
 import type { OpStep } from "../../contracts/testing-metadata.types";
 import { StepRegistry } from "../../core/step-registry";
 
-type VisibleInput = { selector: string };
-type ExpectTextInput = { selector: string; equals?: string; contains?: string };
+type VisibleInput = { selector: string; timeoutMs?: number };
+type ExpectTextInput = {
+  selector: string;
+  equals?: string;
+  contains?: string;
+  timeoutMs?: number;
+};
 
 function requirePage(ctx: TestContext, op: string) {
   if (!ctx.ui || !ctx.ui.page) {
@@ -19,7 +24,10 @@ export function registerAssertionSteps(registry: StepRegistry): void {
     if (!input.selector) {
       throw new Error('Missing "selector" in step.with for op "ui.expectVisible"');
     }
-    await page.waitForSelector(input.selector, { state: "visible" });
+    await page.waitForSelector(input.selector, {
+      state: "visible",
+      timeout: ctx.ui?.resolveTimeout(input.timeoutMs),
+    });
   });
 
   registry.register("ui.expectHidden", async (ctx: TestContext, step: OpStep) => {
@@ -28,7 +36,10 @@ export function registerAssertionSteps(registry: StepRegistry): void {
     if (!input.selector) {
       throw new Error('Missing "selector" in step.with for op "ui.expectHidden"');
     }
-    await page.waitForSelector(input.selector, { state: "hidden" });
+    await page.waitForSelector(input.selector, {
+      state: "hidden",
+      timeout: ctx.ui?.resolveTimeout(input.timeoutMs),
+    });
   });
 
   registry.register("ui.expectText", async (ctx: TestContext, step: OpStep) => {
@@ -38,7 +49,9 @@ export function registerAssertionSteps(registry: StepRegistry): void {
       throw new Error('Missing "selector" in step.with for op "ui.expectText"');
     }
 
-    const text = await page.locator(input.selector).innerText();
+    const text = await page
+      .locator(input.selector)
+      .innerText({ timeout: ctx.ui?.resolveTimeout(input.timeoutMs) });
     if (input.equals !== undefined) {
       if (text !== input.equals) {
         throw new Error(

package/src/testing/steps/ui/form.step.ts

@@ -4,9 +4,13 @@ import type { TestContext } from "../../contracts/runtime-context.types";
 import type { OpStep } from "../../contracts/testing-metadata.types";
 import { StepRegistry } from "../../core/step-registry";
 
-type FillInput = { selector: string; value: string };
-type SelectInput = { selector: string; value: string };
-type UploadFileInput = { selector: string; filePath: string | string[] };
+type FillInput = { selector: string; value: string; timeoutMs?: number };
+type SelectInput = { selector: string; value: string; timeoutMs?: number };
+type UploadFileInput = {
+  selector: string;
+  filePath: string | string[];
+  timeoutMs?: number;
+};
 
 function requirePage(ctx: TestContext, op: string) {
   if (!ctx.ui || !ctx.ui.page) {
@@ -25,7 +29,9 @@ export function registerFormSteps(registry: StepRegistry): void {
     if (input.value === undefined) {
       throw new Error('Missing "value" in step.with for op "ui.fill"');
     }
-    await page.fill(input.selector, String(input.value));
+    await page.fill(input.selector, String(input.value), {
+      timeout: ctx.ui?.resolveTimeout(input.timeoutMs),
+    });
   });
 
   registry.register("ui.select", async (ctx: TestContext, step: OpStep) => {
@@ -37,7 +43,9 @@ export function registerFormSteps(registry: StepRegistry): void {
     if (input.value === undefined) {
       throw new Error('Missing "value" in step.with for op "ui.select"');
     }
-    await page.selectOption(input.selector, String(input.value));
+    await page.selectOption(input.selector, String(input.value), {
+      timeout: ctx.ui?.resolveTimeout(input.timeoutMs),
+    });
   });
 
   registry.register("ui.uploadFile", async (ctx: TestContext, step: OpStep) => {
@@ -53,6 +61,8 @@ export function registerFormSteps(registry: StepRegistry): void {
     const resolved = Array.isArray(input.filePath)
       ? input.filePath.map((p) => path.resolve(cwd, String(p)))
       : path.resolve(cwd, String(input.filePath));
-    await page.setInputFiles(input.selector, resolved);
+    await page.setInputFiles(input.selector, resolved, {
+      timeout: ctx.ui?.resolveTimeout(input.timeoutMs),
+    });
   });
 }

package/src/testing/steps/ui/manual.step.ts

@@ -28,7 +28,7 @@ export function registerManualSteps(registry: StepRegistry): void {
     const inputConfig = (step.with ?? {}) as WaitForManualInput;
     const message = inputConfig.message?.trim() || "Manual interaction required.";
     const prompt = inputConfig.prompt?.trim() || "Press Enter to continue...";
-    const timeoutMs = inputConfig.timeoutMs;
+    const timeoutMs = ctx.ui?.resolveTimeout(inputConfig.timeoutMs);
     const bringToFront = inputConfig.bringToFront ?? true;
 
     if (ctx.ui?.isHeadless()) {

package/src/testing/steps/ui/navigation.step.ts

@@ -2,7 +2,7 @@ import type { TestContext } from "../../contracts/runtime-context.types";
 import type { OpStep } from "../../contracts/testing-metadata.types";
 import { StepRegistry } from "../../core/step-registry";
 
-type GotoInput = { url: string };
+type GotoInput = { url: string; timeoutMs?: number };
 type ExpectUrlInput = { equals?: string; contains?: string };
 
 function requirePage(ctx: TestContext, op: string) {
@@ -20,7 +20,9 @@ export function registerNavigationSteps(registry: StepRegistry): void {
       throw new Error('Missing "url" in step.with for op "ui.goto"');
     }
     const url = ctx.ui?.resolveUrl(input.url) ?? input.url;
-    await page.goto(url);
+    await page.goto(url, {
+      timeout: ctx.ui?.resolveNavigationTimeout(input.timeoutMs),
+    });
   });
 
   registry.register("ui.expectUrl", async (ctx: TestContext, step: OpStep) => {