@molecule/api-ai-tools 1.8.2 → 1.9.1

package/dist/sleep-peek.d.ts

@@ -0,0 +1,51 @@
+/**
+ * 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
+ * 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
+ * provably dead — the task had ended 0.1 s in (`playwright: not found`, exit 127) and another had
+ * already printed `Error: No tests found` — and the third spent 120 s asleep beside a live
+ * 139-test run whose failures were already in the log.
+ *
+ * The platform does not have to answer "what is the task doing" from a sleep: `wait_for_task`
+ * already returns the moment the task ends, early on a proven repeating cause, and with the
+ * progress and failures the log holds. This module answers only the parsing question — is the
+ * command's FIRST statement a `sleep` of {@link MIN_PEEK_SLEEP_SECONDS} seconds or more, and what
+ * follows it — from the package's own shell parse ({@link locatedCommandSegments}), so a `sleep`
+ * named in an argument (`grep -n 'sleep 60' notes.md`) or written after another statement
+ * (`cd x && sleep 60`) is not one.
+ *
+ * @module
+ */
+/**
+ * The shortest leading sleep the platform drops: below it the wall clock it costs is noise, and a
+ * short settle (`sleep 2; curl …`) is a legitimate thing to run.
+ */
+export declare const MIN_PEEK_SLEEP_SECONDS = 5;
+/** The leading `sleep` a command opens with, and the command that follows it. */
+export interface LeadingSleep {
+    /** How many seconds the statement would have slept (GNU sleep sums its operands). */
+    seconds: number;
+    /** What follows the leading statement, trimmed — '' when the sleep was the whole command. */
+    rest: string;
+}
+/**
+ * The leading `sleep` of a command, when the first statement is one and it asks for at least
+ * {@link MIN_PEEK_SLEEP_SECONDS}.
+ *
+ * The statement is read by {@link locatedCommandSegments} — the same parse every other command
+ * classifier uses — so only a `sleep` in command position of the FIRST statement counts. The end
+ * of that statement is then found by walking forward from its own start: the statement is
+ * `sleep <duration>`, whose words carry no quotes and open no substitution, so the first unquoted
+ * `;`, newline or `&` ends it. A `|` is refused: dropping the left side of a pipeline would hand
+ * the right side its stdin instead, and a `||` fallback would run on a success that never did.
+ *
+ * @param command - The shell command the executor sent.
+ * @returns The seconds and the remaining command, or null when the command does not open with a
+ *   long `sleep`.
+ */
+export declare function leadingSleepPeek(command: string): LeadingSleep | null;
+//# sourceMappingURL=sleep-peek.d.ts.map

package/dist/sleep-peek.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sleep-peek.d.ts","sourceRoot":"","sources":["../src/sleep-peek.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH;;;GAGG;AACH,eAAO,MAAM,sBAAsB,IAAI,CAAA;AAEvC,iFAAiF;AACjF,MAAM,WAAW,YAAY;IAC3B,qFAAqF;IACrF,OAAO,EAAE,MAAM,CAAA;IACf,6FAA6F;IAC7F,IAAI,EAAE,MAAM,CAAA;CACb;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAyBrE"}

package/dist/sleep-peek.js

