@unotest/protocol 0.25.0 → 0.26.0

package/CHANGELOG.md

@@ -1,5 +1,220 @@
 # 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

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;
@@ -684,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
@@ -744,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. */
@@ -845,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. */
@@ -1455,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. */
@@ -1472,7 +2041,7 @@ 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"];
@@ -1705,4 +2274,4 @@ declare const JUDGE_ENV: {
     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 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 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 _0x48998b=_0x3a78;(function(_0x4b5ee6,_0x37527c){const _0x1b2dee={_0x311c97:0x1eb,_0x16342b:0x229,_0x36f585:0x1ce,_0x5c7055:0x1f2,_0x3b7b07:0x206,_0x26d02d:0x18e,_0x56072a:0x1c8},_0x502c5a=_0x3a78,_0x2129ad=_0x4b5ee6();while(!![]){try{const _0x3a2d30=parseInt(_0x502c5a(0x1f4))/0x1*(parseInt(_0x502c5a(0x1da))/0x2)+parseInt(_0x502c5a(_0x1b2dee._0x311c97))/0x3*(-parseInt(_0x502c5a(_0x1b2dee._0x16342b))/0x4)+-parseInt(_0x502c5a(_0x1b2dee._0x36f585))/0x5*(-parseInt(_0x502c5a(0x1d8))/0x6)+-parseInt(_0x502c5a(0x190))/0x7*(-parseInt(_0x502c5a(_0x1b2dee._0x5c7055))/0x8)+parseInt(_0x502c5a(0x175))/0x9*(parseInt(_0x502c5a(_0x1b2dee._0x3b7b07))/0xa)+parseInt(_0x502c5a(_0x1b2dee._0x26d02d))/0xb*(parseInt(_0x502c5a(_0x1b2dee._0x56072a))/0xc)+-parseInt(_0x502c5a(0x1e7))/0xd*(parseInt(_0x502c5a(0x1a5))/0xe);if(_0x3a2d30===_0x37527c)break;else _0x2129ad['push'](_0x2129ad['shift']());}catch(_0x4b2b18){_0x2129ad['push'](_0x2129ad['shift']());}}}(_0x5be3,0xd6fe4));var __defProp=Object['defineProperty'],__name=(_0x5d24f8,_0x221ed9)=>__defProp(_0x5d24f8,_0x48998b(0x18b),{'value':_0x221ed9,'configurable':!![]});function parseAppServerEvent(_0x2dbd71){const _0x2ef7ed={_0xde2658:0x216,_0x15d8e4:0x17a,_0x3bfc85:0x204,_0x4fc71a:0x1fb,_0x2d34e7:0x17a,_0x144e1a:0x1c9},_0x2d504b=_0x48998b,_0x1dc19f=_0x2dbd71[_0x2d504b(0x17b)]();if(!_0x1dc19f[_0x2d504b(_0x2ef7ed._0xde2658)]('{'))return null;try{const _0x4a816d=JSON[_0x2d504b(0x20d)](_0x1dc19f);if(_0x4a816d[_0x2d504b(_0x2ef7ed._0x15d8e4)]===_0x2d504b(_0x2ef7ed._0x3bfc85)||_0x4a816d[_0x2d504b(_0x2ef7ed._0x15d8e4)]===_0x2d504b(_0x2ef7ed._0x4fc71a)||_0x4a816d[_0x2d504b(_0x2ef7ed._0x2d34e7)]===_0x2d504b(_0x2ef7ed._0x144e1a))return _0x4a816d;return null;}catch{return null;}}__name(parseAppServerEvent,'parseAppServerEvent');var UNOTEST_DIR=_0x48998b(0x186),E2E_SUBDIR=_0x48998b(0x1d4),HELPERS_SUBDIR=_0x48998b(0x210),COLLECTIONS_SUBDIR=_0x48998b(0x208),RUNS_SUBDIR=_0x48998b(0x18d),SNAPSHOTS_SUBDIR=_0x48998b(0x222);function testDirFor(_0x23a893){return''+E2E_SUBDIR+_0x23a893;}__name(testDirFor,_0x48998b(0x19b));function runsDirFor(_0x3d5309,_0x509b74){return''+RUNS_SUBDIR+_0x3d5309+(_0x509b74?'.'+_0x509b74:'');}__name(runsDirFor,_0x48998b(0x22d));function isRunsDirName(_0x50beb5){const _0x171f6d={_0x5a38e5:0x216},_0x5cb8ce=_0x48998b;return _0x50beb5===RUNS_SUBDIR||_0x50beb5[_0x5cb8ce(_0x171f6d._0x5a38e5)](RUNS_SUBDIR+'-')||_0x50beb5[_0x5cb8ce(0x216)](RUNS_SUBDIR+'.');}__name(isRunsDirName,'isRunsDirName');function debugDirFor(_0x391af7){return'.debug'+_0x391af7;}__name(debugDirFor,_0x48998b(0x1b6));function debuggerFileFor(_0x561a83){const _0x4a9d3b={_0x1970d6:0x213,_0x596d4b:0x1d9},_0x123268=_0x48998b;return UNOTEST_DIR+_0x123268(_0x4a9d3b._0x1970d6)+_0x561a83+_0x123268(_0x4a9d3b._0x596d4b);}__name(debuggerFileFor,'debuggerFileFor');var LOCK_FILE=_0x48998b(0x16d),LOG_FILE=_0x48998b(0x1b3),STEPS_FILE=_0x48998b(0x1ed),HEARTBEAT_FILE=_0x48998b(0x18a),DAY_INDEX_FILE=_0x48998b(0x1e6),SCENARIOS_INDEX_DIR=_0x48998b(0x1ea),SCENARIOS_LATEST_FILE=_0x48998b(0x1cf),STDOUT_FILE=_0x48998b(0x227),STDERR_FILE=_0x48998b(0x1bb),COMMANDS_FILE='commands.jsonl',RUNTIME_FILE=_0x48998b(0x1b8),PICKER_SNAPSHOT_FILE=_0x48998b(0x1cd),ENV_FILE='unotest/.env',SECRETS_FILE=_0x48998b(0x197);function envFileFor(_0xec4686,_0x4becbf){return''+ENV_FILE+_0xec4686+(_0x4becbf?'.'+_0x4becbf:'');}__name(envFileFor,_0x48998b(0x1e1));function secretsFileFor(_0x9da832,_0x48a63d){return''+SECRETS_FILE+_0x9da832+(_0x48a63d?'.'+_0x48a63d:'');}__name(secretsFileFor,_0x48998b(0x1b7));function envLayerFilesFor(_0x2d190c,_0x4e5b6e){return layersFor(ENV_FILE,_0x2d190c,_0x4e5b6e);}__name(envLayerFilesFor,_0x48998b(0x202));function secretsLayerFilesFor(_0x2d4093,_0x12f057){return layersFor(SECRETS_FILE,_0x2d4093,_0x12f057);}__name(secretsLayerFilesFor,_0x48998b(0x182));function layersFor(_0x356632,_0x405347,_0x40bc27){const _0x4befc0={_0x175955:0x1a6},_0x592b79=_0x48998b,_0xed3bad=[_0x356632];if(_0x405347)_0xed3bad['push'](''+_0x356632+_0x405347);if(_0x40bc27){_0xed3bad[_0x592b79(_0x4befc0._0x175955)](_0x356632+'.'+_0x40bc27);if(_0x405347)_0xed3bad[_0x592b79(_0x4befc0._0x175955)](''+_0x356632+_0x405347+'.'+_0x40bc27);}return _0xed3bad;}__name(layersFor,_0x48998b(0x1e2));function activeEnvName(_0x19273d){const _0x8e051e={_0x296c69:0x1d7},_0x32b468=_0x48998b,_0x114829=_0x19273d[_0x32b468(_0x8e051e._0x296c69)]?.[_0x32b468(0x17b)]();return _0x114829?_0x114829:void 0x0;}__name(activeEnvName,'activeEnvName');var RESERVED_ENV_NAMES=new Set(['example',_0x48998b(0x1b9),_0x48998b(0x1a7)]);function _0x3a78(_0x12d6b1,_0x6c5c09){_0x12d6b1=_0x12d6b1-0x16c;const _0x5be382=_0x5be3();let _0x3a7895=_0x5be382[_0x12d6b1];if(_0x3a78['kddBaa']===undefined){var _0x7d973a=function(_0x290a77){const _0x3a773f='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/=';let _0x5d24f8='',_0x221ed9='';for(let _0x2dbd71=0x0,_0x1dc19f,_0x4a816d,_0x23a893=0x0;_0x4a816d=_0x290a77['charAt'](_0x23a893++);~_0x4a816d&&(_0x1dc19f=_0x2dbd71%0x4?_0x1dc19f*0x40+_0x4a816d:_0x4a816d,_0x2dbd71++%0x4)?_0x5d24f8+=String['fromCharCode'](0xff&_0x1dc19f>>(-0x2*_0x2dbd71&0x6)):0x0){_0x4a816d=_0x3a773f['indexOf'](_0x4a816d);}for(let _0x3d5309=0x0,_0x509b74=_0x5d24f8['length'];_0x3d5309<_0x509b74;_0x3d5309++){_0x221ed9+='%'+('00'+_0x5d24f8['charCodeAt'](_0x3d5309)['toString'](0x10))['slice'](-0x2);}return decodeURIComponent(_0x221ed9);};_0x3a78['RJrkXx']=_0x7d973a,_0x3a78['UfDpOr']={},_0x3a78['kddBaa']=!![];}const _0xbcc5ed=_0x5be382[0x0],_0x30c822=_0x12d6b1+_0xbcc5ed,_0x1f43de=_0x3a78['UfDpOr'][_0x30c822];return!_0x1f43de?(_0x3a7895=_0x3a78['RJrkXx'](_0x3a7895),_0x3a78['UfDpOr'][_0x30c822]=_0x3a7895):_0x3a7895=_0x1f43de,_0x3a7895;}function envNamesFromDirListing(_0x57b8e9,_0x5eb081){const _0xd6861a={_0x4926e1:0x177,_0x4f3fa5:0x170,_0x3948f9:0x228},_0x27dfec=_0x48998b,_0x165561=[_0x27dfec(0x212),_0x27dfec(0x1f8)][_0x27dfec(_0xd6861a._0x4926e1)](_0xbfe117=>_0x5eb081?[_0xbfe117,''+_0xbfe117+_0x5eb081]:[_0xbfe117]),_0x135a3d=new Set();for(const _0x386cfa of _0x57b8e9){for(const _0x4cc7df of _0x165561){const _0x609b39=_0x4cc7df+'.';if(!_0x386cfa[_0x27dfec(0x216)](_0x609b39))continue;const _0x5336a1=_0x386cfa[_0x27dfec(0x1cc)](_0x609b39['length']);if(!_0x5336a1||_0x5336a1['includes']('/'))continue;if(RESERVED_ENV_NAMES[_0x27dfec(_0xd6861a._0x4f3fa5)](_0x5336a1))continue;_0x135a3d['add'](_0x5336a1);}}return[..._0x135a3d][_0x27dfec(_0xd6861a._0x3948f9)]();}__name(envNamesFromDirListing,_0x48998b(0x16c));function isRegexLiteral(_0x332ef8){const _0x205561={_0x1990d5:0x17a,_0x526a56:0x1c1},_0x498fa6=_0x48998b;return typeof _0x332ef8===_0x498fa6(0x1a8)&&_0x332ef8!==null&&_0x332ef8[_0x498fa6(_0x205561._0x1990d5)]===_0x498fa6(0x22b)&&typeof _0x332ef8[_0x498fa6(0x1de)]===_0x498fa6(_0x205561._0x526a56)&&typeof _0x332ef8[_0x498fa6(0x218)]===_0x498fa6(_0x205561._0x526a56);}__name(isRegexLiteral,_0x48998b(0x224));function regexLiteral(_0x3d04b8,_0x43a3c0=''){return{'kind':'regex','source':_0x3d04b8,'flags':_0x43a3c0};}__name(regexLiteral,'regexLiteral');var RAND_BYTES=0x6;function makeRunId(_0x184f45){const _0x5a90a9={_0x1b8b66:0x1fd,_0x20af26:0x1ac,_0x50d376:0x1c3,_0x589fd8:0x214},_0x4e571a=_0x48998b,_0x5d9cd1=sanitizeRunIdSegment(_0x184f45),_0x5a0497=Date[_0x4e571a(_0x5a90a9._0x1b8b66)]()['toString'](0x24),_0x32f0d3=new Uint8Array(RAND_BYTES);globalThis[_0x4e571a(_0x5a90a9._0x20af26)][_0x4e571a(0x1b1)](_0x32f0d3);let _0x152bf3='';for(let _0x20eab5=0x0;_0x20eab5<_0x32f0d3[_0x4e571a(_0x5a90a9._0x50d376)];_0x20eab5++){_0x152bf3+=_0x32f0d3[_0x20eab5][_0x4e571a(_0x5a90a9._0x589fd8)](0x10)['padStart'](0x2,'0');}return _0x5d9cd1+'-'+_0x5a0497+'-'+_0x152bf3;}__name(makeRunId,_0x48998b(0x16e));function sanitizeRunIdSegment(_0x291701){const _0x34c6d3={_0x5367f6:0x19c},_0x343271=_0x48998b,_0x336689=_0x291701[_0x343271(_0x34c6d3._0x5367f6)](/[^a-zA-Z0-9_-]+/g,'-')['replace'](/-+/g,'-')[_0x343271(0x19c)](/^-|-$/g,'');return _0x336689[_0x343271(0x1c3)]>0x0?_0x336689:'run';}__name(sanitizeRunIdSegment,'sanitizeRunIdSegment');var RANDOM_SUFFIX_RE=/^[0-9a-f]{6,}$/,MIN_PLAUSIBLE_MS=Date[_0x48998b(0x1d0)](0x7e4,0x0,0x1),MAX_PLAUSIBLE_MS=Date[_0x48998b(0x1d0)](0x834,0x0,0x1);function runIdStartedAt(_0x1c4630){const _0x1db9b4={_0x19c9af:0x1c3,_0x212115:0x22e,_0x5947e9:0x1b0},_0x4dbb5f=_0x48998b,_0x5be9c7=_0x1c4630[_0x4dbb5f(0x223)]('-');if(_0x5be9c7[_0x4dbb5f(_0x1db9b4._0x19c9af)]<0x3)return null;const _0x39b0d0=_0x5be9c7[_0x5be9c7['length']-0x1];if(!RANDOM_SUFFIX_RE[_0x4dbb5f(_0x1db9b4._0x212115)](_0x39b0d0))return null;const _0x4009f9=_0x5be9c7[_0x5be9c7[_0x4dbb5f(0x1c3)]-0x2];if(!/^[0-9a-z]+$/[_0x4dbb5f(0x22e)](_0x4009f9))return null;const _0xd3d50a=parseInt(_0x4009f9,0x24);if(!Number[_0x4dbb5f(_0x1db9b4._0x5947e9)](_0xd3d50a))return null;if(_0xd3d50a<MIN_PLAUSIBLE_MS||_0xd3d50a>=MAX_PLAUSIBLE_MS)return null;return _0xd3d50a;}__name(runIdStartedAt,_0x48998b(0x187));function shardPathForTimestamp(_0x29a8ed){const _0x77dc14={_0x25ad13:0x22a,_0x140a12:0x174,_0x14d255:0x1f7,_0x5c1a7f:0x1f0},_0x1ef35d=_0x48998b,_0x392594=new Date(_0x29a8ed),_0x1d747b=String(_0x392594[_0x1ef35d(_0x77dc14._0x25ad13)]())[_0x1ef35d(0x1f0)](0x4,'0'),_0x27a25e=String(_0x392594[_0x1ef35d(_0x77dc14._0x140a12)]()+0x1)[_0x1ef35d(0x1f0)](0x2,'0'),_0x29ee7d=String(_0x392594[_0x1ef35d(_0x77dc14._0x14d255)]())[_0x1ef35d(_0x77dc14._0x5c1a7f)](0x2,'0');return _0x1d747b+'/'+_0x27a25e+'/'+_0x29ee7d;}__name(shardPathForTimestamp,'shardPathForTimestamp');function shardPathForRunId(_0x2403b5){const _0x46f7ac=runIdStartedAt(_0x2403b5);return _0x46f7ac===null?null:shardPathForTimestamp(_0x46f7ac);}__name(shardPathForRunId,_0x48998b(0x196));function runDirFor(_0x5a50ef,_0x57212a){const _0x2ce433=shardPathForRunId(_0x57212a);return _0x2ce433===null?null:_0x5a50ef+'/'+_0x2ce433+'/'+_0x57212a;}__name(runDirFor,_0x48998b(0x21d));var UnplaceableRunIdError=class extends Error{static{__name(this,_0x48998b(0x1af));}constructor(_0x37fae5){const _0x362ca7={_0x28e644:0x18b,_0xb989:0x1af},_0xebcc3f=_0x48998b;super(_0xebcc3f(0x1db)+_0x37fae5),this[_0xebcc3f(_0x362ca7._0x28e644)]=_0xebcc3f(_0x362ca7._0xb989);}};function requireRunDirFor(_0x42d11b,_0x49430a){const _0x25b51a=runDirFor(_0x42d11b,_0x49430a);if(_0x25b51a===null)throw new UnplaceableRunIdError(_0x49430a);return _0x25b51a;}__name(requireRunDirFor,_0x48998b(0x1d1));function projectRunsRoot(_0x22dfd0='',_0x214647){return UNOTEST_DIR+'/'+runsDirFor(_0x22dfd0,_0x214647);}__name(projectRunsRoot,_0x48998b(0x19e));function projectRunDirFor(_0x3bd41d,_0x13bb5c='',_0x374eed){return requireRunDirFor(projectRunsRoot(_0x13bb5c,_0x374eed),_0x3bd41d);}__name(projectRunDirFor,_0x48998b(0x1c7));function shardDirFor(_0x58f14c,_0x24ec5e){return _0x58f14c+'/'+shardPathForTimestamp(_0x24ec5e);}__name(shardDirFor,_0x48998b(0x215));function*shardDaysDescending(_0x160072,_0x11fde2,_0x52091d){const _0x177bc0={_0x2442d4:0x173},_0x1037de=_0x48998b,_0x402e96=0x5265c00;let _0x1943fa=Math[_0x1037de(_0x177bc0._0x2442d4)](_0x11fde2/_0x402e96)*_0x402e96;for(let _0xe58fe9=0x0;_0xe58fe9<_0x52091d;_0xe58fe9++){yield shardDirFor(_0x160072,_0x1943fa),_0x1943fa-=_0x402e96;}}__name(shardDaysDescending,_0x48998b(0x1ab));var RUN_INDEX_SCHEMA_VERSION=0x2,SCENARIO_RECENT_WINDOW=0xc;function isFailingStatus(_0x2e4c1f){const _0x41308f={_0x38a319:0x205},_0x38820f=_0x48998b;return _0x2e4c1f===_0x38820f(_0x41308f._0x38a319)||_0x2e4c1f==='interrupted';}__name(isFailingStatus,'isFailingStatus');function foldScenarioRun(_0x5ecc3c,_0x26919c){const _0x5256a2={_0x31516d:0x1cc,_0x19b4f2:0x17c,_0x2bec71:0x181},_0x150cc8=_0x48998b,_0x161e3a={'lastRunId':_0x26919c['runId'],'lastStatus':_0x26919c['status'],'lastAt':_0x26919c[_0x150cc8(0x181)],'lastDurationMs':_0x26919c[_0x150cc8(0x1d5)],'recent':[..._0x5ecc3c?.['recent']??[],_0x26919c[_0x150cc8(0x17c)]][_0x150cc8(_0x5256a2._0x31516d)](-SCENARIO_RECENT_WINDOW)};if(!isFailingStatus(_0x26919c[_0x150cc8(_0x5256a2._0x19b4f2)]))return{..._0x161e3a,'failStreak':0x0,'failingSince':null};const _0x507a51=(_0x5ecc3c?.[_0x150cc8(0x1dc)]??0x0)+0x1;return{..._0x161e3a,'failStreak':_0x507a51,'failingSince':_0x507a51===0x1?_0x26919c[_0x150cc8(_0x5256a2._0x2bec71)]:_0x5ecc3c?.['failingSince']??_0x26919c[_0x150cc8(0x181)]};}__name(foldScenarioRun,_0x48998b(0x1c5));function scenarioIndexFileName(_0x4f8c67){const _0x779deb={_0x53d457:0x19d},_0xe27d43=_0x48998b;return encodeURIComponent(_0x4f8c67)+_0xe27d43(_0x779deb._0x53d457);}__name(scenarioIndexFileName,_0x48998b(0x176));function scenarioRefFromFileName(_0x33343b){const _0x1a6ea4={_0x52c910:0x1cc,_0x4ee519:0x1c3},_0x28abf1=_0x48998b;if(!_0x33343b[_0x28abf1(0x1ae)](_0x28abf1(0x19d)))return null;try{return decodeURIComponent(_0x33343b[_0x28abf1(_0x1a6ea4._0x52c910)](0x0,-_0x28abf1(0x19d)[_0x28abf1(_0x1a6ea4._0x4ee519)]));}catch{return null;}}__name(scenarioRefFromFileName,'scenarioRefFromFileName');var BLOBS_DIR=_0x48998b(0x20b),GENERATION_SEP='~',HASH_RE=/^[0-9a-f]{8,}$/,InvalidBlobHashError=class extends Error{static{__name(this,'InvalidBlobHashError');}constructor(_0x9b1eb){const _0x4fb744={_0x33353e:0x1f6,_0x44e71c:0x18b},_0x18e272=_0x48998b;super(_0x18e272(_0x4fb744._0x33353e)+_0x9b1eb),this[_0x18e272(_0x4fb744._0x44e71c)]=_0x18e272(0x207);}};function blobPathFor(_0x2d5181,_0x3e4b18,_0x1baf9e,_0x34ae66=0x0){return _0x2d5181+'/'+blobRelPathFor(_0x3e4b18,_0x1baf9e,_0x34ae66);}__name(blobPathFor,_0x48998b(0x1f5));function blobRelSegmentsFor(_0x4f036b,_0x3330ab,_0x206dbd=0x0){const _0x58e8fe={_0x27739e:0x1cc},_0x44af99=_0x48998b;if(!HASH_RE[_0x44af99(0x22e)](_0x4f036b))throw new InvalidBlobHashError(_0x4f036b);const _0x94eb4d=_0x206dbd>0x0?''+GENERATION_SEP+_0x206dbd:'';return[BLOBS_DIR,_0x4f036b[_0x44af99(_0x58e8fe._0x27739e)](0x0,0x2),_0x4f036b['slice'](0x2,0x4),''+_0x4f036b+_0x94eb4d+'.'+_0x3330ab];}__name(blobRelSegmentsFor,_0x48998b(0x1ff));function blobRelPathFor(_0x2eceb6,_0x511947,_0x34c151=0x0){const _0x1bb93b=_0x48998b;return blobRelSegmentsFor(_0x2eceb6,_0x511947,_0x34c151)[_0x1bb93b(0x1cb)]('/');}__name(blobRelPathFor,_0x48998b(0x183));function _0x5be3(){const _0x2c9c6a=['BxvZDcbUB3qGy29UDgfPBIbCic8GoIaQid8GiIa8id4GFcbVCIbJB250CM9SignOyxjHy3rLCNm','C291CMnLCY5QC29U','AxnbBM5VDgf0Aw9UtgLUzq','DMfSAwrHDgvgC1nHzMvoyw1L','CNvUrgLYrM9Y','Dw5VDgvZDc8Uzw52','CgXHBKfKzfzHCMLHyMXL','vu5pvevtvf9erujvr19lruvqx0nbteXt','zMLUzeLUzgv4','lNnUyxbZAg90CW','C3bSAxq','AxnszwDLEeXPDgvYywW','C2vJCMv0','vu5pvevtvf9kvurhrv9mt0DFtevwruW','C3rKB3v0lMXVzW','C29YDa','mteYnhzxu1rmuW','z2v0vvrdrNvSBfLLyxi','CMvNzxG','iI4G','CNvUC0rPCKzVCG','DgvZDa','Dw5RBM93BI1YDw5UzxiTA2v5','iokaLcbWAwnRigeGzgLMzMvYzw50ig5HBwuGB3iGzwrPDcb0AguGzxHPC3rPBMCGDMfSDwuU','zw52s2v5CW','yMXVyNnsB290rM9Y','zw52tMfTzxngCM9TrgLYtgLZDgLUzW','lNzPzxDLCI5SB2nR','BwfRzvj1BKLK','zw52','AgfZ','vu5pvevtvf9kvurhrv9bq0nfu1nFve9lru4','vu5pvevtvf9eruzbvuXux1rjtuvpvvrFtvm','zMXVB3i','z2v0vvrdtw9UDgG','ntqYmda3CNvQsgDY','C2nLBMfYAw9jBMrLEezPBgvoyw1L','zMXHDe1HCa','zhvWBgLJyxrL','vu5pvevtvf9kvurhrv9nt0rfta','A2LUza','DhjPBq','C3rHDhvZ','tK9Fq09mt1i','rK9sq0vFq09mt1i','ywrK','AxnfEhrLCM5HBfzHCK5HBwu','C3rHCNrLzef0','C2vJCMv0C0XHEwvYrMLSzxngB3i','yMXVyLjLBfbHDgHgB3i','vu5pvevtvf9erujvr19nqvHFqLLurvm','vu5pvevtvf9kvurhrv9wt1rf','Dw5VDgvZDa','CNvUswrtDgfYDgvKqxq','AxnbC3nPz25Tzw50t2y','qxbW','AgvHCNrIzwf0','BMfTzq','CgfYC2vty2vUyxjPB0fUBM90yxrPB25Z','lNj1BNm','ntm0mZKXz2ffwfvQ','yxbW','n3r4BfzgvG','BxvZDcbIzsbHihn0CMLUzW','zMLSDgvY','y2fUBM90igXVywqGCNvUBMvYigfKyxb0zxiGiG','uNvUBMvYqwrHChrLCK5VDezVDw5KrxjYB3i','vu5pvevtvf9kvurhrv9qt1ju','C2HHCMrqyxrOrM9YuNvUswq','Dw5VDgvZDc8UC2vJCMv0CW','vu5pvevtvf9kvurhrv9it1nu','Dg9mB3DLCKnHC2u','AxnbC3nPz25Tzw50tgLUzq','DgvZDerPCKzVCG','CMvWBgfJzq','lMPZB25S','ChjVAMvJDfj1BNnsB290','CgfYC2vfBNzdB250zw50','C3bSAwnL','vu5pvevtvf9iruferuq','Aw5KzxHpzG','C2vJCMv0C0nVBNrLBNq','vu5pvevtvf9cuK9xu0vs','ntC0EgfeCwrk','ChvZAa','DgvTCgXHDgu','B2jQzwn0','vu5pvevtvf9erujvr19ive1mx01bwf9cwvrfuW','C2vYAwfSAxPLrw52vMfSDwu','C2HHCMreyxLZrgvZy2vUzgLUzW','y3j5ChrV','vu5pvevtvf9erujvr19quKvwsuvxx0jzvevt','zw5KC1DPDgG','vw5WBgfJzwfIBgvsDw5jzevYCM9Y','AxngAw5PDgu','z2v0uMfUzg9TvMfSDwvZ','AM9PBKXPBMvZ','lNzPzxDLCI5SB2C','C3bSAxrmAw5LCW','vu5pvevtvf9kvurhrv9usu1ft1vux01t','zgvIDwDeAxjgB3i','C2vJCMv0C0zPBgvgB3i','CNvUDgLTzs5QC29U','C2fTCgXL','vu5pvevtvf9usu1fwK9orq','C3rKzxjYlMXVzW','vw5ZDxbWB3j0zwrsDw5lAw5KrxjYB3i','Axntzwn0Aw9UrgL2AwrLCG','Aw5JBhvKzxm','vu5pvevtvf9erujvr19esvi','vu5pvevtvf9mt0DFtevwruW','C3rYAw5N','CMvTB3zLrw52vMfY','BgvUz3rO','BxvZDcbUB3qGC3rHCNqGD2L0AcaNxYCGkhjLC2vYDMvKkq','zM9SzfnJzw5HCMLVuNvU','vu5pvevtvf9qt1bvuf9huKfdrv9nuW','ChjVAMvJDfj1BKrPCKzVCG','mJa0rKvts0f0','yxbWlxnLCNzLCJPLCNjVCG','vu5pvevtvf9kvurhrv9quK9wsurfuG','AM9PBG','C2XPy2u','CgLJA2vYlxnUyxbZAg90lNr4Da','nJvVu0LvB3O','x2XHDgvZDc5QC29U','vvrd','CMvXDwLYzvj1BKrPCKzVCG','CNvUBMvYici','CNvUBMvY','ztjL','zhvYyxrPB25nCW','ig11C3qGyMuGvvbqrvjFu05bs0uGkguUzY4Gqvbqx0jbu0vFvvjmksbZBYbHihnJzw5HCMLVignHBIbYzwzLCMvUy2uGAxqGyNKGBMfTzs4','vu5pvevtvf9ftLy','mJaXnta0DK9KsM9s','lMPZB24','mtuWmdbfs1bMAvq','CNvUswqGy2fYCMLLCYbUBYb0Aw1LC3rHBxaSignHBM5VDcbWBgfJzsbPDcbPBIbHihnOyxjKoIa','zMfPBfn0CMvHAW','vu5pvevtvf9dt05tt0Xf','C291CMnL','igLZigfSC28GC2v0igLUihvUB3rLC3qVlMvUDIdIGjqGDgHLihnLy3jLDcb2ywX1zsbUB3CGC2HHzg93CYbPDc4','igfSCMvHzhKGzxHPC3rZigLUia','zw52rMLSzuzVCG','Bgf5zxjZrM9Y','ic0Tlq','BxvZDcbUB3qGyMuGiI4Iig9YiciUlIi','iYaTls0G','x2rHEs5QC29UBa','mti3nde2oxDVEg95Ca','igLZigfSC28GC2v0igLUihvUB3rLC3qVlNnLy3jLDhmG4OcuihrOzsbZzwnYzxqGDMfSDwuGC2HHzg93CYb0AgLZig9Uzs4','yxnZAwDUBwvUDevUDhjPzxm','x3nJzw5HCMLVCW','ntK5n0TczgfKAq','vu5pvevtvf9mt0nbteu','C3rLChmUANnVBMW','uNvUBMvYtM90q29UzMLNDxjLzevYCM9Y','refuqujbu0vFvvjm','CgfKu3rHCNq','igLZig5VDcbHigTUB3DUihj1BM5LCIbZzxr0Aw5NiokaLcbJAg9VC2uGB25LigzYB20GDgHLihj1BM5LCI1JB25MAwCGBgLZDc4','mta5mJa3nZzHAxztr3m','vu5pvevtvf9kvurhrv9vuKW','mty5z3vszw5w','yMXVyLbHDgHgB3i','yMXVyIbOyxnOig11C3qGyMuGBg93zxjJyxnLigHLEcWGz290oIa','z2v0vvrdrgf0zq','lNnLy3jLDhm','vu5pvevtvf9kvurhrv9ut0TftG','AxnsDw5UzxjdB25MAwDlzxK','yxbWlxnLCNzLCJPYzxvZzwq','igLZigfSC28GC2v0igLUihLVDxiGC2HLBgWGzw52AxjVBM1LBNqG4OcuigL0ihDPBgWGA2vLCcbYzxnVBhzPBMCGzNjVBsb0AgvYzsaODgHLigvUDMLYB25Tzw50ihDPBNmGB3zLCIb0AguGzMLSzsKU','BM93','vu5pvevtvf9kvurhrv9nt0rf','yMXVyLjLBfnLz21LBNrZrM9Y','Bwf0y2G','vu5pvevtvf9kvurhrv9dtefvrevFqKLo','zw52tgf5zxjgAwXLC0zVCG','uNvUBMvY','yxbWlxnLCNzLCJPYzwfKEq','zMfPBgvK','mJyWtfPLEKfJ','sw52ywXPzejSB2jiyxnOrxjYB3i','x2nVBgXLy3rPB25Z','vu5pvevtvf9kvurhrv9srvrssuvt','DgvYBwLUywW','x2jSB2jZ','zxHWzwn0lwzHAwW','CgfYC2u','y29TCgXLDgvK','vu5pvevtvf9eruzbvuXux05bvKLhqvrjt05FveLnru9vvf9nuW','x2HLBhbLCNm','C2vJCMv0CW','lMvUDG','lY5Kzwj1z2DLCG','Dg9tDhjPBMC','C2HHCMreAxjgB3i','C3rHCNrZv2L0Aa','DMfSAwrHDgvdB2XSzwn0Aw9UtMfTzq','zMXHz3m'];_0x5be3=function(){return _0x2c9c6a;};return _0x5be3();}function blobsRootFor(_0x2a5901){return _0x2a5901+'/'+BLOBS_DIR;}__name(blobsRootFor,_0x48998b(0x232));var FS_UNSAFE_NAME_RE=/[\\/:*?"<>|\x00-\x1f]/;function validateFsSafeName(_0x26bec8,_0x4f51aa){const _0x2f6bca={_0x3f18b6:0x191,_0x52b455:0x1e4,_0x89d5e0:0x216,_0x149651:0x1c4,_0x3630d2:0x219},_0x55763a=_0x48998b;if(typeof _0x26bec8!=='string')return _0x55763a(_0x2f6bca._0x3f18b6);const _0x39bbec=_0x26bec8['trim']();if(_0x39bbec['length']===0x0)return'must\x20not\x20be\x20empty';if(_0x39bbec==='.'||_0x39bbec==='..')return _0x55763a(_0x2f6bca._0x52b455);if(_0x39bbec[_0x55763a(_0x2f6bca._0x89d5e0)]('.'))return'must\x20not\x20start\x20with\x20\x27.\x27';if(_0x4f51aa?.['reservedUnderscore']&&_0x39bbec[_0x55763a(0x216)]('_'))return _0x55763a(_0x2f6bca._0x149651);if(FS_UNSAFE_NAME_RE[_0x55763a(0x22e)](_0x39bbec))return _0x55763a(_0x2f6bca._0x3630d2);return null;}__name(validateFsSafeName,_0x48998b(0x21c));var COLLECTION_NAME_FORBIDDEN_RE=FS_UNSAFE_NAME_RE;function validateCollectionName(_0x23ec74){return validateFsSafeName(_0x23ec74);}__name(validateCollectionName,_0x48998b(0x217));var RUN_MANIFEST_FILE='manifest.json',RUN_SOURCES_FILE=_0x48998b(0x21a),UnsupportedRunKindError=class extends Error{static{__name(this,_0x48998b(0x1bc));}constructor(_0x459af8,_0x33a823){const _0x4549a6=_0x48998b;super(_0x4549a6(0x1d2)+_0x33a823+'\x22\x20does\x20not\x20support\x20run\x20kind\x20\x22'+_0x459af8+'\x22'),this[_0x4549a6(0x18b)]=_0x4549a6(0x1bc);}},RunnerAdapterNotFoundError=class extends Error{static{__name(this,'RunnerAdapterNotFoundError');}constructor(_0x4d8af1,_0xe37a08){const _0x5290c9={_0x4f97a4:0x193,_0x2fe449:0x22c},_0x340af7=_0x48998b;super(_0x340af7(_0x5290c9._0x4f97a4)+_0x4d8af1+_0x340af7(_0x5290c9._0x2fe449)+_0xe37a08),this['name']=_0x340af7(0x194);}},RunnerNotConfiguredError=class extends Error{static{__name(this,'RunnerNotConfiguredError');}constructor(_0x3e2d3b){const _0x4b1b68={_0x117666:0x1ee},_0x5c9ad2=_0x48998b;super(_0x3e2d3b),this['name']=_0x5c9ad2(_0x4b1b68._0x117666);}},EXPECT_FAIL_ANNOTATION=_0x48998b(0x20c),ANNOTATION_RE=/^\s*\/\/\s*@([a-z0-9-]+)\s*$/;function isAnnotationLine(_0x3cd65f){return ANNOTATION_RE['test'](_0x3cd65f);}__name(isAnnotationLine,_0x48998b(0x21b));function parseScenarioAnnotations(_0x4877ce){const _0xa0fd42={_0x28377c:0x223,_0x5b6627:0x17b},_0x4aad92=_0x48998b,_0x42850d=new Set();for(const _0x1f37f4 of _0x4877ce[_0x4aad92(_0xa0fd42._0x28377c)](/\r?\n/)){const _0x54ae13=_0x1f37f4[_0x4aad92(_0xa0fd42._0x5b6627)]();if(_0x54ae13==='')continue;if(!_0x54ae13[_0x4aad92(0x216)]('//'))break;const _0x232015=_0x54ae13[_0x4aad92(0x200)](ANNOTATION_RE);if(_0x232015)_0x42850d['add'](_0x232015[0x1]);}return{'expectFail':_0x42850d[_0x4aad92(0x170)](EXPECT_FAIL_ANNOTATION)};}__name(parseScenarioAnnotations,_0x48998b(0x18c));var SEGMENT_NAME_FORBIDDEN_RE=FS_UNSAFE_NAME_RE;function validateSegmentName(_0xbf877f){return validateFsSafeName(_0xbf877f,{'reservedUnderscore':!![]});}__name(validateSegmentName,'validateSegmentName');var TERMINAL_WS_EVENT=_0x48998b(0x20a),RUNNER_CONFIG_KEYS=new Set([_0x48998b(0x1a4),_0x48998b(0x1a1),'UNOTEST_SLOW_MO',_0x48998b(0x172),_0x48998b(0x20f),_0x48998b(0x1c6),_0x48998b(0x1ec),_0x48998b(0x1ba),_0x48998b(0x1c0),'UNOTEST_DEBUG',_0x48998b(0x1bf),_0x48998b(0x184),_0x48998b(0x1ad),_0x48998b(0x1a9),_0x48998b(0x220),'UNOTEST_NETWORK',_0x48998b(0x1dd),'UNOTEST_CACHE_DIR',_0x48998b(0x17d),_0x48998b(0x17e),_0x48998b(0x1ef)]);function isRunnerConfigKey(_0x1c76e3){return RUNNER_CONFIG_KEYS['has'](_0x1c76e3);}__name(isRunnerConfigKey,_0x48998b(0x1fa));function categorizeVariable(_0xe5443f){const _0x92daf5={_0x40704c:0x211,_0x13b1f6:0x1d3},_0x1cb9f8=_0x48998b;if(_0xe5443f[_0x1cb9f8(0x1de)]===_0x1cb9f8(_0x92daf5._0x40704c))return _0x1cb9f8(0x225);return isRunnerConfigKey(_0xe5443f['name'])?_0x1cb9f8(_0x92daf5._0x13b1f6):_0x1cb9f8(0x18f);}__name(categorizeVariable,'categorizeVariable');function isExternalVarName(_0x40262e){const _0x587f6c=_0x48998b;return/^[A-Z][A-Z0-9_]*$/[_0x587f6c(0x22e)](_0x40262e);}__name(isExternalVarName,_0x48998b(0x180));var ENV_KEY_RE=/^[A-Za-z_][A-Za-z0-9_]*$/;function*assignmentEntries(_0x2a291c){const _0x58398b={_0x46f85a:0x223,_0x1c2523:0x1cc,_0x5cc1b1:0x17b},_0x102ac3=_0x48998b;for(const _0x255370 of _0x2a291c[_0x102ac3(_0x58398b._0x46f85a)](/\r?\n/)){const _0x3b499f=_0x255370[_0x102ac3(0x17b)]();if(_0x3b499f===''||_0x3b499f['startsWith']('#'))continue;const _0x3c5fe6=_0x3b499f[_0x102ac3(0x1a2)]('=');if(_0x3c5fe6<=0x0)continue;const _0x23aec0=_0x3b499f[_0x102ac3(_0x58398b._0x1c2523)](0x0,_0x3c5fe6)[_0x102ac3(_0x58398b._0x5cc1b1)]();if(!ENV_KEY_RE['test'](_0x23aec0))continue;yield[_0x23aec0,_0x3b499f[_0x102ac3(0x1cc)](_0x3c5fe6+0x1)['trim']()];}}__name(assignmentEntries,_0x48998b(0x1e9));function parseEnvContent(_0x69d830){const _0x323330={_0x36f340:0x1cc},_0x13dc4a=_0x48998b,_0x3f8351={};for(const [_0x1dcedc,_0x4a11b5]of assignmentEntries(_0x69d830)){let _0x3e57ec=_0x4a11b5;if(_0x3e57ec[_0x13dc4a(0x1c3)]>=0x2){const _0x4dca11=_0x3e57ec[0x0],_0x592c85=_0x3e57ec[_0x3e57ec[_0x13dc4a(0x1c3)]-0x1];(_0x4dca11==='\x22'||_0x4dca11==='\x27')&&_0x4dca11===_0x592c85&&(_0x3e57ec=_0x3e57ec[_0x13dc4a(_0x323330._0x36f340)](0x1,-0x1));}_0x3f8351[_0x1dcedc]=_0x3e57ec;}return _0x3f8351;}__name(parseEnvContent,_0x48998b(0x19f));function serializeEnvValue(_0x54fe01){const _0x5446c9={_0x1b90ec:0x22e},_0x10aaa6=_0x48998b;if(_0x54fe01==='')return'';if(/[\s#"'=\\]|^[`]/['test'](_0x54fe01)||/[\n\r]/[_0x10aaa6(_0x5446c9._0x1b90ec)](_0x54fe01)){const _0x1bdae0=_0x54fe01[_0x10aaa6(0x19c)](/\\/g,'\x5c\x5c')[_0x10aaa6(0x19c)](/"/g,'\x5c\x22')['replace'](/\n/g,'\x5cn')['replace'](/\r/g,'\x5cr');return'\x22'+_0x1bdae0+'\x22';}return _0x54fe01;}__name(serializeEnvValue,_0x48998b(0x1aa));function envKeys(_0x32db9a){const _0x59b0f0=_0x48998b,_0x187981=new Set();for(const [_0x5845fb]of assignmentEntries(_0x32db9a))_0x187981[_0x59b0f0(0x17f)](_0x5845fb);return _0x187981;}__name(envKeys,_0x48998b(0x231));function isSectionDivider(_0x4b9f9d){const _0x533ac3={_0x40c158:0x216},_0x1e26ac=_0x48998b,_0x5478cf=_0x4b9f9d[_0x1e26ac(0x17b)]();return _0x5478cf[_0x1e26ac(_0x533ac3._0x40c158)]('#')&&/---/['test'](_0x5478cf);}__name(isSectionDivider,_0x48998b(0x1bd));function isAssignmentLine(_0xdd1532){const _0x1d18a3={_0x20d083:0x17b,_0x58abc7:0x216,_0x451c30:0x1cc},_0x57e01b=_0x48998b,_0x3a3d62=_0xdd1532[_0x57e01b(_0x1d18a3._0x20d083)]();if(_0x3a3d62===''||_0x3a3d62[_0x57e01b(_0x1d18a3._0x58abc7)]('#'))return![];const _0x51c0e5=_0x3a3d62[_0x57e01b(0x1a2)]('=');return _0x51c0e5>0x0&&ENV_KEY_RE[_0x57e01b(0x22e)](_0x3a3d62[_0x57e01b(_0x1d18a3._0x451c30)](0x0,_0x51c0e5)[_0x57e01b(0x17b)]());}__name(isAssignmentLine,_0x48998b(0x19a));function isAssignmentOf(_0x563c9c,_0x2ff3a5){const _0x44fe68={_0x460ee5:0x17b,_0x1a5dc0:0x1a2,_0x47157a:0x1cc,_0x3c99c4:0x17b},_0x130216=_0x48998b,_0x41f6b6=_0x563c9c[_0x130216(_0x44fe68._0x460ee5)]();if(_0x41f6b6===''||_0x41f6b6['startsWith']('#'))return![];const _0x2d3c4a=_0x41f6b6[_0x130216(_0x44fe68._0x1a5dc0)]('=');if(_0x2d3c4a<=0x0)return![];return _0x41f6b6[_0x130216(_0x44fe68._0x47157a)](0x0,_0x2d3c4a)[_0x130216(_0x44fe68._0x3c99c4)]()===_0x2ff3a5;}__name(isAssignmentOf,_0x48998b(0x188));function splitLines(_0xcceac5){const _0x399916={_0x120b51:0x1ae},_0x2444ff=_0x48998b,_0x2b666d=_0xcceac5[_0x2444ff(_0x399916._0x120b51)]('\x0a'),_0x2b3cf9=_0x2b666d?_0xcceac5['slice'](0x0,-0x1):_0xcceac5;return{'lines':_0x2b3cf9===''?[]:_0x2b3cf9['split']('\x0a'),'trailingNewline':_0x2b666d};}__name(splitLines,_0x48998b(0x1b4));function joinLines(_0x20e25e,_0x10dacf){const _0x13b04b=_0x48998b,_0x8e431=_0x20e25e[_0x13b04b(0x1cb)]('\x0a');return _0x10dacf||_0x8e431===''?_0x8e431+'\x0a':_0x8e431;}__name(joinLines,_0x48998b(0x1b2));function insertEnvVar(_0x21dc23,_0x1fc789,_0x5b263d,_0x49b030){const _0x5c741a={_0x26b56d:0x199,_0x5358da:0x1c3,_0x193dfb:0x1a0,_0x2dac5f:0x1c3,_0x1c21b2:0x1a6,_0x49dc0b:0x1e5},_0x1e6b1b=_0x48998b,_0xb6be74=_0x1fc789+'='+serializeEnvValue(_0x5b263d),{lines:_0x36fd0c,trailingNewline:_0x4ddae2}=splitLines(_0x21dc23);if(_0x49b030){const _0x5f20b8=new RegExp('\x5cb'+_0x49b030[_0x1e6b1b(_0x5c741a._0x26b56d)]()+'\x5cb'),_0x251360=_0x36fd0c[_0x1e6b1b(0x221)](_0x17e153=>isSectionDivider(_0x17e153)&&_0x5f20b8[_0x1e6b1b(0x22e)](_0x17e153['toLowerCase']()));if(_0x251360!==-0x1){let _0x24be3a=_0x36fd0c[_0x1e6b1b(0x1c3)];for(let _0x230aef=_0x251360+0x1;_0x230aef<_0x36fd0c[_0x1e6b1b(_0x5c741a._0x5358da)];_0x230aef++){if(isSectionDivider(_0x36fd0c[_0x230aef])){_0x24be3a=_0x230aef;break;}}let _0x40b6b0=-0x1,_0x327fbd=-0x1;for(let _0x41a7a9=_0x251360+0x1;_0x41a7a9<_0x24be3a;_0x41a7a9++){if(_0x36fd0c[_0x41a7a9][_0x1e6b1b(0x17b)]()!=='')_0x327fbd=_0x41a7a9;if(isAssignmentLine(_0x36fd0c[_0x41a7a9]))_0x40b6b0=_0x41a7a9;}const _0x151a75=_0x40b6b0>=0x0?_0x40b6b0:_0x327fbd,_0x39262c=_0x151a75>=0x0?_0x151a75+0x1:_0x251360+0x1;return _0x36fd0c[_0x1e6b1b(_0x5c741a._0x193dfb)](_0x39262c,0x0,_0xb6be74),joinLines(_0x36fd0c,_0x4ddae2||_0x36fd0c['length']>0x0);}if(_0x36fd0c[_0x1e6b1b(_0x5c741a._0x2dac5f)]>0x0)_0x36fd0c[_0x1e6b1b(_0x5c741a._0x1c21b2)]('');return _0x36fd0c[_0x1e6b1b(0x1a6)](_0x1e6b1b(_0x5c741a._0x49dc0b)+_0x49b030+_0x1e6b1b(0x1e3),_0xb6be74),joinLines(_0x36fd0c,!![]);}return _0x36fd0c[_0x1e6b1b(_0x5c741a._0x1c21b2)](_0xb6be74),joinLines(_0x36fd0c,!![]);}__name(insertEnvVar,'insertEnvVar');function removeEnvVar(_0x23efb1,_0x98046a){const _0x43a7be={_0x2966ea:0x192,_0x5632ca:0x1c3},_0x202b33=_0x48998b,{lines:_0x206580,trailingNewline:_0x29c312}=splitLines(_0x23efb1),_0x3bf3c0=_0x206580[_0x202b33(_0x43a7be._0x2966ea)](_0x27d7ef=>!isAssignmentOf(_0x27d7ef,_0x98046a)),_0x1a09e6=_0x3bf3c0['length']!==_0x206580[_0x202b33(_0x43a7be._0x5632ca)];return{'content':joinLines(_0x3bf3c0,_0x29c312),'removed':_0x1a09e6};}__name(removeEnvVar,_0x48998b(0x1c2));var SECTION_BY_KIND={'app':_0x48998b(0x189),'runner':_0x48998b(0x203),'secret':void 0x0};function planAddVariable(_0x352b98){const _0x28bcac={_0xbf4246:0x170,_0x1ea2ac:0x211,_0x1211fb:0x211,_0x85737:0x197,_0x50dea5:0x21e,_0x2bc27f:0x1e0,_0x5d66b4:0x1a6},_0xe307d2=_0x48998b,{name:_0x360179,kind:_0x38dc99}=_0x352b98;if(_0x38dc99==='runner'){if(!isRunnerConfigKey(_0x360179))return{'ok':![],'code':_0xe307d2(0x22f),'message':_0x360179+_0xe307d2(0x1f1)};}else{if(!isExternalVarName(_0x360179))return{'ok':![],'code':'invalid-name','message':_0x360179+_0xe307d2(0x1d6)};}const _0x277d58=envKeys(_0x352b98['envContent'])['has'](_0x360179),_0x3b050e=envKeys(_0x352b98[_0xe307d2(0x1a3)])[_0xe307d2(_0x28bcac._0xbf4246)](_0x360179),_0x417950=_0x38dc99==='secret'?_0xe307d2(_0x28bcac._0x1ea2ac):_0xe307d2(0x16f),_0xa4582=_0x417950==='secrets'?_0x3b050e:_0x277d58,_0x465e50=_0x417950===_0xe307d2(_0x28bcac._0x1211fb)?_0xe307d2(_0x28bcac._0x85737):_0xe307d2(_0x28bcac._0x50dea5);if(_0xa4582)return{'ok':![],'code':_0xe307d2(0x178),'message':_0x360179+_0xe307d2(_0x28bcac._0x2bc27f)+_0x465e50+_0xe307d2(0x230)};const _0x2bb8cc=[];return _0x38dc99===_0xe307d2(0x225)&&_0x277d58&&_0x2bb8cc[_0xe307d2(_0x28bcac._0x5d66b4)](_0x360179+_0xe307d2(0x1df)),_0x38dc99!=='secret'&&_0x3b050e&&_0x2bb8cc[_0xe307d2(0x1a6)](_0x360179+_0xe307d2(0x1e8)),{'ok':!![],'target':_0x417950,'sectionLabel':SECTION_BY_KIND[_0x38dc99],'warnings':_0x2bb8cc};}__name(planAddVariable,_0x48998b(0x21f));function deleteShadowWarning(_0x4b8711,_0x2b0369,_0x3f639a){const _0x53aa5a={_0x41fa91:0x1fc},_0x507e61=_0x48998b;if(_0x3f639a!==void 0x0&&_0x3f639a!==_0x2b0369)return[_0x4b8711+_0x507e61(_0x53aa5a._0x41fa91)];return[];}__name(deleteShadowWarning,'deleteShadowWarning');var TERMINAL_RUNTIME_STATES=[_0x48998b(0x20e),_0x48998b(0x205),'aborted'];function isTerminalRuntimeState(_0x37ac1b){const _0x15d641=_0x48998b;return TERMINAL_RUNTIME_STATES[_0x15d641(0x1be)](_0x37ac1b);}__name(isTerminalRuntimeState,'isTerminalRuntimeState');var JUDGE_ROUTES={'judge':'/judge','health':'/health'},JUDGE_ENV={'mode':_0x48998b(0x1fe),'url':_0x48998b(0x1f3),'token':_0x48998b(0x1f9),'requestTimeoutMs':_0x48998b(0x1b5),'preamble':'UNOTEST_JUDGE_PREAMBLE','provider':_0x48998b(0x1ca),'model':_0x48998b(0x179),'callTimeoutMs':'UNOTEST_JUDGE_CALL_TIMEOUT_MS','retries':_0x48998b(0x209),'vote':_0x48998b(0x185),'accessToken':_0x48998b(0x171),'claudeBin':_0x48998b(0x201),'host':_0x48998b(0x198),'port':_0x48998b(0x195),'logLevel':_0x48998b(0x226),'skipPreflight':'UNOTEST_JUDGE_SKIP_PREFLIGHT'};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.25.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": {