@cementic/cementic-test 0.2.15 → 0.2.17

package/CHANGELOG.md

@@ -0,0 +1,92 @@
+# Changelog
+
+All notable changes to `@cementic/cementic-test` are documented here.
+
+## v0.2.17
+
+- fixed `ct gen` URL assertions so redirect and stay-on-page regexes are derived from the exact intent text, including `secure area -> /secure/` and `login page -> /login/`
+- stripped leaked backticks from generated regex literals so negative URL assertions no longer emit invalid patterns such as ``/`[-_\/]?login`/``
+- added a post-generation Playwright validation pass that repairs known method typos such as `.fil()` before files are written
+- fixed negative auth generation so the field under test uses a deliberately invalid literal value instead of reusing valid `CT_VAR_*` credentials
+- updated package metadata, capture artifact metadata, and capture user agent strings to `0.2.17`
+
+## v0.2.16
+
+- fixed `ct gen` so unquoted and backticked step values such as ```${CT_VAR_EMAIL}``` now map to runnable `.fill()` and `.selectOption()` calls instead of falling back to `TODO` comments
+- fixed generated auth button clicks so generic phrases like `Click the login button` use resilient role-name regex matching when an exact accessible name is unavailable
+- added regression coverage for unquoted `CT_VAR_*` auth steps to keep generated login specs runnable
+- hardened the publish workflow so release tags must match `package.json`, and publishing aborts if the npm version already exists
+- updated package metadata, capture artifact metadata, and capture user agent strings to `0.2.16`
+
+## v0.2.15
+
+- fixed capture semantics so `<a href="...">` elements are classified as links unless they explicitly expose `role="button"`
+- made CTA-like presence selectors resilient by generating `Locator.or(...)` fallbacks across button and link roles when the intent is ambiguous
+- tightened intent label cleanup so trailing filler phrases like `on the page` do not leak into generated locator text
+- updated capture artifact metadata and capture user agent version strings to `0.2.15`
+
+## v0.2.14
+
+- hardened the release gate so `npm test` now includes the prompt regression suite and `prepublishOnly` runs the full test gate
+- fixed the prompt test harness so it executes the local `dist/cli.js` build instead of depending on whichever global `ct` happens to be on `PATH`
+- added deterministic capture-analysis fallback for `ct tc url --ai` when no LLM key is configured or remote analysis fails
+- hardened auth, navigation, negative-state, heading, and count scenario fallback behavior so capture-driven generation still produces intent-aligned Playwright output offline
+- added smoke coverage for `ct new`, `ct ci`, `ct flow --no-run`, `ct report`, and both `ct serve` execution paths
+- replaced the old browser bootstrap heuristic in `ct new` with explicit browser install profiles: `auto`, `all`, and `chromium`
+- kept the compatibility downgrade conditional to affected older macOS versions only, while preserving the normal Playwright install path for newer machines
+- changed `ct new --mode` handling to reject unsupported scaffold modes explicitly instead of silently behaving like `greenfield`
+
+## v0.2.13
+
+- replaced the old Rule 10 prompt guidance with a Playwright knowledge base aligned to official Playwright docs and web-first assertion patterns
+- aligned locator priority with Playwright best practices: `getByRole -> getByLabel -> getByPlaceholder -> getByText -> locator`
+- made counting intents generate `toHaveCount()` or `.count()` instead of intent-text locators
+- enforced that intent wording is never reused as locator text
+- made negative assertions generate `.not.` or `toBeHidden()` patterns
+- made error assertions prefer `getByRole('alert')` and heading assertions prefer `getByRole('heading')`
+- added on-demand Playwright doc fetching for advanced categories such as uploads, mocking, accessibility, viewports, auth, downloads, dialogs, frames, and popups
+- added the 12-check prompt regression suite in `test/prompt.spec.mjs`
+
+## v0.2.12
+
+- made both AI generation paths intent-first so markdown and capture-based scenario generation follow the same scope and presence-only rules
+- tightened capture-based scenario generation to preserve presence-only checks as visibility assertions, honor intent-based selector fallback, and avoid generic `'value'` placeholders
+- added regression coverage for the new markdown prompt contract and capture-path intent enforcement
+- breaking change: none
+
+## v0.2.11
+
+- AI no longer writes `'value'` as a step input and now prefers matching `CT_VAR_*` references or `test-{fieldname}` fallbacks
+- fixed `ct gen` so generic fill steps read matching `CT_VAR_*` values from the environment and emit env-backed constants only when they are actually needed
+- fixed generated `toHaveValue(...)` assertions so they reuse the same emitted fill value for selector-backed form fields
+- added a generated spec header comment that lists required `CT_VAR_*` variables with inline usage examples
+- breaking change: none
+
+## v0.2.10
+
+- fixed `ct gen` so selector-hinted fields like `#username` and `#password` infer matching `CT_VAR_*` constants instead of leaving `.fill('value')` placeholders behind
+- fixed generated `toHaveValue(...)` assertions so they reuse the same `CT_VAR_*` binding when the related fill step was variablized
+- added regression coverage for selector-driven auth generation to keep fill calls and value assertions aligned
+
+## v0.2.9
+
+- added `CT_VAR_*` extraction in `ct gen` for input and select test data so generated specs use env-backed constants instead of hardcoded values
+- added `ct gen --vars '{...}'` to override generated fallback values without editing the emitted spec files by hand
+- added regression coverage for variableized generated specs, selector-hint preservation, and select-option extraction
+
+## v0.2.8
+
+- fixed TypeScript generator identifier sanitization so scenario titles containing em dashes and other non-identifier characters no longer break generated POM class names or spec imports
+- added regression coverage for generated TypeScript output from scenario titles like `Login-002 — User can enter credentials — before submission`
+
+## v0.2.7
+
+- fixed project-first Playwright resolution for `ct tc url --ai`, including global and `npx` CLI usage
+- added clearer capture failure categories and setup guidance for missing Playwright, missing browsers, and page-load failures
+- centralized AI provider detection so `tc --ai` and capture analysis recognize the same providers and env vars
+- fixed missing DeepSeek guidance in the CLI help path
+- changed legacy macOS browser setup to install Chromium only by default and avoid WebKit unsupported failures
+
+## v0.2.6
+
+- added an install-time banner with links to the website and community

