@webhands/core 0.1.0 → 1.0.0

package/dist/cookies-export.d.ts

@@ -2,8 +2,8 @@
  * The `cookies export` / `cookies import` verb's FILE FORMAT (PRD story 11).
  *
  * The seam already carries the transport-neutral cookie primitives:
- * {@link Page.cookies} reads the active context's cookies and
- * {@link Page.setCookies} loads cookies into it. The export/import VERB is built
+ * {@link WebHandsPage.cookies} reads the active context's cookies and
+ * {@link WebHandsPage.setCookies} loads cookies into it. The export/import VERB is built
  * ON TOP of those two methods (the forward-note: refine the existing seam,
  * do NOT add a parallel cookie path). What this module adds is only the
  * SERIALIZATION the verb needs to move a session to/from disk: how a
@@ -31,11 +31,11 @@ export declare const COOKIES_EXPORT_VERSION: 1;
 export interface CookiesExport {
     /** Format version (see {@link COOKIES_EXPORT_VERSION}). */
     readonly version: typeof COOKIES_EXPORT_VERSION;
-    /** The exported cookies, exactly as the seam's {@link Page.cookies} returns them. */
+    /** The exported cookies, exactly as the seam's {@link WebHandsPage.cookies} returns them. */
     readonly cookies: readonly Cookie[];
 }
 /**
- * Serialize the cookies read from the seam ({@link Page.cookies}) into the
+ * Serialize the cookies read from the seam ({@link WebHandsPage.cookies}) into the
  * export file's text. Pretty-printed JSON so a human can read/diff a backed-up
  * session. This is pure: it does NO disk I/O, so the caller (the CLI verb, a
  * test) owns WHERE the file lands — which is what lets a test keep its export
@@ -44,7 +44,7 @@ export interface CookiesExport {
 export declare function serializeCookies(cookies: readonly Cookie[]): string;
 /**
  * Parse an export file's text back into the cookies to hand to the seam's
- * {@link Page.setCookies} ({@link parse} is pure; the caller does the disk read
+ * {@link WebHandsPage.setCookies} ({@link parse} is pure; the caller does the disk read
  * and the `setCookies` call). Rejects anything that is not a recognised export
  * envelope so a corrupt or wrong-version file surfaces as a clear error rather
  * than silently importing nothing or a half-parsed list.

package/dist/cookies-export.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cookies-export.d.ts","sourceRoot":"","sources":["../src/cookies-export.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,WAAW,CAAC;AAEtC;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,EAAG,CAAU,CAAC;AAEjD;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC7B,2DAA2D;IAC3D,QAAQ,CAAC,OAAO,EAAE,OAAO,sBAAsB,CAAC;IAChD,qFAAqF;IACrF,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAMnE;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAyBlE"}
+{"version":3,"file":"cookies-export.d.ts","sourceRoot":"","sources":["../src/cookies-export.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,WAAW,CAAC;AAEtC;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,EAAG,CAAU,CAAC;AAEjD;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC7B,2DAA2D;IAC3D,QAAQ,CAAC,OAAO,EAAE,OAAO,sBAAsB,CAAC;IAChD,6FAA6F;IAC7F,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAMnE;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAyBlE"}

package/dist/cookies-export.js

@@ -2,8 +2,8 @@
  * The `cookies export` / `cookies import` verb's FILE FORMAT (PRD story 11).
  *
  * The seam already carries the transport-neutral cookie primitives:
- * {@link Page.cookies} reads the active context's cookies and
- * {@link Page.setCookies} loads cookies into it. The export/import VERB is built
+ * {@link WebHandsPage.cookies} reads the active context's cookies and
+ * {@link WebHandsPage.setCookies} loads cookies into it. The export/import VERB is built
  * ON TOP of those two methods (the forward-note: refine the existing seam,
  * do NOT add a parallel cookie path). What this module adds is only the
  * SERIALIZATION the verb needs to move a session to/from disk: how a
@@ -23,7 +23,7 @@
  */
 export const COOKIES_EXPORT_VERSION = 1;
 /**
- * Serialize the cookies read from the seam ({@link Page.cookies}) into the
+ * Serialize the cookies read from the seam ({@link WebHandsPage.cookies}) into the
  * export file's text. Pretty-printed JSON so a human can read/diff a backed-up
  * session. This is pure: it does NO disk I/O, so the caller (the CLI verb, a
  * test) owns WHERE the file lands — which is what lets a test keep its export
@@ -38,7 +38,7 @@ export function serializeCookies(cookies) {
 }
 /**
  * Parse an export file's text back into the cookies to hand to the seam's
- * {@link Page.setCookies} ({@link parse} is pure; the caller does the disk read
+ * {@link WebHandsPage.setCookies} ({@link parse} is pure; the caller does the disk read
  * and the `setCookies` call). Rejects anything that is not a recognised export
  * envelope so a corrupt or wrong-version file surfaces as a clear error rather
  * than silently importing nothing or a half-parsed list.

package/dist/hand-host.d.ts

@@ -0,0 +1,217 @@
+import { type BrowserContext, type Page } from 'playwright';
+import type { WebHandsPage, WaitCondition } from './seam.js';
+/**
+ * The hand-host primitive (Phase 1 of the "hands" prd,
+ * `work/prds/tasked/hands-pluggable-page-capabilities.md`).
+ *
+ * A **hand** is in-process code that closes over the WebHandsPage and contributes named
+ * verbs (+ an optional `dispose`). This module is the host: it builds the
+ * scoped-but-LIVE {@link HandContext} from the live Playwright objects, lets
+ * each hand contribute its verbs, and composes them into the same {@link WebHandsPage}
+ * object the seam already exposes (see {@link composePage}).
+ *
+ * webhands' OWN eight verbs are themselves built-in hands over this host
+ * ({@link BUILT_IN_HANDS}), so the primitive is proven by self-application: if
+ * it can express webhands' `click`/`snapshot`/`cookies`, it can host a
+ * third-party hand the same way (Phase 2). This is a purely INTERNAL,
+ * behavior-preserving refactor — the verb composition that lived as a
+ * duplicated `page` object literal in BOTH Playwright transports now lives here
+ * once.
+ *
+ * INTERNAL-ONLY BOUNDARY (the prd's resolved Q2): this whole module is
+ * package-internal. {@link Hand}/{@link HandContext}/{@link composePage} are
+ * NOT exported from the package entry point (`index.ts`) in Phase 1; they go
+ * public in the separate Phase 2 task. The public seam (`seam.ts`) is
+ * unchanged.
+ *
+ * NO-LEAK / CROSS-BROWSER (ADR-0003, refined by the prd): the host is built
+ * INSIDE the Playwright transport(s) and uses only the Playwright
+ * `Page`/`BrowserContext` API — no CDP/Chromium-only types — so the live
+ * `pwPage` stays in-process and never crosses the seam, and the host introduces
+ * no Chromium-only dependency that would foreclose a future Firefox launch
+ * (only CDP-`attach` stays Chromium-bound, as today).
+ *
+ * TRUST MODEL (stated, not enforced here): hands are trusted, local, in-process
+ * peers with ZERO isolation between them (one live page, one process).
+ * Inter-hand reuse is ordinary Node composition (import & call), NOT a
+ * sibling-hand registry in the context — so {@link HandContext} carries live
+ * page access only.
+ */
+/**
+ * The scoped-but-LIVE access a hand receives. It carries live page access ONLY
+ * (the trust model note above): the real Playwright {@link Page} and
+ * {@link BrowserContext} the hand operates against in-process, plus the
+ * lifecycle guard.
+ *
+ * - `pwPage` — the live Node-side Playwright `Page`. NEVER crosses the seam.
+ * - `context` — the live `BrowserContext`; the built-in `cookies`/`setCookies`
+ *   hand proves it is needed (cookies are a context-level, not page-level,
+ *   concern).
+ * - `ensureOpen` — the per-session lifecycle guard. Each verb calls it first so
+ *   a verb invoked after the session closed rejects with `session is closed`
+ *   (the seam's lifetime contract). The guard's "closed" state is owned by the
+ *   per-transport session wiring (launch vs attach differ); the host only reads
+ *   it through this function.
+ */
+export interface HandContext {
+    readonly pwPage: Page;
+    readonly context: BrowserContext;
+    readonly ensureOpen: () => void;
+}
+/**
+ * What a hand contributes once given its {@link HandContext}: a set of named
+ * verbs (a subset of webhands' (eight) seam verbs, i.e. a `Partial` of the
+ * seam {@link WebHandsPage}) and an optional `dispose` for any in-process
+ * resource it set up.
+ *
+ * A hand may contribute several verbs (the built-in interaction hand contributes
+ * both `click` and `type`) — a hand is NOT a single verb. It is NOT a transport
+ * either: it does not `open` sessions. Nothing more than this is allowed (no
+ * lifecycle hooks, no event handlers, no MCP-definition objects) — those are
+ * either the transport's job (session lifecycle) or a later phase's.
+ */
+export interface HandContribution {
+    readonly verbs: Partial<WebHandsPage>;
+    readonly dispose?: () => Promise<void> | void;
+}
+/**
+ * A hand: a capability MODULE that, given live page access, contributes verbs.
+ * It is a plain factory function so a hand is just ordinary in-process Node
+ * code closing over the {@link HandContext} — the exact shape webhands' own
+ * verbs already had, made explicit.
+ */
+export type Hand = (ctx: HandContext) => HandContribution;
+/**
+ * The composed result the host hands back to a transport's session wiring: the
+ * {@link WebHandsPage} (the seam object the verbs were merged into) and a single
+ * `dispose` that tears down every hand.
+ */
+export interface ComposedHands {
+    readonly page: WebHandsPage;
+    /**
+     * Dispose every hand's resources. Hands are disposed in REVERSE registration
+     * order (LIFO, the natural teardown order for layered setup), and every
+     * hand's `dispose` is awaited even if an earlier one rejects, so one failing
+     * hand cannot strand another's cleanup. This disposes the HANDS only; tearing
+     * down the browser/context (and the order relative to this) is the
+     * per-transport session lifecycle's job, NOT the host's.
+     */
+    dispose(): Promise<void>;
+}
+/**
+ * Compose a set of hands over one live {@link HandContext} into a single
+ * {@link WebHandsPage}. This is the host primitive both Playwright transports call to
+ * build their session's verb surface — the SINGLE shared composition (no
+ * duplicated page-object literal).
+ *
+ * Composition is EAGER (exactly as the page object literal was built before):
+ * each hand is invoked once at session-open time and its verbs are merged into
+ * one page object. There is no lazy registration and no ordering effect on the
+ * verbs themselves (the eight built-in verbs have disjoint names). The returned
+ * {@link WebHandsPage} is validated to carry every verb the seam requires, so a missing
+ * built-in verb is a build-time/open-time failure here rather than an `undefined
+ * is not a function` at the call site.
+ */
+export declare function composePage(ctx: HandContext, hands: readonly Hand[]): ComposedHands;
+/** The `navigate` verb: go to a URL and let it settle on the `load` event. */
+export declare const navigationHand: Hand;
+/** The `snapshot` verb: the token-cheap a11y view, or `--full` raw DOM. */
+export declare const snapshotHand: Hand;
+/** The `click` + `type` verbs: page interaction by raw locator (ADR-0004). */
+export declare const interactionHand: Hand;
+/** The `eval` escape hatch: run a JS EXPRESSION in the page, return by value. */
+export declare const evalHand: Hand;
+/** The `wait` verb: pace actions by a condition (timeout/locator/navigation). */
+export declare const waitHand: Hand;
+/**
+ * The `cookies` + `setCookies` verbs. These prove the {@link HandContext} needs
+ * the `context`: cookies are a context-level, not page-level, concern, so this
+ * hand reaches `ctx.context`, not `ctx.pwPage`.
+ */
+export declare const cookiesHand: Hand;
+/**
+ * webhands' eight built-in verbs as built-in hands, in composition order. Both
+ * Playwright transports compose THIS exact set, so the verb surface is
+ * identical across launch and attach (the only legitimate difference is the
+ * per-transport SESSION LIFECYCLE, which is not a hand's concern).
+ */
+export declare const BUILT_IN_HANDS: readonly Hand[];
+/**
+ * Compose webhands' built-in hands over a live context into the seam's
+ * {@link WebHandsPage}. The convenience both transports call: `composePage(ctx,
+ * BUILT_IN_HANDS)`. The built-in hands set up no in-process resources, so the
+ * returned `dispose` is a no-op today; it exists so a transport can sequence
+ * hand-teardown before its own browser/context teardown once third-party hands
+ * (which may hold resources) are added in Phase 2.
+ */
+export declare function composeBuiltInPage(ctx: HandContext): ComposedHands;
+/**
+ * Compose webhands' built-in hands together with any explicitly-loaded
+ * third-party hands (Phase 2) over a live context. The third-party hands are
+ * composed AFTER the built-ins through the EXACT same {@link composePage} the
+ * built-ins use, so a loaded hand plugs into the same host: its verbs merge into
+ * the same seam {@link WebHandsPage} and its `dispose` is sequenced LIFO with the rest.
+ * A third-party hand may add NEW verbs (the common case) and, because later
+ * contributions win the merge, may also override a built-in verb — that is the
+ * operator's choice, made by the trust act of naming the hand (ADR-0007).
+ */
+export declare function composeWithHands(ctx: HandContext, extraHands: readonly Hand[]): ComposedHands;
+/**
+ * Run the `wait` verb's three forms (PRD story 10) against a Playwright page.
+ *
+ * - `timeout` — pace by a fixed delay (`waitForTimeout`), so an agent can act
+ *   like a human and let XHR-rendered content land.
+ * - `locator` — block until the addressed element appears (`Locator.waitFor()`),
+ *   the form for content rendered AFTER `goto` settled on `load`.
+ * - `navigation` — block until the NEXT navigation settles to `load`. We use
+ *   `waitForNavigation()` even though Playwright marks it `@deprecated` ("racy,
+ *   use waitForURL"): that deprecation targets in-process TEST code that can arm
+ *   the wait BEFORE the action and pass a target URL. Neither holds here. Across
+ *   this seam verbs are DISCRETE sequential calls (`click` then `wait`), so we
+ *   CANNOT arm before the trigger; and the realistic trigger is an async,
+ *   JS-driven transition (a redirect / SPA route change that fires AFTER the
+ *   agent's action, the "let XHR-rendered content load" case of story 10), so
+ *   "wait for the NEXT navigation" is exactly right — whereas `waitForLoadState`
+ *   would see the already-loaded current page and return before the pending
+ *   transition. `waitForURL` is unusable because the verb has no target URL by
+ *   design (the agent waits for "a navigation", not a known address). (See the
+ *   task's ## Decisions note.)
+ *
+ * Shared by both Playwright transports (via the `wait` built-in hand) so the
+ * verb behaviour stays identical (no parallel second implementation).
+ */
+export declare function waitFor(page: Page, condition: WaitCondition): Promise<void>;
+/**
+ * Resolve a raw Playwright locator EXPRESSION (ADR-0004) against the page. The
+ * verb surface passes locator expressions like `getByRole('button', …)`; we
+ * evaluate them in a small sandbox where `page`/`p` is the page, so the full
+ * Playwright locator grammar is available without leaking the type across the
+ * seam.
+ *
+ * One resolution path for both transports (via the built-in interaction/wait
+ * hands), so there is no parallel addressing scheme.
+ */
+export declare function resolveLocator(page: Page, expression: string): import("playwright").Locator;
+/**
+ * Run the `click` verb against a Playwright page (PRD story 8), shared by both
+ * Playwright transports (via the built-in interaction hand) so the verb behaves
+ * identically (mirrors {@link waitFor}; no parallel second implementation).
+ *
+ * First try a normal `Locator.click()`, which AUTO-WAITS for the element to be
+ * visible and actionable — the right behaviour for a real button. A hidden
+ * custom input (the case the prd calls out) NEVER becomes actionable, so that
+ * click times out; on a Playwright `TimeoutError` we fall back to
+ * `dispatchEvent('click')`, which fires a click WITHOUT the actionability
+ * checks. The fallback is deliberately the documented Playwright escape (a
+ * sibling to the `eval` hatch, ADR-0004), not a reimplemented click: we keep
+ * the locator a raw resolved expression and only change HOW the resolved
+ * locator is clicked.
+ *
+ * Only a timeout triggers the fallback. The fallback `dispatchEvent` is itself
+ * bounded by the same short timeout, so a locator that resolves NO element (a
+ * bad locator) surfaces its timeout quickly instead of hanging the dispatch on
+ * Playwright's 30s default — the dispatch escape is for elements that EXIST but
+ * are not actionable (hidden custom inputs), not for absent ones.
+ */
+export declare function clickLocator(page: Page, expression: string): Promise<void>;
+//# sourceMappingURL=hand-host.d.ts.map

