@molecule/api-ai-tools 1.14.4 → 1.14.6

package/dist/no-test-run.js

@@ -9,13 +9,13 @@
  * prints with `--help`/`--version`, the same way.
  *
  * Every check in the platform read such a command as a whole-suite run, because each one
- * matched the runner's NAME. X1 xr-molecule-flash-m79's first Playwright command was a config
+ * matched the runner's NAME. A first Playwright command that was a config
  * check — a config written to `/tmp`, `cp`'d beside the suite and used with `--list` — and it
  * came back HELD, `status: not_run`, with a ~4 KB `suiteNote` telling it to send the same
  * command with `--max-failures=15` ("uncapped it walks every test … 8–13 minutes"), beside an
  * environment block saying the run "ran on their defaults" and an import note about a path the
  * `cp` had already fixed. Nothing ran. The model gave up on the approach, wrote a second
- * config, and its next command was held again (flash-m74's "same command three times" shape):
+ * config, and its next command was held again ("same command three times" shape):
  * two holds, zero tests, and the config check it asked for never answered.
  *
  * So the classifiers live here, in one place, and callers ask them instead of their own
@@ -27,8 +27,8 @@
  * What counts as an invocation is COMMAND POSITION, read by `@molecule/api-ai-tools`'
  * `commandSegments`: `npx playwright test --list`, `hurl --help` and `bash run.sh` invoke the
  * runner, while a runner named as an argument (`grep -n playwright e2e/README.md`,
- * `head -30 run-api-tests-hurl.sh`) invokes nothing at all. X1 xr-molecule-flash-m81 (+20:03)
- * read a runner script with `head -30` and the suite-overlap hold answered "a Playwright suite is
+ * `head -30 run-api-tests-hurl.sh`) invokes nothing at all. Reading a runner script with
+ * `head -30` has had the suite-overlap hold answer "a Playwright suite is
  * already running … wait for it", for a command that runs nothing.
  *
  * @module
@@ -84,9 +84,10 @@ const NO_RUN_FLAGS = {
  * account for: the suite's own script (`./run-api-tests-hurl.sh`), a wrapper the executor wrote,
  * anything that may itself start a suite. {@link commandRunsNoTests} answers false for a command
  * carrying one — "every invocation only prints" is not a claim an unknown step can support.
- * X1 xr-molecule-flash-m197 (+05:18) sent
- * `hurl --version | head -2 && HOST=http://localhost:4000 ./run-api-tests-hurl.sh 2>&1 | tail -60`,
- * the suite passed 13/13, and the supplied script was the one segment nobody could place: the
+ * A command like
+ * `hurl --version | head -2 && HOST=http://localhost:4000 ./run-api-tests-hurl.sh 2>&1 | tail -60`
+ * ran a suite that passed 13/13, and the supplied script was the one segment nobody could place:
+ * the
  * whole command read as a version probe, so every "has the suite run?" reader said no for the
  * rest of the run and the early deploy was held to the end of the list.
  */
@@ -207,7 +208,7 @@ function informational(runner, after) {
  * position of a segment, after its wrapper prefixes. A runner named in an argument is not an
  * invocation — `head -30 run-api-tests-hurl.sh` and `grep -n playwright e2e/README.md` name a
  * file to read, and a `--list` written inside a file the command writes is not a flag anyone runs
- * with (flash-m81).
+ * with.
  *
  * A command that invokes no runner is NOT one of these (false): "the command runs no test" is
  * then true for `ls`, which is not the question any caller is asking. The question is whether

package/dist/output-filter.d.ts

@@ -2,7 +2,7 @@
  * A run whose own command piped its output through `tail`/`head`/`grep`/`sed`/`awk`/`cut`, so the
  * failure the runner printed is not in what came back.
  *
- * xr-molecule-flash-m147 (+10:12) sent `hurl --variable uid=… --test /tmp/t.hurl 2>&1 | tail -6`.
+ * A command sent `hurl --variable uid=… --test /tmp/t.hurl 2>&1 | tail -6`.
  * The six lines that survived are Hurl's closing tally; the failed assertion was above the cut.
  * The platform, seeing a red run with no assertion block, said the cause was "the transport or the
  * run itself" — a sentence that sends the reader at the network for a status assertion it never
@@ -50,7 +50,7 @@ export interface RunnerOutputFilter {
  *   {@link CommandSegment.program} is the program, once wrapper words like `timeout 280` and
  *   `npx` are taken away).
  * @param occurrence - Which runner invocation the output belongs to, 1-based. A command can run
- *   the same runner more than once (xr-molecule-flash-m170: the suite bare, then with `HOST=…`),
+ *   the same runner more than once (the suite bare, then with `HOST=…`),
  *   and each invocation carries its OWN pipe; a reader judging the second walk must name the
  *   second walk's cut, never the first's.
  * @returns The filter and the unfiltered command, or null.

package/dist/output-filter.js

@@ -2,7 +2,7 @@
  * A run whose own command piped its output through `tail`/`head`/`grep`/`sed`/`awk`/`cut`, so the
  * failure the runner printed is not in what came back.
  *
- * xr-molecule-flash-m147 (+10:12) sent `hurl --variable uid=… --test /tmp/t.hurl 2>&1 | tail -6`.
+ * A command sent `hurl --variable uid=… --test /tmp/t.hurl 2>&1 | tail -6`.
  * The six lines that survived are Hurl's closing tally; the failed assertion was above the cut.
  * The platform, seeing a red run with no assertion block, said the cause was "the transport or the
  * run itself" — a sentence that sends the reader at the network for a status assertion it never
@@ -39,7 +39,7 @@ const CUTTING_FILTERS = new Set(['awk', 'cut', 'grep', 'head', 'sed', 'tail']);
  *   {@link CommandSegment.program} is the program, once wrapper words like `timeout 280` and
  *   `npx` are taken away).
  * @param occurrence - Which runner invocation the output belongs to, 1-based. A command can run
- *   the same runner more than once (xr-molecule-flash-m170: the suite bare, then with `HOST=…`),
+ *   the same runner more than once (the suite bare, then with `HOST=…`),
  *   and each invocation carries its OWN pipe; a reader judging the second walk must name the
  *   second walk's cut, never the first's.
  * @returns The filter and the unfiltered command, or null.

package/dist/pipeline-exit-note.d.ts

@@ -4,7 +4,7 @@
  *
  * `npx tsc --noEmit 2>&1 | head -40` reports `head`'s 0 while the output above it carries a type
  * error, and `… | head -40 && tail -30 missing.log` reports `tail`'s 1 while the checker was clean —
- * both measured in xr-molecule-flash-m117 (+04:06, +08:05). A model that trusts the code concludes
+ * both are the same reading. A model that trusts the code concludes
  * "clean" and ships a build that does not compile, or hunts an error that is not there. This module
  * says which stage produced the code, and what the output actually carries, in one sentence beside
  * `exitCode`.

package/dist/pipeline-exit-note.js

@@ -4,7 +4,7 @@
  *
  * `npx tsc --noEmit 2>&1 | head -40` reports `head`'s 0 while the output above it carries a type
  * error, and `… | head -40 && tail -30 missing.log` reports `tail`'s 1 while the checker was clean —
- * both measured in xr-molecule-flash-m117 (+04:06, +08:05). A model that trusts the code concludes
+ * both are the same reading. A model that trusts the code concludes
  * "clean" and ships a build that does not compile, or hunts an error that is not there. This module
  * says which stage produced the code, and what the output actually carries, in one sentence beside
  * `exitCode`.

package/dist/playwright-report.d.ts

@@ -5,7 +5,7 @@
  * preserves a file reporter the executor named ({@link ./utilities.js} `withPlaywrightRunReport`,
  * `streamingBackgroundCommand`). That log is text: which failure a trace, a route or a locator
  * belongs to has to be reconstructed from printed headings, and a mis-join reads one failing
- * test's evidence as another's (xr-molecule-flash-m411). Playwright already writes the answer down
+ * test's evidence as another's. Playwright already writes the answer down
  * itself — its built-in `json` reporter records every test's own identity (project, file, line,
  * column, title path, status, retries) and every attachment the runner saved for THAT test, path
  * included.

