@unotest/web 0.24.0 → 0.26.0

package/CHANGELOG.md

@@ -1,5 +1,352 @@
 # 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.
+
+### Patch Changes
+
+- Updated dependencies [3eede7c]
+- Updated dependencies [6d1c612]
+- Updated dependencies [dbfa36f]
+- Updated dependencies [c43aa00]
+- Updated dependencies [8ec4177]
+  - @unotest/viewer@0.26.0
+  - @unotest/protocol@0.26.0
+  - @unotest/core@0.26.0
+  - @unotest/dsl@0.26.0
+  - @unotest/grounder-client@0.26.0
+
+## [0.25.0] - 2026-08-29
+
+### Minor Changes
+
+- adb9d72: Viewer: a pinned Home tab, a multi-row tab strip, and live tiles.
+
+  The viewer ships with `@unotest/web` and opens via `npx @unotest/web viewer`,
+  so the change lands here too. The project-health overview used to render
+  only when no tab was open — it disappeared exactly while you were working.
+  It is now a pinned first tab: always present, never closable, and where
+  "Close All" leaves you. The tab strip wraps into up to three rows instead
+  of scrolling sideways, tabs are pills (middle-click closes, `⋮` opens the
+  right-click actions), and the strip is a proper `tablist` for screen
+  readers. A scenario running right now breathes on the overview field: the
+  tile fades under a warm ring, still when paused. Full notes in
+  `@unotest/viewer`'s changelog.
+
+- 70f2e11: Judge: provider edge cases, a startup preflight, and logs.
+
+  **Vertex `GOOGLE_CLOUD_LOCATION=global` could not work.** The endpoint was
+  built as `https://<location>-aiplatform.googleapis.com`, so `global` asked
+  `global-aiplatform.googleapis.com` — not a Vertex host. Google's edge
+  answered 404 with an HTML page, which arrived as "model not found". The
+  global endpoint has no region prefix; it is now special-cased. `global` is
+  the default in Google's own docs, so this was the first thing a Vertex user
+  hit. A model id containing a slash
+  (`publishers/anthropic/models/claude-haiku-4-5`) is now passed through
+  instead of being forced under `publishers/google`, and a pasted
+  `models/gemini-2.5-flash` no longer doubles the prefix on the Gemini API.
+
+  **Backend replies are classified instead of lumped together.**
+
+  - `401`/`403` → `config` with the variable to fix (`OPENAI_API_KEY`, ADC,
+    an expired `UNOTEST_JUDGE_ACCESS_TOKEN`), no longer indistinguishable
+    from a model fault.
+  - `429` and `5xx` → retried transparently with a short backoff that
+    honours `Retry-After`. A single rate limit used to kill a whole scenario.
+    The retry policy is a decorator over `JudgeProvider`, not a loop inside
+    the HTTP helper, so it covers every provider — `claude` spawns a process
+    and therefore had no re-send at all. A `claude` usage limit is
+    deliberately still reported rather than retried: the window is seconds,
+    the limit is not.
+  - A non-JSON error body says the endpoint is wrong rather than quoting an
+    HTML page back as the backend's opinion of the model. The body is kept
+    for `debug` logging.
+  - OpenAI `finish_reason: length` and Anthropic `stop_reason: max_tokens`
+    are named as token-limit truncation instead of surfacing as "did not
+    reply with the requested JSON verdict".
+  - The verdict parser accepts `"PASS"` and a JSON object embedded in prose —
+    providers without a JSON mode do both.
+
+  **`UNOTEST_JUDGE_VOTE=N` no longer fails on one bad ballot.** The N calls
+  ran under `Promise.all`, so voting — the reliability feature — tripled the
+  chance that one transient error killed the request. Errored ballots are now
+  dropped as long as a majority of the N calls still voted; a tie among the
+  survivors re-raises the failure rather than picking a side.
+
+  **The service checks its credentials before it says "listening".** Each
+  provider exposes a free probe (an ADC token exchange, `GET /models`,
+  `claude --version`) — no model call, no cost. A failing probe prints the
+  reason and exits non-zero (`UNOTEST_JUDGE_SKIP_PREFLIGHT=1` waives it), and
+  `npx @unotest/judge --check` runs just the probe for start scripts.
+  `GET /health` reports the same thing instead of an unconditional
+  `{"ok":true}`: `503` + `{"ok":false,"code":"config","error":"..."}`, cached
+  for a few seconds. The waiver covers the startup gate only — a service
+  started under it still answers `/health` from a real probe, and `--check`
+  still answers honestly, because the operator who reaches for the flag is
+  precisely the one whose credentials are dead. A static
+  `UNOTEST_JUDGE_ACCESS_TOKEN` is validated too, against Google's free
+  `tokeninfo`: those tokens live about an hour and refresh themselves never,
+  so "valid at startup" is a different question from "valid now".
+
+  ADC that expires on a daily reauth policy is a normal morning state, not a
+  one-off misconfiguration — it should not cost a five-minute run to
+  discover.
+
+  **New: `UNOTEST_JUDGE_LOG_LEVEL`** (falls back to the `UNOTEST_LOG_LEVEL`
+  `@unotest/web` already reads). At the default `info`, one line per judged
+  request — verdict, attempts, model, latency — with errors on stderr; a run
+  of 21 assertions with `VOTE=3` is 63 billed model calls that previously
+  left no trace. At `debug`, per call: the effective prompt (rubric
+  **including** any `UNOTEST_JUDGE_PREAMBLE`), each ballot with its
+  reasoning, and the raw provider reply. **The judged text is application
+  content** — debug writes it to stdout verbatim, which is why it is opt-in
+  and never the default.
+
+  An oversized request body now returns `413` with a reason; the socket used
+  to be destroyed while the client was still writing, so the client saw
+  `socket hang up`.
+
+  **`@unotest/web`:** the `judge:verdict` run artifact records `preamble`
+  beside `rubric` when one is set. The model saw the concatenation, but only
+  the split says which half came from the scenario and which from the
+  environment — without it, "a red step is explainable without a re-run" held
+  only for whoever also knew the env file. A judge request that outlives
+  `UNOTEST_JUDGE_TIMEOUT_MS` now says so, and names the service-side
+  `UNOTEST_JUDGE_CALL_TIMEOUT_MS` it may be racing.
+
+  The Claude CLI provider also stopped leaking a timer: the per-call budget
+  is now our own timer, cleared on every exit path. `child_process.spawn`'s
+  `timeout` option does not clear itself when the spawn fails, so a missing
+  binary held the event loop for the whole budget — 15s for a `--version`
+  probe, 120s for a verdict.
+
+  **Breaking (0.x minor):** `@unotest/judge` no longer exports `ExecFileFn` /
+  `ExecFileResult`; the Claude CLI provider takes `runImpl: RunProcess`
+  instead of `execImpl`, because the prompt moved from `argv` to stdin — a
+  long judged text used to overflow `ARG_MAX` and fail as a bare `E2BIG`.
+
+### Patch Changes
+
+- Updated dependencies [70f2e11]
+- Updated dependencies [adb9d72]
+  - @unotest/protocol@0.25.0
+  - @unotest/viewer@0.25.0
+  - @unotest/core@0.25.0
+  - @unotest/dsl@0.25.0
+  - @unotest/grounder-client@0.25.0
+
 ## [0.24.0] - 2026-08-26
 
 ### Minor Changes

