@harnessed-ts/resolve 0.0.0-stage → 0.6.0

package/dist/inject.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=inject.js.map
+//# sourceMappingURL=inject.js.map

package/dist/inject.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":"inject.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/page-api.d.ts

@@ -0,0 +1,57 @@
+import type { BoundingBox, FileTarget, Selector } from '@harnessed-ts/core';
+import type { Point } from './box';
+import { PAGE_API_GLOBAL } from './global-name';
+import type { WireSelector } from './wire';
+export { PAGE_API_GLOBAL };
+/**
+ * Settings a remote driver passes on every call. The page has no access to the
+ * test process's `configure()`, so the runtime config travels with the call
+ * rather than being pushed once.
+ */
+/** A selector as handed over the wire, or as-is when caller and page share a realm. */
+type Wire = Selector | WireSelector;
+export interface PageApiOptions {
+    testIdAttribute: string;
+    timeout: number;
+}
+/**
+ * The resolver as seen from inside a page a driver does not share a realm with
+ * — WebdriverIO, Puppeteer, TestCafe. Every argument is serialisable except
+ * `root`, which is an element handle the driver passes back in (or `null` for
+ * the document body).
+ *
+ * The same functions back the dom driver, so role, label, strictness, index
+ * and frame semantics cannot differ between a driver resolving in-process and
+ * one resolving through this.
+ */
+export interface PageApi {
+    /** How many nodes match. The scope waits; the count does not. */
+    count(root: Element | null, scope: Wire[], selector: Wire, options: PageApiOptions): Promise<number>;
+    /** The single node a strict operation acts on, waiting for it. */
+    one(root: Element | null, scope: Wire[], selector: Wire, options: PageApiOptions): Promise<Element>;
+    /** Every match, after waiting for the scope. `nth` is ignored, as for any list. */
+    all(root: Element | null, scope: Wire[], selector: Wire, options: PageApiOptions): Promise<Element[]>;
+    /** The single node now, or `null`. For runtimes that do their own retrying. */
+    oneNow(root: Element | null, scope: Wire[], selector: Wire, options: PageApiOptions): Element | null;
+    /** Every match now. */
+    allNow(root: Element | null, scope: Wire[], selector: Wire, options: PageApiOptions): Element[];
+    /**
+     * Whether an element is visible by layout, within its own document only. A
+     * driver that enters frames from outside the page asks about each iframe it
+     * crossed in that iframe's own document, which also covers a cross-origin
+     * frame no in-page walk could cross.
+     */
+    visible(element: Element): boolean;
+    /**
+     * The element's box in its own document's viewport, or `null` when it draws
+     * none. A driver that enters frames from outside adds each crossed frame's
+     * `origin` itself.
+     */
+    box(element: Element): BoundingBox | null;
+    /** Where an iframe's document is drawn, in the iframe's own document. */
+    origin(iframe: Element): Point;
+    /** What an upload would set: the file input's `multiple`, or what the element is instead. */
+    fileTarget(element: Element): FileTarget;
+}
+export declare function createPageApi(document: Document): PageApi;
+//# sourceMappingURL=page-api.d.ts.map

package/dist/page-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-api.d.ts","sourceRoot":"","sources":["../src/page-api.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAA;AAE3E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,OAAO,CAAA;AAElC,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAI/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AAE1C,OAAO,EAAE,eAAe,EAAE,CAAA;AAE1B;;;;GAIG;AACH,uFAAuF;AACvF,KAAK,IAAI,GAAG,QAAQ,GAAG,YAAY,CAAA;AAEnC,MAAM,WAAW,cAAc;IAC7B,eAAe,EAAE,MAAM,CAAA;IACvB,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,OAAO;IACtB,iEAAiE;IACjE,KAAK,CACH,IAAI,EAAE,OAAO,GAAG,IAAI,EACpB,KAAK,EAAE,IAAI,EAAE,EACb,QAAQ,EAAE,IAAI,EACd,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,MAAM,CAAC,CAAA;IAClB,kEAAkE;IAClE,GAAG,CACD,IAAI,EAAE,OAAO,GAAG,IAAI,EACpB,KAAK,EAAE,IAAI,EAAE,EACb,QAAQ,EAAE,IAAI,EACd,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,OAAO,CAAC,CAAA;IACnB,mFAAmF;IACnF,GAAG,CACD,IAAI,EAAE,OAAO,GAAG,IAAI,EACpB,KAAK,EAAE,IAAI,EAAE,EACb,QAAQ,EAAE,IAAI,EACd,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,OAAO,EAAE,CAAC,CAAA;IACrB,+EAA+E;IAC/E,MAAM,CACJ,IAAI,EAAE,OAAO,GAAG,IAAI,EACpB,KAAK,EAAE,IAAI,EAAE,EACb,QAAQ,EAAE,IAAI,EACd,OAAO,EAAE,cAAc,GACtB,OAAO,GAAG,IAAI,CAAA;IACjB,uBAAuB;IACvB,MAAM,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,EAAE,CAAA;IAC/F;;;;;OAKG;IACH,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAA;IAClC;;;;OAIG;IACH,GAAG,CAAC,OAAO,EAAE,OAAO,GAAG,WAAW,GAAG,IAAI,CAAA;IACzC,yEAAyE;IACzE,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,KAAK,CAAA;IAC9B,6FAA6F;IAC7F,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,UAAU,CAAA;CACzC;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAgDzD"}

