pi-browser-harness 0.10.2 → 0.12.0

package/src/domains/forms.ts

@@ -1,355 +0,0 @@
-import { Type } from "typebox";
-import type { BrowserClient } from "../client";
-import { type Result, err, ok } from "../util/result";
-import { defineBrowserTool, type ToolErr, type ToolOk } from "../util/tool";
-
-// ── Page-side functions ──────────────────────────────────────────────────────
-// These run inside the page via Runtime.callFunctionOn with `this` bound to the
-// resolved element. They are NOT string-interpolated with user data — the value
-// is passed as a structured `arguments` entry, so safeJs is unnecessary here.
-
-/**
- * Universal field setter. Auto-detects the element type and applies the right
- * strategy, then reads the resulting value back so the caller can confirm.
- *
- * The <input>/<textarea> branch uses the "native setter" trick: React (and
- * other frameworks) overload the element's `value` setter to track state, so a
- * plain `el.value = x` updates the DOM but not the framework. Calling the
- * prototype's original setter and then dispatching a bubbling `input` event is
- * what makes React's onChange fire.
- */
-const FILL_FN = `
-function(value) {
-  const el = this;
-  if (!el || el.nodeType !== 1) return { ok: false, reason: "ref does not point to an element" };
-  if (el.disabled) return { ok: false, reason: "element is disabled" };
-  const tag = (el.tagName || "").toLowerCase();
-  const type = (el.type || "").toLowerCase();
-  try { el.focus(); } catch (e) {}
-  const fire = function(t) { el.dispatchEvent(new Event(t, { bubbles: true })); };
-
-  if (tag === "select") {
-    const want = String(value);
-    let matched = null;
-    for (let i = 0; i < el.options.length; i++) {
-      const o = el.options[i];
-      if (o.value === want || o.label === want || o.text === want) { matched = o; break; }
-    }
-    if (!matched) {
-      const opts = [];
-      for (let i = 0; i < el.options.length; i++) opts.push({ value: el.options[i].value, text: el.options[i].text });
-      return { ok: false, reason: "no matching option", kind: "select", options: opts };
-    }
-    el.value = matched.value;
-    fire("input"); fire("change");
-    return { ok: true, kind: "select", value: el.value, text: matched.text };
-  }
-
-  if (tag === "input" && (type === "checkbox" || type === "radio")) {
-    const want = value === true || value === "true" || value === "on" || value === 1;
-    if (el.checked !== want) {
-      try { el.click(); } catch (e) {}
-      if (el.checked !== want) { el.checked = want; fire("input"); fire("change"); }
-    }
-    return { ok: true, kind: type, checked: el.checked };
-  }
-
-  if (el.isContentEditable) {
-    el.textContent = String(value);
-    fire("input"); fire("change");
-    return { ok: true, kind: "contenteditable", value: el.textContent };
-  }
-
-  if (tag === "input" || tag === "textarea") {
-    const proto = tag === "textarea" ? window.HTMLTextAreaElement.prototype : window.HTMLInputElement.prototype;
-    const desc = Object.getOwnPropertyDescriptor(proto, "value");
-    if (desc && desc.set) desc.set.call(el, String(value));
-    else el.value = String(value);
-    fire("input"); fire("change");
-    return { ok: true, kind: tag, value: el.value };
-  }
-
-  return { ok: false, reason: "element is not a fillable field (tag=" + tag + ")" };
-}`;
-
-/** Specialized <select> setter — matches by value first, then by label/text. */
-const SELECT_FN = `
-function(value, label) {
-  const el = this;
-  if (!el || (el.tagName || "").toLowerCase() !== "select") return { ok: false, reason: "ref is not a <select> element" };
-  if (el.disabled) return { ok: false, reason: "select is disabled" };
-  let matched = null;
-  for (let i = 0; i < el.options.length; i++) {
-    const o = el.options[i];
-    if (value != null && o.value === String(value)) { matched = o; break; }
-    if (label != null && (o.text === String(label) || o.label === String(label))) { matched = o; break; }
-  }
-  if (!matched) {
-    const opts = [];
-    for (let i = 0; i < el.options.length; i++) opts.push({ value: el.options[i].value, text: el.options[i].text });
-    return { ok: false, reason: "no matching option", options: opts };
-  }
-  try { el.focus(); } catch (e) {}
-  el.value = matched.value;
-  el.dispatchEvent(new Event("input", { bubbles: true }));
-  el.dispatchEvent(new Event("change", { bubbles: true }));
-  return { ok: true, value: el.value, text: matched.text };
-}`;
-
-/** Specialized checkbox/radio setter — only acts when the state differs. */
-const CHECK_FN = `
-function(checked) {
-  const el = this;
-  const tag = (el.tagName || "").toLowerCase();
-  const type = (el.type || "").toLowerCase();
-  if (tag !== "input" || (type !== "checkbox" && type !== "radio")) return { ok: false, reason: "ref is not a checkbox or radio" };
-  if (el.disabled) return { ok: false, reason: "element is disabled" };
-  const want = checked === true;
-  let changed = false;
-  if (el.checked !== want) {
-    try { el.click(); } catch (e) {}
-    if (el.checked !== want) { el.checked = want; el.dispatchEvent(new Event("change", { bubbles: true })); }
-    changed = true;
-  }
-  return { ok: true, checked: el.checked, changed: changed };
-}`;
-
-// ── Resolver ─────────────────────────────────────────────────────────────────
-
-/** Shape returned by the page-side functions above. */
-type PageResult = {
-  readonly ok: boolean;
-  readonly reason?: string;
-  readonly kind?: string;
-  readonly value?: unknown;
-  readonly text?: string;
-  readonly checked?: boolean;
-  readonly changed?: boolean;
-  readonly options?: ReadonlyArray<{ value: string; text: string }>;
-};
-
-/**
- * Resolve a ref (CDP backendDOMNodeId) to a live JS handle and invoke a
- * page-side function on it. DOM + Runtime are enabled on every session
- * (see cdp/session.ts enableDomains), so no extra setup is required.
- */
-const resolveAndCall = async (
-  client: BrowserClient,
-  ref: number,
-  functionDeclaration: string,
-  args: ReadonlyArray<unknown>,
-): Promise<Result<PageResult, ToolErr>> => {
-  const session = client.session();
-
-  const resolved = await session.call("DOM.resolveNode", { backendNodeId: ref });
-  if (!resolved.success) {
-    return err({
-      kind: "invalid_state",
-      message: `ref ${ref} could not be resolved — the page may have changed. Re-run browser_snapshot to get fresh refs.`,
-      details: { ref },
-    });
-  }
-  const objectId = (resolved.data as { object?: { objectId?: string } }).object?.objectId;
-  if (objectId === undefined) {
-    return err({
-      kind: "invalid_state",
-      message: `ref ${ref} resolved to no JS object — re-run browser_snapshot to get fresh refs.`,
-      details: { ref },
-    });
-  }
-
-  try {
-    const called = await session.call("Runtime.callFunctionOn", {
-      objectId,
-      functionDeclaration,
-      arguments: args.map((v) => ({ value: v })),
-      returnByValue: true,
-      awaitPromise: true,
-    });
-    if (!called.success) return err({ kind: "cdp_error", message: called.error.message, details: { ref } });
-    const data = called.data as { result?: { value?: unknown }; exceptionDetails?: unknown };
-    if (data.exceptionDetails !== undefined) {
-      return err({ kind: "cdp_error", message: `page function threw: ${JSON.stringify(data.exceptionDetails)}`, details: { ref } });
-    }
-    const value = data.result?.value;
-    if (typeof value !== "object" || value === null) {
-      return err({ kind: "internal", message: "page function returned no result object", details: { ref } });
-    }
-    return ok(value as PageResult);
-  } finally {
-    // Best-effort: release the remote handle so it can be GC'd. Failure is
-    // harmless (the page may have navigated), so we ignore the result.
-    await session.call("Runtime.releaseObject", { objectId });
-  }
-};
-
-/** Drop the `ok` flag before stashing a page result in tool `details` — the
- *  tool-result envelope reserves `ok` for its own success discriminant. */
-const detailsOf = (ref: number, res: PageResult, extra?: Readonly<Record<string, unknown>>): Readonly<Record<string, unknown>> => {
-  const { ok: _ok, ...rest } = res;
-  return { ref, ...rest, ...(extra ?? {}) };
-};
-
-// ── Tools ────────────────────────────────────────────────────────────────────
-
-const FieldValue = Type.Union([Type.String(), Type.Boolean()], {
-  description: "Value to set. String for text inputs / textareas / selects / contenteditable; boolean for checkboxes & radios.",
-});
-
-const FillArgs = Type.Object({
-  ref: Type.Integer({ description: "Element ref from browser_snapshot ([ref=N])." }),
-  value: FieldValue,
-});
-
-export const fillTool = defineBrowserTool({
-  name: "browser_fill",
-  label: "Browser Fill",
-  description:
-    "Fill a single form field by ref. Auto-detects input/textarea/select/checkbox/radio/contenteditable, clears then sets the value, fires input+change events (drives React/Vue controlled inputs correctly), and reads the value back to confirm. Get the ref from browser_snapshot's [ref=N].",
-  promptSnippet: "Fill a form field by ref (text, select, checkbox) — React-safe, self-confirming",
-  promptGuidelines: [
-    "Get the ref from browser_snapshot's [ref=N] for the target field. No click-to-focus needed.",
-    "value is a string for text fields/selects/contenteditable, or a boolean for checkboxes/radios.",
-    "The result reports the value the field actually holds after filling — check it matches what you intended.",
-    "For autocomplete/typeahead that needs real keystrokes, click the field's @(x,y) then use browser_type instead.",
-    "If a ref no longer resolves, re-run browser_snapshot to get fresh refs.",
-  ],
-  parameters: FillArgs,
-  async handler(args, { client }): Promise<Result<ToolOk, ToolErr>> {
-    const r = await resolveAndCall(client, args.ref, FILL_FN, [args.value]);
-    if (!r.success) return r;
-    const res = r.data;
-    if (!res.ok) {
-      return err({ kind: "invalid_state", message: `Could not fill ref ${args.ref}: ${res.reason ?? "unknown reason"}`, details: detailsOf(args.ref, res) });
-    }
-    const wanted = typeof args.value === "boolean" ? undefined : String(args.value);
-    const got = res.value !== undefined ? String(res.value) : undefined;
-    const mismatch = wanted !== undefined && got !== undefined && got !== wanted;
-    let text: string;
-    if (mismatch) {
-      text = `Filled ref ${args.ref}, but it now reads ${JSON.stringify(got)} (wanted ${JSON.stringify(wanted)})`;
-    } else if (got !== undefined) {
-      text = `Filled ref ${args.ref} = ${JSON.stringify(got)}`;
-    } else if (res.checked !== undefined) {
-      text = `Filled ref ${args.ref} (checked=${res.checked})`;
-    } else {
-      text = `Filled ref ${args.ref}`;
-    }
-    return ok({ text, details: detailsOf(args.ref, res, { mismatch }) });
-  },
-});
-
-const FillFormArgs = Type.Object({
-  fields: Type.Array(
-    Type.Object({
-      ref: Type.Integer({ description: "Element ref from browser_snapshot ([ref=N])." }),
-      value: FieldValue,
-    }),
-    { minItems: 1, description: "Fields to fill in one batch, each by ref." },
-  ),
-});
-
-export const fillFormTool = defineBrowserTool({
-  name: "browser_fill_form",
-  label: "Browser Fill Form",
-  description:
-    "Fill multiple form fields in one call — the efficient way to complete a form. Each field is { ref, value }; refs come from browser_snapshot's [ref=N]. Handles text inputs, textareas, selects, checkboxes, radios, and contenteditable, drives React/Vue controlled inputs correctly, and reports the resulting value of every field.",
-  promptSnippet: "Fill many form fields at once by ref — React-safe, self-confirming",
-  promptGuidelines: [
-    "Preferred for forms: snapshot once, then fill all fields in a single browser_fill_form call.",
-    "Each field: { ref, value }. value is a string for text/select/contenteditable, boolean for checkbox/radio.",
-    "The result summarizes how many fields filled cleanly and flags any value mismatches or per-field errors.",
-    "Re-run browser_snapshot afterwards to verify the form state if needed.",
-  ],
-  parameters: FillFormArgs,
-  async handler(args, { client }): Promise<Result<ToolOk, ToolErr>> {
-    const results: Array<Readonly<Record<string, unknown>>> = [];
-    let okCount = 0;
-    const issues: string[] = [];
-    for (const f of args.fields) {
-      const r = await resolveAndCall(client, f.ref, FILL_FN, [f.value]);
-      if (!r.success) {
-        results.push({ ref: f.ref, ok: false, error: r.error.message });
-        issues.push(`ref ${f.ref} (${r.error.message})`);
-        continue;
-      }
-      const res = r.data;
-      const wanted = typeof f.value === "boolean" ? undefined : String(f.value);
-      const got = res.value !== undefined ? String(res.value) : undefined;
-      const mismatch = wanted !== undefined && got !== undefined && got !== wanted;
-      const fieldOk = res.ok === true && !mismatch;
-      if (fieldOk) okCount++;
-      else issues.push(`ref ${f.ref} (${res.ok === false ? (res.reason ?? "failed") : "value mismatch"})`);
-      results.push({ ref: f.ref, ok: fieldOk, mismatch, ...detailsOf(f.ref, res) });
-    }
-    const text =
-      `Filled ${okCount}/${args.fields.length} fields` +
-      (issues.length > 0 ? `; issues: ${issues.join(", ")}` : "");
-    return ok({ text, details: { results } });
-  },
-});
-
-const SelectOptionArgs = Type.Object({
-  ref: Type.Integer({ description: "Element ref of a <select> from browser_snapshot ([ref=N])." }),
-  value: Type.Optional(Type.String({ description: "Option value attribute to select." })),
-  label: Type.Optional(Type.String({ description: "Visible option text/label to select (used if value is omitted)." })),
-});
-
-export const selectOptionTool = defineBrowserTool({
-  name: "browser_select_option",
-  label: "Browser Select Option",
-  description:
-    "Select an option in a native <select> dropdown by ref. Matches by option value, then by visible label/text, and fires change. Native selects cannot be driven by clicking coordinates — use this instead. Get the ref from browser_snapshot's [ref=N].",
-  promptSnippet: "Choose an option in a <select> dropdown by ref",
-  promptGuidelines: [
-    "Provide value (the option's value attribute) or label (the visible text). value wins if both given.",
-    "On no match, the result lists the available options so you can retry with a valid one.",
-    "Use this for native <select> elements — clicking coordinates does not work for OS dropdowns.",
-  ],
-  parameters: SelectOptionArgs,
-  async handler(args, { client }): Promise<Result<ToolOk, ToolErr>> {
-    if (args.value === undefined && args.label === undefined) {
-      return err({ kind: "invalid_state", message: "Provide value or label to select an option." });
-    }
-    const r = await resolveAndCall(client, args.ref, SELECT_FN, [args.value ?? null, args.label ?? null]);
-    if (!r.success) return r;
-    const res = r.data;
-    if (!res.ok) {
-      return err({ kind: "invalid_state", message: `Could not select option on ref ${args.ref}: ${res.reason ?? "unknown reason"}`, details: detailsOf(args.ref, res) });
-    }
-    return ok({
-      text: `Selected ${JSON.stringify(res.text)} (value=${JSON.stringify(res.value)}) on ref ${args.ref}`,
-      details: detailsOf(args.ref, res),
-    });
-  },
-});
-
-const SetCheckedArgs = Type.Object({
-  ref: Type.Integer({ description: "Element ref of a checkbox or radio from browser_snapshot ([ref=N])." }),
-  checked: Type.Boolean({ description: "Desired checked state." }),
-});
-
-export const setCheckedTool = defineBrowserTool({
-  name: "browser_set_checked",
-  label: "Browser Set Checked",
-  description:
-    "Set a checkbox or radio to a desired checked state by ref. Only acts if the current state differs, fires change, and reports the final state. Get the ref from browser_snapshot's [ref=N].",
-  promptSnippet: "Set a checkbox/radio checked state by ref",
-  promptGuidelines: [
-    "checked:true ticks the box, checked:false unticks it. Idempotent — no-op if already in the desired state.",
-    "For radios, set checked:true on the option you want; the group deselects the others.",
-  ],
-  parameters: SetCheckedArgs,
-  async handler(args, { client }): Promise<Result<ToolOk, ToolErr>> {
-    const r = await resolveAndCall(client, args.ref, CHECK_FN, [args.checked]);
-    if (!r.success) return r;
-    const res = r.data;
-    if (!res.ok) {
-      return err({ kind: "invalid_state", message: `Could not set checked on ref ${args.ref}: ${res.reason ?? "unknown reason"}`, details: detailsOf(args.ref, res) });
-    }
-    return ok({
-      text: `Set ref ${args.ref} checked=${res.checked}` + (res.changed === false ? " (already)" : ""),
-      details: detailsOf(args.ref, res),
-    });
-  },
-});

