@ia-qa/self-healing 0.1.0

package/README.md

@@ -0,0 +1,91 @@
+# @ia-qa/self-healing (MVP — private)
+
+Self-healing E2E toolkit: a **local MCP server** for AI agents, a guided **CLI**, an accessibility-tree page mapper, and runtime helpers (`aiClick` / `aiFill`) that recover from broken selectors. Framework- and language-agnostic (Cypress, Playwright, Selenium…; JS/TS, Python, Java…).
+
+> 👉 **New here? Read [TUTORIAL.md](./TUTORIAL.md)** — the step-by-step, no-jargon guide. This README is the reference.
+
+**It runs entirely on the end user's machine.** It brings its own headless Chromium, so it sees `localhost`, staging, or an app behind a VPN — and **no data ever leaves the machine**. Nothing is hosted.
+
+## Two front doors, one engine
+
+| | For | Entry point |
+|---|---|---|
+| **MCP server** (stdio) | AI agents — "map my app at \<url\>" | `ia-qa-heal-mcp` → tools `map_app`, `diff_mappings`, `fix_tests` |
+| **CLI** | humans & CI | `ia-qa-heal` → `init`, `map`, `diff`, `fix` |
+
+Agent config (Claude Code / Desktop, Cursor…):
+```json
+{
+  "mcpServers": {
+    "ia-qa-self-healing": {
+      "command": "npx",
+      "args": ["-y", "-p", "@ia-qa/self-healing", "ia-qa-heal-mcp"]
+    }
+  }
+}
+```
+`-p` is required, not cosmetic: the package ships **two** bins (`ia-qa-heal`, `ia-qa-heal-mcp`), so `npx @ia-qa/self-healing …` cannot resolve which to run and silently starts nothing. Verified against a packed tarball.
+The MCP server is a dependency-free JSON-RPC 2.0 stdio implementation (`src/mcp/server.ts`) — no SDK, matching the repo's zero-dep client ethos. It does **not** require the separate Playwright MCP: it drives its own browser. stdout is the protocol channel; logs go to stderr.
+
+### Browser reuse — no second Chromium (`src/launcher.ts`)
+Playwright's browser cache is **machine-wide and shared** (`%LOCALAPPDATA%\ms-playwright`, `~/.cache/ms-playwright`). If the user already has *any* Playwright install — their own tests or the Playwright MCP — the bundled Chromium is already there and we reuse it for free. There is no "second Chromium" to avoid; the only real cost is **revision skew** (a different Playwright version pins a different Chromium revision). For that case, and for machines that forbid the download, the launcher resolves in this order:
+
+1. explicit executable — `browserPath` / `$IAQA_BROWSER_PATH`
+2. explicit channel — `browserChannel` / `$IAQA_BROWSER_CHANNEL` (`chrome`, `msedge`…) → **zero download**
+3. Playwright's bundled Chromium (shared cache — usually already present)
+4. automatic fallback to the system Chrome, then Edge
+
+Only if all four fail does it error, listing the three fixes. `map_app` exposes `browser_channel` / `browser_path` and always reports which browser it used. For DOM extraction the engine is irrelevant — Chrome, Edge and Chromium yield the same contract.
+
+## How it works
+
+1. **`ia-qa-heal init`** — interactive wizard. Choose the framework, where credentials live (**local `.env`** or **AWS SSM Parameter Store**), the login flow, and the pages to map. Writes `.ia-qa/config.json` — it contains **secret references only, never values**.
+2. **`ia-qa-heal map [page]`** — resolves credentials at runtime (env or SSM via your local AWS credential chain), launches headless Chromium, logs in if configured, and extracts every **visible interactive element** (role + accessible name + stable selector) to **two files** per page: `.ia-qa/mapping/<page>.json` (for tooling / `diff`) and `.ia-qa/mapping/<page>.md` (the **page contract** — the framework-agnostic artifact you hand to an LLM to auto-heal tests):
+   ```json
+   {
+     "page": "login",
+     "url": "/login",
+     "capturedAt": "2026-07-15T10:00:00.000Z",
+     "elements": [
+       { "role": "button", "name": "Se connecter", "selector": "button#login" }
+     ]
+   }
+   ```
+   The `<page>.md` groups elements by role and carries a self-describing header telling a model exactly how to use it. **The CI auto-heal loop:** when a UI test fails, hand the failing test file + the current `<page>.md` to an LLM — it finds the element by role + accessible name, reads the current selector, and rewrites the test in **whatever framework and language** it is written in (Cypress, Playwright, Selenium; JS or Python). The contract is the source of truth; the model handles the syntax. The same contract is downloadable from the zero-install **Selector Drift Detector** page on ia-qa.com.
+3. **`ia-qa-heal diff <before.json> <after.json>`** — CI-gate verdict. Diffs two mappings (from `map` or the ia-qa.com browser snippet) and reports which selectors survived, which the runtime healer would recover, and which will hard-fail:
+   ```
+   ⛔  BLOCK
+      before.json → after.json  ·  3 ok · 2 healable · 1 lost · 2 new
+      🔧 healable  button "Se connecter"      button#login-btn → button.btn-primary (exact name)
+      ⛔ lost      button "Supprimer le compte"  button#delete → (no match)
+   ```
+   Exit codes for pipelines: `0` = PASS or FIX, `1` = BLOCK (add `--strict` to fail on FIX too), `2` = bad input. Use `--json` for machine-readable output. Same diff engine as the web tool (`src/browser/match.js`).
+
+   Every element carries a **context** (nearest landmark + section heading) so two elements with the same role + accessible name (five "Delete" buttons) stay distinguishable. The diff classifies each baseline element as `ok`, `renamed` (selector valid but the accessible name changed — a *content* drift to eyeball), `healable` (deterministic old→new rewrite), `ambiguous` (several equal matches — the tool **refuses to guess**, a human decides), or `lost` (no match).
+4. **`ia-qa-heal fix <before.json> <after.json> <test-paths…>`** — the deterministic half. Applies **only** the `healable` rewrites to your test files, replacing the selector only where it appears as a quoted string literal (`'…'`/`"…"`/`` `…` ``, quote-safe for attribute selectors), across any framework/language. LOST / AMBIGUOUS / RENAMED are printed but never touched — they need judgment. It **edits the working tree and never commits**: review with `git diff`, then push or discard. `--dry-run` previews the plan. This is "prepare the ground, the human decides" as a command.
+5. **Runtime healing** — in your Playwright tests:
+   ```ts
+   import { aiClick, aiFill } from '@ia-qa/self-healing';
+
+   await aiFill(page, 'input[name="email"]', user);
+   await aiClick(page, 'button#login');
+   ```
+   If the selector fails, the helper re-scans the live page, matches the element by role + accessible name (exact, then fuzzy Dice ≥ 0.6 — or your own `llmResolver`), retries on the healed selector, and logs a warning telling you to update the test and re-map.
+
+## Design notes
+
+- `page.accessibility.snapshot()` is deprecated **and returns no selectors**, so mapping walks the DOM directly and computes ARIA role + accname + a stable selector (`data-testid` → `id` → `name` → short structural path).
+- **Shared browser-safe core.** `src/browser/` holds plain, self-contained JS (no imports, no TS syntax) used by both the CLI and the ia-qa.com web tool: `extract.js` (DOM walk), `match.js` (semantic matching + mapping diff), `contract.js` (Markdown page-contract renderer). The CLI feeds `extractInPage` to Playwright's `page.evaluate()` and the healer re-runs it live; ia-qa.com imports `extract.js` with `?raw` to show it as a copy-paste DevTools snippet and imports `match.js`/`contract.js` directly. Result: the zero-install web flow produces byte-identical mappings, verdicts and `.md` contracts to `ia-qa-heal` (verified on the same page). Keep everything in `src/browser/` dependency-free or all consumers break.
+- Secrets: never written to disk. `env` reads `process.env`; `aws-ssm` calls `GetParameter` with decryption using the AWS SDK default credential chain (needs `ssm:GetParameter`, plus `kms:Decrypt` for SecureString).
+- `llmResolverStub` in `src/playwright/healer.ts` is the extension point for a real LLM/embedding-based resolver (e.g. via `POST https://www.ia-qa.com/mcp/call`).
+
+## Build & run
+
+```bash
+cd packages/self-healing
+npm run build          # tsc → dist/
+node dist/cli/index.js init
+node dist/cli/index.js map
+```
+
+`playwright` is a peer dependency — the consuming test project provides it (`npx playwright install chromium` if needed).

