@molecule/api-ai-tools 1.10.1 → 1.10.3

package/README.md

@@ -3,7 +3,7 @@ AUTO-GENERATED — DO NOT EDIT THIS FILE.
 Generated by `mlcl sync-docs` from the package's src/index.ts JSDoc + mlcl/registry.json.
 Edits here are overwritten on the next commit (molecule's pre-commit hook regenerates).
 To change this document, edit the module-level JSDoc in src/index.ts.
-Generated: 2026-10-18T22:07:04.913Z
+Generated: 2026-10-19T03:15:38.119Z
 -->
 
 # @molecule/api-ai-tools
@@ -586,6 +586,16 @@ interface TraceMissingText {
   method: string
   /** The path of the response that carried it (`/api/tags`). */
   path: string
+  /**
+   * Whether the trace PROVES the page dropped the text: the named response is a successful GET
+   * of the collection that started after the last navigation, and the text is absent from the
+   * page's own failure snapshot ({@link traceArtifactsScript}).
+   *
+   * Absent when the evidence is weaker — a creation POST carried the text (m194's button failure
+   * was not a missing article), the snapshot still showed it, or the trace recorded no clock —
+   * and the note then says only that a response contained the text.
+   */
+  dropped?: true
 }
 ```
 
@@ -616,6 +626,43 @@ interface TraceReadContradiction {
 }
 ```
 
+#### `TraceHiddenBox`
+
+A visibility failure whose locator RESOLVED: Playwright calls an element with a zero-size box
+"hidden" even when it is painted, so the useful fact is why the box is empty. The trace's own
+failure snapshot carries the element's children — read here, never guessed.
+
+```typescript
+interface TraceHiddenBox {
+  /** The locator the assertion printed (`locator('a.navbar-brand')`), or the element it names. */
+  locator: string
+  /** The element's tag, lowercased (`a`). */
+  tag: string
+  /** The element's own inline style, when the snapshot carries one. */
+  style?: string
+  /**
+   * The `<img>` the element wraps when that image is its only element child and the element has
+   * no text of its own: the size the box would collapse to.
+   */
+  image?: {
+    /** The image's `src`, bounded. */
+    src?: string
+    /** Its `width` attribute. */
+    width?: string
+    /** Its `height` attribute. */
+    height?: string
+    /** Its inline `style`. */
+    style?: string
+    /** Its `class`. */
+    className?: string
+    /** Its `alt` text. */
+    alt?: string
+  }
+  /** True when the element has no text and no element children at all. */
+  empty?: true
+}
+```
+
 #### `TraceArtifact`
 
 What one trace says: the test it belongs to, the requests it made, and its console lines.
@@ -705,6 +752,13 @@ interface TraceArtifact {
    * and on traces read before this field existed.
    */
   readContradiction?: TraceReadContradiction
+  /**
+   * A visibility failure whose locator RESOLVED into an empty box — Playwright's "hidden" — with
+   * the element's children read from the failure snapshot ({@link TraceHiddenBox}). The note uses
+   * it to name why the box is empty (an `<img>` with no CSS size, a textless element) instead of
+   * leaving the run to probe computed styles (xr-molecule-flash-m197).
+   */
+  hiddenBox?: TraceHiddenBox
 }
 ```
 
@@ -843,14 +897,31 @@ interface SuiteBudgetPin {
   /**
    * The Playwright flags that carry the suite's own settings onto the command
    * (`--timeout=15000`, `--workers=1`), as the consumer's own scan reads them. Empty when the
-   * difference is in settings no flag carries — the pin is then the sentence alone.
+   * difference is in settings no flag carries.
    */
   flags: string[]
+  /** One sentence for the run's result: which of the suite's own settings this run uses. */
+  note: string
   /**
-   * One sentence for the run's result: this run uses the suite's own budget, and which settings
-   * a config keeps because Playwright has no flag for them.
+   * A config file the consumer wrote OUTSIDE the supplied suite, which re-imports the config the
+   * run selected and pins the settings no Playwright flag can carry (`expect.timeout`,
+   * `use.actionTimeout`, `use.navigationTimeout`). When present, the run is launched with
+   * `--config <this path>` in place of the config it named, so those settings are the suite's own
+   * rather than the executor's. Absent when the consumer could not write one.
    */
-  note: string
+  config?: string
+  /**
+   * Every setting the derived config ({@link config}) pins at the suite's own value, by the scan's
+   * key (`timeout`, `expect.timeout`, `actionTimeout`, `navigationTimeout`), in milliseconds as
+   * digits. Empty when no derived config was placed.
+   */
+  values?: Record<string, string>
+  /**
+   * Every setting the run's own config makes different from the suite's, as the consumer's scan
+   * read them: the value this run's config writes and the suite's own. The tool reports the ones
+   * its placement did NOT put back, so a result never claims a drift it carried.
+   */
+  drift?: Record<string, { used: string; suite: string }>
 }
 ```
 
@@ -986,7 +1057,8 @@ interface ToolBuildConfig {
    * different settings, asked BEFORE the run executes. The consumer knows where the suite and its
    * base config live; this shared package does not, so the reading is the consumer's and the
    * mechanics — putting the flags on the runner's own arguments, before the pipeline and outside
-   * any redirect or group closer — are this tool's.
+   * any redirect or group closer, and pointing `--config` at the derived config that carries the
+   * settings no flag can — are this tool's.
    *
    * Called for a Playwright suite command only, and only the LAST suite step is touched. A run
    * that already keeps the suite's settings, or a sandbox with no supplied suite, answers `null`.
@@ -994,7 +1066,7 @@ interface ToolBuildConfig {
    *
    * @param command - The shell command, as the model sent it.
    * @param cwd - The resolved working directory it will run in.
-   * @returns The flags and the sentence, or null when nothing is put back.
+   * @returns The flags, the derived config and the sentence, or null when nothing is put back.
    */
   suiteBudget?: (command: string, cwd: string) => Promise<SuiteBudgetPin | null | undefined>
 
@@ -1227,6 +1299,19 @@ interface CausePageErrors {
   where: string
   /** The alert / error items the page showed at the moment it failed. */
   items: readonly string[]
+  /**
+   * The landmark roles the test's page snapshot printed (`navigation`, `banner`), read from the
+   * YAML block of its own `error-context.md`. Present ONLY when the caller has that test's
+   * snapshot; an empty array means the snapshot was read and showed no landmark, while an absent
+   * field means nothing was read and no claim may be made ({@link missingHeaderNote}).
+   */
+  landmarks?: readonly string[]
+  /**
+   * Whether the test's snapshot showed populated page content (headings, paragraphs, links,
+   * list items, buttons), the other half of the missing-header reading: a page that painted its
+   * main content but no navigation.
+   */
+  populated?: boolean
 }
 ```
 
@@ -1296,6 +1381,14 @@ from any shell runner.
 type InstalledPackageProbe = (path: string) => Promise<InstalledPackageFacts>
 ```
 
+#### `RequiredLandmark`
+
+A landmark role a failed selector requires: `<nav>`/`role=navigation`, `<header>`/`role=banner`.
+
+```typescript
+type RequiredLandmark = 'navigation' | 'banner'
+```
+
 ### Classes
 
 #### `ToolInputError`
@@ -1769,7 +1862,9 @@ the runner invocation each caller read as a run is one.
 
 A command that also runs tests is false however it is spelled: `npx playwright install &&
 npx playwright test` installs and runs, so a caller that sees `playwright test` in it is
-reading a real run.
+reading a real run. So is a command carrying a segment this reader cannot place (a script it
+does not know, which may start a suite): only the runners and the {@link NO_TEST_PROGRAMS}
+table can be accounted for, and "only prints" is a claim about the WHOLE command.
 
 ```typescript
 function commandRunsNoTests(command: string): boolean
@@ -2360,6 +2455,26 @@ function isCredentialExchangePath(path: string, authEndpoints?: readonly string[
 
 **Returns:** True when the path names a credential exchange.
 
+#### `hiddenBoxNote(items)`
+
+The sentence a "hidden" visibility failure earns when the trace proved WHY the box is empty.
+
+Playwright calls an element with a zero-size box hidden even when it is painted, so the answer
+is in the element's children. `a.navbar-brand` on xr-molecule-flash-m197 was 0×4 px because its
+only child was `<img src="/conduit-logo.svg" height="26">`: an SVG with a `viewBox` and no
+width/height has no intrinsic size, and the `height` attribute loses to Tailwind's preflight
+(`img { max-width: 100%; height: auto }`), which the scaffold's own `index.css` imports. The
+note said only "the cause is in the page", and the run spent over four minutes rasterising an
+SVG to PNG. Only what the snapshot shows is claimed ({@link TraceHiddenBox}).
+
+```typescript
+function hiddenBoxNote(items: readonly TraceArtifact[]): string | null
+```
+
+- `items` — The traces {@link parseTraceArtifacts} read.
+
+**Returns:** The sentence, or null when no failure carries a hidden-box reading.
+
 #### `failureTraceNote(items, target, earlierFailures, apiPrefixes, report)`
 
 The note a failed suite run's result carries: what each failing test's page actually sent, and
@@ -2741,6 +2856,33 @@ function suiteRunBudgetCommand(
 
 **Returns:** The command to run, the flags placed on it, and the ones it could not carry.
 
+#### `suiteRunConfigCommand(command, config)`
+
+A command with the derived config put on the LAST suite runner's own arguments, replacing the
+config the run names or added when it names none.
+
+Some of the suite's settings have no Playwright flag (`expect.timeout`, `use.actionTimeout`,
+`use.navigationTimeout`), so a config the executor wrote cannot be corrected from the command
+line. The consumer writes a derived config OUTSIDE the supplied suite that re-imports the one
+the run selected and pins those settings ({@link SuiteBudgetPin.config}); pointing the runner at
+it is the one way to carry them, and it belongs on the runner itself for the same reasons
+{@link suiteRunBudgetCommand}'s flags do (last suite step, before a pipe or group closer).
+
+A command whose runner cannot be placed is returned exactly as written with `placed: false`, so
+the caller never claims a config it did not point the run at.
+
+```typescript
+function suiteRunConfigCommand(
+  command: string,
+  config: string,
+): { command: string; placed: boolean }
+```
+
+- `command` — The shell command about to run.
+- `config` — The config to run, as the runner takes it (`--config <path>`).
+
+**Returns:** The command to run and whether the config was placed.
+
 #### `withoutSuiteTimeout(command)`
 
 The command with the `timeout <N>` wrapper lifted off the statement that runs the suite, and the
@@ -3327,6 +3469,31 @@ function repeatingFailure(log: string): RepeatingFailure | null
 
 **Returns:** The repeating cause, or null when no signature has {@link REPEATING_FAILURE_MIN} distinct tests behind it.
 
+#### `logShowsInlineFailureBodies(log)`
+
+Whether the log read so far carries a failure's own body under a `✘` row — the evidence that a
+run prints each failure's error as that test fails ({@link PLAYWRIGHT_FAILURES_INLINE_ENV}).
+
+`wait_for_task` promises the executor that each failure's report sits right under its `✘` line
+only when the log proves it. The command's shape cannot answer: the launch sets the switch on
+every background command (the executor's wrapper script inherits it), so a wrapper this reader
+cannot place is exactly as covered as `npx playwright test` ({@link streamingBackgroundCommand}).
+The log is the evidence — a `1) [project] › spec › title ───` block whose test the log also
+printed with `✘` ({@link failureBlocks}).
+
+A block alone is not enough: a FINISHED run's end-of-run summary carries the same blocks, and a
+running wait must not be told "as it fails" about a log whose bodies only appear at the end.
+During a wait the run has not ended (the exit file is read first), so a block beside a `✘` row
+is one the reporter printed inline.
+
+```typescript
+function logShowsInlineFailureBodies(log: string): boolean
+```
+
+- `log` — A log, or the slice of one a wait reads.
+
+**Returns:** True when a `✘` row's own test has a failure body under it.
+
 #### `specFilesSelected(command)`
 
 How many test FILES a Playwright run's own command narrows it to, or null when it selects the
@@ -3481,6 +3648,50 @@ function failuresByCause(log: string, excluded?: readonly string[]): FailureCaus
 
 **Returns:** The causes, the one with the most tests first.
 
+#### `requiredLandmark(selector)`
+
+The landmark a selector requires as an ANCESTOR (or names as its own role), or null when it
+names no landmark at all (`h1`, `.article-preview`, `a[href="/profile/x"]`).
+
+```typescript
+function requiredLandmark(selector: string): RequiredLandmark | null
+```
+
+- `selector` — One CSS selector or `getByRole` role from a failure's call log.
+
+**Returns:** The landmark, or null.
+
+#### `missingHeaderNote(log, pageErrors)`
+
+The sentence for a run whose navigational elements are all missing from pages that otherwise
+painted — the missing shared header the executor must check BEFORE rewriting auth.
+
+xr-molecule-flash-m193 (+13:54 → +20:00): four failures on `/` — `a[href="/profile/…"]`,
+`a.navbar-brand`, `nav a[href="/"]`, `nav .user-pic` — while every `error-context.md` snapshot
+showed the feed, sidebar and footer with no navigation at all. `Home.tsx` imported and
+re-exported `Navbar` but never rendered it, and `App.tsx` mounted `<Home />` in a bare route.
+The cause list named four unrelated symptoms, so the run rewrote `Navbar`'s auth logic and then
+the HTTP bond across two whole walks (~6 minutes) instead of mounting the header.
+
+The reading is per FAILURE and per SNAPSHOT: each failure's own selector must require the
+landmark, its own snapshot must have been read AND show populated page content, and that
+snapshot must not contain the landmark. Two or more such failures on ONE route (the route a
+selector names, e.g. `nav a[href="/"]` → `/`; failures whose selector names none ride along)
+are the group. A page that shows the navigation and merely misses a signed-in link is not this
+shape — its snapshots contain the landmark, so nothing is said.
+
+This never stops the run and never claims the page is blank: it is one sentence prepended to
+the causes note ({@link failureCausesNote}).
+
+```typescript
+function missingHeaderNote(log: string, pageErrors?: readonly CausePageErrors[]): string | null
+```
+
+- `log` — The run's output.
+- `pageErrors` — The page snapshot facts the caller read per failing test.
+
+**Returns:** The sentence, or null when the failures do not share a missing landmark.
+
 #### `failureCausesNote(log, excluded, run)`
 
 The one-line-per-cause summary of a finished run's failures, or null when the run named fewer
@@ -3514,6 +3725,7 @@ function failureCausesNote(
     env?: readonly RunEnvSetting[]
   },
   pageErrors?: readonly CausePageErrors[],
+  regressedSpecs?: readonly string[],
 ): string | null
 ```
 
@@ -3862,8 +4074,9 @@ the summary at the end: `list` reads it in its constructor (`ListReporterOptions
 inline the end-of-run repeat is suppressed with it (`epilogue(!printFailuresInline)`), so one
 reporter still prints each failure exactly once.
 
-A background suite is put on `list` (see {@link streamingBackgroundCommand}) and this with it, so
-the log names its causes WHILE it walks. Without it the log's only failure lines are `✘` rows:
+Every background command is given this (see {@link streamingBackgroundCommand}), so a suite the
+executor starts through its own wrapper is covered too — the wrapper passes the environment on
+to the Playwright process it spawns. Without it the log's only failure lines are `✘` rows:
 X1 xr-molecule-flash-m99 (+19:27 → +21:00, 2026-10-16) was told to `grep -n -A 20 '<test name>'`
 the log, got nothing back through four greps, inferred causes from the spec prose instead, and
 edited `app/src` while the run was still walking — which voids the run.
@@ -4174,11 +4387,12 @@ a test whose result is thrown away, and a blank page costs its per-test budget e
 (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.
+no failure showing a locator RESOLVING ({@link ELEMENT_FOUND} — a blank page cannot resolve
+one), 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 locators that never resolved,
+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.
 
 ```typescript
 const EMPTY_PAGE_CAUSE_TESTS: 3

package/dist/no-test-run.d.ts

@@ -49,7 +49,9 @@
  *
  * A command that also runs tests is false however it is spelled: `npx playwright install &&
  * npx playwright test` installs and runs, so a caller that sees `playwright test` in it is
- * reading a real run.
+ * reading a real run. So is a command carrying a segment this reader cannot place (a script it
+ * does not know, which may start a suite): only the runners and the {@link NO_TEST_PROGRAMS}
+ * table can be accounted for, and "only prints" is a claim about the WHOLE command.
  *
  * @param command - The shell command as the executor sent it.
  * @returns True when the command invokes a runner only to print.

package/dist/no-test-run.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-test-run.d.ts","sourceRoot":"","sources":["../src/no-test-run.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AA0EH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAU3D"}
+{"version":3,"file":"no-test-run.d.ts","sourceRoot":"","sources":["../src/no-test-run.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAiLH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAiB3D"}

package/dist/no-test-run.js

@@ -75,6 +75,108 @@ const NO_RUN_FLAGS = {
     ],
     hurl: [/(?:^|\s)--help(?=\s|$)/, /(?:^|\s)-h(?=\s|$)/, /(?:^|\s)--version(?=\s|$)/],
 };
+/**
+ * The programs that start no test — the shell's own bookkeeping (`cd`, `export`, `echo`), and the
+ * readers, printers and file commands an executor uses to look at what is already there (`cat`,
+ * `ls`, `cp`, `tail`, …).
+ *
+ * A segment whose program is neither a runner nor one of these is a program this reader cannot
+ * 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
+ * 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.
+ */
+const NO_TEST_PROGRAMS = new Set([
+    '[',
+    '[[',
+    ':',
+    'awk',
+    'base64',
+    'basename',
+    'case',
+    'cat',
+    'cd',
+    'chmod',
+    'chown',
+    'column',
+    'comm',
+    'cp',
+    'cut',
+    'date',
+    'df',
+    'diff',
+    'dirname',
+    'do',
+    'done',
+    'du',
+    'echo',
+    'egrep',
+    'else',
+    'env',
+    'esac',
+    'export',
+    'expr',
+    'false',
+    'fgrep',
+    'fi',
+    'file',
+    'fold',
+    'for',
+    'grep',
+    'head',
+    'hostname',
+    'id',
+    'if',
+    'jq',
+    'kill',
+    'less',
+    'ln',
+    'ls',
+    'md5sum',
+    'mkdir',
+    'mktemp',
+    'more',
+    'mv',
+    'nl',
+    'od',
+    'paste',
+    'printf',
+    'pwd',
+    'readlink',
+    'realpath',
+    'rev',
+    'rm',
+    'rmdir',
+    'seq',
+    'set',
+    'sha256sum',
+    'sleep',
+    'sort',
+    'stat',
+    'tac',
+    'tail',
+    'tee',
+    'test',
+    'then',
+    'touch',
+    'tr',
+    'true',
+    'type',
+    'uname',
+    'uniq',
+    'unset',
+    'until',
+    'wait',
+    'wc',
+    'which',
+    'while',
+    'whoami',
+    'xxd',
+]);
 /**
  * A heredoc body is data a command writes, not what it runs: a `playwright test --list` inside
  * the config a command writes is not a run of this command either way. The pattern consumes the
@@ -113,7 +215,9 @@ function informational(runner, after) {
  *
  * A command that also runs tests is false however it is spelled: `npx playwright install &&
  * npx playwright test` installs and runs, so a caller that sees `playwright test` in it is
- * reading a real run.
+ * reading a real run. So is a command carrying a segment this reader cannot place (a script it
+ * does not know, which may start a suite): only the runners and the {@link NO_TEST_PROGRAMS}
+ * table can be accounted for, and "only prints" is a claim about the WHOLE command.
  *
  * @param command - The shell command as the executor sent it.
  * @returns True when the command invokes a runner only to print.
@@ -123,9 +227,16 @@ export function commandRunsNoTests(command) {
         return false;
     let invocations = 0;
     for (const segment of commandSegments(command.replace(HEREDOC, ' '))) {
-        const runner = RUNNERS[segment.program];
-        if (!runner)
+        // An own key only: `constructor` is a program name (`constructor --version`) and a
+        // prototype key is not a runner.
+        const runner = Object.hasOwn(RUNNERS, segment.program) ? RUNNERS[segment.program] : undefined;
+        if (runner === undefined) {
+            // A program this reader cannot place may start a suite of its own; only a known
+            // non-test program lets the command keep reading as "prints only".
+            if (!NO_TEST_PROGRAMS.has(segment.program))
+                return false;
             continue;
+        }
         invocations += 1;
         if (!informational(runner, segment.args.join(' ')))
             return false;

package/dist/tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AA4K9C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAahG;AA6ZD,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAqFnE;;;GAGG;AACH,eAAO,MAAM,iBAAiB,QAEA,CAAA;AAE9B;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB,QAI6C,CAAA;AA2ElF;;;;;;;;;;;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;AA2GD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,CAAC,EAAE,eAAe,GAAG,MAAM,EAAE,CAyuFxF"}
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AA4K9C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAahG;AA6ZD,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAsHnE;;;GAGG;AACH,eAAO,MAAM,iBAAiB,QAEA,CAAA;AAE9B;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB,QAI6C,CAAA;AA2ElF;;;;;;;;;;;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;AA2GD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,CAAC,EAAE,eAAe,GAAG,MAAM,EAAE,CAyvFxF"}