package/src/domains/readpage/capture.ts

@@ -1,46 +0,0 @@
-/**
- * The JavaScript source evaluated in a loaded page to capture candidate content
- * blocks + metadata for the pure readability extractor (readability.ts). Crosses
- * the CDP boundary via Runtime.evaluate (returnByValue) and returns a JSON
- * string shaped like PageCapture.
- *
- * The DOM walk lives here (unavoidable); all scoring/selection is pure and lives
- * in readability.ts, so the decision logic stays unit-testable.
- */
-
-/** Max bytes of body-text fallback captured for thin/structure-less pages. */
-const BODY_TEXT_LIMIT = 20_000;
-
-/** Build the capture expression. No interpolated values ⇒ no injection surface. */
-export const buildPageCaptureExpr = (): string => `
-  (() => {
-    const BOILERPLATE = new Set(['NAV', 'HEADER', 'FOOTER', 'ASIDE']);
-    const inBoilerplate = (el) => {
-      for (let n = el; n; n = n.parentElement) {
-        if (BOILERPLATE.has(n.tagName)) return true;
-        const role = n.getAttribute && n.getAttribute('role');
-        if (role === 'navigation' || role === 'banner' || role === 'contentinfo') return true;
-      }
-      return false;
-    };
-    const kindOf = (tag) => {
-      if (/^H[1-6]$/.test(tag)) return 'heading';
-      if (tag === 'LI') return 'listitem';
-      if (tag === 'BLOCKQUOTE') return 'blockquote';
-      if (tag === 'P') return 'paragraph';
-      return 'other';
-    };
-    const selector = 'p, h1, h2, h3, h4, h5, h6, li, blockquote';
-    const root = document.querySelector('article, main, [role=main]') || document.body;
-    const blocks = [];
-    for (const el of root.querySelectorAll(selector)) {
-      const text = (el.innerText || '').replace(/\\s+/g, ' ').trim();
-      if (!text) continue;
-      let linkTextLength = 0;
-      for (const a of el.querySelectorAll('a')) linkTextLength += (a.innerText || '').length;
-      blocks.push({ kind: kindOf(el.tagName), text, linkTextLength, inBoilerplate: inBoilerplate(el) });
-    }
-    const bodyText = (document.body.innerText || '').replace(/\\n{3,}/g, '\\n\\n').slice(0, ${BODY_TEXT_LIMIT});
-    return JSON.stringify({ url: location.href, title: document.title, blocks, bodyText });
-  })()
-`;