package/README.md

@@ -65,6 +65,71 @@ npx @unotest/web e2e <name>      # one scenario
 npx @unotest/web e2e             # list / usage
 ```
 
+Runs of one project take turns. A second run — from another terminal, the
+viewer's Run button or an agent — joins a queue in `unotest/.queue/` and
+starts when the machine is free, instead of fighting the first one over
+the same browser and the same seeded data. It costs nothing when nothing
+else is running, the viewer shows who is waiting (and can cancel them),
+and Ctrl-C gives up your place in line. Raise `queue.concurrency` in
+`unotest.config` to allow more at once, or set `UNOTEST_NO_QUEUE=1` for a
+single command that must not wait. A collection is one run: its `workers`
+still run in parallel inside it.
+
+### Running on a schedule
+
+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" },
+  ],
+};
+```
+
+`npx @unotest/web schedules` prints them. Nothing in the CLI ticks: cron
+is executed by whatever hosts your runs — your CI, or a box — so a clone
+of your repo never starts running suites in the background. Run one now
+with `npx @unotest/web collection nightly --scheduled` (that also runs its
+`prepare` command, inside the same run slot).
+
+### Sending the suite to a box
+
+If your team runs a box (a machine that keeps the environments, the
+schedules and the history in one place), tests get there by being pushed:
+
+```sh
+npx @unotest/web bundle push --box https://tests.example.com
+```
+
+It packs `unotest/`, your `unotest.config`, `package.json` and its
+lockfile — nothing else — and uploads that. **The box never reads your
+repository**: it holds no key to it, so nothing is there that you did not
+send. Uncommitted work is included and marked *wip*, which is what makes
+this a fast loop rather than a release step. Secrets stay behind:
+`unotest/.env*` and `.secrets*` never travel, because environment values
+belong to the environment and are injected over the bundle when it runs.
+
+What would break on the box is refused here instead — a scenario that
+reads a file outside `unotest/`, a missing lockfile, no `@unotest/web`
+pin. The bundle's id is a hash of its content, so pushing an unchanged
+suite is a no-op.
+
+From a CI job, push and run in one command:
+
+```sh
+npx @unotest/web bundle push --run --env test --collection smoke --pr 412
+```
+
+The box answers as soon as the runs are queued and gives you their ids —
+a suite takes minutes, and a request held open that long is a timeout,
+not a result. Watch them in the viewer, or let the box report the checks
+back to GitHub. `--pr` makes a newer push withdraw the older runs of the
+same pull request that are still waiting, so three pushes in five minutes
+cost one suite. Recipe: `guides/manuals/ci-setup.md`.
+
 ## 5. Watch it run — the viewer
 
 `npx @unotest/web viewer` opens a local UI (no cloud, no account):