package/dist/hand-host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hand-host.d.ts","sourceRoot":"","sources":["../src/hand-host.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,KAAK,cAAc,EAAE,KAAK,IAAI,EAAC,MAAM,YAAY,CAAC;AAC9E,OAAO,KAAK,EAEX,YAAY,EAGZ,aAAa,EACb,MAAM,WAAW,CAAC;AAEnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,WAAW;IAC3B,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;IACjC,QAAQ,CAAC,UAAU,EAAE,MAAM,IAAI,CAAC;CAChC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,gBAAgB;IAChC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC;IACtC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CAC9C;AAED;;;;;GAKG;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,GAAG,EAAE,WAAW,KAAK,gBAAgB,CAAC;AAE1D;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC7B,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B;;;;;;;OAOG;IACH,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAC1B,GAAG,EAAE,WAAW,EAChB,KAAK,EAAE,SAAS,IAAI,EAAE,GACpB,aAAa,CAgCf;AAsDD,8EAA8E;AAC9E,eAAO,MAAM,cAAc,EAAE,IAe3B,CAAC;AAEH,2EAA2E;AAC3E,eAAO,MAAM,YAAY,EAAE,IAyBzB,CAAC;AAEH,8EAA8E;AAC9E,eAAO,MAAM,eAAe,EAAE,IAW5B,CAAC;AAEH,iFAAiF;AACjF,eAAO,MAAM,QAAQ,EAAE,IAoBrB,CAAC;AAEH,iFAAiF;AACjF,eAAO,MAAM,QAAQ,EAAE,IAOrB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAE,IAYxB,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,cAAc,EAAE,SAAS,IAAI,EAOzC,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,WAAW,GAAG,aAAa,CAElE;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC/B,GAAG,EAAE,WAAW,EAChB,UAAU,EAAE,SAAS,IAAI,EAAE,GACzB,aAAa,CAEf;AAOD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,OAAO,CAC5B,IAAI,EAAE,IAAI,EACV,SAAS,EAAE,aAAa,GACtB,OAAO,CAAC,IAAI,CAAC,CAaf;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,gCAO5D;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,YAAY,CACjC,IAAI,EAAE,IAAI,EACV,UAAU,EAAE,MAAM,GAChB,OAAO,CAAC,IAAI,CAAC,CAYf"}

