@molecule/api-ai-tools 1.9.16 → 1.9.19

package/dist/utilities.js

@@ -350,6 +350,25 @@ const PRINTING_REPORTERS = new Set(['list', 'line', 'dot', 'basic', 'spec']);
  * edited `app/src` while the run was still walking — which voids the run.
  */
 export const PLAYWRIGHT_FAILURES_INLINE_ENV = 'PLAYWRIGHT_LIST_PRINT_FAILURES_INLINE';
+/**
+ * Whether a command step only reports or discards the status of the steps before it: `echo EXIT
+ * $?`, `echo $?`, `printf …`, `true`, `exit 0`.
+ *
+ * The shape models and the platform's own re-run notes send routinely ends on one of these —
+ * `npx playwright test … > /tmp/pw.log 2>&1; echo EXIT $?` — and reading the split's last part as
+ * the run withheld the reporter, the inline-failure switch and `--retries=0` from every one of
+ * them: the log then carried `✘` rows and nothing else while the wait note promised each failure's
+ * error under them (xr-molecule-flash-m173 +17:07, +39:14). Whitespace and a group's closing
+ * punctuation are not part of the step; {@link streamingBackgroundCommand} strips those before
+ * asking, and strips them here too for the split it is given.
+ *
+ * @param step - One statement of the command, as the `&&`/`||`/`;` split left it.
+ * @returns True when the step runs nothing but a status report.
+ */
+function isStatusOnlyStep(step) {
+    const text = step.replace(/[\s)}]+$/, '').trim();
+    return /^(?:echo|printf)\b/.test(text) || /^true$/.test(text) || /^exit(?:\s+\S+)?$/.test(text);
+}
 /**
  * Rewrite a command about to run in the background so its log grows while it
  * runs. Two shapes left the log empty until exit, and an empty log is what
@@ -384,24 +403,32 @@ export const PLAYWRIGHT_FAILURES_INLINE_ENV = 'PLAYWRIGHT_LIST_PRINT_FAILURES_IN
  * is exactly when the executor reads the log, and without it a running log carries `✘` rows and
  * nothing else (xr-molecule-flash-m99 spent ~90 s on greps of one, then fixed what it guessed).
  *
- * Only the command's last step is touched, and only its reporter, and only when that step runs
- * something: `npx playwright test --list` takes two seconds and writes nothing per test, so
- * neither reporter nor `--retries=0` is added to it ({@link isPlaywrightRunCommand}).
+ * Only the step that runs the suite is touched, and only its reporter, and only when that step
+ * runs something: `npx playwright test --list` takes two seconds and writes nothing per test, so
+ * neither reporter nor `--retries=0` is added to it ({@link isPlaywrightRunCommand}). A trailing
+ * status step (`; echo EXIT $?`, `&& true`) is not the run and is skipped when the run step is
+ * found ({@link isStatusOnlyStep}); a run whose output is redirected to a file is still readable
+ * through that file, which the launch records as the task's own output.
  *
  * A command that starts the suite MORE THAN ONCE is not launched at all: every run it carries is
  * a whole walk of the same suite against the same app, and only the last step is rewritten, so the
  * earlier walks run unmeasured for nothing. X1 xr-molecule-flash-m157 (+14:02) chained two whole
  * walks of one 138-test suite with `;` — 4.5 minutes each — and the second measured nothing the
- * first had not. The platform already refuses a second CONCURRENT run against one app; this is the
+ * first had not. The platform refuses a second CONCURRENT run against one app and database by the
+ * ONE rule ({@link suiteRunInTheWay}) — for every pair, whatever uid a run mints — and this is the
  * same hazard inside one command ({@link suiteRunStatements}). `error` then carries the refusal,
  * naming each suite step and the ONE command to send instead (the last suite step, rewritten as
  * this function rewrites a run), and nothing is launched.
  *
  * @param command - The command as the executor sent it.
+ * @param context - What the caller knows beyond the command: the tests the person's request
+ *   excludes by name ({@link DiagnosisRunContext}). A `--grep-invert` of exactly those is the
+ *   request's own scope, not a diagnosis, so it keeps the suite's retries on a deployed proof
+ *   (xr-molecule-flash-m170 +33:16).
  * @returns The command to run and one sentence per change made (empty when none), or `error` when
  *   the command starts the suite more than once.
  */