package/dist/config/schema.d.ts

@@ -105,6 +105,49 @@ declare const LinterConfigSchema: z.ZodObject<{
     rules: Partial<Record<"lint:deep-css" | "lint:xpath" | "lint:obfuscated-class" | "lint:pause-explicit" | "lint:disambig-by-index" | "lint:evaluate-discouraged" | "lint:scenario-in-root" | "lint:mustache-in-dsl" | "lint:goto-concat" | "lint:regex-invalid" | "lint:echo-assert" | "lint:api-call-file-body" | "lint:lint-ok-missing-reason" | "lint:flow-returns-value" | "validator:unknown-function" | "validator:arity" | "validator:arg-kind" | "validator:step-coverage" | "validator:step-shape" | "validator:meta-shape" | "validator:function-shape" | "validator:for-shape" | "validator:if-shape" | "validator:var-shape" | "validator:unsupported-statement" | "validator:unsupported-expression" | "validator:string-concat" | "validator:semantic-loss" | "validator:list-arg" | "validator:wrapped-format", "off" | "warn" | "error">>;
 }>;
 type LinterConfig = z.infer<typeof LinterConfigSchema>;
+declare const QueueConfigSchema: z.ZodObject<{
+    /** Turn queueing off for this project. `UNOTEST_NO_QUEUE=1` does the
+     *  same for a single command. */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    /** How many runs may be in flight for one environment. 1 (the default)
+     *  is strict FIFO — the machine runs one thing at a time. */
+    concurrency: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    concurrency: number;
+}, {
+    enabled?: boolean | undefined;
+    concurrency?: number | undefined;
+}>;
+type QueueConfig = z.infer<typeof QueueConfigSchema>;
+declare const ScheduleSchema: z.ZodObject<{
+    /** Collection name — file stem under `_collections/`. */
+    collection: z.ZodString;
+    /** Standard 5-field cron expression, interpreted in the timezone of
+     *  whatever executes it (a box container is UTC unless its TZ says
+     *  otherwise). Validated as a non-empty string and no further:
+     *  checking the EXPRESSION would mean shipping the cron parser this
+     *  package deliberately does not have. */
+    cron: z.ZodString;
+    /** Environment the run happens in (`.env.<name>` overlay + its own
+     *  `.runs.<name>` root). Absent = base. */
+    env: z.ZodOptional<z.ZodString>;
+    /** Shell command run before the collection, inside the same queue slot
+     *  — seeding a database, resetting a fixture. Its failure is reported
+     *  as "the environment was not prepared", not as a red suite. */
+    prepare: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    collection: string;
+    cron: string;
+    env?: string | undefined;
+    prepare?: string | undefined;
+}, {
+    collection: string;
+    cron: string;
+    env?: string | undefined;
+    prepare?: string | undefined;
+}>;
+type ScheduleConfig = z.infer<typeof ScheduleSchema>;
 declare const McpConfigSchema: z.ZodObject<{
     transport: z.ZodLiteral<"stdio">;
 }, "strip", z.ZodTypeAny, {
@@ -172,15 +215,15 @@ declare const WebServerConfigSchema: z.ZodObject<{
     /** How long to wait for the URL to come up after spawning. */
     timeoutMs: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
-    url: string;
-    timeoutMs: number;
     command: string;
+    url: string;
     reuseExistingServer: boolean;
+    timeoutMs: number;
 }, {
-    url: string;
     command: string;
-    timeoutMs?: number | undefined;
+    url: string;
     reuseExistingServer?: boolean | undefined;
+    timeoutMs?: number | undefined;
 }>;
 type WebServerConfig = z.infer<typeof WebServerConfigSchema>;
 declare const UnotestConfigSchema: z.ZodObject<{
@@ -206,15 +249,15 @@ declare const UnotestConfigSchema: z.ZodObject<{
         /** How long to wait for the URL to come up after spawning. */
         timeoutMs: z.ZodDefault<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
-        url: string;
-        timeoutMs: number;
         command: string;
+        url: string;
         reuseExistingServer: boolean;
+        timeoutMs: number;
     }, {
-        url: string;
         command: string;
-        timeoutMs?: number | undefined;
+        url: string;
         reuseExistingServer?: boolean | undefined;
+        timeoutMs?: number | undefined;
     }>>;
     browsers: z.ZodArray<z.ZodEnum<["chromium", "firefox", "webkit"]>, "many">;
     channel: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"chrome">, z.ZodLiteral<"msedge">, z.ZodLiteral<"chrome-beta">, z.ZodNull]>>;
@@ -327,6 +370,48 @@ declare const UnotestConfigSchema: z.ZodObject<{
     }, {
         transport: "stdio";
     }>;
+    queue: z.ZodObject<{
+        /** Turn queueing off for this project. `UNOTEST_NO_QUEUE=1` does the
+         *  same for a single command. */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /** How many runs may be in flight for one environment. 1 (the default)
+         *  is strict FIFO — the machine runs one thing at a time. */
+        concurrency: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        concurrency: number;
+    }, {
+        enabled?: boolean | undefined;
+        concurrency?: number | undefined;
+    }>;
+    /** Scheduled runs (data — nothing here executes them). */
+    schedules: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Collection name — file stem under `_collections/`. */
+        collection: z.ZodString;
+        /** Standard 5-field cron expression, interpreted in the timezone of
+         *  whatever executes it (a box container is UTC unless its TZ says
+         *  otherwise). Validated as a non-empty string and no further:
+         *  checking the EXPRESSION would mean shipping the cron parser this
+         *  package deliberately does not have. */
+        cron: z.ZodString;
+        /** Environment the run happens in (`.env.<name>` overlay + its own
+         *  `.runs.<name>` root). Absent = base. */
+        env: z.ZodOptional<z.ZodString>;
+        /** Shell command run before the collection, inside the same queue slot
+         *  — seeding a database, resetting a fixture. Its failure is reported
+         *  as "the environment was not prepared", not as a red suite. */
+        prepare: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        collection: string;
+        cron: string;
+        env?: string | undefined;
+        prepare?: string | undefined;
+    }, {
+        collection: string;
+        cron: string;
+        env?: string | undefined;
+        prepare?: string | undefined;
+    }>, "many">>;
     sandbox: z.ZodObject<{
         /** Default cwd for `shell(cmd, ...args)`. Defaults to `process.cwd()`. */
         shellCwd: z.ZodOptional<z.ZodString>;
@@ -403,6 +488,16 @@ declare const UnotestConfigSchema: z.ZodObject<{
     mcp: {
         transport: "stdio";
     };
+    queue: {
+        enabled: boolean;
+        concurrency: number;
+    };
+    schedules: {
+        collection: string;
+        cron: string;
+        env?: string | undefined;
+        prepare?: string | undefined;
+    }[];
     sandbox: {
         shellCwd?: string | undefined;
         shellTimeoutMs?: number | undefined;
@@ -413,10 +508,10 @@ declare const UnotestConfigSchema: z.ZodObject<{
     };
     baseUrl?: string | undefined;
     webServer?: {
-        url: string;
-        timeoutMs: number;
         command: string;
+        url: string;
         reuseExistingServer: boolean;
+        timeoutMs: number;
     } | undefined;
     channel?: "chrome" | "msedge" | "chrome-beta" | null | undefined;
     storageState?: string | undefined;
@@ -455,6 +550,10 @@ declare const UnotestConfigSchema: z.ZodObject<{
     mcp: {
         transport: "stdio";
     };
+    queue: {
+        enabled?: boolean | undefined;
+        concurrency?: number | undefined;
+    };
     sandbox: {
         shellCwd?: string | undefined;
         shellTimeoutMs?: number | undefined;
@@ -465,16 +564,22 @@ declare const UnotestConfigSchema: z.ZodObject<{
     };
     baseUrl?: string | undefined;
     webServer?: {
-        url: string;
         command: string;
-        timeoutMs?: number | undefined;
+        url: string;
         reuseExistingServer?: boolean | undefined;
+        timeoutMs?: number | undefined;
     } | undefined;
     channel?: "chrome" | "msedge" | "chrome-beta" | null | undefined;
     storageState?: string | undefined;
+    schedules?: {
+        collection: string;
+        cron: string;
+        env?: string | undefined;
+        prepare?: string | undefined;
+    }[] | undefined;
 }>;
 type UnotestConfig = z.infer<typeof UnotestConfigSchema>;
 type UnotestConfigInput = z.input<typeof UnotestConfigSchema>;
 declare const DEFAULT_CONFIG: UnotestConfig;
 
-export { type Browser, type BrowserChannel, BrowserChannelSchema, BrowserSchema, DEFAULT_CONFIG, type DialogPolicy, DialogPolicySchema, type FailureBundleConfig, FailureBundleConfigSchema, type LinterConfig, LinterConfigSchema, type LinterRuleId, LinterRuleIdSchema, type LinterSeverity, LinterSeveritySchema, type McpConfig, McpConfigSchema, type RetryConfig, RetryConfigSchema, type RetryReason, RetryReasonSchema, type SandboxConfig, SandboxConfigSchema, type UnotestConfig, type UnotestConfigInput, UnotestConfigSchema, type Viewport, ViewportSchema, type WebServerConfig, WebServerConfigSchema };
+export { type Browser, type BrowserChannel, BrowserChannelSchema, BrowserSchema, DEFAULT_CONFIG, type DialogPolicy, DialogPolicySchema, type FailureBundleConfig, FailureBundleConfigSchema, type LinterConfig, LinterConfigSchema, type LinterRuleId, LinterRuleIdSchema, type LinterSeverity, LinterSeveritySchema, type McpConfig, McpConfigSchema, type QueueConfig, QueueConfigSchema, type RetryConfig, RetryConfigSchema, type RetryReason, RetryReasonSchema, type SandboxConfig, SandboxConfigSchema, type ScheduleConfig, ScheduleSchema, type UnotestConfig, type UnotestConfigInput, UnotestConfigSchema, type Viewport, ViewportSchema, type WebServerConfig, WebServerConfigSchema };