@unotest/protocol 0.24.0 → 0.26.0

package/CHANGELOG.md

@@ -1,5 +1,337 @@
 # Changelog
 
+## [0.26.0] - 2026-08-30
+
+### Minor Changes
+
+- 3eede7c: The viewer can now be hosted: it shows which test bundle an environment
+  is running, and lets you switch it.
+
+  This is the other half of `bundle push`. Nothing changes for a local
+  viewer — everything here appears only when something is hosting it.
+
+  - **The artifact root and the project root are now genuinely separate.**
+    The viewer already took `UNOTEST_ARTIFACTS_ROOT` for the run queue;
+    run discovery, the run index, snapshots, log capture and the viewer's
+    own lock file now honour it too. Locally the two are the same directory
+    and nothing moves. Where they differ — sources in a disposable copy of a
+    bundle, history in the environment beside it — the history is no longer
+    read out of (or written into) the sources.
+  - **Bundle badge in the status bar.** `main@1a2b3c4`, or `wip` for a
+    bundle packed from an uncommitted tree, with the author, the pinned
+    `@unotest/web` and who switched the environment last. Clicking it lists
+    the bundles pushed to this environment and switches to one — that runs
+    as a maintenance ticket on the host, so it waits for the environment to
+    be free instead of pulling the code out from under a running suite.
+  - **Runs remember their bundle.** `manifest.json` and `GET /api/runs`
+    carry `bundleId` (from `UNOTEST_BUNDLE_ID`, set by the host); the runs
+    list marks the ones that ran on another bundle, so "was this red run
+    even the code I am looking at?" has an answer.
+  - **The contract is a file, not a mode.** `@unotest/protocol` gains
+    `WorkspaceFile` — the host writes `unotest/.workspace.json` beside the
+    artifacts and the viewer reads it, the same way the guard's session
+    header narrows the UI. No file, no bundle UI; the viewer never learns
+    what a box is. Values of environment variables and secrets never appear
+    in it — only their names.
+  - **Queue tickets can name a bundle.** `QueueTicket.source.bundleId` is
+    recorded when a run is queued, so a run executes the code it was
+    ordered with even if the environment moved on while it waited.
+
+- 6d1c612: `npx @unotest/web bundle push` — send your suite to a box, instead of
+  giving a box access to your repository.
+
+  ```sh
+  npx @unotest/web bundle push --box https://tests.example.com
+  ```
+
+  It packs `unotest/`, `unotest.config`, `package.json` and its lockfile
+  into one archive and uploads it. That is the whole channel: a box holds
+  no deploy key and no token for anybody's code and never pulls anything,
+  so nothing is on it that was not pushed to it. (There is no path-scoped
+  git credential anywhere — a key that can fetch `unotest/` can fetch the
+  product source next to it, which is why this direction is the only one
+  we offer.)
+
+  - **Uncommitted work travels.** The manifest records `dirty: true` and
+    the bundle shows up as _wip_, so pushing a fix you have not committed
+    yet is a normal loop, not a release step.
+  - **What would fail on the box is refused here.** A scenario that reads a
+    file outside `unotest/` (`MODULE_NOT_FOUND` on the box, hours later, on
+    a run nobody is watching), a missing lockfile (`npm ci` will not run
+    without one), no `@unotest/web` in the dependencies, a symlink. Each
+    problem names the file, the line and the fix.
+  - **Secrets do not travel.** `unotest/.env*` and `.secrets*` are excluded
+    even if committed: environment values belong to the environment and are
+    injected over the bundle when it runs.
+  - **In a git project, git decides what belongs.** The file list comes from
+    `git ls-files --cached --others --exclude-standard`, so whatever your
+    `.gitignore` keeps out — generated databases, recordings, `.runs` —
+    stays out. Content is read from the working tree, not the index.
+  - **The id is the content.** `bundleId` is a hash of the packed files, not
+    a commit sha (a dirty tree's sha is not unique), so re-pushing an
+    unchanged suite is an instant no-op and two people packing the same tree
+    get the same bundle.
+  - `--dry-run` packs and checks without uploading, `--out <file>` keeps the
+    archive (plain `tar.gz` — `tar -tzf` shows what is inside), `--json`
+    prints `{ bundleId, status }` for a CI job that runs it afterwards.
+  - `UNOTEST_BOX_URL` / `UNOTEST_BOX_TOKEN` supply the address and the
+    token, which a CI job usually takes from its secret store. Tokens are
+    issued per project on the box.
+
+- dbfa36f: Your CI can now ask a box to run the suite it just pushed, and a box can
+  report the result back to GitHub.
+
+  ```sh
+  npx @unotest/web bundle push --run --env test --collection smoke
+  ```
+
+  `--run` sends the second half of the CI recipe: upload the bundle, then
+  order a run of it. Two requests rather than one flag on the upload,
+  because a bundle is _content_ — pushing an identical tree twice is normal
+  and answers `exists` — while "run it" is an event. The same split is what
+  lets a deploy script run a bundle somebody pushed hours ago.
+
+  - **The box answers as soon as the runs are queued** (202) with their run
+    ids. A suite takes minutes to hours; an HTTP request held open for that
+    long is a timeout in somebody's proxy, not a result. The ids are real
+    from the moment you get them, so a CI log can print a link into the
+    viewer straight away.
+  - **`--env <name>` is required with `--run`.** Which environments a box
+    has is the operator's decision, and guessing one would be guessing
+    which system gets tested.
+  - **Without `--collection`, the box runs what that environment normally
+    runs** — the collections its `schedules` name. Naming them explicitly is
+    the deploy-check case; leaving it out is the "same as every night" case.
+  - **`--pr <number>` coalesces.** A newer push of the same pull request
+    withdraws its older runs that are still _waiting_; a run that already
+    started is never killed. Three pushes in five minutes cost one suite.
+    `--json` reports how many were withdrawn, so "my run vanished" has an
+    answer in the log of the run that replaced it.
+  - **Refusals are typed and say what to do**: no such environment, an
+    environment belonging to another project, a bundle the box no longer
+    holds, nothing to run.
+
+  On a hosted viewer, the queue panel now names the change each machine
+  ticket belongs to (`PR #412@1a2b3c4`) instead of a row of identical "ci"
+  entries, and the history gained a **this bundle only** filter for the
+  moment you are judging the bundle in front of you rather than the last
+  month of runs.
+
+  Nothing changes for a local `npx @unotest/web viewer`: there are no
+  bundles there, so neither the badge nor the filter appears.
+
+- c43aa00: Runs of one project now take turns instead of colliding.
+
+  Until now nothing coordinated them: the viewer refused a second run with
+  HTTP 409, and that was the whole defence — a `npx @unotest/web e2e` in a
+  terminal, an agent's `run_test` and a scheduled suite would all start on
+  top of each other, driving the same browser and the same seeded database
+  at the same time. The 409 protected the UI, not the machine.
+
+  - **A filesystem queue**, in `unotest/.queue<target>[.<env>]/` beside the
+    runs root it belongs to. A run writes a ticket, waits until it is at
+    the head, takes a slot, runs, and gives the slot back. There is no
+    daemon: whoever holds the slot executes the run itself, so nothing new
+    has to be installed, started or kept alive. Only `open("wx")`, rename,
+    unlink and mtime — no `flock`, which lies on network and container
+    filesystems. A crashed producer is reaped by whoever comes next.
+  - **Every producer is in it**: the CLI (`e2e`, `collection`, `author`),
+    the viewer's Run button, and the MCP `run_test` (which spawns the CLI).
+    A collection is ONE run — its `workers` still run in parallel inside
+    it, because a child process carries its parent's lease and skips the
+    queue.
+  - **The viewer shows the queue**: the Active panel lists what is waiting,
+    including tickets a terminal or an agent wrote, with a button to take
+    any of them back out. `GET /api/queue`, `DELETE /api/queue/:ticket`,
+    and a `queue:changed` websocket message.
+  - **Config**: `queue.concurrency` (default 1) and `queue.enabled`
+    (default true) in `unotest.config`. Both the CLI and the viewer read
+    the same file, so they cannot disagree about how many slots exist.
+  - **Escape hatches**: `UNOTEST_NO_QUEUE=1` runs without queueing;
+    Ctrl-C while waiting gives up your place in line and runs nothing.
+  - **For boxes**: `UNOTEST_QUEUE_GLOBAL_DIR` + `UNOTEST_QUEUE_GLOBAL_SLOTS`
+    add a host-wide budget several environments share (a collection weighs
+    its worker count), and `UNOTEST_ARTIFACTS_ROOT` puts `.runs` / `.queue`
+    somewhere other than the directory the tests live in — so the history
+    outlives a throwaway copy of the tests.
+
+  ### Migration notes
+
+  **`POST /api/run` no longer answers 409.** Ordering a run while another
+  one is active used to fail with `ActiveRunConflictError` (HTTP 409); it
+  now succeeds and the run waits. The response changed shape with it:
+
+  ```diff
+  - { runId, kind, ref, pid, startedAt }
+  + { runId, kind, ref, status: "queued" | "running", ticket, acceptedAt }
+  ```
+
+  `runId` is still final and immediately usable — open the tab on it as
+  before — but the run may not have started yet, and `pid` is not known at
+  that point. `POST /api/runs/:runId/abort` covers both states: it
+  withdraws a waiting ticket or SIGTERMs a running child.
+
+  Anything that treated 409 as "busy, try later" should now simply order
+  the run. Anything that relied on "only one run can exist" should read
+  `GET /api/queue`. To keep the old immediate-start behaviour (without the
+  protection), set `queue.enabled: false`.
+
+- 8ec4177: Scheduled runs: declare what should run on its own, next to the tests it
+  runs.
+
+  ```js
+  // unotest.config.mjs
+  export default {
+    schedules: [
+      { collection: "smoke", cron: "0 * * * *" },
+      { collection: "nightly", cron: "0 3 * * *", prepare: "node seed.mjs" },
+    ],
+  };
+  ```
+
+  - **`schedules`** — a new config leaf: collection + cron, plus an
+    optional `env` (which environment the run happens in) and `prepare` (a
+    command run before the suite). Versioned with the tests, so "what is
+    supposed to run nightly" is in the repo instead of on a machine nobody
+    can see.
+  - **`npx @unotest/web schedules`** prints what is declared; `--json` is
+    the machine shape a scheduler reads back. Each entry also carries the
+    collection's `workers` resolved from its yaml manifest, so an executor
+    can weigh the run without parsing yaml itself.
+  - **`npx @unotest/web collection <name> --scheduled`** runs a collection
+    the way its schedule does: in the entry's `env` (unless you set one)
+    and with its `prepare` command first, inside the same run slot
+    (preparing touches the target, which is exactly what the run queue
+    serialises). A failed prepare exits **94**, not 1 — "the environment
+    was not prepared, nothing was tested" is a different event from "the
+    suite is red", and alerting has to tell them apart. A collection
+    listed in `schedules` more than once needs `--scheduled=<index>`
+    (zero-based) — guessing which entry's prepare to run is refused.
+
+  **Nothing in this package ticks.** `schedules` is data: no cron parser,
+  no timers, no background runs. Cron is executed by whatever hosts your
+  runs — your CI (`on: schedule` + `unotest-web collection`), or a box. A
+  clone of a repo that declares schedules therefore never starts running
+  suites by itself; `unotest-web schedules` says so out loud instead of
+  implying a timer that does not exist.
+
+## [0.25.0] - 2026-08-29
+
+### Minor Changes
+
+- 70f2e11: Judge: provider edge cases, a startup preflight, and logs.
+
+  **Vertex `GOOGLE_CLOUD_LOCATION=global` could not work.** The endpoint was
+  built as `https://<location>-aiplatform.googleapis.com`, so `global` asked
+  `global-aiplatform.googleapis.com` — not a Vertex host. Google's edge
+  answered 404 with an HTML page, which arrived as "model not found". The
+  global endpoint has no region prefix; it is now special-cased. `global` is
+  the default in Google's own docs, so this was the first thing a Vertex user
+  hit. A model id containing a slash
+  (`publishers/anthropic/models/claude-haiku-4-5`) is now passed through
+  instead of being forced under `publishers/google`, and a pasted
+  `models/gemini-2.5-flash` no longer doubles the prefix on the Gemini API.
+
+  **Backend replies are classified instead of lumped together.**
+
+  - `401`/`403` → `config` with the variable to fix (`OPENAI_API_KEY`, ADC,
+    an expired `UNOTEST_JUDGE_ACCESS_TOKEN`), no longer indistinguishable
+    from a model fault.
+  - `429` and `5xx` → retried transparently with a short backoff that
+    honours `Retry-After`. A single rate limit used to kill a whole scenario.
+    The retry policy is a decorator over `JudgeProvider`, not a loop inside
+    the HTTP helper, so it covers every provider — `claude` spawns a process
+    and therefore had no re-send at all. A `claude` usage limit is
+    deliberately still reported rather than retried: the window is seconds,
+    the limit is not.
+  - A non-JSON error body says the endpoint is wrong rather than quoting an
+    HTML page back as the backend's opinion of the model. The body is kept
+    for `debug` logging.
+  - OpenAI `finish_reason: length` and Anthropic `stop_reason: max_tokens`
+    are named as token-limit truncation instead of surfacing as "did not
+    reply with the requested JSON verdict".
+  - The verdict parser accepts `"PASS"` and a JSON object embedded in prose —
+    providers without a JSON mode do both.
+
+  **`UNOTEST_JUDGE_VOTE=N` no longer fails on one bad ballot.** The N calls
+  ran under `Promise.all`, so voting — the reliability feature — tripled the
+  chance that one transient error killed the request. Errored ballots are now
+  dropped as long as a majority of the N calls still voted; a tie among the
+  survivors re-raises the failure rather than picking a side.
+
+  **The service checks its credentials before it says "listening".** Each
+  provider exposes a free probe (an ADC token exchange, `GET /models`,
+  `claude --version`) — no model call, no cost. A failing probe prints the
+  reason and exits non-zero (`UNOTEST_JUDGE_SKIP_PREFLIGHT=1` waives it), and
+  `npx @unotest/judge --check` runs just the probe for start scripts.
+  `GET /health` reports the same thing instead of an unconditional
+  `{"ok":true}`: `503` + `{"ok":false,"code":"config","error":"..."}`, cached
+  for a few seconds. The waiver covers the startup gate only — a service
+  started under it still answers `/health` from a real probe, and `--check`
+  still answers honestly, because the operator who reaches for the flag is
+  precisely the one whose credentials are dead. A static
+  `UNOTEST_JUDGE_ACCESS_TOKEN` is validated too, against Google's free
+  `tokeninfo`: those tokens live about an hour and refresh themselves never,
+  so "valid at startup" is a different question from "valid now".
+
+  ADC that expires on a daily reauth policy is a normal morning state, not a
+  one-off misconfiguration — it should not cost a five-minute run to
+  discover.
+
+  **New: `UNOTEST_JUDGE_LOG_LEVEL`** (falls back to the `UNOTEST_LOG_LEVEL`
+  `@unotest/web` already reads). At the default `info`, one line per judged
+  request — verdict, attempts, model, latency — with errors on stderr; a run
+  of 21 assertions with `VOTE=3` is 63 billed model calls that previously
+  left no trace. At `debug`, per call: the effective prompt (rubric
+  **including** any `UNOTEST_JUDGE_PREAMBLE`), each ballot with its
+  reasoning, and the raw provider reply. **The judged text is application
+  content** — debug writes it to stdout verbatim, which is why it is opt-in
+  and never the default.
+
+  An oversized request body now returns `413` with a reason; the socket used
+  to be destroyed while the client was still writing, so the client saw
+  `socket hang up`.
+
+  **`@unotest/web`:** the `judge:verdict` run artifact records `preamble`
+  beside `rubric` when one is set. The model saw the concatenation, but only
+  the split says which half came from the scenario and which from the
+  environment — without it, "a red step is explainable without a re-run" held
+  only for whoever also knew the env file. A judge request that outlives
+  `UNOTEST_JUDGE_TIMEOUT_MS` now says so, and names the service-side
+  `UNOTEST_JUDGE_CALL_TIMEOUT_MS` it may be racing.
+
+  The Claude CLI provider also stopped leaking a timer: the per-call budget
+  is now our own timer, cleared on every exit path. `child_process.spawn`'s
+  `timeout` option does not clear itself when the spawn fails, so a missing
+  binary held the event loop for the whole budget — 15s for a `--version`
+  probe, 120s for a verdict.
+
+  **Breaking (0.x minor):** `@unotest/judge` no longer exports `ExecFileFn` /
+  `ExecFileResult`; the Claude CLI provider takes `runImpl: RunProcess`
+  instead of `execImpl`, because the prompt moved from `argv` to stdin — a
+  long judged text used to overflow `ARG_MAX` and fail as a bare `E2BIG`.
+
+- adb9d72: Viewer: a pinned Home tab, a multi-row tab strip, and live tiles on the
+  overview field.
+
+  - **Home tab.** The project-health overview used to render only when no
+    tab was open, so it disappeared exactly while you were working. It is
+    now a pinned first tab: always present, never closable, and what
+    "Close All" leaves you on.
+  - **Multi-row tabs.** The strip wraps instead of scrolling sideways —
+    every open tab is visible at once, up to three rows, then it scrolls.
+    Tabs are pills now: the active one is filled like a selected tree row,
+    inactive ones are plain text until hovered. Middle-click closes a tab,
+    the `⋮` button opens the same actions as a right-click, and the strip
+    is a proper `tablist` for screen readers.
+  - **Live tiles.** A scenario that is running right now breathes on the
+    overview field — the tile fades in and out under a warm ring (a still
+    ring when paused, since nothing is moving). Status colour, tile order
+    and the counters/filters stay exactly as they were until the run
+    finishes.
+
+  `@unotest/protocol` gains the `overview` tab kind in the `TabKind` union.
+
 ## [0.24.0] - 2026-08-26
 
 ### Minor Changes

package/README.md

@@ -28,3 +28,8 @@ that needs an environment lives in the consumer package — not here.
   written by runners under `unotest/.runs/<runId>/`, read by the viewer.
 - `WsMessage` — the typed websocket event protocol from viewer-server
   to viewer-web.
+- `QueueTicket` / `IRunQueue` — the run queue's on-disk ticket format,
+  its directory layout (`unotest/.queue<target>[.<env>]/`) and the
+  engine contract every producer depends on. The implementation is
+  `FsRunQueue` in `@unotest/core` (it needs a filesystem; this package
+  does not).

package/dist/index.d.ts

@@ -26,6 +26,8 @@ type AppServerEvent =
  *  is ordinary dev-server output. */
 declare function parseAppServerEvent(line: string): AppServerEvent | null;
 
+declare function isRecord(v: unknown): v is Record<string, unknown>;
+
 /** User-facing project directory containing scenarios + helpers + collections. */
 declare const UNOTEST_DIR = "unotest";
 /** Subdir under `unotest/` for `.test.js` scenarios. */
@@ -136,6 +138,22 @@ declare function secretsFileFor(suffix: string, envName?: string): string;
  *  environment reads just `[unotest/.env]`. */
 declare function envLayerFilesFor(suffix: string, envName?: string): string[];
 declare function secretsLayerFilesFor(suffix: string, envName?: string): string[];
+/** Absolute root the `unotest/` ARTIFACT tree (`.runs`, `.queue`) hangs
+ *  off, when it is not the directory the sources live in.
+ *
+ *  Two roots exist because they have different lifetimes. On a box the
+ *  sources are a disposable unpacked copy of a test bundle — replaced
+ *  whenever a newer one is pushed, garbage-collected when it is not the
+ *  active one; the artifacts are the history of what ran, and must
+ *  outlive every copy. Keeping `.runs` / `.queue` in the environment's
+ *  own directory is what lets the sources be swept without taking the
+ *  history with them. Unset (every npm user, and every local run) = the
+ *  project root, exactly as before. */
+declare const ARTIFACTS_ROOT_ENV = "UNOTEST_ARTIFACTS_ROOT";
+/** Resolve the artifact root from a process-env-like record, falling
+ *  back to the source root. Blank is treated as unset — an exported but
+ *  empty variable must not relocate anything. */
+declare function artifactsRootFrom(env: Record<string, string | undefined>, projectRoot: string): string;
 /** Read an environment name from a process-env-like record (`UNOTEST_ENV`),
  *  normalising empty/blank to `undefined` (= base only). */
 declare function activeEnvName(env: Record<string, string | undefined>): string | undefined;
@@ -426,7 +444,15 @@ interface ScreenshotEvent extends RunArtifactBase {
  *  at emit time, like unbound `screenshot` events. */
 interface JudgeVerdictEvent extends RunArtifactBase {
     kind: "judge:verdict";
+    /** The scenario's own rubric, as written in the test. */
     rubric: string;
+    /** Project-wide judging context prepended to every rubric
+     *  (UNOTEST_JUDGE_PREAMBLE), when one is set. Recorded next to the rubric
+     *  rather than glued to it: what the model saw is the concatenation, but
+     *  only this split says which half came from the scenario and which from
+     *  the environment. Absent on runs with no preamble (and on runs recorded
+     *  before 0.25.0). */
+    preamble?: string;
     /** The judged text (the resolved element's rendered text). */
     text: string;
     verdict: "pass" | "fail";
@@ -676,6 +702,11 @@ interface RunMeta {
      *  collection-runs themselves. Populated by the writer from the
      *  child's `manifest.json`. */
     parentRunId?: string;
+    /** Which test bundle produced this run, from its manifest. Absent for
+     *  every local run; on a box it is what tells two runs of the same
+     *  scenario apart when the environment moved to another bundle between
+     *  them. */
+    bundleId?: string;
 }
 
 /** Bumped when a line's shape changes incompatibly. A file whose header
@@ -736,6 +767,536 @@ declare function scenarioIndexFileName(ref: string): string;
 /** Inverse of `scenarioIndexFileName`. */
 declare function scenarioRefFromFileName(fileName: string): string | null;
 
+/** Run endpoint, relative to the box origin:
+ *  `POST <origin>/api/box/ci/run` with `Authorization: Bearer <token>` —
+ *  the same project token that uploaded the bundle. */
+declare const CI_RUN_PATH = "/api/box/ci/run";
+/** Where a ticket came from, when it came from a machine.
+ *
+ *  `api` is the honest answer for `POST /ci/run`: the caller is somebody's
+ *  CI job holding a project token, and which CI product it is is not
+ *  something the box can know or needs to. `github`/`gitlab` are set only
+ *  when the box itself received (and verified) a webhook, which is when it
+ *  also has somewhere to report a status back to. */
+type CiProviderId = "github" | "gitlab" | "api";
+/** What a CI job asks for. The bundle is named by id — the box does not
+ *  guess "the newest one", because the point of the pair upload+run is
+ *  that a job runs exactly the tree it just packed. */
+interface CiRunRequest {
+    bundleId: string;
+    /** Environment name on the box (`test`, `staging`). Which environments
+     *  exist is the operator's decision, so the name is spelled out rather
+     *  than derived. */
+    environment: string;
+    /** Collections to run. Absent = whatever this bundle's `schedules`
+     *  name for this environment — "run what this environment normally
+     *  runs", which is what a deploy check wants and what keeps the CI
+     *  recipe from repeating the suite's own configuration. */
+    collections?: string[];
+    /** Provenance for the queue badges and for coalescing: which pull
+     *  request / branch this run belongs to. Free-form and untrusted — it
+     *  labels, it never authorises. */
+    pr?: number;
+    branch?: string;
+    sha?: string;
+}
+/** One queued run. The ids are generated by the box before anything
+ *  starts, so a CI job can print a link to the viewer immediately. */
+interface CiQueuedRun {
+    runId: string;
+    collection: string;
+}
+interface CiRunAccepted {
+    status: "queued";
+    bundleId: string;
+    environment: string;
+    runs: CiQueuedRun[];
+    /** Waiting tickets of the same branch/PR withdrawn in favour of this
+     *  one. Reported rather than silent: "my run vanished" must have an
+     *  answer in the CI log of the run that replaced it. */
+    superseded?: number;
+}
+/** Why a run request was refused. A code, not a message — the CLI turns
+ *  each into its own advice, and matching on message text is the
+ *  string-match error handling the monorepo forbids. */
+type CiRunErrorCode = 
+/** Missing, unknown or revoked token. */
+"unauthorized"
+/** The token's project does not own that environment. */
+ | "scope-mismatch"
+/** No such environment on this box. */
+ | "unknown-environment"
+/** The box holds no bundle with that id — push it first. */
+ | "unknown-bundle"
+/** Neither the request nor the bundle's `schedules` name a collection
+ *  to run in this environment. */
+ | "no-collections"
+/** Not a readable request. */
+ | "malformed"
+/** The bundle could not be installed on the box. Retryable. */
+ | "storage";
+interface CiRunError {
+    error: {
+        code: CiRunErrorCode;
+        message: string;
+    };
+}
+type CiRunResponse = CiRunAccepted | CiRunError;
+/** Validate a request off the wire. Null for anything we will not act on:
+ *  the box answers `malformed` rather than filling in a default, because
+ *  every default here would be "run something nobody asked for". */
+declare function parseCiRunRequest(value: unknown): CiRunRequest | null;
+/** Parse a box's answer. Null when the body is not one of ours at all —
+ *  a proxy's HTML error page, a captive portal — which the caller reports
+ *  as "that URL is not a box" rather than as a run problem. */
+declare function parseCiRunResponse(value: unknown): CiRunResponse | null;
+/** Structural validation of the CI provenance carried on a queue ticket.
+ *  Shared by the ticket parser and by whoever reads a ticket back. */
+declare function parseCiProvider(value: unknown): CiProviderId | null;
+
+/** Queue root under `unotest/`, mirroring the two axes of `runsDirFor`:
+ *  TARGET (dash) and ENVIRONMENT (dot) — `.queue`, `.queue-mobile`,
+ *  `.queue.staging`. One queue per runs root, always: what serialises
+ *  runs must be scoped exactly like what stores them. */
+declare const QUEUE_SUBDIR = ".queue";
+/** Waiting tickets. The FILE NAME is the queue order (see
+ *  `makeQueueTicketName`) — no index, nothing to rebuild. */
+declare const QUEUE_TICKETS_DIR = "tickets";
+/** Tickets that hold a slot. Visibility only: the slot files are the
+ *  authority, a `running/` entry without one is garbage (GC unlinks it). */
+declare const QUEUE_RUNNING_DIR = "running";
+/** Env-level leases: `slots/slot-<n>`, `n < concurrency`. Created with
+ *  `open("wx")` — the loser of the race gets EEXIST and keeps waiting. */
+declare const QUEUE_SLOTS_DIR = "slots";
+/** Mutex file for the all-or-nothing weight claim in a global pool.
+ *  Short-lived by construction; a stale one is reaped like any lease. */
+declare const QUEUE_MUTEX_FILE = ".mutex";
+/** Set by a lease holder on every child it spawns. A process that sees
+ *  it is already covered by someone's slot and must not queue again —
+ *  this is the "top-level run" boundary (a collection's scenario
+ *  subprocesses). Value: the holder's runId, for diagnostics. */
+declare const QUEUE_LEASE_ENV = "UNOTEST_QUEUE_LEASE";
+/** Escape hatch: `1` runs without touching the queue at all. */
+declare const QUEUE_DISABLED_ENV = "UNOTEST_NO_QUEUE";
+/** Optional host-wide weight pool shared by every environment on the
+ *  box (a shared volume in compose). Unset = no global pool. */
+declare const QUEUE_GLOBAL_DIR_ENV = "UNOTEST_QUEUE_GLOBAL_DIR";
+declare const QUEUE_GLOBAL_SLOTS_ENV = "UNOTEST_QUEUE_GLOBAL_SLOTS";
+/** Bumped when the on-disk ticket shape changes incompatibly. A reader
+ *  that meets a higher version treats the ticket as opaque and waits for
+ *  its owner to reap it rather than guessing. */
+declare const QUEUE_SCHEMA_VERSION = 1;
+/** Queue root under `unotest/` for a target + environment. */
+declare function queueDirFor(suffix: string, envName?: string): string;
+/** True for directory names under `unotest/` that hold a queue for ANY
+ *  target/environment combination. Mirrors `isRunsDirName`. */
+declare function isQueueDirName(name: string): boolean;
+/** Artifact-root-relative queue root: `unotest/.queue<suffix>[.<env>]`. */
+declare function projectQueueRoot(suffix?: string, envName?: string): string;
+/** Ordered highest-priority-first. `maintenance` takes every slot of its
+ *  environment (branch switch, `npm ci`); `interactive` is a human
+ *  waiting in front of a viewer / terminal / agent; `ci` and `schedule`
+ *  are machines that can wait. */
+type QueuePriority = "maintenance" | "interactive" | "ci" | "schedule";
+/** Every priority, highest first. */
+declare const QUEUE_PRIORITIES: readonly QueuePriority[];
+declare function queuePriorityRank(priority: QueuePriority): number;
+declare function queuePriorityFromRank(rank: number): QueuePriority | null;
+/** What a ticket asks the queue to run. `maintenance` is not a
+ *  `RunKind` — it produces no run artifacts, it takes the environment
+ *  exclusively to mutate it (stage 3: unpacking a new test bundle,
+ *  reinstalling its dependencies). Declared here so the engine's
+ *  exclusivity rule is written once, not retrofitted around a later
+ *  producer. */
+type QueueTicketKind = RunKind | "maintenance";
+/** Who put the ticket in. Diagnostics only — the engine never branches
+ *  on it; the UI shows it so "why is my run waiting" has an answer. */
+type QueueProducerKind = "cli" | "viewer" | "mcp" | "schedule" | "ci";
+interface QueueProducer {
+    kind: QueueProducerKind;
+    /** Pid of the process that will EXECUTE the run — the ticket holder
+     *  runs it itself, there is no dispatcher. */
+    pid: number;
+    /** `os.hostname()`. The queue is single-host by design (see the plan's
+     *  non-goals); this is here to make a cross-host mistake visible
+     *  instead of silent. */
+    host: string;
+}
+/** WHERE the tests come from, when that is not simply "the working
+ *  directory". A box runs uploaded bundles: the ticket records which one
+ *  AT THE MOMENT IT WAS QUEUED, so a run executes the code that was asked
+ *  for even if the environment was pointed at another bundle while the
+ *  ticket waited.
+ *
+ *  Deliberately only the id: branch, commit and author are properties of
+ *  the bundle, and the queue is not where anybody should read them from.
+ *  Nothing about a project or a customer — see the plan's "the project
+ *  axis is a box-layer concept". */
+interface QueueTicketSource {
+    bundleId: string;
+}
+/** WHY the run was ordered, when a machine ordered it. Labels only: the
+ *  queue never branches on any of this, the viewer prints it ("PR #412",
+ *  "release-3.2") so a waiting ticket nobody recognises has an
+ *  explanation, and the box uses it to withdraw the tickets a newer push
+ *  to the same branch made pointless.
+ *
+ *  Nothing here is trusted. `checkId` is opaque to everything but the
+ *  provider that issued it — the queue carries it so a finished run can be
+ *  reported back to the right check without a second index. */
+interface QueueTicketCi {
+    provider: CiProviderId;
+    /** Repository the change belongs to, as the provider spells it. */
+    repo?: string;
+    branch?: string;
+    sha?: string;
+    /** Pull / merge request number. */
+    pr?: number;
+    /** The provider-side status this run reports into. */
+    checkId?: string;
+}
+/** One line naming the change a ticket belongs to: `PR #412`,
+ *  `main@1a2b3c4`, or the provider when it carries neither. Lives here so
+ *  the viewer's queue panel, the box's log and a CI recipe cannot each
+ *  invent their own spelling of the same fact. */
+declare function describeTicketCi(ci: QueueTicketCi): string;
+/** What is ordered, and by whom. */
+interface QueueTicket {
+    schemaVersion: number;
+    /** Generated by the PRODUCER before enqueueing, so it can return the
+     *  id (and open the tab) without waiting for the run to start. */
+    runId: string;
+    kind: QueueTicketKind;
+    /** WHAT to run: the scenario / collection name, exactly as in
+     *  `RunRequest` — and the `ref` the produced run carries in `RunMeta`.
+     *  Not a git ref. */
+    ref: string;
+    /** Environment name; absent = base. Redundant with the queue
+     *  directory, kept for readable diagnostics. */
+    env?: string;
+    priority: QueuePriority;
+    /** Cost in a global pool: a collection weighs its `workers`, a single
+     *  scenario weighs 1. Clamped to the pool size by the engine — a
+     *  collection with more workers than the pool has slots must still be
+     *  able to run. Ignored when no global pool is configured. */
+    weight: number;
+    producer: QueueProducer;
+    /** Absent on every local run: the sources are the working directory. */
+    source?: QueueTicketSource;
+    /** Absent unless a machine with an opinion about a commit ordered this
+     *  run. Additive: a reader that does not know the field ignores it. */
+    ci?: QueueTicketCi;
+    createdAt: number;
+}
+/** `<rank>-<base36 ms>-<rand>.json`. The name IS the queue order: rank
+ *  first, then the enqueue timestamp, then a random tiebreak for two
+ *  producers landing in the same millisecond.
+ *
+ *  Clock skew between producers is a documented non-problem: every
+ *  producer of one queue runs on one host (cross-host queues are a
+ *  non-goal), so they read the same clock. */
+declare function makeQueueTicketName(priority: QueuePriority, createdAt: number, random: string): string;
+interface ParsedTicketName {
+    rank: number;
+    priority: QueuePriority;
+    createdAt: number;
+    random: string;
+}
+/** Parse a ticket file name, or null when the entry is not one — a
+ *  half-written temp file, an editor's backup, a quarantined ticket.
+ *  Callers MUST skip nulls rather than guess: an unparseable name has no
+ *  position, and inventing one reorders the queue. */
+declare function parseQueueTicketName(name: string): ParsedTicketName | null;
+/** Total order over ticket names — priority, then FIFO. Plain string
+ *  comparison would do while every base36 timestamp is the same width
+ *  (it is, until 2059), but a width change must reorder rather than
+ *  silently sort `100` before `99`. */
+declare function compareQueueTicketNames(a: string, b: string): number;
+/** Structural validation of a ticket read off disk. Returns null for
+ *  anything we cannot trust — a torn write, a future schema version, a
+ *  file some other tool dropped in the directory. Null is not an error
+ *  for the caller: an unreadable ticket is treated as garbage and reaped
+ *  on its own staleness timer, never executed. */
+declare function parseQueueTicket(value: unknown): QueueTicket | null;
+/** What a producer asks for. Only `weight` is optional; the engine fills
+ *  the rest of the ticket (schema version, timestamp). */
+interface EnqueueRunInput {
+    runId: string;
+    kind: QueueTicketKind;
+    ref: string;
+    env?: string;
+    priority: QueuePriority;
+    weight?: number;
+    producer: QueueProducer;
+    source?: QueueTicketSource;
+    ci?: QueueTicketCi;
+}
+/** A ticket that holds a slot. Released exactly once, by the holder. */
+interface RunQueueLease {
+    readonly runId: string;
+    readonly ticketName: string;
+    /** Environment the holder MUST pass to the process that executes the
+     *  run, so its children (a collection's scenario subprocesses) bypass
+     *  the queue instead of deadlocking behind their own parent. */
+    readonly env: Readonly<Record<string, string>>;
+    release(): Promise<void>;
+    /** Same, from a process that is about to exit and cannot await —
+     *  a signal handler. Without it a Ctrl-C'd run would hold its slot
+     *  until the staleness timer expires and block the next run for a
+     *  minute for no reason. */
+    releaseSync(): void;
+}
+interface RunQueueTicketHandle {
+    /** File name — also this ticket's identity in `DELETE /api/queue/:ticket`. */
+    readonly name: string;
+    readonly ticket: QueueTicket;
+    /** Wait until this ticket owns a slot. Rejects with
+     *  `QueueTicketLostError` when the ticket is cancelled or reaped while
+     *  waiting, and with `QueueWaitAbortedError` when the caller's signal
+     *  fires (the ticket is withdrawn first, either way). */
+    acquire(opts?: {
+        signal?: AbortSignal;
+    }): Promise<RunQueueLease>;
+    /** Withdraw a still-waiting ticket. Idempotent. */
+    cancel(): Promise<void>;
+}
+interface QueueEntry {
+    name: string;
+    ticket: QueueTicket;
+}
+interface QueuePoolState {
+    total: number;
+    used: number;
+}
+interface QueueSnapshot {
+    /** Ordered exactly as the queue will serve them. */
+    waiting: QueueEntry[];
+    running: QueueEntry[];
+    slots: QueuePoolState;
+    /** Present only when a global pool is configured for this host. */
+    global?: QueuePoolState;
+}
+interface IRunQueue {
+    enqueue(input: EnqueueRunInput): Promise<RunQueueTicketHandle>;
+    snapshot(): Promise<QueueSnapshot>;
+    /** Withdraw a waiting ticket by file name. Returns false when the
+     *  ticket is already gone or already running. */
+    cancel(ticketName: string): Promise<boolean>;
+    /** Reap what died: stale tickets, stale leases, `running/` entries
+     *  with no lease behind them. Every producer runs this on its way
+     *  past, so a queue with any traffic needs no janitor. */
+    sweep(): Promise<void>;
+}
+
+/** Bumped when the manifest shape changes incompatibly. A box that meets
+ *  a higher version refuses the upload with a readable message instead of
+ *  guessing what a field it does not know means. */
+declare const BUNDLE_SCHEMA_VERSION = 1;
+/** The manifest, stored at the root of the archive so a bundle on disk
+ *  describes itself.
+ *
+ *  It is NOT part of the content hash: it carries the `bundleId`, which
+ *  would otherwise have to predict its own hash. Everything the hash
+ *  covers is the suite; everything the manifest adds is provenance. */
+declare const BUNDLE_MANIFEST_FILE = "bundle.json";
+/** Upload endpoint, relative to the box origin:
+ *  `POST <origin>/api/box/bundles/<bundleId>` with the gzipped tar as the
+ *  body and `Authorization: Bearer <token>`.
+ *
+ *  The id is in the PATH rather than derived from the body so the receiver
+ *  can answer "already have it" without reading a single byte of the
+ *  upload — re-pushing an unchanged suite is the common case (a CI job
+ *  runs on every push; most of them change nothing under `unotest/`). */
+declare const BUNDLE_UPLOAD_PATH = "/api/box/bundles";
+/** Box origin (`https://box.example.com`) and the upload token, for
+ *  people and CI jobs that would rather not repeat them on every command
+ *  line. Flags win over both. */
+declare const BOX_URL_ENV = "UNOTEST_BOX_URL";
+declare const BOX_TOKEN_ENV = "UNOTEST_BOX_TOKEN";
+/** Set by a box on every run it starts: which bundle the sources came
+ *  from. The runner stamps it into the run's manifest, so history keeps
+ *  the answer to "which code produced this" after the environment has
+ *  moved on. Never set locally — there is no bundle there. */
+declare const BUNDLE_ID_ENV = "UNOTEST_BUNDLE_ID";
+/** Where the code came from — provenance, never identity. A bundle is
+ *  identified by its CONTENT (see `bundleId`): the sha of a dirty working
+ *  tree is not unique, and two people can push different trees from the
+ *  same commit. */
+interface BundleGitInfo {
+    /** Remote URL with any credential stripped by the packer. Absent when
+     *  the project has no remote. */
+    repo?: string;
+    branch?: string;
+    sha?: string;
+    /** Uncommitted changes at pack time. The viewer labels such a bundle
+     *  "wip" so nobody reads `branch@sha` as "this is what is on the
+     *  branch". */
+    dirty: boolean;
+}
+interface BundleManifest {
+    schemaVersion: number;
+    /** Short HANDLE derived from the full content hash — see
+     *  `computeBundleId` in `@unotest/core`. Stable across repacks of an
+     *  identical tree, which is what makes a re-upload a no-op. Directory
+     *  names, URLs and run manifests carry this. */
+    bundleId: string;
+    /** FULL sha256 of the payload tree — the integrity anchor a box
+     *  verifies whole after unpacking (64 bits of `bundleId` name a
+     *  bundle; 256 bits guarantee it). Optional only because a manifest
+     *  written by a pre-release packer lacks it. */
+    sha256?: string;
+    createdAt: number;
+    /** The `@unotest/web` the bundle pins, read from its own package.json.
+     *  The box installs exactly this (`npm ci`) and checks it against its
+     *  minimum before storing anything: a suite pinned to a version older
+     *  than the box supports is refused at upload, where a human is still
+     *  watching, instead of failing on a nightly run. */
+    webVersion: string;
+    /** Who packed it, for the "who switched the environment" banner.
+     *  `git config user.email`, falling back to the OS user. */
+    author?: string;
+    git?: BundleGitInfo;
+    /** Payload size, excluding this manifest. Diagnostics and limits — a
+     *  box states its cap in these terms. */
+    fileCount: number;
+    byteSize: number;
+}
+/** Structural validation of a manifest read off disk or off the wire.
+ *  Null for anything we cannot trust — a torn write, a newer schema, a
+ *  file that is not a manifest at all. Callers treat null as "this is not
+ *  a bundle", never as "assume defaults": a bundle whose provenance we
+ *  invented would show a branch nobody pushed. */
+declare function parseBundleManifest(value: unknown): BundleManifest | null;
+/** One-line provenance for a UI or a log: `main@1a2b3c4`, `main@1a2b3c4
+ *  (wip)`, or the bundle id when the tree had no git at all. Lives here
+ *  so the CLI, the viewer and the box daemon cannot each invent their own
+ *  spelling of the same fact. */
+declare function describeBundle(manifest: BundleManifest): string;
+/** `created` — the box stored it now; `exists` — same content hash was
+ *  already there and the upload was a no-op. Both are success: a CI job
+ *  that pushes an unchanged suite must not go red. */
+type BundleUploadStatus = "created" | "exists";
+interface BundleUploadOk {
+    status: BundleUploadStatus;
+    bundleId: string;
+}
+/** Why an upload was refused. A code, not a message, because the CLI
+ *  turns each into its own advice — and because matching on message text
+ *  is exactly the string-match error handling the monorepo forbids. */
+type BundleUploadErrorCode = 
+/** Missing, unknown or revoked token. */
+"unauthorized"
+/** Bigger than the box accepts. */
+ | "too-large"
+/** Not a readable bundle: broken gzip/tar, no manifest, bad manifest. */
+ | "malformed"
+/** The content hash of what arrived is not the id it was sent under —
+ *  a truncated upload or a proxy that rewrote the body. */
+ | "id-mismatch"
+/** The bundle pins an `@unotest/web` older than this box supports. */
+ | "min-version"
+/** The token's scope does not match where the bundle says it is from. */
+ | "scope-mismatch"
+/** The box could not store it (disk, permissions). Retryable. */
+ | "storage";
+interface BundleUploadError {
+    error: {
+        code: BundleUploadErrorCode;
+        message: string;
+    };
+}
+type BundleUploadResponse = BundleUploadOk | BundleUploadError;
+/** Parse a box's answer. Null when the body is not one of ours at all —
+ *  a proxy's HTML error page, a captive portal — which the caller reports
+ *  as "that URL is not a box" rather than as a bundle problem. */
+declare function parseBundleUploadResponse(value: unknown): BundleUploadResponse | null;
+
+declare const WORKSPACE_SCHEMA_VERSION = 1;
+/** Written by the host beside the artifacts it manages:
+ *  `<artifactsRoot>/unotest/.workspace.json`. In the artifact tree and
+ *  not in the sources, because the sources are a bundle — immutable,
+ *  shared between environments, and replaced under this very file. */
+declare const WORKSPACE_FILE = ".workspace.json";
+interface WorkspaceBundle {
+    bundleId: string;
+    /** Ready to print: `main@1a2b3c4`, `main@1a2b3c4 (wip)`, or the id. */
+    label: string;
+    branch?: string;
+    sha?: string;
+    /** Packed from a working tree with uncommitted changes. */
+    dirty: boolean;
+    author?: string;
+    createdAt: number;
+    /** `@unotest/web` this bundle pinned — what its runs execute on. */
+    webVersion: string;
+}
+interface WorkspaceFile {
+    schemaVersion: number;
+    /** Human label of what this viewer serves, e.g. `acme/test`. Opaque to
+     *  the viewer: it prints it and never parses it. */
+    workspace: string;
+    /** Environment name — the `.runs.<env>` suffix this viewer reads. */
+    environment: string;
+    /** Whether switching bundles is offered at all. False where what is
+     *  deployed is the point (a release environment follows its branch). */
+    allowSwitch: boolean;
+    /** What the environment runs now. Absent before the first push. */
+    currentBundleId?: string;
+    /** Who pointed it there, and when — the banner on a shared
+     *  environment, where "why did the tests change" needs an answer. */
+    switchedBy?: string;
+    switchedAt?: number;
+    /** Bundles available to switch to, newest first. */
+    bundles: WorkspaceBundle[];
+    /** NAMES of the values the host injects into every run here. Names
+     *  only, always: the values (and every secret among them) belong to the
+     *  host and never travel to a browser. */
+    variables: string[];
+    secrets: string[];
+    /** Where to POST `{ bundleId }` to switch, relative to the page's own
+     *  origin. Absent when switching is not offered. */
+    switchPath?: string;
+}
+/** Null for anything we cannot trust — a torn write, a newer schema, a
+ *  file that is not ours. Null means "no host", i.e. exactly the local
+ *  viewer: the bundle UI stays hidden rather than half-populated. */
+declare function parseWorkspaceFile(value: unknown): WorkspaceFile | null;
+
+/** One scheduled run of one collection. */
+interface ScheduleEntry {
+    /** Collection name — the file stem under `_collections/`. */
+    collection: string;
+    /** Standard 5-field cron expression, interpreted by whoever executes
+     *  the schedule. Opaque to every public package. */
+    cron: string;
+    /** Environment name (`.env.<name>` overlay + `.runs<suffix>.<name>`
+     *  artifact root) the run happens in. Absent = base. */
+    env?: string;
+    /** Shell command run BEFORE the collection, inside the same queue
+     *  slot: seeding a database, resetting a fixture. A failure means the
+     *  environment was not prepared — a different thing from a red suite,
+     *  and reported as such (see `PREPARE_FAILED_EXIT` in `@unotest/web`). */
+    prepare?: string;
+    /** `workers` of the collection's OWN manifest — resolved by
+     *  `unotest-web schedules --json`, never written in `unotest.config`:
+     *  the yaml stays the single authority on parallelism. Carried here so
+     *  an executor can weigh the run's queue ticket (a suite costs its
+     *  worker count in a host-wide pool) without parsing yaml itself.
+     *  Absent when the manifest declares none, or does not exist. */
+    workers?: number;
+}
+/** Structural validation of one entry read from JSON. Null for anything
+ *  we cannot trust — a consumer skips it rather than scheduling a run it
+ *  does not understand. A malformed `workers` is dropped alone (the
+ *  engine's weight then defaults to 1) — losing a weight is recoverable,
+ *  losing a schedule is a suite that silently stops running. */
+declare function parseScheduleEntry(value: unknown): ScheduleEntry | null;
+/** Parse the whole `schedules --json` payload. Null when the text is not
+ *  a JSON array — the caller reports "could not read the schedules"
+ *  rather than silently running nothing. Entries that fail validation
+ *  are dropped individually and counted by the caller. */
+declare function parseSchedulesJson(text: string): ScheduleEntry[] | null;
+
 /** Blob root under the runs root. Leading underscore for the same reason
  *  as `_scenarios`: derived, internal, and can never be mistaken for a
  *  `YYYY` shard directory. */
@@ -837,6 +1398,14 @@ interface RunManifest {
         console: boolean;
         network: boolean;
     };
+    /** Which test bundle produced this run, when the sources came from one
+     *  (`UNOTEST_BUNDLE_ID`, set by a box). Absent for every local run,
+     *  where the sources are simply the working directory.
+     *
+     *  Recorded so history stays readable after the fact: a box runs many
+     *  bundles into one environment, and "which code produced this red
+     *  run" is otherwise unanswerable once the environment moved on. */
+    bundleId?: string;
 }
 
 /** Snapshot file holding entry + every helper source that was loaded. */
@@ -1447,6 +2016,14 @@ interface EnvChangedMessage {
     kind: "env:changed";
     env?: string;
 }
+/** Emitted when the run queue changed — a ticket was added, claimed,
+ *  cancelled or reaped. Carries no payload: producers other than this
+ *  viewer (a terminal, an agent) change the queue too, so the only
+ *  trustworthy answer is the directory itself. Clients refetch
+ *  `/api/queue`, exactly like `fs:bp-changed`. */
+interface QueueChangedMessage {
+    kind: "queue:changed";
+}
 /** A single line of stdout or stderr captured from a runner child the
  *  viewer-server spawned. Logs always carry a `runId` so the browser
  *  attaches them to the right run-pane. */
@@ -1464,11 +2041,17 @@ interface ErrorMessage {
     message: string;
 }
 /** Discriminated union of every WS message the server emits to clients. */
-type WsMessage = FsScenariosChangedMessage | FsHelpersChangedMessage | FsCollectionsChangedMessage | FsBreakpointsChangedMessage | FsRunStartedMessage | FsRunStepMessage | FsCollectionRunStepMessage | FsRunFinishedMessage | EnvChangedMessage | LogLineMessage | ErrorMessage;
+type WsMessage = FsScenariosChangedMessage | FsHelpersChangedMessage | FsCollectionsChangedMessage | FsBreakpointsChangedMessage | FsRunStartedMessage | FsRunStepMessage | FsCollectionRunStepMessage | FsRunFinishedMessage | EnvChangedMessage | QueueChangedMessage | LogLineMessage | ErrorMessage;
 /** All WS message `kind` literals as a union type — useful for handler
  *  registries (`Record<WsMessageKind, Handler>`). */
 type WsMessageKind = WsMessage["kind"];
 
+/** The pinned Overview ("Home") tab — project health, always open and
+ *  never closable. Carries no target: there is exactly one of it, so the
+ *  `kind` alone is its identity. */
+interface OverviewTab {
+    kind: "overview";
+}
 /** Open scenario source (read-only view). Keyed by project-relative path. */
 interface ScenarioTab {
     kind: "scenario";
@@ -1503,7 +2086,7 @@ interface SnapshotTab {
     snapshotId: string;
 }
 /** Discriminated union of every open-tab shape the frontend supports. */
-type TabKind = ScenarioTab | HelperTab | CollectionTab | ScenarioRunTab | CollectionRunTab | SnapshotTab;
+type TabKind = OverviewTab | ScenarioTab | HelperTab | CollectionTab | ScenarioRunTab | CollectionRunTab | SnapshotTab;
 /** All tab `kind` literals — useful for switch-completeness checks. */
 type TabKindName = TabKind["kind"];
 
@@ -1635,6 +2218,17 @@ interface JudgeErrorResponse {
      *  the message says what to run. */
     code?: "unauthorized" | "bad-request" | "provider-error" | "config" | "internal";
 }
+/** `GET /health` — whether the service can actually judge, not merely
+ *  whether it is listening. A judge whose credentials are dead answers
+ *  `ok: false` with the same message (and `code`) a verdict call would
+ *  fail with, so a runner can preflight it instead of spending a scenario
+ *  to find out. */
+interface JudgeHealthResponse {
+    ok: boolean;
+    /** Present when `ok` is false — same taxonomy as JudgeErrorResponse. */
+    code?: JudgeErrorResponse["code"];
+    error?: string;
+}
 declare const JUDGE_ROUTES: {
     readonly judge: "/judge";
     readonly health: "/health";
@@ -1670,6 +2264,14 @@ declare const JUDGE_ENV: {
     /** judge: bind address. */
     readonly host: "UNOTEST_JUDGE_HOST";
     readonly port: "UNOTEST_JUDGE_PORT";
+    /** judge: silent | error | warn | info | debug. Falls back to the
+     *  UNOTEST_LOG_LEVEL @unotest/web already reads, so one variable can
+     *  cover both halves of a run. */
+    readonly logLevel: "UNOTEST_JUDGE_LOG_LEVEL";
+    /** judge: skip the startup credential probe. Escape hatch for a closed
+     *  network where the free probe endpoint is unreachable but the model
+     *  endpoint is not. */
+    readonly skipPreflight: "UNOTEST_JUDGE_SKIP_PREFLIGHT";
 };
 
-export { type AddVariablePlan, type AddVariablePlanInput, type AppPathPickerSpec, type AppServerEvent, type AuthoringRunRequest, BLOBS_DIR, type BreakpointEntry, type BreakpointsFile, COLLECTIONS_SUBDIR, COLLECTION_NAME_FORBIDDEN_RE, COMMANDS_FILE, type CheckSeverity, type CollectionMeta, type CollectionRunArtifact, type CollectionRunFinishedEvent, type CollectionRunRequest, type CollectionRunStartedEvent, type CollectionRunTab, type CollectionScenarioFinishedEvent, type CollectionScenarioStartedEvent, type CollectionTab, DAY_INDEX_FILE, type DbgCommand, type DbgCommandAbort, type DbgCommandClearBp, type DbgCommandContinue, type DbgCommandKind, type DbgCommandPause, type DbgCommandPickerStart, type DbgCommandPickerStop, type DbgCommandProbe, type DbgCommandRecord, type DbgCommandSetBp, type DbgCommandSnapshot, type DbgCommandStep, type DbgCommandWheel, type DebugCapabilities, type DoctorCheck, type DoctorContext, type DslDiagnostic, type DslValidateContext, type DslVocabArg, type DslVocabCategory, type DslVocabEntry, E2E_SUBDIR, ENV_FILE, EXPECT_FAIL_ANNOTATION, type EnvChangedMessage, type EnvFile, type EnvUpdate, type EnvVar, type ErrorMessage, type FailureBundleWrittenEvent, type FsBreakpointsChangedMessage, type FsCollectionRunStepMessage, type FsCollectionsChangedMessage, type FsHelpersChangedMessage, type FsRunFinishedMessage, type FsRunStartedMessage, type FsRunStepMessage, type FsScenariosChangedMessage, HEARTBEAT_FILE, HELPERS_SUBDIR, type HelperMeta, type HelperTab, type HostRequirement, type IDslLanguageService, type ILaunchedProcess, type IProcessLauncher, type IRunnerAdapter, InvalidBlobHashError, JUDGE_ENV, JUDGE_ROUTES, type JudgeErrorResponse, type JudgeRequest, type JudgeVerdict, type JudgeVerdictEvent, LOCK_FILE, LOG_FILE, type LaunchSpec, type LocatorPickedEvent, type LockFile, type LogLineMessage, type Matcher, PICKER_SNAPSHOT_FILE, type PausedEvent, type PickerMode, type ProbeMatch, type ProbePinned, type ProbeResult, type ProbeResultEvent, RUNNER_CONFIG_KEYS, RUNS_SUBDIR, RUNTIME_FILE, RUN_INDEX_SCHEMA_VERSION, RUN_MANIFEST_FILE, RUN_SOURCES_FILE, type RecordedActionKind, type RegexLiteral, type ResumedEvent, type RunArtifact, type RunFinishedEvent, type RunId, type RunIndexEntry, type RunIndexHeader, type RunKind, type RunManifest, type RunMeta, type RunOutcome, type RunRequest, type RunSources, type RunStartedEvent, type RunStatus, RunnerAdapterNotFoundError, RunnerNotConfiguredError, type RuntimeState, type RuntimeStateFile, SCENARIOS_INDEX_DIR, SCENARIOS_LATEST_FILE, SCENARIO_RECENT_WINDOW, SECRETS_FILE, SEGMENT_NAME_FORBIDDEN_RE, SNAPSHOTS_SUBDIR, STDERR_FILE, STDOUT_FILE, STEPS_FILE, type ScenarioAnnotations, type ScenarioLatestEntry, type ScenarioMeta, type ScenarioRunRequest, type ScenarioRunTab, type ScenarioTab, type ScenariosLatest, type ScenariosPayload, type ScreenshotEvent, type SnapshotTab, type StepFailEvent, type StepOkEvent, type StepStartedEvent, TERMINAL_RUNTIME_STATES, TERMINAL_WS_EVENT, type TabKind, type TabKindName, type TerminalClientMessage, type TerminalCloseMessage, type TerminalDataMessage, type TerminalErrorMessage, type TerminalExitMessage, type TerminalKind, type TerminalOutputMessage, type TerminalResizeMessage, type TerminalServerMessage, type TerminalSpawnMessage, type ToolCallEvent, type ToolResultEvent, UNOTEST_DIR, UnplaceableRunIdError, UnsupportedRunKindError, type VariableCategory, type VariableKind, type VariablePlanError, type WheelChangedEvent, type WsMessage, type WsMessageKind, activeEnvName, blobPathFor, blobRelPathFor, blobRelSegmentsFor, blobsRootFor, categorizeVariable, debugDirFor, debuggerFileFor, deleteShadowWarning, envFileFor, envKeys, envLayerFilesFor, envNamesFromDirListing, foldScenarioRun, insertEnvVar, isAnnotationLine, isExternalVarName, isFailingStatus, isRegexLiteral, isRunnerConfigKey, isRunsDirName, isTerminalRuntimeState, makeRunId, parseAppServerEvent, parseEnvContent, parseScenarioAnnotations, planAddVariable, projectRunDirFor, projectRunsRoot, regexLiteral, removeEnvVar, requireRunDirFor, runDirFor, runIdStartedAt, runsDirFor, sanitizeRunIdSegment, scenarioIndexFileName, scenarioRefFromFileName, secretsFileFor, secretsLayerFilesFor, serializeEnvValue, shardDaysDescending, shardDirFor, shardPathForRunId, shardPathForTimestamp, testDirFor, validateCollectionName, validateSegmentName };
+export { ARTIFACTS_ROOT_ENV, type AddVariablePlan, type AddVariablePlanInput, type AppPathPickerSpec, type AppServerEvent, type AuthoringRunRequest, BLOBS_DIR, BOX_TOKEN_ENV, BOX_URL_ENV, BUNDLE_ID_ENV, BUNDLE_MANIFEST_FILE, BUNDLE_SCHEMA_VERSION, BUNDLE_UPLOAD_PATH, type BreakpointEntry, type BreakpointsFile, type BundleGitInfo, type BundleManifest, type BundleUploadError, type BundleUploadErrorCode, type BundleUploadOk, type BundleUploadResponse, type BundleUploadStatus, CI_RUN_PATH, COLLECTIONS_SUBDIR, COLLECTION_NAME_FORBIDDEN_RE, COMMANDS_FILE, type CheckSeverity, type CiProviderId, type CiQueuedRun, type CiRunAccepted, type CiRunError, type CiRunErrorCode, type CiRunRequest, type CiRunResponse, type CollectionMeta, type CollectionRunArtifact, type CollectionRunFinishedEvent, type CollectionRunRequest, type CollectionRunStartedEvent, type CollectionRunTab, type CollectionScenarioFinishedEvent, type CollectionScenarioStartedEvent, type CollectionTab, DAY_INDEX_FILE, type DbgCommand, type DbgCommandAbort, type DbgCommandClearBp, type DbgCommandContinue, type DbgCommandKind, type DbgCommandPause, type DbgCommandPickerStart, type DbgCommandPickerStop, type DbgCommandProbe, type DbgCommandRecord, type DbgCommandSetBp, type DbgCommandSnapshot, type DbgCommandStep, type DbgCommandWheel, type DebugCapabilities, type DoctorCheck, type DoctorContext, type DslDiagnostic, type DslValidateContext, type DslVocabArg, type DslVocabCategory, type DslVocabEntry, E2E_SUBDIR, ENV_FILE, EXPECT_FAIL_ANNOTATION, type EnqueueRunInput, type EnvChangedMessage, type EnvFile, type EnvUpdate, type EnvVar, type ErrorMessage, type FailureBundleWrittenEvent, type FsBreakpointsChangedMessage, type FsCollectionRunStepMessage, type FsCollectionsChangedMessage, type FsHelpersChangedMessage, type FsRunFinishedMessage, type FsRunStartedMessage, type FsRunStepMessage, type FsScenariosChangedMessage, HEARTBEAT_FILE, HELPERS_SUBDIR, type HelperMeta, type HelperTab, type HostRequirement, type IDslLanguageService, type ILaunchedProcess, type IProcessLauncher, type IRunQueue, type IRunnerAdapter, InvalidBlobHashError, JUDGE_ENV, JUDGE_ROUTES, type JudgeErrorResponse, type JudgeHealthResponse, type JudgeRequest, type JudgeVerdict, type JudgeVerdictEvent, LOCK_FILE, LOG_FILE, type LaunchSpec, type LocatorPickedEvent, type LockFile, type LogLineMessage, type Matcher, type OverviewTab, PICKER_SNAPSHOT_FILE, type ParsedTicketName, type PausedEvent, type PickerMode, type ProbeMatch, type ProbePinned, type ProbeResult, type ProbeResultEvent, QUEUE_DISABLED_ENV, QUEUE_GLOBAL_DIR_ENV, QUEUE_GLOBAL_SLOTS_ENV, QUEUE_LEASE_ENV, QUEUE_MUTEX_FILE, QUEUE_PRIORITIES, QUEUE_RUNNING_DIR, QUEUE_SCHEMA_VERSION, QUEUE_SLOTS_DIR, QUEUE_SUBDIR, QUEUE_TICKETS_DIR, type QueueChangedMessage, type QueueEntry, type QueuePoolState, type QueuePriority, type QueueProducer, type QueueProducerKind, type QueueSnapshot, type QueueTicket, type QueueTicketCi, type QueueTicketKind, type QueueTicketSource, RUNNER_CONFIG_KEYS, RUNS_SUBDIR, RUNTIME_FILE, RUN_INDEX_SCHEMA_VERSION, RUN_MANIFEST_FILE, RUN_SOURCES_FILE, type RecordedActionKind, type RegexLiteral, type ResumedEvent, type RunArtifact, type RunFinishedEvent, type RunId, type RunIndexEntry, type RunIndexHeader, type RunKind, type RunManifest, type RunMeta, type RunOutcome, type RunQueueLease, type RunQueueTicketHandle, type RunRequest, type RunSources, type RunStartedEvent, type RunStatus, RunnerAdapterNotFoundError, RunnerNotConfiguredError, type RuntimeState, type RuntimeStateFile, SCENARIOS_INDEX_DIR, SCENARIOS_LATEST_FILE, SCENARIO_RECENT_WINDOW, SECRETS_FILE, SEGMENT_NAME_FORBIDDEN_RE, SNAPSHOTS_SUBDIR, STDERR_FILE, STDOUT_FILE, STEPS_FILE, type ScenarioAnnotations, type ScenarioLatestEntry, type ScenarioMeta, type ScenarioRunRequest, type ScenarioRunTab, type ScenarioTab, type ScenariosLatest, type ScenariosPayload, type ScheduleEntry, type ScreenshotEvent, type SnapshotTab, type StepFailEvent, type StepOkEvent, type StepStartedEvent, TERMINAL_RUNTIME_STATES, TERMINAL_WS_EVENT, type TabKind, type TabKindName, type TerminalClientMessage, type TerminalCloseMessage, type TerminalDataMessage, type TerminalErrorMessage, type TerminalExitMessage, type TerminalKind, type TerminalOutputMessage, type TerminalResizeMessage, type TerminalServerMessage, type TerminalSpawnMessage, type ToolCallEvent, type ToolResultEvent, UNOTEST_DIR, UnplaceableRunIdError, UnsupportedRunKindError, type VariableCategory, type VariableKind, type VariablePlanError, WORKSPACE_FILE, WORKSPACE_SCHEMA_VERSION, type WheelChangedEvent, type WorkspaceBundle, type WorkspaceFile, type WsMessage, type WsMessageKind, activeEnvName, artifactsRootFrom, blobPathFor, blobRelPathFor, blobRelSegmentsFor, blobsRootFor, categorizeVariable, compareQueueTicketNames, debugDirFor, debuggerFileFor, deleteShadowWarning, describeBundle, describeTicketCi, envFileFor, envKeys, envLayerFilesFor, envNamesFromDirListing, foldScenarioRun, insertEnvVar, isAnnotationLine, isExternalVarName, isFailingStatus, isQueueDirName, isRecord, isRegexLiteral, isRunnerConfigKey, isRunsDirName, isTerminalRuntimeState, makeQueueTicketName, makeRunId, parseAppServerEvent, parseBundleManifest, parseBundleUploadResponse, parseCiProvider, parseCiRunRequest, parseCiRunResponse, parseEnvContent, parseQueueTicket, parseQueueTicketName, parseScenarioAnnotations, parseScheduleEntry, parseSchedulesJson, parseWorkspaceFile, planAddVariable, projectQueueRoot, projectRunDirFor, projectRunsRoot, queueDirFor, queuePriorityFromRank, queuePriorityRank, regexLiteral, removeEnvVar, requireRunDirFor, runDirFor, runIdStartedAt, runsDirFor, sanitizeRunIdSegment, scenarioIndexFileName, scenarioRefFromFileName, secretsFileFor, secretsLayerFilesFor, serializeEnvValue, shardDaysDescending, shardDirFor, shardPathForRunId, shardPathForTimestamp, testDirFor, validateCollectionName, validateSegmentName };

package/dist/index.js

@@ -1 +1 @@
-const _0x116ffa=_0x200a;(function(_0x27d94b,_0x35e3c4){const _0x3b833b={_0x50921b:0x22d,_0x3e1358:0x1ee,_0x475ede:0x1f9,_0x3e45ae:0x198,_0xa50cb2:0x1c1},_0x41b16b=_0x200a,_0x4bb2f7=_0x27d94b();while(!![]){try{const _0x21bd0a=-parseInt(_0x41b16b(_0x3b833b._0x50921b))/0x1*(parseInt(_0x41b16b(0x205))/0x2)+parseInt(_0x41b16b(0x256))/0x3*(-parseInt(_0x41b16b(0x215))/0x4)+parseInt(_0x41b16b(0x192))/0x5+-parseInt(_0x41b16b(_0x3b833b._0x3e1358))/0x6*(-parseInt(_0x41b16b(0x1b1))/0x7)+-parseInt(_0x41b16b(_0x3b833b._0x475ede))/0x8+parseInt(_0x41b16b(0x1c5))/0x9+-parseInt(_0x41b16b(_0x3b833b._0x3e45ae))/0xa*(-parseInt(_0x41b16b(_0x3b833b._0xa50cb2))/0xb);if(_0x21bd0a===_0x35e3c4)break;else _0x4bb2f7['push'](_0x4bb2f7['shift']());}catch(_0x58da1c){_0x4bb2f7['push'](_0x4bb2f7['shift']());}}}(_0x3720,0x26e1e));var __defProp=Object['defineProperty'],__name=(_0x2fdceb,_0x5693e4)=>__defProp(_0x2fdceb,'name',{'value':_0x5693e4,'configurable':!![]});function parseAppServerEvent(_0x4b2a3a){const _0x47d636={_0x5171bc:0x1e8,_0x596675:0x201},_0x3ec199=_0x200a,_0x423c72=_0x4b2a3a[_0x3ec199(0x204)]();if(!_0x423c72[_0x3ec199(0x1a1)]('{'))return null;try{const _0x3a522f=JSON[_0x3ec199(_0x47d636._0x5171bc)](_0x423c72);if(_0x3a522f[_0x3ec199(_0x47d636._0x596675)]===_0x3ec199(0x24b)||_0x3a522f[_0x3ec199(0x201)]===_0x3ec199(0x1fe)||_0x3a522f[_0x3ec199(_0x47d636._0x596675)]===_0x3ec199(0x219))return _0x3a522f;return null;}catch{return null;}}__name(parseAppServerEvent,'parseAppServerEvent');var UNOTEST_DIR=_0x116ffa(0x1ac),E2E_SUBDIR=_0x116ffa(0x221),HELPERS_SUBDIR=_0x116ffa(0x19a),COLLECTIONS_SUBDIR='_collections',RUNS_SUBDIR=_0x116ffa(0x193),SNAPSHOTS_SUBDIR='.snapshots';function testDirFor(_0x106fc4){return''+E2E_SUBDIR+_0x106fc4;}__name(testDirFor,_0x116ffa(0x230));function runsDirFor(_0x2974be,_0x162c18){return''+RUNS_SUBDIR+_0x2974be+(_0x162c18?'.'+_0x162c18:'');}__name(runsDirFor,'runsDirFor');function isRunsDirName(_0x145273){const _0x5afd98=_0x116ffa;return _0x145273===RUNS_SUBDIR||_0x145273['startsWith'](RUNS_SUBDIR+'-')||_0x145273[_0x5afd98(0x1a1)](RUNS_SUBDIR+'.');}__name(isRunsDirName,'isRunsDirName');function debugDirFor(_0xcf836c){return'.debug'+_0xcf836c;}__name(debugDirFor,'debugDirFor');function debuggerFileFor(_0x16de6e){const _0x4cbdc4={_0xf4522a:0x253},_0x1c5387=_0x116ffa;return UNOTEST_DIR+_0x1c5387(_0x4cbdc4._0xf4522a)+_0x16de6e+_0x1c5387(0x1dd);}__name(debuggerFileFor,_0x116ffa(0x220));var LOCK_FILE=_0x116ffa(0x254),LOG_FILE=_0x116ffa(0x1b5),STEPS_FILE=_0x116ffa(0x1b8),HEARTBEAT_FILE='heartbeat',DAY_INDEX_FILE=_0x116ffa(0x21d),SCENARIOS_INDEX_DIR=_0x116ffa(0x21f),SCENARIOS_LATEST_FILE=_0x116ffa(0x23b),STDOUT_FILE=_0x116ffa(0x1c9),STDERR_FILE=_0x116ffa(0x1fb),COMMANDS_FILE=_0x116ffa(0x1f8),RUNTIME_FILE=_0x116ffa(0x1ce),PICKER_SNAPSHOT_FILE=_0x116ffa(0x1db),ENV_FILE=_0x116ffa(0x1d0),SECRETS_FILE=_0x116ffa(0x21b);function envFileFor(_0x5bd1e4,_0x2e743d){return''+ENV_FILE+_0x5bd1e4+(_0x2e743d?'.'+_0x2e743d:'');}__name(envFileFor,_0x116ffa(0x24d));function secretsFileFor(_0x136521,_0x41fd37){return''+SECRETS_FILE+_0x136521+(_0x41fd37?'.'+_0x41fd37:'');}__name(secretsFileFor,'secretsFileFor');function envLayerFilesFor(_0x5ac52a,_0x14db69){return layersFor(ENV_FILE,_0x5ac52a,_0x14db69);}__name(envLayerFilesFor,_0x116ffa(0x1d9));function secretsLayerFilesFor(_0x47592e,_0x490ee8){return layersFor(SECRETS_FILE,_0x47592e,_0x490ee8);}__name(secretsLayerFilesFor,'secretsLayerFilesFor');function layersFor(_0x29c4c0,_0x5f02fb,_0x45116d){const _0xfdf440={_0x464695:0x233,_0x50a7da:0x233},_0x26c25a=_0x116ffa,_0x6d0fe7=[_0x29c4c0];if(_0x5f02fb)_0x6d0fe7[_0x26c25a(_0xfdf440._0x464695)](''+_0x29c4c0+_0x5f02fb);if(_0x45116d){_0x6d0fe7['push'](_0x29c4c0+'.'+_0x45116d);if(_0x5f02fb)_0x6d0fe7[_0x26c25a(_0xfdf440._0x50a7da)](''+_0x29c4c0+_0x5f02fb+'.'+_0x45116d);}return _0x6d0fe7;}__name(layersFor,_0x116ffa(0x255));function activeEnvName(_0x43df25){const _0x42b4b7={_0x469696:0x218},_0x2350f5=_0x116ffa,_0x5bf6fa=_0x43df25[_0x2350f5(_0x42b4b7._0x469696)]?.[_0x2350f5(0x204)]();return _0x5bf6fa?_0x5bf6fa:void 0x0;}__name(activeEnvName,_0x116ffa(0x1a0));var RESERVED_ENV_NAMES=new Set([_0x116ffa(0x19e),_0x116ffa(0x1e3),_0x116ffa(0x1e0)]);function envNamesFromDirListing(_0x955c6d,_0x5f5207){const _0x325dd7={_0xf8fcb6:0x1ad,_0x4a620f:0x22b,_0x1cdba3:0x227},_0x1b40f8=_0x116ffa,_0x3eed55=['.env',_0x1b40f8(_0x325dd7._0xf8fcb6)][_0x1b40f8(0x1be)](_0x2e2d63=>_0x5f5207?[_0x2e2d63,''+_0x2e2d63+_0x5f5207]:[_0x2e2d63]),_0xabae84=new Set();for(const _0x298448 of _0x955c6d){for(const _0x22ddfa of _0x3eed55){const _0x32028e=_0x22ddfa+'.';if(!_0x298448[_0x1b40f8(0x1a1)](_0x32028e))continue;const _0x43c6f5=_0x298448[_0x1b40f8(0x1d4)](_0x32028e[_0x1b40f8(_0x325dd7._0x4a620f)]);if(!_0x43c6f5||_0x43c6f5['includes']('/'))continue;if(RESERVED_ENV_NAMES[_0x1b40f8(0x20f)](_0x43c6f5))continue;_0xabae84['add'](_0x43c6f5);}}return[..._0xabae84][_0x1b40f8(_0x325dd7._0x1cdba3)]();}__name(envNamesFromDirListing,_0x116ffa(0x252));function isRegexLiteral(_0x3b302f){const _0xade919={_0xb288f:0x1cf,_0x83ae3a:0x201,_0x33be99:0x1a7,_0x259f1d:0x1a3,_0x4fd395:0x1ae,_0x363e30:0x20d,_0x365b33:0x1ae},_0x1154c1=_0x116ffa;return typeof _0x3b302f===_0x1154c1(_0xade919._0xb288f)&&_0x3b302f!==null&&_0x3b302f[_0x1154c1(_0xade919._0x83ae3a)]===_0x1154c1(_0xade919._0x33be99)&&typeof _0x3b302f[_0x1154c1(_0xade919._0x259f1d)]===_0x1154c1(_0xade919._0x4fd395)&&typeof _0x3b302f[_0x1154c1(_0xade919._0x363e30)]===_0x1154c1(_0xade919._0x365b33);}__name(isRegexLiteral,_0x116ffa(0x206));function regexLiteral(_0x1787b3,_0x2d4b37=''){const _0xacd23={_0x465b79:0x1a7},_0x4c7b5=_0x116ffa;return{'kind':_0x4c7b5(_0xacd23._0x465b79),'source':_0x1787b3,'flags':_0x2d4b37};}__name(regexLiteral,_0x116ffa(0x1d5));var RAND_BYTES=0x6;function makeRunId(_0x40f8d5){const _0x14a3d0={_0x23ecdc:0x1c2,_0x198ad8:0x1c4,_0x5ea264:0x22e,_0x9cc54:0x257},_0x28117a=_0x116ffa,_0x215022=sanitizeRunIdSegment(_0x40f8d5),_0x4d2521=Date[_0x28117a(_0x14a3d0._0x23ecdc)]()[_0x28117a(_0x14a3d0._0x198ad8)](0x24),_0x1a457a=new Uint8Array(RAND_BYTES);globalThis[_0x28117a(_0x14a3d0._0x5ea264)]['getRandomValues'](_0x1a457a);let _0x2fe692='';for(let _0x3c838b=0x0;_0x3c838b<_0x1a457a[_0x28117a(0x22b)];_0x3c838b++){_0x2fe692+=_0x1a457a[_0x3c838b]['toString'](0x10)[_0x28117a(_0x14a3d0._0x9cc54)](0x2,'0');}return _0x215022+'-'+_0x4d2521+'-'+_0x2fe692;}__name(makeRunId,_0x116ffa(0x1b3));function sanitizeRunIdSegment(_0x39dd64){const _0x410dea={_0x4e9038:0x199,_0x2e3dbb:0x1fa},_0x1e9796=_0x116ffa,_0x24eb05=_0x39dd64[_0x1e9796(0x199)](/[^a-zA-Z0-9_-]+/g,'-')[_0x1e9796(0x199)](/-+/g,'-')[_0x1e9796(_0x410dea._0x4e9038)](/^-|-$/g,'');return _0x24eb05[_0x1e9796(0x22b)]>0x0?_0x24eb05:_0x1e9796(_0x410dea._0x2e3dbb);}__name(sanitizeRunIdSegment,_0x116ffa(0x23f));var RANDOM_SUFFIX_RE=/^[0-9a-f]{6,}$/,MIN_PLAUSIBLE_MS=Date[_0x116ffa(0x236)](0x7e4,0x0,0x1),MAX_PLAUSIBLE_MS=Date[_0x116ffa(0x236)](0x834,0x0,0x1);function runIdStartedAt(_0x56cc1b){const _0x4592e0={_0x1bb4f6:0x203,_0xd76748:0x22b,_0x3e0c90:0x1dc,_0x3eb56f:0x19c},_0x1845f9=_0x116ffa,_0x23cf06=_0x56cc1b[_0x1845f9(_0x4592e0._0x1bb4f6)]('-');if(_0x23cf06[_0x1845f9(0x22b)]<0x3)return null;const _0x418603=_0x23cf06[_0x23cf06[_0x1845f9(_0x4592e0._0xd76748)]-0x1];if(!RANDOM_SUFFIX_RE[_0x1845f9(_0x4592e0._0x3e0c90)](_0x418603))return null;const _0x241189=_0x23cf06[_0x23cf06['length']-0x2];if(!/^[0-9a-z]+$/[_0x1845f9(0x1dc)](_0x241189))return null;const _0x148cf3=parseInt(_0x241189,0x24);if(!Number[_0x1845f9(_0x4592e0._0x3eb56f)](_0x148cf3))return null;if(_0x148cf3<MIN_PLAUSIBLE_MS||_0x148cf3>=MAX_PLAUSIBLE_MS)return null;return _0x148cf3;}__name(runIdStartedAt,_0x116ffa(0x1bb));function shardPathForTimestamp(_0x560f6f){const _0x61263d={_0x36f5b6:0x216,_0x24f188:0x257,_0x203e7e:0x228},_0x5a5b54=_0x116ffa,_0x550c56=new Date(_0x560f6f),_0x4a8b4b=String(_0x550c56[_0x5a5b54(0x251)]())['padStart'](0x4,'0'),_0x1e1cf0=String(_0x550c56[_0x5a5b54(_0x61263d._0x36f5b6)]()+0x1)[_0x5a5b54(_0x61263d._0x24f188)](0x2,'0'),_0x1a6176=String(_0x550c56[_0x5a5b54(_0x61263d._0x203e7e)]())[_0x5a5b54(_0x61263d._0x24f188)](0x2,'0');return _0x4a8b4b+'/'+_0x1e1cf0+'/'+_0x1a6176;}__name(shardPathForTimestamp,_0x116ffa(0x239));function shardPathForRunId(_0x4053b1){const _0x883260=runIdStartedAt(_0x4053b1);return _0x883260===null?null:shardPathForTimestamp(_0x883260);}__name(shardPathForRunId,_0x116ffa(0x245));function runDirFor(_0x49437f,_0x37e309){const _0x1debde=shardPathForRunId(_0x37e309);return _0x1debde===null?null:_0x49437f+'/'+_0x1debde+'/'+_0x37e309;}__name(runDirFor,'runDirFor');var UnplaceableRunIdError=class extends Error{static{__name(this,_0x116ffa(0x1f3));}constructor(_0xda6e1d){const _0xd42bca={_0x5e0061:0x1ff},_0x1b7351=_0x116ffa;super(_0x1b7351(0x1e5)+_0xda6e1d),this[_0x1b7351(_0xd42bca._0x5e0061)]='UnplaceableRunIdError';}};function requireRunDirFor(_0x29d9c1,_0x5ec03e){const _0x477c86=runDirFor(_0x29d9c1,_0x5ec03e);if(_0x477c86===null)throw new UnplaceableRunIdError(_0x5ec03e);return _0x477c86;}__name(requireRunDirFor,_0x116ffa(0x208));function projectRunsRoot(_0x138d66='',_0x594e7e){return UNOTEST_DIR+'/'+runsDirFor(_0x138d66,_0x594e7e);}__name(projectRunsRoot,_0x116ffa(0x1f0));function projectRunDirFor(_0x3fa6ce,_0x2c3c21='',_0x12884f){return requireRunDirFor(projectRunsRoot(_0x2c3c21,_0x12884f),_0x3fa6ce);}__name(projectRunDirFor,_0x116ffa(0x1a8));function shardDirFor(_0x4db600,_0xf7fc93){return _0x4db600+'/'+shardPathForTimestamp(_0xf7fc93);}__name(shardDirFor,'shardDirFor');function*shardDaysDescending(_0x8e0f55,_0x329adf,_0x51e73d){const _0x526274={_0x21ff4:0x212},_0x4b75cb=_0x116ffa,_0x100b24=0x5265c00;let _0xfebec=Math[_0x4b75cb(_0x526274._0x21ff4)](_0x329adf/_0x100b24)*_0x100b24;for(let _0x406038=0x0;_0x406038<_0x51e73d;_0x406038++){yield shardDirFor(_0x8e0f55,_0xfebec),_0xfebec-=_0x100b24;}}__name(shardDaysDescending,_0x116ffa(0x1a9));var RUN_INDEX_SCHEMA_VERSION=0x2,SCENARIO_RECENT_WINDOW=0xc;function isFailingStatus(_0x43a40e){const _0x1a4329={_0x2b7f6d:0x19d},_0x8b7894=_0x116ffa;return _0x43a40e===_0x8b7894(_0x1a4329._0x2b7f6d)||_0x43a40e===_0x8b7894(0x22f);}__name(isFailingStatus,_0x116ffa(0x1e2));function foldScenarioRun(_0x47b580,_0x447118){const _0x4749f7={_0x691b5e:0x21a,_0x30e471:0x229,_0x7f13e6:0x217,_0xd545a5:0x1de,_0x242d6a:0x20a,_0x3ec600:0x229},_0x2e3005=_0x116ffa,_0x3ae930={'lastRunId':_0x447118[_0x2e3005(_0x4749f7._0x691b5e)],'lastStatus':_0x447118['status'],'lastAt':_0x447118[_0x2e3005(_0x4749f7._0x30e471)],'lastDurationMs':_0x447118[_0x2e3005(_0x4749f7._0x7f13e6)],'recent':[..._0x47b580?.[_0x2e3005(_0x4749f7._0xd545a5)]??[],_0x447118[_0x2e3005(_0x4749f7._0x242d6a)]][_0x2e3005(0x1d4)](-SCENARIO_RECENT_WINDOW)};if(!isFailingStatus(_0x447118[_0x2e3005(0x20a)]))return{..._0x3ae930,'failStreak':0x0,'failingSince':null};const _0x1c7a77=(_0x47b580?.[_0x2e3005(0x249)]??0x0)+0x1;return{..._0x3ae930,'failStreak':_0x1c7a77,'failingSince':_0x1c7a77===0x1?_0x447118[_0x2e3005(_0x4749f7._0x30e471)]:_0x47b580?.[_0x2e3005(0x1fd)]??_0x447118[_0x2e3005(_0x4749f7._0x3ec600)]};}__name(foldScenarioRun,_0x116ffa(0x225));function scenarioIndexFileName(_0x18e240){const _0x1373d9={_0x49f34c:0x1aa},_0x28bf9a=_0x116ffa;return encodeURIComponent(_0x18e240)+_0x28bf9a(_0x1373d9._0x49f34c);}__name(scenarioIndexFileName,_0x116ffa(0x23d));function scenarioRefFromFileName(_0x12d6d6){const _0x589e56={_0x3b04c3:0x1c3,_0x29da73:0x1aa,_0xa1861d:0x22b},_0xb7738c=_0x116ffa;if(!_0x12d6d6[_0xb7738c(_0x589e56._0x3b04c3)](_0xb7738c(0x1aa)))return null;try{return decodeURIComponent(_0x12d6d6['slice'](0x0,-_0xb7738c(_0x589e56._0x29da73)[_0xb7738c(_0x589e56._0xa1861d)]));}catch{return null;}}__name(scenarioRefFromFileName,_0x116ffa(0x1c7));var BLOBS_DIR=_0x116ffa(0x210),GENERATION_SEP='~',HASH_RE=/^[0-9a-f]{8,}$/,InvalidBlobHashError=class extends Error{static{__name(this,_0x116ffa(0x1bf));}constructor(_0x451f23){const _0x8983e5={_0x37ac3f:0x1e1,_0x2a3567:0x1bf},_0x31f7c5=_0x116ffa;super(_0x31f7c5(_0x8983e5._0x37ac3f)+_0x451f23),this[_0x31f7c5(0x1ff)]=_0x31f7c5(_0x8983e5._0x2a3567);}};function blobPathFor(_0x20ac1e,_0x176934,_0x3b6b8b,_0x579c4d=0x0){return _0x20ac1e+'/'+blobRelPathFor(_0x176934,_0x3b6b8b,_0x579c4d);}__name(blobPathFor,_0x116ffa(0x1f7));function blobRelSegmentsFor(_0x256a6c,_0x1fa868,_0x4082d6=0x0){const _0x1667ba={_0x3dcddd:0x1dc,_0x3054e9:0x1d4},_0x2d0cb9=_0x116ffa;if(!HASH_RE[_0x2d0cb9(_0x1667ba._0x3dcddd)](_0x256a6c))throw new InvalidBlobHashError(_0x256a6c);const _0x16fb42=_0x4082d6>0x0?''+GENERATION_SEP+_0x4082d6:'';return[BLOBS_DIR,_0x256a6c['slice'](0x0,0x2),_0x256a6c[_0x2d0cb9(_0x1667ba._0x3054e9)](0x2,0x4),''+_0x256a6c+_0x16fb42+'.'+_0x1fa868];}__name(blobRelSegmentsFor,_0x116ffa(0x224));function blobRelPathFor(_0x98dd8b,_0x30ecb5,_0x3dee9a=0x0){const _0x6aa748=_0x116ffa;return blobRelSegmentsFor(_0x98dd8b,_0x30ecb5,_0x3dee9a)[_0x6aa748(0x1fc)]('/');}__name(blobRelPathFor,_0x116ffa(0x235));function blobsRootFor(_0x52d308){return _0x52d308+'/'+BLOBS_DIR;}__name(blobsRootFor,'blobsRootFor');var FS_UNSAFE_NAME_RE=/[\\/:*?"<>|\x00-\x1f]/;function validateFsSafeName(_0x3a6953,_0x1bf7bc){const _0x11e8e3={_0x147c62:0x213,_0x36f100:0x1a1,_0x38c626:0x1dc,_0x538be5:0x190},_0x5812f7=_0x116ffa;if(typeof _0x3a6953!==_0x5812f7(0x1ae))return _0x5812f7(0x1b9);const _0x3753f8=_0x3a6953[_0x5812f7(0x204)]();if(_0x3753f8[_0x5812f7(0x22b)]===0x0)return _0x5812f7(_0x11e8e3._0x147c62);if(_0x3753f8==='.'||_0x3753f8==='..')return _0x5812f7(0x1c0);if(_0x3753f8['startsWith']('.'))return _0x5812f7(0x1bd);if(_0x1bf7bc?.['reservedUnderscore']&&_0x3753f8[_0x5812f7(_0x11e8e3._0x36f100)]('_'))return _0x5812f7(0x214);if(FS_UNSAFE_NAME_RE[_0x5812f7(_0x11e8e3._0x38c626)](_0x3753f8))return _0x5812f7(_0x11e8e3._0x538be5);return null;}__name(validateFsSafeName,'validateFsSafeName');var COLLECTION_NAME_FORBIDDEN_RE=FS_UNSAFE_NAME_RE;function validateCollectionName(_0xbf7997){return validateFsSafeName(_0xbf7997);}__name(validateCollectionName,_0x116ffa(0x211));var RUN_MANIFEST_FILE=_0x116ffa(0x1f4),RUN_SOURCES_FILE=_0x116ffa(0x23e),UnsupportedRunKindError=class extends Error{static{__name(this,'UnsupportedRunKindError');}constructor(_0x1326a7,_0x8f0dfe){const _0x8d00cb=_0x116ffa;super(_0x8d00cb(0x1b4)+_0x8f0dfe+'\x22\x20does\x20not\x20support\x20run\x20kind\x20\x22'+_0x1326a7+'\x22'),this[_0x8d00cb(0x1ff)]=_0x8d00cb(0x1ab);}},RunnerAdapterNotFoundError=class extends Error{static{__name(this,_0x116ffa(0x1c8));}constructor(_0x1df3b8,_0x4f1c2f){const _0x563bd0={_0x3619dc:0x1c8},_0x3db583=_0x116ffa;super(_0x3db583(0x1d2)+_0x1df3b8+'\x22.\x20'+_0x4f1c2f),this['name']=_0x3db583(_0x563bd0._0x3619dc);}},RunnerNotConfiguredError=class extends Error{static{__name(this,'RunnerNotConfiguredError');}constructor(_0x5b9213){const _0x4634f5=_0x116ffa;super(_0x5b9213),this['name']=_0x4634f5(0x24f);}},EXPECT_FAIL_ANNOTATION=_0x116ffa(0x24e),ANNOTATION_RE=/^\s*\/\/\s*@([a-z0-9-]+)\s*$/;function isAnnotationLine(_0x5c46d8){const _0x3983d1=_0x116ffa;return ANNOTATION_RE[_0x3983d1(0x1dc)](_0x5c46d8);}__name(isAnnotationLine,_0x116ffa(0x1da));function parseScenarioAnnotations(_0x462107){const _0x3d0db1={_0x416c76:0x203,_0x48b427:0x204,_0x1fa3b2:0x19b,_0x54b36b:0x1b7,_0x2f4303:0x20f},_0x541bd0=_0x116ffa,_0x57f215=new Set();for(const _0x3cbef5 of _0x462107[_0x541bd0(_0x3d0db1._0x416c76)](/\r?\n/)){const _0x4ef1b1=_0x3cbef5[_0x541bd0(_0x3d0db1._0x48b427)]();if(_0x4ef1b1==='')continue;if(!_0x4ef1b1['startsWith']('//'))break;const _0xf7b62d=_0x4ef1b1[_0x541bd0(_0x3d0db1._0x1fa3b2)](ANNOTATION_RE);if(_0xf7b62d)_0x57f215[_0x541bd0(_0x3d0db1._0x54b36b)](_0xf7b62d[0x1]);}return{'expectFail':_0x57f215[_0x541bd0(_0x3d0db1._0x2f4303)](EXPECT_FAIL_ANNOTATION)};}__name(parseScenarioAnnotations,_0x116ffa(0x1d3));var SEGMENT_NAME_FORBIDDEN_RE=FS_UNSAFE_NAME_RE;function validateSegmentName(_0x29442b){return validateFsSafeName(_0x29442b,{'reservedUnderscore':!![]});}__name(validateSegmentName,_0x116ffa(0x1bc));var TERMINAL_WS_EVENT=_0x116ffa(0x22a),RUNNER_CONFIG_KEYS=new Set([_0x116ffa(0x194),_0x116ffa(0x244),_0x116ffa(0x222),'UNOTEST_DEFAULT_TIMEOUT_MS',_0x116ffa(0x1ca),_0x116ffa(0x1af),_0x116ffa(0x21c),_0x116ffa(0x22c),_0x116ffa(0x238),_0x116ffa(0x1f6),_0x116ffa(0x24a),_0x116ffa(0x209),_0x116ffa(0x247),_0x116ffa(0x1ec),_0x116ffa(0x1cc),'UNOTEST_NETWORK',_0x116ffa(0x200),_0x116ffa(0x1a4),_0x116ffa(0x196),_0x116ffa(0x234),'DATABASE_URL']);function isRunnerConfigKey(_0x3251fb){return RUNNER_CONFIG_KEYS['has'](_0x3251fb);}__name(isRunnerConfigKey,_0x116ffa(0x20b));function categorizeVariable(_0x436e22){const _0x10574c={_0x36af99:0x1a5,_0x18105c:0x1df,_0x1941f8:0x1cd,_0x4f6b76:0x23c},_0x366658=_0x116ffa;if(_0x436e22[_0x366658(0x1a3)]===_0x366658(_0x10574c._0x36af99))return _0x366658(_0x10574c._0x18105c);return isRunnerConfigKey(_0x436e22[_0x366658(0x1ff)])?_0x366658(_0x10574c._0x1941f8):_0x366658(_0x10574c._0x4f6b76);}__name(categorizeVariable,_0x116ffa(0x232));function isExternalVarName(_0x497bd1){const _0xf21306=_0x116ffa;return/^[A-Z][A-Z0-9_]*$/[_0xf21306(0x1dc)](_0x497bd1);}__name(isExternalVarName,_0x116ffa(0x1c6));var ENV_KEY_RE=/^[A-Za-z_][A-Za-z0-9_]*$/;function*assignmentEntries(_0x5ce775){const _0x34aab4={_0x1f020e:0x204,_0x35d136:0x204},_0x1d3b6c=_0x116ffa;for(const _0x422ae3 of _0x5ce775['split'](/\r?\n/)){const _0x460768=_0x422ae3[_0x1d3b6c(_0x34aab4._0x1f020e)]();if(_0x460768===''||_0x460768['startsWith']('#'))continue;const _0xec2378=_0x460768[_0x1d3b6c(0x1d6)]('=');if(_0xec2378<=0x0)continue;const _0x2deb23=_0x460768[_0x1d3b6c(0x1d4)](0x0,_0xec2378)[_0x1d3b6c(_0x34aab4._0x35d136)]();if(!ENV_KEY_RE['test'](_0x2deb23))continue;yield[_0x2deb23,_0x460768['slice'](_0xec2378+0x1)[_0x1d3b6c(0x204)]()];}}__name(assignmentEntries,_0x116ffa(0x1f5));function parseEnvContent(_0x51693e){const _0x10d785={_0x57ef42:0x22b},_0x45bef5=_0x116ffa,_0x1d17ed={};for(const [_0x217904,_0x44afe4]of assignmentEntries(_0x51693e)){let _0x2c63df=_0x44afe4;if(_0x2c63df[_0x45bef5(_0x10d785._0x57ef42)]>=0x2){const _0x3686e3=_0x2c63df[0x0],_0x1138d3=_0x2c63df[_0x2c63df['length']-0x1];(_0x3686e3==='\x22'||_0x3686e3==='\x27')&&_0x3686e3===_0x1138d3&&(_0x2c63df=_0x2c63df['slice'](0x1,-0x1));}_0x1d17ed[_0x217904]=_0x2c63df;}return _0x1d17ed;}__name(parseEnvContent,_0x116ffa(0x197));function serializeEnvValue(_0xd741d5){const _0x2e786a={_0x5299fd:0x199},_0x2995ba=_0x116ffa;if(_0xd741d5==='')return'';if(/[\s#"'=\\]|^[`]/[_0x2995ba(0x1dc)](_0xd741d5)||/[\n\r]/[_0x2995ba(0x1dc)](_0xd741d5)){const _0x30198c=_0xd741d5[_0x2995ba(_0x2e786a._0x5299fd)](/\\/g,'\x5c\x5c')[_0x2995ba(0x199)](/"/g,'\x5c\x22')['replace'](/\n/g,'\x5cn')[_0x2995ba(_0x2e786a._0x5299fd)](/\r/g,'\x5cr');return'\x22'+_0x30198c+'\x22';}return _0xd741d5;}__name(serializeEnvValue,_0x116ffa(0x1b0));function envKeys(_0x296c6b){const _0x30b099=_0x116ffa,_0xc8708=new Set();for(const [_0xd5d4]of assignmentEntries(_0x296c6b))_0xc8708[_0x30b099(0x1b7)](_0xd5d4);return _0xc8708;}__name(envKeys,_0x116ffa(0x1ea));function _0x200a(_0x51d4d2,_0x3e5daa){_0x51d4d2=_0x51d4d2-0x190;const _0x372062=_0x3720();let _0x200a84=_0x372062[_0x51d4d2];if(_0x200a['MCMcFo']===undefined){var _0x52222a=function(_0xd14038){const _0x51a2e5='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/=';let _0x2fdceb='',_0x5693e4='';for(let _0x4b2a3a=0x0,_0x423c72,_0x3a522f,_0x106fc4=0x0;_0x3a522f=_0xd14038['charAt'](_0x106fc4++);~_0x3a522f&&(_0x423c72=_0x4b2a3a%0x4?_0x423c72*0x40+_0x3a522f:_0x3a522f,_0x4b2a3a++%0x4)?_0x2fdceb+=String['fromCharCode'](0xff&_0x423c72>>(-0x2*_0x4b2a3a&0x6)):0x0){_0x3a522f=_0x51a2e5['indexOf'](_0x3a522f);}for(let _0x2974be=0x0,_0x162c18=_0x2fdceb['length'];_0x2974be<_0x162c18;_0x2974be++){_0x5693e4+='%'+('00'+_0x2fdceb['charCodeAt'](_0x2974be)['toString'](0x10))['slice'](-0x2);}return decodeURIComponent(_0x5693e4);};_0x200a['byJvYc']=_0x52222a,_0x200a['TBToYo']={},_0x200a['MCMcFo']=!![];}const _0xeba26c=_0x372062[0x0],_0x74ad2=_0x51d4d2+_0xeba26c,_0x32e171=_0x200a['TBToYo'][_0x74ad2];return!_0x32e171?(_0x200a84=_0x200a['byJvYc'](_0x200a84),_0x200a['TBToYo'][_0x74ad2]=_0x200a84):_0x200a84=_0x32e171,_0x200a84;}function isSectionDivider(_0x42fdc8){const _0x4aa885={_0xe589b6:0x204,_0x548675:0x1dc},_0x29afed=_0x116ffa,_0xeeb1ed=_0x42fdc8[_0x29afed(_0x4aa885._0xe589b6)]();return _0xeeb1ed[_0x29afed(0x1a1)]('#')&&/---/[_0x29afed(_0x4aa885._0x548675)](_0xeeb1ed);}__name(isSectionDivider,_0x116ffa(0x1d7));function isAssignmentLine(_0x309764){const _0x107f2c={_0x4d5411:0x1d4,_0x214e1c:0x204},_0x445574=_0x116ffa,_0x39f315=_0x309764[_0x445574(0x204)]();if(_0x39f315===''||_0x39f315['startsWith']('#'))return![];const _0x122023=_0x39f315[_0x445574(0x1d6)]('=');return _0x122023>0x0&&ENV_KEY_RE[_0x445574(0x1dc)](_0x39f315[_0x445574(_0x107f2c._0x4d5411)](0x0,_0x122023)[_0x445574(_0x107f2c._0x214e1c)]());}__name(isAssignmentLine,_0x116ffa(0x1ba));function isAssignmentOf(_0x582f49,_0x4765f4){const _0x1a687c={_0x1b3e7f:0x204,_0x5cc4a8:0x1d6},_0x37b60d=_0x116ffa,_0x22c9b9=_0x582f49[_0x37b60d(_0x1a687c._0x1b3e7f)]();if(_0x22c9b9===''||_0x22c9b9['startsWith']('#'))return![];const _0x20c7ad=_0x22c9b9[_0x37b60d(_0x1a687c._0x5cc4a8)]('=');if(_0x20c7ad<=0x0)return![];return _0x22c9b9[_0x37b60d(0x1d4)](0x0,_0x20c7ad)[_0x37b60d(0x204)]()===_0x4765f4;}__name(isAssignmentOf,'isAssignmentOf');function splitLines(_0x6cf080){const _0x572b9e=_0x116ffa,_0x5a4908=_0x6cf080[_0x572b9e(0x1c3)]('\x0a'),_0x246548=_0x5a4908?_0x6cf080['slice'](0x0,-0x1):_0x6cf080;return{'lines':_0x246548===''?[]:_0x246548['split']('\x0a'),'trailingNewline':_0x5a4908};}__name(splitLines,_0x116ffa(0x250));function joinLines(_0x48997e,_0x40a33e){const _0x53f527={_0x1412f7:0x1fc},_0x1fa990=_0x116ffa,_0x36b9fd=_0x48997e[_0x1fa990(_0x53f527._0x1412f7)]('\x0a');return _0x40a33e||_0x36b9fd===''?_0x36b9fd+'\x0a':_0x36b9fd;}__name(joinLines,_0x116ffa(0x1d8));function _0x3720(){const _0x5c9c38=['vu5pvevtvf9kvurhrv9vuKW','AgfZ','x2jSB2jZ','DMfSAwrHDgvdB2XSzwn0Aw9UtMfTzq','zMXVB3i','BxvZDcbUB3qGyMuGzw1WDhK','BxvZDcbUB3qGC3rHCNqGD2L0AcaNxYCGkhjLC2vYDMvKkq','nhvdCvfWtq','z2v0vvrdtw9UDgG','zhvYyxrPB25nCW','vu5pvevtvf9ftLy','yxbWlxnLCNzLCJPLCNjVCG','CNvUswq','Dw5VDgvZDc8UC2vJCMv0CW','vu5pvevtvf9mt0nbteu','x2rHEs5QC29UBa','Dw5RBM93BI1YDw5UzxiTA2v5','x3nJzw5HCMLVCW','zgvIDwDNzxjgAwXLrM9Y','ztjL','vu5pvevtvf9tte9xx01p','vu5pvevtvf9kvurhrv9bq0nfu1nFve9lru4','yMXVyLjLBfnLz21LBNrZrM9Y','zM9SzfnJzw5HCMLVuNvU','Dg9mB3DLCKnHC2u','C29YDa','z2v0vvrdrgf0zq','C3rHCNrLzef0','DgvYBwLUywW','BgvUz3rO','vu5pvevtvf9usu1fwK9orq','mJq1nZa0D0TOzxfk','y3j5ChrV','Aw50zxjYDxb0zwq','DgvZDerPCKzVCG','iokaLcbWAwnRigeGzgLMzMvYzw50ig5HBwuGB3iGzwrPDcb0AguGzxHPC3rPBMCGDMfSDwuU','y2f0zwDVCML6zvzHCMLHyMXL','ChvZAa','rK9sq0vFq09mt1i','yMXVyLjLBfbHDgHgB3i','vvrd','y29TCgXLDgvK','vu5pvevtvf9mt0DFtevwruW','C2HHCMrqyxrOrM9YvgLTzxn0yw1W','Aw52ywXPzc1Uyw1L','x2XHDgvZDc5QC29U','yxbW','C2nLBMfYAw9jBMrLEezPBgvoyw1L','C291CMnLCY5QC29U','C2fUAxrPEMvsDw5jzfnLz21LBNq','vu5pvevtvf9kvurhrv9nt0rfta','Aw5Zzxj0rw52vMfY','uNvUBMvY','vu5pvevtvf9kvurhrv9ut0TftG','vu5pvevtvf9iruferuq','C2HHCMrqyxrOrM9YuNvUswq','zhvWBgLJyxrL','vu5pvevtvf9erujvr19quKvwsuvxx0jzvevt','ic0Tlq','zMfPBfn0CMvHAW','vu5pvevtvf9erujvr19esvi','yxbWlxnLCNzLCJPYzwfKEq','l2P1zgDL','zw52rMLSzuzVCG','zxHWzwn0lwzHAwW','uNvUBMvYtM90q29UzMLNDxjLzevYCM9Y','C3bSAxrmAw5LCW','z2v0vvrdrNvSBfLLyxi','zw52tMfTzxngCM9TrgLYtgLZDgLUzW','lY5Kzwj1z2DLCG','lNzPzxDLCI5SB2nR','Bgf5zxjZrM9Y','ntGWndC2whbUtLbg','CgfKu3rHCNq','BxvZDcbUB3qGy29UDgfPBIbCic8GoIaQid8GiIa8id4GFcbVCIbJB250CM9SignOyxjHy3rLCNm','zw52','mteXnZCWshjjA3fo','lNj1BNm','vu5pvevtvf9cuK9xu0vs','vu5pvevtvf9kvurhrv9qt1ju','tK9Fq09mt1i','CgfYC2vfBNzdB250zw50','mtbnDgLPvNi','CMvWBgfJzq','x2HLBhbLCNm','Bwf0y2G','AxngAw5PDgu','zMfPBgvK','zxHHBxbSzq','vu5pvevtvf9kvurhrv9srvrssuvt','ywn0AxzLrw52tMfTzq','C3rHCNrZv2L0Aa','AxnuzxjTAw5HBfj1BNrPBwvtDgf0zq','C291CMnL','vu5pvevtvf9dqunirv9esvi','C2vJCMv0CW','igLZigfSC28GC2v0igLUihvUB3rLC3qVlMvUDIdIGjqGDgHLihnLy3jLDcb2ywX1zsbUB3CGC2HHzg93CYbPDc4','CMvNzxG','ChjVAMvJDfj1BKrPCKzVCG','C2HHCMreyxLZrgvZy2vUzgLUzW','lMPZB25S','vw5ZDxbWB3j0zwrsDw5lAw5KrxjYB3i','Dw5VDgvZDa','lNnLy3jLDhm','C3rYAw5N','vu5pvevtvf9qt1bvuf9huKfdrv9nuW','C2vYAwfSAxPLrw52vMfSDwu','odyWm2ruu0j3sq','igLZigfSC28GC2v0igLUihLVDxiGC2HLBgWGzw52AxjVBM1LBNqG4OcuigL0ihDPBgWGA2vLCcbYzxnVBhzPBMCGzNjVBsb0AgvYzsaODgHLigvUDMLYB25Tzw50ihDPBNmGB3zLCIb0AguGzMLSzsKU','BwfRzvj1BKLK','CNvUBMvYici','lNzPzxDLCI5SB2C','vu5pvevtvf9kvurhrv9dtefvrevFqKLo','ywrK','C3rLChmUANnVBMW','BxvZDcbIzsbHihn0CMLUzW','AxnbC3nPz25Tzw50tgLUzq','CNvUswrtDgfYDgvKqxq','DMfSAwrHDgvtzwDTzw50tMfTzq','BxvZDcbUB3qGC3rHCNqGD2L0AcaNlIC','zMXHDe1HCa','sw52ywXPzejSB2jiyxnOrxjYB3i','BxvZDcbUB3qGyMuGiI4Iig9YiciUlIi','mZiZmZqZovfIB09Puq','BM93','zw5KC1DPDgG','Dg9tDhjPBMC','mJu5mdy4nKPxrLHktq','AxnfEhrLCM5HBfzHCK5HBwu','C2nLBMfYAw9szwzgCM9TrMLSzu5HBwu','uNvUBMvYqwrHChrLCK5VDezVDw5KrxjYB3i','C3rKB3v0lMXVzW','vu5pvevtvf9eruzbvuXux05bvKLhqvrjt05FveLnru9vvf9nuW','ywjVCNrLza','vu5pvevtvf9erujvr19lruvqx0nbteXt','CNvUBMvY','CNvUDgLTzs5QC29U','B2jQzwn0','Dw5VDgvZDc8Uzw52','ig11C3qGyMuGvvbqrvjFu05bs0uGkguUzY4Gqvbqx0jbu0vFvvjmksbZBYbHihnJzw5HCMLVignHBIbYzwzLCMvUy2uGAxqGyNKGBMfTzs4','y2fUBM90igXVywqGCNvUBMvYigfKyxb0zxiGiG','CgfYC2vty2vUyxjPB0fUBM90yxrPB25Z','C2XPy2u','CMvNzxHmAxrLCMfS','Aw5KzxHpzG','Axntzwn0Aw9UrgL2AwrLCG','AM9PBKXPBMvZ','zw52tgf5zxjgAwXLC0zVCG','AxnbBM5VDgf0Aw9UtgLUzq','CgLJA2vYlxnUyxbZAg90lNr4Da','DgvZDa','lMPZB24','CMvJzw50','C2vJCMv0','DgvTCgXHDgu','yMXVyIbOyxnOig11C3qGyMuGBg93zxjJyxnLigHLEcWGz290oIa','AxngywLSAw5Nu3rHDhvZ','C2fTCgXL','CMvTB3zLrw52vMfY','CNvUswqGy2fYCMLLCYbUBYb0Aw1LC3rHBxaSignHBM5VDcbWBgfJzsbPDcbPBIbHihnOyxjKoIa','igLZigfSC28GC2v0igLUihvUB3rLC3qVlNnLy3jLDhmG4OcuihrOzsbZzwnYzxqGDMfSDwuGC2HHzg93CYb0AgLZig9Uzs4','qxbW','CgfYC2u','iYaTls0G','zw52s2v5CW','igfSCMvHzhKGzxHPC3rZigLUia','vu5pvevtvf9erujvr19ive1mx01bwf9cwvrfuW','zgvSzxrLu2HHzg93v2fYBMLUzW','ntGYA1buALnd','CgXHBKfKzfzHCMLHyMXL','ChjVAMvJDfj1BNnsB290','vu5pvevtvf9kvurhrv9wt1rf','zw52q29UDgvUDa','vw5WBgfJzwfIBgvsDw5jzevYCM9Y','BwfUAwzLC3qUANnVBG','yxnZAwDUBwvUDevUDhjPzxm','vu5pvevtvf9erujvrW','yMXVyLbHDgHgB3i','y29TBwfUzhmUANnVBMW','otK5mJK2y3vfquDf','CNvU','C3rKzxjYlMXVzW','AM9PBG','zMfPBgLUz1nPBMnL','yxbWlxnLCNzLCJPYzxvZzwq','BMfTzq','vu5pvevtvf9dt05tt0Xf','A2LUza','vu5pvevtvf9kvurhrv9usu1ft1vux01t','C3bSAxq','DhjPBq','mMjytwXzyW','AxnszwDLEeXPDgvYywW','zMLUzeLUzgv4','CMvXDwLYzvj1BKrPCKzVCG','vu5pvevtvf9erujvr19nqvHFqLLurvm','C3rHDhvZ','AxnsDw5UzxjdB25MAwDlzxK','C3bSAwnL','zMXHz3m'];_0x3720=function(){return _0x5c9c38;};return _0x3720();}function insertEnvVar(_0x1c3ead,_0xd1d658,_0x5c73cb,_0x3ceb1e){const _0x56a147={_0x29629c:0x226,_0x360c04:0x22b,_0x33473d:0x20c,_0x31e69e:0x233,_0x5066dd:0x1e9},_0x1ff75b=_0x116ffa,_0x4837ca=_0xd1d658+'='+serializeEnvValue(_0x5c73cb),{lines:_0x17dcaa,trailingNewline:_0x1d0a69}=splitLines(_0x1c3ead);if(_0x3ceb1e){const _0x4f1014=new RegExp('\x5cb'+_0x3ceb1e[_0x1ff75b(_0x56a147._0x29629c)]()+'\x5cb'),_0x5e32a0=_0x17dcaa[_0x1ff75b(0x207)](_0x503de5=>isSectionDivider(_0x503de5)&&_0x4f1014['test'](_0x503de5['toLowerCase']()));if(_0x5e32a0!==-0x1){let _0x5cf14d=_0x17dcaa[_0x1ff75b(_0x56a147._0x360c04)];for(let _0x1020dc=_0x5e32a0+0x1;_0x1020dc<_0x17dcaa['length'];_0x1020dc++){if(isSectionDivider(_0x17dcaa[_0x1020dc])){_0x5cf14d=_0x1020dc;break;}}let _0x793ddb=-0x1,_0x571e43=-0x1;for(let _0x1bc535=_0x5e32a0+0x1;_0x1bc535<_0x5cf14d;_0x1bc535++){if(_0x17dcaa[_0x1bc535]['trim']()!=='')_0x571e43=_0x1bc535;if(isAssignmentLine(_0x17dcaa[_0x1bc535]))_0x793ddb=_0x1bc535;}const _0x13e63c=_0x793ddb>=0x0?_0x793ddb:_0x571e43,_0x1bce96=_0x13e63c>=0x0?_0x13e63c+0x1:_0x5e32a0+0x1;return _0x17dcaa[_0x1ff75b(_0x56a147._0x33473d)](_0x1bce96,0x0,_0x4837ca),joinLines(_0x17dcaa,_0x1d0a69||_0x17dcaa['length']>0x0);}if(_0x17dcaa[_0x1ff75b(_0x56a147._0x360c04)]>0x0)_0x17dcaa[_0x1ff75b(_0x56a147._0x31e69e)]('');return _0x17dcaa[_0x1ff75b(0x233)](_0x1ff75b(_0x56a147._0x5066dd)+_0x3ceb1e+_0x1ff75b(0x248),_0x4837ca),joinLines(_0x17dcaa,!![]);}return _0x17dcaa[_0x1ff75b(0x233)](_0x4837ca),joinLines(_0x17dcaa,!![]);}__name(insertEnvVar,_0x116ffa(0x241));function removeEnvVar(_0x53d48d,_0x3fbd87){const _0x170198={_0x4a5317:0x22b},_0x102fce=_0x116ffa,{lines:_0x5957d5,trailingNewline:_0x412e22}=splitLines(_0x53d48d),_0x5941c1=_0x5957d5['filter'](_0x212631=>!isAssignmentOf(_0x212631,_0x3fbd87)),_0x1a290d=_0x5941c1[_0x102fce(_0x170198._0x4a5317)]!==_0x5957d5['length'];return{'content':joinLines(_0x5941c1,_0x412e22),'removed':_0x1a290d};}__name(removeEnvVar,_0x116ffa(0x1e4));var SECTION_BY_KIND={'app':_0x116ffa(0x1e7),'runner':_0x116ffa(0x242),'secret':void 0x0};function planAddVariable(_0xd7896d){const _0x4d5793={_0x846756:0x1cd,_0x87a192:0x23a,_0x2a045e:0x1df,_0xcc073d:0x1a5,_0x3df0af:0x1a5,_0x5900fd:0x1eb,_0x58f6b2:0x1a6,_0x1ee364:0x1df},_0x596433=_0x116ffa,{name:_0x2b6413,kind:_0x774431}=_0xd7896d;if(_0x774431===_0x596433(_0x4d5793._0x846756)){if(!isRunnerConfigKey(_0x2b6413))return{'ok':![],'code':_0x596433(0x21e),'message':_0x2b6413+'\x20is\x20not\x20a\x20known\x20runner\x20setting\x20—\x20choose\x20one\x20from\x20the\x20runner-config\x20list.'};}else{if(!isExternalVarName(_0x2b6413))return{'ok':![],'code':_0x596433(_0x4d5793._0x87a192),'message':_0x2b6413+_0x596433(0x1d1)};}const _0x2fd184=envKeys(_0xd7896d[_0x596433(0x1f2)])['has'](_0x2b6413),_0x32bf83=envKeys(_0xd7896d['secretsContent'])[_0x596433(0x20f)](_0x2b6413),_0x6402d4=_0x774431===_0x596433(_0x4d5793._0x2a045e)?_0x596433(_0x4d5793._0xcc073d):_0x596433(0x191),_0x52e210=_0x6402d4===_0x596433(_0x4d5793._0x3df0af)?_0x32bf83:_0x2fd184,_0x2768d2=_0x6402d4===_0x596433(0x1a5)?'unotest/.secrets':_0x596433(0x1d0);if(_0x52e210)return{'ok':![],'code':_0x596433(0x246),'message':_0x2b6413+_0x596433(_0x4d5793._0x5900fd)+_0x2768d2+_0x596433(0x231)};const _0x5e04cf=[];return _0x774431===_0x596433(0x1df)&&_0x2fd184&&_0x5e04cf[_0x596433(0x233)](_0x2b6413+_0x596433(_0x4d5793._0x58f6b2)),_0x774431!==_0x596433(_0x4d5793._0x1ee364)&&_0x32bf83&&_0x5e04cf[_0x596433(0x233)](_0x2b6413+_0x596433(0x1e6)),{'ok':!![],'target':_0x6402d4,'sectionLabel':SECTION_BY_KIND[_0x774431],'warnings':_0x5e04cf};}__name(planAddVariable,_0x116ffa(0x1ef));function deleteShadowWarning(_0x14ad7d,_0x23b25c,_0x5c4f6e){const _0x5eaed5=_0x116ffa;if(_0x5c4f6e!==void 0x0&&_0x5c4f6e!==_0x23b25c)return[_0x14ad7d+_0x5eaed5(0x1b2)];return[];}__name(deleteShadowWarning,_0x116ffa(0x1ed));var TERMINAL_RUNTIME_STATES=[_0x116ffa(0x237),_0x116ffa(0x19d),_0x116ffa(0x1cb)];function isTerminalRuntimeState(_0x5ddc48){return TERMINAL_RUNTIME_STATES['includes'](_0x5ddc48);}__name(isTerminalRuntimeState,_0x116ffa(0x1a2));var JUDGE_ROUTES={'judge':_0x116ffa(0x24c),'health':'/health'},JUDGE_ENV={'mode':'UNOTEST_JUDGE_MODE','url':_0x116ffa(0x20e),'token':_0x116ffa(0x243),'requestTimeoutMs':_0x116ffa(0x202),'preamble':'UNOTEST_JUDGE_PREAMBLE','provider':'UNOTEST_JUDGE_PROVIDER','model':_0x116ffa(0x240),'callTimeoutMs':'UNOTEST_JUDGE_CALL_TIMEOUT_MS','retries':_0x116ffa(0x19f),'vote':_0x116ffa(0x1f1),'accessToken':_0x116ffa(0x223),'claudeBin':_0x116ffa(0x1b6),'host':'UNOTEST_JUDGE_HOST','port':_0x116ffa(0x195)};export{BLOBS_DIR,COLLECTIONS_SUBDIR,COLLECTION_NAME_FORBIDDEN_RE,COMMANDS_FILE,DAY_INDEX_FILE,E2E_SUBDIR,ENV_FILE,EXPECT_FAIL_ANNOTATION,HEARTBEAT_FILE,HELPERS_SUBDIR,InvalidBlobHashError,JUDGE_ENV,JUDGE_ROUTES,LOCK_FILE,LOG_FILE,PICKER_SNAPSHOT_FILE,RUNNER_CONFIG_KEYS,RUNS_SUBDIR,RUNTIME_FILE,RUN_INDEX_SCHEMA_VERSION,RUN_MANIFEST_FILE,RUN_SOURCES_FILE,RunnerAdapterNotFoundError,RunnerNotConfiguredError,SCENARIOS_INDEX_DIR,SCENARIOS_LATEST_FILE,SCENARIO_RECENT_WINDOW,SECRETS_FILE,SEGMENT_NAME_FORBIDDEN_RE,SNAPSHOTS_SUBDIR,STDERR_FILE,STDOUT_FILE,STEPS_FILE,TERMINAL_RUNTIME_STATES,TERMINAL_WS_EVENT,UNOTEST_DIR,UnplaceableRunIdError,UnsupportedRunKindError,activeEnvName,blobPathFor,blobRelPathFor,blobRelSegmentsFor,blobsRootFor,categorizeVariable,debugDirFor,debuggerFileFor,deleteShadowWarning,envFileFor,envKeys,envLayerFilesFor,envNamesFromDirListing,foldScenarioRun,insertEnvVar,isAnnotationLine,isExternalVarName,isFailingStatus,isRegexLiteral,isRunnerConfigKey,isRunsDirName,isTerminalRuntimeState,makeRunId,parseAppServerEvent,parseEnvContent,parseScenarioAnnotations,planAddVariable,projectRunDirFor,projectRunsRoot,regexLiteral,removeEnvVar,requireRunDirFor,runDirFor,runIdStartedAt,runsDirFor,sanitizeRunIdSegment,scenarioIndexFileName,scenarioRefFromFileName,secretsFileFor,secretsLayerFilesFor,serializeEnvValue,shardDaysDescending,shardDirFor,shardPathForRunId,shardPathForTimestamp,testDirFor,validateCollectionName,validateSegmentName};
+const _0x705370=_0x4252;(function(_0x54fd00,_0x1b09a1){const _0x2fd5a8={_0x193be1:0x157,_0x1532e5:0x17a,_0x2edd52:0x10a,_0x337238:0x127,_0x1bc460:0x10e,_0x175a6f:0x114,_0x19be48:0x1a5,_0x563692:0x12b},_0x2bdb0e=_0x4252,_0x577da5=_0x54fd00();while(!![]){try{const _0x142552=parseInt(_0x2bdb0e(_0x2fd5a8._0x193be1))/0x1*(-parseInt(_0x2bdb0e(_0x2fd5a8._0x1532e5))/0x2)+-parseInt(_0x2bdb0e(0x1ae))/0x3*(parseInt(_0x2bdb0e(_0x2fd5a8._0x2edd52))/0x4)+-parseInt(_0x2bdb0e(0x186))/0x5*(parseInt(_0x2bdb0e(0x103))/0x6)+parseInt(_0x2bdb0e(_0x2fd5a8._0x337238))/0x7*(parseInt(_0x2bdb0e(0xd0))/0x8)+parseInt(_0x2bdb0e(_0x2fd5a8._0x1bc460))/0x9*(parseInt(_0x2bdb0e(_0x2fd5a8._0x175a6f))/0xa)+-parseInt(_0x2bdb0e(_0x2fd5a8._0x19be48))/0xb*(-parseInt(_0x2bdb0e(_0x2fd5a8._0x563692))/0xc)+parseInt(_0x2bdb0e(0x19f))/0xd*(-parseInt(_0x2bdb0e(0xc8))/0xe);if(_0x142552===_0x1b09a1)break;else _0x577da5['push'](_0x577da5['shift']());}catch(_0x233444){_0x577da5['push'](_0x577da5['shift']());}}}(_0x2c65,0x4b807));var __defProp=Object[_0x705370(0xfa)],__name=(_0x1eca7d,_0x565f78)=>__defProp(_0x1eca7d,_0x705370(0xdd),{'value':_0x565f78,'configurable':!![]});function parseAppServerEvent(_0x454b09){const _0x4e2dd2={_0x50f617:0x116},_0x17cf14=_0x705370,_0x2dedc7=_0x454b09[_0x17cf14(0xdc)]();if(!_0x2dedc7['startsWith']('{'))return null;try{const _0x3c9c4f=JSON['parse'](_0x2dedc7);if(_0x3c9c4f[_0x17cf14(0x116)]==='app-server:ready'||_0x3c9c4f[_0x17cf14(0x116)]===_0x17cf14(0x14c)||_0x3c9c4f[_0x17cf14(_0x4e2dd2._0x50f617)]===_0x17cf14(0x13f))return _0x3c9c4f;return null;}catch{return null;}}__name(parseAppServerEvent,_0x705370(0x101));function isRecord(_0x11a723){const _0x5912d3=_0x705370;return typeof _0x11a723===_0x5912d3(0xc0)&&_0x11a723!==null&&!Array[_0x5912d3(0x18f)](_0x11a723);}__name(isRecord,_0x705370(0xff));var UNOTEST_DIR=_0x705370(0x18d),E2E_SUBDIR='e2e',HELPERS_SUBDIR='_helpers',COLLECTIONS_SUBDIR=_0x705370(0x174),RUNS_SUBDIR=_0x705370(0xe0),SNAPSHOTS_SUBDIR=_0x705370(0xf1);function testDirFor(_0x3850c5){return''+E2E_SUBDIR+_0x3850c5;}__name(testDirFor,'testDirFor');function runsDirFor(_0x2cf097,_0x182864){return''+RUNS_SUBDIR+_0x2cf097+(_0x182864?'.'+_0x182864:'');}__name(runsDirFor,'runsDirFor');function isRunsDirName(_0x5de615){const _0x411e87=_0x705370;return _0x5de615===RUNS_SUBDIR||_0x5de615[_0x411e87(0x145)](RUNS_SUBDIR+'-')||_0x5de615['startsWith'](RUNS_SUBDIR+'.');}__name(isRunsDirName,_0x705370(0x185));function debugDirFor(_0x1ca785){return'.debug'+_0x1ca785;}__name(debugDirFor,_0x705370(0x105));function debuggerFileFor(_0x2ed65e){const _0x3c7a1f=_0x705370;return UNOTEST_DIR+_0x3c7a1f(0x190)+_0x2ed65e+_0x3c7a1f(0x11f);}__name(debuggerFileFor,_0x705370(0x191));var LOCK_FILE=_0x705370(0xe5),LOG_FILE=_0x705370(0xfc),STEPS_FILE=_0x705370(0x171),HEARTBEAT_FILE=_0x705370(0x173),DAY_INDEX_FILE=_0x705370(0xeb),SCENARIOS_INDEX_DIR='_scenarios',SCENARIOS_LATEST_FILE=_0x705370(0xd6),STDOUT_FILE=_0x705370(0x15a),STDERR_FILE='stderr.log',COMMANDS_FILE=_0x705370(0xda),RUNTIME_FILE=_0x705370(0x1af),PICKER_SNAPSHOT_FILE=_0x705370(0xef),ENV_FILE=_0x705370(0x112),SECRETS_FILE=_0x705370(0x136);function envFileFor(_0x5b69f1,_0x42f12f){return''+ENV_FILE+_0x5b69f1+(_0x42f12f?'.'+_0x42f12f:'');}__name(envFileFor,_0x705370(0x153));function secretsFileFor(_0x181c56,_0x3e00d6){return''+SECRETS_FILE+_0x181c56+(_0x3e00d6?'.'+_0x3e00d6:'');}__name(secretsFileFor,'secretsFileFor');function envLayerFilesFor(_0x51ec87,_0x433e3a){return layersFor(ENV_FILE,_0x51ec87,_0x433e3a);}__name(envLayerFilesFor,_0x705370(0xee));function secretsLayerFilesFor(_0x40b852,_0xb9d860){return layersFor(SECRETS_FILE,_0x40b852,_0xb9d860);}__name(secretsLayerFilesFor,'secretsLayerFilesFor');function layersFor(_0x370fd9,_0x59c9b5,_0x7ca320){const _0x467912={_0x379597:0x130},_0x565662=_0x705370,_0x4e4e1b=[_0x370fd9];if(_0x59c9b5)_0x4e4e1b['push'](''+_0x370fd9+_0x59c9b5);if(_0x7ca320){_0x4e4e1b['push'](_0x370fd9+'.'+_0x7ca320);if(_0x59c9b5)_0x4e4e1b[_0x565662(_0x467912._0x379597)](''+_0x370fd9+_0x59c9b5+'.'+_0x7ca320);}return _0x4e4e1b;}__name(layersFor,_0x705370(0x1b5));var ARTIFACTS_ROOT_ENV='UNOTEST_ARTIFACTS_ROOT';function artifactsRootFrom(_0x20ee75,_0x5096ee){const _0x486dd3=_0x20ee75[ARTIFACTS_ROOT_ENV]?.['trim']();return _0x486dd3?_0x486dd3:_0x5096ee;}__name(artifactsRootFrom,_0x705370(0x199));function activeEnvName(_0x2b5d16){const _0x54f386={_0x42d4b9:0xdc},_0x5e7ee6=_0x705370,_0x3a10cd=_0x2b5d16[_0x5e7ee6(0x133)]?.[_0x5e7ee6(_0x54f386._0x42d4b9)]();return _0x3a10cd?_0x3a10cd:void 0x0;}__name(activeEnvName,_0x705370(0x187));var RESERVED_ENV_NAMES=new Set(['example','sample',_0x705370(0x178)]);function envNamesFromDirListing(_0x27e696,_0x1f38d6){const _0x2d572f={_0x11ce8:0xf3,_0x2c6df1:0x145,_0x2e5226:0x1b9,_0x370aa9:0x131,_0x5efd86:0x17e},_0x4a395d=_0x705370,_0xcbc4ea=[_0x4a395d(_0x2d572f._0x11ce8),_0x4a395d(0x14e)]['flatMap'](_0x3c153f=>_0x1f38d6?[_0x3c153f,''+_0x3c153f+_0x1f38d6]:[_0x3c153f]),_0x10edc3=new Set();for(const _0xae6d17 of _0x27e696){for(const _0x3a58c1 of _0xcbc4ea){const _0x376a9d=_0x3a58c1+'.';if(!_0xae6d17[_0x4a395d(_0x2d572f._0x2c6df1)](_0x376a9d))continue;const _0x2d8c8a=_0xae6d17[_0x4a395d(_0x2d572f._0x2e5226)](_0x376a9d[_0x4a395d(_0x2d572f._0x370aa9)]);if(!_0x2d8c8a||_0x2d8c8a['includes']('/'))continue;if(RESERVED_ENV_NAMES[_0x4a395d(_0x2d572f._0x5efd86)](_0x2d8c8a))continue;_0x10edc3[_0x4a395d(0x166)](_0x2d8c8a);}}return[..._0x10edc3]['sort']();}__name(envNamesFromDirListing,_0x705370(0x19d));function isRegexLiteral(_0x10a5d3){const _0x46e4f4={_0x8a40e7:0x116,_0x34035d:0x162,_0x4f8e21:0x14b,_0x2e979f:0x15b},_0x276f26=_0x705370;return typeof _0x10a5d3===_0x276f26(0xc0)&&_0x10a5d3!==null&&_0x10a5d3[_0x276f26(_0x46e4f4._0x8a40e7)]===_0x276f26(_0x46e4f4._0x34035d)&&typeof _0x10a5d3[_0x276f26(_0x46e4f4._0x4f8e21)]===_0x276f26(_0x46e4f4._0x2e979f)&&typeof _0x10a5d3[_0x276f26(0x12c)]==='string';}function _0x4252(_0x33b801,_0x2fe28b){_0x33b801=_0x33b801-0xc0;const _0x2c65a9=_0x2c65();let _0x4252f4=_0x2c65a9[_0x33b801];if(_0x4252['EwHWNv']===undefined){var _0x31bf7f=function(_0x5a4f8d){const _0x53c709='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/=';let _0x1eca7d='',_0x565f78='';for(let _0x454b09=0x0,_0x2dedc7,_0x3c9c4f,_0x11a723=0x0;_0x3c9c4f=_0x5a4f8d['charAt'](_0x11a723++);~_0x3c9c4f&&(_0x2dedc7=_0x454b09%0x4?_0x2dedc7*0x40+_0x3c9c4f:_0x3c9c4f,_0x454b09++%0x4)?_0x1eca7d+=String['fromCharCode'](0xff&_0x2dedc7>>(-0x2*_0x454b09&0x6)):0x0){_0x3c9c4f=_0x53c709['indexOf'](_0x3c9c4f);}for(let _0x3850c5=0x0,_0x2cf097=_0x1eca7d['length'];_0x3850c5<_0x2cf097;_0x3850c5++){_0x565f78+='%'+('00'+_0x1eca7d['charCodeAt'](_0x3850c5)['toString'](0x10))['slice'](-0x2);}return decodeURIComponent(_0x565f78);};_0x4252['YfqTFj']=_0x31bf7f,_0x4252['hWsJQd']={},_0x4252['EwHWNv']=!![];}const _0x32fe32=_0x2c65a9[0x0],_0x347854=_0x33b801+_0x32fe32,_0x22f3c3=_0x4252['hWsJQd'][_0x347854];return!_0x22f3c3?(_0x4252f4=_0x4252['YfqTFj'](_0x4252f4),_0x4252['hWsJQd'][_0x347854]=_0x4252f4):_0x4252f4=_0x22f3c3,_0x4252f4;}__name(isRegexLiteral,'isRegexLiteral');function regexLiteral(_0x34d369,_0x5efe34=''){const _0x5808a1={_0x418bef:0x162},_0xc304f4=_0x705370;return{'kind':_0xc304f4(_0x5808a1._0x418bef),'source':_0x34d369,'flags':_0x5efe34};}__name(regexLiteral,_0x705370(0xce));var RAND_BYTES=0x6;function makeRunId(_0x20712f){const _0x6084d6={_0x409c6c:0x142,_0x38fb42:0x104},_0x3304a3=_0x705370,_0x255f5e=sanitizeRunIdSegment(_0x20712f),_0xf10482=Date[_0x3304a3(_0x6084d6._0x409c6c)]()['toString'](0x24),_0xc2c4a0=new Uint8Array(RAND_BYTES);globalThis[_0x3304a3(0x1b7)][_0x3304a3(0xe2)](_0xc2c4a0);let _0x135faa='';for(let _0xcdae8=0x0;_0xcdae8<_0xc2c4a0['length'];_0xcdae8++){_0x135faa+=_0xc2c4a0[_0xcdae8][_0x3304a3(_0x6084d6._0x38fb42)](0x10)['padStart'](0x2,'0');}return _0x255f5e+'-'+_0xf10482+'-'+_0x135faa;}__name(makeRunId,_0x705370(0x129));function sanitizeRunIdSegment(_0x399820){const _0x21248b={_0x9df7be:0x15f},_0x54c42d=_0x705370,_0x4eecde=_0x399820[_0x54c42d(_0x21248b._0x9df7be)](/[^a-zA-Z0-9_-]+/g,'-')[_0x54c42d(0x15f)](/-+/g,'-')['replace'](/^-|-$/g,'');return _0x4eecde[_0x54c42d(0x131)]>0x0?_0x4eecde:_0x54c42d(0x195);}__name(sanitizeRunIdSegment,'sanitizeRunIdSegment');var RANDOM_SUFFIX_RE=/^[0-9a-f]{6,}$/,MIN_PLAUSIBLE_MS=Date[_0x705370(0xca)](0x7e4,0x0,0x1),MAX_PLAUSIBLE_MS=Date[_0x705370(0xca)](0x834,0x0,0x1);function runIdStartedAt(_0x5bc1cd){const _0x299610={_0x40ccf6:0xc9,_0x3a4c5d:0x131,_0x460899:0x1be,_0x5afe58:0x11b},_0x1ad23=_0x705370,_0x2a77e2=_0x5bc1cd[_0x1ad23(_0x299610._0x40ccf6)]('-');if(_0x2a77e2['length']<0x3)return null;const _0x2b1a74=_0x2a77e2[_0x2a77e2[_0x1ad23(_0x299610._0x3a4c5d)]-0x1];if(!RANDOM_SUFFIX_RE[_0x1ad23(0x1be)](_0x2b1a74))return null;const _0x342796=_0x2a77e2[_0x2a77e2[_0x1ad23(0x131)]-0x2];if(!/^[0-9a-z]+$/[_0x1ad23(_0x299610._0x460899)](_0x342796))return null;const _0x5d4d5e=parseInt(_0x342796,0x24);if(!Number[_0x1ad23(_0x299610._0x5afe58)](_0x5d4d5e))return null;if(_0x5d4d5e<MIN_PLAUSIBLE_MS||_0x5d4d5e>=MAX_PLAUSIBLE_MS)return null;return _0x5d4d5e;}__name(runIdStartedAt,_0x705370(0x108));function shardPathForTimestamp(_0x133eb0){const _0x138a12={_0x14e349:0xfd,_0xf862d8:0x123,_0x24fa3c:0x16b},_0x2247d2=_0x705370,_0x26abb9=new Date(_0x133eb0),_0x134d8a=String(_0x26abb9[_0x2247d2(_0x138a12._0x14e349)]())[_0x2247d2(_0x138a12._0xf862d8)](0x4,'0'),_0x2f0f5c=String(_0x26abb9['getUTCMonth']()+0x1)[_0x2247d2(0x123)](0x2,'0'),_0x34ef05=String(_0x26abb9[_0x2247d2(_0x138a12._0x24fa3c)]())[_0x2247d2(_0x138a12._0xf862d8)](0x2,'0');return _0x134d8a+'/'+_0x2f0f5c+'/'+_0x34ef05;}__name(shardPathForTimestamp,_0x705370(0x17b));function shardPathForRunId(_0x2333b6){const _0x4db7bf=runIdStartedAt(_0x2333b6);return _0x4db7bf===null?null:shardPathForTimestamp(_0x4db7bf);}__name(shardPathForRunId,_0x705370(0xea));function runDirFor(_0x23679b,_0x1f9e61){const _0x27e64f=shardPathForRunId(_0x1f9e61);return _0x27e64f===null?null:_0x23679b+'/'+_0x27e64f+'/'+_0x1f9e61;}__name(runDirFor,'runDirFor');var UnplaceableRunIdError=class extends Error{static{__name(this,_0x705370(0x13a));}constructor(_0x1794cf){const _0x4dc26d={_0x116f9b:0x128,_0x338051:0x13a},_0x4ca739=_0x705370;super(_0x4ca739(_0x4dc26d._0x116f9b)+_0x1794cf),this['name']=_0x4ca739(_0x4dc26d._0x338051);}};function requireRunDirFor(_0x470059,_0x5a21b2){const _0x1b937e=runDirFor(_0x470059,_0x5a21b2);if(_0x1b937e===null)throw new UnplaceableRunIdError(_0x5a21b2);return _0x1b937e;}__name(requireRunDirFor,'requireRunDirFor');function projectRunsRoot(_0x260a60='',_0x61416){return UNOTEST_DIR+'/'+runsDirFor(_0x260a60,_0x61416);}__name(projectRunsRoot,'projectRunsRoot');function projectRunDirFor(_0x5e6f54,_0x3331ec='',_0x1736e4){return requireRunDirFor(projectRunsRoot(_0x3331ec,_0x1736e4),_0x5e6f54);}__name(projectRunDirFor,'projectRunDirFor');function shardDirFor(_0x54e960,_0x3c1027){return _0x54e960+'/'+shardPathForTimestamp(_0x3c1027);}__name(shardDirFor,'shardDirFor');function*shardDaysDescending(_0x191d2d,_0x461267,_0x44c0bd){const _0x955308={_0x4c1fcd:0xd9},_0x303784=_0x705370,_0x4d5921=0x5265c00;let _0x684954=Math[_0x303784(_0x955308._0x4c1fcd)](_0x461267/_0x4d5921)*_0x4d5921;for(let _0x499c9a=0x0;_0x499c9a<_0x44c0bd;_0x499c9a++){yield shardDirFor(_0x191d2d,_0x684954),_0x684954-=_0x4d5921;}}__name(shardDaysDescending,_0x705370(0x18c));var RUN_INDEX_SCHEMA_VERSION=0x2,SCENARIO_RECENT_WINDOW=0xc;function isFailingStatus(_0x2b17b4){const _0x51632e={_0x4f24ae:0x16c},_0x9d2f0a=_0x705370;return _0x2b17b4==='failed'||_0x2b17b4===_0x9d2f0a(_0x51632e._0x4f24ae);}__name(isFailingStatus,'isFailingStatus');function foldScenarioRun(_0x2d36df,_0x1f839c){const _0x514926={_0x401cba:0x148,_0x147b79:0x172,_0x205300:0x134,_0x3c2274:0x155,_0x3711a1:0x1b9,_0x464663:0x155,_0x5bb8b6:0xc4,_0x49ec1c:0x126},_0xe37255=_0x705370,_0x1da825={'lastRunId':_0x1f839c[_0xe37255(_0x514926._0x401cba)],'lastStatus':_0x1f839c[_0xe37255(0x155)],'lastAt':_0x1f839c[_0xe37255(_0x514926._0x147b79)],'lastDurationMs':_0x1f839c['durationMs'],'recent':[..._0x2d36df?.[_0xe37255(_0x514926._0x205300)]??[],_0x1f839c[_0xe37255(_0x514926._0x3c2274)]][_0xe37255(_0x514926._0x3711a1)](-SCENARIO_RECENT_WINDOW)};if(!isFailingStatus(_0x1f839c[_0xe37255(_0x514926._0x464663)]))return{..._0x1da825,'failStreak':0x0,'failingSince':null};const _0x325969=(_0x2d36df?.[_0xe37255(_0x514926._0x5bb8b6)]??0x0)+0x1;return{..._0x1da825,'failStreak':_0x325969,'failingSince':_0x325969===0x1?_0x1f839c[_0xe37255(0x172)]:_0x2d36df?.[_0xe37255(_0x514926._0x49ec1c)]??_0x1f839c[_0xe37255(0x172)]};}__name(foldScenarioRun,'foldScenarioRun');function scenarioIndexFileName(_0x1d0142){const _0x43d26e={_0x4157c3:0x159},_0x39c28f=_0x705370;return encodeURIComponent(_0x1d0142)+_0x39c28f(_0x43d26e._0x4157c3);}__name(scenarioIndexFileName,_0x705370(0x1a7));function scenarioRefFromFileName(_0x370f6c){const _0x4fd705={_0x5200c6:0x1a3,_0x1a5f54:0x159,_0x489c6f:0x1b9,_0x3681e7:0x131},_0x47bd48=_0x705370;if(!_0x370f6c[_0x47bd48(_0x4fd705._0x5200c6)](_0x47bd48(_0x4fd705._0x1a5f54)))return null;try{return decodeURIComponent(_0x370f6c[_0x47bd48(_0x4fd705._0x489c6f)](0x0,-_0x47bd48(0x159)[_0x47bd48(_0x4fd705._0x3681e7)]));}catch{return null;}}__name(scenarioRefFromFileName,_0x705370(0xed));var CI_RUN_PATH=_0x705370(0xe1),PROVIDER_IDS=[_0x705370(0xc7),'gitlab',_0x705370(0x1a2)],RUN_ERROR_CODES=['unauthorized',_0x705370(0x10f),_0x705370(0x181),_0x705370(0x1bf),_0x705370(0x18b),_0x705370(0x165),_0x705370(0xfe)];function parseCiRunRequest(_0x2e4d2b){const _0x592eef={_0x2fbb77:0x131,_0x10944d:0x131,_0x570a4f:0x18f,_0x1f96e8:0x15b,_0xc11240:0x15b,_0x2b7926:0x15b},_0x350ecf=_0x705370;if(!isRecord(_0x2e4d2b))return null;const {bundleId:_0x43b57c,environment:_0x301c97,collections:_0x32c751,pr:_0xad2bfc,branch:_0x1a6ba0,sha:_0x1acfb3}=_0x2e4d2b;if(typeof _0x43b57c!==_0x350ecf(0x15b)||_0x43b57c[_0x350ecf(_0x592eef._0x2fbb77)]===0x0)return null;if(typeof _0x301c97!==_0x350ecf(0x15b)||_0x301c97[_0x350ecf(_0x592eef._0x10944d)]===0x0)return null;let _0x5a0234=null;if(_0x32c751!==void 0x0){if(!Array[_0x350ecf(_0x592eef._0x570a4f)](_0x32c751))return null;if(_0x32c751[_0x350ecf(0xf7)](_0x13bc4b=>typeof _0x13bc4b!=='string'||_0x13bc4b['length']===0x0))return null;_0x5a0234=_0x32c751;}if(_0xad2bfc!==void 0x0&&(typeof _0xad2bfc!=='number'||!Number[_0x350ecf(0x13d)](_0xad2bfc)))return null;for(const _0x404fab of[_0x1a6ba0,_0x1acfb3]){if(_0x404fab!==void 0x0&&typeof _0x404fab!==_0x350ecf(_0x592eef._0x1f96e8))return null;}return{'bundleId':_0x43b57c,'environment':_0x301c97,..._0x5a0234?{'collections':_0x5a0234}:{},...typeof _0xad2bfc===_0x350ecf(0x1b2)?{'pr':_0xad2bfc}:{},...typeof _0x1a6ba0===_0x350ecf(_0x592eef._0xc11240)?{'branch':_0x1a6ba0}:{},...typeof _0x1acfb3===_0x350ecf(_0x592eef._0x2b7926)?{'sha':_0x1acfb3}:{}};}__name(parseCiRunRequest,_0x705370(0x1ac));function parseCiRunResponse(_0x126527){const _0x400ae4={_0x159cfc:0x15b,_0x533a63:0x15c,_0x4175bc:0x130,_0x1363e4:0x1b2},_0x6fa91e=_0x705370;if(!isRecord(_0x126527))return null;if(isRecord(_0x126527['error'])){const {code:_0x59bb5b,message:_0x248427}=_0x126527[_0x6fa91e(0x111)];if(!RUN_ERROR_CODES['includes'](_0x59bb5b))return null;if(typeof _0x248427!==_0x6fa91e(_0x400ae4._0x159cfc))return null;return{'error':{'code':_0x59bb5b,'message':_0x248427}};}const {status:_0x51e85e,bundleId:_0x4b89db,environment:_0x5063cc,runs:_0x59106c,superseded:_0x3cbb1c}=_0x126527;if(_0x51e85e!==_0x6fa91e(_0x400ae4._0x533a63))return null;if(typeof _0x4b89db!==_0x6fa91e(0x15b)||typeof _0x5063cc!==_0x6fa91e(0x15b))return null;if(!Array[_0x6fa91e(0x18f)](_0x59106c))return null;const _0x27b151=[];for(const _0x557780 of _0x59106c){if(!isRecord(_0x557780))return null;const {runId:_0x38a58d,collection:_0x4262ee}=_0x557780;if(typeof _0x38a58d!==_0x6fa91e(0x15b)||typeof _0x4262ee!==_0x6fa91e(_0x400ae4._0x159cfc))return null;_0x27b151[_0x6fa91e(_0x400ae4._0x4175bc)]({'runId':_0x38a58d,'collection':_0x4262ee});}if(_0x3cbb1c!==void 0x0&&typeof _0x3cbb1c!==_0x6fa91e(_0x400ae4._0x1363e4))return null;return{'status':_0x6fa91e(0x15c),'bundleId':_0x4b89db,'environment':_0x5063cc,'runs':_0x27b151,...typeof _0x3cbb1c==='number'?{'superseded':_0x3cbb1c}:{}};}__name(parseCiRunResponse,_0x705370(0xf2));function parseCiProvider(_0x40e25b){return PROVIDER_IDS['includes'](_0x40e25b)?_0x40e25b:null;}__name(parseCiProvider,_0x705370(0x132));var QUEUE_SUBDIR=_0x705370(0x198),QUEUE_TICKETS_DIR='tickets',QUEUE_RUNNING_DIR=_0x705370(0x13e),QUEUE_SLOTS_DIR=_0x705370(0xd5),QUEUE_MUTEX_FILE='.mutex',QUEUE_LEASE_ENV=_0x705370(0x15e),QUEUE_DISABLED_ENV=_0x705370(0x182),QUEUE_GLOBAL_DIR_ENV='UNOTEST_QUEUE_GLOBAL_DIR',QUEUE_GLOBAL_SLOTS_ENV=_0x705370(0xf4),QUEUE_SCHEMA_VERSION=0x1;function queueDirFor(_0x2e3b97,_0x2952cf){return''+QUEUE_SUBDIR+_0x2e3b97+(_0x2952cf?'.'+_0x2952cf:'');}__name(queueDirFor,_0x705370(0x146));function isQueueDirName(_0x458d96){const _0x4fcb7c=_0x705370;return _0x458d96===QUEUE_SUBDIR||_0x458d96[_0x4fcb7c(0x145)](QUEUE_SUBDIR+'-')||_0x458d96[_0x4fcb7c(0x145)](QUEUE_SUBDIR+'.');}__name(isQueueDirName,_0x705370(0xe3));function projectQueueRoot(_0x4d6507='',_0xdc9500){return UNOTEST_DIR+'/'+queueDirFor(_0x4d6507,_0xdc9500);}__name(projectQueueRoot,_0x705370(0x1b8));var PRIORITY_RANKS=Object[_0x705370(0xe7)]({'maintenance':0x0,'interactive':0x1,'ci':0x2,'schedule':0x3}),RANK_PRIORITIES=[_0x705370(0xc1),'interactive','ci','schedule'],QUEUE_PRIORITIES=RANK_PRIORITIES;function queuePriorityRank(_0x102cff){return PRIORITY_RANKS[_0x102cff];}__name(queuePriorityRank,_0x705370(0x14f));function queuePriorityFromRank(_0x274972){return RANK_PRIORITIES[_0x274972]??null;}__name(queuePriorityFromRank,_0x705370(0x170));function describeTicketCi(_0x1c8302){const _0x10d6db={_0x4e76fc:0x11d,_0x48ccbc:0x1b9,_0x73a244:0xcc},_0x5c25aa=_0x705370,_0x10d889=_0x1c8302[_0x5c25aa(0x11d)]?'@'+_0x1c8302[_0x5c25aa(_0x10d6db._0x4e76fc)][_0x5c25aa(_0x10d6db._0x48ccbc)](0x0,0x7):'';if(_0x1c8302['pr']!==void 0x0)return _0x5c25aa(0x1b4)+_0x1c8302['pr']+_0x10d889;if(_0x1c8302[_0x5c25aa(0xd2)]!==void 0x0)return''+_0x1c8302[_0x5c25aa(0xd2)]+_0x10d889;return _0x10d889[_0x5c25aa(0x131)]>0x0?_0x10d889[_0x5c25aa(0x1b9)](0x1):_0x1c8302[_0x5c25aa(_0x10d6db._0x73a244)];}__name(describeTicketCi,_0x705370(0x118));function makeQueueTicketName(_0x5316aa,_0x4bf8fe,_0x34582e){const _0x1482f0=_0x705370;return queuePriorityRank(_0x5316aa)+'-'+_0x4bf8fe['toString'](0x24)+'-'+_0x34582e+_0x1482f0(0x11f);}__name(makeQueueTicketName,'makeQueueTicketName');var TICKET_NAME_RE=/^([0-3])-([0-9a-z]+)-([0-9a-f]+)\.json$/;function parseQueueTicketName(_0x279854){const _0x4355b6={_0x412865:0x156},_0x3dab62=_0x705370,_0x4b3c93=TICKET_NAME_RE[_0x3dab62(_0x4355b6._0x412865)](_0x279854);if(!_0x4b3c93)return null;const _0x3b3b17=Number(_0x4b3c93[0x1]),_0x6354b7=queuePriorityFromRank(_0x3b3b17);if(_0x6354b7===null)return null;const _0x459fce=parseInt(_0x4b3c93[0x2],0x24);if(!Number[_0x3dab62(0x11b)](_0x459fce))return null;return{'rank':_0x3b3b17,'priority':_0x6354b7,'createdAt':_0x459fce,'random':_0x4b3c93[0x3]};}__name(parseQueueTicketName,_0x705370(0x109));function compareQueueTicketNames(_0x485e89,_0x328000){const _0x382b2d={_0x2eab77:0x11e,_0x20a92a:0x161},_0x318acb=_0x705370,_0x4bd624=parseQueueTicketName(_0x485e89),_0x390a52=parseQueueTicketName(_0x328000);if(!_0x4bd624||!_0x390a52)return _0x485e89<_0x328000?-0x1:_0x485e89>_0x328000?0x1:0x0;if(_0x4bd624[_0x318acb(_0x382b2d._0x2eab77)]!==_0x390a52[_0x318acb(0x11e)])return _0x4bd624['rank']-_0x390a52[_0x318acb(_0x382b2d._0x2eab77)];if(_0x4bd624['createdAt']!==_0x390a52[_0x318acb(_0x382b2d._0x20a92a)])return _0x4bd624['createdAt']-_0x390a52[_0x318acb(_0x382b2d._0x20a92a)];return _0x4bd624[_0x318acb(0x19a)]<_0x390a52['random']?-0x1:_0x4bd624['random']>_0x390a52[_0x318acb(0x19a)]?0x1:0x0;}__name(compareQueueTicketNames,_0x705370(0x106));var TICKET_KINDS=[_0x705370(0x12a),_0x705370(0x167),_0x705370(0xe4),_0x705370(0xc1)],PRODUCER_KINDS=['cli',_0x705370(0x15d),_0x705370(0x110),_0x705370(0x1ab),'ci'];function parseQueueTicket(_0x32bfc2){const _0x181a74={_0x4ded68:0x15b,_0x23d8f6:0xcb,_0x41ba1f:0x1b2,_0x5dfa10:0x11b,_0x94dd76:0xcb,_0x958597:0x116,_0x35c064:0x1c0,_0x221e3c:0x1b2,_0x4ed5dd:0x13b,_0x1f10c5:0x131},_0x2dedfa=_0x705370;if(!isRecord(_0x32bfc2))return null;const {schemaVersion:_0xf8d739,runId:_0x35d8b2,kind:_0x523033,ref:_0x2c9cda,env:_0x2f8e3f,priority:_0x5afb57,weight:_0x4da27c,producer:_0x31f2f5,source:_0x5315c4,ci:_0x902b08,createdAt:_0x171f28}=_0x32bfc2;if(_0xf8d739!==QUEUE_SCHEMA_VERSION)return null;if(typeof _0x35d8b2!==_0x2dedfa(0x15b)||_0x35d8b2[_0x2dedfa(0x131)]===0x0)return null;if(typeof _0x2c9cda!==_0x2dedfa(_0x181a74._0x4ded68))return null;if(!TICKET_KINDS[_0x2dedfa(0xcb)](_0x523033))return null;if(!QUEUE_PRIORITIES[_0x2dedfa(_0x181a74._0x23d8f6)](_0x5afb57))return null;if(typeof _0x4da27c!==_0x2dedfa(_0x181a74._0x41ba1f)||!Number[_0x2dedfa(_0x181a74._0x5dfa10)](_0x4da27c)||_0x4da27c<0x1)return null;if(typeof _0x171f28!=='number'||!Number[_0x2dedfa(_0x181a74._0x5dfa10)](_0x171f28))return null;if(!isRecord(_0x31f2f5))return null;if(!PRODUCER_KINDS[_0x2dedfa(_0x181a74._0x94dd76)](_0x31f2f5[_0x2dedfa(_0x181a74._0x958597)]))return null;if(typeof _0x31f2f5[_0x2dedfa(_0x181a74._0x35c064)]!==_0x2dedfa(_0x181a74._0x221e3c)||typeof _0x31f2f5[_0x2dedfa(0x1a4)]!=='string')return null;if(_0x2f8e3f!==void 0x0&&typeof _0x2f8e3f!==_0x2dedfa(0x15b))return null;let _0x44f46b=null;if(_0x5315c4!==void 0x0){if(!isRecord(_0x5315c4)||typeof _0x5315c4[_0x2dedfa(_0x181a74._0x4ed5dd)]!==_0x2dedfa(0x15b)||_0x5315c4['bundleId'][_0x2dedfa(_0x181a74._0x1f10c5)]===0x0)return null;_0x44f46b={'bundleId':_0x5315c4[_0x2dedfa(0x13b)]};}let _0x573e46=null;if(_0x902b08!==void 0x0){_0x573e46=parseTicketCi(_0x902b08);if(_0x573e46===null)return null;}return{'schemaVersion':QUEUE_SCHEMA_VERSION,'runId':_0x35d8b2,'kind':_0x523033,'ref':_0x2c9cda,'priority':_0x5afb57,'weight':_0x4da27c,'producer':{'kind':_0x31f2f5['kind'],'pid':_0x31f2f5[_0x2dedfa(0x1c0)],'host':_0x31f2f5[_0x2dedfa(0x1a4)]},'createdAt':_0x171f28,...typeof _0x2f8e3f===_0x2dedfa(0x15b)?{'env':_0x2f8e3f}:{},..._0x44f46b?{'source':_0x44f46b}:{},..._0x573e46?{'ci':_0x573e46}:{}};}__name(parseQueueTicket,_0x705370(0x10d));function parseTicketCi(_0x10c148){const _0x133c23={_0x206a08:0x1b2,_0x3be618:0x15b,_0x21d58a:0x15b},_0x3a0eae=_0x705370;if(!isRecord(_0x10c148))return null;const _0x5888ae=parseCiProvider(_0x10c148['provider']);if(_0x5888ae===null)return null;const {repo:_0xd748aa,branch:_0x3ff8f0,sha:_0x1dfe1c,pr:_0x512326,checkId:_0xcf46a7}=_0x10c148;for(const _0x506ab3 of[_0xd748aa,_0x3ff8f0,_0x1dfe1c,_0xcf46a7]){if(_0x506ab3!==void 0x0&&typeof _0x506ab3!=='string')return null;}if(_0x512326!==void 0x0&&(typeof _0x512326!==_0x3a0eae(_0x133c23._0x206a08)||!Number[_0x3a0eae(0x13d)](_0x512326)))return null;return{'provider':_0x5888ae,...typeof _0xd748aa===_0x3a0eae(_0x133c23._0x3be618)?{'repo':_0xd748aa}:{},...typeof _0x3ff8f0===_0x3a0eae(0x15b)?{'branch':_0x3ff8f0}:{},...typeof _0x1dfe1c===_0x3a0eae(_0x133c23._0x21d58a)?{'sha':_0x1dfe1c}:{},...typeof _0x512326==='number'?{'pr':_0x512326}:{},...typeof _0xcf46a7==='string'?{'checkId':_0xcf46a7}:{}};}__name(parseTicketCi,_0x705370(0x1b1));var BUNDLE_SCHEMA_VERSION=0x1,BUNDLE_MANIFEST_FILE=_0x705370(0xcd),BUNDLE_UPLOAD_PATH=_0x705370(0xc3),BOX_URL_ENV='UNOTEST_BOX_URL',BOX_TOKEN_ENV=_0x705370(0x160),BUNDLE_ID_ENV=_0x705370(0xd1);function parseGitInfo(_0x6f243d){const _0x5d6df3={_0x514c3f:0x15b},_0x1605b2=_0x705370;if(!isRecord(_0x6f243d))return null;const {repo:_0x53d321,branch:_0xdb4951,sha:_0x135689,dirty:_0x1e17a8}=_0x6f243d;if(typeof _0x1e17a8!=='boolean')return null;for(const _0x55c955 of[_0x53d321,_0xdb4951,_0x135689]){if(_0x55c955!==void 0x0&&typeof _0x55c955!==_0x1605b2(_0x5d6df3._0x514c3f))return null;}return{'dirty':_0x1e17a8,...typeof _0x53d321===_0x1605b2(_0x5d6df3._0x514c3f)?{'repo':_0x53d321}:{},...typeof _0xdb4951===_0x1605b2(0x15b)?{'branch':_0xdb4951}:{},...typeof _0x135689===_0x1605b2(0x15b)?{'sha':_0x135689}:{}};}__name(parseGitInfo,'parseGitInfo');function parseBundleManifest(_0x1a1a4c){const _0x334037={_0x4c4fdd:0x131,_0x33818b:0x11b,_0x36f78d:0x1b2,_0x5b1b6d:0x13d,_0x28ced8:0x15b},_0x468995=_0x705370;if(!isRecord(_0x1a1a4c))return null;const {schemaVersion:_0x373baf,bundleId:_0x1e4895,sha256:_0x47a05e,createdAt:_0x5232bf,webVersion:_0x2eecd2,author:_0x888d8a,git:_0x9b42eb,fileCount:_0x44777d,byteSize:_0x494d58}=_0x1a1a4c;if(_0x373baf!==BUNDLE_SCHEMA_VERSION)return null;if(typeof _0x1e4895!=='string'||_0x1e4895[_0x468995(_0x334037._0x4c4fdd)]===0x0)return null;if(_0x47a05e!==void 0x0&&!/^[0-9a-f]{64}$/['test'](String(_0x47a05e)))return null;if(typeof _0x2eecd2!==_0x468995(0x15b)||_0x2eecd2[_0x468995(_0x334037._0x4c4fdd)]===0x0)return null;if(typeof _0x5232bf!=='number'||!Number[_0x468995(_0x334037._0x33818b)](_0x5232bf))return null;if(typeof _0x44777d!==_0x468995(_0x334037._0x36f78d)||!Number[_0x468995(0x13d)](_0x44777d))return null;if(typeof _0x494d58!==_0x468995(_0x334037._0x36f78d)||!Number[_0x468995(_0x334037._0x5b1b6d)](_0x494d58))return null;if(_0x888d8a!==void 0x0&&typeof _0x888d8a!==_0x468995(0x15b))return null;let _0x5cf431=null;if(_0x9b42eb!==void 0x0){_0x5cf431=parseGitInfo(_0x9b42eb);if(_0x5cf431===null)return null;}return{'schemaVersion':BUNDLE_SCHEMA_VERSION,'bundleId':_0x1e4895,...typeof _0x47a05e===_0x468995(_0x334037._0x28ced8)?{'sha256':_0x47a05e}:{},'createdAt':_0x5232bf,'webVersion':_0x2eecd2,'fileCount':_0x44777d,'byteSize':_0x494d58,...typeof _0x888d8a===_0x468995(_0x334037._0x28ced8)?{'author':_0x888d8a}:{},..._0x5cf431?{'git':_0x5cf431}:{}};}__name(parseBundleManifest,'parseBundleManifest');function describeBundle(_0x3582be){const _0x3352a7={_0x515a11:0xd2,_0x587f74:0xc2},_0x53818c=_0x705370,_0x2114cd=_0x3582be['git'];if(!_0x2114cd||_0x2114cd['branch']===void 0x0&&_0x2114cd[_0x53818c(0x11d)]===void 0x0)return _0x3582be[_0x53818c(0x13b)];const _0xbdb994=_0x2114cd[_0x53818c(0x11d)]?_0x2114cd[_0x53818c(0x11d)][_0x53818c(0x1b9)](0x0,0x7):'?',_0x511eb6=_0x2114cd[_0x53818c(_0x3352a7._0x515a11)]??'?';return _0x511eb6+'@'+_0xbdb994+(_0x2114cd[_0x53818c(0x14d)]?_0x53818c(_0x3352a7._0x587f74):'');}__name(describeBundle,_0x705370(0x18e));var UPLOAD_ERROR_CODES=[_0x705370(0xfb),_0x705370(0x113),_0x705370(0x165),_0x705370(0xd3),_0x705370(0xd8),_0x705370(0x10f),_0x705370(0xfe)];function parseBundleUploadResponse(_0x327143){const _0x4dd155={_0x4e2678:0x111,_0x493217:0xcb,_0x5d38d2:0x15b,_0x5556ef:0x131},_0xefb2e1=_0x705370;if(!isRecord(_0x327143))return null;if(isRecord(_0x327143[_0xefb2e1(_0x4dd155._0x4e2678)])){const {code:_0x11dd2b,message:_0x12c100}=_0x327143['error'];if(!UPLOAD_ERROR_CODES[_0xefb2e1(_0x4dd155._0x493217)](_0x11dd2b))return null;if(typeof _0x12c100!=='string')return null;return{'error':{'code':_0x11dd2b,'message':_0x12c100}};}const {status:_0x8b337e,bundleId:_0x220f1e}=_0x327143;if(_0x8b337e!==_0xefb2e1(0x1a1)&&_0x8b337e!=='exists')return null;if(typeof _0x220f1e!==_0xefb2e1(_0x4dd155._0x5d38d2)||_0x220f1e[_0xefb2e1(_0x4dd155._0x5556ef)]===0x0)return null;return{'status':_0x8b337e,'bundleId':_0x220f1e};}__name(parseBundleUploadResponse,_0x705370(0xf0));var WORKSPACE_SCHEMA_VERSION=0x1,WORKSPACE_FILE='.workspace.json';function stringList(_0x361884){const _0x365f84={_0x4ce77c:0x18f,_0x18aa89:0xf7},_0xc269d5=_0x705370;if(!Array[_0xc269d5(_0x365f84._0x4ce77c)](_0x361884))return null;if(_0x361884[_0xc269d5(_0x365f84._0x18aa89)](_0x3356e9=>typeof _0x3356e9!==_0xc269d5(0x15b)))return null;return _0x361884;}__name(stringList,_0x705370(0x184));function parseBundle(_0x557cfc){const _0x4b2852={_0x13a608:0x131,_0x10eabb:0x15b,_0x1b621d:0x15b,_0x354399:0x15b},_0x53647e=_0x705370;if(!isRecord(_0x557cfc))return null;const {bundleId:_0x439833,label:_0x5de0ff,branch:_0x2d53bc,sha:_0x257f3c,dirty:_0x2bd647,author:_0x361b9c,createdAt:_0x1c58d8,webVersion:_0x5762cf}=_0x557cfc;if(typeof _0x439833!==_0x53647e(0x15b)||_0x439833[_0x53647e(_0x4b2852._0x13a608)]===0x0)return null;if(typeof _0x5de0ff!==_0x53647e(_0x4b2852._0x10eabb)||typeof _0x5762cf!==_0x53647e(_0x4b2852._0x1b621d))return null;if(typeof _0x2bd647!=='boolean')return null;if(typeof _0x1c58d8!==_0x53647e(0x1b2)||!Number[_0x53647e(0x11b)](_0x1c58d8))return null;for(const _0x4e47e9 of[_0x2d53bc,_0x257f3c,_0x361b9c]){if(_0x4e47e9!==void 0x0&&typeof _0x4e47e9!=='string')return null;}return{'bundleId':_0x439833,'label':_0x5de0ff,'dirty':_0x2bd647,'createdAt':_0x1c58d8,'webVersion':_0x5762cf,...typeof _0x2d53bc==='string'?{'branch':_0x2d53bc}:{},...typeof _0x257f3c===_0x53647e(_0x4b2852._0x354399)?{'sha':_0x257f3c}:{},...typeof _0x361b9c==='string'?{'author':_0x361b9c}:{}};}__name(parseBundle,_0x705370(0x1a6));function parseWorkspaceFile(_0x10d233){const _0x438007={_0x372c50:0x15b,_0x52500b:0x177,_0x4bbc26:0x18f,_0xdc9074:0x15b,_0x133e93:0x15b,_0x3ffc49:0x15b},_0x20d89c=_0x705370;if(!isRecord(_0x10d233))return null;if(_0x10d233[_0x20d89c(0x102)]!==WORKSPACE_SCHEMA_VERSION)return null;const {workspace:_0x22efaf,environment:_0x180753,allowSwitch:_0x30c1c1,currentBundleId:_0x37538d,switchedBy:_0x28422d,switchedAt:_0x486a84,bundles:_0x50b531,variables:_0x2bcf43,secrets:_0x566b05,switchPath:_0xaf5752}=_0x10d233;if(typeof _0x22efaf!==_0x20d89c(0x15b)||typeof _0x180753!==_0x20d89c(_0x438007._0x372c50))return null;if(typeof _0x30c1c1!==_0x20d89c(_0x438007._0x52500b))return null;if(!Array[_0x20d89c(_0x438007._0x4bbc26)](_0x50b531))return null;const _0x47e59e=[];for(const _0x229a07 of _0x50b531){const _0x3e2954=parseBundle(_0x229a07);if(!_0x3e2954)return null;_0x47e59e[_0x20d89c(0x130)](_0x3e2954);}const _0xf21b60=stringList(_0x2bcf43),_0x20beff=stringList(_0x566b05);if(!_0xf21b60||!_0x20beff)return null;for(const _0x261e5a of[_0x37538d,_0x28422d,_0xaf5752]){if(_0x261e5a!==void 0x0&&typeof _0x261e5a!==_0x20d89c(_0x438007._0xdc9074))return null;}if(_0x486a84!==void 0x0&&typeof _0x486a84!==_0x20d89c(0x1b2))return null;return{'schemaVersion':WORKSPACE_SCHEMA_VERSION,'workspace':_0x22efaf,'environment':_0x180753,'allowSwitch':_0x30c1c1,'bundles':_0x47e59e,'variables':_0xf21b60,'secrets':_0x20beff,...typeof _0x37538d===_0x20d89c(_0x438007._0x133e93)?{'currentBundleId':_0x37538d}:{},...typeof _0x28422d===_0x20d89c(_0x438007._0x3ffc49)?{'switchedBy':_0x28422d}:{},...typeof _0x486a84===_0x20d89c(0x1b2)?{'switchedAt':_0x486a84}:{},...typeof _0xaf5752==='string'?{'switchPath':_0xaf5752}:{}};}__name(parseWorkspaceFile,_0x705370(0x1b3));function parseScheduleEntry(_0x5e73cc){const _0x4080c7={_0x3123f1:0x131,_0x1e3f02:0x15b,_0xe6d065:0x1b2},_0x24c09b=_0x705370;if(!isRecord(_0x5e73cc))return null;const {collection:_0x417978,cron:_0x56b371,env:_0x1cd817,prepare:_0x1774bb,workers:_0x393337}=_0x5e73cc;if(typeof _0x417978!=='string'||_0x417978[_0x24c09b(_0x4080c7._0x3123f1)]===0x0)return null;if(typeof _0x56b371!==_0x24c09b(_0x4080c7._0x1e3f02)||_0x56b371[_0x24c09b(0xdc)]()[_0x24c09b(0x131)]===0x0)return null;if(_0x1cd817!==void 0x0&&typeof _0x1cd817!=='string')return null;if(_0x1774bb!==void 0x0&&typeof _0x1774bb!=='string')return null;const _0x464bb5=typeof _0x393337===_0x24c09b(_0x4080c7._0xe6d065)&&Number[_0x24c09b(0x13d)](_0x393337)&&_0x393337>=0x1?_0x393337:void 0x0;return{'collection':_0x417978,'cron':_0x56b371,..._0x1cd817!==void 0x0?{'env':_0x1cd817}:{},..._0x1774bb!==void 0x0?{'prepare':_0x1774bb}:{},..._0x464bb5!==void 0x0?{'workers':_0x464bb5}:{}};}__name(parseScheduleEntry,'parseScheduleEntry');function parseSchedulesJson(_0x3b2f82){const _0x16fd08=_0x705370;let _0x4596d9;try{_0x4596d9=JSON[_0x16fd08(0x164)](_0x3b2f82);}catch{return null;}if(!Array[_0x16fd08(0x18f)](_0x4596d9))return null;const _0x29e947=[];for(const _0x51f43c of _0x4596d9){const _0x2cbb56=parseScheduleEntry(_0x51f43c);if(_0x2cbb56)_0x29e947[_0x16fd08(0x130)](_0x2cbb56);}return _0x29e947;}__name(parseSchedulesJson,_0x705370(0x16e));var BLOBS_DIR=_0x705370(0x12d),GENERATION_SEP='~',HASH_RE=/^[0-9a-f]{8,}$/,InvalidBlobHashError=class extends Error{static{__name(this,_0x705370(0x10c));}constructor(_0x9dde74){const _0x1d9bb1={_0x2d44e0:0xe6,_0xbbe03a:0xdd},_0x194d31=_0x705370;super(_0x194d31(_0x1d9bb1._0x2d44e0)+_0x9dde74),this[_0x194d31(_0x1d9bb1._0xbbe03a)]=_0x194d31(0x10c);}};function blobPathFor(_0x1a90a0,_0x330c85,_0x2c0cce,_0x333791=0x0){return _0x1a90a0+'/'+blobRelPathFor(_0x330c85,_0x2c0cce,_0x333791);}__name(blobPathFor,_0x705370(0x139));function blobRelSegmentsFor(_0x4da3f8,_0x4b97c8,_0x149913=0x0){const _0x5b761c={_0xe91324:0x1be,_0x27333f:0x1b9},_0x5325d3=_0x705370;if(!HASH_RE[_0x5325d3(_0x5b761c._0xe91324)](_0x4da3f8))throw new InvalidBlobHashError(_0x4da3f8);const _0x443614=_0x149913>0x0?''+GENERATION_SEP+_0x149913:'';return[BLOBS_DIR,_0x4da3f8[_0x5325d3(_0x5b761c._0x27333f)](0x0,0x2),_0x4da3f8['slice'](0x2,0x4),''+_0x4da3f8+_0x443614+'.'+_0x4b97c8];}__name(blobRelSegmentsFor,'blobRelSegmentsFor');function blobRelPathFor(_0x50961d,_0x85e1bb,_0x229841=0x0){const _0x3a3801=_0x705370;return blobRelSegmentsFor(_0x50961d,_0x85e1bb,_0x229841)[_0x3a3801(0x12e)]('/');}__name(blobRelPathFor,_0x705370(0xdb));function _0x2c65(){const _0x455384=['BMfTzq','AxnbBM5VDgf0Aw9UtgLUzq','AxnsDw5UzxjdB25MAwDlzxK','lNj1BNm','l2fWAs9IB3GVy2KVCNvU','z2v0uMfUzg9TvMfSDwvZ','AxnrDwv1zurPCK5HBwu','yxv0Ag9YAw5N','lNzPzxDLCI5SB2nR','yMXVyIbOyxnOig11C3qGyMuGBg93zxjJyxnLigHLEcWGz290oIa','zNjLzxPL','CNvUBMvYici','vu5pvevtvf9orvrxt1jl','C2HHCMrqyxrOrM9YuNvUswq','x2rHEs5QC29UBa','vu5pvevtvf9kvurhrv9srvrssuvt','C2nLBMfYAw9szwzgCM9TrMLSzu5HBwu','zw52tgf5zxjgAwXLC0zVCG','CgLJA2vYlxnUyxbZAg90lNr4Da','CgfYC2vcDw5KBgvvCgXVywrszxnWB25Zzq','lNnUyxbZAg90CW','CgfYC2vdAvj1BLjLC3bVBNnL','lMvUDG','vu5pvevtvf9rvuvvrv9hte9cquXFu0Xpvfm','AM9PBKXPBMvZ','CNvUBMvY','C29Tzq','BxvZDcbUB3qGC3rHCNqGD2L0AcaNxYCGkhjLC2vYDMvKkq','Aw5KzxHpzG','zgvMAw5LuhjVCgvYDhK','Dw5HDxrOB3jPEMvK','lNzPzxDLCI5SB2C','z2v0vvrdrNvSBfLLyxi','C3rVCMfNzq','AxnszwnVCMq','vu5pvevtvf9tte9xx01p','CgfYC2vbChbtzxj2zxjfDMvUDa','C2nOzw1HvMvYC2LVBG','nKLirhfgqq','Dg9tDhjPBMC','zgvIDwDeAxjgB3i','y29TCgfYzvf1zxvLvgLJA2v0tMfTzxm','C2vJCMv0C0nVBNrLBNq','CNvUswrtDgfYDgvKqxq','CgfYC2vrDwv1zvrPy2TLDe5HBwu','mtyZnZzIwxrgq3y','CMvTB3zLrw52vMfY','sw52ywXPzejSB2jiyxnOrxjYB3i','CgfYC2vrDwv1zvrPy2TLDa','ndaZmZqZmvPJCxnRra','C2nVCguTBwLZBwf0y2G','BwnW','zxjYB3i','Dw5VDgvZDc8Uzw52','Dg9VlwXHCMDL','mtbLExDvBMW','zMLUzeLUzgv4','A2LUza','vu5pvevtvf9erujvr19nqvHFqLLurvm','zgvZy3jPyMvuAwnRzxrdAq','igfSCMvHzhKGzxHPC3rZigLUia','zgvSzxrLu2HHzg93v2fYBMLUzW','AxngAw5PDgu','AxnbC3nPz25Tzw50tgLUzq','C2HH','CMfUAW','lMPZB24','vu5pvevtvf9erujvr19quKvwsuvxx0jzvevt','DMfSAwrHDgvgC1nHzMvoyw1L','BxvZDcbUB3qGy29UDgfPBIbCic8GoIaQid8GiIa8id4GFcbVCIbJB250CM9SignOyxjHy3rLCNm','CgfKu3rHCNq','ywjVCNrLza','C3bSAwnL','zMfPBgLUz1nPBMnL','ndGZn3vfuNfTCa','CNvUswqGy2fYCMLLCYbUBYb0Aw1LC3rHBxaSignHBM5VDcbWBgfJzsbPDcbPBIbHihnOyxjKoIa','BwfRzvj1BKLK','C2nLBMfYAw8','nti2otmWoejADefSqq','zMXHz3m','x2jSB2jZ','AM9PBG','vu5pvevtvf9kvurhrv9quKvbtujmrq','ChvZAa','BgvUz3rO','CgfYC2vdAvbYB3zPzgvY','vu5pvevtvf9ftLy','CMvJzw50','iokaLcbWAwnRigeGzgLMzMvYzw50ig5HBwuGB3iGzwrPDcb0AguGzxHPC3rPBMCGDMfSDwuU','Dw5VDgvZDc8UC2vJCMv0CW','vu5pvevtvf9kvurhrv9usu1ft1vux01t','vu5pvevtvf9kvurhrv9mt0DFtevwruW','yMXVyLbHDgHgB3i','vw5WBgfJzwfIBgvsDw5jzevYCM9Y','yNvUzgXLswq','zMfPBgvK','AxnjBNrLz2vY','CNvUBMLUzW','yxbWlxnLCNzLCJPLCNjVCG','C2vJCMv0','BxvZDcbUB3qGC3rHCNqGD2L0AcaNlIC','BM93','vu5pvevtvf9eruzbvuXux05bvKLhqvrjt05FveLnru9vvf9nuW','vu5pvevtvf9kvurhrv9dtefvrevFqKLo','C3rHCNrZv2L0Aa','CxvLDwveAxjgB3i','igLZigfSC28GC2v0igLUihvUB3rLC3qVlMvUDIdIGjqGDgHLihnLy3jLDcb2ywX1zsbUB3CGC2HHzg93CYbPDc4','CNvUswq','C3bSAxrmAw5LCW','vu5pvevtvf9dt05tt0Xf','C291CMnL','yxbWlxnLCNzLCJPYzxvZzwq','zgLYDhK','lNnLy3jLDhm','CxvLDwvqCMLVCML0EvjHBMS','Dw5RBM93BI1YDw5UzxiTA2v5','Dg9mB3DLCKnHC2u','qxbW','zw52rMLSzuzVCG','zw52','C3rHDhvZ','zxHLyW','mZm4mJDnAg5hsKS','uNvUBMvYtM90q29UzMLNDxjLzevYCM9Y','lMPZB25S','C3rKB3v0lMXVzW','C3rYAw5N','CxvLDwvK','DMLLD2vY','vu5pvevtvf9rvuvvrv9mruftrq','CMvWBgfJzq','vu5pvevtvf9ct1HFve9lru4','y3jLyxrLzef0','CMvNzxG','C2vJCMv0CW','CgfYC2u','BwfSzM9YBwvK','ywrK','y29SBgvJDgLVBG','vu5pvevtvf9kvurhrv9nt0rfta','DgvYBwLUywW','igLZigfSC28GC2v0igLUihvUB3rLC3qVlNnLy3jLDhmG4OcuihrOzsbZzwnYzxqGDMfSDwuGC2HHzg93CYb0AgLZig9Uzs4','z2v0vvrdrgf0zq','Aw50zxjYDxb0zwq','Aw52ywXPzc1Uyw1L','CgfYC2vty2HLzhvSzxnkC29U','vu5pvevtvf9kvurhrv9it1nu','CxvLDwvqCMLVCML0EuzYB21syw5R','C3rLChmUANnVBMW','C3rHCNrLzef0','AgvHCNrIzwf0','x2nVBgXLy3rPB25Z','vu5pvevtvf9kvurhrv9qt1ju','BwfUAwzLC3qUANnVBG','yM9VBgvHBG','DgvTCgXHDgu','l2HLywX0Aa','mJb4D3Lcq1a','C2HHCMrqyxrOrM9YvgLTzxn0yw1W','l2P1zgDL','CgfYC2vty2vUyxjPB0fUBM90yxrPB25Z','AgfZ','iI4G','tK9Fq09mt1i','Dw5RBM93BI1LBNzPCM9UBwvUDa','vu5pvevtvf9ot19rvuvvrq','vu5pvevtvf9qt1bvuf9huKfdrv9nuW','C3rYAw5NtgLZDa','AxnsDw5ZrgLYtMfTzq','mtmXoty5nvDOBgT2sW','ywn0AxzLrw52tMfTzq','BxvZDcbIzsbHihn0CMLUzW','C291CMnLCY5QC29U','vu5pvevtvf9kvurhrv9quK9wsurfuG','BM8Ty29SBgvJDgLVBNm','C2HHCMreyxLZrgvZy2vUzgLUzW','Dw5VDgvZDa','zgvZy3jPyMvcDw5KBgu','AxnbCNjHEq','lY5Kzwj1z2DLCG','zgvIDwDNzxjgAwXLrM9Y','igLZigfSC28GC2v0igLUihLVDxiGC2HLBgWGzw52AxjVBM1LBNqG4OcuigL0ihDPBgWGA2vLCcbYzxnVBhzPBMCGzNjVBsb0AgvYzsaODgHLigvUDMLYB25Tzw50ihDPBNmGB3zLCIb0AguGzMLSzsKU','vu5pvevtvf9erujvr19lruvqx0nbteXt','vu5pvevtvf9kvurhrv9vuKW','CNvU','vw5ZDxbWB3j0zwrsDw5lAw5KrxjYB3i','C2vYAwfSAxPLrw52vMfSDwu','lNf1zxvL','yxj0AwzHy3rZuM9VDezYB20','CMfUzg9T','AxnfEhrLCM5HBfzHCK5HBwu','CMvZzxj2zwrvBMrLCNnJB3jL','zw52tMfTzxngCM9TrgLYtgLZDgLUzW','vu5pvevtvf9erujvr19ive1mx01bwf9cwvrfuW','mtnAB291zum','uNvUBMvYqwrHChrLCK5VDezVDw5KrxjYB3i','y3jLyxrLza','yxbP','zw5KC1DPDgG','Ag9ZDa','mtf5t0PswgG','CgfYC2vcDw5KBgu','C2nLBMfYAw9jBMrLEezPBgvoyw1L','Bwf0y2G','zhvWBgLJyxrL','Aw5Zzxj0rw52vMfY','C2nOzwr1Bgu','CgfYC2vdAvj1BLjLCxvLC3q','CgfYC2vfBNzdB250zw50','mZe4tw1rre5U','CNvUDgLTzs5QC29U','vu5pvevtvf9erujvrW','CgfYC2vuAwnRzxrdAq','BNvTyMvY','CgfYC2vxB3jRC3bHy2vgAwXL','ufiGiW','Bgf5zxjZrM9Y','zMLSDgvY','y3j5ChrV','ChjVAMvJDff1zxvLuM9VDa','C2XPy2u','yxbW','refuqujbu0vFvvjm','DMfSAwrHDgvdB2XSzwn0Aw9UtMfTzq','vu5pvevtvf9kvurhrv9wt1rf','DgvZDa','Dw5RBM93BI1IDw5KBgu','CgLK','AxnbC3nPz25Tzw50t2y','B2jQzwn0','BwfPBNrLBMfUy2u','icH3AxaP','l2fWAs9IB3GVyNvUzgXLCW','zMfPBfn0CMvHAW','iIbKB2vZig5VDcbZDxbWB3j0ihj1BIbRAw5Kici','CgXHBKfKzfzHCMLHyMXL','z2L0AhvI','mJiXndK2ofrpDxHNAq','C3bSAxq','vvrd','Aw5JBhvKzxm','ChjVDMLKzxi','yNvUzgXLlMPZB24','CMvNzxHmAxrLCMfS','DMfSAwrHDgvtzwDTzw50tMfTzq','nZeZnMLyAhnYuq','vu5pvevtvf9cvu5etevFsuq','yNjHBMnO','AwqTBwLZBwf0y2G','ic0Tlq','C2XVDhm','x2XHDgvZDc5QC29U','zxHWzwn0lwzHAwW','BwLUlxzLCNnPB24','zMXVB3i','y29TBwfUzhmUANnVBMW','yMXVyLjLBfbHDgHgB3i','DhjPBq'];_0x2c65=function(){return _0x455384;};return _0x2c65();}function blobsRootFor(_0x251bcc){return _0x251bcc+'/'+BLOBS_DIR;}__name(blobsRootFor,'blobsRootFor');var FS_UNSAFE_NAME_RE=/[\\/:*?"<>|\x00-\x1f]/;function validateFsSafeName(_0x1f5531,_0x592d91){const _0x4fd26c={_0x6d1a1f:0x15b,_0x16ea2c:0x188,_0xc31976:0xdc,_0x154cf4:0x131,_0x2436d8:0x145,_0x4992a6:0x145,_0x1eafa4:0xf8,_0x521ae2:0x122},_0x106f89=_0x705370;if(typeof _0x1f5531!==_0x106f89(_0x4fd26c._0x6d1a1f))return _0x106f89(_0x4fd26c._0x16ea2c);const _0x3b1cda=_0x1f5531[_0x106f89(_0x4fd26c._0xc31976)]();if(_0x3b1cda[_0x106f89(_0x4fd26c._0x154cf4)]===0x0)return'must\x20not\x20be\x20empty';if(_0x3b1cda==='.'||_0x3b1cda==='..')return'must\x20not\x20be\x20\x22.\x22\x20or\x20\x22..\x22';if(_0x3b1cda[_0x106f89(_0x4fd26c._0x2436d8)]('.'))return _0x106f89(0x141);if(_0x592d91?.[_0x106f89(0x19c)]&&_0x3b1cda[_0x106f89(_0x4fd26c._0x4992a6)]('_'))return _0x106f89(_0x4fd26c._0x1eafa4);if(FS_UNSAFE_NAME_RE[_0x106f89(0x1be)](_0x3b1cda))return _0x106f89(_0x4fd26c._0x521ae2);return null;}__name(validateFsSafeName,_0x705370(0x121));var COLLECTION_NAME_FORBIDDEN_RE=FS_UNSAFE_NAME_RE;function validateCollectionName(_0x4cf4db){return validateFsSafeName(_0x4cf4db);}__name(validateCollectionName,_0x705370(0x1bc));var RUN_MANIFEST_FILE=_0x705370(0x176),RUN_SOURCES_FILE=_0x705370(0x189),UnsupportedRunKindError=class extends Error{static{__name(this,_0x705370(0x196));}constructor(_0x474687,_0x157414){const _0x1ecfa6={_0x519f55:0xe8,_0x3edce8:0xdd},_0x57cb86=_0x705370;super(_0x57cb86(_0x1ecfa6._0x519f55)+_0x157414+_0x57cb86(0xc5)+_0x474687+'\x22'),this[_0x57cb86(_0x1ecfa6._0x3edce8)]='UnsupportedRunKindError';}},RunnerAdapterNotFoundError=class extends Error{static{__name(this,'RunnerAdapterNotFoundError');}constructor(_0x2fac00,_0x2c4d28){const _0x2ae47d={_0x50774c:0x17f,_0x585ca7:0x1a0},_0x5f14fb=_0x705370;super('cannot\x20load\x20runner\x20adapter\x20\x22'+_0x2fac00+_0x5f14fb(_0x2ae47d._0x50774c)+_0x2c4d28),this['name']=_0x5f14fb(_0x2ae47d._0x585ca7);}},RunnerNotConfiguredError=class extends Error{static{__name(this,_0x705370(0x158));}constructor(_0x47f646){const _0x15d62c=_0x705370;super(_0x47f646),this['name']=_0x15d62c(0x158);}},EXPECT_FAIL_ANNOTATION=_0x705370(0xd7),ANNOTATION_RE=/^\s*\/\/\s*@([a-z0-9-]+)\s*$/;function isAnnotationLine(_0xb720b2){const _0x484321=_0x705370;return ANNOTATION_RE[_0x484321(0x1be)](_0xb720b2);}__name(isAnnotationLine,_0x705370(0xde));function parseScenarioAnnotations(_0x503e17){const _0x348d71={_0x3f2348:0xc9,_0x4bbb92:0xdc,_0x23f97d:0x166,_0x47a670:0x17e},_0x5c1cf4=_0x705370,_0x3d58e7=new Set();for(const _0x5b7646 of _0x503e17[_0x5c1cf4(_0x348d71._0x3f2348)](/\r?\n/)){const _0x4c21d1=_0x5b7646[_0x5c1cf4(_0x348d71._0x4bbb92)]();if(_0x4c21d1==='')continue;if(!_0x4c21d1['startsWith']('//'))break;const _0x2c8714=_0x4c21d1[_0x5c1cf4(0x1a8)](ANNOTATION_RE);if(_0x2c8714)_0x3d58e7[_0x5c1cf4(_0x348d71._0x23f97d)](_0x2c8714[0x1]);}return{'expectFail':_0x3d58e7[_0x5c1cf4(_0x348d71._0x47a670)](EXPECT_FAIL_ANNOTATION)};}__name(parseScenarioAnnotations,_0x705370(0x17d));var SEGMENT_NAME_FORBIDDEN_RE=FS_UNSAFE_NAME_RE;function validateSegmentName(_0x15cb8a){return validateFsSafeName(_0x15cb8a,{'reservedUnderscore':!![]});}__name(validateSegmentName,_0x705370(0xcf));var TERMINAL_WS_EVENT=_0x705370(0x169),RUNNER_CONFIG_KEYS=new Set(['UNOTEST_BROWSER','UNOTEST_HEADED',_0x705370(0x100),'UNOTEST_DEFAULT_TIMEOUT_MS',_0x705370(0x143),_0x705370(0x183),'UNOTEST_LOCALE','UNOTEST_TIMEZONE','UNOTEST_LOG_LEVEL',_0x705370(0x1b0),'UNOTEST_DEBUG_DIR',_0x705370(0x117),_0x705370(0x120),_0x705370(0x19e),_0x705370(0x193),_0x705370(0xe9),_0x705370(0x14a),'UNOTEST_CACHE_DIR',_0x705370(0x180),'FORCE_COLOR',_0x705370(0x1bb)]);function isRunnerConfigKey(_0x38fb28){const _0x52df65=_0x705370;return RUNNER_CONFIG_KEYS[_0x52df65(0x17e)](_0x38fb28);}__name(isRunnerConfigKey,_0x705370(0xdf));function categorizeVariable(_0x134afb){const _0x4fe440={_0x27794b:0xf6},_0x49c06b=_0x705370;if(_0x134afb[_0x49c06b(0x14b)]==='secrets')return'secret';return isRunnerConfigKey(_0x134afb[_0x49c06b(0xdd)])?_0x49c06b(_0x4fe440._0x27794b):_0x49c06b(0x1ba);}__name(categorizeVariable,'categorizeVariable');function isExternalVarName(_0x3158df){return/^[A-Z][A-Z0-9_]*$/['test'](_0x3158df);}__name(isExternalVarName,_0x705370(0x19b));var ENV_KEY_RE=/^[A-Za-z_][A-Za-z0-9_]*$/;function*assignmentEntries(_0x492f8e){const _0x4cc7e3={_0x4ebd57:0x145,_0x1481d9:0x1b9,_0x472a9a:0xdc},_0x3d773c=_0x705370;for(const _0x16b263 of _0x492f8e[_0x3d773c(0xc9)](/\r?\n/)){const _0xf39ed6=_0x16b263[_0x3d773c(0xdc)]();if(_0xf39ed6===''||_0xf39ed6[_0x3d773c(_0x4cc7e3._0x4ebd57)]('#'))continue;const _0x4b2245=_0xf39ed6[_0x3d773c(0xf9)]('=');if(_0x4b2245<=0x0)continue;const _0x4a10c1=_0xf39ed6[_0x3d773c(_0x4cc7e3._0x1481d9)](0x0,_0x4b2245)[_0x3d773c(_0x4cc7e3._0x472a9a)]();if(!ENV_KEY_RE[_0x3d773c(0x1be)](_0x4a10c1))continue;yield[_0x4a10c1,_0xf39ed6[_0x3d773c(0x1b9)](_0x4b2245+0x1)['trim']()];}}__name(assignmentEntries,'assignmentEntries');function parseEnvContent(_0x4945bf){const _0x501694=_0x705370,_0x1acbd8={};for(const [_0x1e0c37,_0x46d036]of assignmentEntries(_0x4945bf)){let _0x4878ad=_0x46d036;if(_0x4878ad['length']>=0x2){const _0x5b416a=_0x4878ad[0x0],_0x57b9bb=_0x4878ad[_0x4878ad[_0x501694(0x131)]-0x1];(_0x5b416a==='\x22'||_0x5b416a==='\x27')&&_0x5b416a===_0x57b9bb&&(_0x4878ad=_0x4878ad[_0x501694(0x1b9)](0x1,-0x1));}_0x1acbd8[_0x1e0c37]=_0x4878ad;}return _0x1acbd8;}__name(parseEnvContent,_0x705370(0x1ad));function serializeEnvValue(_0x2893fa){const _0x245f87={_0x3e1638:0x1be,_0x590eec:0x1be,_0x8e93e6:0x15f},_0x5e9aac=_0x705370;if(_0x2893fa==='')return'';if(/[\s#"'=\\]|^[`]/[_0x5e9aac(_0x245f87._0x3e1638)](_0x2893fa)||/[\n\r]/[_0x5e9aac(_0x245f87._0x590eec)](_0x2893fa)){const _0xce3bd8=_0x2893fa[_0x5e9aac(0x15f)](/\\/g,'\x5c\x5c')[_0x5e9aac(0x15f)](/"/g,'\x5c\x22')['replace'](/\n/g,'\x5cn')[_0x5e9aac(_0x245f87._0x8e93e6)](/\r/g,'\x5cr');return'\x22'+_0xce3bd8+'\x22';}return _0x2893fa;}__name(serializeEnvValue,_0x705370(0x197));function envKeys(_0x488ff7){const _0x2f67ee=_0x705370,_0x367b72=new Set();for(const [_0x57f6f5]of assignmentEntries(_0x488ff7))_0x367b72[_0x2f67ee(0x166)](_0x57f6f5);return _0x367b72;}__name(envKeys,'envKeys');function isSectionDivider(_0x149dda){const _0x1d9b01={_0x1d4196:0xdc},_0x2a4671=_0x705370,_0x72a8b1=_0x149dda[_0x2a4671(_0x1d9b01._0x1d4196)]();return _0x72a8b1[_0x2a4671(0x145)]('#')&&/---/['test'](_0x72a8b1);}__name(isSectionDivider,'isSectionDivider');function isAssignmentLine(_0x4fb2c2){const _0x290d09={_0x20a457:0xdc,_0xa1bd7a:0x145,_0x341541:0xf9},_0x1d202c=_0x705370,_0x3ab3e8=_0x4fb2c2[_0x1d202c(_0x290d09._0x20a457)]();if(_0x3ab3e8===''||_0x3ab3e8[_0x1d202c(_0x290d09._0xa1bd7a)]('#'))return![];const _0x36e4b6=_0x3ab3e8[_0x1d202c(_0x290d09._0x341541)]('=');return _0x36e4b6>0x0&&ENV_KEY_RE['test'](_0x3ab3e8[_0x1d202c(0x1b9)](0x0,_0x36e4b6)[_0x1d202c(0xdc)]());}__name(isAssignmentLine,_0x705370(0x11c));function isAssignmentOf(_0x57abe3,_0x5d18b0){const _0x2b9489={_0x6925c7:0xf9},_0x19629d=_0x705370,_0x883351=_0x57abe3[_0x19629d(0xdc)]();if(_0x883351===''||_0x883351['startsWith']('#'))return![];const _0x45bbe8=_0x883351[_0x19629d(_0x2b9489._0x6925c7)]('=');if(_0x45bbe8<=0x0)return![];return _0x883351[_0x19629d(0x1b9)](0x0,_0x45bbe8)['trim']()===_0x5d18b0;}__name(isAssignmentOf,_0x705370(0x1c1));function splitLines(_0x5bd342){const _0x2978a5={_0x544265:0x1b9},_0x4b81ee=_0x705370,_0x5bcbc8=_0x5bd342['endsWith']('\x0a'),_0xd3629b=_0x5bcbc8?_0x5bd342[_0x4b81ee(_0x2978a5._0x544265)](0x0,-0x1):_0x5bd342;return{'lines':_0xd3629b===''?[]:_0xd3629b[_0x4b81ee(0xc9)]('\x0a'),'trailingNewline':_0x5bcbc8};}__name(splitLines,_0x705370(0x149));function joinLines(_0x468dc4,_0x181353){const _0xb38757=_0x705370,_0x589a7b=_0x468dc4[_0xb38757(0x12e)]('\x0a');return _0x181353||_0x589a7b===''?_0x589a7b+'\x0a':_0x589a7b;}__name(joinLines,_0x705370(0xf5));function insertEnvVar(_0x192027,_0x32665c,_0x2826a0,_0xa7456b){const _0x3d4351={_0x20eade:0x151,_0x507391:0x131,_0x346727:0x130},_0x524a96=_0x705370,_0x2e48fe=_0x32665c+'='+serializeEnvValue(_0x2826a0),{lines:_0x178d77,trailingNewline:_0x477b48}=splitLines(_0x192027);if(_0xa7456b){const _0x33f2f2=new RegExp('\x5cb'+_0xa7456b[_0x524a96(_0x3d4351._0x20eade)]()+'\x5cb'),_0x439fee=_0x178d77[_0x524a96(0x115)](_0x38d600=>isSectionDivider(_0x38d600)&&_0x33f2f2[_0x524a96(0x1be)](_0x38d600[_0x524a96(0x151)]()));if(_0x439fee!==-0x1){let _0x560a39=_0x178d77[_0x524a96(_0x3d4351._0x507391)];for(let _0x33b765=_0x439fee+0x1;_0x33b765<_0x178d77['length'];_0x33b765++){if(isSectionDivider(_0x178d77[_0x33b765])){_0x560a39=_0x33b765;break;}}let _0x42b6cb=-0x1,_0x28ab7a=-0x1;for(let _0x588e57=_0x439fee+0x1;_0x588e57<_0x560a39;_0x588e57++){if(_0x178d77[_0x588e57][_0x524a96(0xdc)]()!=='')_0x28ab7a=_0x588e57;if(isAssignmentLine(_0x178d77[_0x588e57]))_0x42b6cb=_0x588e57;}const _0x370b05=_0x42b6cb>=0x0?_0x42b6cb:_0x28ab7a,_0x26bfb5=_0x370b05>=0x0?_0x370b05+0x1:_0x439fee+0x1;return _0x178d77[_0x524a96(0x125)](_0x26bfb5,0x0,_0x2e48fe),joinLines(_0x178d77,_0x477b48||_0x178d77['length']>0x0);}if(_0x178d77[_0x524a96(0x131)]>0x0)_0x178d77[_0x524a96(_0x3d4351._0x346727)]('');return _0x178d77['push']('#\x20---\x20'+_0xa7456b+_0x524a96(0xd4),_0x2e48fe),joinLines(_0x178d77,!![]);}return _0x178d77['push'](_0x2e48fe),joinLines(_0x178d77,!![]);}__name(insertEnvVar,_0x705370(0x1aa));function removeEnvVar(_0x514d5a,_0x27da16){const _0x42913c=_0x705370,{lines:_0x4ce401,trailingNewline:_0x39f931}=splitLines(_0x514d5a),_0x3c85bc=_0x4ce401[_0x42913c(0x1b6)](_0x2fd700=>!isAssignmentOf(_0x2fd700,_0x27da16)),_0x151601=_0x3c85bc['length']!==_0x4ce401['length'];return{'content':joinLines(_0x3c85bc,_0x39f931),'removed':_0x151601};}__name(removeEnvVar,_0x705370(0x10b));var SECTION_BY_KIND={'app':_0x705370(0x152),'runner':'Runner','secret':void 0x0};function planAddVariable(_0x771604){const _0x2300c1={_0x35ddc3:0x16d,_0x5c41ba:0x163,_0x107628:0x163,_0x1bbd0e:0x135,_0x23b471:0x140,_0x3055a4:0x130,_0x6875f9:0x16a},_0x5a3774=_0x705370,{name:_0x1ab331,kind:_0x8ffb8f}=_0x771604;if(_0x8ffb8f===_0x5a3774(0xf6)){if(!isRunnerConfigKey(_0x1ab331))return{'ok':![],'code':_0x5a3774(0x150),'message':_0x1ab331+'\x20is\x20not\x20a\x20known\x20runner\x20setting\x20—\x20choose\x20one\x20from\x20the\x20runner-config\x20list.'};}else{if(!isExternalVarName(_0x1ab331))return{'ok':![],'code':_0x5a3774(_0x2300c1._0x35ddc3),'message':_0x1ab331+'\x20must\x20be\x20UPPER_SNAKE\x20(e.g.\x20APP_BASE_URL)\x20so\x20a\x20scenario\x20can\x20reference\x20it\x20by\x20name.'};}const _0x16ba1d=envKeys(_0x771604['envContent'])[_0x5a3774(0x17e)](_0x1ab331),_0x4aacc7=envKeys(_0x771604[_0x5a3774(0x107)])['has'](_0x1ab331),_0x2741af=_0x8ffb8f===_0x5a3774(0x140)?_0x5a3774(_0x2300c1._0x5c41ba):_0x5a3774(0x154),_0x562217=_0x2741af===_0x5a3774(0x163)?_0x4aacc7:_0x16ba1d,_0x51a98f=_0x2741af===_0x5a3774(_0x2300c1._0x107628)?_0x5a3774(0x136):_0x5a3774(0x112);if(_0x562217)return{'ok':![],'code':_0x5a3774(0x1a9),'message':_0x1ab331+_0x5a3774(0x119)+_0x51a98f+_0x5a3774(_0x2300c1._0x1bbd0e)};const _0x4e4002=[];return _0x8ffb8f===_0x5a3774(_0x2300c1._0x23b471)&&_0x16ba1d&&_0x4e4002[_0x5a3774(0x130)](_0x1ab331+_0x5a3774(0x147)),_0x8ffb8f!==_0x5a3774(0x140)&&_0x4aacc7&&_0x4e4002[_0x5a3774(_0x2300c1._0x3055a4)](_0x1ab331+_0x5a3774(_0x2300c1._0x6875f9)),{'ok':!![],'target':_0x2741af,'sectionLabel':SECTION_BY_KIND[_0x8ffb8f],'warnings':_0x4e4002};}__name(planAddVariable,_0x705370(0xc6));function deleteShadowWarning(_0x147b0d,_0x546821,_0xa849f3){const _0x69f909=_0x705370;if(_0xa849f3!==void 0x0&&_0xa849f3!==_0x546821)return[_0x147b0d+_0x69f909(0x192)];return[];}__name(deleteShadowWarning,_0x705370(0x11a));var TERMINAL_RUNTIME_STATES=['completed',_0x705370(0x13c),_0x705370(0x124)];function isTerminalRuntimeState(_0x2b6311){return TERMINAL_RUNTIME_STATES['includes'](_0x2b6311);}__name(isTerminalRuntimeState,'isTerminalRuntimeState');var JUDGE_ROUTES={'judge':_0x705370(0x17c),'health':_0x705370(0x179)},JUDGE_ENV={'mode':'UNOTEST_JUDGE_MODE','url':_0x705370(0x194),'token':'UNOTEST_JUDGE_TOKEN','requestTimeoutMs':_0x705370(0x137),'preamble':_0x705370(0x12f),'provider':_0x705370(0x18a),'model':_0x705370(0x168),'callTimeoutMs':'UNOTEST_JUDGE_CALL_TIMEOUT_MS','retries':_0x705370(0xec),'vote':_0x705370(0x1bd),'accessToken':'UNOTEST_JUDGE_ACCESS_TOKEN','claudeBin':_0x705370(0x144),'host':_0x705370(0x16f),'port':_0x705370(0x175),'logLevel':_0x705370(0x138),'skipPreflight':'UNOTEST_JUDGE_SKIP_PREFLIGHT'};export{ARTIFACTS_ROOT_ENV,BLOBS_DIR,BOX_TOKEN_ENV,BOX_URL_ENV,BUNDLE_ID_ENV,BUNDLE_MANIFEST_FILE,BUNDLE_SCHEMA_VERSION,BUNDLE_UPLOAD_PATH,CI_RUN_PATH,COLLECTIONS_SUBDIR,COLLECTION_NAME_FORBIDDEN_RE,COMMANDS_FILE,DAY_INDEX_FILE,E2E_SUBDIR,ENV_FILE,EXPECT_FAIL_ANNOTATION,HEARTBEAT_FILE,HELPERS_SUBDIR,InvalidBlobHashError,JUDGE_ENV,JUDGE_ROUTES,LOCK_FILE,LOG_FILE,PICKER_SNAPSHOT_FILE,QUEUE_DISABLED_ENV,QUEUE_GLOBAL_DIR_ENV,QUEUE_GLOBAL_SLOTS_ENV,QUEUE_LEASE_ENV,QUEUE_MUTEX_FILE,QUEUE_PRIORITIES,QUEUE_RUNNING_DIR,QUEUE_SCHEMA_VERSION,QUEUE_SLOTS_DIR,QUEUE_SUBDIR,QUEUE_TICKETS_DIR,RUNNER_CONFIG_KEYS,RUNS_SUBDIR,RUNTIME_FILE,RUN_INDEX_SCHEMA_VERSION,RUN_MANIFEST_FILE,RUN_SOURCES_FILE,RunnerAdapterNotFoundError,RunnerNotConfiguredError,SCENARIOS_INDEX_DIR,SCENARIOS_LATEST_FILE,SCENARIO_RECENT_WINDOW,SECRETS_FILE,SEGMENT_NAME_FORBIDDEN_RE,SNAPSHOTS_SUBDIR,STDERR_FILE,STDOUT_FILE,STEPS_FILE,TERMINAL_RUNTIME_STATES,TERMINAL_WS_EVENT,UNOTEST_DIR,UnplaceableRunIdError,UnsupportedRunKindError,WORKSPACE_FILE,WORKSPACE_SCHEMA_VERSION,activeEnvName,artifactsRootFrom,blobPathFor,blobRelPathFor,blobRelSegmentsFor,blobsRootFor,categorizeVariable,compareQueueTicketNames,debugDirFor,debuggerFileFor,deleteShadowWarning,describeBundle,describeTicketCi,envFileFor,envKeys,envLayerFilesFor,envNamesFromDirListing,foldScenarioRun,insertEnvVar,isAnnotationLine,isExternalVarName,isFailingStatus,isQueueDirName,isRecord,isRegexLiteral,isRunnerConfigKey,isRunsDirName,isTerminalRuntimeState,makeQueueTicketName,makeRunId,parseAppServerEvent,parseBundleManifest,parseBundleUploadResponse,parseCiProvider,parseCiRunRequest,parseCiRunResponse,parseEnvContent,parseQueueTicket,parseQueueTicketName,parseScenarioAnnotations,parseScheduleEntry,parseSchedulesJson,parseWorkspaceFile,planAddVariable,projectQueueRoot,projectRunDirFor,projectRunsRoot,queueDirFor,queuePriorityFromRank,queuePriorityRank,regexLiteral,removeEnvVar,requireRunDirFor,runDirFor,runIdStartedAt,runsDirFor,sanitizeRunIdSegment,scenarioIndexFileName,scenarioRefFromFileName,secretsFileFor,secretsLayerFilesFor,serializeEnvValue,shardDaysDescending,shardDirFor,shardPathForRunId,shardPathForTimestamp,testDirFor,validateCollectionName,validateSegmentName};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unotest/protocol",
-  "version": "0.24.0",
+  "version": "0.26.0",
   "description": "Cross-runner protocol for the @unotest ecosystem: shared TypeScript types, path constants, the IRunnerAdapter contract that lets @unotest/viewer drive @unotest/web, @unotest/mobile (and future runners) through the same surface. Pure types + pure functions only — zero runtime deps, browser-safe.",
   "license": "MIT",
   "publishConfig": {