-export function streamingBackgroundCommand(command) {
+export function streamingBackgroundCommand(command, context) {
     // A command that runs no test is not a run to keep a growing log for: nothing about it is
     // rewritten (flash-m79's `--list` was read as a whole-suite run end to end, and got a ~4 KB
     // refusal to send itself again with `--max-failures=15`).
@@ -442,10 +469,15 @@ export function streamingBackgroundCommand(command) {
     }
     // The last step that RUNS something. A trailing group closer is punctuation, not a step: a
     // brace group writes it after a `;` (`{ …; }`), so reading the split's last part literally
-    // made `}` the step and withheld every rewrite from a run inside a group.
+    // made `}` the step and withheld every rewrite from a run inside a group. A trailing status
+    // step is not the run either: `… > /tmp/pw.log 2>&1; echo EXIT $?` ends on the echo, and
+    // treating THAT as the run withheld the reporter, the inline-failure switch and `--retries=0`
+    // from the exact shape models and the platform's re-run notes send (xr-molecule-flash-m173
+    // +17:07, +39:14).
     const parts = out.split(/&&|\|\||;/);
     let stepIndex = parts.length - 1;
-    while (stepIndex > 0 && /^[\s)}]*$/.test(parts[stepIndex] ?? ''))
+    while (stepIndex > 0 &&
+        (/^[\s)}]*$/.test(parts[stepIndex] ?? '') || isStatusOnlyStep(parts[stepIndex] ?? '')))
         stepIndex -= 1;
     const rawLastStep = parts[stepIndex] ?? '';
     // The step's own text, with the punctuation that closes the group it sits in taken off — the
@@ -455,34 +487,28 @@ export function streamingBackgroundCommand(command) {
     // A command that starts the suite more than once is not launched: each statement is a whole walk
     // of the same suite against the same app, only the last of them is rewritten, and the earlier
     // ones measure nothing the first did. X1 xr-molecule-flash-m157 (+14:02) chained two whole walks
-    // of one 138-test suite with `;` (4.5 minutes each); the platform already refuses a second
-    // CONCURRENT run against one app, and this is the same hazard inside one command.
-    const suiteSteps = suiteRunStatements(out);
-    if (suiteSteps.length > 1) {
-        // The ONE run to send instead: the last step that runs the suite, rewritten exactly as this
-        // function rewrites a run (its own count is one — guarded, so this cannot recurse).
-        const lastSuitePart = [...parts]
-            .reverse()
-            .map((p) => p.trim())
-            .find((p) => isSuiteRunCommand(p));
-        const single = lastSuitePart && suiteRunStatements(lastSuitePart).length === 1
-            ? streamingBackgroundCommand(lastSuitePart).command
-            : (lastSuitePart ?? '');
-        return {
-            command: out,
-            changes: [],
-            error: `This command runs the suite ${suiteSteps.length === 2 ? 'twice' : `${suiteSteps.length} times`} ` +
-                `(${suiteSteps.map((s, i) => `step ${i + 1}: \`${s}\``).join(', ')}). One walk is the ` +
-                `measurement; run exactly one: \`${single}\``,
-        };
-    }
+    // of one 138-test suite with `;` (4.5 minutes each); the platform refuses a second CONCURRENT
+    // run against one app and database by the ONE rule ({@link suiteRunInTheWay}) — for every pair,
+    // whatever uid a run mints — and this is the same hazard inside one command. The reading is
+    // {@link repeatedSuiteRunError}'s, so a foreground `exec_command` refuses the same commands.
+    const repeated = repeatedSuiteRunError(out);
+    if (repeated)
+        return { command: out, changes: [], error: repeated };
     // The last step runs Playwright — whether or not anything is piped from it. Keying this on
     // "nothing is piped out of the last step" withheld the reporter, the inline-failure switch and
     // `--retries=0` from exactly the runs whose output was filtered (xr-molecule-flash-m101
     // +25:54); what the runner writes into its log does not depend on what reads the pipe. A