@@ -0,0 +1,76 @@
+/**
+ * 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
+ * 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
+ * provably dead — the task had ended 0.1 s in (`playwright: not found`, exit 127) and another had
+ * already printed `Error: No tests found` — and the third spent 120 s asleep beside a live
+ * 139-test run whose failures were already in the log.
+ *
+ * The platform does not have to answer "what is the task doing" from a sleep: `wait_for_task`
+ * already returns the moment the task ends, early on a proven repeating cause, and with the
+ * progress and failures the log holds. This module answers only the parsing question — is the
+ * command's FIRST statement a `sleep` of {@link MIN_PEEK_SLEEP_SECONDS} seconds or more, and what
+ * follows it — from the package's own shell parse ({@link locatedCommandSegments}), so a `sleep`
+ * named in an argument (`grep -n 'sleep 60' notes.md`) or written after another statement
+ * (`cd x && sleep 60`) is not one.
+ *
+ * @module
+ */
+import { durationSeconds, locatedCommandSegments } from './command-position.js';
+/**
+ * The shortest leading sleep the platform drops: below it the wall clock it costs is noise, and a
+ * short settle (`sleep 2; curl …`) is a legitimate thing to run.
+ */
+export const MIN_PEEK_SLEEP_SECONDS = 5;
+/**
+ * The leading `sleep` of a command, when the first statement is one and it asks for at least
+ * {@link MIN_PEEK_SLEEP_SECONDS}.
+ *
+ * The statement is read by {@link locatedCommandSegments} — the same parse every other command
+ * classifier uses — so only a `sleep` in command position of the FIRST statement counts. The end
+ * of that statement is then found by walking forward from its own start: the statement is
+ * `sleep <duration>`, whose words carry no quotes and open no substitution, so the first unquoted
+ * `;`, newline or `&` ends it. A `|` is refused: dropping the left side of a pipeline would hand
+ * the right side its stdin instead, and a `||` fallback would run on a success that never did.
+ *
+ * @param command - The shell command the executor sent.
+ * @returns The seconds and the remaining command, or null when the command does not open with a
+ *   long `sleep`.
+ */
+export function leadingSleepPeek(command) {
+    if (typeof command !== 'string')
+        return null;
+    const first = locatedCommandSegments(command)[0];
+    if (!first || first.start === null || first.segment === null)
+        return null;
+    if (first.segment.program !== 'sleep')
+        return null;
+    // GNU sleep sums its operands (`sleep 45 15`); every one of them has to be a duration.
+    let seconds = 0;
+    for (const arg of first.segment.args) {
+        const part = durationSeconds(arg);
+        if (part === null)
+            return null;
+        seconds += part;
+    }
+    if (seconds < MIN_PEEK_SLEEP_SECONDS)
+        return null;
+    let end = command.length;
+    for (let i = first.start; i < command.length; i++) {
+        const char = command[i] ?? '';
+        if (char === '|')
+            return null;
+        if (char === ';' || char === '\n' || char === '&') {
+            end = i;
+            break;
+        }
+    }
+    let at = end;
+    while (at < command.length && /[;&\s]/.test(command[at] ?? ''))
+        at += 1;
+    return { seconds, rest: command.slice(at).trim() };
+}

package/dist/suite-overlap.d.ts

@@ -50,12 +50,44 @@ export declare function withoutHeredocs(command: string): string;
  * @returns The target key.
  */
 export declare function suiteCommandTarget(command: string): string;