package/dist/playwright-report.js

@@ -5,7 +5,7 @@
  * preserves a file reporter the executor named ({@link ./utilities.js} `withPlaywrightRunReport`,
  * `streamingBackgroundCommand`). That log is text: which failure a trace, a route or a locator
  * belongs to has to be reconstructed from printed headings, and a mis-join reads one failing
- * test's evidence as another's (xr-molecule-flash-m411). Playwright already writes the answer down
+ * test's evidence as another's. Playwright already writes the answer down
  * itself — its built-in `json` reporter records every test's own identity (project, file, line,
  * column, title path, status, retries) and every attachment the runner saved for THAT test, path
  * included.

package/dist/server-command.d.ts

@@ -4,7 +4,7 @@
  * (`molecule-dev/api/src/ai/own-server-note.ts` imports {@link SERVER_PROGRAM} and
  * {@link BACKGROUNDED} from here), so every surface that names a server names the same commands.
  *
- * X1 xr-molecule-flash-m167 (+19:16 → +24:04) wrote `/tmp/probe.mts` whose body imports the app's
+ * A probe wrote `/tmp/probe.mts` whose body imports the app's
  * `api/src/server.ts` and calls its `create(0)`, then ran it in the FOREGROUND:
  * `npx tsx --env-file=.env /tmp/probe.mts 2>&1 | tail -15`. The scaffold's `create()` calls
  * `server.listen(port)` and returns the server, so the process never exits — and behind `| tail`
@@ -29,7 +29,7 @@ export declare const BACKGROUNDED: RegExp;
  * when the command only names the script file — but NEVER against an inline program's code
  * (`node -e …`, `python3 -c …`), where this text is the user's program rather than a file being
  * run: `require('…/node_modules/vite')` imports a module, it does not start a dev server