-    // REDIRECT still sends the output somewhere this tool cannot read it (`> out.txt`); `2>&1` only
-    // joins stderr to it.
-    const finalPlaywrightRun = isPlaywrightRunCommand(lastStep) && !/>/.test(lastStep.replace(/\d?>&\d/g, ''));
+    // REDIRECT used to withhold them too (`> out.txt`), but a redirect to a FILE is readable: the
+    // launch records that file as the task's own output (`outputFileByTask`, resolved from this
+    // same reader) and every wait reads it back. `> /tmp/pw-full.log 2>&1; echo EXIT $?` is the
+    // shape models and the platform's re-run notes send, so a run whose own redirect target is the
+    // one the launch will read is a readable run (xr-molecule-flash-m173 +17:07, +39:14). A target
+    // that is not a file (`/dev/null`, `2>&1`) still leaves the output unreadable.
+    const runRedirect = outputRedirectTarget(lastStep);
+    const finalPlaywrightRun = isPlaywrightRunCommand(lastStep) &&
+        (runRedirect === null
+            ? !/>/.test(lastStep.replace(/\d?>&\d/g, ''))
+            : runRedirect === outputRedirectTarget(out));
     /**
      * Add a word to the suite runner's own arguments; false when the runner could not be placed.
      *
@@ -494,14 +520,17 @@ export function streamingBackgroundCommand(command) {
      * platform's runner shape (xr-molecule-flash-m129 +34:29); appending after a pipe hands the
      * word to the filter (m102's dangling `--trace` flag, in the same shape).
      *
-     * A suite the parse could not place — one inside a nested `sh -c '<command>'` string, whose
-     * offsets are positions in THAT string, or a runner that is not the command's last step — is
-     * left exactly as written and the caller reports no rewrite. There is nowhere in this command
-     * the word belongs, and guessing at the text is what produced both failures above.
+     * The suite's own segment is found wherever it sits ({@link lastSuiteRun}), because a trailing
+     * status step is not another command's output: in `… > /tmp/pw.log 2>&1; echo EXIT $?` the run
+     * is what the launcher measures, and the echo only repeats its status
+     * ({@link isStatusOnlyStep}). A suite the parse could not place — one inside a nested
+     * `sh -c '<command>'` string, whose offsets are positions in THAT string — is left exactly as
+     * written and the caller reports no rewrite. There is nowhere in this command the word
+     * belongs, and guessing at the text is what produced both failures above.
      */
     const addToRun = (flag) => {
-        const pipeline = lastSuitePipeline(out);
-        const runner = pipeline ? pipeline.located[pipeline.at] : undefined;
+        const run = lastSuiteRun(out);
+        const runner = run ? run.located[run.at] : undefined;
         if (!runner)
             return false;
         const at = statementArgumentEnd(out, runner.start, runner.end);
@@ -522,7 +551,7 @@ export function streamingBackgroundCommand(command) {
     // {@link isDiagnosisRun}'s answer and nobody else's: the platform's notes ask the same
     // function, so a run cannot be a diagnosis to one of them and the whole suite to the other.
     // Which targets are local is {@link suiteCommandTarget}'s answer.
-    const diagnosis = isDiagnosisRun(lastStep);
+    const diagnosis = isDiagnosisRun(lastStep, context);
     const localTarget = suiteCommandTarget(lastStep) === 'local';
     // The last step's reporters: one printer, and it is `list`. Every branch below only ever moves
     // the command TO that shape — a reporter set is never left with two printers in it.
@@ -590,8 +619,14 @@ export function streamingBackgroundCommand(command) {
             'and you need not wait for it to end to start on them.');
     }
     if (finalPlaywrightRun && (diagnosis || localTarget) && !/--retries\b/.test(lastStep)) {
+        // The reason named is the one that fired: a narrowed diagnosis against a DEPLOYED URL is not a
+        // local run, and calling it one (xr-molecule-flash-m170's note did) reads as the platform having
+        // misread the target.
+        const why = diagnosis
+            ? 'a diagnosis or re-run walks each failure once; the suite’s retries apply on the deployed proof run'
+            : 'a local run walks each failure once; the suite’s retries apply on the deployed proof run';
         if (addToRun('--retries=0'))
-            changes.push('Added `--retries=0`: a local run walks each failure once; the suite’s retries apply on the deployed proof run.');
+            changes.push(`Added \`--retries=0\`: ${why}.`);
     }
     return { command: out, changes };
 }
