intellitester 0.2.11 → 0.2.13

package/dist/{chunk-VOGZ7IFW.js → chunk-BYSKHSJB.js}

@@ -15,14 +15,14 @@ import { createServer } from 'http';
 
 var nonEmptyString = z.string().trim().min(1, "Value cannot be empty");
 var LocatorSchema = z.object({
-  description: z.string().trim().optional(),
-  testId: z.string().trim().optional(),
-  text: z.string().trim().optional(),
-  css: z.string().trim().optional(),
-  xpath: z.string().trim().optional(),
-  role: z.string().trim().optional(),
-  name: z.string().trim().optional()
-}).refine(
+  description: z.string().trim().optional().describe("AI-friendly description of the element to find"),
+  testId: z.string().trim().optional().describe("data-testid attribute value"),
+  text: z.string().trim().optional().describe("Visible text content"),
+  css: z.string().trim().optional().describe("CSS selector"),
+  xpath: z.string().trim().optional().describe("XPath selector"),
+  role: z.string().trim().optional().describe("ARIA role"),
+  name: z.string().trim().optional().describe("Accessible name")
+}).describe("Defines how to locate an element on the page. At least one selector must be provided.").refine(
   (locator) => Boolean(
     locator.description || locator.testId || locator.text || locator.css || locator.xpath || locator.role || locator.name
   ),
@@ -30,73 +30,73 @@ var LocatorSchema = z.object({
 );
 var navigateActionSchema = z.object({
   type: z.literal("navigate"),
-  value: nonEmptyString
-});
+  value: nonEmptyString.describe("URL or path to navigate to")
+}).describe("Navigate to a URL");
 var tapActionSchema = z.object({
   type: z.literal("tap"),
   target: LocatorSchema
-});
+}).describe("Click or tap on an element");
 var inputActionSchema = z.object({
   type: z.literal("input"),
   target: LocatorSchema,
-  value: z.string()
-});
+  value: z.string().describe("Text to input (can reference variables with ${VAR_NAME})")
+}).describe("Input text into a field");
 var assertActionSchema = z.object({
   type: z.literal("assert"),
   target: LocatorSchema,
-  value: z.string().optional()
-});
+  value: z.string().optional().describe("Expected text content")
+}).describe("Assert that an element exists or contains expected text");
 var waitActionSchema = z.object({
   type: z.literal("wait"),
-  target: LocatorSchema.optional(),
-  timeout: z.number().int().positive().optional()
-}).refine((action) => action.target || action.timeout, {
+  target: LocatorSchema.optional().describe("Element to wait for"),
+  timeout: z.number().int().positive().optional().describe("Time to wait in milliseconds")
+}).describe("Wait for an element or timeout").refine((action) => action.target || action.timeout, {
   message: "wait requires a target or timeout"
 });
 var scrollActionSchema = z.object({
   type: z.literal("scroll"),
-  target: LocatorSchema.optional(),
-  direction: z.enum(["up", "down"]).optional(),
-  amount: z.number().int().positive().optional()
-});
+  target: LocatorSchema.optional().describe("Element to scroll"),
+  direction: z.enum(["up", "down"]).optional().describe("Direction to scroll"),
+  amount: z.number().int().positive().optional().describe("Amount to scroll in pixels")
+}).describe("Scroll the page or an element");
 var screenshotActionSchema = z.object({
   type: z.literal("screenshot"),
-  name: z.string().optional()
-});
+  name: z.string().optional().describe("Name for the screenshot file")
+}).describe("Take a screenshot");
 var setVarActionSchema = z.object({
   type: z.literal("setVar"),
-  name: nonEmptyString,
-  value: z.string().optional(),
-  from: z.enum(["response", "element", "email"]).optional(),
-  path: z.string().optional(),
-  pattern: z.string().optional()
-});
+  name: nonEmptyString.describe("Variable name to set"),
+  value: z.string().optional().describe("Static value to set"),
+  from: z.enum(["response", "element", "email"]).optional().describe("Extract value from a source"),
+  path: z.string().optional().describe("JSON path or selector for extraction"),
+  pattern: z.string().optional().describe("Regular expression pattern for extraction")
+}).describe("Set a variable for use in later steps");
 var emailWaitForActionSchema = z.object({
   type: z.literal("email.waitFor"),
-  mailbox: nonEmptyString,
-  timeout: z.number().int().positive().optional(),
-  subjectContains: z.string().optional()
-});
+  mailbox: nonEmptyString.describe("Email address or mailbox to check"),
+  timeout: z.number().int().positive().optional().describe("How long to wait for email in milliseconds"),
+  subjectContains: z.string().optional().describe("Filter by email subject")
+}).describe("Wait for an email to arrive");
 var emailExtractCodeActionSchema = z.object({
   type: z.literal("email.extractCode"),
-  saveTo: nonEmptyString,
-  pattern: z.string().optional()
-});
+  saveTo: nonEmptyString.describe("Variable name to save the extracted code"),
+  pattern: z.string().optional().describe("Regular expression to extract code")
+}).describe("Extract a verification code from email");
 var emailExtractLinkActionSchema = z.object({
   type: z.literal("email.extractLink"),
-  saveTo: nonEmptyString,
-  pattern: z.string().optional()
-});
+  saveTo: nonEmptyString.describe("Variable name to save the extracted link"),
+  pattern: z.string().optional().describe("Regular expression to match specific links")
+}).describe("Extract a link from email");
 var emailClearActionSchema = z.object({
   type: z.literal("email.clear"),
-  mailbox: nonEmptyString
-});
+  mailbox: nonEmptyString.describe("Email address or mailbox to clear")
+}).describe("Clear emails from a mailbox");
 var appwriteVerifyEmailActionSchema = z.object({
   type: z.literal("appwrite.verifyEmail")
-});
+}).describe("Verify email using Appwrite");
 var debugActionSchema = z.object({
   type: z.literal("debug")
-});
+}).describe("Pause execution and open Playwright Inspector for debugging");
 var ActionSchema = z.discriminatedUnion("type", [
   navigateActionSchema,
   tapActionSchema,
@@ -114,96 +114,92 @@ var ActionSchema = z.discriminatedUnion("type", [
   debugActionSchema
 ]);
 var defaultsSchema = z.object({
-  timeout: z.number().int().positive().optional(),
-  screenshots: z.enum(["on-failure", "always", "never"]).optional()
-});
+  timeout: z.number().int().positive().optional().describe("Default timeout in milliseconds for all actions"),
+  screenshots: z.enum(["on-failure", "always", "never"]).optional().describe("When to capture screenshots during test execution")
+}).describe("Default settings that apply to all tests unless overridden");
 var webConfigSchema = z.object({
-  baseUrl: nonEmptyString.url().optional(),
-  browser: z.string().trim().optional(),
-  headless: z.boolean().optional(),
-  timeout: z.number().int().positive().optional()
-});
+  baseUrl: nonEmptyString.url().optional().describe("Base URL for the web application"),
+  browser: z.string().trim().optional().describe("Browser to use for testing"),
+  headless: z.boolean().optional().describe("Run browser in headless mode"),
+  timeout: z.number().int().positive().optional().describe("Timeout in milliseconds for web actions")
+}).describe("Web platform configuration");
 var androidConfigSchema = z.object({
-  appId: z.string().trim().optional(),
-  device: z.string().trim().optional()
-});
+  appId: z.string().trim().optional().describe("Android application ID"),
+  device: z.string().trim().optional().describe("Device name or ID to run tests on")
+}).describe("Android platform configuration");
 var iosConfigSchema = z.object({
-  bundleId: z.string().trim().optional(),
-  simulator: z.string().trim().optional()
-});
+  bundleId: z.string().trim().optional().describe("iOS bundle identifier"),
+  simulator: z.string().trim().optional().describe("Simulator name to run tests on")
+}).describe("iOS platform configuration");
 var emailConfigSchema = z.object({
-  provider: z.literal("inbucket"),
-  endpoint: nonEmptyString.url().optional()
-});
+  provider: z.literal("inbucket").describe("Email testing provider"),
+  endpoint: nonEmptyString.url().optional().describe("Email service endpoint URL")
+}).describe("Email testing configuration");
 var appwriteConfigSchema = z.object({
-  endpoint: nonEmptyString.url(),
-  projectId: nonEmptyString,
-  apiKey: nonEmptyString,
-  cleanup: z.boolean().optional(),
-  cleanupOnFailure: z.boolean().optional()
-});
+  endpoint: nonEmptyString.url().describe("Appwrite API endpoint"),
+  projectId: nonEmptyString.describe("Appwrite project ID"),
+  apiKey: nonEmptyString.describe("Appwrite API key with appropriate permissions"),
+  cleanup: z.boolean().optional().describe("Enable automatic cleanup of created resources"),
+  cleanupOnFailure: z.boolean().optional().describe("Clean up resources even when test fails")
+}).describe("Appwrite backend configuration");
 var healingSchema = z.object({
-  enabled: z.boolean().optional(),
-  strategies: z.array(z.string().trim()).optional()
-});
+  enabled: z.boolean().optional().describe("Enable self-healing capabilities"),
+  strategies: z.array(z.string().trim()).optional().describe("Healing strategies to use")
+}).describe("Self-healing test configuration");
 var webServerSchema = z.object({
-  // Option 1: Explicit command
-  command: nonEmptyString.optional(),
-  // Option 2: Auto-detect
-  auto: z.boolean().optional(),
-  // Option 3: Static directory
-  static: z.string().optional(),
-  // Required
-  url: nonEmptyString.url(),
-  port: z.number().int().positive().optional(),
-  reuseExistingServer: z.boolean().default(true),
-  timeout: z.number().int().positive().default(3e4),
-  cwd: z.string().optional()
-}).refine((config) => config.command || config.auto || config.static, {
+  command: nonEmptyString.optional().describe("Command to start the web server"),
+  auto: z.boolean().optional().describe("Automatically detect and run the dev server from package.json"),
+  static: z.string().optional().describe("Serve a static directory instead of running a command"),
+  url: nonEmptyString.url().describe("URL to wait for before starting tests"),
+  port: z.number().int().positive().optional().describe("Port number for the web server"),
+  reuseExistingServer: z.boolean().default(true).describe("Use existing server if already running at the specified URL"),
+  timeout: z.number().int().positive().default(3e4).describe("Timeout in milliseconds to wait for server to become available"),
+  cwd: z.string().optional().describe("Working directory for the server command")
+}).describe("Configuration for starting a web server before running tests").refine((config) => config.command || config.auto || config.static, {
   message: "WebServerConfig requires command, auto: true, or static directory"
 });
 var aiSourceSchema = z.object({
-  pagesDir: z.string().optional(),
-  componentsDir: z.string().optional(),
-  extensions: z.array(z.string()).default([".vue", ".astro", ".tsx", ".jsx", ".svelte"])
-}).optional();
+  pagesDir: z.string().optional().describe("Directory containing page components"),
+  componentsDir: z.string().optional().describe("Directory containing reusable components"),
+  extensions: z.array(z.string()).default([".vue", ".astro", ".tsx", ".jsx", ".svelte"]).describe("File extensions to include in source code analysis")
+}).optional().describe("Source code directories for AI to analyze when generating tests");
 var aiConfigSchema = z.object({
-  provider: z.enum(["anthropic", "openai", "ollama"]),
-  model: nonEmptyString,
-  apiKey: z.string().trim().optional(),
-  baseUrl: z.string().trim().url().optional(),
-  temperature: z.number().min(0).max(2).default(0.2),
-  maxTokens: z.number().int().positive().default(4096),
+  provider: z.enum(["anthropic", "openai", "ollama"]).describe("AI provider to use for test generation"),
+  model: nonEmptyString.describe("Model name to use"),
+  apiKey: z.string().trim().optional().describe("API key for the AI provider"),
+  baseUrl: z.string().trim().url().optional().describe("Base URL for the AI API (required for Ollama)"),
+  temperature: z.number().min(0).max(2).default(0.2).describe("Temperature for AI generation (0 = deterministic, 2 = very creative)"),
+  maxTokens: z.number().int().positive().default(4096).describe("Maximum tokens for AI responses"),
   source: aiSourceSchema
-});
+}).describe("AI configuration for test generation and healing");
 var cleanupDiscoverSchema = z.object({
-  enabled: z.boolean().default(true),
-  paths: z.array(z.string()).default(["./tests/cleanup"]),
-  pattern: z.string().default("**/*.ts")
-}).optional();
+  enabled: z.boolean().default(true).describe("Enable auto-discovery of cleanup handlers in specified paths"),
+  paths: z.array(z.string()).default(["./tests/cleanup"]).describe("Directories to search for cleanup handler files"),
+  pattern: z.string().default("**/*.ts").describe("Glob pattern to match handler files")
+}).optional().describe("Auto-discovery configuration for cleanup handlers");
 var cleanupConfigSchema = z.object({
-  provider: z.string().optional(),
-  parallel: z.boolean().default(false),
-  retries: z.number().min(1).max(10).default(3),
-  types: z.record(z.string(), z.string()).optional(),
-  handlers: z.array(z.string()).optional(),
+  provider: z.string().optional().describe("Primary cleanup provider to use"),
+  parallel: z.boolean().default(false).describe("Execute cleanup operations in parallel"),
+  retries: z.number().min(1).max(10).default(3).describe("Number of retry attempts for failed cleanup operations"),
+  types: z.record(z.string(), z.string()).optional().describe("Map resource types to cleanup handler methods"),
+  handlers: z.array(z.string()).optional().describe("Explicit paths to custom cleanup handler files"),
   discover: cleanupDiscoverSchema
-}).passthrough();
+}).passthrough().describe("Comprehensive resource cleanup configuration");
 var platformsSchema = z.object({
   web: webConfigSchema.optional(),
   android: androidConfigSchema.optional(),
   ios: iosConfigSchema.optional()
-});
+}).describe("Platform-specific configurations");
 var previewConfigSchema = z.object({
   build: z.object({
-    command: z.string().optional()
-  }).optional(),
+    command: z.string().optional().describe("Command to build the project")
+  }).optional().describe("Build configuration"),
   preview: z.object({
-    command: z.string().optional()
-  }).optional(),
-  url: z.string().url().optional(),
-  timeout: z.number().int().positive().optional()
-});
+    command: z.string().optional().describe("Command to start the preview server after build")
+  }).optional().describe("Preview server configuration"),
+  url: z.string().url().optional().describe("URL to wait for before starting tests"),
+  timeout: z.number().int().positive().optional().describe("Timeout in milliseconds to wait for preview server")
+}).describe("Configuration for the --preview flag (build and serve production build)");
 var TestConfigSchema = z.object({
   defaults: defaultsSchema.optional(),
   web: webConfigSchema.optional(),
@@ -211,14 +207,14 @@ var TestConfigSchema = z.object({
   ios: iosConfigSchema.optional(),
   email: emailConfigSchema.optional(),
   appwrite: appwriteConfigSchema.optional()
-});
+}).describe("Test-specific configuration that overrides global settings");
 var TestDefinitionSchema = z.object({
-  name: nonEmptyString,
-  platform: z.enum(["web", "android", "ios"]),
-  variables: z.record(z.string(), z.string()).optional(),
+  name: nonEmptyString.describe("The name of the test"),
+  platform: z.enum(["web", "android", "ios"]).describe("The platform to run the test on"),
+  variables: z.record(z.string(), z.string()).optional().describe("Variables that can be referenced in test steps using ${VARIABLE_NAME} syntax"),
   config: TestConfigSchema.optional(),
-  steps: z.array(ActionSchema).min(1)
-});
+  steps: z.array(ActionSchema).min(1).describe("The sequence of actions to execute in this test")
+}).describe("Schema for IntelliTester test definition files");
 var IntellitesterConfigSchema = z.object({
   defaults: defaultsSchema.optional(),
   ai: aiConfigSchema.optional(),
@@ -229,119 +225,114 @@ var IntellitesterConfigSchema = z.object({
   cleanup: cleanupConfigSchema.optional(),
   webServer: webServerSchema.optional(),
   preview: previewConfigSchema.optional(),
-  secrets: z.record(z.string(), z.string().trim()).optional()
-});
+  secrets: z.record(z.string(), z.string().trim()).optional().describe("Secret values that can be referenced in tests")
+}).describe("Global configuration file for IntelliTester");
 var nonEmptyString2 = z.string().trim().min(1, "Value cannot be empty");
 var testReferenceSchema = z.object({
-  file: nonEmptyString2,
-  id: nonEmptyString2.optional(),
-  // Optional ID for referencing in variables
-  variables: z.record(z.string(), z.string()).optional()
-  // Override/inject variables
-});
+  file: nonEmptyString2.describe("Path to the test file relative to the workflow file"),
+  id: nonEmptyString2.optional().describe("Optional ID for referencing this test in variables or dependencies"),
+  variables: z.record(z.string(), z.string()).optional().describe("Variables to inject or override for this specific test")
+}).describe("Reference to a test file");
 var workflowWebConfigSchema = z.object({
-  baseUrl: nonEmptyString2.url().optional(),
-  browser: z.enum(["chromium", "firefox", "webkit"]).optional(),
-  headless: z.boolean().optional()
-});
+  baseUrl: nonEmptyString2.url().optional().describe("Base URL for all tests in this workflow"),
+  browser: z.enum(["chromium", "firefox", "webkit"]).optional().describe("Browser to use for all web tests"),
+  headless: z.boolean().optional().describe("Run browser in headless mode")
+}).describe("Web platform configuration for the workflow");
 var workflowAppwriteConfigSchema = z.object({
-  endpoint: nonEmptyString2.url(),
-  projectId: nonEmptyString2,
-  apiKey: nonEmptyString2,
-  cleanup: z.boolean().default(true),
-  // Backwards compatibility
-  cleanupOnFailure: z.boolean().default(true)
-  // Backwards compatibility
-});
+  endpoint: nonEmptyString2.url().describe("Appwrite API endpoint"),
+  projectId: nonEmptyString2.describe("Appwrite project ID"),
+  apiKey: nonEmptyString2.describe("Appwrite API key"),
+  cleanup: z.boolean().default(true).describe("Enable automatic cleanup of created resources"),
+  cleanupOnFailure: z.boolean().default(true).describe("Clean up resources even when tests fail")
+}).describe("Appwrite backend configuration for the workflow");
 var workflowCleanupDiscoverSchema = z.object({
-  enabled: z.boolean().default(true),
-  paths: z.array(z.string()).default(["./tests/cleanup"]),
-  pattern: z.string().default("**/*.ts")
-}).optional();
+  enabled: z.boolean().default(true).describe("Enable auto-discovery of cleanup handlers"),
+  paths: z.array(z.string()).default(["./tests/cleanup"]).describe("Directories to search for cleanup handlers"),
+  pattern: z.string().default("**/*.ts").describe("Glob pattern for handler files")
+}).optional().describe("Auto-discovery configuration for cleanup handlers");
 var workflowCleanupConfigSchema = z.object({
-  provider: z.string().optional(),
-  parallel: z.boolean().default(false),
-  retries: z.number().min(1).max(10).default(3),
-  types: z.record(z.string(), z.string()).optional(),
-  handlers: z.array(z.string()).optional(),
+  provider: z.string().optional().describe("Cleanup provider to use"),
+  parallel: z.boolean().default(false).describe("Run cleanup tasks in parallel"),
+  retries: z.number().min(1).max(10).default(3).describe("Number of retry attempts for failed cleanup operations"),
+  types: z.record(z.string(), z.string()).optional().describe("Map resource types to cleanup handler methods"),
+  handlers: z.array(z.string()).optional().describe("Explicit paths to custom cleanup handler files"),
   discover: workflowCleanupDiscoverSchema
-}).passthrough();
+}).passthrough().describe("Resource cleanup configuration");
 var workflowWebServerSchema = z.object({
-  command: nonEmptyString2.optional(),
-  auto: z.boolean().optional(),
-  url: nonEmptyString2.url(),
-  reuseExistingServer: z.boolean().default(true),
-  timeout: z.number().int().positive().default(3e4)
-});
+  command: nonEmptyString2.optional().describe("Command to start the web server"),
+  auto: z.boolean().optional().describe("Auto-detect server start command from package.json"),
+  url: nonEmptyString2.url().describe("URL to wait for before starting tests"),
+  reuseExistingServer: z.boolean().default(true).describe("Use existing server if already running at the URL"),
+  timeout: z.number().int().positive().default(3e4).describe("Timeout in milliseconds to wait for server to start")
+}).describe("Configuration for starting a web server before tests");
 var workflowConfigSchema = z.object({
   web: workflowWebConfigSchema.optional(),
   appwrite: workflowAppwriteConfigSchema.optional(),
   cleanup: workflowCleanupConfigSchema.optional(),
   webServer: workflowWebServerSchema.optional()
-});
+}).describe("Workflow-level configuration that applies to all tests");
 var WorkflowDefinitionSchema = z.object({
-  name: nonEmptyString2,
-  platform: z.enum(["web", "android", "ios"]).default("web"),
+  name: nonEmptyString2.describe("The name of the workflow"),
+  platform: z.enum(["web", "android", "ios"]).default("web").describe("The platform to run the workflow on"),
   config: workflowConfigSchema.optional(),
-  continueOnFailure: z.boolean().default(false),
-  tests: z.array(testReferenceSchema).min(1, "Workflow must contain at least one test")
-});
+  continueOnFailure: z.boolean().default(false).describe("Continue running subsequent tests even if a test fails"),
+  tests: z.array(testReferenceSchema).min(1, "Workflow must contain at least one test").describe("List of test files to execute in this workflow")
+}).describe("Schema for IntelliTester workflow files that orchestrate multiple tests");
 var nonEmptyString3 = z.string().trim().min(1, "Value cannot be empty");
 var workflowReferenceSchema = z.object({
-  file: nonEmptyString3,
-  id: nonEmptyString3.optional(),
-  depends_on: z.array(nonEmptyString3).optional(),
-  on_failure: z.enum(["skip", "fail", "ignore"]).optional(),
-  variables: z.record(z.string(), z.string()).optional()
-});
+  file: nonEmptyString3.describe("Path to the workflow file"),
+  id: nonEmptyString3.optional().describe("Optional ID for referencing this workflow in dependencies"),
+  depends_on: z.array(nonEmptyString3).optional().describe("IDs of workflows that must complete before this one"),
+  on_failure: z.enum(["skip", "fail", "ignore"]).optional().describe("How to handle failure of this workflow"),
+  variables: z.record(z.string(), z.string()).optional().describe("Variables to inject or override for this workflow")
+}).describe("Reference to a workflow file");
 var pipelineWebConfigSchema = z.object({
-  baseUrl: nonEmptyString3.url().optional(),
-  browser: z.enum(["chromium", "firefox", "webkit"]).optional(),
-  headless: z.boolean().optional()
-});
+  baseUrl: nonEmptyString3.url().optional().describe("Base URL for all workflows in this pipeline"),
+  browser: z.enum(["chromium", "firefox", "webkit"]).optional().describe("Browser to use for all web tests"),
+  headless: z.boolean().optional().describe("Run browser in headless mode")
+}).describe("Web platform configuration for the pipeline");
 var pipelineAppwriteConfigSchema = z.object({
-  endpoint: nonEmptyString3.url(),
-  projectId: nonEmptyString3,
-  apiKey: nonEmptyString3,
-  cleanup: z.boolean().default(true),
-  cleanupOnFailure: z.boolean().default(true)
-});
+  endpoint: nonEmptyString3.url().describe("Appwrite API endpoint"),
+  projectId: nonEmptyString3.describe("Appwrite project ID"),
+  apiKey: nonEmptyString3.describe("Appwrite API key"),
+  cleanup: z.boolean().default(true).describe("Enable automatic cleanup of created resources"),
+  cleanupOnFailure: z.boolean().default(true).describe("Clean up resources even when workflows fail")
+}).describe("Appwrite backend configuration for the pipeline");
 var pipelineCleanupDiscoverSchema = z.object({
-  enabled: z.boolean().default(true),
-  paths: z.array(z.string()).default(["./tests/cleanup"]),
-  pattern: z.string().default("**/*.ts")
-}).optional();
+  enabled: z.boolean().default(true).describe("Enable auto-discovery of cleanup handlers"),
+  paths: z.array(z.string()).default(["./tests/cleanup"]).describe("Directories to search for cleanup handlers"),
+  pattern: z.string().default("**/*.ts").describe("Glob pattern for handler files")
+}).optional().describe("Auto-discovery configuration for cleanup handlers");
 var pipelineCleanupConfigSchema = z.object({
-  provider: z.string().optional(),
-  parallel: z.boolean().default(false),
-  retries: z.number().min(1).max(10).default(3),
-  types: z.record(z.string(), z.string()).optional(),
-  handlers: z.array(z.string()).optional(),
+  provider: z.string().optional().describe("Cleanup provider to use"),
+  parallel: z.boolean().default(false).describe("Run cleanup tasks in parallel"),
+  retries: z.number().min(1).max(10).default(3).describe("Number of retry attempts for failed cleanup operations"),
+  types: z.record(z.string(), z.string()).optional().describe("Map resource types to cleanup handler methods"),
+  handlers: z.array(z.string()).optional().describe("Explicit paths to custom cleanup handler files"),
   discover: pipelineCleanupDiscoverSchema,
-  on_failure: z.boolean().default(true)
-  // Run cleanup even if pipeline fails
-}).passthrough();
+  on_failure: z.boolean().default(true).describe("Run cleanup even if pipeline fails")
+}).passthrough().describe("Resource cleanup configuration");
 var pipelineWebServerSchema = z.object({
-  command: nonEmptyString3.optional(),
-  auto: z.boolean().optional(),
-  url: nonEmptyString3.url(),
-  reuseExistingServer: z.boolean().default(true),
-  timeout: z.number().int().positive().default(3e4)
-});
+  command: nonEmptyString3.optional().describe("Command to start the web server"),
+  auto: z.boolean().optional().describe("Auto-detect server start command from package.json"),
+  url: nonEmptyString3.url().describe("URL to wait for before starting workflows"),
+  reuseExistingServer: z.boolean().default(true).describe("Use existing server if already running at the URL"),
+  timeout: z.number().int().positive().default(3e4).describe("Timeout in milliseconds to wait for server to start")
+}).describe("Configuration for starting a web server before workflows");
 var pipelineConfigSchema = z.object({
   web: pipelineWebConfigSchema.optional(),
   appwrite: pipelineAppwriteConfigSchema.optional(),
   cleanup: pipelineCleanupConfigSchema.optional(),
   webServer: pipelineWebServerSchema.optional()
-});
+}).describe("Pipeline-level configuration that applies to all workflows");
 var PipelineDefinitionSchema = z.object({
-  name: nonEmptyString3,
-  platform: z.enum(["web", "android", "ios"]).default("web"),
+  name: nonEmptyString3.describe("The name of the pipeline"),
+  platform: z.enum(["web", "android", "ios"]).default("web").describe("The platform to run the pipeline on"),
   config: pipelineConfigSchema.optional(),
-  on_failure: z.enum(["skip", "fail", "ignore"]).default("skip"),
-  cleanup_on_failure: z.boolean().default(true),
-  workflows: z.array(workflowReferenceSchema).min(1, "Pipeline must contain at least one workflow")
-});
+  on_failure: z.enum(["skip", "fail", "ignore"]).default("skip").describe("Default failure handling for workflows"),
+  cleanup_on_failure: z.boolean().default(true).describe("Run cleanup even when pipeline fails"),
+  workflows: z.array(workflowReferenceSchema).min(1, "Pipeline must contain at least one workflow").describe("List of workflow files to execute in this pipeline")
+}).describe("Schema for IntelliTester pipeline files that orchestrate multiple workflows");
 
 // src/core/loader.ts
 var formatIssues = (issues) => issues.map((issue) => {
@@ -1798,7 +1789,7 @@ function interpolateWorkflowVariables(value, currentVariables, testResults) {
     return currentVariables.get(path3) ?? match;
   });
 }