- * (xr-molecule-flash-m391 +13:13, refused as "node starts a server" for exactly that line).
+ * (refused as "node starts a server" for exactly that line).
  */
 export declare const SERVER_PROGRAM: RegExp;
 /**

package/dist/server-command.js

@@ -4,7 +4,7 @@
  * (`molecule-dev/api/src/ai/own-server-note.ts` imports {@link SERVER_PROGRAM} and
  * {@link BACKGROUNDED} from here), so every surface that names a server names the same commands.
  *
- * X1 xr-molecule-flash-m167 (+19:16 → +24:04) wrote `/tmp/probe.mts` whose body imports the app's
+ * A probe wrote `/tmp/probe.mts` whose body imports the app's
  * `api/src/server.ts` and calls its `create(0)`, then ran it in the FOREGROUND:
  * `npx tsx --env-file=.env /tmp/probe.mts 2>&1 | tail -15`. The scaffold's `create()` calls
  * `server.listen(port)` and returns the server, so the process never exits — and behind `| tail`
@@ -31,7 +31,7 @@ export const BACKGROUNDED = /(?:^|[^&>])&(?!&|>)|\b(?:nohup|setsid)\b/;
  * when the command only names the script file — but NEVER against an inline program's code
  * (`node -e …`, `python3 -c …`), where this text is the user's program rather than a file being
  * run: `require('…/node_modules/vite')` imports a module, it does not start a dev server
- * (xr-molecule-flash-m391 +13:13, refused as "node starts a server" for exactly that line).
+ * (refused as "node starts a server" for exactly that line).
  */
 export const SERVER_PROGRAM = /\bserver\.[cm]?[jt]s\b|\b(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:start|dev|serve|preview)\b|\bvite\s+(?:preview|dev|serve)\b|\bvite(?![.\w-])(?!\s+(?:build|optimize)\b)|\bnext\s+(?:start|dev)\b|\b(?:uvicorn|gunicorn)\b|\bflask\s+run\b|\bpython\d?\s+-m\s+http\.server\b/;
 /** Programs that run a script FILE, so the file's own source decides whether it serves. */

package/dist/sleep-peek.d.ts

@@ -2,7 +2,7 @@
  * A leading `sleep` in an executor's command: the seconds it would have waited, and the command
  * that follows it.
  *
- * X1 xr-molecule-flash-m105 (+08:49 → +10:53, 2026-10-17) spent 225 s of its 60-minute clock
+ * One run spent 225 s of its 60-minute clock
  * inside `exec_command` calls of the shape `sleep N; tail <task log>`. The platform's own launch
  * note said "peek with exec_command: tail <log>" beside "never sleep", and the only concrete
  * instruction was the peek, so the executor built the poll by hand. Two of its three sleeps were

package/dist/sleep-peek.js

@@ -2,7 +2,7 @@
  * A leading `sleep` in an executor's command: the seconds it would have waited, and the command
  * that follows it.
  *
- * X1 xr-molecule-flash-m105 (+08:49 → +10:53, 2026-10-17) spent 225 s of its 60-minute clock
+ * One run spent 225 s of its 60-minute clock
  * inside `exec_command` calls of the shape `sleep N; tail <task log>`. The platform's own launch
  * note said "peek with exec_command: tail <log>" beside "never sleep", and the only concrete
  * instruction was the peek, so the executor built the poll by hand. Two of its three sleeps were

package/dist/suite-overlap.d.ts

@@ -5,12 +5,12 @@
  * Two sites ask "may a second run start now?" about the same pair of runs — the mid-run note that
  * tells the executor what to do next while the suite it is waiting on is still going
  * ({@link ./utilities.js} `repeatingFailureNote`), and the hold that refuses the run when it