package/src/domains/search/extract.ts

@@ -1,44 +0,0 @@
-/**
- * The JavaScript source evaluated inside the Google SERP page to capture raw
- * anchors + page text. This string crosses the CDP boundary via
- * Runtime.evaluate (returnByValue) and returns a JSON string that
- * `parseGoogleSerp` / `classifySerp` consume on the harness side.
- *
- * ADR-0001: anchors are selected structurally (a link carrying an <h3>), not by
- * Google CSS class names, so cosmetic markup churn does not break extraction.
- */
-
-/** Max bytes of page text captured for CAPTCHA / no-results classification. */
-const PAGE_TEXT_LIMIT = 4000;
-
-/**
- * Build the extraction expression. Takes no interpolated values, so it is a
- * fixed source string (no injection surface). Returns
- * `JSON.stringify({ anchors, pageText })`.
- */
-export const buildSerpExtractionExpr = (): string => `
-  (() => {
-    const main = document.querySelector('#search, #rso, #main') || document.body;
-    const headings = Array.from(main.querySelectorAll('a h3'));
-    const seen = new Set();
-    const anchors = [];
-    for (const h3 of headings) {
-      const a = h3.closest('a[href]');
-      if (!a) continue;
-      const href = a.href;
-      if (!href || seen.has(href)) continue;
-      seen.add(href);
-      const container =
-        a.closest('div.g') ||
-        a.closest('div[data-hveid]') ||
-        a.parentElement?.parentElement ||
-        a.parentElement;
-      const containerText = container ? container.innerText || '' : '';
-      const heading = h3.innerText || h3.textContent || '';
-      const snippet = containerText.replace(heading, '').replace(/\\s+/g, ' ').trim().slice(0, 500);
-      anchors.push({ href, heading, snippet });
-    }
-    const pageText = (document.body.innerText || '').slice(0, ${PAGE_TEXT_LIMIT});
-    return JSON.stringify({ anchors, pageText });
-  })()
-`;