package/dist/hand-host.js

@@ -0,0 +1,351 @@
+import { errors as pwErrors } from 'playwright';
+/**
+ * Compose a set of hands over one live {@link HandContext} into a single
+ * {@link WebHandsPage}. This is the host primitive both Playwright transports call to
+ * build their session's verb surface — the SINGLE shared composition (no
+ * duplicated page-object literal).
+ *
+ * Composition is EAGER (exactly as the page object literal was built before):
+ * each hand is invoked once at session-open time and its verbs are merged into
+ * one page object. There is no lazy registration and no ordering effect on the
+ * verbs themselves (the eight built-in verbs have disjoint names). The returned
+ * {@link WebHandsPage} is validated to carry every verb the seam requires, so a missing
+ * built-in verb is a build-time/open-time failure here rather than an `undefined
+ * is not a function` at the call site.
+ */
+export function composePage(ctx, hands) {
+    const verbs = {};
+    const disposers = [];
+    for (const hand of hands) {
+        const contribution = hand(ctx);
+        Object.assign(verbs, contribution.verbs);
+        if (contribution.dispose !== undefined) {
+            disposers.push(contribution.dispose);
+        }
+    }
+    const page = assertCompletePage(verbs);
+    return {
+        page,
+        async dispose() {
+            // LIFO teardown; await every disposer even if one rejects so a single
+            // failing hand cannot strand the others' cleanup.
+            const failures = [];
+            for (let i = disposers.length - 1; i >= 0; i--) {
+                try {
+                    await disposers[i]();
+                }
+                catch (cause) {
+                    failures.push(cause);
+                }
+            }
+            if (failures.length > 0) {
+                throw failures[0];
+            }
+        },
+    };
+}
+/** The seam's full verb set; used to validate a composed page is complete. */
+const REQUIRED_VERBS = [
+    'navigate',
+    'snapshot',
+    'click',
+    'type',
+    'eval',
+    'wait',
+    'cookies',
+    'setCookies',
+];
+/**
+ * Assert the composed verbs cover the whole seam {@link WebHandsPage}, then return it
+ * as a `WebHandsPage`. A gap here means a built-in hand was dropped from the
+ * composition — surfacing it at open time is far cheaper than a runtime
+ * `undefined is not a function`.
+ */
+function assertCompletePage(verbs) {
+    const missing = REQUIRED_VERBS.filter((name) => typeof verbs[name] !== 'function');
+    if (missing.length > 0) {
+        throw new Error(`hand-host: composed page is missing verb(s): ${missing.join(', ')}`);
+    }
+    return verbs;
+}
+/**
+ * How long a normal, actionability-checked `click` may wait before we treat the
+ * element as un-clickable and fall back to a dispatched click. Short on purpose:
+ * a hidden custom input never becomes actionable, so the regular click would
+ * otherwise burn Playwright's full default timeout (30s) before the escape path
+ * runs. The visible-element happy path clicks immediately and never hits this;
+ * this bound is the latency cost paid ONLY on the hidden/non-actionable path,
+ * and is long enough to tolerate a slow-but-eventually-actionable element
+ * (animations, late layout) before deciding to dispatch.
+ */
+const NORMAL_CLICK_TIMEOUT_MS = 1_000;
+// ---------------------------------------------------------------------------
+// Built-in hands: webhands' OWN eight verbs, each a hand over the host.
+//
+// Grouped into cohesive capability modules (navigation, snapshot, interaction,
+// eval, wait, cookies) to demonstrate that a hand can contribute several verbs
+// + in-process logic (it is NOT one-verb-per-hand). The verb BODIES are moved
+// verbatim from the two transports' page-object literals, so behavior is
+// preserved byte-for-byte (the existing verb suite is the proof).
+// ---------------------------------------------------------------------------
+/** The `navigate` verb: go to a URL and let it settle on the `load` event. */
+export const navigationHand = ({ pwPage, ensureOpen }) => ({
+    verbs: {
+        async navigate(url) {
+            ensureOpen();
+            // "Settled" for `goto` = the `load` event: the document and its
+            // subresources have loaded (PRD story 6, "navigate ... and wait for it
+            // to settle"). We deliberately do NOT wait for `networkidle`:
+            // Playwright discourages it, and it hangs forever on pages with
+            // long-poll / streaming / analytics beacons (exactly the logged-in apps
+            // this tool targets). Content rendered AFTER load (XHR-injected prices,
+            // hydrated lists) is the job of the explicit `wait` verb (story 10), not
+            // of `goto`.
+            await pwPage.goto(url, { waitUntil: 'load' });
+        },
+    },
+});
+/** The `snapshot` verb: the token-cheap a11y view, or `--full` raw DOM. */
+export const snapshotHand = ({ pwPage, ensureOpen }) => ({
+    verbs: {
+        async snapshot(options) {
+            ensureOpen();
+            const url = pwPage.url();
+            if (options?.full === true) {
+                // `--full`: the raw DOM. `documentElement.outerHTML` is the serialized
+                // live DOM (post-script render), which is what an agent that wants the
+                // real HTML expects — not the original network response.
+                const content = await pwPage.evaluate(() => document.documentElement.outerHTML);
+                return { url, view: 'full', content };
+            }
+            // Default: the token-cheap accessibility tree + visible text with stable
+            // `[ref=...]` element refs. Playwright's `ariaSnapshot({mode: 'ai'})`
+            // emits exactly that — a YAML aria tree (roles + accessible names +
+            // text) where each node carries a stable `[ref=eN]` reference, assigned
+            // deterministically by traversal order so re-snapshotting an unchanged
+            // page yields the same refs. The string crosses the seam as opaque,
+            // transport-neutral text (no Playwright type leaks, ADR-0003).
+            const content = await pwPage.ariaSnapshot({ mode: 'ai' });
+            return { url, view: 'accessibility', content };
+        },
+    },
+});
+/** The `click` + `type` verbs: page interaction by raw locator (ADR-0004). */
+export const interactionHand = ({ pwPage, ensureOpen }) => ({
+    verbs: {
+        async click(t) {
+            ensureOpen();
+            await clickLocator(pwPage, t);
+        },
+        async type(t, text) {
+            ensureOpen();
+            await resolveLocator(pwPage, t).fill(text);
+        },
+    },
+});
+/** The `eval` escape hatch: run a JS EXPRESSION in the page, return by value. */
+export const evalHand = ({ pwPage, ensureOpen }) => ({
+    verbs: {
+        async eval(expression) {
+            ensureOpen();
+            // The `eval` escape hatch (PRD story 9): run the raw JS EXPRESSION in the
+            // page and return its serializable result. Playwright's `evaluate`
+            // already IS the seam's serialization contract (see {@link WebHandsPage.eval}):
+            // it passes a string as an expression, awaits a returned Promise, and
+            // structurally clones the result out of the page by VALUE. That clone is
+            // richer than JSON: it preserves NaN/Infinity/BigInt and circular
+            // structures (back-refs become a `[Circular]` marker), yields `undefined`
+            // for functions/symbols, and returns an opaque preview string for a live
+            // host object (a DOM node never crosses the process boundary). A page-side
+            // throw rejects. We pass it straight through rather than re-encode it:
+            // wrapping the value in a transport-specific envelope would invent a
+            // dialect the seam deliberately avoids. The thrown error is a plain
+            // `Error`, so no Playwright/CDP type leaks across the seam (ADR-0003).
+            return pwPage.evaluate(expression);
+        },
+    },
+});
+/** The `wait` verb: pace actions by a condition (timeout/locator/navigation). */
+export const waitHand = ({ pwPage, ensureOpen }) => ({
+    verbs: {
+        async wait(condition) {
+            ensureOpen();
+            await waitFor(pwPage, condition);
+        },
+    },
+});
+/**
+ * The `cookies` + `setCookies` verbs. These prove the {@link HandContext} needs
+ * the `context`: cookies are a context-level, not page-level, concern, so this
+ * hand reaches `ctx.context`, not `ctx.pwPage`.
+ */
+export const cookiesHand = ({ context, ensureOpen }) => ({
+    verbs: {
+        async cookies() {
+            ensureOpen();
+            const raw = await context.cookies();
+            return raw.map(toSeamCookie);
+        },
+        async setCookies(cookies) {
+            ensureOpen();
+            await context.addCookies(cookies.map(fromSeamCookie));
+        },
+    },
+});
+/**
+ * webhands' eight built-in verbs as built-in hands, in composition order. Both
+ * Playwright transports compose THIS exact set, so the verb surface is
+ * identical across launch and attach (the only legitimate difference is the
+ * per-transport SESSION LIFECYCLE, which is not a hand's concern).
+ */
+export const BUILT_IN_HANDS = [
+    navigationHand,
+    snapshotHand,
+    interactionHand,
+    evalHand,
+    waitHand,
+    cookiesHand,
+];
+/**
+ * Compose webhands' built-in hands over a live context into the seam's
+ * {@link WebHandsPage}. The convenience both transports call: `composePage(ctx,
+ * BUILT_IN_HANDS)`. The built-in hands set up no in-process resources, so the
+ * returned `dispose` is a no-op today; it exists so a transport can sequence
+ * hand-teardown before its own browser/context teardown once third-party hands
+ * (which may hold resources) are added in Phase 2.
+ */
+export function composeBuiltInPage(ctx) {
+    return composePage(ctx, BUILT_IN_HANDS);
+}
+/**
+ * Compose webhands' built-in hands together with any explicitly-loaded
+ * third-party hands (Phase 2) over a live context. The third-party hands are
+ * composed AFTER the built-ins through the EXACT same {@link composePage} the
+ * built-ins use, so a loaded hand plugs into the same host: its verbs merge into
+ * the same seam {@link WebHandsPage} and its `dispose` is sequenced LIFO with the rest.
+ * A third-party hand may add NEW verbs (the common case) and, because later
+ * contributions win the merge, may also override a built-in verb — that is the
+ * operator's choice, made by the trust act of naming the hand (ADR-0007).
+ */
+export function composeWithHands(ctx, extraHands) {
+    return composePage(ctx, [...BUILT_IN_HANDS, ...extraHands]);
+}
+// ---------------------------------------------------------------------------
+// Shared verb building blocks (moved here with the verb bodies they back).
+// Re-exported from the launch transport for its existing public-API consumers.
+// ---------------------------------------------------------------------------
+/**
+ * Run the `wait` verb's three forms (PRD story 10) against a Playwright page.
+ *
+ * - `timeout` — pace by a fixed delay (`waitForTimeout`), so an agent can act
+ *   like a human and let XHR-rendered content land.
+ * - `locator` — block until the addressed element appears (`Locator.waitFor()`),
+ *   the form for content rendered AFTER `goto` settled on `load`.
+ * - `navigation` — block until the NEXT navigation settles to `load`. We use
+ *   `waitForNavigation()` even though Playwright marks it `@deprecated` ("racy,
+ *   use waitForURL"): that deprecation targets in-process TEST code that can arm
+ *   the wait BEFORE the action and pass a target URL. Neither holds here. Across
+ *   this seam verbs are DISCRETE sequential calls (`click` then `wait`), so we
+ *   CANNOT arm before the trigger; and the realistic trigger is an async,
+ *   JS-driven transition (a redirect / SPA route change that fires AFTER the
+ *   agent's action, the "let XHR-rendered content load" case of story 10), so
+ *   "wait for the NEXT navigation" is exactly right — whereas `waitForLoadState`
+ *   would see the already-loaded current page and return before the pending
+ *   transition. `waitForURL` is unusable because the verb has no target URL by
+ *   design (the agent waits for "a navigation", not a known address). (See the
+ *   task's ## Decisions note.)
+ *
+ * Shared by both Playwright transports (via the `wait` built-in hand) so the
+ * verb behaviour stays identical (no parallel second implementation).
+ */
+export async function waitFor(page, condition) {
+    switch (condition.kind) {
+        case 'timeout':
+            await page.waitForTimeout(condition.ms);
+            return;
+        case 'locator':
+            await resolveLocator(page, condition.target).waitFor();
+            return;
+        case 'navigation':
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            await page.waitForNavigation();
+            return;
+    }
+}
+/**
+ * Resolve a raw Playwright locator EXPRESSION (ADR-0004) against the page. The
+ * verb surface passes locator expressions like `getByRole('button', …)`; we
+ * evaluate them in a small sandbox where `page`/`p` is the page, so the full
+ * Playwright locator grammar is available without leaking the type across the
+ * seam.
+ *
+ * One resolution path for both transports (via the built-in interaction/wait
+ * hands), so there is no parallel addressing scheme.
+ */
+export function resolveLocator(page, expression) {
+    // eslint-disable-next-line no-new-func
+    const factory = new Function('page', 'p', `return (${expression});`);
+    return factory(page, page);
+}
+/**
+ * Run the `click` verb against a Playwright page (PRD story 8), shared by both
+ * Playwright transports (via the built-in interaction hand) so the verb behaves
+ * identically (mirrors {@link waitFor}; no parallel second implementation).
+ *
+ * First try a normal `Locator.click()`, which AUTO-WAITS for the element to be
+ * visible and actionable — the right behaviour for a real button. A hidden
+ * custom input (the case the prd calls out) NEVER becomes actionable, so that
+ * click times out; on a Playwright `TimeoutError` we fall back to
+ * `dispatchEvent('click')`, which fires a click WITHOUT the actionability
+ * checks. The fallback is deliberately the documented Playwright escape (a
+ * sibling to the `eval` hatch, ADR-0004), not a reimplemented click: we keep
+ * the locator a raw resolved expression and only change HOW the resolved
+ * locator is clicked.
+ *
+ * Only a timeout triggers the fallback. The fallback `dispatchEvent` is itself
+ * bounded by the same short timeout, so a locator that resolves NO element (a
+ * bad locator) surfaces its timeout quickly instead of hanging the dispatch on
+ * Playwright's 30s default — the dispatch escape is for elements that EXIST but
+ * are not actionable (hidden custom inputs), not for absent ones.
+ */
+export async function clickLocator(page, expression) {
+    const target = resolveLocator(page, expression);
+    try {
+        await target.click({ timeout: NORMAL_CLICK_TIMEOUT_MS });
+    }
+    catch (cause) {
+        if (!(cause instanceof pwErrors.TimeoutError)) {
+            throw cause;
+        }
+        // The element never became actionable (e.g. a hidden custom input). Fire
+        // the click without actionability checks, the prd's explicit escape path.
+        await target.dispatchEvent('click', { timeout: NORMAL_CLICK_TIMEOUT_MS });
+    }
+}
+/** Map a Playwright cookie to the transport-neutral seam {@link Cookie}. */
+function toSeamCookie(c) {
+    return {
+        name: c.name,
+        value: c.value,
+        domain: c.domain,
+        path: c.path,
+        expires: c.expires,
+        httpOnly: c.httpOnly,
+        secure: c.secure,
+        sameSite: c.sameSite,
+    };
+}
+/** Map a seam {@link Cookie} to a Playwright cookie shape. */
+function fromSeamCookie(c) {
+    return {
+        name: c.name,
+        value: c.value,
+        domain: c.domain,
+        path: c.path,
+        expires: c.expires,
+        httpOnly: c.httpOnly,
+        secure: c.secure,
+        sameSite: c.sameSite,
+    };
+}
+//# sourceMappingURL=hand-host.js.map

package/dist/hand-host.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hand-host.js","sourceRoot":"","sources":["../src/hand-host.ts"],"names":[],"mappings":"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"}