constella 0.1.0

package/skills/stacks/testing/jasmine/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: jasmine
+description: Jasmine is a dependency-free behavior-driven JavaScript testing framework for browsers and Node.js with built-in matchers, spies, and async support; consult when writing describe/it specs, using expect matchers and spies, testing async code, or running standalone browser and Node suites.
+domain: stack
+category: testing
+tags: [jasmine, javascript, bdd, node, browser-testing, spies, unit-testing]
+official_sources:
+  - https://jasmine.github.io/
+  - https://github.com/jasmine/jasmine
+  - https://jasmine.github.io/pages/getting_started.html
+verified: 2026-06-17
+---
+
+# Jasmine
+
+## Overview
+Jasmine is a behavior-driven development (BDD) framework for testing JavaScript that has no dependencies on any other framework and needs no DOM. It runs in browsers and Node.js with the same clean `describe`/`it`/`expect` syntax, bundling matchers, spies, clocks, and async helpers out of the box. Read this when writing unit specs, spying on functions, controlling time, or testing asynchronous code without extra assertion libraries.
+
+## Official sources
+- Docs: https://jasmine.github.io/
+- Repo: https://github.com/jasmine/jasmine
+- Install: https://jasmine.github.io/pages/getting_started.html
+
+## Install / setup
+```bash
+npm install --save-dev jasmine
+```
+Source: https://jasmine.github.io/setup/nodejs.html (run `npx jasmine init` to scaffold config, then `npx jasmine`).
+
+## Core concepts
+- **`describe` / `it`** — group specs and define expectations in readable BDD style.
+- **`expect` + matchers** — built-in `toBe`, `toEqual`, `toContain`, `toThrow`, and custom matchers.
+- **Spies** — `spyOn` and `jasmine.createSpy` stub and record function calls and returns.
+- **Setup/teardown** — `beforeEach`/`afterEach`/`beforeAll`/`afterAll` manage shared state.
+- **Async support** — return a promise, `await`, or use the `done` callback.
+- **Clock** — `jasmine.clock()` fakes `setTimeout`/`Date` for deterministic timing.
+- **Configuration** — `spec/support/jasmine.json` defines spec dirs, helpers, and patterns.
+- **Standalone runner** — a browser distribution runs specs without Node tooling.
+
+## Best practices
+- Use `beforeEach` to reset state so specs stay independent (https://jasmine.github.io/tutorials/your_first_suite).
+- Prefer specific matchers and write custom ones for clarity (https://jasmine.github.io/tutorials/custom_matchers).
+- Spy on collaborators rather than calling real side effects (https://jasmine.github.io/tutorials/your_first_suite).
+- Use the clock for time-dependent code instead of real delays (https://jasmine.github.io/tutorials/your_first_suite).
+
+## Common pitfalls
+- Async spec finishes before assertions run → return the promise or call `done()`.
+- Forgetting to install the clock makes timer tests flaky → `jasmine.clock().install()`/`uninstall()`.
+- Shared mutable state leaks across specs → re-initialize in `beforeEach`.
+
+## Examples
+```js
+describe('A suite', () => {
+  it('contains a spec with an expectation', () => {
+    expect(true).toBe(true);
+  });
+});
+```
+
+## Further reading
+- https://jasmine.github.io/tutorials/your_first_suite — first suite walkthrough
+- https://jasmine.github.io/api/edge/global — global matcher and spy API
+
+## Related skills
+- ../mocha — flexible runner needing a separate assertion library
+- ../jest — Jasmine-derived framework with snapshots and built-in mocking
+- ../vitest — Vite-native runner with a Jest-style API

package/skills/stacks/testing/jest/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: jest
+description: Jest is a zero-config JavaScript/TypeScript testing framework with a built-in runner, assertions, mocking, snapshots, and coverage; consult when writing or debugging unit tests, mocking modules, snapshot testing, or configuring jest.config for Babel/TS/React/Vue/Node projects.
+domain: stack
+category: testing
+tags: [jest, javascript, typescript, unit-testing, mocking, snapshot, node]
+official_sources:
+  - https://jestjs.io/docs/getting-started
+  - https://github.com/jestjs/jest
+  - https://www.npmjs.com/package/jest
+verified: 2026-06-17
+---
+
+# Jest
+
+## Overview
+Jest is a JavaScript testing framework focused on simplicity that works out of the box on most projects (Babel, TypeScript, Node, React, Angular, Vue). It bundles a test runner, `expect` assertions, mocking, snapshot testing, and coverage in one tool. Read this when writing unit/integration tests, mocking modules or timers, debugging snapshot mismatches, or configuring Jest for a JS/TS codebase.
+
+## Official sources
+- Docs: https://jestjs.io/docs/getting-started
+- Repo: https://github.com/jestjs/jest
+- Install: https://www.npmjs.com/package/jest
+
+## Install / setup
+```bash
+npm install --save-dev jest
+```
+Source: https://jestjs.io/docs/getting-started (install via your package manager, then run with `npx jest`).
+
+## Core concepts
+- **`test` / `it`** — declare a test; pair with a `describe` block to group related cases.
+- **`expect` matchers** — `toBe`, `toEqual`, `toContain`, `toThrow`, etc. drive assertions.
+- **Snapshot testing** — `toMatchSnapshot()` serializes output to `__snapshots__` and diffs on rerun.
+- **Mock functions** — `jest.fn()`, `jest.spyOn()`, and `jest.mock()` replace dependencies and record calls.
+- **Setup/teardown** — `beforeEach`/`afterEach`/`beforeAll`/`afterAll` manage shared fixtures.
+- **Fake timers** — `jest.useFakeTimers()` controls `setTimeout`/`Date` for deterministic time-based tests.
+- **Parallelism** — tests run in isolated worker processes; use `--runInBand` to debug serially.
+- **Coverage** — add `--coverage` to emit reports with no extra setup.
+
+## Best practices
+- Keep tests isolated and deterministic; reset mocks with `clearMocks: true` (https://jestjs.io/docs/configuration).
+- Prefer explicit matchers over generic `toBe` so failures read clearly (https://jestjs.io/docs/expect).
+- Review snapshots in code review and regenerate intentionally with `--ci`/`-u` (https://jestjs.io/docs/snapshot-testing).
+- Mock only external boundaries (network, fs, time); test real logic (https://jestjs.io/docs/mock-functions).
+
+## Common pitfalls
+- Async test passes despite a failed promise → `return`/`await` the promise or use `resolves`/`rejects`.
+- Stale snapshots hide regressions → run `jest -u` only after verifying the change is intended.
+- Leaked timers/handles hang the run → use fake timers and `--detectOpenHandles`.
+
+## Examples
+```js
+const sum = require('./sum');
+
+test('adds 1 + 2 to equal 3', () => {
+  expect(sum(1, 2)).toBe(3);
+});
+```
+
+## Further reading
+- https://jestjs.io/docs/cli — full CLI flag reference
+- https://jestjs.io/docs/configuration — `jest.config.js` options
+
+## Related skills
+- ../vitest — Vite-native alternative with a Jest-compatible API
+- ../mocha — flexible runner often paired with a separate assertion library
+- ../jasmine — BDD framework Jest's API descends from

package/skills/stacks/testing/mocha/SKILL.md

@@ -0,0 +1,71 @@
+---
+name: mocha
+description: Mocha is a flexible JavaScript test framework for Node.js and the browser that runs tests serially with rich async support and pluggable assertions/reporters; consult when structuring describe/it suites, choosing an assertion library like Chai, testing async code, or configuring .mocharc.
+domain: stack
+category: testing
+tags: [mocha, javascript, node, test-runner, bdd, async, chai]
+official_sources:
+  - https://mochajs.org/
+  - https://github.com/mochajs/mocha
+  - https://mochajs.org/getting-started/
+verified: 2026-06-17
+---
+
+# Mocha
+
+## Overview
+Mocha is a feature-rich JavaScript test framework that runs on Node.js and in the browser, making asynchronous testing simple. It provides the test structure (`describe`/`it`), hooks, and reporters but leaves assertions to a library of your choice (commonly Chai). Tests run serially for accurate reporting and correct mapping of uncaught exceptions. Read this when organizing suites, testing promises/callbacks, picking reporters, or configuring Mocha.
+
+## Official sources
+- Docs: https://mochajs.org/
+- Repo: https://github.com/mochajs/mocha
+- Install: https://mochajs.org/getting-started/
+
+## Install / setup
+```bash
+npm install --save-dev mocha
+```
+Source: https://mochajs.org/getting-started/ (Mocha 11.x — current latest, 11.7.x — requires Node.js `^18.18.0 || ^20.9.0 || >=21.1.0`; the upcoming v12, still in beta, will require `^20.19.0 || >=22.12.0`; run with `npx mocha`).
+
+## Core concepts
+- **`describe` / `it`** — group suites and declare individual test cases (BDD-style).
+- **Hooks** — `before`, `after`, `beforeEach`, `afterEach` set up and tear down state.
+- **Async support** — return a promise, `await`, or call the `done` callback to test async code.
+- **Pluggable assertions** — bring Chai, Node's `assert`, or another library; Mocha ships none.
+- **Reporters** — `spec`, `dot`, `tap`, `json`, etc. format results via `--reporter`.
+- **Exclusivity/skip** — `.only` and `.skip` focus or omit suites and tests.
+- **Configuration** — `.mocharc.{js,json,yml}` sets specs, timeouts, requires, and flags.
+- **Browser support** — runs the same tests in browsers alongside Node.
+
+## Best practices
+- Use `--require` to load Babel/TS or setup hooks consistently (https://mochajs.org/interfaces/require/).
+- Set realistic timeouts per slow test rather than globally inflating them (https://mochajs.org/features/timeouts/).
+- Avoid arrow functions when you need Mocha's `this` context for timeouts (https://mochajs.org/features/arrow-functions/).
+- Return promises instead of mixing `done` with async/await (https://mochajs.org/features/asynchronous-code/).
+
+## Common pitfalls
+- Calling `done()` and returning a promise both → pick one async style, not both.
+- Arrow-function tests break `this.timeout()` → use `function () { ... }`.
+- Unhandled rejection passes silently → always `await`/return the async assertion.
+
+## Examples
+```js
+const assert = require('assert');
+
+describe('Array', () => {
+  describe('#indexOf()', () => {
+    it('returns -1 when the value is not present', () => {
+      assert.equal([1, 2, 3].indexOf(4), -1);
+    });
+  });
+});
+```
+
+## Further reading
+- https://mochajs.org/running/cli/ — CLI flags and config
+- https://www.chaijs.com/ — Chai assertion library commonly paired with Mocha
+
+## Related skills
+- ../jasmine — batteries-included BDD framework with built-in assertions
+- ../jest — all-in-one runner with bundled assertions and mocking
+- ../vitest — Vite-native runner with a Jest-style API

package/skills/stacks/testing/playwright/SKILL.md

@@ -0,0 +1,68 @@
+---
+name: playwright
+description: Playwright is a Microsoft framework for cross-browser web testing and automation across Chromium, Firefox, and WebKit with auto-waiting, tracing, and parallel execution; consult when writing E2E tests, using locators and web-first assertions, generating tests with codegen, or configuring playwright.config.
+domain: stack
+category: testing
+tags: [playwright, e2e, cross-browser, automation, typescript, web-testing, microsoft]
+official_sources:
+  - https://playwright.dev/docs/intro
+  - https://github.com/microsoft/playwright
+  - https://www.npmjs.com/package/playwright
+verified: 2026-06-17
+---
+
+# Playwright
+
+## Overview
+Playwright is a framework for web testing and automation that drives Chromium, Firefox, and WebKit through a single API, with bindings for Node.js, Python, Java, and .NET. Its test runner adds auto-waiting locators, web-first assertions, isolated browser contexts, tracing, and parallelism. Read this when writing cross-browser E2E tests, recording tests with codegen, debugging flakiness with traces, or configuring projects/devices.
+
+## Official sources
+- Docs: https://playwright.dev/docs/intro
+- Repo: https://github.com/microsoft/playwright
+- Install: https://www.npmjs.com/package/playwright
+
+## Install / setup
+```bash
+npm init playwright@latest
+```
+Source: https://playwright.dev/docs/intro (scaffolds config, examples, and installs browsers; add browsers later with `npx playwright install --with-deps`).
+
+## Core concepts
+- **Locators** — `page.getByRole`/`getByText`/`locator()` are lazy and auto-retry until actionable.
+- **Web-first assertions** — `expect(locator).toBeVisible()` polls until the condition holds or times out.
+- **Browser contexts** — lightweight isolated sessions give each test fresh cookies/storage in parallel.
+- **Fixtures** — the test runner injects `page`, `context`, `request`, and custom fixtures per test.
+- **Auto-waiting** — actions wait for elements to be visible, stable, and enabled before acting.
+- **Trace viewer** — `--trace on` records DOM, network, and actions for post-mortem debugging.
+- **Codegen** — `npx playwright codegen` records interactions into runnable test code.
+- **Projects** — config matrix runs the same suite across browsers, devices, and viewports.
+
+## Best practices
+- Prefer role/label/text locators over CSS/XPath for resilient, user-facing tests (https://playwright.dev/docs/locators).
+- Use web-first `expect` assertions instead of manual waits (https://playwright.dev/docs/test-assertions).
+- Keep tests isolated via contexts; share auth state with `storageState` (https://playwright.dev/docs/auth).
+- Enable traces/retries in CI to triage flakes (https://playwright.dev/docs/test-retries).
+
+## Common pitfalls
+- Manual `waitForTimeout` sleeps → rely on auto-waiting locators and `expect` polling.
+- Brittle CSS selectors break on markup changes → use `getByRole`/`getByTestId`.
+- Forgetting `await` on actions/assertions → every Playwright call returns a promise.
+
+## Examples
+```ts
+import { test, expect } from '@playwright/test';
+
+test('has title', async ({ page }) => {
+  await page.goto('https://playwright.dev/');
+  await expect(page).toHaveTitle(/Playwright/);
+});
+```
+
+## Further reading
+- https://playwright.dev/docs/test-configuration — `playwright.config` and projects
+- https://playwright.dev/docs/trace-viewer — debugging with traces
+
+## Related skills
+- ../cypress — in-browser E2E alternative with a time-travel debugger
+- ../selenium — WebDriver-standard automation across many languages
+- ../puppeteer — lower-level Chrome/Firefox control library

package/skills/stacks/testing/puppeteer/SKILL.md

@@ -0,0 +1,70 @@
+---
+name: puppeteer
+description: Puppeteer is a Node.js library providing a high-level API to control Chrome or Firefox via DevTools Protocol or WebDriver BiDi for automation, scraping, PDFs, and headless testing; consult when launching browsers, navigating pages, evaluating DOM, intercepting requests, or capturing screenshots.
+domain: stack
+category: testing
+tags: [puppeteer, headless-chrome, automation, node, scraping, devtools-protocol, screenshots]
+official_sources:
+  - https://pptr.dev/guides/getting-started
+  - https://github.com/puppeteer/puppeteer
+  - https://pptr.dev/guides/installation
+verified: 2026-06-17
+---
+
+# Puppeteer
+
+## Overview
+Puppeteer is a JavaScript library that provides a high-level API to control Chrome or Firefox over the DevTools Protocol or WebDriver BiDi. It runs headless by default and is used for browser automation, end-to-end testing, scraping, generating PDFs/screenshots, and pre-rendering. Read this when launching and driving a browser, navigating and evaluating pages, intercepting network traffic, or capturing rendered output from Node.js.
+
+## Official sources
+- Docs: https://pptr.dev/guides/getting-started
+- Repo: https://github.com/puppeteer/puppeteer
+- Install: https://pptr.dev/guides/installation
+
+## Install / setup
+```bash
+npm i puppeteer
+```
+Source: https://pptr.dev/guides/installation (downloads a compatible Chrome for Testing; use `puppeteer-core` to skip the browser download).
+
+## Core concepts
+- **Browser / Page** — `puppeteer.launch()` opens a browser; `browser.newPage()` creates tabs.
+- **Navigation** — `page.goto()` with `waitUntil` controls load completion.
+- **`page.evaluate`** — runs functions in the page context to read or manipulate the DOM.
+- **Selectors & waits** — `page.waitForSelector()`, `$`, and `$$` locate elements reliably.
+- **Request interception** — `page.setRequestInterception(true)` to block, mock, or modify requests.
+- **Screenshots & PDFs** — `page.screenshot()` and `page.pdf()` capture rendered output.
+- **Headless modes** — runs headless by default; pass `headless: false` to watch interactively.
+- **Chrome for Testing** — a pinned browser auto-downloaded for reproducible automation.
+
+## Best practices
+- Always `await browser.close()` (use try/finally) to avoid leaked processes (https://pptr.dev/guides/getting-started).
+- Wait on selectors/network, not arbitrary timeouts, before interacting (https://pptr.dev/guides/page-interactions).
+- Use `puppeteer-core` plus a managed browser in CI/Docker (https://pptr.dev/guides/installation).
+- Keep page-context code in `evaluate` pure; it is serialized and cannot close over Node vars (https://pptr.dev/guides/evaluate-javascript).
+
+## Common pitfalls
+- `evaluate` callback can't see outer variables → pass them as `evaluate` arguments.
+- Acting before the element exists → `await page.waitForSelector()` first.
+- Forgetting to close the browser leaks Chrome processes → close in a `finally` block.
+
+## Examples
+```js
+import puppeteer from 'puppeteer';
+
+const browser = await puppeteer.launch();
+const page = await browser.newPage();
+await page.goto('https://example.com');
+const title = await page.title();
+console.log(title);
+await browser.close();
+```
+
+## Further reading
+- https://pptr.dev/api — full Page/Browser API reference
+- https://pptr.dev/guides/request-interception — mocking and blocking requests
+
+## Related skills
+- ../playwright — multi-browser successor with a built-in test runner and auto-waiting
+- ../selenium — WebDriver-standard automation across many languages
+- ../cypress — in-browser E2E testing framework

package/skills/stacks/testing/selenium/SKILL.md

@@ -0,0 +1,70 @@
+---
+name: selenium
+description: Selenium WebDriver is the W3C-standard browser-automation API for controlling real browsers across Java, Python, C#, Ruby, and JavaScript; consult when writing cross-browser UI tests, locating elements, handling waits/frames/windows, or running tests with Selenium Grid and WebDriver drivers.
+domain: stack
+category: testing
+tags: [selenium, webdriver, browser-automation, e2e, cross-browser, grid, ui-testing]
+official_sources:
+  - https://www.selenium.dev/documentation/webdriver/getting_started/
+  - https://github.com/SeleniumHQ/selenium
+  - https://www.selenium.dev/documentation/webdriver/getting_started/install_library/
+verified: 2026-06-17
+---
+
+# Selenium
+
+## Overview
+Selenium WebDriver is a language-neutral API and W3C protocol for driving real browsers (Chrome, Firefox, Edge, Safari) programmatically. It has official bindings for Java, Python, C#, Ruby, JavaScript, and Kotlin, and scales out via Selenium Grid. Read this when automating cross-browser UI tests, locating and interacting with elements, handling explicit waits, frames, and alerts, or distributing runs across machines.
+
+## Official sources
+- Docs: https://www.selenium.dev/documentation/webdriver/getting_started/
+- Repo: https://github.com/SeleniumHQ/selenium
+- Install: https://www.selenium.dev/documentation/webdriver/getting_started/install_library/
+
+## Install / setup
+```bash
+pip install selenium
+```
+Source: https://www.selenium.dev/documentation/webdriver/getting_started/install_library/ (Java uses the Maven `org.seleniumhq.selenium:selenium-java` dependency; drivers are auto-managed by Selenium Manager).
+
+## Core concepts
+- **WebDriver** — the session object that launches and commands a browser per the W3C protocol.
+- **Locators** — `By.id`, `By.cssSelector`, `By.xpath`, etc. find elements on the page.
+- **WebElement** — handle for an element you can `click()`, `send_keys()`, or read text from.
+- **Explicit waits** — `WebDriverWait` + expected conditions poll until an element is ready.
+- **Selenium Manager** — built-in tool that downloads matching browser drivers automatically.
+- **Selenium Grid** — runs tests remotely and in parallel across browsers/OSes via a hub/nodes.
+- **Frames & windows** — `switch_to.frame()` / `switch_to.window()` change the driver's focus.
+- **Actions API** — chains advanced keyboard/mouse interactions (hover, drag, key combos).
+
+## Best practices
+- Use explicit waits over `sleep`; avoid deprecated implicit+explicit mixing (https://www.selenium.dev/documentation/webdriver/waits/).
+- Prefer stable locators (id, name, data attributes) over brittle XPath (https://www.selenium.dev/documentation/webdriver/elements/locators/).
+- Always `driver.quit()` to release the browser and driver process (https://www.selenium.dev/documentation/webdriver/drivers/).
+- Apply the Page Object pattern to isolate selectors from test logic (https://www.selenium.dev/documentation/test_practices/encouraged/page_object_models/).
+
+## Common pitfalls
+- `NoSuchElementException` on dynamic pages → wait with `WebDriverWait` + expected conditions.
+- Mixing implicit and explicit waits causes unpredictable timeouts → use explicit waits only.
+- Stale element after DOM re-render → re-find the element instead of reusing the handle.
+
+## Examples
+```python
+from selenium import webdriver
+from selenium.webdriver.common.by import By
+
+driver = webdriver.Chrome()
+driver.get("https://www.selenium.dev/")
+assert "Selenium" in driver.title
+driver.find_element(By.CSS_SELECTOR, "a.navbar-brand")
+driver.quit()
+```
+
+## Further reading
+- https://www.selenium.dev/documentation/webdriver/waits/ — waiting strategies
+- https://www.selenium.dev/documentation/grid/ — distributing tests with Grid
+
+## Related skills
+- ../playwright — modern auto-waiting cross-browser alternative
+- ../cypress — in-browser JavaScript E2E framework
+- ../puppeteer — Chrome/Firefox DevTools-Protocol automation

package/skills/stacks/testing/vitest/SKILL.md

@@ -0,0 +1,68 @@
+---
+name: vitest
+description: Vitest is a Vite-native, Jest-compatible testing framework with instant HMR-style watch, ESM/TS support, and built-in coverage; consult when testing Vite/Vue/React/Svelte projects, migrating from Jest, configuring vitest.config, or using in-source and browser-mode testing.
+domain: stack
+category: testing
+tags: [vitest, vite, javascript, typescript, unit-testing, esm, vue]
+official_sources:
+  - https://vitest.dev/guide/
+  - https://github.com/vitest-dev/vitest
+  - https://www.npmjs.com/package/vitest
+verified: 2026-06-17
+---
+
+# Vitest
+
+## Overview
+Vitest is a next-generation testing framework powered by Vite that reuses your app's Vite config and transform pipeline for native ESM, TypeScript, and JSX support. Its API is largely Jest-compatible (`describe`/`it`/`expect`), with a fast smart-watch mode. Read this when adding tests to a Vite-based project, migrating from Jest, configuring coverage, or setting up jsdom/browser environments.
+
+## Official sources
+- Docs: https://vitest.dev/guide/
+- Repo: https://github.com/vitest-dev/vitest
+- Install: https://www.npmjs.com/package/vitest
+
+## Install / setup
+```bash
+npm install -D vitest
+```
+Source: https://vitest.dev/guide/ (add a `"test": "vitest"` script, then run `npm run test`).
+
+## Core concepts
+- **Vite-powered** — reuses `vite.config` plugins/resolve/aliases, so tests transform code like the app does.
+- **Jest-compatible API** — `describe`, `it`/`test`, `expect`, `vi.fn()`/`vi.mock()` ease migration.
+- **Smart watch** — reruns only tests affected by changed modules via the module graph.
+- **Environments** — `node`, `jsdom`, or `happy-dom` per file via `// @vitest-environment` or config.
+- **In-source testing** — colocate tests inside source using `import.meta.vitest`.
+- **Coverage** — `--coverage` backed by v8 or istanbul providers.
+- **`vi` utility** — mocks, spies, fake timers, and module stubbing namespace.
+- **Browser mode** — run component tests in a real browser via the experimental browser runner.
+
+## Best practices
+- Share one config: import the app's Vite plugins so tests resolve identically (https://vitest.dev/config/).
+- Pick the lightest environment per suite; default `node` is fastest (https://vitest.dev/guide/environment).
+- Use `vi.mock` hoisting awareness and `vi.resetAllMocks()` between tests (https://vitest.dev/api/vi).
+- Enable `globals: true` only if you want Jest-style implicit globals (https://vitest.dev/config/#globals).
+
+## Common pitfalls
+- Forgetting `await` on async expectations → use `await expect(p).resolves` / `.rejects`.
+- `vi.mock` not applied → it is hoisted; keep factory pure and import the mocked module after.
+- Tests pass in Jest but fail here on ESM → rely on Vite resolution, not Jest's CJS transforms.
+
+## Examples
+```ts
+import { expect, test } from 'vitest';
+import { sum } from './sum';
+
+test('adds 1 + 2 to equal 3', () => {
+  expect(sum(1, 2)).toBe(3);
+});
+```
+
+## Further reading
+- https://vitest.dev/api/ — full test and `expect` API
+- https://vitest.dev/guide/migration — migrating from Jest
+
+## Related skills
+- ../jest — the framework Vitest's API mirrors
+- ../cypress — pairs with Vitest for E2E coverage above unit tests
+- ../playwright — browser-level E2E to complement Vitest unit tests