scenescout 3.23.3 → 3.23.4

package/dist/engine/memory.js

@@ -3,6 +3,7 @@ import crypto from "node:crypto";
 import path from "node:path";
 import { laneRoutePaths, normalizePath, shortHash, stripRouteQuery } from "./fingerprint.js";
 import { isFormBookkeeping } from "./forms.js";
+import { maskSecretFieldValues, maskSecretParams, redactPersonal } from "./sensitive.js";
 import { readFromRunNotes, readRunRecords, recordFromJson, unionFromRunNotes, unionRecords } from "./from-run.js";
 import { addReading, addVerdict, MAX_TICKETS_KEPT, mergeTicketData } from "./tickets.js";
 /**
@@ -230,20 +231,30 @@ const SECRET_PATTERNS = [
     [/\b(api[-_]?key|secret|password|token)(["'\s:=]+)(?=[A-Za-z0-9._~+/=-]*\d)(?=[A-Za-z0-9._~+/=-]*[A-Za-z])[A-Za-z0-9._~+/=]{12,}/gi, "$1$2[redacted]"],
 ];
 /**
- * Strip anything that looks like a credential from text we are about to persist.
+ * Strip anything that looks like a credential from text we are about to
+ * persist: credential shapes, a value typed into a field whose label names a
+ * secret (`textbox "Password" ← "…"`, whatever its length), the value of a
+ * parameter named for one (`?password=…`), and personal data
+ * (email addresses and card numbers, sensitive.ts).
  *
  * Silent edits are their own hazard, so a redaction announces itself: a reader
  * who sees mangled-looking text needs to know the tool did it deliberately.
+ * Credentials and masked values are counted in a trailing note; personal data
+ * is replaced by a marker that names it (`[email redacted]`).
  */
 export function redactSecrets(text) {
-    let out = text;
-    let hits = 0;
+    const masked = maskSecretFieldValues(text);
+    // A parameter named for a secret (`?pin=…` from a GET form) is masked whatever its value looks like.
+    const params = maskSecretParams(masked.text);
+    let out = params.text;
+    let hits = masked.hits + params.hits;
     for (const [re, replacement] of SECRET_PATTERNS) {
         out = out.replace(re, (...args) => {
             hits += 1;
             return replacement.replace(/\$(\d)/g, (_, n) => String(args[Number(n)] ?? ""));
         });
     }
+    out = redactPersonal(out);
     return hits > 0 ? `${out} [${hits} secret${hits === 1 ? "" : "s"} redacted]` : out;
 }
 /**
@@ -1927,11 +1938,17 @@ export class MemoryStore {
      * Append to the action log — the choke point where redaction belongs.
      *
      * Redacting only a finding's title/detail/evidence left the same secrets
-     * flowing by a parallel route: `repro` is built from these entries, and a
-     * `type` step logs the text that was typed (a password, during an auth-flow
-     * pass) while every entry carries a full URL that may hold `?token=…`. Both
-     * land in memory.json and are rendered into the report. One filter here
+     * flowing by a parallel route: `repro` is built from these entries, a `type`
+     * step logs the text that was typed, and every entry carries a full URL that
+     * may hold `?token=…`. All of it lands in memory.json and is rendered into
+     * the report, the live view's feed and exported issues. One filter here
      * covers the log, the repro traces and the JSONL trail at once.
+     *
+     * A value typed into a secret field (type=password, a credential or card
+     * autocomplete token, or a name or label that says so) is masked by the
+     * browser before it gets here (sensitive.ts secretFieldKind). redactSecrets
+     * masks it again where only the label is left to go on, and catches
+     * credential shapes, email addresses and card numbers in anything else.
      */
     logAction(entry) {
         const full = {

package/dist/engine/open.js

@@ -34,7 +34,7 @@ export function openChoiceFromEnv(env) {
  * browser would open on the remote machine if at all, or a Linux or other
  * Unix machine with no display server. macOS and Windows always have one.
  */
-export function noDisplay(env, platform) {
+function noDisplay(env, platform) {
     if (env.SSH_CONNECTION || env.SSH_TTY)
         return true;
     if (platform === "darwin" || platform === "win32")

package/dist/engine/oracles.js

@@ -196,7 +196,7 @@ export function isRouteCancellation(message, c) {
     return ROUTE_CANCEL_RE.test(message) || (c.viaLink && c.dialogOpened);
 }
 /** Appended to a page error read as a route-change cancellation, saying which evidence it was read on. */
-export function routeCancelNote(message) {
+function routeCancelNote(message) {
     const why = ROUTE_CANCEL_RE.test(message)
         ? "the click left the URL unchanged and the error says the route change was cancelled"
         : "the click on a link left the URL unchanged and the page opened a dialog instead";
@@ -456,7 +456,7 @@ export class OracleMonitor {
  * uncaught exception, a failed request, typed markup coming back, a page
  * contradicting the server, a token posted to any origin) stops a plan either way.
  */
-export const CONTINUABLE_KINDS = new Set(["http_error", "console_error"]);
+const CONTINUABLE_KINDS = new Set(["http_error", "console_error"]);
 /** Whether these violations, drained after one plan step, end the plan. Repeats of already-reported violations never do. */
 export function planStopsAt(violations, rule) {
     const fresh = violations.filter((v) => !v.repeat);

package/dist/engine/plain.js

@@ -184,7 +184,7 @@ function joinAnd(parts) {
     return parts.length <= 1 ? parts.join("") : `${parts.slice(0, -1).join(", ")} and ${parts[parts.length - 1]}`;
 }
 /** The short summary that opens the plain section. */
-export function plainSummary(input) {
+function plainSummary(input) {
     const lines = [];
     const { current } = input;
     const by = (s) => current.filter((f) => f.severity === s).length;

package/dist/engine/png.js

@@ -12,7 +12,7 @@ const SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
 /** Channels a pixel has, by PNG colour type: grey, RGB, grey and alpha, RGBA. Palette images are not read. */
 const CHANNELS = { 0: 1, 2: 3, 4: 2, 6: 4 };
 /** The largest picture read or diffed, in pixels. An element's capture is far smaller; this bounds the memory a bad file can ask for. */
-export const MAX_PIXELS = 40_000_000;
+const MAX_PIXELS = 40_000_000;
 const CRC_TABLE = (() => {
     const t = new Uint32Array(256);
     for (let n = 0; n < 256; n++) {
@@ -162,7 +162,7 @@ export function encodePng(img) {
  * match exactly; the allowance absorbs the odd colour rounded one step
  * differently, not a change anyone would see.
  */
-export const DIFF_THRESHOLD = 8;
+const DIFF_THRESHOLD = 8;
 /** The colour a changed pixel is painted in the diff picture. */
 export const DIFF_HIGHLIGHT = [255, 0, 80];
 /**

package/dist/engine/policy.js

@@ -3,6 +3,7 @@
  * with elements whose accessible name / testid / id matches these patterns —
  * enforcement lives here, at the tool layer, never in the model's prompt.
  */
+import { scriptLiteral } from "./script-literal.js";
 const DESTRUCTIVE_PATTERNS = [
     /\bdelete\b/i,
     // "Remove" a filter chip drops a condition from the view: "Remove Status:
@@ -634,9 +635,8 @@ export function offAppPageWrite(appUrl, pageUrl, destinationUrl, movedByEmbed) {
  * the browser without asking, and the page it lands on was not sandboxed.
  */
 export function sandboxedRedirectPage(target) {
-    const json = JSON.stringify(target).replace(/</g, "\\u003c");
     // No referrer: the next hop would otherwise name this stand-in page, where a real redirect names the app.
-    return `<!doctype html><meta charset="utf-8"><meta name="referrer" content="no-referrer"><script>location.replace(${json});</script>`;
+    return `<!doctype html><meta charset="utf-8"><meta name="referrer" content="no-referrer"><script>location.replace(${scriptLiteral(target)});</script>`;
 }
 /** The last path segment of a page that is a sign-in page, and nothing else: not a verification step, where a payment provider's frame sits. */
 const SIGN_IN_SEGMENT_RE = /^(login|log-in|signin|sign-in|signup|sign-up|sso|oauth)$/i;

package/dist/engine/postmessage.js

@@ -50,18 +50,18 @@ import { normalizePath } from "./fingerprint.js";
 /** The binding the capture script reports through. */
 export const POSTMESSAGE_BINDING = "__scenescoutPostMessage";
 /** Strings shorter than this are not sent to the engine: nothing token-shaped is shorter. */
-export const MIN_CANDIDATE_LENGTH = 16;
+const MIN_CANDIDATE_LENGTH = 16;
 /** Longest string sent; a JWT carrying many claims runs to a few kilobytes. */
-export const MAX_CANDIDATE_LENGTH = 8192;
+const MAX_CANDIDATE_LENGTH = 8192;
 /** Longest JSON-looking string sent whole, so the engine can parse it; a longer one is cut and its contents go unread. */
-export const MAX_JSON_LENGTH = 262144;
+const MAX_JSON_LENGTH = 262144;
 /** Most values the walk visits per message: a large array or a binary buffer must not stall the app's call. */
-export const MAX_VISITS = 2000;
+const MAX_VISITS = 2000;
 /** Most items read from any one array or object. */
 export const MAX_ITEMS = 200;
 /** Most strings sent per message, and the deepest nesting walked. */
-export const MAX_CANDIDATES = 50;
-export const MAX_DEPTH = 6;
+const MAX_CANDIDATES = 50;
+const MAX_DEPTH = 6;
 /** Whether a targetOrigin lets any origin read the message. Only "*" does; "/" is the sender's own origin. */
 export function postsToAnyOrigin(targetOrigin) {
     return targetOrigin === "*";
@@ -139,7 +139,7 @@ export function postMessageCaptureScript(binding = POSTMESSAGE_BINDING) {
 })();`;
 }
 /** Key names, lower-cased with `_` and `-` removed, whose value is a credential. */
-export const CREDENTIAL_KEYS = new Set([
+const CREDENTIAL_KEYS = new Set([
     "accesstoken",
     "idtoken",
     "refreshtoken",

package/dist/engine/project-folder.js

@@ -25,7 +25,7 @@ import { MEMORY_DIRNAME } from "./memory.js";
 /** The setting: an absolute folder that holds one folder per tested site, or `off`. */
 export const PROJECTS_DIR_ENV = "SCENESCOUT_PROJECTS_DIR";
 /** The folder made under the documents folder when the setting is unset. */
-export const DEFAULT_PROJECTS_DIRNAME = "SceneScout";
+const DEFAULT_PROJECTS_DIRNAME = "SceneScout";
 /**
  * The user's documents folder. Windows: `%USERPROFILE%\Documents`; Linux and
  * others: XDG_DOCUMENTS_DIR from the environment or user-dirs.dirs (which the

package/dist/engine/provider.js

@@ -2,7 +2,7 @@
 export class MalformedReply extends Error {
 }
 /** The most output one model call may produce. Large enough for a plan of steps; small enough that one reply cannot spend the budget. */
-export const MAX_OUTPUT_TOKENS = 16_000;
+const MAX_OUTPUT_TOKENS = 16_000;
 /** A plain object as a record, or null for anything else (an array, null, a string). */
 export const obj = (v) => (v && typeof v === "object" && !Array.isArray(v) ? v : null);
 const num = (v) => (typeof v === "number" && Number.isFinite(v) && v >= 0 ? v : 0);

package/dist/engine/replay.js

@@ -21,6 +21,7 @@
 import crypto from "node:crypto";
 import path from "node:path";
 import { isSafeRelativePath } from "./plain.js";
+import { scriptLiteral } from "./script-literal.js";
 /** Most frames one recorded session keeps. A long run is thousands of actions, and a project folder is not a video store. */
 export const RECORD_MAX_FRAMES = 600;
 /** A name reduced to one plain path segment: letters, digits, dot, dash and underscore, never leading with a dot or dash. */
@@ -407,7 +408,8 @@ details.evidence figcaption { margin-top:4px; color:var(--muted); font:11px/1.5
 function exitWatch(savedFile) {
     return ("<script>(function () {\n" +
         "  var saved = " +
-        JSON.stringify(savedFile) +
+        // Escaped: a folder named with "</script>" must not end this element.
+        scriptLiteral(savedFile) +
         ";\n" +
         "  var gone = false;\n" +
         "  var bar = document.getElementById('gone-bar');\n" +

package/dist/engine/report.js

@@ -117,7 +117,7 @@ function projectName(dir) {
  * when there are none. The first bullet names the id, as a finding's does, so
  * the live view hangs the frames recorded around it under the entry.
  */
-export function formatWorthALook(items, sessionStart) {
+function formatWorthALook(items, sessionStart) {
     if (items.length === 0)
         return [];
     const lines = [
@@ -139,7 +139,7 @@ export function formatWorthALook(items, sessionStart) {
     return lines;
 }
 /** A finding's picture as a bullet, its path relative to report.md, or nothing when it has none. */
-export function pictureLine(f) {
+function pictureLine(f) {
     const p = readFindingPicture(f);
     return p ? [`- **Picture:** \`${p.file}\` (${describePicture(p)})`] : [];
 }
@@ -182,7 +182,7 @@ function replaySessions(memory) {
     }));
 }
 /** The frames that were on screen while each finding was being found. */
-export function findingEvidence(memory, sessions) {
+function findingEvidence(memory, sessions) {
     const all = sessions.flatMap((s) => s.steps).sort((a, b) => a.at.localeCompare(b.at));
     return memory.findings
         .map((f) => {

package/dist/engine/sarif.js

@@ -80,11 +80,11 @@ export function resolveSarifAnchor(o) {
     return { ...chosen, warning: `SARIF: ${missed.map(describe).join(" and ")} is not in the repository; results point at ${chosen.file} instead` };
 }
 /** The repository root the paths are relative to: the Actions checkout when there is one, else the project. */
-export function repositoryRoot(env, projectDir) {
+function repositoryRoot(env, projectDir) {
     return env.GITHUB_WORKSPACE || projectDir;
 }
 /** `target` relative to `root` with forward slashes, or null when it is outside it. */
-export function repoRelative(root, target) {
+function repoRelative(root, target) {
     const rel = path.relative(path.resolve(root), path.resolve(target));
     if (rel === "")
         return "";

package/dist/engine/script-literal.js

@@ -0,0 +1,11 @@
+/**
+ * A value written into an inline `<script>` as a JavaScript literal.
+ *
+ * JSON alone is not enough there: the HTML parser ends a script element at the
+ * first `</script`, and `<!--` or `<script` inside it change how the rest is
+ * read, before any JavaScript runs. Every `<` is written as `<`, which
+ * the string reads back as the same character, so none of those can appear.
+ */
+export function scriptLiteral(value) {
+    return JSON.stringify(value).replace(/</g, "\\u003c");
+}

package/dist/engine/sensitive.js

@@ -0,0 +1,254 @@
+/**
+ * What must never be written down in clear: the value typed into a secret
+ * field, and personal data (email addresses, card numbers) in any text the
+ * tool keeps. Pure functions of what the page and the text say, so
+ * memory-test table-tests them; browser.ts only gathers the facts.
+ *
+ * Masking errs towards hiding. A field wrongly taken for a secret costs a repro
+ * one typed value; a password wrongly taken for an ordinary field is published
+ * in the action log, the report and every issue exported from it.
+ */
+/** The autocomplete tokens (HTML's autofill field names) that mark a credential or a payment card. */
+const AUTOCOMPLETE_KINDS = {
+    "current-password": "password",
+    "new-password": "password",
+    "one-time-code": "one-time code",
+    "cc-number": "card",
+    "cc-csc": "card",
+    "cc-exp": "card",
+    "cc-exp-month": "card",
+    "cc-exp-year": "card",
+};
+/**
+ * Words that name a secret, matched against a name's words (camelCase, `_`,
+ * `-` and spaces split them; trailing digits dropped, so `password2` and
+ * `cvv2` count). A word in `whole` must be the whole word, so "spinner",
+ * "pinned", "tokens" and "tokenizer" are not a PIN or a token. A word in
+ * `suffix` may also end a longer one (`userpassword`, `clientsecret`, `totp`), but not
+ * start it: "passwordless" and "secretary" are not secrets.
+ */
+const WORD_KINDS = [
+    { kind: "password", whole: ["pwd"], suffix: ["password", "passwd", "passphrase"], phrases: [] },
+    {
+        kind: "one-time code",
+        whole: ["pin", "onetime", "otpcode", "mfa", "authenticator"],
+        suffix: ["otp", "passcode"],
+        phrases: ["one time", "verification code", "pass code", "auth code", "authentication code", "two factor"],
+    },
+    {
+        kind: "card",
+        whole: ["cvc", "cvv", "csc", "ccv", "ccnum"],
+        suffix: ["cardnumber", "ccnumber"],
+        phrases: ["security code", "card number", "card no", "credit card", "cc number", "cc num", "cc csc", "cc exp"],
+    },
+    {
+        kind: "secret",
+        whole: ["token"],
+        suffix: ["secret", "apikey"],
+        phrases: ["api key", "recovery code", "backup code", "private key", "seed phrase", "recovery phrase", "security answer"],
+    },
+];
+/** A name's words, lower-case: `newPassword` → new password, `PINCode` → pin code, `cvv2` → cvv. */
+function wordsOf(text) {
+    return text
+        .replace(/([a-z\d])([A-Z])/g, "$1 $2")
+        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2")
+        .toLowerCase()
+        .split(/[^\p{L}\p{N}]+/u)
+        .map((w) => w.replace(/\d+$/, ""))
+        .filter((w) => w.length > 0);
+}
+/** Which kind of secret a field's name, label or placeholder names, if any. */
+export function secretWordKind(text) {
+    // "2FA" splits into "2" and "fa" below, so it is read before the split.
+    if (/(?:^|[^\p{L}\p{N}])2fa(?![\p{L}\p{N}])/iu.test(text))
+        return "one-time code";
+    const words = wordsOf(text);
+    if (words.length === 0)
+        return null;
+    const joined = ` ${words.join(" ")} `;
+    for (const { kind, whole, suffix, phrases } of WORD_KINDS) {
+        if (words.some((w) => whole.includes(w) || suffix.some((s) => w.endsWith(s))))
+            return kind;
+        if (phrases.some((p) => joined.includes(` ${p} `)))
+            return kind;
+    }
+    return null;
+}
+/** The input types a split code's boxes use (scripted-login.ts reads the same boxes). */
+const SINGLE_CHARACTER_TYPES = new Set(["", "text", "tel", "number", "password"]);
+/** Whether what is typed into this field is a secret, and which kind; null for an ordinary field. */
+export function secretFieldKind(facts) {
+    if ((facts.type ?? "").trim().toLowerCase() === "password")
+        return "password";
+    for (const token of (facts.autocomplete ?? "").toLowerCase().split(/\s+/)) {
+        const kind = AUTOCOMPLETE_KINDS[token];
+        if (kind)
+            return kind;
+    }
+    // One box per character is a split one-time code, whatever each box is called ("Digit 1").
+    if (facts.maxLength === 1 && SINGLE_CHARACTER_TYPES.has((facts.type ?? "").trim().toLowerCase()))
+        return "one-time code";
+    const labels = typeof facts.label === "string" ? [facts.label] : (facts.label ?? []);
+    for (const text of [facts.name, facts.id, ...labels, facts.placeholder]) {
+        const kind = text ? secretWordKind(text) : null;
+        if (kind)
+            return kind;
+    }
+    return null;
+}
+/** The fixed stand-in for a secret field's value: the same whatever was typed, so not even its length is kept. */
+export function maskedValue(kind) {
+    return `•••• (masked: ${kind} field)`;
+}
+/** A JSON-quoted string, as the type result writes a value. */
+const QUOTED = String.raw `"(?:[^"\\]|\\.)*"`;
+/** `"<label>" ← "<value>"`, the shape a type entry names its field and value in. */
+const TYPED_INTO_RE = new RegExp(String.raw `"((?:[^"\\]|\\.)*)" ← (${QUOTED})`, "g");
+const EXISTING_RE = new RegExp(String.raw `existing content ${QUOTED}`, "g");
+/**
+ * Mask the typed value, and any previous content a note quotes, wherever text
+ * says a value went into a field whose label names a secret. The browser masks
+ * these as it types (browser.ts); this catches text written by any other route,
+ * such as an older log or an agent's own note. `hits` counts what was masked.
+ */
+export function maskSecretFieldValues(text) {
+    let hits = 0;
+    let out = "";
+    let last = 0;
+    for (const m of text.matchAll(TYPED_INTO_RE)) {
+        const kind = secretWordKind(m[1]);
+        if (!kind)
+            continue;
+        const start = m.index ?? 0;
+        out += text.slice(last, start) + `"${m[1]}" ← ${maskedValue(kind)}`;
+        last = start + m[0].length;
+        hits += 1;
+        // What the note says the field held before is the same secret's earlier value.
+        const next = text.indexOf(" ← ", last);
+        const rest = text.slice(last, next === -1 ? text.length : next);
+        const cleaned = rest.replace(EXISTING_RE, () => {
+            hits += 1;
+            return `existing content (masked: ${kind} field)`;
+        });
+        out += cleaned;
+        last += rest.length;
+    }
+    return { text: out + text.slice(last), hits };
+}
+/**
+ * `name=value` in a query string, a fragment or a form body. A GET form puts
+ * what was typed into the address (`?password=…`), and the address is logged
+ * with every action. Group 1 is what precedes it, 2 the name, 3 the value.
+ */
+const PARAM_RE = /(^|[?&;#\s"'(])([A-Za-z][\w.%[\]-]*)=([^&#;\s"')]+)/g;
+/** Mask the value of every parameter whose name names a secret (`pin=`, `otp=`, `password=`, `access_token=`), whatever its length. */
+export function maskSecretParams(text) {
+    let hits = 0;
+    const out = text.replace(PARAM_RE, (m, before, name, value) => {
+        // A form's nested names (`user[password]`, `user%5Bpassword%5D`) name the field last; a value already masked stays.
+        if (value.startsWith("[") || !secretWordKind(name.replace(/%5[BD]/gi, " ")))
+            return m;
+        hits += 1;
+        return `${before}${name}=[redacted]`;
+    });
+    return { text: out, hits };
+}
+/**
+ * Playwright's call log names the value an action was given (`- fill("…")`),
+ * so the error from a failed fill of a secret field quotes the secret. It does
+ * not escape a quote inside the value, so the call is masked to the end of its
+ * line, and every value the fill was given is removed wherever else it appears.
+ */
+export function maskFillCalls(message, values = []) {
+    let out = message;
+    // Longest first, so a value inside another is not left behind as part of it.
+    for (const value of [...values].sort((a, b) => b.length - a.length))
+        if (value !== "")
+            out = out.split(value).join("(masked)");
+    return out.replace(/\b(fill|type|pressSequentially|insertText)\(.*$/gm, "$1((masked))");
+}
+// ---------------------------------------------------------------------------
+// Personal data in text
+// ---------------------------------------------------------------------------
+/** Domains reserved for documentation (RFC 2606 / 6761) name nobody, so an address on one stays readable. */
+const RESERVED_DOMAIN_RE = /^(?:[\p{L}\p{N}-]+\.)*(?:example\.(?:com|org|net)|example|test|invalid|localhost)$/iu;
+/** An image's pixel-density suffix (`@2x` before its extension), which reads like an address but is a file name. */
+const DENSITY_DOMAIN_RE = /^\d+(?:\.\d+)?x\./i;
+/** An address in any script, its @ written out or percent-encoded (`%40`), as a query string carries it. Group 1 is the domain. */
+const EMAIL_RE = /[\p{L}\p{N}._%+-]+(?:@|%40)([\p{L}\p{N}-]+(?:\.[\p{L}\p{N}-]+)*\.(?:\p{L}{2,}|xn--[a-z0-9-]+))/giu;
+/** A run of digit groups split by single spaces or hyphens; a card number is some of its groups. */
+const DIGIT_RUN_RE = /(?<![\d.])\d+(?:[ -]\d+)*/g;
+/** A card number's first digit: the networks issue from 2 to 6 and 8, so a millisecond timestamp (a leading 1) is never one. */
+const CARD_FIRST_DIGIT_RE = /^[2-68]/;
+function luhnValid(digits) {
+    let sum = 0;
+    for (let i = 0; i < digits.length; i++) {
+        let d = Number(digits[digits.length - 1 - i]);
+        if (i % 2 === 1) {
+            d *= 2;
+            if (d > 9)
+                d -= 9;
+        }
+        sum += d;
+    }
+    return sum % 10 === 0;
+}
+function isCardNumber(digits) {
+    return digits.length >= 13 && digits.length <= 19 && CARD_FIRST_DIGIT_RE.test(digits) && luhnValid(digits);
+}
+/**
+ * Whether groups[i..j] are laid out as a card number is written: one run of
+ * digits, or groups of at least four (4-4-4-4, 4-6-5) with a shorter last one
+ * allowed. A list of small numbers (`320 375 414 768`) is not, whatever its
+ * digits add up to.
+ */
+function cardShaped(groups, i, j) {
+    for (let k = i; k < j; k++)
+        if (groups[k].length < 4)
+            return false;
+    return true;
+}
+/**
+ * The card numbers among a run's digit groups, each the longest that starts at
+ * its group, so a date or a quantity written just before a card number does
+ * not hide it. A group is never split: digits inside a longer id stay.
+ */
+function redactCardsInRun(run) {
+    const parts = run.split(/([ -])/);
+    const groups = parts.filter((_, i) => i % 2 === 0);
+    let out = "";
+    let i = 0;
+    while (i < groups.length) {
+        let end = -1;
+        let digits = "";
+        for (let j = i; j < groups.length && digits.length + groups[j].length <= 19; j++) {
+            digits += groups[j];
+            if (cardShaped(groups, i, j) && isCardNumber(digits))
+                end = j;
+        }
+        if (i > 0)
+            out += parts[2 * i - 1];
+        if (end === -1) {
+            out += groups[i];
+            i += 1;
+        }
+        else {
+            out += "[card number redacted]";
+            i = end + 1;
+        }
+    }
+    return out;
+}
+/**
+ * Personal data a page, a flow or a typed value can put in text the tool
+ * keeps: an email address, its @ written out or percent-encoded (a reserved
+ * example address and an image's `@2x` name excepted), and a card number
+ * (digits that start as a card network's do and pass the Luhn check, so an
+ * order number or a timestamp stays). Each replacement names what it removed.
+ */
+export function redactPersonal(text) {
+    return text
+        .replace(EMAIL_RE, (m, domain) => (RESERVED_DOMAIN_RE.test(domain) || DENSITY_DOMAIN_RE.test(domain) ? m : "[email redacted]"))
+        .replace(DIGIT_RUN_RE, redactCardsInRun);
+}

package/dist/engine/signed-in.js

@@ -137,7 +137,7 @@ export function looksLikeCredential(h) {
     return OPAQUE.test(h.value);
 }
 /** The first value held now that was not held when the window opened, or held a different value, and looks like a session. */
-export function newCredential(watch, held) {
+function newCredential(watch, held) {
     for (const h of held) {
         if (watch.baseline.get(h.key) === h.value)
             continue;
@@ -153,7 +153,7 @@ export function newCredential(watch, held) {
  */
 const SIGN_IN_STEP_RE = /\/(log-in|mfa|2fa|otp|verify|challenge|select-account|choose-account|account-picker)(\/|$)/;
 /** The path is a sign-in route (/login, /signin, /auth/..., /mfa, /verify, an account picker). */
-export function signInRoute(url) {
+function signInRoute(url) {
     try {
         const path = new URL(url).pathname.toLowerCase();
         return LOGIN_ROUTE_RE.test(path) || SIGN_IN_STEP_RE.test(path);

package/dist/engine/status-pane-page.js

@@ -16,6 +16,7 @@
  * its parent window. Like live-page.ts, the client script avoids template
  * literals because the page is one; status-pane tests check the script parses.
  */
+import { scriptLiteral } from "./script-literal.js";
 import { MCP_APPS_PROTOCOL, STATUS_POLL_MS, STATUS_POLL_TOOL } from "./status-pane.js";
 export function statusPanePage(version) {
     return `<!doctype html>
@@ -140,10 +141,10 @@ export function statusPanePage(version) {
 <script>
 (function () {
   "use strict";
-  var POLL_TOOL = ${JSON.stringify(STATUS_POLL_TOOL)};
+  var POLL_TOOL = ${scriptLiteral(STATUS_POLL_TOOL)};
   var POLL_MS = ${STATUS_POLL_MS};
-  var PROTOCOL = ${JSON.stringify(MCP_APPS_PROTOCOL)};
-  var VERSION = ${JSON.stringify(version)};
+  var PROTOCOL = ${scriptLiteral(MCP_APPS_PROTOCOL)};
+  var VERSION = ${scriptLiteral(version)};
   var REQUEST_MS = 10000;
 
   var nextId = 1;

package/dist/engine/task.js

@@ -23,7 +23,7 @@ export const TASK_MAX = 120;
  * The tools that act on the app under test. Each changes what the person
  * watching is looking at, so each has to be able to say why.
  */
-export const NEEDS_TASK = new Set([
+const NEEDS_TASK = new Set([
     "scout_navigate",
     "scout_back",
     "scout_click",

package/dist/engine/teardown.js

@@ -25,6 +25,7 @@ export async function boundedTeardown(context, browser, capMs) {
         await context?.close().catch(() => { });
         await browser?.close().catch(() => { });
     })()
+        // Each close above already ignores its own failure; this keeps anything unexpected from becoming an unhandled rejection, since teardown never throws.
         .catch(() => { })
         .finally(() => {
         finished = true;
@@ -36,6 +37,7 @@ export async function boundedTeardown(context, browser, capMs) {
             timer = setTimeout(resolve, capMs);
         }),
     ]);
+    // Past the cap: one more try at the browser, whose failure changes nothing for a caller already released.
     if (!finished)
         void browser?.close().catch(() => { });
 }

package/dist/engine/tickets.js

@@ -6,17 +6,17 @@ export const MAX_TICKET_TEXT = 200_000;
 export const MAX_TICKETS = 50;
 /** Most tickets the project keeps across runs: the newest readings. */
 export const MAX_TICKETS_KEPT = 100;
-export const MAX_CRITERIA_PER_TICKET = 50;
-export const MAX_CRITERION_TEXT = 500;
+const MAX_CRITERIA_PER_TICKET = 50;
+const MAX_CRITERION_TEXT = 500;
 export const MAX_REASON = 300;
 export const MAX_CRITERION_FINDINGS = 20;
-export const MAX_CRITERION_VERDICTS = 1000;
+const MAX_CRITERION_VERDICTS = 1000;
 /** A ticket file is read only up to this size. */
 export const MAX_TICKET_FILE_BYTES = 1_000_000;
 /** The file types a ticket is read from: text, never a binary or a document format. */
 export const TICKET_FILE_EXTENSIONS = [".md", ".markdown", ".txt", ".text", ".feature"];
 /** Below this confidence, the plain report says the verdict is unsure. */
-export const UNSURE_BELOW = 0.6;
+const UNSURE_BELOW = 0.6;
 /** Whether a file name has one of the extensions a ticket is read from. */
 export function isTicketFileName(name) {
     const lower = name.toLowerCase();
@@ -287,7 +287,7 @@ function numberCriteria(drafts) {
     });
 }
 /** The key a ticket's heading carries, if any: "PROJ-12" or "#12". */
-export function ticketKey(heading) {
+function ticketKey(heading) {
     const key = TICKET_KEY.exec(heading)?.[1];
     if (key)
         return key;
@@ -520,7 +520,7 @@ export function answerTicket(ticket, verdicts) {
 }
 // ── Reporting ─────────────────────────────────────────────────────────────────
 /** Why a criterion was not tested, in plain words. */
-export const NOT_TESTED_WORDS = {
+const NOT_TESTED_WORDS = {
     "no-access": "the account the run used could not reach this part of the site",
     "observe-blocked": "the run was only allowed to look, not to send changes, so this could not be tried",
     "out-of-scope": "it is outside what this run could check",