package/src/profile/picker.ts

@@ -1,73 +0,0 @@
-/**
- * The profile picker, shared by /browser-profile and first-run setup so both
- * show the user exactly the same list.
- *
- * Rendering rules:
- *   - one row per profile, labelled "Name (email)" — or "Name (Profile 3)" when
- *     the profile has no signed-in account, so every row keeps its shape
- *   - the pinned profile is marked with a check
- *   - a final row clears the selection, since a pin must be undoable
- *
- * `ctx.ui.select` resolves to undefined when the user presses Escape AND in
- * non-interactive modes (pi's print/RPC UI context returns undefined for every
- * dialog), so callers must treat "no answer" as "change nothing".
- */
-
-import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
-import type { BrowserProfile } from "./list";
-import type { ProfilePin } from "./store";
-
-export const CLEAR_SELECTION_LABEL = "— Clear selection (use whichever window is focused) —";
-
-export type ProfileChoice =
-  | { readonly kind: "profile"; readonly profile: BrowserProfile }
-  | { readonly kind: "clear" }
-  | { readonly kind: "cancelled" };
-
-/**
- * Two profiles can legitimately share a name and account (the same person
- * signed into two profiles). Labels must stay distinct or the selection cannot
- * be mapped back, so a repeated label gains its directory.
- */
-const disambiguate = (profiles: ReadonlyArray<BrowserProfile>): ReadonlyArray<string> => {
-  const counts = new Map<string, number>();
-  for (const p of profiles) counts.set(p.label, (counts.get(p.label) ?? 0) + 1);
-  return profiles.map((p) => ((counts.get(p.label) ?? 0) > 1 ? `${p.label} [${p.dir}]` : p.label));
-};
-
-/**
- * Show the picker and report what the user chose. Returns "cancelled" when
- * there is no UI or the user dismissed the dialog.
- */
-export const promptForProfile = async (
-  ctx: ExtensionContext,
-  profiles: ReadonlyArray<BrowserProfile>,
-  currentPin: ProfilePin | null,
-  title = "Select browser profile",
-): Promise<ProfileChoice> => {
-  if (!ctx.hasUI || profiles.length === 0) return { kind: "cancelled" };
-
-  const labels = disambiguate(profiles);
-  const rows = labels.map((label, i) => {
-    const isPinned = currentPin?.profileDir === profiles[i]?.dir;
-    return isPinned ? `✓ ${label}` : `  ${label}`;
-  });
-  const options = [...rows, CLEAR_SELECTION_LABEL];
-
-  const answer = await ctx.ui.select(title, options);
-  if (answer === undefined) return { kind: "cancelled" };
-  if (answer === CLEAR_SELECTION_LABEL) return { kind: "clear" };
-
-  const index = options.indexOf(answer);
-  const profile = index >= 0 ? profiles[index] : undefined;
-  if (!profile) return { kind: "cancelled" };
-  return { kind: "profile", profile };
-};
-
-/** Build the durable pin for a chosen profile. */
-export const pinFor = (userDataDir: string, profile: BrowserProfile): ProfilePin => ({
-  userDataDir,
-  profileDir: profile.dir,
-  label: profile.label,
-  savedAt: new Date().toISOString(),
-});