package/dist/resolve.d.ts

@@ -0,0 +1,38 @@
+import type { Selector } from '@harnessed-ts/core';
+/** Every match for one selector, without waiting. Zero is an answer. */
+export declare function queryAll(root: HTMLElement, selector: Selector): HTMLElement[];
+/**
+ * Walks the scope chain down to the element the final selector is queried within.
+ * Waiting is correct here: a container that has not rendered yet is not the same
+ * thing as a target that is absent.
+ */
+export declare function resolveScope(container: HTMLElement, scope: readonly Selector[], timeout?: number): Promise<HTMLElement>;
+/** A frame link that cannot be entered — a wiring mistake, never "not rendered yet". */
+export declare class FrameEntryError extends Error {
+    name: string;
+}
+/** The single node a strict operation acts on. */
+export declare function resolveOne(container: HTMLElement, scope: readonly Selector[], selector: Selector, timeout?: number): Promise<HTMLElement>;
+/**
+ * How many nodes match. The scope chain still waits, but the final count uses the
+ * non-waiting query so that zero answers immediately rather than throwing after a
+ * retry timeout. This is the behaviour Playwright already had.
+ */
+export declare function countAll(container: HTMLElement, scope: readonly Selector[], selector: Selector, timeout?: number): Promise<number>;
+/** The scope chain's innermost element now, or `null` if a link is not on screen. */
+export declare function resolveScopeNow(container: HTMLElement, scope: readonly Selector[]): HTMLElement | null;
+/** The single node a strict operation acts on now, or `null` if it is not on screen. */
+export declare function resolveOneNow(container: HTMLElement, scope: readonly Selector[], selector: Selector): HTMLElement | null;
+/**
+ * Every match now, agreeing with `countAll` on every scope it cannot resolve:
+ * an absent or ambiguous scope is an empty list, and only a frame that cannot
+ * be entered throws.
+ */
+export declare function resolveAllNow(container: HTMLElement, scope: readonly Selector[], selector: Selector): HTMLElement[];
+/**
+ * Every match for a list operation: the scope waits, the list does not, and
+ * `nth` is ignored — each result is addressed by its own index afterwards. The
+ * one definition of "the list" for in-process and injected drivers alike.
+ */
+export declare function resolveAll(container: HTMLElement, scope: readonly Selector[], selector: Selector, timeout?: number): Promise<HTMLElement[]>;
+//# sourceMappingURL=resolve.d.ts.map

package/dist/resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../src/resolve.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAA;AA8BlD,wEAAwE;AACxE,wBAAgB,QAAQ,CAAC,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,GAAG,WAAW,EAAE,CAmB7E;AAwED;;;;GAIG;AACH,wBAAsB,YAAY,CAChC,SAAS,EAAE,WAAW,EACtB,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,WAAW,CAAC,CAUtB;AAED,wFAAwF;AACxF,qBAAa,eAAgB,SAAQ,KAAK;IAC/B,IAAI,SAAoB;CAClC;AA6BD,kDAAkD;AAClD,wBAAsB,UAAU,CAC9B,SAAS,EAAE,WAAW,EACtB,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,QAAQ,EAAE,QAAQ,EAClB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,WAAW,CAAC,CAItB;AAED;;;;GAIG;AACH,wBAAsB,QAAQ,CAC5B,SAAS,EAAE,WAAW,EACtB,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,QAAQ,EAAE,QAAQ,EAClB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,CAAC,CAYjB;AAUD,qFAAqF;AACrF,wBAAgB,eAAe,CAC7B,SAAS,EAAE,WAAW,EACtB,KAAK,EAAE,SAAS,QAAQ,EAAE,GACzB,WAAW,GAAG,IAAI,CAUpB;AAED,wFAAwF;AACxF,wBAAgB,aAAa,CAC3B,SAAS,EAAE,WAAW,EACtB,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,QAAQ,EAAE,QAAQ,GACjB,WAAW,GAAG,IAAI,CAMpB;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,SAAS,EAAE,WAAW,EACtB,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,QAAQ,EAAE,QAAQ,GACjB,WAAW,EAAE,CAaf;AAED;;;;GAIG;AACH,wBAAsB,UAAU,CAC9B,SAAS,EAAE,WAAW,EACtB,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,QAAQ,EAAE,QAAQ,EAClB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,WAAW,EAAE,CAAC,CAExB"}