+/**
+ * Whether a Playwright statement names its own config — the reading {@link withSuiteConfig} and
+ * {@link scopedRerunCommand} share, so neither adds a second `--config` to a command that has one.
+ *
+ * @param command - A command, or the Playwright statement inside it.
+ * @returns True when the statement loads a config of its own.
+ */
+export declare function namesSuiteConfig(command: string): boolean;
+/**
+ * The command with a `--config` added to the Playwright invocation it starts — or unchanged when
+ * it already names one, or starts no Playwright run.
+ *
+ * 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
+ * `--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
+ * narrowed re-run of a finished run's failures), and a command it hands back has to carry the
+ * config the run was measured under, never the shape that caused that finding.
+ *
+ * @param command - The command as the executor sent it.
+ * @param config - The config the run loads, when the caller knows it.
+ * @returns The command with the flag, or the command unchanged.
+ */
+export declare function withSuiteConfig(command: string, config: string | null | undefined): string;
 /**
  * The whole-suite command made scoped to the tests it should re-run instead: the same
  * invocation — same directory, same settings — with the named `file:line`s in place of the whole
  * suite, `--last-failed` dropped (it re-runs the tests that never ran too, X1 flash-m60) and
  * `--retries=0` set (a re-run of a known failure does not need to pay for retries).
  *
+ * `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
+ * `Cannot navigate to invalid URL` because the re-run loaded no base URL).
+ *
  * @param command - The whole-suite run's command.
  * @param locations - The failing `file:line`s to re-run, as the run's own log printed them — or,
  *   for a run that started outside the suite, the absolute form Playwright matches each file
@@ -64,9 +96,11 @@ export declare function suiteCommandTarget(command: string): string;
  *   (`--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 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.
  * @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[]): string;
+export declare function scopedRerunCommand(command: string, locations: readonly string[], excluded?: readonly string[], config?: string | null): string;
 /**
  * One suite run, as the rule that decides whether a second may start beside it reads it.
  *

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;AAMH;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAoB1D;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,QAAQ,GAAE,SAAS,MAAM,EAAO,GAC/B,MAAM,CA2BR;AAED;;;;;;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;AAqDD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAQvD"}
+{"version":3,"file":"suite-overlap.d.ts","sourceRoot":"","sources":["../src/suite-overlap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAMH;;;;;;;;;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,CAc1F;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;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,GACrB,MAAM,CA8BR;AAED;;;;;;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;AAqDD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAQvD"}

package/dist/suite-overlap.js

@@ -74,12 +74,62 @@ export function suiteCommandTarget(command) {
     }
     return 'local';
 }
+/** Whether a Playwright statement already names its own config (`-c`, `--config`, `--config=`). */
+const NAMES_CONFIG = /(?:^|\s)(?:-c|--config)(?:\s+|=)/;
+/**
+ * Whether a Playwright statement names its own config — the reading {@link withSuiteConfig} and
+ * {@link scopedRerunCommand} share, so neither adds a second `--config` to a command that has one.
+ *
+ * @param command - A command, or the Playwright statement inside it.
+ * @returns True when the statement loads a config of its own.
+ */
+export function namesSuiteConfig(command) {
+    return NAMES_CONFIG.test(command);
+}
+/**
+ * The command with a `--config` added to the Playwright invocation it starts — or unchanged when
+ * it already names one, or starts no Playwright run.
+ *
+ * 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
+ * `--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
+ * narrowed re-run of a finished run's failures), and a command it hands back has to carry the
+ * config the run was measured under, never the shape that caused that finding.
+ *
+ * @param command - The command as the executor sent it.
+ * @param config - The config the run loads, when the caller knows it.
+ * @returns The command with the flag, or the command unchanged.
+ */
+export function withSuiteConfig(command, config) {
+    if (!config)
+        return command;
+    const at = command.search(/\bplaywright\s+test\b/);
+    if (at === -1)
+        return command;
+    const head = command.slice(0, at);
+    const rest = command.slice(at);
+    const end = rest.search(/&&|\|\||;|\|/);
+    const statement = end === -1 ? rest : rest.slice(0, end);
+    const tail = end === -1 ? '' : rest.slice(end);
+    if (namesSuiteConfig(statement))
+        return command;
+    return `${head}${statement.replace(/^(playwright\s+test)\b/, `$1 --config ${shellQuote(config)}`)}${tail}`;
+}
 /**
  * The whole-suite command made scoped to the tests it should re-run instead: the same
  * invocation — same directory, same settings — with the named `file:line`s in place of the whole
  * suite, `--last-failed` dropped (it re-runs the tests that never ran too, X1 flash-m60) and
  * `--retries=0` set (a re-run of a known failure does not need to pay for retries).
  *
+ * `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
+ * `Cannot navigate to invalid URL` because the re-run loaded no base URL).
+ *
  * @param command - The whole-suite run's command.
  * @param locations - The failing `file:line`s to re-run, as the run's own log printed them — or,
  *   for a run that started outside the suite, the absolute form Playwright matches each file
@@ -88,9 +138,11 @@ export function suiteCommandTarget(command) {
  *   (`--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 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.
  * @returns The scoped command, or the command unchanged when it runs no Playwright suite.
  */