package/README.md

@@ -206,6 +206,8 @@ Before publishing, run the full local gate:
 npm test
 ```
 
+Do not reuse an npm version. npm will reject republishing an existing version even if the Git tag was moved later.
+
 If you want to inspect the prompt regression suite directly:
 
 ```bash
@@ -216,12 +218,14 @@ node --test --test-name-pattern="counting intent" test/prompt.spec.mjs
 
 Note: on current Node test runner versions, use `--test-reporter=spec`, not `--reporter=spec`.
 
-### v0.2.15 acceptance criteria
+### v0.2.17 acceptance criteria
 
-All of the following must be true before publishing `v0.2.15`:
+All of the following must be true before publishing `v0.2.17`:
 
 - `npm test` passes from a clean checkout and includes both the integration suite and `test/prompt.spec.mjs`
 - `prepublishOnly` runs the same full release gate, not just `build`
+- the release tag matches `package.json`
+- the target npm version is not already published
 - prompt regression suite verifies:
   - counting intents generate `toHaveCount()` or `.count()`
   - intent text is never reused as `getByText(...)`
@@ -246,8 +250,14 @@ All of the following must be true before publishing `v0.2.15`:
   - review flags and review reasons
 - `ct gen` guarantees:
   - no `.fill('value')` placeholders
+  - no `TODO` comments for recognized fill/select auth steps using quoted, unquoted, or backticked `CT_VAR_*` values
   - env-backed `CT_VAR_*` extraction when matching vars are available
   - field-specific fallback values when env vars are not available