@@ -613,6 +648,15 @@ const SUITE_RUN_COMMANDS = [
     /^vitest\b/,
     // `hurl --test …` or `hurl … x.hurl`.
     /^hurl\s+[^|\n]*(?:--test|\.hurl)/,
+    // The suite's own runner SCRIPT, whoever wrote it: the supplied trees ship
+    // `run-api-tests-hurl.sh` and `run-hurl-tests.sh`, and the command-position parser puts the
+    // script's own NAME where the program goes (`bash fixtures/…/run-api-tests-hurl.sh` →
+    // `run-api-tests-hurl.sh`). xr-molecule-flash-m170 (+06:02) chained two invocations of one such
+    // script in the FOREGROUND, which no launch site counted: the first walk's tally was the only
+    // evidence the note had, and it reported a passing run as 13 failures. A script named for the
+    // suite is a whole walk of it; `head -30 run-api-tests-hurl.sh` is not in command position and
+    // stays a read ({@link commandSegments}).
+    /^run-(?:api-)?(?:hurl-)?tests?[\w-]*\.sh\b/,
 ];
 /**
  * Every statement of a command that starts a whole test suite, in command order.
@@ -649,6 +693,122 @@ export function suiteRunStatements(command) {
 export function isSuiteRunCommand(command) {
     return suiteRunStatements(command).length > 0;
 }
+/**
+ * The refusal for a command that starts the suite MORE THAN ONCE — the ONE reading every launch
+ * site asks, foreground and background alike.
+ *
+ * Each statement is a whole walk of the same suite against the same app, and only the last of them
+ * is rewritten, so the earlier ones measure nothing the first did. X1 xr-molecule-flash-m157
+ * (+14:02) chained two whole walks of one 138-test suite with `;` (4.5 minutes each) and the
+ * background launcher refused it; X1 xr-molecule-flash-m170 (+06:02) chained two invocations of the
+ * suite's own runner script in the foreground, where nothing counted them, and the note reported
+ * the passing second walk as the first walk's 13 failures.
+ *
+ * The one run handed back is the LAST suite statement, rewritten exactly as
+ * {@link streamingBackgroundCommand} rewrites a run (a filter or `| tail` after the runner is
+ * dropped, and a Playwright run gets the reporter that prints failures). Its own count is one —
+ * guarded, so this cannot recurse.
+ *
+ * @param command - The shell command as the executor sent it.
+ * @returns The refusal sentence, or null when the command starts the suite zero or one time.
+ */
+export function repeatedSuiteRunError(command) {
+    if (commandRunsNoTests(command))
+        return null;
+    const suiteSteps = suiteRunStatements(command);
+    if (suiteSteps.length <= 1)
+        return null;
+    const lastSuitePart = command
+        .split(/&&|\|\||;/)
+        .reverse()
+        .map((p) => p.trim())
+        .find((p) => isSuiteRunCommand(p));
+    const single = lastSuitePart && suiteRunStatements(lastSuitePart).length === 1
+        ? streamingBackgroundCommand(lastSuitePart).command
+        : (lastSuitePart ?? '');
+    return (`This command runs the suite ${suiteSteps.length === 2 ? 'twice' : `${suiteSteps.length} times`} ` +
+        `(${suiteSteps.map((s, i) => `step ${i + 1}: \`${s}\``).join(', ')}). One walk is the ` +
+        `measurement; run exactly one: \`${single}\``);
+}
+/** A flag with its value, as {@link suiteRunBudgetCommand} writes it: `--timeout=15000`. */
+const BUDGET_FLAG = /^(--[A-Za-z][\w-]*)=(\S+)$/;
+/**
+ * The statement the suite runner occupies, and where its own arguments end.
+ *
+ * The LAST suite statement, wherever it sits: unlike a reporter or `--retries=0` (which only make
+ * sense on the run a launcher measures), the suite's budget belongs on the run itself even when
+ * another command follows it (`… ; npm run build`).
+ */
+function suiteRunnerArguments(command) {
+    const pipeline = lastSuiteRun(command);
+    const runner = pipeline ? pipeline.located[pipeline.at] : undefined;
+    if (!runner || runner.start === null || runner.end === null)
+        return null;
+    const start = runner.start;
+    const end = runner.end;
+    const at = statementArgumentEnd(command, start, end);
+    if (at === null)
+        return null;
+    return { start, end, at };
+}
+/**
+ * A command with the supplied suite's own settings written back onto its runner as Playwright
+ * flags, and the flags that could not be placed.
+ *
+ * The grader walks the suite under its OWN budget, so a run whose runner config sets a different
+ * timeout or worker count measures a run the grader never sees (xr-molecule-flash-m169: a 60 s
+ * wrapper config produced a green local proof the official 15 s grader then failed). Playwright
+ * lets a command-line flag win over every config file, so the suite's values are put on the
+ * runner's own arguments — written where {@link statementArgumentEnd} places them, never after a
+ * pipe, redirect or group closer. Only the command's LAST suite step is touched: that is the run
+ * every launch site measures.
+ *
+ * A flag the command already carries is REWRITTEN in place (last occurrence wins, as it does for
+ * Playwright); a flag it does not carry is inserted at the end of the runner's arguments. A
+ * command whose runner cannot be placed is returned exactly as written, with every flag reported
+ * as unplaced, so the caller states the fact instead of claiming a pin it did not make.
+ *
+ * @param command - The shell command about to run.
+ * @param flags - The flags to put on it, each as `--name=value`.
+ * @returns The command to run, the flags placed on it, and the ones it could not carry.
+ */
+export function suiteRunBudgetCommand(command, flags) {
+    const placed = [];
+    const unplaced = [];
+    let out = command;
+    for (const flag of flags) {
+        const parts = BUDGET_FLAG.exec(flag);
+        if (parts === null) {
+            unplaced.push(flag);
+            continue;
+        }
+        const name = parts[1] ?? '';
+        const value = parts[2] ?? '';
+        const run = suiteRunnerArguments(out);
+        if (run === null) {
+            unplaced.push(flag);
+            continue;
+        }
+        // `--name=value` and `--name value` alike; the last occurrence is the one Playwright uses.
+        // The value is digits (milliseconds, worker counts), so a percentage or an expression is
+        // left alone rather than half-rewritten.
+        const written = new RegExp(`(?:^|[\\s;&|(])${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?:=|\\s+)(['"]?)(\\d[\\d_]*)(?![\\w%.])`, 'g');
+        const text = out.slice(run.start, run.at);
+        let last = null;
+        for (let m = written.exec(text); m !== null; m = written.exec(text))
+            last = m;
+        if (last !== null) {
+            const digits = last[2] ?? '';
+            const at = run.start + last.index + last[0].length - digits.length;
+            out = `${out.slice(0, at)}${value}${out.slice(at + digits.length)}`;
+            placed.push(`${name}=${value}`);
+            continue;
+        }
+        out = `${out.slice(0, run.at)} ${flag}${out.slice(run.at)}`;
+        placed.push(flag);
+    }
+    return { command: out, placed, unplaced };
+}
 /**
  * The command with the `timeout <N>` wrapper lifted off the statement that runs the suite, and the
  * bound that was lifted.
@@ -2224,10 +2384,21 @@ function failureBlockTests(text) {
 export const UNIVERSAL_CAUSE_FILES = 3;
 /**
  * How many tests a run must have walked — with nothing passing since its first failure — before
- * "the page renders nothing" can be its one cause. A handful of failures is a handful of bugs;
- * a page that never painted fails every spec that reaches it, and m141's walk had 36 by +20:30.
- */
-export const EMPTY_PAGE_CAUSE_TESTS = 15;
+ * "the page renders nothing" can be its one cause.
+ *
+ * THREE, and the number is the cost of the alternative. The old floor of 15 was chosen when the
+ * reading was only offered at a completed run; once it STOPS the walk, every test waited for is
+ * a test whose result is thrown away, and a blank page costs its per-test budget each time
+ * (m177: 18 tests, ~4.2 minutes, on a page whose thrown error was visible in the first
+ * `pageerror`). Three is the smallest count that is not one page's own bug: the cause additionally
+ * needs three DISTINCT spec files (`UNIVERSAL_CAUSE_FILES`, or the files a narrowed run selected),
+ * each spec waiting for its OWN first element, and no test passing after the first failure. A page
+ * that renders misses elements, but three unrelated specs in three files failing at three
+ * different first locators with nothing passing in between is the page, not three bugs. At the
+ * suite's own 5 s action timeout that verdict lands ~20 s into the walk, so the early stop costs
+ * about one test's worth of time instead of fifteen.
+ */
+export const EMPTY_PAGE_CAUSE_TESTS = 3;
 /**
  * A failure body whose whole complaint is a wait for an element the page never rendered:
  * Playwright's `waiting for locator(…)` call log, its `element(s) not found` line, or the
@@ -2251,22 +2422,32 @@ function pageErrorInLog(text) {
     return m?.[1]?.trim() || null;
 }
 /**
- * The "nothing has passed and nothing renders" cause: every failure block the log has written is
- * a locator wait, the run has walked at least {@link EMPTY_PAGE_CAUSE_TESTS} tests across the
- * file threshold, and no test has passed since the first failure.
+ * The "nothing has passed and nothing renders" cause: the run's FIRST consecutive failures — from
+ * its first failed test, with no pass since — are all locator waits, at least
+ * {@link EMPTY_PAGE_CAUSE_TESTS} of them across {@link UNIVERSAL_CAUSE_FILES} different spec
+ * files, and each waits for its own spec's first element.
+ *
+ * The file span stays at {@link UNIVERSAL_CAUSE_FILES} whatever the run selected: "the page
+ * renders nothing" is a claim about the APP, and one file's failures can be that file's own setup
+ * (a broken login helper fails every test of one spec at its first locator). A run narrowed to one
+ * or two files still has the signature and connection causes for a whole-run stop.
+ *
+ * Stops the walk as soon as that verdict is readable, not after a fixed floor of failures have
+ * been burned: the page error arrives with the first test, so every further test only repeats it.
  *
  * This is ONE cause even though the signatures differ — each spec asks for its own first element
  * (`input[name="username"]`, `a.navbar-brand`, `h1`), so {@link repeatingFailure} cannot group
  * them and {@link universalCause}'s signature test cannot see the run is over. xr-molecule-flash-
  * m141 (+20:30) walked a built app that rendered nothing: 36 tests had failed, every one at its
- * first locator, and the note told the run to keep walking for another ~9 minutes.
+ * first locator, and the note told the run to keep walking for another ~9 minutes. xr-molecule-
+ * flash-m177 (+08:38 → +12:52) repeated it: 18 tests, one whole walk, on a page whose
+ * `PAGEERROR No 'auth-client' provider bonded` was in the log from the first one.
  *
  * @param text - The log (ANSI already stripped).
- * @param threshold - The spec-file threshold this run is judged against ({@link universalCause}).
  * @param found - The repeating cause {@link repeatingFailure} found, when it found one.
  * @returns The cause, or null when the log is not this shape.
  */