package/TUTORIAL.md

@@ -0,0 +1,399 @@
+# Self-healing tests — the complete beginner's guide
+
+**What this does, in one sentence:** it takes a photo of every button, link and field in your web app, so when a developer changes the UI and your tests break, you get a ready-to-review fix instead of a red pipeline and an afternoon of detective work.
+
+**You do not need to understand any of the internals to use it.** Follow the steps.
+
+---
+
+## Table of contents
+1. [Is this for me?](#1-is-this-for-me)
+2. [The 30-second mental model](#2-the-30-second-mental-model)
+3. [Before you start](#3-before-you-start)
+4. [Path A — I use an AI agent (easiest)](#4-path-a--i-use-an-ai-agent-easiest)
+5. [Path B — I use a terminal](#5-path-b--i-use-a-terminal)
+6. [Your first real workflow](#6-your-first-real-workflow-the-whole-point)
+7. [Reading the verdict](#7-reading-the-verdict)
+8. [Putting it in CI](#8-putting-it-in-ci)
+9. [Troubleshooting](#9-troubleshooting)
+10. [FAQ](#10-faq)
+
+---
+
+## 1. Is this for me?
+
+**Yes** if you have automated UI tests (Cypress, Playwright, Selenium, WebdriverIO — in any language) that break when the front-end changes.
+
+**No** if you only have unit tests or API tests. This tool is about UI selectors.
+
+It works on **your** app: `localhost`, a staging server, or an internal app behind a **VPN**. Everything runs on your machine. **Nothing is ever sent to ia-qa.com or anywhere else.**
+
+---
+
+## 2. The 30-second mental model
+
+Your test says "click `button#login`". A developer renames a CSS class, `button#login` no longer exists, your test fails. The button is still there — it's still the button that says *"Se connecter"*. Only its address changed.
+
+This tool:
+1. **Maps** your app → a *page contract*: every element listed as *role + name + where it lives + its current selector*.
+2. **Diffs** yesterday's contract against today's → tells you exactly what moved.
+3. **Fixes** the safe ones automatically, and **hands you the rest**.
+
+> 🛑 **The golden rule:** the tool **never** commits and **never** pushes. It prepares the change; **you** decide. A test that silently repairs itself is not a test.
+
+---
+
+## 3. Before you start
+
+You need **Node.js 18 or newer**. Check it:
+
+```bash
+node --version
+```
+
+If you get `v18.x.x` or higher (e.g. `v20.11.0`), you're good. If you get "command not found", install Node from [nodejs.org](https://nodejs.org) (take the "LTS" button) and reopen your terminal.
+
+That's the only prerequisite. A browser downloads automatically the first time — you don't have to do anything.
+
+### 💡 "I don't want to download another browser"
+
+Good news, usually you won't:
+
+- **If you already use Playwright** (your own tests, or the Playwright MCP), the browser is **already on your machine** and this tool reuses it. Playwright keeps one shared cache for the whole machine (`%LOCALAPPDATA%\ms-playwright` on Windows, `~/.cache/ms-playwright` on macOS/Linux). **Nothing extra is downloaded.**
+- **If you have Google Chrome or Edge installed**, you can use that instead and download *nothing at all*:
+
+  ```bash
+  # Windows (PowerShell)
+  $env:IAQA_BROWSER_CHANNEL = "chrome"
+  # macOS / Linux
+  export IAQA_BROWSER_CHANNEL=chrome
+  ```
+  (`msedge` also works. Or point at any browser: `IAQA_BROWSER_PATH=/path/to/chrome`.)
+
+  With an agent, just ask: **"Map my app at http://localhost:3000 using the chrome channel"**.
+
+- **If nothing is installed**, it downloads Chromium once (~150 MB) — the same thing any browser-automation tool does.
+
+Whatever it uses, it tells you: `Browser: system browser (channel "chrome")`.
+
+---
+
+## 4. Path A — I use an AI agent (easiest)
+
+*Use this if you have Claude Code, Claude Desktop, Cursor, or another MCP-compatible agent. You'll talk to your app in plain English.*
+
+### Step 4.1 — Add the tool to your agent
+
+Find your agent's MCP config file and add the `ia-qa-self-healing` block below.
+
+| Agent | Config file |
+|---|---|
+| **Claude Code** | run `claude mcp add` (or edit `.mcp.json` in your project) |
+| **Claude Desktop (Windows)** | `%APPDATA%\Claude\claude_desktop_config.json` |
+| **Claude Desktop (macOS)** | `~/Library/Application Support/Claude/claude_desktop_config.json` |
+| **Cursor** | `~/.cursor/mcp.json` |
+
+```json
+{
+  "mcpServers": {
+    "ia-qa-self-healing": {
+      "command": "npx",
+      "args": ["-y", "-p", "@ia-qa/self-healing", "ia-qa-heal-mcp"]
+    }
+  }
+}
+```
+
+> ⚠️ Copy it exactly — the `-p` matters. The package ships two commands (`ia-qa-heal` and `ia-qa-heal-mcp`), and `-p` is what tells `npx` which one to run. Without it, nothing starts.
+
+<details>
+<summary><b>Running from the source repo instead?</b> (click)</summary>
+
+If you cloned the repo rather than installing from npm:
+
+```bash
+cd packages/self-healing
+npm install
+npm run build
+```
+
+Then point the config at the built file (use the **absolute** path):
+
+```json
+{
+  "mcpServers": {
+    "ia-qa-self-healing": {
+      "command": "node",
+      "args": ["/absolute/path/to/packages/self-healing/dist/mcp/server.js"]
+    }
+  }
+}
+```
+</details>
+
+### Step 4.2 — Restart your agent
+
+Fully quit and reopen it. Otherwise it won't see the new tool.
+
+### Step 4.3 — Check it worked
+
+Ask your agent:
+
+> **"What ia-qa self-healing tools do you have?"**
+
+It should list three: `map_app`, `diff_mappings`, `fix_tests`. If it doesn't, jump to [Troubleshooting](#9-troubleshooting).
+
+### Step 4.4 — Map your first page 🎉
+
+Start your app (e.g. `npm start`, running on `http://localhost:3000`). Then say:
+
+> **"Map my app at http://localhost:3000 and save the contract to .ia-qa/mapping"**
+
+The agent launches a browser in the background and gives you back something like:
+
+```markdown
+# Page contract — home
+
+- **URL:** `http://localhost:3000`
+- **Interactive elements:** 12
+
+## button (3)
+
+| Accessible name | Context | Selector |
+| --- | --- | --- |
+| Se connecter    | main › Connexion | `button#login-btn` |
+| Valider         | main › Paiement  | `button[data-testid="pay"]` |
+```
+
+**That's your baseline.** Commit it — it lives in git like code:
+
+```bash
+git add .ia-qa/mapping
+git commit -m "Add page contract baseline"
+```
+
+### Step 4.5 — Map several pages
+
+Just ask:
+
+> **"Map these routes on http://localhost:3000: /, /login, /checkout, /account — save each to .ia-qa/mapping"**
+
+Or let it find them:
+
+> **"Look at my router config, list all the routes, then map them"**
+
+It will show you the route list and ask you to confirm before crawling. Say yes.
+
+---
+
+## 5. Path B — I use a terminal
+
+*Use this if you'd rather run commands, or you're setting up CI.*
+
+### Step 5.1 — Install
+
+```bash
+npm install -D @ia-qa/self-healing
+```
+
+### Step 5.2 — Configure once
+
+```bash
+npx ia-qa-heal init
+```
+
+It asks a few questions (your app's URL, whether there's a login, which pages to map) and writes `.ia-qa/config.json`.
+
+> 🔐 **Your password is never written to that file** — only the *name* of the environment variable that holds it.
+
+### Step 5.3 — Map
+
+```bash
+npx ia-qa-heal map
+```
+
+You get two files per page in `.ia-qa/mapping/`:
+- `checkout.json` — for the tools
+- `checkout.md` — for humans and AI
+
+Commit them.
+
+---
+
+## 6. Your first real workflow (the whole point)
+
+Here's the loop you'll actually live in.
+
+### Step 6.1 — You have a baseline
+From step 4.4 or 5.3, committed to git. Call it `checkout.baseline.json` (just copy it):
+
+```bash
+cp .ia-qa/mapping/checkout.json .ia-qa/mapping/checkout.baseline.json
+git add .ia-qa/mapping && git commit -m "baseline"
+```
+
+### Step 6.2 — Someone changes the UI
+A developer ships a redesign. Your tests start failing. **Normal.**
+
+### Step 6.3 — Re-map
+Agent: **"Re-map http://localhost:3000/checkout to .ia-qa/mapping"**
+Terminal: `npx ia-qa-heal map checkout`
+
+### Step 6.4 — See what moved
+Agent: **"Diff the baseline against the new contract"**
+Terminal:
+```bash
+npx ia-qa-heal diff .ia-qa/mapping/checkout.baseline.json .ia-qa/mapping/checkout.json
+```
+
+### Step 6.5 — Apply the safe fixes
+Agent: **"Fix my tests in the tests/ folder using that diff"**
+Terminal:
+```bash
+# Preview first — nothing is written
+npx ia-qa-heal fix .ia-qa/mapping/checkout.baseline.json .ia-qa/mapping/checkout.json tests/ --dry-run
+
+# Do it
+npx ia-qa-heal fix .ia-qa/mapping/checkout.baseline.json .ia-qa/mapping/checkout.json tests/
+```
+
+### Step 6.6 — You review. You decide.
+```bash
+git diff          # look at exactly what changed
+npm test          # re-run your tests
+```
+Happy? Commit and push. Not happy? `git checkout .` and nothing happened. **The tool never pushed anything.**
+
+---
+
+## 7. Reading the verdict
+
+You'll see one of three words. This is the whole product — learn these.
+
+| Verdict | Meaning | What you do |
+|---|---|---|
+| ✅ **PASS** | Nothing moved. | Nothing. Go home. |
+| 🔧 **FIX** | Selectors broke, but each has exactly one obvious replacement. | Run `fix`, review `git diff`, commit. |
+| ⛔ **BLOCK** | Something is **lost** or **ambiguous**. | Read below. A human is required. |
+
+And per element:
+
+| Status | Plain English | Auto-fixed? |
+|---|---|---|
+| **ok** | Unchanged. | — |
+| **renamed** | The selector still works, but the *label* changed ("Buy" → "Subscribe"). Your test still passes. | ❌ No — **look at it**. It might be a real product change your test should have caught. |
+| **healable** | The selector moved; the same element is clearly still there. | ✅ Yes |
+| **ambiguous** | Several elements match equally (five "Delete" buttons). | ❌ No — **the tool refuses to guess.** Healing the wrong one would make a broken test green. Add a `data-testid` to that element. |
+| **lost** | Gone. Nothing matches. | ❌ No — the element was removed or renamed beyond recognition. Fix or delete the test. |
+
+> 💡 **Why "ambiguous" refuses instead of picking:** a test that clicks the *wrong* Delete button and passes is worse than a test that fails. Failing is honest.
+
+---
+
+## 8. Putting it in CI
+
+The `diff` command returns an **exit code**, so your pipeline can gate on it:
+
+- `0` → PASS or FIX (tests will run)
+- `1` → BLOCK (a human must look)
+- `2` → bad input
+
+```yaml
+# .github/workflows/selector-drift.yml
+name: Selector drift
+on: [pull_request]
+
+jobs:
+  drift:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with: { node-version: '20' }
+      - run: npm ci
+      - run: npx playwright install --with-deps chromium
+
+      - name: Start the app
+        run: npm start &
+
+      - name: Re-map the app
+        run: npx ia-qa-heal map
+
+      - name: Fail if selectors drifted with no safe fix
+        run: npx ia-qa-heal diff .ia-qa/mapping/checkout.baseline.json .ia-qa/mapping/checkout.json
+```
+
+Add `--strict` if you want **FIX** to fail the build too (forces tests to be updated, not just healed).
+
+---
+
+## 9. Troubleshooting
+
+**"My agent doesn't see the tools"**
+- Did you fully quit and reopen the agent? (Not just close the window.)
+- Is the JSON valid? A trailing comma breaks it. Paste it into [jsonlint.com](https://jsonlint.com).
+- Using the source path? It must be **absolute** (`/Users/you/...` or `C:\\Users\\you\\...`), not `./dist`.
+
+**"It's downloading something huge the first time"**
+That's Chromium (~150 MB), once. Normal — any browser-automation tool does this. To avoid it entirely, reuse a browser you already have: set `IAQA_BROWSER_CHANNEL=chrome` (see [Before you start](#3-before-you-start)). If you already use Playwright anywhere, nothing is downloaded at all — the cache is shared.
+
+**"No usable browser found"**
+The error tells you the three ways out: `npx playwright install chromium`, or `IAQA_BROWSER_CHANNEL=chrome`, or `IAQA_BROWSER_PATH=/path/to/chrome`.
+
+**"The contract is half empty"**
+Your app is probably still loading when the snapshot is taken. Tell the agent:
+> "Map it again, but wait for the selector `#app-ready` first"
+
+Or in terminal, the app needs more time to settle — check the page really renders at that URL.
+
+**"It can't get past my login"**
+- Terminal: `ia-qa-heal init` sets up the login flow for you.
+- Agent: log in manually first, or ask it to log in step by step, then map.
+
+**"ERR_CONNECTION_REFUSED"**
+Your app isn't running at that URL. Start it first and open the URL in your own browser to check.
+
+**"0 elements found"**
+The page may be a canvas/WebGL app, or have no accessible elements. This tool needs real buttons, links and inputs. (If a screen reader can't use your app, neither can this — that's an accessibility bug worth fixing anyway.)
+
+---
+
+## 10. FAQ
+
+**Does my code or my app's content get sent anywhere?**
+No. Everything runs on your machine and writes local files. There is no network call to ia-qa.com. That's why it works behind a VPN.
+
+**Will it commit or push my code?**
+Never. It edits files in your working tree at most. You review with `git diff` and decide.
+
+**Do I need the Playwright MCP too?**
+No. This tool brings its own browser. One install, not two.
+
+**Cypress or Playwright or Selenium?**
+All of them, and any language. The `fix` command replaces the selector wherever it appears as a quoted string — that's the same in JavaScript, Python, Java, C#, Ruby.
+
+**Why is my "renamed" element not fixed automatically?**
+Because the selector still works — your test isn't broken. But the button now says something different, which might be a real change worth failing on. Only a human knows.
+
+**What's the `.md` file for?**
+It's the same contract, written for humans and AI. When a test breaks, hand your AI assistant the failing test **plus** that `.md` and ask it to fix the test — it has everything it needs, in any framework.
+
+**Can I run this against a public website?**
+Yes, any URL your machine can reach.
+
+---
+
+## Cheat sheet
+
+```bash
+npx ia-qa-heal init                       # one-time setup
+npx ia-qa-heal map                        # scan → .ia-qa/mapping/*.json + *.md
+npx ia-qa-heal diff before.json after.json    # verdict: PASS / FIX / BLOCK
+npx ia-qa-heal fix before.json after.json tests/ --dry-run   # preview
+npx ia-qa-heal fix before.json after.json tests/             # apply (never commits)
+```
+
+Talking to an agent instead:
+> "Map my app at http://localhost:3000 to .ia-qa/mapping"
+> "Diff the baseline against the new contract"
+> "Fix my tests in tests/ — show me the diff, don't commit"

package/dist/aom.d.ts

@@ -0,0 +1,22 @@
+import type { Page } from 'playwright';
+/**
+ * Mapping I/O. The extraction itself lives in `browser/extract.js` — it is plain
+ * self-contained JS because Playwright serializes it into the page and the web
+ * tool on ia-qa.com serves the same file as a copy-paste DevTools snippet.
+ */
+export interface MappedElement {
+    role: string;
+    name: string;
+    selector: string;
+    /** Disambiguating container hint: nearest landmark + section heading. May be empty. */
+    context?: string;
+}
+export interface PageMapping {
+    page: string;
+    url: string;
+    capturedAt: string;
+    elements: MappedElement[];
+}
+export declare function extractInteractiveElements(page: Page): Promise<MappedElement[]>;
+export declare function saveMapping(mapping: PageMapping, dir?: string): string;
+export declare function loadMapping(pageName: string, dir?: string): PageMapping;

package/dist/aom.js

@@ -0,0 +1,58 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractInteractiveElements = extractInteractiveElements;
+exports.saveMapping = saveMapping;
+exports.loadMapping = loadMapping;
+const fs = __importStar(require("fs"));
+const config_1 = require("./config");
+const extract_1 = require("./browser/extract");
+async function extractInteractiveElements(page) {
+    return page.evaluate(extract_1.extractInPage);
+}
+function saveMapping(mapping, dir = (0, config_1.mappingDir)()) {
+    fs.mkdirSync(dir, { recursive: true });
+    const file = (0, config_1.mappingPath)(mapping.page, dir);
+    fs.writeFileSync(file, JSON.stringify(mapping, null, 2) + '\n', 'utf8');
+    return file;
+}
+function loadMapping(pageName, dir = (0, config_1.mappingDir)()) {
+    const file = (0, config_1.mappingPath)(pageName, dir);
+    if (!fs.existsSync(file)) {
+        throw new Error(`No mapping found for page "${pageName}" (${file}). Run \`ia-qa-heal map ${pageName}\` first.`);
+    }
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+//# sourceMappingURL=aom.js.map

package/dist/aom.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aom.js","sourceRoot":"","sources":["../src/aom.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,gEAEC;AAED,kCAKC;AAED,kCAQC;AA7CD,uCAAyB;AAEzB,qCAAmD;AACnD,+CAAkD;AAuB3C,KAAK,UAAU,0BAA0B,CAAC,IAAU;IACzD,OAAO,IAAI,CAAC,QAAQ,CAAC,uBAAa,CAA6B,CAAC;AAClE,CAAC;AAED,SAAgB,WAAW,CAAC,OAAoB,EAAE,MAAc,IAAA,mBAAU,GAAE;IAC1E,EAAE,CAAC,SAAS,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IACvC,MAAM,IAAI,GAAG,IAAA,oBAAW,EAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;IAC5C,EAAE,CAAC,aAAa,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,GAAG,IAAI,EAAE,MAAM,CAAC,CAAC;IACxE,OAAO,IAAI,CAAC;AACd,CAAC;AAED,SAAgB,WAAW,CAAC,QAAgB,EAAE,MAAc,IAAA,mBAAU,GAAE;IACtE,MAAM,IAAI,GAAG,IAAA,oBAAW,EAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;IACxC,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;QACzB,MAAM,IAAI,KAAK,CACb,8BAA8B,QAAQ,MAAM,IAAI,2BAA2B,QAAQ,WAAW,CAC/F,CAAC;IACJ,CAAC;IACD,OAAO,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,CAAgB,CAAC;AAClE,CAAC"}

package/dist/browser/contract.d.ts

@@ -0,0 +1 @@
+export function renderPageContract(mapping: any): string;