+  - redirect and stay-on-page assertions derive `toHaveURL(/.../)` from the exact intent text or explicit path instead of generic hardcoded alternates
+  - backticks never leak into generated regex literals
+  - field-specific negative auth tests use deliberately invalid literal values for the field under test
+  - generic auth button click steps fall back to resilient role-name matching when exact labels are missing
+  - generated Playwright method calls are validated before files are written, and known typos such as `.fil()` are repaired to valid API names
   - existing POM files are not overwritten
   - generated specs compile as valid Playwright TypeScript or JavaScript
 - command smoke coverage passes for:
@@ -258,7 +268,7 @@ All of the following must be true before publishing `v0.2.15`:
   - unsupported `ct new --mode` values failing explicitly
   - `ct ci`
   - `ct flow --no-run`
-- README, package version, and documented changelog entries match the release being cut
+- README, package version, runtime metadata strings, and changelog entries match the release being cut
 
 ---
 
@@ -451,6 +461,20 @@ And start automating.
 
 ## Changelog
 
+See [CHANGELOG.md](./CHANGELOG.md) for the full release history.
+
+### v0.2.17
+
+- fixed `ct gen` URL assertions so redirect and stay-on-page regexes now come from the exact intent text, including `secure area -> /secure/` and `login page -> /login/`
+- stripped leaked backticks from generated regex literals and added a post-generation Playwright validation pass that repairs known typos such as `.fil()`
+- fixed negative auth generation so the field under test uses a deliberately invalid literal instead of reusing valid `CT_VAR_*` credentials
+
+### v0.2.16
+
+- fixed `ct gen` so unquoted and backticked `CT_VAR_*` fill steps now generate runnable `.fill()` calls instead of `TODO` comments
+- made generated auth button clicks more resilient for generic phrases like `Click the login button`
+- added release guards so publish only proceeds when the Git tag matches `package.json` and the npm version has not already been published
+
 ### v0.2.15
 
 - fixed capture semantics so `<a href="...">` elements are classified as links unless they explicitly expose `role="button"`

package/dist/capture.js

@@ -6,7 +6,7 @@ import {
   formatCaptureFailure,
   inferInteractiveRole,
   toPageSummary
-} from "./chunk-XUWFEWJZ.js";
+} from "./chunk-JWGYAQ3O.js";
 export {
   CaptureRuntimeError,
   captureElements,

package/dist/{chunk-3S26OWNR.js → chunk-A4IHRXON.js}

@@ -30,12 +30,27 @@ function urlPatternFromAbsoluteUrl(value) {
     return void 0;
   }
 }
