@molecule/api-ai-tools 1.9.19 → 1.10.1

package/dist/tools.js

@@ -7,7 +7,7 @@
  * @module
  */
 import { posix } from 'path';
-import { commandCutRun, CUT_AT_BUDGET, cutRunSentence, suiteRunExitCode } from './cut-run.js';
+import { commandCutRun, CUT_AT_BUDGET, cutRunSentence, suiteRunExitCode, suiteSummary, } from './cut-run.js';
 import { addChangeSpan, changedSpan, countLines, renderEditExcerpt, renderSmallFile, } from './edit-excerpt.js';
 import { guardToolExecute, missingParamError, ToolInputError } from './input-normalizer.js';
 import { diffLineCount } from './line-diff.js';
@@ -171,6 +171,105 @@ export async function taskStopCommand(backend, taskId) {
         return fallback;
     }
 }
+/**
+ * How often a wait re-asks whether a task whose exit file has not appeared has ended. The exit
+ * file is read every tick; this probe is a process test plus the task's own output, and 3 s is
+ * close enough that a run which ended is never waited out (m182: 281 s on a walk that ended in 20).
+ */
+const TASK_END_LOOK_MS = 3_000;
+/** How much of a task's own output the end test reads — a runner's tally is its last lines. */
+const TASK_OUTPUT_END_BYTES = 4_000;
+/**
+ * The shell probe behind {@link taskEndState}: the pid the launcher wrote, and the end of the
+ * file the command redirects its own output to.
+ *
+ * The pid test is the one `molecule-dev/api/src/ai/background-tasks.ts` applies in `liveness` —
+ * a written exit code ends the task, a live pid keeps it running, and a handle the sandbox cannot
+ * account for stays unknown — so this package and that one cannot disagree about whether a task
+ * is still walking.
+ *
+ * @param taskId - The task's `mol-bg-…` handle (format already checked by the caller).
+ * @param own - The file the command redirects its own output to, when the launch could tell.
+ * @returns The command; its first line is `MOL_TASK_STATE <alive|gone|unknown>`, the rest the tail.
+ */
+const taskStateCommand = (taskId, own) => `P=$(cat /tmp/${taskId}.pid 2>/dev/null); ` +
+    `if [ -z "$P" ] || [ ! -f /tmp/${taskId}.sh ]; then echo MOL_TASK_STATE unknown; ` +
+    `elif kill -0 "$P" 2>/dev/null; then echo MOL_TASK_STATE alive; ` +
+    `else echo MOL_TASK_STATE gone; fi; ` +
+    (own ? `tail -c ${TASK_OUTPUT_END_BYTES} ${shellQuote(own)} 2>/dev/null` : 'true');
+/**
+ * The ending a task's own output already records, read from the file its command redirects to.
+ *
+ * A command can put its real work in a subshell and leave the platform's wrapper waiting on
+ * something else — `( runner > /tmp/full-run.log; echo EXIT=$? >> /tmp/full-run.log ) &` — so
+ * the task log stays empty and the exit file may never appear while the run itself is over. The
+ * run's own file is where its outcome is: an `EXIT=<n>` line the command appended, or the
+ * runner's closing tally (Playwright's status lines, Vitest's `Tests …` line, Hurl's
+ * `Executed files:`), which is the last thing a finished run prints.
+ *
+ * @param text - The tail of the task's own output file.
+ * @returns Whether the output records an ending, and the code when it recorded one.
+ */
+function outputEnding(text) {
+    const trimmed = text.trimEnd();
+    if (!trimmed)
+        return { ended: false, exitCode: null };
+    // An explicit marker the command appended is the run's own verdict, whatever precedes it.
+    const marker = /(?:^|\n)EXIT=(\d+)\s*$/.exec(trimmed);
+    if (marker)
+        return { ended: true, exitCode: Number(marker[1]) };
+    const lastLine = trimmed.slice(trimmed.lastIndexOf('\n') + 1).trim();
+    // A tally is an ending only as the LAST line: a second walk starts by printing its own header,
+    // so a file whose last line is still the first walk's tally is between the two.
+    const tallyLine = /^\d+\s+(?:passed|failed|flaky|skipped|interrupted|timed out|did not run)\b/.test(lastLine) ||
+        /^Tests\s+.+\(\d+\)$/.test(lastLine) ||
+        /\bExecuted files:\s*\d+/.test(lastLine);
+    if (!tallyLine)
+        return { ended: false, exitCode: null };
+    return { ended: suiteSummary(trimmed)?.finished ?? false, exitCode: null };
+}
+/**
+ * Whether a background task has ENDED, asked of the task itself rather than of a note about it.
+ *
+ * A missing exit file alone is not "running": the launcher writes that file from the wrapper it
+ * started, and a command that backgrounds its real work leaves the file missing after the run is
+ * over. X1 xr-molecule-flash-m182 (+30:25) waited 281 s — its whole remaining ceiling — on a walk
+ * that had ended in 20 s, and a `sleep 240; tail` on the same handle was answered "is live". The
+ * end is read the way `molecule-dev/api/src/ai/background-tasks.ts` reads it — exit file, then
+ * the pid — plus the one signal this package has and that tracker does not: the task's own output
+ * file already holding its ending.
+ *
+ * @param backend - The execution backend the task runs on.
+ * @param taskId - The task's `mol-bg-…` handle.
+ * @returns Whether it has ended, and the code its own output recorded when it recorded one.
+ */
+async function taskEndState(backend, taskId) {
+    const own = outputFileByTask.get(taskId);
+    let stdout;
+    try {
+        const r = await backend.run(taskStateCommand(taskId, own), { timeout: 5_000 });
+        stdout = String(r.stdout ?? '');
+    }
+    catch (_error) {
+        // A sandbox that cannot answer is not evidence of an ending: the quiet failure (a wait) beats
+        // the loud one (a result handed back for a run that is still walking).
+        return { ended: false, exitCode: null };
+    }
+    const [stateLine = '', ...rest] = stdout.split('\n');
+    const state = /MOL_TASK_STATE (alive|gone|unknown)/.exec(stateLine)?.[1] ?? 'unknown';
+    const ownEnding = outputEnding(rest.join('\n'));
+    // The run's own output can end the task while its wrapper is still alive: the wrapper may be
+    // waiting on the wrong thing (m182's was blocked) while the run it started is over. An explicit
+    // `EXIT=<n>` is that verdict; a bare tally is trusted only once the pid is gone, because the
+    // instant between a walk's tally and its next walk's header reads the same.
+    if (ownEnding.ended && (ownEnding.exitCode !== null || state === 'gone'))
+        return ownEnding;
+    // A pid this sandbox can account for and that is gone, with no exit file: the wrapper that
+    // writes the exit code was killed or exited, so the task ended and has no verdict to invent.
+    if (state === 'gone')
+        return { ended: true, exitCode: null };
+    return { ended: false, exitCode: null };
+}
 /** A millisecond span the way a model reads it: seconds under 90, else minutes. */
 function durationText(ms) {
     const s = Math.max(0, Math.round(ms / 1000));
@@ -382,17 +481,27 @@ async function backgroundTaskState(backend, command, seconds, ceilingMs) {
         const own = outputFileByTask.get(id);
         return own !== undefined && command.includes(own);
     };
+    // A task is only a candidate to WAIT on while it is still walking: the exit file and the same
+    // end test `wait_for_task` applies both say when it ended, so a sleep is never held for a handle
+    // whose run is already over (m182 +30:25: `sleep 240; tail /tmp/full-run.log` was answered "is
+    // live" for a task that had ended 20 s after it started).
+    const stateOf = async (id) => {
+        const exitCode = await exitCodeOf(id);
+        if (exitCode !== null)
+            return { id, ended: true, exitCode };
+        return { id, ...(await taskEndState(backend, id)) };
+    };
     const newestFirst = [...ids].reverse();
     const namedId = newestFirst.find(names);
     let target = namedId
-        ? { id: namedId, exitCode: await exitCodeOf(namedId) }
+        ? await stateOf(namedId)
         : null;
     if (!target) {
         // Bounded: a long session can leave many finished tasks behind, and each look costs a read.
         for (const id of newestFirst.slice(0, 8)) {
-            const exitCode = await exitCodeOf(id);
-            if (exitCode === null) {
-                target = { id, exitCode };
+            const state = await stateOf(id);
+            if (!state.ended) {
+                target = state;
                 break;
             }
         }
@@ -408,7 +517,7 @@ async function backgroundTaskState(backend, command, seconds, ceilingMs) {
         // No slice: the note still says the task's state and how to get its result.
     }
     const secondsText = `Did not sleep ${Math.round(seconds)} s: background task \`${target.id}\``;
-    if (target.exitCode === null) {
+    if (!target.ended) {
         const facts = waitProgressClauses({
             taskId: target.id,
             slice,
@@ -427,8 +536,12 @@ async function backgroundTaskState(backend, command, seconds, ceilingMs) {
     const counter = logProgress(slice);
     const progress = counter ? `, at ${counter.done} of ${counter.total} in its log` : '';
     const failures = slice.trim() ? '; the failures in its log are in outputSoFar' : '';
+    // No exit file and no code in the run's own output: it ended and there is no verdict to invent.
+    const verdict = target.exitCode === null
+        ? 'no exit code — its process is gone and its output recorded none'
+        : `exit code ${target.exitCode}`;
     return {
-        note: `${secondsText} had already ended (exit code ${target.exitCode})${progress}${failures} — ` +
+        note: `${secondsText} had already ended (${verdict})${progress}${failures} — ` +
             `\`wait_for_task ${target.id}\` returns its result now.`,
         slice,
     };
@@ -483,6 +596,62 @@ export const SUITE_OVER_BUDGET_ADVICE = 'A test suite is not a bigger unit to sp
  * sentence, which names an option the executor cannot set.
  */
 const SEARCH_TIMEOUT_MS = 10_000;
+/**
+ * The most alternatives one brace group in a `search_files` include may expand
+ * to. The point is to accept the ordinary multi-extension form a model writes
+ * from habit (`*.{ts,tsx,yml,json,md}`), not to grow a glob engine: a group is
+ * bounded so a pattern cannot turn one grep call into hundreds.
+ */
+const MAX_INCLUDE_BRACE_ALTERNATIVES = 16;
+/**
+ * Expand ONE level of brace alternatives in a `search_files` include pattern,
+ * validating every expanded pattern.
+ *
+ * `grep --include` has no brace expansion of its own (the shell that would do it
+ * is never involved — the pattern is `shellQuote`d first), so the group has to
+ * be expanded here and each alternative passed as its own `--include`. The
+ * m189 run wrote the everyday `*.{ts,tsx,yml,json,md}` and the search was
+ * refused outright, costing a round trip and pushing the agent to a narrower
+ * search.
+ *
+ * Bounded on purpose: one level of braces, alternatives split on `,`, at most
+ * {@link MAX_INCLUDE_BRACE_ALTERNATIVES}, none empty, and each EXPANDED
+ * pattern must still pass {@link isValidGlob} — so a shell metacharacter in any
+ * alternative (`*.{ts,$(rm)}`) is refused exactly as a bare one is.
+ *
+ * @param pattern - The user-supplied `include` value.
+ * @returns Every pattern to pass to grep, or null when the value is not
+ *   accepted (the caller reports the include-glob error).
+ */
+function expandIncludeGlob(pattern) {
+    const open = pattern.indexOf('{');
+    if (open === -1)
+        return isValidGlob(pattern) ? [pattern] : null;
+    const close = pattern.indexOf('}', open + 1);
+    if (close === -1)
+        return null;
+    // One level only: a second `{` before the close or a second `}` after it is a
+    // nested/malformed group, not an alternative.
+    const nextOpen = pattern.indexOf('{', open + 1);
+    if (nextOpen !== -1 && nextOpen < close)
+        return null;
+    if (pattern.indexOf('}', close + 1) !== -1)
+        return null;
+    const alternatives = pattern.slice(open + 1, close).split(',');
+    if (alternatives.length > MAX_INCLUDE_BRACE_ALTERNATIVES)
+        return null;
+    if (alternatives.some((alt) => alt.length === 0))
+        return null;
+    const expanded = alternatives.map((alt) => `${pattern.slice(0, open)}${alt}${pattern.slice(close + 1)}`);
+    return expanded.every((p) => isValidGlob(p)) ? expanded : null;
+}
+/**
+ * The include-glob error. It keeps the original character-rule sentence and
+ * names the accepted multi-extension form, so a refusal teaches the syntax
+ * rather than only reporting that the value was wrong.
+ */
+const INCLUDE_GLOB_ERROR = 'Invalid include glob pattern. Allowed: alphanumeric and @ * ? . _ - / [ ] ( ), ' +
+    'or one brace group of up to 16 comma-separated alternatives such as *.{ts,tsx}.';
 /**
  * The share of its budget a command must use before the "you asked for more than
  * this tool's ceiling" note is worth attaching. Below it the clamp changed nothing
@@ -728,7 +897,7 @@ function packageCatalog(path) {
  * @returns Array of AITool objects ready to pass to an AI provider
  */
 export function buildTools(backend, config) {
-    const { include, exclude, pathGuards = true, symlinkGuards = false, redactSecrets: doRedact = true, blockDangerousCommands = false, blockCommand, execTimeoutMs = 120_000, commandBudgetMs, overCeilingGraceMs = OVER_CEILING_GRACE_MS, searchExcludedDirs, outlineLargeHtml, excludedTestTitles, onAfterWrite, onFileDiff, onFileChange, } = config ?? {};
+    const { include, exclude, pathGuards = true, symlinkGuards = false, redactSecrets: doRedact = true, blockDangerousCommands = false, blockCommand, execTimeoutMs = 120_000, commandBudgetMs, overCeilingGraceMs = OVER_CEILING_GRACE_MS, searchExcludedDirs, outlineLargeHtml, excludedTestTitles, requiredSuiteEnv, onAfterWrite, onFileDiff, onFileChange, } = config ?? {};
     const root = backend.projectRoot;
     // A host-filesystem backend with escape guards off is the combination the
     // audit flagged: `pathGuards` off lets `..` paths out of the workspace,
@@ -1541,7 +1710,14 @@ export function buildTools(backend, config) {
                 await backend.writeFile(path, content);
                 if (onAfterWrite)
                     await onAfterWrite(path).catch(() => { });
-                const finalContent = await backend.readFile(path).catch(() => content);
+                // The text on disk is the text just written unless an after-write hook (a formatter)
+                // may have rewritten it. Without one, the re-read is a whole sandbox round trip per
+                // write that can only return what is already in hand — measured in the write path's
+                // own timings (x0 fast-file-writes: four sandbox calls per write, one of them this
+                // re-read, and the excerpt it feeds is identical either way).
+                const finalContent = onAfterWrite
+                    ? await backend.readFile(path).catch(() => content)
+                    : content;
                 const diff = computeDiff(oldContent, finalContent);
                 if (onFileChange)
                     onFileChange({ type: oldContent === null ? 'created' : 'modified', path });
@@ -2066,15 +2242,18 @@ export function buildTools(backend, config) {
             const contextLines = Number.isFinite(rawContext)
                 ? Math.min(Math.max(Math.trunc(rawContext), 0), MAX_SEARCH_CONTEXT_LINES)
                 : 0;
-            if (include && !isValidGlob(include))
-                return {
-                    error: 'Invalid include glob pattern. Allowed: alphanumeric and @ * ? . _ - / [ ] ( ).',
-                };
+            // `--include` has no brace expansion inside the quoted grep argument, so
+            // a brace group is expanded here and grep gets one --include per pattern.
+            const includes = include ? expandIncludeGlob(include) : [];
+            if (includes === null)
+                return { error: INCLUDE_GLOB_ERROR };
             const symlinkErr = await checkSymlink(path);
             if (symlinkErr)
                 return { error: symlinkErr };
             try {
-                const globArg = include ? `--include=${shellQuote(include)}` : '';
+                const globArg = includes.length
+                    ? includes.map((p) => `--include=${shellQuote(p)}`).join(' ')
+                    : '';
                 // With context, grep emits `file-line-content` for context lines and
                 // `file:line:content` for matches, plus `--` group separators. Both
                 // shapes are parsed below; without context the output is unchanged.
@@ -2900,6 +3079,8 @@ export function buildTools(backend, config) {
             const started = runByTask.get(taskId);
             let midRunNote = null;
             let lastCauseLookAt = startedAt - repeatingCauseLookMs();
+            let lastEndLookAt = startedAt - TASK_END_LOOK_MS;
+            let endedWithoutCode = false;
             let exitCode = await readExit();
             while (exitCode === null && Date.now() - startedAt < budgetMs) {
                 await new Promise((r) => setTimeout(r, Math.min(2_000, budgetMs - (Date.now() - startedAt))));
@@ -2908,6 +3089,19 @@ export function buildTools(backend, config) {
                 // its real result instead of a note about it.
                 if (exitCode !== null)
                     break;
+                // A missing exit file is not "running": the launcher writes that file from its wrapper,
+                // and a command that backgrounds its real work leaves it missing after the run is over.
+                // The same end test the sleep peek uses answers here, before a cause look can `continue`
+                // past it — m182 (+30:25) waited 281 s on a walk that had ended in 20 s.
+                if (Date.now() - lastEndLookAt >= TASK_END_LOOK_MS) {
+                    lastEndLookAt = Date.now();
+                    const state = await taskEndState(backend, taskId);
+                    if (state.ended) {
+                        exitCode = state.exitCode;
+                        endedWithoutCode = state.exitCode === null;
+                        break;
+                    }
+                }
                 if (repeatingCauseNoted.has(taskId))
                     continue;
                 if (Date.now() - lastCauseLookAt < repeatingCauseLookMs())
@@ -2987,7 +3181,10 @@ export function buildTools(backend, config) {
             }
             const waitedMs = Date.now() - startedAt;
             waitedByTask.set(taskId, waitedBefore + waitedMs);
-            if (exitCode === null) {
+            // A task the end test found over with no exit code is FINISHED, not still walking: its
+            // result is read below from its own output. Only a task still alive (or a sandbox that
+            // could not answer) reaches the running/stuck answers.
+            if (exitCode === null && !endedWithoutCode) {
                 const grownTo = await logBytes();
                 const lastSize = logBytesByTask.get(taskId);
                 if (grownTo !== null)
@@ -3138,12 +3335,20 @@ export function buildTools(backend, config) {
             // failing tests instead of leaving the executor to re-run the whole suite (xr-molecule-
             // flash-m101 +12:13: 139 tests, ~4 minutes, to check two fixes).
             const run = runByTask.get(taskId);
+            // What the REQUEST requires of this suite and the run left out: the narrowed re-run below
+            // is composed from the run's own command, so without these it would measure the same wrong
+            // configuration again (m182: the request names `TEST_MODE=fullstack`, the run and its
+            // re-run both omitted it, and the walk measured the `spa` suite). The consumer's reading,
+            // asked once per finished run; a failure to read answers "nothing required".
+            const requiredEnv = run && requiredSuiteEnv
+                ? ((await requiredSuiteEnv(run.command, run.cwd).catch(() => [])) ?? [])
+                : [];
             // The tests the request excludes are not causes to fix, and the re-run below inverts them
             // out — a result must never ask the executor to fix a test it also says does not count.
             // The log's own path rides along so a recap that leaves causes out can hand over the ONE
             // grep that prints their bodies: the stdout above is cut in the middle, so the log is where
             // they still are whole.
-            const causes = failureCausesNote(output, excludedTestTitles?.() ?? [], run ? { ...run, log: ownFile ?? log } : undefined);
+            const causes = failureCausesNote(output, excludedTestTitles?.() ?? [], run ? { ...run, log: ownFile ?? log, env: requiredEnv } : undefined);
             // A backgrounded run is under no tool budget, and the exit file hands back the PIPELINE's
             // code — so a suite killed at a `timeout 280` the command carried behind a `| tail` reports
             // 0 here too. The run's start is in its own id ({@link taskStartedAt}), so the bound it used
@@ -3177,7 +3382,16 @@ export function buildTools(backend, config) {
                 ? suiteRunPipelinePlacement(run.command)
                 : { piped: false, unplaced: false };
             const reported = suiteRunExitCode(exitCode, output, placement.piped);
-            const noCodeNote = suiteExitCodeNote(placement, reported);
+            // A run that ended with no code at all is not a filtered pipeline: the sentence below says
+            // where its result came from, and claiming a stage after the runner would contradict it.
+            const noCodeNote = endedWithoutCode ? null : suiteExitCodeNote(placement, reported);
+            // The task ended and no exit file recorded a verdict: say so, and say where the result came
+            // from, so the executor reads it instead of waiting on a handle that can never answer.
+            const endedNote = endedWithoutCode
+                ? 'It ended without writing an exit code — its process is gone' +
+                    (ownFile ? `, and its own output (${ownFile}) is the result below` : '') +
+                    '. Read that result; do not wait on this task again.'
+                : null;
             // A FINISHED result says so, even when the code it would report is withheld: a filtered
             // pipeline's code is not the run's verdict ({@link FILTERED_EXIT_NOTE}), so `exitCode` alone
             // cannot tell a caller this is the delivered result rather than a progress return — and a
@@ -3187,8 +3401,12 @@ export function buildTools(backend, config) {
                 status: 'completed',
                 exitCode: reported,
                 waitedMs,
-                ...(causes || noCodeNote
-                    ? { note: [causes, noCodeNote].filter((n) => Boolean(n)).join(' ') }
+                ...(causes || noCodeNote || endedNote
+                    ? {
+                        note: [causes, noCodeNote, endedNote]
+                            .filter((n) => Boolean(n))
+                            .join(' '),
+                    }
                     : {}),
                 stdout: sanitizeOutput(truncateMiddle(output, MAX_OUTPUT_SIZE)),
                 ...(output.length > MAX_OUTPUT_SIZE ? { truncated: true, fullOutput: log } : {}),

package/dist/trace-artifacts.d.ts

@@ -190,6 +190,29 @@ export interface TraceMissingText {
     /** The path of the response that carried it (`/api/tags`). */
     path: string;
 }
+/**
+ * A write the trace recorded answering a boolean field, and a LATER GET of the same resource
+ * answering the opposite for that field.
+ *
+ * This is the pair that reads as a frontend race and is not one: xr-molecule-flash-m181's follow
+ * test sent `POST /api/profiles/:username/follow` and the API answered
+ * `{"profile":{…,"following":true}}`, then a `GET /api/profiles/:username` answered
+ * `{"profile":{…,"following":false}}` — the READ route never saw the viewer, so it hydrated
+ * `following` from nobody. The run rewrote the profile component twice, the API client once, and
+ * added optimistic state before anyone read the route's middleware; the write itself was fine.
+ */
+export interface TraceReadContradiction {
+    /** The boolean field both answered (`following`, `favorited`). */
+    field: string;
+    /** What the write's response said it is. */
+    writeValue: boolean;
+    /** What the later read's response said it is. */
+    readValue: boolean;
+    /** The write that answered it (`POST /api/profiles/x/follow`). */
+    write: TraceRequest;
+    /** The later GET of the same resource (`GET /api/profiles/x`). */
+    read: TraceRequest;
+}
 /** What one trace says: the test it belongs to, the requests it made, and its console lines. */
 export interface TraceArtifact {
     /** The failure's spec file, relative to the run's directory, when the trace names one. */
@@ -266,6 +289,15 @@ export interface TraceArtifact {
      * read before this field existed.
      */
     missingText?: TraceMissingText;
+    /**
+     * A write's answer a later GET of the same resource contradicted — the read route does not see
+     * the viewer (xr-molecule-flash-m181's `following`). The note leads with it and sends the run at
+     * the route's middleware, not the page's state handling.
+     *
+     * Absent when no write and later read in the trace answered the same boolean field differently,
+     * and on traces read before this field existed.
+     */
+    readContradiction?: TraceReadContradiction;
 }
 /** How many traces one read reports, newest first. */
 export declare const MAX_TRACE_ARTIFACTS = 12;
@@ -491,6 +523,12 @@ export declare function isCredentialExchangePath(path: string, authEndpoints?: r
  * this on the deployed URL only, where the background session verification lands later than it
  * does locally.
  *
+ * A write whose response said a boolean field is true and a LATER GET of the same resource that
+ * said it is false leads the note first ({@link readContradictionSentence}): the read route never
+ * saw the viewer, so the fix is on that route's middleware, not in the page. xr-molecule-flash-m181
+ * spent ~8 minutes rewriting the profile component over exactly that pair — the write answered
+ * `{"following":true}` and the next profile GET answered `false`.
+ *
  * WHICH rows it spends is evidence, not artifact order (xr-molecule-flash-m112 +53:46): a row
  * needs a recorded response, a real failure or a console line ({@link traceRowEvidence}), rows are
  * deduplicated by the test's location, and they are ordered real failure → repeated from an

package/dist/trace-artifacts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trace-artifacts.d.ts","sourceRoot":"","sources":["../src/trace-artifacts.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"trace-artifacts.d.ts","sourceRoot":"","sources":["../src/trace-artifacts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAKH,iEAAiE;AACjE,MAAM,WAAW,YAAY;IAC3B,gCAAgC;IAChC,MAAM,EAAE,MAAM,CAAA;IACd,iGAAiG;IACjG,IAAI,EAAE,MAAM,CAAA;IACZ;;;;OAIG;IACH,MAAM,EAAE,MAAM,CAAA;IACd;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;;;;;OAKG;IACH,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,oFAAoF;IACpF,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAA;IACb;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;;;;;;;;OAQG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,iFAAiF;IACjF,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,eAAe;IAC9B,yFAAyF;IACzF,GAAG,EAAE,MAAM,CAAA;IACX,oEAAoE;IACpE,KAAK,EAAE,MAAM,CAAA;IACb,kEAAkE;IAClE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;IAClB;;;;OAIG;IACH,QAAQ,EAAE,YAAY,EAAE,CAAA;IACxB,yFAAyF;IACzF,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,4EAA4E;IAC5E,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,gFAAgF;AAChF,MAAM,WAAW,WAAW;IAC1B,yFAAyF;IACzF,GAAG,EAAE,MAAM,CAAA;IACX,wEAAwE;IACxE,KAAK,EAAE,MAAM,CAAA;IACb,kEAAkE;IAClE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;IAClB,2FAA2F;IAC3F,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,oFAAoF;IACpF,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,2DAA2D;IAC3D,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,oBAAoB;IACnC,2CAA2C;IAC3C,OAAO,EAAE,MAAM,CAAA;IACf;;;OAGG;IACH,QAAQ,EAAE,YAAY,EAAE,CAAA;CACzB;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,gBAAgB;IAC/B,sDAAsD;IACtD,IAAI,EAAE,MAAM,CAAA;IACZ,0DAA0D;IAC1D,MAAM,EAAE,MAAM,CAAA;IACd,8DAA8D;IAC9D,IAAI,EAAE,MAAM,CAAA;CACb;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,sBAAsB;IACrC,kEAAkE;IAClE,KAAK,EAAE,MAAM,CAAA;IACb,4CAA4C;IAC5C,UAAU,EAAE,OAAO,CAAA;IACnB,iDAAiD;IACjD,SAAS,EAAE,OAAO,CAAA;IAClB,kEAAkE;IAClE,KAAK,EAAE,YAAY,CAAA;IACnB,kEAAkE;IAClE,IAAI,EAAE,YAAY,CAAA;CACnB;AAED,gGAAgG;AAChG,MAAM,WAAW,aAAa;IAC5B,0FAA0F;IAC1F,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,+EAA+E;IAC/E,IAAI,EAAE,MAAM,CAAA;IACZ,6FAA6F;IAC7F,QAAQ,EAAE,YAAY,EAAE,CAAA;IACxB;;;;;;;;;;OAUG;IACH,IAAI,CAAC,EAAE,YAAY,CAAA;IACnB;;;;OAIG;IACH,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB;;;;;;;;;;;;;;OAcG;IACH,UAAU,CAAC,EAAE,eAAe,CAAA;IAC5B;;;;;OAKG;IACH,OAAO,EAAE,WAAW,EAAE,CAAA;IACtB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,IAAI,CAAA;IACnB;;;;;;;OAOG;IACH,aAAa,CAAC,EAAE,oBAAoB,EAAE,CAAA;IACtC;;;;;;;;;OASG;IACH,WAAW,CAAC,EAAE,gBAAgB,CAAA;IAC9B;;;;;;;OAOG;IACH,iBAAiB,CAAC,EAAE,sBAAsB,CAAA;CAC3C;AAED,sDAAsD;AACtD,eAAO,MAAM,mBAAmB,KAAK,CAAA;AAErC,sDAAsD;AACtD,eAAO,MAAM,mBAAmB,IAAI,CAAA;AAEpC;;;GAGG;AACH,eAAO,MAAM,kBAAkB,IAAI,CAAA;AAEnC,sFAAsF;AACtF,eAAO,MAAM,kBAAkB,KAAK,CAAA;AAEpC,yFAAyF;AACzF,eAAO,MAAM,qBAAqB,MAAM,CAAA;AAUxC,uDAAuD;AACvD,eAAO,MAAM,oBAAoB,IAAI,CAAA;AAErC,iDAAiD;AACjD,eAAO,MAAM,uBAAuB,IAAI,CAAA;AAExC,gEAAgE;AAChE,eAAO,MAAM,oBAAoB,KAAK,CAAA;AAEtC,wFAAwF;AACxF,eAAO,MAAM,qBAAqB,MAAM,CAAA;AAExC,kFAAkF;AAClF,eAAO,MAAM,oBAAoB,MAAM,CAAA;AAEvC;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,MAAM,CAAA;AAK5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,oBAAoB,QAAO,MAy6BvC,CAAA;AAyFD;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,EAAE,CAwDnE;AA2KD;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAKnE;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAG5D;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAGhE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAMzE;AAkDD;;;;;;;;;;GAUG;AACH,MAAM,WAAW,eAAe;IAC9B,+EAA+E;IAC/E,IAAI,EAAE,MAAM,CAAA;IACZ,mEAAmE;IACnE,IAAI,EAAE,MAAM,CAAA;IACZ,4FAA4F;IAC5F,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,4FAA4F;IAC5F,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;CACxB;AAED,2DAA2D;AAC3D,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,QAAQ,CAAC,EAAE,SAAS,eAAe,EAAE,CAAA;IACrC;;;;;OAKG;IACH,sBAAsB,CAAC,EAAE,OAAO,CAAA;IAChC;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAClC;AA4SD;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,MAAM,EACZ,aAAa,GAAE,SAAS,MAAM,EAAO,GACpC,OAAO,CAcT;AAipBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgHG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,SAAS,aAAa,EAAE,EAC/B,MAAM,EAAE,MAAM,EACd,eAAe,GAAE,SAAS,MAAM,EAAO,EACvC,WAAW,GAAE,SAAS,MAAM,EAAO,EACnC,MAAM,GAAE,cAAmB,GAC1B,MAAM,GAAG,IAAI,CAocf;AAaD;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAG9D;AAED,iFAAiF;AACjF,eAAO,MAAM,oBAAoB,8BAA8B,CAAA;AAwG/D,oGAAoG;AACpG,MAAM,WAAW,qBAAqB;IACpC,0BAA0B;IAC1B,OAAO,EAAE,MAAM,CAAA;IACf,4EAA4E;IAC5E,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CACtB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,qBAAqB,CAAC,IAAI,EAAE;IAChD,OAAO,EAAE,MAAM,CAAA;IACf,GAAG,EAAE,MAAM,CAAA;IACX,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;CAC5C,GAAG,OAAO,CAAC,qBAAqB,CAAC,CA0BjC"}