@runcofactor/cli 0.10.0

package/dist/chunk-SJJW77WN.js

@@ -0,0 +1,605 @@
+import { createRequire as __cr } from "module"; const require = __cr(import.meta.url);
+
+// ../types/src/workflows.ts
+var USER_SETTABLE_WORKFLOW_STATUSES = [
+  "draft",
+  "published"
+];
+
+// ../types/src/sandbox-instance-size.ts
+var INSTANCE_SIZES = ["small", "medium", "large", "xlarge", "2xlarge"];
+var INSTANCE_SIZE_SPEC = {
+  small: {
+    ec2InstanceType: "t3.small",
+    vcpu: 2,
+    memoryMiB: 2048,
+    // 2 GiB instance — agent capped at min(2048, 0.4 × 2048) = 819
+    agentCapMiB: 819,
+    appSoftCapMiB: 1024,
+    proxyCapMiB: 256,
+    emulationCapMiB: 128,
+    storageCapMiB: 256,
+    appCpus: "1.0"
+  },
+  medium: {
+    ec2InstanceType: "t3.medium",
+    vcpu: 2,
+    memoryMiB: 4096,
+    agentCapMiB: 1536,
+    appSoftCapMiB: 1536,
+    proxyCapMiB: 256,
+    emulationCapMiB: 128,
+    storageCapMiB: 256,
+    appCpus: "1.0"
+  },
+  large: {
+    ec2InstanceType: "t3.large",
+    vcpu: 2,
+    memoryMiB: 8192,
+    agentCapMiB: 2048,
+    appSoftCapMiB: 5120,
+    proxyCapMiB: 256,
+    emulationCapMiB: 128,
+    storageCapMiB: 512,
+    // t3.large is memory-only — same 2 vCPU as medium.
+    appCpus: "1.0"
+  },
+  xlarge: {
+    ec2InstanceType: "t3.xlarge",
+    vcpu: 4,
+    memoryMiB: 16384,
+    agentCapMiB: 2048,
+    appSoftCapMiB: 12288,
+    proxyCapMiB: 256,
+    emulationCapMiB: 256,
+    storageCapMiB: 512,
+    appCpus: "2.5"
+  },
+  "2xlarge": {
+    ec2InstanceType: "t3.2xlarge",
+    vcpu: 8,
+    memoryMiB: 32768,
+    agentCapMiB: 2048,
+    appSoftCapMiB: 28672,
+    proxyCapMiB: 512,
+    emulationCapMiB: 512,
+    storageCapMiB: 1024,
+    appCpus: "6.5"
+  }
+};
+var INSTANCE_SIZE_SET = new Set(INSTANCE_SIZES);
+function parseInstanceSize(s) {
+  return s && INSTANCE_SIZE_SET.has(s) ? s : null;
+}
+
+// ../types/src/node-type-labels.ts
+var NODE_TYPE_LABEL = {
+  login: "Acting As",
+  navigate: "Navigate",
+  action: "Action",
+  assertion: "Assertion",
+  condition: "Condition",
+  wait: "Wait",
+  api_sequence: "API Sequence",
+  seed: "Seed Data",
+  setup: "Setup Flow",
+  notification: "Notification",
+  audio: "Audio input",
+  "audio-assertion": "Audio assertion",
+  end: "End"
+};
+function normalizeNodeType(input) {
+  if (input === "acting-as" || input === "acting_as") return "login";
+  return input;
+}
+
+// ../types/src/index.ts
+import { z as z5 } from "zod";
+
+// ../types/src/credentials.ts
+import { z } from "zod";
+var tokenRefreshPolicySchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("firebase"),
+    refreshTokenPath: z.string().default("$.value.stsTokenManager.refreshToken"),
+    expirationPath: z.string().default("$.value.stsTokenManager.expirationTime"),
+    accessTokenPath: z.string().default("$.value.stsTokenManager.accessToken"),
+    apiKeyPath: z.string().default("$.value.apiKey")
+  })
+]);
+var localStorageSourceSchema = z.object({
+  kind: z.literal("localStorage"),
+  origin: z.string().min(1),
+  key: z.string().min(1),
+  jsonPath: z.string().optional()
+});
+var indexedDBSourceSchema = z.object({
+  kind: z.literal("indexedDB"),
+  database: z.string().min(1),
+  store: z.string().min(1),
+  key: z.string().min(1),
+  jsonPath: z.string().min(1)
+});
+var cookieSourceSchema = z.object({
+  kind: z.literal("cookie"),
+  domain: z.string().min(1),
+  name: z.string().min(1)
+});
+var headerExtractorSourceSchema = z.discriminatedUnion("kind", [
+  localStorageSourceSchema,
+  indexedDBSourceSchema,
+  cookieSourceSchema
+]);
+var headerExtractorSchema = z.object({
+  name: z.string().min(1),
+  header: z.string().min(1).optional(),
+  prefix: z.string().optional(),
+  source: headerExtractorSourceSchema,
+  refresh: tokenRefreshPolicySchema.optional()
+});
+var credentialMetadataSchema = z.object({
+  headerName: z.string().optional(),
+  tokenHeaderName: z.string().optional(),
+  tokenHeaderPrefix: z.string().optional(),
+  headerExtractors: z.array(headerExtractorSchema).optional()
+}).passthrough();
+
+// ../types/src/issues.ts
+import { z as z2 } from "zod";
+var clamp = (value, max) => value.length > max ? value.slice(0, max) : value;
+var requiredLimitedString = (label, max) => z2.string().transform((value) => value.trim()).pipe(z2.string().min(1, `${label} is required`)).transform((value) => clamp(value, max));
+var optionalLimitedString = (max) => z2.string().optional().nullable().transform((value) => {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  return clamp(trimmed, max);
+});
+var ISO_DATETIME = z2.string().datetime({ offset: true });
+var UUID = z2.string().uuid();
+var IssueSeveritySchema = z2.enum(["low", "medium", "high", "unknown"]);
+var IssueStatusSchema = z2.enum(["open", "closed", "not_a_bug"]);
+var IssueSourceKindSchema = z2.enum([
+  "crawler_analysis",
+  "exploratory_attempt",
+  "qa_page_test",
+  "workflow_test",
+  "chaos_test",
+  "adhoc_test"
+]);
+var TITLE_LIMIT = 512;
+var TLDR_LIMIT = 512;
+var URL_LIMIT = 2048;
+var STORAGE_KEY_LIMIT = 1024;
+var DIAGNOSTIC_LIMIT = 4e3;
+var NarrationTranscriptSegmentSchema = z2.object({
+  startMs: z2.number().int().min(0),
+  endMs: z2.number().int().min(1),
+  text: z2.string().min(1)
+});
+var RecordIssueOccurrencePayloadSchema = z2.object({
+  orgId: UUID,
+  propertyId: UUID,
+  canonicalPageId: UUID.optional().nullable().transform((value) => value ?? null),
+  credentialId: UUID.optional().nullable().transform((value) => value ?? null),
+  issueTitle: requiredLimitedString("Issue title", TITLE_LIMIT),
+  issueSeverity: IssueSeveritySchema,
+  issueCategoryId: UUID.optional().nullable().transform((value) => value ?? null),
+  issueCategoryKey: z2.string().min(1).max(64).optional().nullable().transform((value) => {
+    if (typeof value !== "string") return null;
+    const trimmed = value.trim();
+    return trimmed.length ? trimmed : null;
+  }),
+  issueConfidence: z2.number().int().min(0).max(100).optional().nullable().transform((value) => {
+    if (value === null || value === void 0) return null;
+    return value;
+  }),
+  detectedAt: ISO_DATETIME,
+  sourceKind: IssueSourceKindSchema,
+  sourceId: requiredLimitedString("Source identifier", STORAGE_KEY_LIMIT),
+  primaryUrl: requiredLimitedString("Primary URL", URL_LIMIT),
+  summary: requiredLimitedString("Summary", DIAGNOSTIC_LIMIT),
+  tldr: requiredLimitedString("TLDR", TLDR_LIMIT),
+  screenshotStorageKey: requiredLimitedString("Screenshot storage key", STORAGE_KEY_LIMIT),
+  screenshotCaption: optionalLimitedString(DIAGNOSTIC_LIMIT),
+  traceStorageKey: optionalLimitedString(STORAGE_KEY_LIMIT),
+  videoStorageKey: optionalLimitedString(STORAGE_KEY_LIMIT),
+  /** Action timeline for video overlay synchronization */
+  videoTimelineJson: z2.unknown().optional().nullable(),
+  /** Timed narration transcript for video overlay */
+  narrationTranscriptJson: z2.array(NarrationTranscriptSegmentSchema).optional().nullable(),
+  consoleLogExcerpt: optionalLimitedString(DIAGNOSTIC_LIMIT),
+  networkFailureUrl: optionalLimitedString(URL_LIMIT),
+  networkFailureStatus: z2.number().int().optional().nullable().transform((value) => value ?? null),
+  /** Structured network requests captured from Playwright trace */
+  networkRequestsJson: z2.array(z2.unknown()).optional().nullable(),
+  /** Structured console logs captured from Playwright trace */
+  consoleLogsJson: z2.array(z2.unknown()).optional().nullable(),
+  ticketReproSteps: optionalLimitedString(DIAGNOSTIC_LIMIT),
+  ticketUserFacingSummary: requiredLimitedString("Ticket summary", DIAGNOSTIC_LIMIT),
+  ticketDiagnosticsAnalysis: requiredLimitedString("Ticket diagnostics analysis", DIAGNOSTIC_LIMIT)
+});
+
+// ../types/src/local-browser.ts
+var SESSION_EXPIRATION_MS = 60 * 60 * 1e3;
+
+// ../types/src/benchmark.ts
+import { z as z3 } from "zod";
+var benchmarkWorkflowSuiteConfigSchema = z3.object({
+  runsPerWorkflow: z3.number().int().min(1).max(20).optional(),
+  runTimeoutMinutes: z3.number().int().min(1).max(720).optional(),
+  suiteTimeoutHours: z3.number().int().min(1).max(24).optional(),
+  sendSlackSummary: z3.boolean().optional()
+});
+
+// ../types/src/sandbox-tasks.ts
+var CHECKLIST_ITEMS = [
+  {
+    id: "provisioned",
+    label: "Provisioned",
+    description: "Sandbox instance has been provisioned",
+    dependsOn: [],
+    producesArtifacts: [],
+    agentAutomatable: false
+  },
+  {
+    id: "code-cloned",
+    label: "Code Cloned",
+    description: "Repository has been cloned into the sandbox",
+    dependsOn: ["provisioned"],
+    producesArtifacts: [],
+    agentAutomatable: false
+  },
+  {
+    id: "environment-analyzed",
+    label: "Environment Analyzed",
+    description: "Repository analyzed for runtime, services, and dependencies",
+    dependsOn: ["code-cloned"],
+    producesArtifacts: ["environment-config"],
+    agentAutomatable: true,
+    promptTemplate: "env-checklist-analyze-environment"
+  },
+  {
+    id: "setup-script-created",
+    label: "Setup Script Created",
+    description: "Environment setup script for installing dependencies and build prerequisites",
+    dependsOn: ["environment-analyzed"],
+    producesArtifacts: ["setup-script"],
+    agentAutomatable: true,
+    promptTemplate: "env-checklist-create-setup-script"
+  },
+  {
+    id: "unit-tests-runnable",
+    label: "Unit Tests Runnable",
+    description: "Unit test suite can be executed successfully",
+    dependsOn: ["setup-script-created"],
+    producesArtifacts: [],
+    agentAutomatable: true,
+    promptTemplate: "env-checklist-verify-unit-tests"
+  },
+  {
+    id: "dockerfile-created",
+    label: "Dockerfile Created",
+    description: "Dockerfile generated from environment analysis",
+    dependsOn: ["environment-analyzed"],
+    producesArtifacts: ["dockerfile"],
+    agentAutomatable: true,
+    promptTemplate: "env-checklist-create-dockerfile"
+  },
+  {
+    id: "docker-compose-created",
+    label: "Docker Compose Created",
+    description: "Docker Compose file with application and service containers",
+    dependsOn: ["dockerfile-created"],
+    producesArtifacts: ["docker-compose"],
+    agentAutomatable: true,
+    promptTemplate: "env-checklist-create-docker-compose"
+  },
+  {
+    id: "integration-tests-runnable",
+    label: "Integration Tests Runnable",
+    description: "Integration tests can connect to services and run",
+    dependsOn: ["docker-compose-created"],
+    producesArtifacts: [],
+    agentAutomatable: true,
+    promptTemplate: "env-checklist-verify-integration-tests"
+  },
+  {
+    id: "seed-script-created",
+    label: "Seed Script Created",
+    description: "Database seed script for initial data population",
+    dependsOn: ["docker-compose-created"],
+    producesArtifacts: ["seed-script"],
+    agentAutomatable: true,
+    promptTemplate: "env-checklist-create-seed-script"
+  },
+  {
+    id: "server-running",
+    label: "Server Running",
+    description: "Application server started via startup script",
+    dependsOn: ["docker-compose-created"],
+    producesArtifacts: ["startup-script"],
+    agentAutomatable: true,
+    promptTemplate: "env-checklist-start-server"
+  },
+  {
+    id: "server-accessible",
+    label: "Server Accessible",
+    description: "Application server responds to health check requests",
+    dependsOn: ["server-running"],
+    producesArtifacts: [],
+    agentAutomatable: true,
+    promptTemplate: "env-checklist-verify-server"
+  },
+  {
+    id: "adhoc-test-ready",
+    label: "Ad Hoc Test Ready",
+    description: "Credential-producing sandbox action validated against a running instance for sandbox-backed ad hoc tests",
+    dependsOn: ["server-accessible"],
+    producesArtifacts: [],
+    agentAutomatable: true,
+    countsTowardVerification: false,
+    promptTemplate: "env-checklist-enable-adhoc-testing"
+  },
+  {
+    id: "template-verified",
+    label: "Template Verified",
+    description: "A fresh instance provisioned from this template comes up healthy",
+    dependsOn: ["server-accessible"],
+    producesArtifacts: [],
+    agentAutomatable: true,
+    promptTemplate: "env-checklist-verify-template"
+  }
+];
+var CHECKLIST_ITEM_MAP = Object.fromEntries(CHECKLIST_ITEMS.map((item) => [item.id, item]));
+var ALL_CHECKLIST_ITEM_IDS = CHECKLIST_ITEMS.map((item) => item.id);
+
+// ../types/src/macros.ts
+var MACRO_CATALOG = [
+  {
+    name: "UUID",
+    description: "Generate a random UUID v4",
+    args: [],
+    example: "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
+  },
+  {
+    name: "NOW",
+    description: "Current ISO 8601 timestamp",
+    args: [],
+    example: "2026-02-19T14:30:00.000Z"
+  },
+  {
+    name: "TODAY",
+    description: "Current date (YYYY-MM-DD)",
+    args: [],
+    example: "2026-02-19"
+  },
+  {
+    name: "DATE",
+    description: "Date offset from today by N days (negative for past, positive for future)",
+    args: [{ name: "days", type: "number", description: "Number of days offset (e.g. -7, +30)" }],
+    example: "2026-02-26"
+  },
+  {
+    name: "TIMESTAMP",
+    description: "Current Unix timestamp in milliseconds",
+    args: [],
+    example: "1771520400000"
+  },
+  {
+    name: "RANDOM_INT",
+    description: "Random integer in range (inclusive)",
+    args: [
+      { name: "min", type: "number", description: "Minimum value" },
+      { name: "max", type: "number", description: "Maximum value" }
+    ],
+    example: "42"
+  },
+  {
+    name: "RANDOM_STRING",
+    description: "Random alphanumeric string",
+    args: [{ name: "length", type: "number", description: "Character count" }],
+    example: "xK9mQ"
+  },
+  {
+    name: "EMAIL",
+    description: "Generate a unique test email address",
+    args: [],
+    example: "test-a1b2@example-test.com"
+  },
+  {
+    name: "FIRST_NAME",
+    description: "Random first name",
+    args: [],
+    example: "Jordan"
+  },
+  {
+    name: "LAST_NAME",
+    description: "Random last name",
+    args: [],
+    example: "Chen"
+  },
+  {
+    name: "PHONE",
+    description: "Random US phone number",
+    args: [],
+    example: "+1-555-382-7491"
+  },
+  {
+    name: "SEQUENCE",
+    description: "Auto-incrementing counter (resets per run)",
+    args: [{ name: "name", type: "string", description: "Counter name" }],
+    example: "1"
+  },
+  {
+    name: "AI",
+    description: "AI-generated string for the given prompt (resolved once per run, cached by prompt)",
+    args: [{ name: "prompt", type: "string", description: 'Quoted description of what to generate, e.g. "email subject"' }],
+    example: "Quick question about your refund"
+  }
+];
+var VALID_MACRO_NAMES = new Set(MACRO_CATALOG.map((m) => m.name));
+var MACRO_ARG_COUNTS = new Map(MACRO_CATALOG.map((m) => [m.name, m.args.length]));
+
+// ../types/src/workflow-node-schemas.ts
+import { z as z4 } from "zod";
+var FormFieldSchema = z4.object({
+  name: z4.string().describe('Unique field identifier (snake_case, e.g., "search_query", "recipient_email")'),
+  label: z4.string().describe('Human-friendly label (e.g., "Search Query", "Recipient Email")'),
+  type: z4.enum([
+    "text",
+    "email",
+    "password",
+    "number",
+    "textarea",
+    "select",
+    "checkbox",
+    "multiselect",
+    "file"
+  ]).optional().describe('Input type, defaults to "text"'),
+  required: z4.boolean().optional().describe("Whether this field is required"),
+  value: z4.string().describe("The value to use for this field"),
+  options: z4.array(z4.object({ value: z4.string(), label: z4.string() })).optional().describe("If type is select/multiselect, provide allowed options here")
+});
+var InlineAssertionSchema = z4.object({
+  condition: z4.string().describe("What to verify after the action"),
+  severity: z4.enum(["warn", "fail"]).describe("warn = log and continue on failure, fail = stop the test"),
+  agentic: z4.boolean().optional().describe("true if requires visual/complex evaluation that cannot be cached")
+});
+var NodeTypeEnum = z4.enum([
+  "login",
+  "navigate",
+  "action",
+  "assertion",
+  "seed",
+  "setup",
+  "wait",
+  "condition",
+  "api_sequence",
+  "end",
+  "notification",
+  "audio",
+  "audio-assertion"
+]);
+
+// ../types/src/browser-viewport.ts
+var BROWSER_VIEWPORT_PRESETS = {
+  desktop: { label: "Desktop", width: 1280, height: 800, device: "desktop" },
+  desktop_large: { label: "Large desktop", width: 1920, height: 1080, device: "desktop" },
+  laptop: { label: "Laptop", width: 1440, height: 900, device: "laptop" },
+  tablet: { label: "Tablet", width: 768, height: 1024, device: "tablet" },
+  mobile: { label: "Mobile", width: 390, height: 844, device: "mobile" }
+};
+var BROWSER_VIEWPORT_PRESET_KEYS = Object.keys(
+  BROWSER_VIEWPORT_PRESETS
+);
+
+// ../types/src/index.ts
+var PLAYBOOK_STEP_ACTIONS = [
+  "click",
+  "fill",
+  "fill_form",
+  "select",
+  "navigate",
+  "wait",
+  "scroll",
+  "hover",
+  "upload",
+  "verify",
+  "press_key",
+  "drag",
+  "resize",
+  "capture",
+  "extract_table",
+  "python_execute",
+  "verify_download",
+  "verify_download_content",
+  "screenshot",
+  "agent_loop"
+];
+function isPositiveIntegerString(value) {
+  if (!value || !/^\d+$/.test(value)) return false;
+  return Number(value) > 0;
+}
+var playbookStepAgentSchema = z5.object({
+  order: z5.number().describe("Step number (1-based)."),
+  action: z5.enum(PLAYBOOK_STEP_ACTIONS).describe(
+    'The type of browser interaction. PREFER DETERMINISTIC VERBS even when verbose \u2014 three deterministic steps beat one agentic step, because deterministic steps replay via Playwright with no agent dispatch. Each replayable playbook step must be 1:1 with an exposed browser tool you actually used and must correspond to zero or one recorded actionRef. If you cannot accomplish the intent with the browser tools you have, do not add a playbook step for it; report the limitation outside playbookSteps. Do not summarize several recorded actions into one "other" step; report the same 1:1 browser primitives you actually used. The only multi-field exception is one fill_form step for one browser_fill_form action. Use "verify" for assertion checks \u2014 both inline assertions and completion assertions proving the action succeeded. Use "verify" for inspection language such as "inspect whether", "confirm", "observe", or "check" when the result is visible in the DOM. Use "capture" instead only when the observed value is needed by later steps. Use "fill" for single-field inputs. Use "fill_form" when browser_fill_form was called to fill multiple fields at once \u2014 one fill_form step per call. Use "click" for checkboxes, switches, toggle buttons, and click-to-focus interactions. There is no separate "toggle" or "focus" action. Use "upload" for file upload actions, including generated CSV/file, attach file, choose file, import file, and document/image attachment intents (browser_action action="upload"). Set params.path to the staged attachment handle, generated file variable, or filename reference used by the upload tool (e.g. {path: "$var.csv_file"}), and include actionRefs pointing to the recorded file_upload action. Do NOT use "other" for file attachment/upload/import intents. Use "scroll" only when scrolling is the user-visible action being tested; routine browser_scroll calls for visibility, inspection, or video framing are observation steps and should usually be omitted from playbookSteps. Use "press_key" for keyboard actions (Enter, Escape, Tab, arrows). Use "press_key" with params.key="Escape" to dismiss a popover, dropdown, panel, or modal when Escape was the recorded action; use "click" if the recorded action clicked a close button or outside target. There is no separate "dismiss" action. Use "drag" for drag-and-drop interactions. Use "resize" when browser_resize was used to resize the viewport. Set params.width and params.height to positive integer pixel values and include the actionRef pointing to the recorded resize action. Use "capture" to extract app-generated values (IDs, codes, URLs) for later steps via $var.name, but only from a visible DOM target or the current URL. Do not capture from performance/network timing, storage, hidden DOM, or app-global state. Use "screenshot" only when browser_screenshot itself is the requested evidence capture. Set params.label when a label was used, optionally params.fullPage="true". Do not use screenshot for routine visual checks after actions; use verify when a browser_assert proves visible state. Use "extract_table" when browser_extract_table was used to extract tabular data from the page. Use "python_execute" when python_execute was used with cache_label to run a data validation script. Use "verify_download" when browser_download(action="list") / browser_list_downloads proves that a file matching some pattern was downloaded. Set params.pattern to a glob (supports *, ?) or substring; optionally params.timeoutMs. This is currently agent-only at replay, so do not set actionRefs. Use "verify_download_content" when browser_download(action="read") / browser_read_download content proves CSV headers, PDF text, exported rows, or similar downloaded-file content. Set params.contains or params.pattern to the expected content predicate. This is currently agent-only at replay, so do not set actionRefs. Use "agent_loop" ONLY when the action set is genuinely unknown until runtime \u2014 variable count of items (e.g. "toggle row checkboxes until 3 selected"), conditional retry that depends on UI state, or a runtime predicate over non-DOM state. Set params.goal to a one-sentence checkable predicate (e.g. params.goal = "3 grid row checkboxes are selected"). DO NOT use agent_loop for: known-N iteration (write N deterministic steps), single click that might double-fire (use "click"), retry-on-flake (the runtime handles that). agent_loop steps replay via a Playwright override authored after first run; they are non-deterministic on first run, so the bar is high. Network/devtools/API inspections and unsupported browser environment mutations are diagnostic-only unless there is an exposed browser tool for the action. If visible page state proves the condition, record that as "verify"; otherwise omit the diagnostic observation from playbookSteps. Do not use "other". If no concrete browser-tool-backed action above fits, omit the observation from playbookSteps and report the limitation outside the playbook.'
+  ),
+  target: z5.string().describe(
+    `Human-readable element description using visible labels, placeholders, or aria-labels. Examples: "'Submit' button", "'Email' input field", "'Status' dropdown". For upload actions, describe the file input and include the attachment name (e.g. "CSV file input for 'testing-checklist.csv'"). Never use coordinates, ref IDs, or internal identifiers.`
+  ),
+  params: z5.record(z5.string(), z5.string()).optional().describe(
+    'Data values using $var.name references and $MACRO() expressions \u2014 NEVER hard-coded literals. Common keys: value (for fill: {value: "$EMAIL()"}), option (for select: {option: "Admin"} \u2014 fixed app constants like dropdown options are allowed as literals), url (for navigate: {url: "$var.target_url"}), path (for upload: {path: "$var.file_path"}), key (for press_key: {key: "Enter"}, {key: "Escape"}), width and height (for resize: {width: "390", height: "844"}), label and fullPage (for screenshot: {label: "seats-table", fullPage: "true"}), pattern or contains (for download verification: {pattern: "report-*.csv"} or {contains: "Expected Header"}), expression + saveAs (for capture: prefer a visible DOM ref expression or "() => window.location.href"; do not use performance.getEntries() or other network/storage/global state; e.g. {saveAs: "order_confirmation_id"}). For fill_form: keys are field names from the fill_form call, values are $var.name or $MACRO() (e.g. {company: "$var.company", email: "$EMAIL()"}). Available macros: $UUID(), $EMAIL(), $FIRST_NAME(), $LAST_NAME(), $PHONE(), $RANDOM_STRING(n), $RANDOM_INT(min,max), $TODAY(), $DATE(days), $NOW(), $TIMESTAMP(), $SEQUENCE("name").'
+  ),
+  note: z5.string().optional().describe(
+    'Timing or quirk notes ONLY (e.g. "Wait 1s for modal animation", "Scroll into view first"). Do NOT put data values, optional markers, or verification notes here.'
+  ),
+  actionRefs: z5.array(z5.number()).max(1).optional().describe(
+    'Zero or one recorded browser action index that corresponds to this playbook step. Interaction tools, browser_resize, capture evaluates (browser_evaluate with saveAs), and browser_assert produce [Action #N] tags \u2014 collect those indices here. Read-only browser_snapshot and plain browser_evaluate without saveAs do NOT produce action indices. browser_scroll and browser_screenshot may produce action indices when they are the primary requested tool call; omit actionRefs when no action tag was emitted. If you took multiple cacheable UI actions, report multiple 1:1 playbook steps instead of putting multiple refs on one step or summarizing them as "other". A fill_form call is a single action \u2014 use one fill_form playbook step with one actionRef. For a click that triggers a native dialog, keep one click actionRef on the click step and set expectedDialogs rather than adding a separate dialog actionRef. Actions not referenced by any playbook step are considered exploratory and will be discarded by the cache compiler.'
+  ),
+  expectedDialogs: z5.enum(["accept", "dismiss"]).optional().describe(
+    'Set when this step is known to fire a native browser dialog (alert/confirm/prompt) \u2014 e.g. clicking a "Delete" button that prompts "Are you sure?". On replay the runtime pre-arms the dialog handler with this action automatically. In free-form runs, you should call the dialog tool (browser_dialog for consolidated tools, browser_handle_dialog for legacy tools) with this action immediately before the step. Do not add a separate dialog step \u2014 keeping the pre-arm on the triggering step keeps the pre-arm and the triggering action in one place.'
+  )
+}).superRefine((step, ctx) => {
+  if (step.action === "agent_loop") {
+    const goal = step.params?.goal;
+    if (!goal || goal.trim().length === 0) {
+      ctx.addIssue({
+        code: z5.ZodIssueCode.custom,
+        path: ["params", "goal"],
+        message: 'agent_loop steps must set params.goal to a one-sentence checkable predicate (e.g. "3 grid row checkboxes are selected").'
+      });
+    }
+  }
+  if (step.action === "verify_download") {
+    const pattern = step.params?.pattern;
+    if (!pattern || pattern.trim().length === 0) {
+      ctx.addIssue({
+        code: z5.ZodIssueCode.custom,
+        path: ["params", "pattern"],
+        message: "verify_download steps must set params.pattern to a glob (supports *, ?) or substring matching the expected filename."
+      });
+    }
+  }
+  if (step.action === "verify_download_content") {
+    const pattern = step.params?.pattern;
+    const contains = step.params?.contains;
+    if ((!pattern || pattern.trim().length === 0) && (!contains || contains.trim().length === 0)) {
+      ctx.addIssue({
+        code: z5.ZodIssueCode.custom,
+        path: ["params"],
+        message: "verify_download_content steps must set params.contains or params.pattern for the expected downloaded content."
+      });
+    }
+  }
+  if (step.action === "resize") {
+    const width = step.params?.width;
+    const height = step.params?.height;
+    if (!isPositiveIntegerString(width)) {
+      ctx.addIssue({
+        code: z5.ZodIssueCode.custom,
+        path: ["params", "width"],
+        message: "resize steps must set params.width to a positive integer pixel value."
+      });
+    }
+    if (!isPositiveIntegerString(height)) {
+      ctx.addIssue({
+        code: z5.ZodIssueCode.custom,
+        path: ["params", "height"],
+        message: "resize steps must set params.height to a positive integer pixel value."
+      });
+    }
+  }
+});
+
+export {
+  USER_SETTABLE_WORKFLOW_STATUSES,
+  INSTANCE_SIZES,
+  INSTANCE_SIZE_SPEC,
+  parseInstanceSize,
+  VALID_MACRO_NAMES,
+  InlineAssertionSchema,
+  NODE_TYPE_LABEL,
+  normalizeNodeType
+};
+//# sourceMappingURL=chunk-SJJW77WN.js.map