+function sanitizeUrlIntentPhrase(value) {
+  return value.replace(/`+/g, " ").replace(/^\/+/, " ").replace(/\/[dgimsuvy]*$/i, " ").replace(/["']/g, " ").replace(/\b(?:the|a|an|user|same|current)\b/gi, " ").replace(/\b(?:page|screen|view|area|section|route|path|url|form)\b/gi, " ").replace(/\s+/g, " ").trim();
+}
 function pageNameToUrlPattern(value) {
-  const cleaned = value.replace(/\b(the|a|an|user)\b/gi, " ").replace(/\b(page|screen)\b/gi, " ").trim();
+  const cleaned = sanitizeUrlIntentPhrase(value);
   const tokens = cleaned.split(/[\s/-]+/).map((token) => token.trim()).filter(Boolean);
   if (tokens.length === 0) return void 0;
   return tokens.map((token) => escapeForRegex(token.toLowerCase())).join("[-_\\/]?");
 }
+function urlPatternFromIntentText(value) {
+  const sanitized = value.replace(/`+/g, "").trim();
+  const explicitPathMatch = sanitized.match(/["'](\/[^"']+)["']/) ?? sanitized.match(/\b(?:to|on|at)\s+(\/[\w/-]+)/i) ?? sanitized.match(/https?:\/\/[^\s'"]+/i);
+  const explicitPath = explicitPathMatch?.[1] ?? explicitPathMatch?.[0];
+  if (explicitPath) {
+    const fromUrl = explicitPath.startsWith("http") ? urlPatternFromAbsoluteUrl(explicitPath) : void 0;
+    const fromPath = explicitPath.startsWith("/") ? explicitPath.replace(/^\/+/, "").split("/").map(escapeForRegex).join("\\/") : void 0;
+    return fromUrl ?? fromPath;
+  }
+  const phraseMatch = sanitized.match(/\b(?:redirect(?:s|ed)?|navigat(?:e|es|ed)|go(?:es|ne)?|route|path|url)\b(?:\s+(?:to|on|contains))?\s+(?:the\s+)?(.+?)(?:[.?!]|$)/i) ?? sanitized.match(/\b(?:remain|remains|stays|stay|still)\s+(?:on|at)\s+(?:the\s+)?(.+?)(?:[.?!]|$)/i);
+  return phraseMatch?.[1] ? pageNameToUrlPattern(phraseMatch[1]) : void 0;
+}
 function fieldNameFromSentence(value) {
   const match = value.match(/\bfor\s+([a-zA-Z][a-zA-Z\s-]{0,30}?)\s+field\b/i) ?? value.match(/\b([a-zA-Z][a-zA-Z\s-]{0,30}?)\s+field\b/i) ?? value.match(/\b([a-zA-Z][a-zA-Z\s-]{0,30}?)\s+input\b/i);
   return match?.[1]?.trim();
@@ -92,6 +107,16 @@ function parseQuotedLiteral(value) {
   }
   return void 0;
 }
+function unwrapStepValue(value) {
+  if (!value) return void 0;
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  const quoted = parseQuotedLiteral(trimmed);
+  if (quoted !== void 0) return quoted;
+  const inlineCode = trimmed.match(/^`([^`]+)`$/);
+  if (inlineCode) return inlineCode[1].trim();
+  return trimmed;
+}
 function selectorTargetToEnvSuffix(value) {
   const selector = normalizeSelectorTarget(value);
   if (!selector) return void 0;
@@ -118,7 +143,7 @@ function isGenericFallbackValue(value) {
   return /^(?:value|text|input|option|selection|selected value|default)$/i.test(value.trim());
 }
 function extractCtVarTemplate(value) {
-  const match = value?.trim().match(/^\$\{(CT_VAR_[A-Z0-9_]+)\}$/);
+  const match = unwrapStepValue(value)?.match(/^\$\{(CT_VAR_[A-Z0-9_]+)\}$/);
   return match?.[1];
 }
 function placeholderTokenFromSuffix(value) {
@@ -151,7 +176,16 @@ function parseStepBinding(step) {
       kind: "fill",
       rawField: fillMatch[1].trim(),
       fieldLabel: cleanFieldLabel(fillMatch[1]),
-      value: fillMatch[3].trim()
+      value: unwrapStepValue(fillMatch[3])
+    };
+  }
+  const fillLooseMatch = s.match(/\b(?:fill|input|write)\s+(?:in\s+)?(.+?)\s+with\s+(.+)$/i);
+  if (fillLooseMatch) {
+    return {
+      kind: "fill",
+      rawField: fillLooseMatch[1].trim(),
+      fieldLabel: cleanFieldLabel(fillLooseMatch[1]),
+      value: unwrapStepValue(fillLooseMatch[2])
     };
   }
   const fillWithoutValueMatch = s.match(/\b(?:fill|input|write)\s+(?:in\s+)?(.+?)$/i);
@@ -168,7 +202,16 @@ function parseStepBinding(step) {
       kind: "fill",
       rawField: enterMatch[3].trim(),
       fieldLabel: cleanFieldLabel(enterMatch[3]),
-      value: enterMatch[2].trim()
+      value: unwrapStepValue(enterMatch[2])
+    };
+  }
+  const enterLooseMatch = s.match(/\b(?:enter|type)\s+(.+?)\s+(?:in|into)\s+(.+)$/i);
+  if (enterLooseMatch) {
+    return {
+      kind: "fill",
+      rawField: enterLooseMatch[2].trim(),
+      fieldLabel: cleanFieldLabel(enterLooseMatch[2]),
+      value: unwrapStepValue(enterLooseMatch[1])
     };
   }
   const enterWithoutValueMatch = s.match(/\b(?:enter|type)\s+(?:in|into)\s+(.+)/i);
@@ -185,7 +228,16 @@ function parseStepBinding(step) {
       kind: "select",
       rawField: selectMatch[3].trim(),
       fieldLabel: cleanFieldLabel(selectMatch[3]),
-      value: selectMatch[2].trim()
+      value: unwrapStepValue(selectMatch[2])
+    };
+  }
+  const selectLooseMatch = s.match(/\b(?:select|choose|pick)\s+(.+?)\s+(?:from|in|into|on)\s+(.+)$/i);
+  if (selectLooseMatch) {
+    return {
+      kind: "select",
+      rawField: selectLooseMatch[2].trim(),
+      fieldLabel: cleanFieldLabel(selectLooseMatch[2]),
+      value: unwrapStepValue(selectLooseMatch[1])
     };
   }
   const selectWithoutValueMatch = s.match(/\b(?:select|choose|pick)\s+(.+?)\s+(?:dropdown|combobox|select|menu)\b/i);
@@ -198,6 +250,38 @@ function parseStepBinding(step) {
   }
   return void 0;
 }
+function inferNegativeAuthTarget(norm) {
+  const tags = (norm.tags ?? []).map((tag) => tag.toLowerCase());
+  const content = [norm.id, norm.title, ...norm.expected ?? []].filter(Boolean).join(" ").toLowerCase();
+  const isNegativeCase = tags.includes("negative") || /\b(invalid|wrong|incorrect|bad|nonexistent|not an email)\b/.test(content);
+  if (!isNegativeCase) return void 0;
+  if (/\b(?:invalid|wrong|incorrect|bad|not an email)\s+(?:e-?mail|email)\b|\b(?:e-?mail|email)\b.{0,24}\b(?:invalid|wrong|incorrect|bad|not an email)\b/.test(content)) {
+    return "EMAIL";
+  }
+  if (/\b(?:invalid|wrong|incorrect|bad|nonexistent)\s+(?:user(?:name)?|login)\b|\b(?:user(?:name)?|login)\b.{0,24}\b(?:invalid|wrong|incorrect|bad|nonexistent)\b/.test(content)) {
+    return "USERNAME";
+  }
+  if (/\b(?:invalid|wrong|incorrect|bad)\s+password\b|\bpassword\b.{0,24}\b(?:invalid|wrong|incorrect|bad)\b/.test(content)) {
+    return "PASSWORD";
+  }
+  return void 0;
+}
+function negativeAuthFallbackValue(target) {
+  return target === "EMAIL" ? "invalid-not-an-email" : target === "PASSWORD" ? "wrong-password-123" : "nonexistent-user";
+}
+function rewriteNegativeAuthSteps(steps, stepHints, norm) {
+  const target = inferNegativeAuthTarget(norm);
+  if (!target) return steps;
+  return steps.map((step, index) => {
+    const binding = parseStepBinding(step);
+    if (binding?.kind !== "fill") return step;
+    const selectorTarget = normalizeSelectorTarget(stepHints?.[index]?.selector);
+    const fieldSuffix = fieldNameToEnvSuffix(binding.rawField) ?? fieldNameToEnvSuffix(binding.fieldLabel) ?? selectorTargetToEnvSuffix(selectorTarget);
+    if (fieldSuffix !== target) return step;
+    const rawField = binding.rawField ?? binding.fieldLabel ?? "field";
+    return `Fill in ${rawField} with '${negativeAuthFallbackValue(target)}'`;
+  });
+}
 function resolveStepVarOverride(overrides, envKey, keySuffix, rawField, fieldLabel) {
   const candidates = [envKey, keySuffix, rawField, fieldLabel];
   for (const candidate of candidates) {
@@ -233,10 +317,12 @@ function extractStepVars(steps, stepHints, assertionHints, overrides) {
     const overrideValue = resolveStepVarOverride(overrides, envKey, keySuffix, binding.rawField, binding.fieldLabel);
     const fallbackFromBinding = binding.value?.trim();
     const hasRuntimeEnvValue = process.env[envKey] !== void 0;
-    const shouldDeclareVariable = binding.kind === "select" || templateEnvKey !== void 0 || overrideValue !== void 0 || hasRuntimeEnvValue;
+    const shouldUseRuntimeEnvValue = hasRuntimeEnvValue && (!fallbackFromBinding || isGenericFallbackValue(fallbackFromBinding));
+    const shouldDeclareVariable = binding.kind === "select" || templateEnvKey !== void 0 || overrideValue !== void 0 || shouldUseRuntimeEnvValue;
     let stepVar = shouldDeclareVariable ? seen.get(envKey) : void 0;
     if (shouldDeclareVariable && !stepVar) {
-      const fallback = overrideValue ?? process.env[envKey] ?? ((!fallbackFromBinding || isGenericFallbackValue(fallbackFromBinding) || templateEnvKey) && assertionFallback ? assertionFallback : fallbackFromBinding) ?? (binding.kind === "fill" ? buildFillPlaceholder(binding.rawField, binding.fieldLabel, selectorTarget) : assertionFallback ?? "option");
+      const placeholderFallback = binding.kind === "fill" ? buildFillPlaceholder(binding.rawField, binding.fieldLabel, selectorTarget) : assertionFallback ?? "option";
+      const fallback = overrideValue ?? process.env[envKey] ?? (templateEnvKey ? assertionFallback ?? placeholderFallback : (!fallbackFromBinding || isGenericFallbackValue(fallbackFromBinding)) && assertionFallback ? assertionFallback : fallbackFromBinding) ?? placeholderFallback;
       stepVar = {
         envKey,
         constName: envKey,
@@ -306,6 +392,33 @@ function ensureStatement(value) {
   if (!trimmed) return trimmed;
   return trimmed.endsWith(";") ? trimmed : `${trimmed};`;
 }
+function phraseToRegexPattern(value) {
+  return value.trim().split(/\s+/).filter(Boolean).map((token) => escapeForRegex(token)).join("\\s+");
+}
+function buttonNameExpressionFromStep(step) {
+  const quotedMatch = step.match(/["']([^"']+)["']/);
+  if (quotedMatch) return `'${escapeForSingleQuotedString(quotedMatch[1])}'`;
+  const label = step.replace(/^(click|press|tap)\s+(?:on\s+)?(?:the\s+)?/i, "").replace(/\b(button|btn)\b/gi, "").replace(/[.?!,:;]+$/g, "").trim();
+  if (!label) return `'button'`;
+  const lowered = label.toLowerCase();
+  const variants = /* @__PURE__ */ new Set();
+  if (/\b(?:login|log in|sign in|sign-in)\b/.test(lowered)) {
+    variants.add("login");
+    variants.add("log in");
+    variants.add("sign in");
+  } else if (/\b(?:register|sign up|sign-up|signup|create account)\b/.test(lowered)) {
+    variants.add("register");
+    variants.add("sign up");
+    variants.add("create account");
+  } else if (/\bcontinue\b/.test(lowered)) {
+    variants.add("continue");
+    variants.add("next");
+  } else {
+    variants.add(label);
+  }
+  const pattern = Array.from(variants).map(phraseToRegexPattern).join("|");
+  return `/${pattern}/i`;
+}
 function parseValueAssertionHint(playwright) {
   const statement = ensureStatement(String(playwright ?? "").trim());
   if (!statement) return void 0;
@@ -350,9 +463,7 @@ function stepToPlaywright(step, url, hint, stepVar) {
   }
   if (/\bclick\b.*(button|btn|submit|sign in|log in|login|register|continue|next|save|confirm)/i.test(s)) {
     if (hintedSelector) return `await ${hintedSelector}.click();`;
-    const nameMatch = s.match(/["']([^"']+)["']/);
-    const name = nameMatch?.[1] ?? s.replace(/click\s+(the\s+)?/i, "").trim();
-    return `await page.getByRole('button', { name: '${escapeForSingleQuotedString(name)}' }).click();`;
+    return `await page.getByRole('button', { name: ${buttonNameExpressionFromStep(s)} }).click();`;
   }
   if (/\bclick\b.*(link|anchor|nav)/i.test(s)) {
     if (hintedSelector) return `await ${hintedSelector}.click();`;
@@ -422,20 +533,12 @@ function expectedToAssertion(expected, norm, hint, stepState) {
     return `await expect(page).toHaveURL(/${fallbackPattern}/); // form did not navigate`;
   }
   if (/\b(remains?|stays?|still)\s+on\b/i.test(s)) {
-    const pageMatch = s.match(/\b(?:remains?|stays?|still)\s+on\s+(?:the\s+)?(.+?)(?:\s+page|\s+screen)?$/i);
-    const pagePattern = pageMatch?.[1] ? pageNameToUrlPattern(pageMatch[1]) : void 0;
+    const pagePattern = urlPatternFromIntentText(s);
     return `await expect(page).toHaveURL(/${pagePattern || currentUrlPattern || "login"}/);`;
   }
   if (/\b(url|redirect(?:s|ed)?|navigate(?:s|d)?|route|path)\b/i.test(s)) {
-    const pathMatch = s.match(/["'](\/[^"']+)["']/) ?? s.match(/to\s+(\/[\w/-]+)/i) ?? s.match(/https?:\/\/[^\s'"]+/i);
-    const matchedPath = pathMatch?.[1] ?? pathMatch?.[0];
-    if (matchedPath) {
-      const fromUrl = matchedPath.startsWith("http") ? urlPatternFromAbsoluteUrl(matchedPath) : void 0;
-      const directPath = matchedPath.startsWith("/") ? matchedPath.replace(/^\/+/, "").split("/").map(escapeForRegex).join("\\/") : void 0;
-      const finalPattern = fromUrl ?? directPath ?? currentUrlPattern;
-      if (finalPattern !== void 0) return `await expect(page).toHaveURL(/${finalPattern}/);`;
-    }
-    return `await expect(page).toHaveURL(/dashboard|success|home/);`;
+    const finalPattern = urlPatternFromIntentText(s) ?? currentUrlPattern ?? ".+";
+    return `await expect(page).toHaveURL(/${finalPattern}/);`;
   }
   if (/\bpage title\b|\btitle should\b|\bdocument title\b/i.test(s)) {
     const titleMatch = s.match(/["']([^"']+)["']/);
@@ -568,7 +671,7 @@ function buildTestTitle(norm) {
 }
 function buildSpecFile(norm, pomClassName, pomImportPath, overrides) {
   const title = buildTestTitle(norm);
-  const steps = norm.steps ?? [];
+  const steps = rewriteNegativeAuthSteps(norm.steps ?? [], norm.step_hints, norm);
   const expected = norm.expected ?? [];
   const stepVars = extractStepVars(steps, norm.step_hints, norm.assertion_hints, overrides);
   let importPath = pomImportPath.replace(/\\/g, "/");
@@ -601,6 +704,87 @@ ${assertionLines}
 });
 `;
 }
+var PLAYWRIGHT_METHOD_NAMES = /* @__PURE__ */ new Set([
+  "all",
+  "check",
+  "click",
+  "evaluate",
+  "fill",
+  "filter",
+  "first",
+  "getByLabel",
+  "getByPlaceholder",
+  "getByRole",
+  "getByTestId",
+  "getByText",
+  "goto",
+  "hover",
+  "locator",
+  "nth",
+  "or",
+  "press",
+  "reload",
+  "selectOption",
+  "toBeChecked",
+  "toBeDisabled",
+  "toBeEnabled",
+  "toBeHidden",
+  "toBeVisible",
+  "toContainText",
+  "toHaveCount",
+  "toHaveTitle",
+  "toHaveURL",
+  "toHaveValue",
+  "uncheck",
+  "waitForEvent",
+  "waitForLoad",
+  "waitForLoadState"
+]);
+function levenshteinDistance(left, right) {
+  const distances = Array.from({ length: right.length + 1 }, (_, index) => index);
+  for (let row = 1; row <= left.length; row++) {
+    let previousDiagonal = distances[0];
+    distances[0] = row;
+    for (let column = 1; column <= right.length; column++) {
+      const temp = distances[column];
+      distances[column] = Math.min(
+        distances[column] + 1,
+        distances[column - 1] + 1,
+        previousDiagonal + (left[row - 1] === right[column - 1] ? 0 : 1)
+      );
+      previousDiagonal = temp;
+    }
+  }
+  return distances[right.length];
+}
+function findClosestPlaywrightMethod(methodName) {
+  let bestCandidate;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  for (const candidate of PLAYWRIGHT_METHOD_NAMES) {
+    if (candidate[0] !== methodName[0]) continue;
+    const distance = levenshteinDistance(methodName, candidate);
+    if (distance < bestDistance) {
+      bestDistance = distance;
+      bestCandidate = candidate;
+    }
+  }
+  return bestDistance <= 2 ? bestCandidate : void 0;
+}
+function stripBackticksInsideRegexLiterals(line) {
+  return line.includes("`") ? line.replace(/`/g, "") : line;
+}
+function repairPlaywrightMethodsInLine(line, fileLabel) {
+  if (!/\bawait\b/.test(line)) return line;
+  return line.replace(/\.(\w+)\(/g, (match, methodName) => {
+    if (PLAYWRIGHT_METHOD_NAMES.has(methodName)) return match;
+    const repaired = findClosestPlaywrightMethod(methodName);
+    if (repaired) return `.${repaired}(`;
+    throw new Error(`Generated unsupported Playwright method ".${methodName}(" in ${fileLabel}`);
+  });
+}
+function finalizeGeneratedPlaywrightSource(source, fileLabel) {
+  return source.split("\n").map((line) => repairPlaywrightMethodsInLine(stripBackticksInsideRegexLiterals(line), fileLabel)).join("\n");
+}
 async function gen(opts) {
   if (opts.lang !== "ts" && opts.lang !== "js") {
     console.error("\u274C --lang must be ts or js");
@@ -632,14 +816,23 @@ async function gen(opts) {
     const pomFileName = pomClassName + pomExt;
     const pomFilePath = join(pagesOutDir, pomFileName);
     if (!existsSync(pomFilePath)) {
-      writeFileSync(pomFilePath, buildPomClass(pomClassName, norm, lang));
+      writeFileSync(
+        pomFilePath,
+        finalizeGeneratedPlaywrightSource(buildPomClass(pomClassName, norm, lang), pomFileName)
+      );
       pomCount++;
     }
     const relToPages = relative(testsOutDir, pagesOutDir);
     const pomImportPath = join(relToPages, pomFileName);
     const stem = basename(f).replace(/\.json$/, "").replace(/[^\w-]+/g, "-");
     const specPath = join(testsOutDir, `${stem}.${specExt}`);
-    writeFileSync(specPath, buildSpecFile(norm, pomClassName, pomImportPath, varsOverride));
+    writeFileSync(
+      specPath,
+      finalizeGeneratedPlaywrightSource(
+        buildSpecFile(norm, pomClassName, pomImportPath, varsOverride),
+        basename(specPath)
+      )
+    );
     specCount++;
   }
   console.log(`\u2705 Generated ${specCount} spec file(s)  \u2192 ${opts.out}/`);
@@ -663,7 +856,8 @@ Examples:
 }
 
 export {
+  finalizeGeneratedPlaywrightSource,
   gen,
   genCmd
 };
-//# sourceMappingURL=chunk-3S26OWNR.js.map
+//# sourceMappingURL=chunk-A4IHRXON.js.map