@harnessed-ts/resolve 0.0.0-stage → 0.7.0

package/CHANGELOG.md

@@ -0,0 +1,95 @@
+# @harnessed-ts/resolve
+
+## 0.7.0
+
+### Minor Changes
+
+- ec06bdf: Vue, Solid, Svelte and Angular join React and Ember as conformance-tested UI frameworks, and node:test, Bun and Nightwatch join the runners.
+
+  New packages: `@harnessed-ts/nightwatch` drives Nightwatch 3 through the injected resolver, under Nightwatch's own runner and its Mocha runner, in end-to-end and component tests (`@nightwatch/react`, `@nightwatch/vue`), with cross-origin frames. `@harnessed-ts/angular` drives zoneless Angular 21+: every action settles at `fixture.whenStable()`, or at the `ApplicationRef`'s for an app bootstrapped without TestBed, and `goto()` drives a provided router.
+
+  `@harnessed-ts/core/register` loads TypeScript harnesses under `node --import`: esbuild strips the types, lowers standard decorators and `accessor`, and compiles JSX. `@harnessed-ts/core/bun` does the same as a `bun test` preload, so harnesses keep the standard decorator protocol whatever `experimentalDecorators` the tsconfig sets.
+
+  `@harnessed-ts/dom/matchers/bun` registers the matchers with `bun:test`. The dom driver runs on happy-dom too: it focuses the frames leading to an interaction's target, finds a frame's `<iframe>` where `frameElement` is unset, and reads a select's selection off `options`.
+
+  `@harnessed-ts/resolve/webdriver` holds the WebDriver half of injected resolution, shared by the WebdriverIO and Nightwatch drivers. `@harnessed-ts/gherkin/nightwatch` adapts the cucumber-js world to Nightwatch's Cucumber runner.
+
+  `@harnessed-ts/playwright`, and `@harnessed-ts/cypress` under `realEvents`, give the page a task after every action, so a read straight after it sees what a framework that renders on a timer (zoneless Angular) has rendered. The injectable resolver installs on the page's `window` rather than the script's global, which under Firefox's WebDriver is a sandbox in front of it.
+
+  `@harnessed-ts/conformance` exports `fixtureParity()`, the per-view parity check a port of the fixture to another framework runs, naming the first place its markup parts from the React original; it detects a simulated DOM from the DOM's own window.
+
+  `@harnessed-ts/eslint-plugin` recognises Nightwatch's, Angular's and Vue Test Utils' raw queries, and looks in `nightwatch/` by default. `npx @harnessed-ts/claude install` detects Angular, Nightwatch, node:test and Bun.
+
+### Patch Changes
+
+- Updated dependencies [ec06bdf]
+  - @harnessed-ts/core@0.7.0
+
+## 0.6.0
+
+### Minor Changes
+
+- e324e94: ember-test-selectors style test ids: `configure({ testIdAttribute: 'data-test-*' })` makes `testId('x')` match any element that has the attribute `data-test-x`, whatever its value, with the same scoping, strictness, `{ global: true }`, frame and absence rules as before under every driver. A plain attribute name keeps matching by value. A presence id is held to letters, digits, `-`, `_`, `.` and `:`, and anything else (or a `RegExp`) is refused rather than spliced into a selector.
+
+  `Query.boundingBox()` resolves to `{ x, y, width, height }`: the target's border box in CSS pixels, relative to the top-level viewport, offset by every frame crossed. Strict, and on an absent target it rejects after the timeout, as `text()` does. A node that draws no box reads as all zeros, and so does every node under the dom driver: jsdom computes no layout.
+
+  `Query.upload(files)` sets the files of an `<input type="file">`, or of the input a `<label>` is for, and fires `input` and `change`, replacing any earlier selection. It refuses any other element, and several files for an input that is not `multiple`. Puppeteer, WebdriverIO and TestCafe take only paths, so there each `File` is written to a temporary directory first: its name and bytes arrive, and the browser infers its type from the extension.
+
+  `Query` gains two abstract members, so a driver outside this repo implements both to keep compiling; the conformance catalog pins all three changes.
+
+  `@harnessed-ts/eslint-plugin` supports ESLint 8.57 and legacy `.eslintrc`: the peer range is now `>=8.57`, `legacy-recommended` and `legacy-strict` name the rules under `@harnessed-ts/`, and the CJS build exposes `rules` and `configs` at the top level, where eslintrc reads them.
+
+  `npx @harnessed-ts/claude install` detects ember-test-selectors attributes (in `.gts`, `.gjs` and `.hbs` files too) and writes `testIdAttribute: 'data-test-*'`.
+
+  `@harnessed-ts/storybook` writes and finds its story-ready marker under a `data-test-*` config, where `StoryPage` waits for it.
+
+### Patch Changes
+
+- Updated dependencies [e324e94]
+  - @harnessed-ts/core@0.6.0
+
+## 0.5.0
+
+### Patch Changes
+
+- @harnessed-ts/core@0.5.0
+
+## 0.4.0
+
+### Minor Changes
+
+- 9666a3d: New package `@harnessed-ts/resolve`: the selector resolver the Testing Library driver has always used, extracted so every driver that can run JavaScript in the page shares it — role with `level`, strictness, absence, and frame semantics come from one implementation. Adds non-waiting forms (`resolveOneNow`, `resolveAllNow`) for runtimes that retry on their own, and `@harnessed-ts/resolve/inject`, a self-contained build a remote driver (WebdriverIO, Puppeteer, TestCafe) injects into the page, with `encodeSelector` to carry `RegExp`s across the wire.
+
+  `@harnessed-ts/dom` now depends on it. No behaviour change.
+
+- 9666a3d: Add `isVisibleInLayout(element, home?)`, Playwright's visibility rule — a non-empty box that `visibility` does not hide, inside frames that are visible too — for in-page drivers running in a real browser. The injected page API answers it too, as `visible(element)`, for drivers that resolve from outside the page. The main entry no longer imports Node's `url` and `path` through a chunk shared with `/inject`, so it loads in a browser.
+- 1823546: `isVisible()`, `waitFor('visible')` and `waitFor('hidden')` on a target matching
+  several nodes now reject with the shared strict-mode violation, at once, under
+  every driver. The dom, Ember, Vitest browser mode and Cypress drivers answered
+  `false` from `isVisible()`, waited out the timeout in `waitFor('visible')`, and —
+  worse — resolved `waitFor('hidden')` at once, passing a wait for three rendered
+  nodes to disappear; Playwright's waits raised its own wording instead of the
+  shared one. An `nth()`
+  past the last match answers `false` from `isVisible()` and counts as hidden, as it
+  does under Playwright — Puppeteer and TestCafe used to reject it as an index out
+  of range.
+
+  Core exports `StrictModeViolation`, the class `strictViolation()` now returns, so a
+  driver can tell ambiguity apart from absence. It is the class a caller catches
+  under every driver: core also exports `reviveStrictViolation()`, which the
+  Puppeteer, WebdriverIO and TestCafe drivers apply to what the page throws, so
+  a violation raised in the page arrives as core's class, worded exactly as an
+  in-process driver words it. `instanceof StrictModeViolation` checks a brand
+  rather than the prototype, so it holds across two copies of core in one page —
+  Cypress bundles the support file and each spec separately.
+
+  `WaitState` now documents the rule it is held to: a state joins only when every
+  driver honours it with the same meaning, so a runner's own states — Playwright's
+  `attached` and `detached` — stay out of the shared interface.
+
+### Patch Changes
+
+- Updated dependencies [9666a3d]
+- Updated dependencies [9666a3d]
+- Updated dependencies [1823546]
+  - @harnessed-ts/core@0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Joe Gaudet, Jay Seo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,107 @@
-# Temporary Holding Version
+# @harnessed-ts/resolve
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The selector resolver behind every Testing Library-family driver for
+`@harnessed-ts/core`. It turns a scope chain plus a `Selector` into DOM nodes with
+the cross-driver guarantees built in: `role` honours `level`, a single-target
+lookup is strict, absence answers at once, and only `frame()` crosses into an
+`<iframe>`.
+
+You do not install this to write harnesses — a driver depends on it. Install it
+when you are **writing a driver**.
+
+## In-process drivers
+
+A driver that shares a realm with the page (jsdom, Ember's test container,
+Cypress's AUT, Vitest browser mode) calls the resolver directly:
+
+```ts
+import { countAll, resolveOne } from '@harnessed-ts/resolve'
+
+const element = await resolveOne(container, scope, selector, timeout)
+const total = await countAll(container, scope, selector)
+```
+
+`resolveOneNow`, `resolveAllNow` and `resolveScopeNow` are the non-waiting forms,
+for a runtime that does its own retrying: "not there yet" is `null`, while
+strictness and frame errors still throw.
+
+A driver running in a real browser answers `isVisible()` with
+`isVisibleInLayout(element, home)` — Playwright's rule: a non-empty box that
+`visibility` does not hide, inside frames that are visible too, crossed up to
+`home`. It answers `boundingBox()` with `boundingBoxOf(element, home)`, which adds
+each crossed frame's `frameOrigin()`, and finds an upload's input with
+`fileInputOf(element)` — the element, or a `<label>`'s control — before handing
+the result to core's `checkFileTarget()`.
+
+A remote driver asks the same of the page through `box`, `origin` and
+`fileTarget`, and adds the origin of each frame it entered itself.
+`filesOnDisk(files)` from `@harnessed-ts/resolve/inject` writes `File`s to a
+temporary directory for a browser that only takes paths.
+
+## Remote drivers
+
+A driver whose test code runs in Node while the page runs elsewhere (WebdriverIO,
+Puppeteer, TestCafe) injects a self-contained build and calls it through the page:
+
+```ts
+import { encodeSelector, injectSource, PAGE_API_GLOBAL } from '@harnessed-ts/resolve/inject'
+
+await page.evaluate(injectSource())
+const handle = await page.evaluateHandle(
+  (name, scope, selector, options) => window[name].one(null, scope, selector, options),
+  PAGE_API_GLOBAL,
+  scope.map(encodeSelector),
+  encodeSelector(selector),
+  { testIdAttribute: 'data-testid', timeout: 5000 },
+)
+```
+
+`encodeSelector` is required: a `RegExp` does not survive WebDriver, CDP or
+TestCafe serialisation, and the page API decodes the tagged form back. The
+runtime config travels with each call because the page cannot see the test
+process's `configure()`. `injectPath()` gives the file's path for tools that inject
+by path.
+
+An error the page throws comes back as a plain error: WebDriver, CDP and TestCafe
+keep its message and, at most, its name. Pass it through `reviveStrictViolation()`
+from `@harnessed-ts/core` so a strict-mode violation is `StrictModeViolation`
+again, worded exactly as an in-process driver words it — that is how a caller
+tells ambiguity apart from absence.
+
+## WebDriver drivers
+
+A WebDriver client (WebdriverIO, selenium-webdriver under Nightwatch) shares more
+than injection: the page script that resolves and reads in one round-trip, and
+the walk that enters each frame of a scope chain from outside the page.
+`@harnessed-ts/resolve/webdriver` holds both, behind a small `WebDriverLike`
+adapter — run the page script in a document, inject the resolver, wrap an
+element, enter a frame, leave frames:
+
+```ts
+import { callPage, classicScript, walk } from '@harnessed-ts/resolve/webdriver'
+import type { WebDriverLike, WebDriverSite } from '@harnessed-ts/resolve/webdriver'
+
+const client: WebDriverLike<WebDriverSite, WebElement> = {
+  top: () => ({ top: true, origin: { x: 0, y: 0 } }),
+  run: (_site, args) => driver.executeScript(classicScript(), ...args),
+  inject: async (_site, source) => void (await driver.executeScript(source)),
+  element: async (_site, ref) => ref as unknown as WebElement,
+  async enterFrame(_site, iframe, origin) {
+    await driver.switchTo().frame(iframe)
+    return { top: false, origin }
+  },
+  leaveFrames: () => driver.switchTo().defaultContent(),
+}
+
+const text = await walk(client, scope, { waiting: true, timeout }, (site, rest, remaining) =>
+  callPage(client, site, 'text', rest, selector, remaining()),
+)
+```
+
+Errors the page raises come back as values, so a strict violation arrives as
+core's `StrictModeViolation` and a frame that cannot be entered as a
+`PageError` (`isFrameEntryError`).
+
+Full guide: the [harnessed README](https://github.com/joegaudet/harnessed#readme).
+
+MIT © Joe Gaudet, Jay Seo

package/dist/box.d.ts

@@ -0,0 +1,27 @@
+import type { BoundingBox } from '@harnessed-ts/core';
+/** A point in a document's viewport, in CSS pixels. */
+export interface Point {
+    x: number;
+    y: number;
+}
+/**
+ * An element's border box in its own document's viewport, or `null` when it
+ * renders no box at all (`display: none`, or anything inside it). Every driver
+ * reads `null` as all zeros, which is what Playwright and Puppeteer — whose
+ * native boxes are `null` there — are normalised to.
+ */
+export declare function boxInOwnDocument(element: Element): BoundingBox | null;
+/**
+ * Where an iframe's document is drawn, in the iframe's own document: the corner
+ * of its content box, inside its border and padding. The same offset Playwright
+ * and Puppeteer add when they report a framed element's box.
+ */
+export declare function frameOrigin(iframe: Element): Point;
+/**
+ * An element's box relative to the viewport of `home` — the document the
+ * driver drives — adding the origin of every same-origin frame crossed on the
+ * way up. For drivers that resolve inside the page; under jsdom everything is
+ * zeros, because jsdom computes no layout.
+ */
+export declare function boundingBoxOf(element: Element, home?: Document): BoundingBox;
+//# sourceMappingURL=box.d.ts.map

package/dist/box.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"box.d.ts","sourceRoot":"","sources":["../src/box.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAErD,uDAAuD;AACvD,MAAM,WAAW,KAAK;IACpB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,WAAW,GAAG,IAAI,CAIrE;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,OAAO,GAAG,KAAK,CAQlD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,QAAQ,GAAG,WAAW,CAc5E"}

package/dist/chunk-BYG4HMLR.js

@@ -0,0 +1,61 @@
+import { readFileSync, mkdtempSync, rmSync, mkdirSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join, dirname, basename } from 'path';
+import { fileURLToPath } from 'url';
+
+// src/inject.ts
+
+// src/global-name.ts
+var PAGE_API_GLOBAL = "__harnessedResolve";
+
+// src/wire.ts
+function isRegExp(value) {
+  return Object.prototype.toString.call(value) === "[object RegExp]";
+}
+function encodeValue(value) {
+  if (isRegExp(value)) return { $regexp: value.source, flags: value.flags };
+  if (Array.isArray(value)) return value.map(encodeValue);
+  if (typeof value === "object" && value !== null) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, inner]) => [key, encodeValue(inner)])
+    );
+  }
+  return value;
+}
+function encodeSelector(selector) {
+  return encodeValue(selector);
+}
+
+// src/inject.ts
+function injectPath() {
+  if (typeof __filename === "string") return join(dirname(__filename), "inject.global.js");
+  return fileURLToPath(new URL("./inject.global.js", import.meta.url));
+}
+var cached;
+function injectSource() {
+  if (cached === void 0) cached = readFileSync(injectPath(), "utf8");
+  return cached;
+}
+var uploads;
+var written = 0;
+async function filesOnDisk(files) {
+  if (uploads === void 0) {
+    const root2 = mkdtempSync(join(tmpdir(), "harnessed-uploads-"));
+    uploads = root2;
+    process.once("exit", () => rmSync(root2, { recursive: true, force: true }));
+  }
+  const root = uploads;
+  return Promise.all(
+    files.map(async (file) => {
+      const dir = join(root, String(written++));
+      mkdirSync(dir);
+      const path = join(dir, basename(file.name) || "upload");
+      writeFileSync(path, new Uint8Array(await file.arrayBuffer()));
+      return path;
+    })
+  );
+}
+
+export { PAGE_API_GLOBAL, encodeSelector, filesOnDisk, injectPath, injectSource };
+//# sourceMappingURL=chunk-BYG4HMLR.js.map
+//# sourceMappingURL=chunk-BYG4HMLR.js.map