package/dist/visible.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Whether an element is visible by layout — Playwright's definition, for drivers
+ * that run in a real browser beside the page (Vitest browser mode, Ember, Cypress).
+ * jsdom computes no layout, so the dom driver cannot use this and reads computed
+ * style instead.
+ *
+ * Visible means a non-empty box that `visibility` does not hide. `display: none`
+ * anywhere above gives an empty box, so it needs no check of its own. Opacity
+ * does not count: a transparent box is still there to click, and Playwright
+ * reports it visible.
+ *
+ * Inside a frame, the iframe has to be visible too — a hidden frame hides its
+ * content. The walk crosses frames up to `home` (by default, every reachable
+ * one), so a driver passes its own document to stop at the frames its scope
+ * actually entered.
+ */
+export declare function isVisibleInLayout(element: Element, home?: Document): boolean;
+//# sourceMappingURL=visible.d.ts.map

package/dist/visible.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"visible.d.ts","sourceRoot":"","sources":["../src/visible.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,QAAQ,GAAG,OAAO,CAO5E"}

package/dist/wire.d.ts

@@ -0,0 +1,16 @@
+import type { Selector } from '@harnessed-ts/core';
+/**
+ * A `Selector` as it crosses into a remote page. Everything in one is JSON-safe
+ * except a RegExp — `role('button', { name: /save/i })` — which WebDriver,
+ * CDP and TestCafe all serialise to `{}`. This encodes them as tagged objects
+ * on the way out, and the page API decodes them on the way in.
+ */
+export interface WireRegExp {
+    $regexp: string;
+    flags: string;
+}
+export type WireSelector = Record<string, unknown>;
+export declare function encodeSelector(selector: Selector): WireSelector;
+/** Idempotent: a selector that never left the process decodes to itself. */
+export declare function decodeSelector(selector: Selector | WireSelector): Selector;
+//# sourceMappingURL=wire.d.ts.map

package/dist/wire.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wire.d.ts","sourceRoot":"","sources":["../src/wire.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAA;AAElD;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;CACd;AAED,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AA2ClD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,QAAQ,GAAG,YAAY,CAE/D;AAED,4EAA4E;AAC5E,wBAAgB,cAAc,CAAC,QAAQ,EAAE,QAAQ,GAAG,YAAY,GAAG,QAAQ,CAE1E"}

package/package.json

@@ -1,6 +1,77 @@
 {
   "name": "@harnessed-ts/resolve",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.6.0",
+  "description": "The shared selector resolver behind the Testing Library-family drivers, plus an injectable build for drivers that resolve inside a remote page.",
+  "keywords": [
+    "testing",
+    "harness",
+    "testing-library",
+    "resolver"
+  ],
+  "license": "MIT",
+  "contributors": [
+    {
+      "name": "Joe Gaudet",
+      "url": "https://github.com/joegaudet"
+    },
+    {
+      "name": "Jay Seo",
+      "url": "https://github.com/jayseo5953"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/joegaudet/harnessed.git",
+    "directory": "packages/resolve"
+  },
+  "homepage": "https://github.com/joegaudet/harnessed#readme",
+  "bugs": "https://github.com/joegaudet/harnessed/issues",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./inject": {
+      "types": "./dist/inject.d.ts",
+      "import": "./dist/inject.js",
+      "require": "./dist/inject.cjs"
+    },
+    "./inject.global.js": "./dist/inject.global.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "CHANGELOG.md",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "dependencies": {
+    "@harnessed-ts/core": "^0.6.0"
+  },
+  "peerDependencies": {
+    "@testing-library/dom": ">=10"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@testing-library/dom": "^10.4.2",
+    "@types/jsdom": "^30.0.0",
+    "@types/node": "^26.6.3",
+    "jsdom": "^30.1.1",
+    "vitest": "^5.0.3"
+  },
+  "scripts": {
+    "build": "tsup",
+    "clean": "rm -rf dist *.tsbuildinfo",
+    "test": "vitest run"
+  }
 }