-export function scopedRerunCommand(command, locations, excluded = []) {
+export function scopedRerunCommand(command, locations, excluded = [], config) {
     const at = command.search(/\bplaywright\s+test\b/);
     if (at === -1)
         return command;
@@ -110,10 +162,13 @@ export function scopedRerunCommand(command, locations, excluded = []) {
             .map((t) => t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
             .join('|'))}`
         : '';
+    // The run's own config: the command's `--config` when it has one, else the config the caller
+    // recorded for the run. A re-run without it measures nothing (m113).
+    const carry = config && !namesSuiteConfig(statement) ? ` --config ${shellQuote(config)}` : '';
     const scoped = statement
         .replace(/\s*--last-failed\b/g, '')
         .replace(/\s*--retries(?:[= ]\d+)?/g, '')
-        .replace(/^(playwright\s+test)\b/, `$1 ${locations.join(' ')} --retries=0${invert}`);
+        .replace(/^(playwright\s+test)\b/, `$1 ${locations.join(' ')} --retries=0${carry}${invert}`);
     return `${head}${scoped}${tail}`;
 }
 /**

package/dist/tools.d.ts

@@ -60,8 +60,47 @@ export declare const SUITE_OVER_BUDGET_ADVICE: string;
  */
 export declare function moleculeDistReadNote(path: string): string | null;
 /**
- * The refusal for a write whose target is inside an installed package, or null
- * when the path is not under a `node_modules` directory.
+ * What the filesystem says about a write target under `node_modules` — the half
+ * of the decision a path's spelling cannot make.
+ *
+ * @remarks
+ * A path that reads `node_modules` is not necessarily an install: a run links
+ * `node_modules` beside its e2e copy to borrow the hoisted tree, and that link
+ * is its own. X0 xr-molecule-flash-m106 (+07:58) made exactly that link, found
+ * it dangling (everything was hoisted to `/workspace/node_modules`), and was
+ * refused three times for trying to remove it — 40 s and a "3rd time this turn
+ * … ask the user" escalation, in an unattended run, over a broken symlink in
+ * the run's own scratch directory. So the guard asks what is there.
+ */
+export interface InstalledPackageFacts {
+    /** Whether the `node_modules` entry the path goes through is a symbolic link. */
+    readonly symlink: boolean;
+    /** Whether a package is really installed there: a `package.json` resolves under the entry. */
+    readonly installed: boolean;
+}
+/**
+ * Looks at the filesystem for {@link InstalledPackageFacts}.
+ *
+ * The guard cannot `stat` the path itself: the tools act through a backend (a
+ * sandbox over the network for the fleet), so the caller — which holds that
+ * backend — supplies the look. {@link shellInstalledPackageProbe} builds one
+ * from any shell runner.
+ */
+export type InstalledPackageProbe = (path: string) => Promise<InstalledPackageFacts>;
+/**
+ * Build an {@link InstalledPackageProbe} from a shell runner (a backend's
+ * `run`, or a sandbox's `exec`): one command reports whether the entry is a
+ * link and whether a `package.json` resolves under it.
+ *
+ * @param run - Runs a command where the path lives.
+ * @returns The probe.
+ */
+export declare function shellInstalledPackageProbe(run: (command: string) => Promise<{
+    stdout?: string;
+} | null | undefined>): InstalledPackageProbe;
+/**
+ * The refusal for a write whose target is inside an INSTALLED package, or null
+ * when the path is not under `node_modules` or nothing is installed there.
  *
  * `node_modules` is not the project's code: nothing written there survives the
  * next install, no deploy carries it, and a sandbox whose dependency tree is
@@ -74,6 +113,19 @@ export declare function moleculeDistReadNote(path: string): string | null;
  * putting the file back. Reading these files stays allowed (that is how the
  * declarations above are read at all).
  *
+ * What is protected is the INSTALL, not the spelling: the decision comes from
+ * {@link InstalledPackageFacts}, never from the path alone (m106 above). Three
+ * things are the run's own to remove or replace —
+ *
+ * - a `node_modules` that is a SYMLINK: `rm`/`unlink` removes the link, never the
+ *   tree it points at, so a link the run made cannot clobber anything;
+ * - anything under the run's own `.mol-scratch/` directory;
+ * - a `node_modules` with no `package.json` under it (nothing was ever installed).
+ *
+ * A path INSIDE the link is still decided by what resolves there: a link into a
+ * real tree is refused, because removing or writing through it reaches the
+ * install.
+ *
  * The restore route is named because the model that has ALREADY clobbered a file
  * (this refusal is too late for it) is the one who needs it, and because the
  * obvious repair — `npm install <pkg>` — is itself refused in the pre-installed
@@ -81,9 +133,10 @@ export declare function moleculeDistReadNote(path: string): string | null;
  * m91 used, and what both guards leave alone.
  *
  * @param path - An absolute path a tool is about to write.
+ * @param probe - Looks at the filesystem where the path lives.
  * @returns The one-line refusal naming the package, or null when nothing is installed there.
  */
-export declare function installedPackageWriteRefusal(path: string): string | null;
+export declare function installedPackageWriteRefusal(path: string, probe?: InstalledPackageProbe): Promise<string | null>;
 /**
  * Build a complete set of AI agent tools bound to an execution backend.
  *

package/dist/tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AA0G9C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAahG;AAyHD,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAkEnE;;;GAGG;AACH,eAAO,MAAM,iBAAiB,QAEA,CAAA;AAE9B;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB,QAI6C,CAAA;AAmBlF;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAUhE;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAsBxE;AAgDD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,CAAC,EAAE,eAAe,GAAG,MAAM,EAAE,CAyzExF"}
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAgJ9C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAahG;AAiOD,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAmEnE;;;GAGG;AACH,eAAO,MAAM,iBAAiB,QAEA,CAAA;AAE9B;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB,QAI6C,CAAA;AAmBlF;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAUhE;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,qBAAqB;IACpC,iFAAiF;IACjF,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,8FAA8F;IAC9F,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;CAC5B;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,qBAAqB,CAAC,CAAA;AAoBpF;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,CAAC,GACxE,qBAAqB,CAkBvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAsB,4BAA4B,CAChD,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,qBAAqB,GAC5B,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAiCxB;AAgDD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,CAAC,EAAE,eAAe,GAAG,MAAM,EAAE,CAu2ExF"}