package/dist/chunk-BYG4HMLR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/global-name.ts","../src/wire.ts","../src/inject.ts"],"names":["root"],"mappings":";;;;;;;;AAKO,IAAM,eAAA,GAAkB;;;ACe/B,SAAS,SAAS,KAAA,EAAiC;AACjD,EAAA,OAAO,MAAA,CAAO,SAAA,CAAU,QAAA,CAAS,IAAA,CAAK,KAAK,CAAA,KAAM,iBAAA;AACnD;AAEA,SAAS,YAAY,KAAA,EAAyB;AAC5C,EAAA,IAAI,QAAA,CAAS,KAAK,CAAA,EAAG,OAAO,EAAE,SAAS,KAAA,CAAM,MAAA,EAAQ,KAAA,EAAO,KAAA,CAAM,KAAA,EAAM;AACxE,EAAA,IAAI,MAAM,OAAA,CAAQ,KAAK,GAAG,OAAO,KAAA,CAAM,IAAI,WAAW,CAAA;AACtD,EAAA,IAAI,OAAO,KAAA,KAAU,QAAA,IAAY,KAAA,KAAU,IAAA,EAAM;AAC/C,IAAA,OAAO,MAAA,CAAO,WAAA;AAAA,MACZ,MAAA,CAAO,OAAA,CAAQ,KAAK,CAAA,CAAE,IAAI,CAAC,CAAC,GAAA,EAAK,KAAK,MAAM,CAAC,GAAA,EAAK,WAAA,CAAY,KAAK,CAAC,CAAC;AAAA,KACvE;AAAA,EACF;AACA,EAAA,OAAO,KAAA;AACT;AAuBO,SAAS,eAAe,QAAA,EAAkC;AAC/D,EAAA,OAAO,YAAY,QAAQ,CAAA;AAC7B;;;ACxCO,SAAS,UAAA,GAAqB;AAGnC,EAAA,IAAI,OAAO,eAAe,QAAA,EAAU,OAAO,KAAK,OAAA,CAAQ,UAAU,GAAG,kBAAkB,CAAA;AACvF,EAAA,OAAO,cAAc,IAAI,GAAA,CAAI,oBAAA,EAAsB,MAAA,CAAA,IAAA,CAAY,GAAG,CAAC,CAAA;AACrE;AAEA,IAAI,MAAA;AAMG,SAAS,YAAA,GAAuB;AACrC,EAAA,IAAI,WAAW,MAAA,EAAW,MAAA,GAAS,YAAA,CAAa,UAAA,IAAc,MAAM,CAAA;AACpE,EAAA,OAAO,MAAA;AACT;AAEA,IAAI,OAAA;AACJ,IAAI,OAAA,GAAU,CAAA;AAad,eAAsB,YAAY,KAAA,EAA2C;AAC3E,EAAA,IAAI,YAAY,MAAA,EAAW;AACzB,IAAA,MAAMA,QAAO,WAAA,CAAY,IAAA,CAAK,MAAA,EAAO,EAAG,oBAAoB,CAAC,CAAA;AAC7D,IAAA,OAAA,GAAUA,KAAAA;AACV,IAAA,OAAA,CAAQ,IAAA,CAAK,MAAA,EAAQ,MAAM,MAAA,CAAOA,KAAAA,EAAM,EAAE,SAAA,EAAW,IAAA,EAAM,KAAA,EAAO,IAAA,EAAM,CAAC,CAAA;AAAA,EAC3E;AACA,EAAA,MAAM,IAAA,GAAO,OAAA;AACb,EAAA,OAAO,OAAA,CAAQ,GAAA;AAAA,IACb,KAAA,CAAM,GAAA,CAAI,OAAM,IAAA,KAAQ;AACtB,MAAA,MAAM,GAAA,GAAM,IAAA,CAAK,IAAA,EAAM,MAAA,CAAO,SAAS,CAAC,CAAA;AACxC,MAAA,SAAA,CAAU,GAAG,CAAA;AAEb,MAAA,MAAM,OAAO,IAAA,CAAK,GAAA,EAAK,SAAS,IAAA,CAAK,IAAI,KAAK,QAAQ,CAAA;AACtD,MAAA,aAAA,CAAc,MAAM,IAAI,UAAA,CAAW,MAAM,IAAA,CAAK,WAAA,EAAa,CAAC,CAAA;AAC5D,MAAA,OAAO,IAAA;AAAA,IACT,CAAC;AAAA,GACH;AACF","file":"chunk-BYG4HMLR.js","sourcesContent":["/**\n * Where the injected build installs itself on the page's `window`. A leaf\n * module with no imports, so the Node-side `inject` entry can name it without\n * pulling in the resolver and Testing Library, which only run in the page.\n */\nexport const PAGE_API_GLOBAL = '__harnessedResolve'\n","import type { Selector } from '@harnessed-ts/core'\n\n/**\n * A `Selector` as it crosses into a remote page. Everything in one is JSON-safe\n * except a RegExp — `role('button', { name: /save/i })` — which WebDriver,\n * CDP and TestCafe all serialise to `{}`. This encodes them as tagged objects\n * on the way out, and the page API decodes them on the way in.\n */\nexport interface WireRegExp {\n  $regexp: string\n  flags: string\n}\n\nexport type WireSelector = Record<string, unknown>\n\n/**\n * Not `instanceof`: a selector built in the test process and handed to a page\n * in the same JS engine (jsdom, a same-origin frame) carries the other realm's\n * RegExp, which `instanceof` does not recognise.\n */\nfunction isRegExp(value: unknown): value is RegExp {\n  return Object.prototype.toString.call(value) === '[object RegExp]'\n}\n\nfunction encodeValue(value: unknown): unknown {\n  if (isRegExp(value)) return { $regexp: value.source, flags: value.flags }\n  if (Array.isArray(value)) return value.map(encodeValue)\n  if (typeof value === 'object' && value !== null) {\n    return Object.fromEntries(\n      Object.entries(value).map(([key, inner]) => [key, encodeValue(inner)]),\n    )\n  }\n  return value\n}\n\nfunction isWireRegExp(value: unknown): value is WireRegExp {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    typeof (value as WireRegExp).$regexp === 'string' &&\n    typeof (value as WireRegExp).flags === 'string'\n  )\n}\n\nfunction decodeValue(value: unknown): unknown {\n  if (isRegExp(value)) return new RegExp(value.source, value.flags)\n  if (isWireRegExp(value)) return new RegExp(value.$regexp, value.flags)\n  if (Array.isArray(value)) return value.map(decodeValue)\n  if (typeof value === 'object' && value !== null) {\n    return Object.fromEntries(\n      Object.entries(value).map(([key, inner]) => [key, decodeValue(inner)]),\n    )\n  }\n  return value\n}\n\nexport function encodeSelector(selector: Selector): WireSelector {\n  return encodeValue(selector) as WireSelector\n}\n\n/** Idempotent: a selector that never left the process decodes to itself. */\nexport function decodeSelector(selector: Selector | WireSelector): Selector {\n  return decodeValue(selector) as Selector\n}\n","import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'\nimport { tmpdir } from 'node:os'\nimport { basename, dirname, join } from 'node:path'\nimport { fileURLToPath } from 'node:url'\n\n// Leaf modules only: this entry runs in the test process, where the resolver\n// and Testing Library have no business loading.\nexport { PAGE_API_GLOBAL } from './global-name'\nexport { encodeSelector } from './wire'\nexport type { WireSelector } from './wire'\nexport type { PageApi, PageApiOptions } from './page-api'\n\ndeclare const __filename: string | undefined\n\n/**\n * Absolute path to the injectable build, for drivers that inject by path\n * (TestCafe's `clientScripts`, Puppeteer's `addScriptTag`).\n */\nexport function injectPath(): string {\n  // A sibling in dist/. The CJS build has __filename; the ESM build has\n  // import.meta.url and no __filename, so each takes its own branch.\n  if (typeof __filename === 'string') return join(dirname(__filename), 'inject.global.js')\n  return fileURLToPath(new URL('./inject.global.js', import.meta.url))\n}\n\nlet cached: string | undefined\n\n/**\n * The injectable build's source, for drivers that inject by evaluating a string\n * (WebdriverIO's `execute`, Puppeteer's `evaluate`). Read once per process.\n */\nexport function injectSource(): string {\n  if (cached === undefined) cached = readFileSync(injectPath(), 'utf8')\n  return cached\n}\n\nlet uploads: string | undefined\nlet written = 0\n\n/**\n * Writes files to disk for a driver whose browser only takes file paths\n * (Puppeteer's `uploadFile`, WebDriver's file input, TestCafe's\n * `setFilesToUpload`), and returns the paths in order.\n *\n * Each file gets a directory of its own, so its name survives as the path's\n * last segment even when two files share one. The browser reads the file when\n * the page does — after the upload resolves — so nothing is deleted until the\n * process exits. What travels is the name and the bytes: the browser infers\n * `type` from the extension, and `lastModified` is the time of writing.\n */\nexport async function filesOnDisk(files: readonly File[]): Promise<string[]> {\n  if (uploads === undefined) {\n    const root = mkdtempSync(join(tmpdir(), 'harnessed-uploads-'))\n    uploads = root\n    process.once('exit', () => rmSync(root, { recursive: true, force: true }))\n  }\n  const root = uploads\n  return Promise.all(\n    files.map(async file => {\n      const dir = join(root, String(written++))\n      mkdirSync(dir)\n      // basename: a name is a name, never a path out of the directory.\n      const path = join(dir, basename(file.name) || 'upload')\n      writeFileSync(path, new Uint8Array(await file.arrayBuffer()))\n      return path\n    }),\n  )\n}\n"]}

package/dist/files.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The file input an upload sets: the element itself, or the control of a
+ * `<label>` — user-event's and Playwright's rule both. Anything else comes back
+ * described as markup, for core's `checkFileTarget` to refuse in one wording.
+ */
+export declare function fileInputOf(element: Element): HTMLInputElement | string;
+//# sourceMappingURL=files.d.ts.map

package/dist/files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"files.d.ts","sourceRoot":"","sources":["../src/files.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,gBAAgB,GAAG,MAAM,CAOvE"}

package/dist/global-name.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Where the injected build installs itself on the page's `window`. A leaf
+ * module with no imports, so the Node-side `inject` entry can name it without
+ * pulling in the resolver and Testing Library, which only run in the page.
+ */
+export declare const PAGE_API_GLOBAL = "__harnessedResolve";
+//# sourceMappingURL=global-name.d.ts.map

package/dist/global-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"global-name.d.ts","sourceRoot":"","sources":["../src/global-name.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,eAAe,uBAAuB,CAAA"}