package/src/util/keycodes.ts

@@ -1,10 +0,0 @@
-const VIRTUAL_KEY_CODES: Readonly<Record<string, number>> = {
-  Enter: 13, Tab: 9, Backspace: 8, Escape: 27, Delete: 46, " ": 32,
-  ArrowLeft: 37, ArrowUp: 38, ArrowRight: 39, ArrowDown: 40,
-  Home: 36, End: 35, PageUp: 33, PageDown: 34,
-};
-
-export const SPECIAL_KEYS: ReadonlyArray<string> = Object.keys(VIRTUAL_KEY_CODES);
-
-export const virtualKeyCode = (key: string): number =>
-  VIRTUAL_KEY_CODES[key] ?? (key.length === 1 ? key.charCodeAt(0) : 0);

package/src/util/time.ts

@@ -1,29 +0,0 @@
-export const sleep = (ms: number, signal?: AbortSignal): Promise<void> =>
-  new Promise((resolve, reject) => {
-    if (signal?.aborted) {
-      reject(signal.reason ?? new Error("aborted"));
-      return;
-    }
-    const onAbort = (): void => {
-      clearTimeout(timer);
-      reject(signal?.reason ?? new Error("aborted"));
-    };
-    const timer = setTimeout(() => {
-      signal?.removeEventListener("abort", onAbort);
-      resolve();
-    }, ms);
-    signal?.addEventListener("abort", onAbort, { once: true });
-  });
-
-export type Deadline = {
-  readonly remainingMs: () => number;
-  readonly expired: () => boolean;
-};
-
-export const deadline = (totalMs: number): Deadline => {
-  const end = Date.now() + totalMs;
-  return {
-    remainingMs: () => Math.max(0, end - Date.now()),
-    expired: () => Date.now() >= end,
-  };
-};