- * arrives (molecule-dev's `suite-overlap-hold.ts`) — and until xr-molecule-flash-m89 they answered
- * it separately. That run's +19:59 `wait_for_task` handed over a repeating cause with "the test
- * alone reproduces the first one … start on them now, while the run keeps walking"; 23 s later the
- * executor sent exactly that re-run, and the overlap hold refused it — "A playwright suite is
- * already running against this app and database … Wait for it." Two orders, one run, and the round
- * trip between them was the whole cost.
+ * arrives (molecule-dev's `suite-overlap-hold.ts`) — and they used to answer it separately.
+ * A `wait_for_task` handed over a repeating cause with "the test alone reproduces the first one …
+ * start on them now, while the run keeps walking"; the executor sent exactly that re-run, and the
+ * overlap hold refused it — "A playwright suite is already running against this app and
+ * database … Wait for it." Two orders, one run, and the round trip between them was the whole
+ * cost.
  *
  * So the rule lives here ({@link suiteRunInTheWay}) and both of them call it: a run may start only
  * when nothing in flight is already measuring the same app and database. What "the same app and
@@ -23,7 +23,7 @@
  * WHOLE suite or a part of it. The rewriter that decides whether a background Playwright run gets
  * `--retries=0` ({@link ./utilities.js} `streamingBackgroundCommand`) and the platform's own notes
  * (molecule-dev's `suite-cli-override.ts`) asked it separately — a regex there, a predicate here —
- * until xr-molecule-flash-m89 showed the two answers were never the same question
+ * until a run showed the two answers were never the same question
  * ({@link isDiagnosisRun}).
  *
  * @module
@@ -65,7 +65,7 @@ export declare function namesSuiteConfig(command: string): boolean;
  * The flag rides the same statement the runner does: a `cd`, an env prefix and a `timeout` before
  * it are left exactly as they were, and so is everything chained after the run (`| tail -50`).
  *
- * xr-molecule-flash-m113 (+19:09): the model's fix-round re-run dropped the
+ * A fix-round re-run dropped the
  * `--config playwright.conduit.config.ts` both earlier runs had carried, so Playwright started with
  * NO base URL and all 10 failures were `page.goto: Cannot navigate to invalid URL` — a failure list
  * that says nothing about the app. The platform composes commands back to the executor too (the
@@ -81,21 +81,21 @@ export declare function withSuiteConfig(command: string, config: string | null |
  * The whole-suite command made scoped to the tests it should re-run instead: the same
  * invocation — same launcher, same settings — with the named `file:line`s in place of every
  * positional selection the run carried (a spec file, a suite directory or a regex filter),
- * `--last-failed` dropped (it re-runs the tests that never ran too, X1 flash-m60) and
+ * `--last-failed` dropped (it re-runs the tests that never ran too) and
  * `--retries=0` set (a re-run of a known failure does not need to pay for retries) — except the
  * re-run of a run against a DEPLOYED URL, which keeps the suite's own retries and tracing
  * (`options.suiteSettings`).
  *
  * The re-run keeps the run's `> <file>` redirect only in the sense of keeping its OUTPUT there:
  * the target is rewritten to a fresh sibling ({@link redirectRunnerOutputsToFreshFiles}), so a
- * re-run never overwrites the log the run itself is the evidence for (xr-molecule-flash-m173) —
- * and the setup around the run keeps its own file writes untouched (xr-molecule-flash-m429). A
+ * re-run never overwrites the log the run itself is the evidence for —
+ * and the setup around the run keeps its own file writes untouched. A
  * `tail`/`head`/`cat`/`grep` chained after the run that reads that exact log is shown the fresh
- * sibling instead, so the re-run displays the run it performed (xr-molecule-flash-o03).
+ * sibling instead, so the re-run displays the run it performed.
  *
  * `config` is the config the run was measured under ({@link withSuiteConfig}): the narrowed re-run
  * carries it whenever the command itself does not, so a run that dropped `--config` cannot be
- * handed back a command with the same defect (xr-molecule-flash-m113: every failing test was
+ * handed back a command with the same defect (every failing test was
  * `Cannot navigate to invalid URL` because the re-run loaded no base URL).
  *
  * @param command - The whole-suite run's command.
@@ -105,7 +105,7 @@ export declare function withSuiteConfig(command: string, config: string | null |
  *   command this returns is one Playwright can match.
  * @param excluded - The test titles the request carves out. They are inverted out
  *   (`--grep-invert`) so a re-run of the failing locations cannot report one of them again —
- *   xr-molecule-flash-m101 re-ran the whole 139-test suite and spent ~4 minutes to be told about
+ *   a re-run of the whole 139-test suite spends ~4 minutes to be told about
  *   a test the request had already said does not count.
  * @param config - The config the run loaded, when the caller knows it; added when the command
  *   does not name one.
@@ -113,13 +113,13 @@ export declare function withSuiteConfig(command: string, config: string | null |
  *   resolved against when the command does not `cd` anywhere.
  * @param env - The settings the REQUEST requires of the suite and this run left out
  *   ({@link withRunEnv}): the re-run carries them, so a re-run of a run measured in the wrong
- *   mode is not measured in that mode again (xr-molecule-flash-m182 +12:06).
+ *   mode is not measured in that mode again.
  * @param options - `suiteSettings` for the re-run of a run against a DEPLOYED URL: it keeps the
  *   suite's own retries and tracing instead of the diagnosis ones. The graded measurement is the
  *   suite's own settings, and a retry is what leaves a failing test's trace there; the platform's
  *   `--retries=0` and its `--trace=retain-on-failure` are both a stricter measurement than the
- *   one that was graded, and on X1 xr-molecule-flash-h15 the recording alone turned three
- *   budget-bound deployed tests into timeouts.
+ *   one that was graded, and the recording alone turned three budget-bound deployed tests into
+ *   timeouts.
  * @returns The scoped command, or the command unchanged when it runs no Playwright suite.
  */
 export declare function scopedRerunCommand(command: string, locations: readonly string[], excluded?: readonly string[], config?: string | null, cwd?: string | null, env?: readonly RunEnvSetting[], options?: {
@@ -132,12 +132,12 @@ export interface RunEnvSetting {
 }
 /**
  * The command with the request's required settings put in front of its RUN statement — the ONE
- * place every composed re-run gets them (xr-molecule-flash-m182).
+ * place every composed re-run gets them.
  *
  * The settings are written at the statement's own assignment offset, never in front of the whole
  * command: a shell binds an assignment there to the statement's program, while one in front of the
  * whole command is the environment of its FIRST statement alone (`APP_BASE=… cd app && npx
- * playwright test` sets the variable for `cd`; xr-molecule-flash-m103 +28:08). A name the command
+ * playwright test` sets the variable for `cd`). A name the command
  * gives a different value is replaced, and one it already gives the required value is left as
  * written. When the parse cannot place the statement (a run inside a nested `sh -c '…'`), the
  * settings become `export`s, which no statement boundary can swallow.
@@ -161,8 +161,7 @@ export interface SuiteRunInFlight {
     target: string;
     /**
      * Whether the command being judged STOPS this run before starting its own — a kill comes first,
-     * so a run the command itself stops is not in the way (xr-molecule-flash-m87's
-     * `kill 19408 … ; npx playwright test …`).
+     * so a run the command itself stops is not in the way (`kill 19408 … ; npx playwright test …`).
      */
     stoppedByCommand?: boolean;
 }
@@ -237,10 +236,10 @@ export declare function isPlatformProofLaunch(input: unknown): boolean;
  *   ({@link ./utilities.js} `streamingBackgroundCommand`) — a diagnosis walks each failure once,
  *   while the run the suite is judged by keeps the suite's own retries; and
  * - the platform's own notes (molecule-dev's `suite-cli-override.ts`), which must not tell the
- *   executor to drop the `--retries=0` the platform itself has just added — the contradiction X1
- *   flash-m74 and m75 filed, and m76 filed a third time.
+ *   executor to drop the `--retries=0` the platform itself has just added — a contradiction
+ *   filed three times.
  *
- * Until xr-molecule-flash-m89 they were a regex and a predicate that only LOOKED alike, and the
+ * Until then they were a regex and a predicate that only LOOKED alike, and the
  * gap was exactly the run the platform had asked for: its `testRunNote` says "run the whole suite
  * once with `--max-failures=0`", and the rewriter read that cap flag as a capped diagnosis and
  * stripped the suite's retries from the uncapped proof run that follows a deploy — the one run the
@@ -256,7 +255,7 @@ export declare function isPlatformProofLaunch(input: unknown): boolean;
  * When the caller passes those approved titles ({@link DiagnosisRunContext}) and the inverted
  * pattern names one of them — the request's own "except …" scope written as the flag, which
  * molecule-dev's `invertDecision` reads the same way — the run still walks the whole proof scope,
- * and it is not a diagnosis. xr-molecule-flash-m170 (+33:16): the deployed proof carried exactly
+ * and it is not a diagnosis. The deployed proof carried exactly
  * that exclusion, the rewriter added `--retries=0` to it, and the run lost the suite's retries on
  * the one walk where a network blip is likeliest.
  *

package/dist/suite-overlap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"suite-overlap.d.ts","sourceRoot":"","sources":["../src/suite-overlap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAaH;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAoB1D;AAKD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAS1F;AA4VD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,QAAQ,GAAE,SAAS,MAAM,EAAO,EAChC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,EACtB,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,EACnB,GAAG,GAAE,SAAS,aAAa,EAAO,EAClC,OAAO,GAAE;IAAE,aAAa,CAAC,EAAE,OAAO,CAAA;CAAO,GACxC,MAAM,CA2DR;AAED,4DAA4D;AAC5D,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;CACd;AAmCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,GAAE,SAAS,aAAa,EAAO,GAAG,MAAM,CAe3F;AAwOD;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,+FAA+F;IAC/F,SAAS,EAAE,OAAO,CAAA;IAClB,oFAAoF;IACpF,MAAM,EAAE,MAAM,CAAA;IACd;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,gBAAgB,EACzD,SAAS,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,EAC7B,QAAQ,EAAE,SAAS,CAAC,EAAE,GACrB,CAAC,GAAG,IAAI,CAMV;AAqHD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACtC;;;;;;;;;;;;;OAaG;IACH,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,EAAE,OAAO,MAA4D,CAAA;AAEhG;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAM7D;AAmCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CA2BtF"}
+{"version":3,"file":"suite-overlap.d.ts","sourceRoot":"","sources":["../src/suite-overlap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAaH;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAoB1D;AAKD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAS1F;AA2VD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,QAAQ,GAAE,SAAS,MAAM,EAAO,EAChC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,EACtB,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,EACnB,GAAG,GAAE,SAAS,aAAa,EAAO,EAClC,OAAO,GAAE;IAAE,aAAa,CAAC,EAAE,OAAO,CAAA;CAAO,GACxC,MAAM,CA2DR;AAED,4DAA4D;AAC5D,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;CACd;AAmCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,GAAE,SAAS,aAAa,EAAO,GAAG,MAAM,CAe3F;AAuOD;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,+FAA+F;IAC/F,SAAS,EAAE,OAAO,CAAA;IAClB,oFAAoF;IACpF,MAAM,EAAE,MAAM,CAAA;IACd;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,gBAAgB,EACzD,SAAS,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,EAC7B,QAAQ,EAAE,SAAS,CAAC,EAAE,GACrB,CAAC,GAAG,IAAI,CAMV;AAqHD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACtC;;;;;;;;;;;;;OAaG;IACH,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,EAAE,OAAO,MAA4D,CAAA;AAEhG;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAM7D;AAmCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CA2BtF"}

package/dist/suite-overlap.js

@@ -5,12 +5,12 @@
  * Two sites ask "may a second run start now?" about the same pair of runs — the mid-run note that
  * tells the executor what to do next while the suite it is waiting on is still going
  * ({@link ./utilities.js} `repeatingFailureNote`), and the hold that refuses the run when it
- * arrives (molecule-dev's `suite-overlap-hold.ts`) — and until xr-molecule-flash-m89 they answered
- * it separately. That run's +19:59 `wait_for_task` handed over a repeating cause with "the test
- * alone reproduces the first one … start on them now, while the run keeps walking"; 23 s later the
- * executor sent exactly that re-run, and the overlap hold refused it — "A playwright suite is
- * already running against this app and database … Wait for it." Two orders, one run, and the round
- * trip between them was the whole cost.
+ * arrives (molecule-dev's `suite-overlap-hold.ts`) — and they used to answer it separately.
+ * A `wait_for_task` handed over a repeating cause with "the test alone reproduces the first one …
+ * start on them now, while the run keeps walking"; the executor sent exactly that re-run, and the
+ * overlap hold refused it — "A playwright suite is already running against this app and
+ * database … Wait for it." Two orders, one run, and the round trip between them was the whole
+ * cost.
  *
  * So the rule lives here ({@link suiteRunInTheWay}) and both of them call it: a run may start only
  * when nothing in flight is already measuring the same app and database. What "the same app and
@@ -23,7 +23,7 @@
  * WHOLE suite or a part of it. The rewriter that decides whether a background Playwright run gets
  * `--retries=0` ({@link ./utilities.js} `streamingBackgroundCommand`) and the platform's own notes
  * (molecule-dev's `suite-cli-override.ts`) asked it separately — a regex there, a predicate here —
- * until xr-molecule-flash-m89 showed the two answers were never the same question
+ * until a run showed the two answers were never the same question
  * ({@link isDiagnosisRun}).
  *
  * @module
@@ -94,7 +94,7 @@ export function namesSuiteConfig(command) {
  * The flag rides the same statement the runner does: a `cd`, an env prefix and a `timeout` before
  * it are left exactly as they were, and so is everything chained after the run (`| tail -50`).
  *
- * xr-molecule-flash-m113 (+19:09): the model's fix-round re-run dropped the
+ * A fix-round re-run dropped the
  * `--config playwright.conduit.config.ts` both earlier runs had carried, so Playwright started with
  * NO base URL and all 10 failures were `page.goto: Cannot navigate to invalid URL` — a failure list
  * that says nothing about the app. The platform composes commands back to the executor too (the
@@ -305,21 +305,21 @@ const GREP_PATTERN_FLAGS = new Set(['-e', '--regexp', '-f', '--file']);
  * The postlude statements that DISPLAY the run's own report, with the exact file that run wrote
  * pointed at the fresh sibling the re-run writes instead.
  *
- * xr-molecule-flash-o03 (2026-10-22; the stale-READ arm m248 filed at +25:55): the recipe the
- * platform handed the executor ended `> /tmp/e2e-local.log.rerun.log 2>&1; echo EXIT=$?; tail -80
- * /tmp/e2e-local.log`. The writer moved to the fresh sibling and the trailing tail did not, so the
- * narrowed re-run displayed the walk it was narrowed FROM — the builder followed that recipe at
- * +19:16 and read the previous walk's failures as the result of the run it had just done.
+ * A recipe the platform handed the executor ended
+ * `> /tmp/e2e-local.log.rerun.log 2>&1; echo EXIT=$?; tail -80 /tmp/e2e-local.log`. The writer
+ * moved to the fresh sibling and the trailing tail did not, so the narrowed re-run displayed the
+ * walk it was narrowed FROM — and a builder following that recipe read the previous walk's
+ * failures as the result of the run it had just done.
  *
  * Only the EXACT file a runner statement (or its `tee`) wrote moves, and only in a statement AFTER
- * the run: the setup in front of it keeps every byte (m429), and a read of any other file is left
+ * the run: the setup in front of it keeps every byte, and a read of any other file is left
  * alone. The value is compared whole — `/tmp/full.log` never matches `/tmp/full.log.bak` — and
  * inside shell quotes the operand's own quoting survives (`"/tmp/my walk.log"` stays quoted).
  *
  * The bound is deliberate: a display this reader set does not recognise (a `wc`, a path held in a
  * variable, a path the command builds) is left exactly as written rather than guessed at. Those
- * shapes are not the ones the platform emits, and rewriting a word by resemblance is how m429's
- * setup redirect was corrupted.
+ * shapes are not the ones the platform emits, and rewriting a word by resemblance is how a setup
+ * redirect was corrupted.
  *
  * @param command - The composed command.
  * @param statements - The statements carrying the run's own output.
@@ -401,14 +401,14 @@ function freshReportReadEdits(command, statements, fresh) {
  * changed.
  *
  * A re-run composed from a run's own command keeps the run's redirect by construction, and the
- * run wrote the walk's only report to that file: xr-molecule-flash-m173 handed over *"Send this
+ * run wrote the walk's only report to that file: the platform handed over *"Send this
  * once the run ends: … npx playwright test …/articles.spec.ts:32 --retries=0 … > /tmp/pw-full.log
  * 2>&1"* — the ONE narrowed re-run that was about to check the fixes would have overwritten the
  * full walk's log, destroying the other 11 failures' error reports. Following the platform's own
  * advice must never destroy the evidence it was based on.
  *
  * Only the run's OWN stream moves. What surrounds it is SETUP and POSTLUDE, and those writes are
- * the command's meaning, not a report: xr-molecule-flash-m429 (2026-10-22) composed
+ * the command's meaning, not a report: a composed command was
  * `printf '/index.html 200' > app/public/_redirects && npx playwright test specs/auth.spec.ts
  * > /tmp/full.log 2>&1` with its SPA fallback written to `_redirects.rerun.log`, so the re-run
  * measured an app with no fallback at all. A heredoc config, a `.env` the command writes and a
@@ -418,8 +418,7 @@ function freshReportReadEdits(command, statements, fresh) {
  * Every statement chained after the run (`; echo EXIT $? > /tmp/done`) is postlude and keeps its
  * own writes, but the DISPLAY of the run's report is part of the same run: a `tail`, `head`, `cat`
  * or `grep` after the run that reads the exact file it wrote is pointed at the fresh sibling too
- * ({@link freshReportReadEdits}), so a re-run shows its own output instead of the walk's
- * (xr-molecule-flash-o03).
+ * ({@link freshReportReadEdits}), so a re-run shows its own output instead of the walk's.
  *
  * @param command - The composed command.
  * @returns The command whose suite-run redirects write to a fresh target.
@@ -444,21 +443,21 @@ function redirectRunnerOutputsToFreshFiles(command) {
  * The whole-suite command made scoped to the tests it should re-run instead: the same
  * invocation — same launcher, same settings — with the named `file:line`s in place of every
  * positional selection the run carried (a spec file, a suite directory or a regex filter),
- * `--last-failed` dropped (it re-runs the tests that never ran too, X1 flash-m60) and
+ * `--last-failed` dropped (it re-runs the tests that never ran too) and
  * `--retries=0` set (a re-run of a known failure does not need to pay for retries) — except the
  * re-run of a run against a DEPLOYED URL, which keeps the suite's own retries and tracing
  * (`options.suiteSettings`).
  *
  * The re-run keeps the run's `> <file>` redirect only in the sense of keeping its OUTPUT there:
  * the target is rewritten to a fresh sibling ({@link redirectRunnerOutputsToFreshFiles}), so a
- * re-run never overwrites the log the run itself is the evidence for (xr-molecule-flash-m173) —
- * and the setup around the run keeps its own file writes untouched (xr-molecule-flash-m429). A
+ * re-run never overwrites the log the run itself is the evidence for —
+ * and the setup around the run keeps its own file writes untouched. A
  * `tail`/`head`/`cat`/`grep` chained after the run that reads that exact log is shown the fresh
- * sibling instead, so the re-run displays the run it performed (xr-molecule-flash-o03).
+ * sibling instead, so the re-run displays the run it performed.
  *
  * `config` is the config the run was measured under ({@link withSuiteConfig}): the narrowed re-run
  * carries it whenever the command itself does not, so a run that dropped `--config` cannot be
- * handed back a command with the same defect (xr-molecule-flash-m113: every failing test was
+ * handed back a command with the same defect (every failing test was
  * `Cannot navigate to invalid URL` because the re-run loaded no base URL).
  *
  * @param command - The whole-suite run's command.
@@ -468,7 +467,7 @@ function redirectRunnerOutputsToFreshFiles(command) {
  *   command this returns is one Playwright can match.
  * @param excluded - The test titles the request carves out. They are inverted out
  *   (`--grep-invert`) so a re-run of the failing locations cannot report one of them again —
- *   xr-molecule-flash-m101 re-ran the whole 139-test suite and spent ~4 minutes to be told about
+ *   a re-run of the whole 139-test suite spends ~4 minutes to be told about
  *   a test the request had already said does not count.
  * @param config - The config the run loaded, when the caller knows it; added when the command
  *   does not name one.
@@ -476,13 +475,13 @@ function redirectRunnerOutputsToFreshFiles(command) {
  *   resolved against when the command does not `cd` anywhere.
  * @param env - The settings the REQUEST requires of the suite and this run left out
  *   ({@link withRunEnv}): the re-run carries them, so a re-run of a run measured in the wrong
- *   mode is not measured in that mode again (xr-molecule-flash-m182 +12:06).
+ *   mode is not measured in that mode again.
  * @param options - `suiteSettings` for the re-run of a run against a DEPLOYED URL: it keeps the
  *   suite's own retries and tracing instead of the diagnosis ones. The graded measurement is the
  *   suite's own settings, and a retry is what leaves a failing test's trace there; the platform's
  *   `--retries=0` and its `--trace=retain-on-failure` are both a stricter measurement than the
- *   one that was graded, and on X1 xr-molecule-flash-h15 the recording alone turned three
- *   budget-bound deployed tests into timeouts.
+ *   one that was graded, and the recording alone turned three budget-bound deployed tests into
+ *   timeouts.
  * @returns The scoped command, or the command unchanged when it runs no Playwright suite.
  */
 export function scopedRerunCommand(command, locations, excluded = [], config, cwd, env = [], options = {}) {
@@ -572,12 +571,12 @@ function withoutEnvWord(command, name) {
 }
 /**
  * The command with the request's required settings put in front of its RUN statement — the ONE
- * place every composed re-run gets them (xr-molecule-flash-m182).
+ * place every composed re-run gets them.
  *
  * The settings are written at the statement's own assignment offset, never in front of the whole
  * command: a shell binds an assignment there to the statement's program, while one in front of the
  * whole command is the environment of its FIRST statement alone (`APP_BASE=… cd app && npx
- * playwright test` sets the variable for `cd`; xr-molecule-flash-m103 +28:08). A name the command
+ * playwright test` sets the variable for `cd`). A name the command
  * gives a different value is replaced, and one it already gives the required value is left as
  * written. When the parse cannot place the statement (a run inside a nested `sh -c '…'`), the
  * settings become `export`s, which no statement boundary can swallow.
@@ -659,9 +658,8 @@ const LOCATION_LINE = /^(.*?)(:\d+(?::\d+)?)$/;
  * suffix the absolute path still contains (`fixtures/…/articles.spec.ts:3` matches).
  *
  * A location without a leading dot is left alone: it is either absolute or already a suffix of the
- * absolute path, and rewriting it against a mis-guessed base could only break it
- * (xr-molecule-flash-m118 +16:34 "No tests found"; m124 +18:38 the platform's own "Re-run just
- * these" command).
+ * absolute path, and rewriting it against a mis-guessed base could only break it ("No tests
+ * found", and the platform's own "Re-run just these" command).
  *
  * @param locations - The failing `file:line`s as the run's log printed them.
  * @param command - The run's command, for its own `cd`s.
@@ -684,7 +682,7 @@ function playwrightLocations(locations, command, cwd) {
  *
  * A value here is never a positional selection however much it looks like a path:
  * `--config playwright.config.ts` names the config the run was measured under, and dropping it
- * because it ends in `.ts` would re-create m113 exactly (a re-run with no base URL).
+ * because it ends in `.ts` would re-create the defect exactly (a re-run with no base URL).
  */
 const SUITE_VALUE_FLAGS = new Set([
     '--add-reporter',
@@ -740,10 +738,10 @@ const ARGUMENT_REDIRECT_OPERATOR = /^(?:\d*|&)(?:<<<|<<-?|>>?\|?|<>|>&|<&)$/;
  *
  * The re-run is "just these", and Playwright OR-s every positional argument into one selection:
  * ANY leftover positional re-admits tests the re-run is supposed to skip. A bare spec file
- * re-admits all of that file's tests (xr-molecule-flash-m118 (+45:24) ~297 s for one file and
- * fourteen duplicates; xr-molecule-flash-m134 (+20:0x) 32 tests instead of 8). A suite DIRECTORY
+ * re-admits all of that file's tests (~297 s for one file and fourteen duplicates; 32 tests
+ * instead of 8). A suite DIRECTORY
  * is the same argument and re-admits the WHOLE walk even beside fourteen exact `file:line`s —
- * xr-molecule-flash-m428's suggested "Re-run just these" kept
+ * A suggested "Re-run just these" kept
  * `/workspace/fixtures/realworld/specs/e2e` after `--config playwright.config.ts`, so the command
  * said 14 locations and selected every spec again. A regex positional filter selects files the
  * same way and goes too.
@@ -850,7 +848,7 @@ const PLAYWRIGHT_RUN = /^(?:@playwright\/test|playwright)(?:@\S+)?\s+test(?=\s|$
  * Both rewrites that compose a command ({@link withSuiteConfig}, {@link scopedRerunCommand}) read
  * the run through the shared shell parse — the same answer every classifier gets — instead of
  * searching the text for `playwright test`. The search missed the runner reached by file (`node
- * <path>/@playwright/test/cli.js test`, xr-molecule-flash-m179), so a narrowed re-run of that run
+ * <path>/@playwright/test/cli.js test`), so a narrowed re-run of that run
  * silently stayed the whole suite.
  *
  * `afterRunner` is the offset just past the runner's own words (`playwright test`): the
@@ -1005,10 +1003,10 @@ function boundsFailures(command) {
  *   ({@link ./utilities.js} `streamingBackgroundCommand`) — a diagnosis walks each failure once,
  *   while the run the suite is judged by keeps the suite's own retries; and
  * - the platform's own notes (molecule-dev's `suite-cli-override.ts`), which must not tell the
- *   executor to drop the `--retries=0` the platform itself has just added — the contradiction X1
- *   flash-m74 and m75 filed, and m76 filed a third time.
+ *   executor to drop the `--retries=0` the platform itself has just added — a contradiction
+ *   filed three times.
  *
- * Until xr-molecule-flash-m89 they were a regex and a predicate that only LOOKED alike, and the
+ * Until then they were a regex and a predicate that only LOOKED alike, and the
  * gap was exactly the run the platform had asked for: its `testRunNote` says "run the whole suite
  * once with `--max-failures=0`", and the rewriter read that cap flag as a capped diagnosis and
  * stripped the suite's retries from the uncapped proof run that follows a deploy — the one run the
@@ -1024,7 +1022,7 @@ function boundsFailures(command) {
  * When the caller passes those approved titles ({@link DiagnosisRunContext}) and the inverted
  * pattern names one of them — the request's own "except …" scope written as the flag, which
  * molecule-dev's `invertDecision` reads the same way — the run still walks the whole proof scope,
- * and it is not a diagnosis. xr-molecule-flash-m170 (+33:16): the deployed proof carried exactly
+ * and it is not a diagnosis. The deployed proof carried exactly
  * that exclusion, the rewriter added `--retries=0` to it, and the run lost the suite's retries on
  * the one walk where a network blip is likeliest.
  *