-function emptyPageCause(text, threshold, found) {
+function emptyPageCause(text, found) {
     const marks = resultMarks(text);
     const firstFailure = marks.indexOf('✘');
     if (firstFailure === -1 || marks.slice(firstFailure).includes('✓'))
@@ -2284,10 +2465,15 @@ function emptyPageCause(text, threshold, found) {
     // (which names the repeated error) says more than "the page renders nothing" would.
     if (found !== null && found.message !== null && found.count >= tests.length)
         return null;
+    // The cause is the FIRST consecutive failures: `tests` starts at the first ✘ and no ✓ follows
+    // it, so a page that has failed three tests in a row across three files has already said
+    // everything the rest of the walk can say (m177 paid 4.2 minutes learning that).
     if (tests.length < EMPTY_PAGE_CAUSE_TESTS)
         return null;
     const files = [...new Set(tests.map((t) => specFile(t.where)).filter(Boolean))];
-    if (files.length < threshold)
+    // The blank-page claim is cross-file by construction (see the doc): a selected-file count
+    // below the span does not shrink it, it removes the claim.
+    if (files.length < UNIVERSAL_CAUSE_FILES)
         return null;
     const pageError = pageErrorInLog(text);
     return {
@@ -2424,7 +2610,7 @@ export function universalCause(log, found, command) {
     const threshold = selected === null ? UNIVERSAL_CAUSE_FILES : Math.min(UNIVERSAL_CAUSE_FILES, selected);
     // Nothing has passed and nothing renders: EVERY spec so far is waiting for its own first
     // element, so the signatures differ while the cause does not (xr-molecule-flash-m141).
-    const emptyPage = emptyPageCause(text, threshold, found);
+    const emptyPage = emptyPageCause(text, found);
     if (emptyPage)
         return emptyPage;
     if (!found)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@molecule/api-ai-tools",
-  "version": "1.9.16",
+  "version": "1.9.19",
   "description": "Shared AI agent tools with backend abstraction for sandbox and local execution",
   "type": "module",
   "main": "dist/index.js",