-async function runTestInWorkflow(test, page, context, options, _workflowDir) {
+async function runTestInWorkflow(test, page, context, options, _workflowDir, workflowBaseUrl) {
   const results = [];
   const debugMode = options.debug ?? false;
   const screenshotDir = defaultScreenshotDir2;
@@ -1841,7 +1832,8 @@ async function runTestInWorkflow(test, page, context, options, _workflowDir) {
         switch (action.type) {
           case "navigate": {
             const interpolated = interpolateVariables2(action.value);
-            const target = resolveUrl2(interpolated, test.config?.web?.baseUrl);
+            const baseUrl = test.config?.web?.baseUrl ?? workflowBaseUrl;
+            const target = resolveUrl2(interpolated, baseUrl);
             if (debugMode) console.log(`  [DEBUG] Navigating to: ${target}`);
             await page.goto(target);
             break;
@@ -2238,7 +2230,7 @@ Starting workflow: ${workflow.name}`);
           executionContext.variables.set(key, interpolated);
         }
       }
-      const result = await runTestInWorkflow(test, page, executionContext, options, workflowDir);
+      const result = await runTestInWorkflow(test, page, executionContext, options, workflowDir, workflow.config?.web?.baseUrl);
       const testResult = {
         id: testRef.id,
         file: testRef.file,
@@ -2540,5 +2532,5 @@ Collected ${serverResources.length} server-tracked resources`);
 }
 
 export { ActionSchema, IntellitesterConfigSchema, LocatorSchema, TestConfigSchema, TestDefinitionSchema, cleanupConfigSchema, cleanupDiscoverSchema, collectMissingEnvVars, createAIProvider, createTestContext, isPipelineContent, isPipelineFile, isWorkflowContent, isWorkflowFile, killServer, loadIntellitesterConfig, loadPipelineDefinition, loadTestDefinition, loadWorkflowDefinition, parseIntellitesterConfig, parsePipelineDefinition, parseTestDefinition, parseWorkflowDefinition, previewConfigSchema, runWebTest, runWorkflow, runWorkflowWithContext, setupAppwriteTracking, startTrackingServer, startWebServer };
-//# sourceMappingURL=chunk-VOGZ7IFW.js.map
-//# sourceMappingURL=chunk-VOGZ7IFW.js.map
+//# sourceMappingURL=chunk-BYSKHSJB.js.map
+//# sourceMappingURL=chunk-BYSKHSJB.js.map