pw-repl 0.15.0 → 0.15.1

package/lib/elements.js

@@ -9,7 +9,7 @@ const { numbers, hints, BUSY_PAGE } = require('./util');
 const { tabState } = require('./tabstate');
 const { cursorOf, aiming, aimAt, glideTo, showClick, showSelect } = require('./cursor');
 const { recordingOf, stepTarget, pauseToShow } = require('./record');
-const { settled } = require('./emulation');
+const { settled, outsideViewport, IN_VIEW } = require('./emulation');
 
 // The type a page sees for a file it is given, from its extension.
 const MIME_TYPES = {
@@ -439,7 +439,54 @@ function dateInputHolds(kind, value, what, selector) {
   return `, a ${kind} input, which now holds ${value}`;
 }
 
+// drag <x1> <y1> <x2> <y2>: for what has no element to drag by, such as a canvas or a map's pan. Moved in
+// steps, as a page that tracks the pointer needs moves between the two points, not one jump.
+const DRAG_STEPS = 10;
+
+async function dragBetween(x1, y1, x2, y2) {
+  await refuseOutside(x1, y1, 'dragged');
+  stepTarget(state.page, null, { x: x1, y: y1 });
+  await glideTo(state.page, x1, y1);
+  await state.page.mouse.move(x1, y1);
+  await state.page.mouse.down();
+  tabState(state.page).mouseAt = { x: x1, y: y1 };
+  // Pressed from here on: a failure would leave the button down, which the page would take as a drag still going.
+  try {
+    await showClick(state.page);
+    await glideTo(state.page, x2, y2);
+    await state.page.mouse.move(x2, y2, { steps: DRAG_STEPS });
+  } catch (error) {
+    await state.page.mouse.up().catch(() => {});
+    throw error;
+  }
+  await state.page.mouse.up();
+  tabState(state.page).mouseAt = { x: x2, y: y2 };
+  out.log(`Dragged from ${x1}, ${y1} to ${x2}, ${y2}${await outsideNote(x2, y2)}`);
+}
+
 // mouse's actions.
+// Playwright's mouse starts at the top left.
+const mouseAt = () => tabState(state.page).mouseAt || { x: 0, y: 0 };
+
+// A press outside the viewport reaches nothing, so it is refused rather than reported done.
+async function refuseOutside(x, y, nothing) {
+  const outside = await outsideViewport(x, y);
+  if (outside) throw new Error(`${x}, ${y} is outside the viewport (${outside}); nothing was ${nothing}. ${IN_VIEW}`);
+}
+
+// mouse down and wheel act where the mouse is.
+async function refuseMouseOutside(nothing) {
+  const { x, y } = mouseAt();
+  const outside = await outsideViewport(x, y);
+  if (outside) throw new Error(`The mouse is at ${x}, ${y}, outside the viewport (${outside}); nothing was ${nothing}. mouse move to a point inside it first, or scroll what you want into view`);
+}
+
+// A move or a release may go outside it, as a drag the page holds on to can.
+async function outsideNote(x, y) {
+  const outside = await outsideViewport(x, y);
+  return outside ? ` (outside the viewport, ${outside})` : '';
+}
+
 const MOUSE = {
   // At a point, in CSS pixels from the top left of the tab's viewport, as playwright-cli's are.
   async move(args) {
@@ -449,7 +496,7 @@ const MOUSE = {
     await glideTo(state.page, x, y);
     await state.page.mouse.move(x, y);
     tabState(state.page).mouseAt = { x, y };
-    out.log(`Moved the mouse to ${x}, ${y}`);
+    out.log(`Moved the mouse to ${x}, ${y}${await outsideNote(x, y)}`);
   },
 
   // A click at a point, as Playwright's mouse.click: for what has no selector, such as a marker drawn on a canvas.
@@ -462,6 +509,7 @@ const MOUSE = {
     const held = delay ? Number(delay.value) : 0;
     const [x, y, extra] = numbers(words.join(' '), usage);
     if (y === undefined || extra !== undefined) throw new Error(`Usage: ${usage}, in CSS pixels from the top left of the viewport`);
+    await refuseOutside(x, y, 'clicked');
     stepTarget(state.page, null, { x, y });
     await glideTo(state.page, x, y);
     await state.page.mouse.move(x, y);
@@ -483,6 +531,7 @@ const MOUSE = {
     const { words, button } = mouseArgs(line, usage);
     const [x, y, extra] = numbers(words.join(' '), usage);
     if (y === undefined || extra !== undefined) throw new Error(`Usage: ${usage}, in CSS pixels from the top left of the viewport`);
+    await refuseOutside(x, y, 'clicked');
     stepTarget(state.page, null, { x, y });
     await glideTo(state.page, x, y);
     await state.page.mouse.dblclick(x, y, { button });
@@ -493,6 +542,7 @@ const MOUSE = {
 
   async down(args) {
     const button = mouseButton(args, 'mouse down');
+    await refuseMouseOutside('pressed');
     await glideToMouse();
     await state.page.mouse.down({ button });
     await showClick(state.page);
@@ -503,13 +553,14 @@ const MOUSE = {
     const button = mouseButton(args, 'mouse up');
     await glideToMouse();
     await state.page.mouse.up({ button });
-    out.log(`Released the ${button} button`);
+    out.log(`Released the ${button} button${await outsideNote(mouseAt().x, mouseAt().y)}`);
   },
 
   // Wheel events where the mouse is (mouse move puts it there): a map zooms around that point.
   async wheel(args) {
     const [dx, dy, extra] = numbers(args, 'mouse wheel <dx> <dy>');
     if (dy === undefined || extra !== undefined) throw new Error('Usage: mouse wheel <dx> <dy>, e.g. mouse wheel 0 300 scrolls down (negative dy up)');
+    await refuseMouseOutside('scrolled');
     await glideToMouse();
     if (recordingOf(state.page)) await smoothWheel(dx, dy);
     else await state.page.mouse.wheel(dx, dy);
@@ -534,7 +585,9 @@ const commands = {
   // source, press, hover the target, release), so the cursor can glide to each in turn. Chromium turns
   // the moves into an HTML5 drag when the source is draggable.
   async drag(args) {
-    const usage = 'Usage: drag <from> <to>, each a selector or a ref, quoted if it has spaces: drag e5 e9, drag "text=Item 1" "#list li"';
+    const usage = 'Usage: drag <from> <to>, each a selector or a ref, quoted if it has spaces: drag e5 e9, drag "text=Item 1" "#list li"; or drag <x1> <y1> <x2> <y2>, points in the viewport';
+    const words = (args || '').trim().split(/\s+/);
+    if (words.length === 4 && words.every(w => /^-?\d+(?:\.\d+)?$/.test(w))) return dragBetween(...words.map(Number));
     const from = splitSelector(args);
     const to = from?.rest !== undefined ? splitSelector(from.rest) : null;
     if (!to || to.rest !== undefined) throw new Error(usage);

package/lib/emulation.js

@@ -24,6 +24,25 @@ async function viewportText() {
   return size ? `${size} (the window's page area)` : 'unknown';
 }
 
+// The viewport's size, in the CSS pixels mouse and touch points are given in: a phone's, a size set
+// with viewport, or else the page's (a tab attached over CDP has none set, so Playwright knows none).
+async function viewportSize() {
+  const device = tabState(state.page).emulation?.device;
+  if (device) return devices[device].viewport;
+  const set = tabState(state.page).viewport;
+  if (set) return set;
+  return state.page.evaluate(() => ({ width: innerWidth, height: innerHeight })).catch(() => null);
+}
+
+// The viewport's size (1280x657) when a point is outside it; null when it is inside, or the size is unknown.
+async function outsideViewport(x, y) {
+  const size = await viewportSize();
+  if (!size || x >= 0 && y >= 0 && x < size.width && y < size.height) return null;
+  return `${size.width}x${size.height}`;
+}
+
+const IN_VIEW = 'A point is in CSS pixels from the top left of the viewport: scroll what you want into view (eval document.querySelector(<selector>).scrollIntoView(), or mouse wheel), then measure it again';
+
 const DEFAULT_DEVICE = 'Pixel 7';
 const EMULATE_KINDS = ['mobile', 'dark', 'light', 'locale', 'timezone'];
 
@@ -234,4 +253,4 @@ const commands = {
   },
 };
 
-module.exports = { commands, viewportText, EMULATE_KINDS, emulatedKinds, deviceMetrics, viewportMetrics, setEmulation, setViewport, settled, reapplyMetrics };
+module.exports = { commands, viewportText, outsideViewport, IN_VIEW, EMULATE_KINDS, emulatedKinds, deviceMetrics, viewportMetrics, setEmulation, setViewport, settled, reapplyMetrics };

package/lib/help.js

@@ -237,15 +237,16 @@ sent, as when the page stops answering, the outcome is unknown.`,
   },
   hover: { usage: 'hover <selector>', summary: 'hover, choosing the match as click does' },
   drag: {
-    usage: 'drag <from> <to>',
-    summary: 'drag one element onto another',
+    usage: 'drag <from> <to> | <x1> <y1> <x2> <y2>',
+    summary: 'drag an element onto another, or between points',
     args: [
       ['<from> <to>', 'selectors or snapshot refs, each quoted if it has spaces: drag e5 e9, drag "text=Item 1" "#done ul".'],
+      ['<x1> <y1> <x2> <y2>', 'points, as for mouse commands: presses the left button at the first, moves to the second in 10 steps, and releases. For what has no element to drag by: a canvas, panning a map. The first point must be in the viewport; the second may be outside it.'],
     ],
     detail: `As Playwright's dragTo: it hovers the first match of <from>, presses the left button, hovers the
 first match of <to>, and releases, waiting up to 5s in all for each to be ready. An HTML5 drag (a
 draggable element) gets dragstart, dragover and drop; any other gets pointer and mouse events. A drag
-through points of its own: mouse move, mouse down, mouse move, mouse up.`,
+through more points than two: mouse move, mouse down, mouse move as often as needed, mouse up.`,
   },
   touch: {
     usage: 'touch <gesture> <x> <y> ...',
@@ -257,7 +258,8 @@ through points of its own: mouse move, mouse down, mouse move, mouse up.`,
       ['swipe <x> <y> <dx> <dy>', 'one finger down at x,y, moved by dx,dy in small steps about a frame apart, then lifted.'],
       ['pinch <x> <y> <scale>', 'two fingers side by side about x,y, 100px apart, moved apart until they are scale times that far apart, then lifted: 2 zooms in, under 1 (0.5) pinches in.'],
     ],
-    detail: `<x> <y> are CSS pixels from the top left of the viewport, as for mouse commands. It needs a touch screen:
+    detail: `<x> <y> are CSS pixels from the top left of the viewport, as for mouse commands. A finger put down outside the
+viewport is refused; a swipe may end outside it. It needs a touch screen:
 emulate mobile, then reload, so the page sees one; without it, touch refuses.
 
 Chromium takes a tap sent soon after a swipe or pinch as part of it, with no click: up to a few seconds
@@ -277,12 +279,13 @@ with no points, which lifts the rest.`,
       ['move <x> <y>', 'moves the mouse there: CSS pixels from the top left of the tab\'s viewport (not the page), as mouse events have them.'],
       ['click <x> <y> [button]', 'clicks there: left, right or middle (Default: left), or --button=<button>; --click-count=<n> as click\'s (2 a double-click, 3 a triple-click); --delay=<ms> holds the button that long, as Playwright\'s mouse.click delay.'],
       ['dblclick <x> <y> [button]', 'mouse click --click-count=2, as Playwright\'s mouse.dblclick: two clicks and a dblclick. Two mouse clicks are two single clicks, which fire no dblclick.'],
-      ['down [button] | up [button]', 'presses or releases a button where the mouse is. A drag: mouse down, mouse move to another point, mouse up.'],
+      ['down [button] | up [button]', 'presses or releases a button where the mouse is. From one point to another, drag <x1> <y1> <x2> <y2> drags; through more: mouse down, mouse move to each point, mouse up.'],
       ['wheel <dx> <dy>', 'turns the wheel where the mouse is; positive dy scrolls down. A map zooms around the mouse: mouse move 400 300, then mouse wheel 0 -300 zooms in. It returns once the events are sent, not once the page has redrawn; while recording, it scrolls in eased steps over up to 1s (help record).'],
     ],
     detail: `For what has no selector, such as a marker drawn on a canvas; anything a selector finds is better
 clicked with click, which waits for it. The mouse stays where it went, for a mouse wheel or mouse down
-after it. The cursor (help cursor) moves there first and shows a ring at a press. Under emulate mobile it is
+after it. A click, or a mouse down or wheel, outside the viewport is refused: nothing there gets
+it. mouse move and mouse up go there and say so, as a drag the page holds on to can. The cursor (help cursor) moves there first and shows a ring at a press. Under emulate mobile it is
 still the mouse; touch sends a finger's events (help touch).
 
 A snapshot has no coordinates; eval of getBoundingClientRect gives an element's centre:
@@ -896,10 +899,12 @@ in front of it usually holds the request open, so the page spins instead of fail
     ],
     options: [
       ['--file=<path>', 'the JavaScript is the file\'s text: anything the line takes, over many lines and with // comments. With a ref or a selector after the path, it is a function called with that element (the first match). Over send, a relative path is from your shell\'s current folder.'],
-      ['--timeout=<time>', 'how long the page has to answer, before --file. Default: 15s. Past 20s, give send time too, or it gives up first and cancels the eval: pw-repl send -t 70s eval --timeout=60s ...'],
+      ['--timeout=<time>', 'how long the page has to answer. Default: 15s. Past 20s, give send time too, or it gives up first and cancels the eval: pw-repl send -t 70s eval --timeout=60s ...'],
       ['--all', 'the whole result, not capped.'],
     ],
-    detail: `eval fetch(...) sends a new request, which can change state on the server; it cannot read one that
+    detail: `Its options go before the JavaScript, in any order; --all may also go at the very end, after it.
+
+eval fetch(...) sends a new request, which can change state on the server; it cannot read one that
 already happened (requests lists those).
 
 Long work (--timeout): every other command waits while an eval runs, the other clients' too. For work of
@@ -1113,8 +1118,15 @@ const SHELL_COMMANDS = new Set(['run', 'serve', 'send', 'attach', 'stop', 'where
 // Commands that were renamed, so the old name says where it went.
 const RENAMED = { mouseclick: 'mouse click', mousedblclick: 'mouse dblclick' };
 
+// An action of mouse or touch (help swipe) is found under its command; one that is a command itself (click) has its own help.
+function actionOf(topic) {
+  return ['mouse', 'touch'].find(command => COMMANDS[command].args.some(([usage]) => usage.split(' | ').some(u => u.split(' ')[0] === topic)));
+}
+
 function notFound(topic) {
   if (Object.hasOwn(RENAMED, topic)) return `${topic} is now ${RENAMED[topic]}: help ${RENAMED[topic].split(' ')[0]}`;
+  const command = actionOf(topic);
+  if (command) return `${topic} is ${command} ${topic}: help ${command}`;
   if (SHELL_COMMANDS.has(topic)) return `${topic} is run at the shell (pw-repl ${topic}), not in the REPL; pw-repl --help has its options`;
   return `No help for ${topic}. Topics: ${Object.keys(TOPICS).join(', ')}`;
 }

package/lib/inspect.js

@@ -493,75 +493,96 @@ const commands = {
 
   async eval(args, all) {
     if (!args) throw new Error('Usage: eval <js-expression>');
-    // eval --timeout=<time> [--file=...] <JavaScript>: how long the page has to answer.
+    // Its options, in any order, before the JavaScript; once that starts, nothing is an option (x --all is JavaScript).
+    // --timeout=<time>: how long the page has to answer. --file=<path>: the JavaScript is the file's text.
     let timeout = COMMAND_TIMEOUT;
-    const timed = /^--timeout(?:=|\s+)(\S+)(?:\s+([\s\S]*))?$/.exec(args.trim());
-    if (/^--timeout(?:[=\s]|$)/.test(args.trim())) {
-      timeout = parseDuration(timed?.[1]);
-      if (!timeout) throw new Error('Usage: eval --timeout=<time> <JavaScript>, a time in ms or with s: eval --timeout=60s ...');
-      args = timed[2] || '';
-      if (!args.trim()) throw new Error('Usage: eval --timeout=<time> <JavaScript>');
-    }
-    let ref = null;
-    // eval --file=<path> [<ref or selector>]: the file's text is what the line would be, over as many lines as
-    // it likes. The rest of the line can only be the element, so any selector goes there, not only a ref.
-    const fromFile = /^--file(?:=|\s+)("(?:[^"\\]|\\.)*"|'[^']*'|\S+)(?:\s+([\s\S]*))?$/.exec(args.trim());
-    if (/^--file(?:[=\s]|$)/.test(args.trim())) {
-      if (!fromFile) throw new Error('Usage: eval --file=<path> [<ref or selector>]: the JavaScript is in the file');
-      const file = path.resolve(unquote(fromFile[1]));
-      const target = fromFile[2]?.trim() || null;
-      try { args = fs.readFileSync(file, 'utf8').trim(); } catch (error) {
-        // eval --file=my dir/x.js reads "my" as the file and "dir/x.js" as the element.
-        throw new Error(`eval --file: cannot read ${file} (${error.code || error.message})${target ? '; quote a path with spaces' : ''}`);
+    let file = null;
+    args = args.trim();
+    for (let option; (option = /^--(all|timeout|file)(?=[=\s]|$)/.exec(args));) {
+      if (option[1] === 'all') {
+        if (!/^--all(?:\s|$)/.test(args)) break;
+        all = true;
+        args = args.slice(5).trimStart();
+      } else if (option[1] === 'timeout') {
+        const timed = /^--timeout(?:=|\s+)(\S+)(?:\s+|$)/.exec(args);
+        timeout = parseDuration(timed?.[1]);
+        if (!timeout) throw new Error('Usage: eval --timeout=<time> <JavaScript>, a time in ms or with s: eval --timeout=60s ...');
+        args = args.slice(timed[0].length);
+      } else {
+        const named = /^--file(?:=|\s+)("(?:[^"\\]|\\.)*"|'[^']*'|\S+)(?:\s+|$)/.exec(args);
+        if (!named) throw new Error('Usage: eval --file=<path> [<ref or selector>]: the JavaScript is in the file');
+        file = path.resolve(unquote(named[1]));
+        args = args.slice(named[0].length);
       }
-      if (!args) throw new Error(`eval --file: ${file} is empty`);
-      ref = target && unquote(target);
-    } else {
-      // eval <function> <ref> calls the function with that element, as playwright-cli's eval does.
-      const onRef = /^([\s\S]+?)\s+((?:f\d+)?e\d+)$/.exec(args.trim());
-      if (onRef && isFunctionText(unquote(onRef[1]))) [args, ref] = [unquote(onRef[1]), onRef[2]];
     }
-    if (ref) {
-      const selector = toSelector(ref);
-      const el = await onElement(selector, () => state.page.locator(selector).first().elementHandle({ timeout: 5000 }));
-      try {
-        // Made from its text by the debugger, as eval is, so a page's CSP cannot
-        // refuse it, and in the element's own frame, which may be an iframe.
-        const fn = await evaluated((await el.ownerFrame()).evaluateHandle(args), timeout);
+    // An option after the JavaScript is JavaScript to the page; a SyntaxError from it says so.
+    const late = !file && /(?:^|\s)(--(?:timeout|file|all))(?=[=\s]|$)/.exec(args)?.[1];
+    const run = async () => {
+      let ref = null;
+      // eval --file=<path> [<ref or selector>]: the file's text is what the line would be, over as many lines as
+      // it likes. The rest of the line can only be the element, so any selector goes there, not only a ref.
+      if (file) {
+        const target = args || null;
+        try { args = fs.readFileSync(file, 'utf8').trim(); } catch (error) {
+          // eval --file=my dir/x.js reads "my" as the file and "dir/x.js" as the element.
+          throw new Error(`eval --file: cannot read ${file} (${error.code || error.message})${target ? '; quote a path with spaces' : ''}`);
+        }
+        if (!args) throw new Error(`eval --file: ${file} is empty`);
+        ref = target && unquote(target);
+      } else {
+        if (!args) throw new Error('Usage: eval [--all] [--timeout=<time>] <JavaScript>');
+        // eval <function> <ref> calls the function with that element, as playwright-cli's eval does.
+        const onRef = /^([\s\S]+?)\s+((?:f\d+)?e\d+)$/.exec(args);
+        if (onRef && isFunctionText(unquote(onRef[1]))) [args, ref] = [unquote(onRef[1]), onRef[2]];
+      }
+      if (ref) {
+        const selector = toSelector(ref);
+        const el = await onElement(selector, () => state.page.locator(selector).first().elementHandle({ timeout: 5000 }));
         try {
-          printOutput(await evaluated(el.evaluate((e, f) => f(e), fn), timeout), all);
+          // Made from its text by the debugger, as eval is, so a page's CSP cannot
+          // refuse it, and in the element's own frame, which may be an iframe.
+          const fn = await evaluated((await el.ownerFrame()).evaluateHandle(args), timeout);
+          try {
+            printOutput(await evaluated(el.evaluate((e, f) => f(e), fn), timeout), all);
+          } finally {
+            await fn.dispose().catch(() => {});
+          }
         } finally {
-          await fn.dispose().catch(() => {});
+          await el.dispose().catch(() => {});
         }
-      } finally {
-        await el.dispose().catch(() => {});
+        return;
       }
-      return;
-    }
-    // A function, as playwright-cli's eval takes, is called rather than returned.
-    // Only a single expression can be one; statements are evaluated as they are.
-    // await at the top level: one expression is run as an async function; statements as DevTools'
-    // console runs them (replMode), which gives back the last one's value.
-    const compiles = (Kind, body) => { try { new Kind(body); return true; } catch { return false; } };
-    const AsyncFunction = (async () => {}).constructor;
-    const awaits = /\bawait\b/.test(args) && !compiles(Function, `return (${args}\n);`);
-    const single = compiles(awaits ? AsyncFunction : Function, `return (${args}\n);`);
-    const call = `const value = (${args}\n); return typeof value === 'function' ? value() : value;`;
-    if (awaits && !single && compiles(AsyncFunction, args)) {
-      const session = await keptSession(state.page);
-      const { result, exceptionDetails } = await evaluated(session.send('Runtime.evaluate', { expression: args, replMode: true, awaitPromise: true, returnByValue: true }), timeout);
-      if (exceptionDetails) throw new Error(exceptionDetails.exception?.description || exceptionDetails.text);
-      printOutput(result.value !== undefined ? result.value : result.description ?? 'undefined', all);
-      return;
-    }
-    const expression = single ? `(${awaits ? 'async ' : ''}() => { ${call} })()` : args;
-    const value = await evaluated(state.page.evaluate(expression), timeout);
-    // An empty string is shown as one, not as no output at all.
-    printOutput(value === '' ? '""' : value, all);
-    // Quotes around the whole of it, as a shell's quoting sent on, make it a string, not code to run:
-    // one plain literal only, not "a" + b or a template with ${...} in it, which ran.
-    if (typeof value === 'string' && value && /^(?:"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\$]|\\.|\$(?!\{))*`)$/s.test(args.trim())) {
-      out.log('(That is a string: the JavaScript was in quotes, which eval keeps. Without them, it runs: eval document.title)');
+      // A function, as playwright-cli's eval takes, is called rather than returned.
+      // Only a single expression can be one; statements are evaluated as they are.
+      // await at the top level: one expression is run as an async function; statements as DevTools'
+      // console runs them (replMode), which gives back the last one's value.
+      const compiles = (Kind, body) => { try { new Kind(body); return true; } catch { return false; } };
+      const AsyncFunction = (async () => {}).constructor;
+      const awaits = /\bawait\b/.test(args) && !compiles(Function, `return (${args}\n);`);
+      const single = compiles(awaits ? AsyncFunction : Function, `return (${args}\n);`);
+      const call = `const value = (${args}\n); return typeof value === 'function' ? value() : value;`;
+      if (awaits && !single && compiles(AsyncFunction, args)) {
+        const session = await keptSession(state.page);
+        const { result, exceptionDetails } = await evaluated(session.send('Runtime.evaluate', { expression: args, replMode: true, awaitPromise: true, returnByValue: true }), timeout);
+        if (exceptionDetails) throw new Error(exceptionDetails.exception?.description || exceptionDetails.text);
+        printOutput(result.value !== undefined ? result.value : result.description ?? 'undefined', all);
+        return;
+      }
+      const expression = single ? `(${awaits ? 'async ' : ''}() => { ${call} })()` : args;
+      const value = await evaluated(state.page.evaluate(expression), timeout);
+      // An empty string is shown as one, not as no output at all.
+      printOutput(value === '' ? '""' : value, all);
+      // Quotes around the whole of it, as a shell's quoting sent on, make it a string, not code to run:
+      // one plain literal only, not "a" + b or a template with ${...} in it, which ran.
+      if (typeof value === 'string' && value && /^(?:"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\$]|\\.|\$(?!\{))*`)$/s.test(args.trim())) {
+        out.log('(That is a string: the JavaScript was in quotes, which eval keeps. Without them, it runs: eval document.title)');
+      }
+    };
+    try {
+      await run();
+    } catch (error) {
+      if (late && /SyntaxError/.test(error.message)) error.message += `\n(${late} after the JavaScript is read as JavaScript: eval's options go before it)`;
+      throw error;
     }
   },
 

package/lib/send.js

@@ -93,12 +93,15 @@ function doubleQuote(word) {
   return `"${word.replace(/[\\"]/g, '\\$&').replace(/\n/g, '\\n').replace(/\r/g, '\\r').replace(/\t/g, '\\t')}"`;
 }
 
-// Where eval's --file is, after its --timeout if it has one; -1 when it has none.
+// Where eval's --file is, among its options before the JavaScript (--all, --timeout); -1 when it has none.
 function evalFileAt(words) {
   if (words[0] !== 'eval') return -1;
   let at = 1;
-  if (/^--timeout=/.test(words[at] || '')) at += 1;
-  else if (words[at] === '--timeout') at += 2;
+  for (;;) {
+    if (words[at] === '--all' || /^--timeout=/.test(words[at] || '')) at += 1;
+    else if (words[at] === '--timeout') at += 2;
+    else break;
+  }
   return /^--file(?:=|$)/.test(words[at] || '') ? at : -1;
 }
 

package/lib/touch.js

@@ -6,6 +6,7 @@ const out = require('./output');
 const { numbers, parseDuration, durationText } = require('./util');
 const { tabState } = require('./tabstate');
 const { keptSession } = require('./cdp');
+const { outsideViewport, IN_VIEW } = require('./emulation');
 
 const GESTURES = ['tap', 'doubletap', 'longpress', 'swipe', 'pinch'];
 const LONGPRESS = 800;
@@ -53,6 +54,9 @@ const commands = {
     const values = numbers(rest.join(' '), usageOf(gesture));
     if (values.length < (gesture === 'longpress' ? 2 : counts) || values.length > counts) throw new Error(usage);
     const [x, y] = values;
+    // A finger put down outside the viewport touches nothing; a swipe may still end outside it.
+    const outside = await outsideViewport(x, y);
+    if (outside) throw new Error(`${x}, ${y} is outside the viewport (${outside}); nothing was touched. ${IN_VIEW}`);
     if (gesture === 'tap') {
       await tap(x, y);
       out.log(`Tapped at ${x}, ${y}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pw-repl",
-  "version": "0.15.0",
+  "version": "0.15.1",
   "description": "Text REPL for driving an existing Chromium through Playwright over CDP",
   "keywords": [
     "playwright",

package/skill/SKILL.md

@@ -53,14 +53,15 @@ first tab).
 - `pw-repl serve` runs the same in a terminal, where the pane shows every command. Its prompt is
   `pw[serve]>`. It stops at that prompt (`quit`, or Ctrl-C); `pw-repl stop` is for a background one.
 - Add `--launch` to `run` or `serve` (with or without `--background`) to have it start a Chromium of its
-  own instead of connecting to one: headless unless `--headed`, in a 1280x800 window, in a temporary
-  profile, on a free port of its own (never 9222). It stops with the REPL, Ctrl-C while it starts
-  included, and `stop` returns once it has exited. It prints the command it ran; flags after `--` are
-  passed to that Chromium (only flags: a start URL goes before `--`), and a `--user-data-dir=<dir>`
-  among them is used instead of the temporary profile, and kept. Started again in a kept profile,
-  Chromium picks up where it left off, as it would for the user, headless too: its tabs come back, and
-  session cookies with them, so a login stays. They start loading before the REPL is attached, so
-  `requests` and `console` have only what came after, often nothing: `reload` for a full record.
+  own instead of connecting to one: headless unless `--headed`, in a 1280x800 window (a 1280x657 page
+  headless; info shows the viewport mouse points are in), in a temporary profile, on a free port of its
+  own (never 9222). It stops with the REPL, Ctrl-C while it starts included, and `stop` returns once it
+  has exited. It prints the command it ran; flags after `--` are passed to that Chromium (only flags: a
+  start URL goes before `--`), and a `--user-data-dir=<dir>` among them is used instead of the temporary
+  profile, and kept. Started again in a kept profile, Chromium picks up where it left off, as it would for
+  the user, headless too: its tabs come back, and session cookies with them, so a login stays. They start
+  loading before the REPL is attached, so `requests` and `console` have only what came after, often
+  nothing: `reload` for a full record.
 - `pw-repl run` runs it in a terminal with no server; `send` then reaches it through tmux, if it runs in
   the tmux session `pw-repl`: