slicetest 0.8.0 → 0.10.0

package/dist/runtime.js

@@ -4,6 +4,7 @@ import os from "node:os";
 import path from "node:path";
 import { App } from "./app.js";
 import { Issuer } from "./auth.js";
+import { seedFiles } from "./config.js";
 import { Dependency } from "./containers.js";
 import { connectionVars } from "./connection.js";
 import { Db, formatChanges, noDatabase } from "./db.js";
@@ -125,7 +126,7 @@ export class Runtime {
                     schemas: opts.db.schemas,
                     keep: opts.db.keep,
                     ignoreChanges: opts.db.ignoreChanges,
-                    seedFile: opts.db.seed && path.resolve(opts.root, opts.db.seed),
+                    seedFiles: seedFiles(opts.db.seed).map((f) => path.resolve(opts.root, f)),
                 })
                 : noDatabase();
             const started = await Promise.allSettled(Object.entries(opts.containers).map(async ([name, c]) => containers.set(name, await Dependency.start(name, c))));
@@ -234,7 +235,7 @@ export class Runtime {
                     throw new Error(`slicetest: unknown container "${name}". Declared containers: ${[...this.containers.keys()].join(", ") || "(none)"}`);
                 return c;
             },
-            trace: async (opts) => mask(buildTrace(this.http.history, this.stubs.values(), await this.db.changesSinceStart(), this.mailbox), opts),
+            trace: async (opts) => mask(buildTrace(this.http.requests, this.stubs.values(), await this.db.changesSinceStart(), this.mailbox), opts),
             diagram: () => this.diagram(),
             get mail() {
                 if (!mailbox)
@@ -252,6 +253,34 @@ export class Runtime {
     #processes() {
         return [this.app, ...this.services.values()];
     }
+    // Marked busy until afterScenario() sees `idle` answer 2xx, so a scenario that failed, or that Vitest
+    // timed out mid-wait, leaves its processes flagged and the next scenario restarts them.
+    #busy = new Set();
+    #queue = Promise.resolve();
+    /** Not concurrent: a scenario Vitest timed out leaves its beforeScenario() running, and a second would race it for `this.app`. */
+    #serial(fn) {
+        const run = this.#queue.then(fn);
+        this.#queue = run.catch(() => { });
+        return run;
+    }
+    #hooked(hook) {
+        const all = [
+            { name: "app", proc: this.app, options: this.opts.app },
+            ...[...this.services].map(([n, proc]) => ({ name: `services.${n}`, proc, options: this.opts.services[n] })),
+        ];
+        return all.filter((p) => p.options[hook] && !p.proc.exited);
+    }
+    /** Every busy process fails the scenario, not only the first, and each is flagged for a restart. */
+    async #waitIdle(deadline) {
+        const hooked = this.#hooked("idle");
+        const results = await Promise.allSettled(hooked.map(async ({ name, proc, options }) => {
+            await pollIdle(proc, options.idle, `${name}.idle`, deadline);
+            this.#busy.delete(proc);
+        }));
+        const failed = results.flatMap((r) => (r.status === "rejected" ? [r.reason.message] : []));
+        if (failed.length > 0)
+            throw new Error(failed.join("\n"));
+    }
     #usageDir;
     /** Note which provider operations the stubs were called for, before their calls are cleared. */
     #collectUsage() {
@@ -266,20 +295,30 @@ export class Runtime {
                 this.#used.set(name, used);
         }
     }
-    async beforeScenario() {
+    beforeScenario() {
+        return this.#serial(() => this.#before());
+    }
+    /** `deadline`: when the test's own timeout is about to end, so `idle` reports before Vitest does. */
+    afterScenario(deadline) {
+        return this.#serial(() => this.#after(deadline));
+    }
+    async #before() {
         this.#collectUsage();
-        // A crash already failed the scenario that caused it; give the next one a fresh process.
-        for (const [name, service] of this.services) {
-            if (!service.exited)
-                continue;
-            await service.stop();
-            this.services.set(name, await App.start(this.opts.services[name], this.opts.root, this.vars, `service.${name}`, service.port));
+        // A failed scenario skipped afterScenario(). One look, not a wait: it already failed, and a restart ends the work.
+        for (const { proc, options } of this.#hooked("idle")) {
+            if (this.#busy.has(proc) && (await probeIdle(proc, options.idle)))
+                this.#busy.delete(proc);
         }
-        if (this.app.exited) {
+        // Stop before the reset, start after. Not start-then-reset: the old process could still write into the
+        // fresh database, and the new one would boot against stale rows.
+        const restartService = (name, service) => service.exited || this.#busy.has(service) || this.opts.services[name].restart === "scenario";
+        const services = [...this.services].filter(([name, service]) => restartService(name, service));
+        const restartApp = !!this.app.exited || this.#busy.has(this.app) || this.opts.app.restart === "scenario";
+        if (restartApp)
             await this.app.stop();
-            this.app = await App.start(this.opts.app, this.opts.root, this.vars);
-            this.#http = this.#client();
-        }
+        for (const [, service] of [...services].reverse())
+            await service.stop();
+        this.#busy.clear();
         this.#contract = [];
         await this.db.reset();
         for (const stub of this.stubs.values())
@@ -293,15 +332,32 @@ export class Runtime {
         this.interceptor?.blocked.clear();
         await Promise.all([...this.containers.values()].map((c) => c.reset()));
         this.http.reset();
+        for (const [name, old] of services) {
+            this.services.set(name, await App.start(this.opts.services[name], this.opts.root, this.vars, `service.${name}`, old.port));
+        }
+        if (restartApp) {
+            this.app = await App.start(this.opts.app, this.opts.root, this.vars);
+            this.#http = this.#client();
+        }
         for (const p of this.#processes())
             p.beginScenario();
+        // Not before the start: a cache filled at boot would hold the pre-reset rows.
+        for (const { name, proc, options } of this.#hooked("reset")) {
+            await callHook(proc, options.reset, `${name}.reset`);
+        }
+        for (const { proc } of this.#hooked("idle"))
+            this.#busy.add(proc);
     }
     /** Failures that the scenario body can't see on its own. */
-    async afterScenario() {
+    async #after(deadline) {
         await Promise.all(this.#processes().map((p) => p.settle()));
         this.#assertAlive();
+        await this.#waitIdle(deadline);
         if (this.interceptor?.blocked.size)
             throw new Error(blockedHint([...this.interceptor.blocked]));
+        const thrown = this.#handlerErrors();
+        if (thrown.length > 0)
+            throw new Error(`slicetest: a stub's reply threw, so the app got an error response instead of the reply:\n${thrown.join("\n")}`);
         const unmatched = this.#unmatched();
         if (unmatched.length > 0) {
             throw new Error(`slicetest: the app called stubbed services with no matching route:\n${unmatched.join("\n")}`);
@@ -337,16 +393,22 @@ export class Runtime {
     #checkStubCall(name, spec, call) {
         if (!call.matched)
             return []; // already reported as an unmatched call
-        const req = { contentType: header(call.headers["content-type"]), body: call.json ?? call.body, query: call.query };
+        const req = { contentType: header(call.headers["content-type"]), body: call.json ?? call.body, query: call.query, headers: call.headers };
         const out = spec.checkRequest(call.method, call.path, req).map((c) => `app → ${name}: ${c}`);
         const res = call.response;
         if (res) {
             const body = res.body ? (parseJson(res.body) ?? res.body) : "";
-            const problems = spec.checkResponse(call.method, call.path, { status: res.status, contentType: res.headers["content-type"], body });
+            const problems = spec.checkResponse(call.method, call.path, { status: res.status, contentType: res.headers["content-type"], body, headers: Object.fromEntries(Object.entries(res.headers).map(([k, v]) => [k.toLowerCase(), v])) });
             out.push(...problems.map((c) => `stub ${name} reply (the real service wouldn't answer this way): ${c}`));
         }
         return out;
     }
+    #handlerErrors() {
+        return [...this.stubs.values()].flatMap((s) => s.handlerErrors().map(({ call, error }) => {
+            const where = error?.stack?.split("\n").find((l) => /^\s+at /.test(l) && !l.includes("node_modules") && !l.includes("node:"))?.trim();
+            return `  ${s.name}: ${call.method} ${call.path}: ${error instanceof Error ? error.message : String(error)}${where ? `\n    ${where}` : ""}`;
+        }));
+    }
     #unmatched() {
         return [...this.stubs.values()].flatMap((s) => {
             const calls = s.unmatched();
@@ -366,7 +428,7 @@ export class Runtime {
     /** The current scenario as a Mermaid sequence diagram. */
     async diagram() {
         const changes = this.opts.db.none ? undefined : await this.db.changesSinceStart().catch(() => undefined);
-        return sequenceDiagram(this.http.history, this.stubs.values(), changes, this.mailbox);
+        return sequenceDiagram(this.http.requests, this.stubs.values(), changes, this.mailbox);
     }
     /**
      * After a scenario: its diagram goes to the `SLICETEST_DIAGRAMS` directory (one Markdown page
@@ -401,6 +463,9 @@ export class Runtime {
             if (exit)
                 sections.push(`the ${p.label} exited (code ${exit.code}, signal ${exit.signal}); it will be restarted for the next scenario`);
         }
+        const thrown = this.#handlerErrors();
+        if (thrown.length > 0)
+            sections.push(`stub replies that threw:\n${thrown.join("\n")}`);
         const unmatched = this.#unmatched();
         if (unmatched.length > 0)
             sections.push(`stub calls with no matching route:\n${unmatched.join("\n")}`);
@@ -499,8 +564,69 @@ async function ensureWorkerDatabase(engine, adminUrl, template, prefix) {
         await admin.close();
     }
 }
+const HOOK_TIMEOUT = 5000;
+/** Not `new URL(path, base)` alone: `//host/x` and `/\host` would send the request to another host. */
+function hookUrl(proc, hook) {
+    const url = new URL(hook.path, proc.url);
+    if (url.origin !== new URL(proc.url).origin)
+        throw new Error(`slicetest: hook path ${JSON.stringify(hook.path)} leaves the ${proc.label} (${url.origin}); use a path on the app`);
+    return url;
+}
+async function callHook(proc, hook, where) {
+    const method = (hook.method ?? "POST").toUpperCase();
+    const what = `${method} ${hook.path}`;
+    let res;
+    try {
+        // Not following redirects: a 3xx must not move the request off the app.
+        res = await fetch(hookUrl(proc, hook), { method, redirect: "manual", signal: AbortSignal.timeout(hook.timeout ?? HOOK_TIMEOUT) });
+    }
+    catch (e) {
+        throw new Error(`slicetest: ${where}: ${what} failed: ${e.message}. The ${proc.label}'s in-process state wasn't reset, so this scenario could see the previous one's. Check that the ${proc.label} serves ${hook.path}.`);
+    }
+    const body = (await res.text().catch(() => "")).slice(0, 300);
+    if (res.status >= 300) {
+        throw new Error(`slicetest: ${where}: ${what} answered ${res.status}${body ? `: ${body}` : ""}. The ${proc.label}'s in-process state wasn't reset, so this scenario could see the previous one's.`);
+    }
+}
+/** One request: is the process idle right now. */
+async function probeIdle(proc, hook) {
+    try {
+        const res = await fetch(hookUrl(proc, hook), { method: (hook.method ?? "GET").toUpperCase(), redirect: "manual", signal: AbortSignal.timeout(1000) });
+        await res.body?.cancel();
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+/** Poll `app.idle` until it answers 2xx, for `timeout` or until `deadline` (epoch ms), whichever is first. */
+async function pollIdle(proc, hook, where, deadline) {
+    const timeout = hook.timeout ?? HOOK_TIMEOUT;
+    const start = Date.now();
+    const limit = Math.min(start + timeout, deadline ?? Infinity);
+    const method = (hook.method ?? "GET").toUpperCase();
+    let last = "no answer";
+    for (;;) {
+        try {
+            const res = await fetch(hookUrl(proc, hook), { method, redirect: "manual", signal: AbortSignal.timeout(Math.max(100, Math.min(1000, limit - Date.now()))) });
+            const body = (await res.text().catch(() => "")).trim().slice(0, 200);
+            if (res.ok)
+                return;
+            last = `${res.status}${body ? ` ${body}` : ""}`;
+        }
+        catch (e) {
+            last = e.message;
+        }
+        if (Date.now() >= limit)
+            break;
+        await new Promise((r) => setTimeout(r, 50));
+    }
+    const cut = limit < start + timeout ? `; the test's own timeout left no more (raise it, or lower ${where}.timeout)` : "";
+    throw new Error(`slicetest: ${where}: the ${proc.label} still had background work after ${Date.now() - start}ms (${method} ${hook.path} last answered: ${last})${cut}. ` +
+        `Left running, it would write into a later scenario, so the ${proc.label} is restarted before the next one. Finish the work before the scenario ends, wait for it in the scenario, or raise the timeout.`);
+}
 function message(res) {
-    return { status: res.status, contentType: res.headers.get("content-type") ?? undefined, body: res.json ?? res.text };
+    return { status: res.status, contentType: res.headers.get("content-type") ?? undefined, body: res.json ?? res.text, headers: Object.fromEntries(res.headers) };
 }
 function header(v) {
     return Array.isArray(v) ? v[0] : v;

package/dist/scenario.js

@@ -1,3 +1,4 @@
+import { clearScenarioDeadline, setScenarioDeadline } from "./deadline.js";
 import { test } from "vitest";
 // Kept on globalThis so it survives the setup file and the test file loading
 // separate copies of this module (e.g. one from dist, one through an alias).
@@ -35,9 +36,17 @@ function define(register) {
                 console.error(`--- slicetest ---\n${await runtime.diagnostics()}\n-----------------`);
                 await runtime.reportDiagram(file, task.name, true);
             });
+            const started = Date.now();
             await runtime.beforeScenario();
-            await body(runtime.context());
-            await runtime.afterScenario();
+            setScenarioDeadline(started, task.timeout);
+            try {
+                await body(runtime.context());
+            }
+            finally {
+                clearScenarioDeadline();
+            }
+            // Leaves a margin for the checks after the wait, so `idle` reports before Vitest's timeout does.
+            await runtime.afterScenario(task.timeout ? started + task.timeout - 500 : undefined);
             await runtime.reportDiagram(file, task.name, false);
         }, timeout);
     };

package/dist/sql-migrations.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Files `migrate: { sql }` applies, in order: the file itself, or a directory's `.sql` files (and
+ * Diesel's `<version>_<name>/up.sql`) sorted by name with numbers compared as numbers. Rollback
+ * files are left out: golang-migrate / sqlx `*.down.sql`, Diesel's `down.sql` and Flyway undo
+ * migrations (`U2__…`).
+ */
+export declare function sqlMigrationFiles(target: string): Promise<string[]>;
+/** The statements of a migration file that migrate up: without a goose or dbmate down section. */
+export declare function upSection(sql: string): string;
+/** Apply `files` in order with `exec`, naming the file that fails. */
+export declare function applySqlFiles(files: string[], exec: (sql: string) => Promise<unknown>, root: string): Promise<void>;

package/dist/sql-migrations.js

@@ -0,0 +1,38 @@
+import { existsSync } from "node:fs";
+import { readdir, readFile, stat } from "node:fs/promises";
+import path from "node:path";
+/** Version numbers compare as numbers: Flyway's `V2__` comes before `V10__`. */
+const byVersion = new Intl.Collator("en", { numeric: true }).compare;
+/**
+ * Files `migrate: { sql }` applies, in order: the file itself, or a directory's `.sql` files (and
+ * Diesel's `<version>_<name>/up.sql`) sorted by name with numbers compared as numbers. Rollback
+ * files are left out: golang-migrate / sqlx `*.down.sql`, Diesel's `down.sql` and Flyway undo
+ * migrations (`U2__…`).
+ */
+export async function sqlMigrationFiles(target) {
+    if (!(await stat(target)).isDirectory())
+        return [target];
+    const entries = await readdir(target, { withFileTypes: true });
+    const files = entries.filter((e) => e.isFile() && e.name.toLowerCase().endsWith(".sql") && !/\.down\.sql$/i.test(e.name) && !/^U\d+(\.\d+)*__/.test(e.name)).map((e) => e.name);
+    // Diesel: one directory per migration, holding up.sql and down.sql.
+    const dirs = entries.filter((e) => e.isDirectory() && existsSync(path.join(target, e.name, "up.sql"))).map((e) => path.join(e.name, "up.sql"));
+    return [...files, ...dirs].sort(byVersion).map((f) => path.join(target, f));
+}
+/** Where a migration's rollback section starts in goose (`-- +goose Down`) and dbmate (`-- migrate:down`) files. */
+const DOWN = /^--\s*(\+goose\s+down|migrate:down)\b/im;
+/** The statements of a migration file that migrate up: without a goose or dbmate down section. */
+export function upSection(sql) {
+    const m = DOWN.exec(sql);
+    return m ? sql.slice(0, m.index) : sql;
+}
+/** Apply `files` in order with `exec`, naming the file that fails. */
+export async function applySqlFiles(files, exec, root) {
+    for (const file of files) {
+        try {
+            await exec(upSection(await readFile(file, "utf8")));
+        }
+        catch (e) {
+            throw new Error(`slicetest: db.migrate.sql: ${path.relative(root, file) || file}: ${e.message}`, { cause: e });
+        }
+    }
+}

package/dist/stub.d.ts

@@ -54,7 +54,7 @@ export interface ChaosOptions {
 export interface StubResponse {
     status?: number;
     headers?: Record<string, string>;
-    /** Objects are sent as JSON. */
+    /** Strings and bytes (`Uint8Array`, `ArrayBuffer`) are sent as they are; anything else as JSON. */
     body?: unknown;
 }
 /** One server-sent event: `[event, data]`, or `{ event, data, id }`. Data that isn't a string is sent as JSON. */
@@ -75,7 +75,8 @@ export type Responder = StubResponse | ((call: RecordedCall) => StubResponse | P
  * `expect.*` asymmetric matchers receive the actual value.
  */
 export interface MatchOptions {
-    query?: Record<string, Matcher>;
+    /** A list matches a repeated parameter's values in order: `{ ids: ["1", "2"] }` for `?ids=1&ids=2`. */
+    query?: Record<string, Matcher | Matcher[]>;
     headers?: Record<string, Matcher>;
     json?: unknown;
     /** Subset of a form-encoded body's fields (`call.form`). Numbers and booleans compare as the strings sent. */
@@ -137,6 +138,7 @@ export declare class Stub {
     /**
      * Answer `method path`. `path` may contain `:name` segments (captured into
      * `call.params`) or be a RegExp; `method` may be `*`. Later routes win.
+     * A query in `path` (`/search?q=tea`) is a condition on those parameters; others may come along.
      */
     on(method: string, path: string | RegExp, match?: MatchOptions): RouteBuilder;
     /**
@@ -160,7 +162,12 @@ export declare class Stub {
     /** The active `chaos()` settings and what they did, for failure output; undefined when off. */
     describeChaos(): string | undefined;
     /** Calls received so far, optionally filtered by method, path and conditions (same syntax as `on()`). */
-    calls(method?: string, path?: string | RegExp, match?: MatchOptions): RecordedCall[];
+    calls(method?: string, fullPath?: string | RegExp, fullMatch?: MatchOptions): RecordedCall[];
+    /** Calls whose reply function or fallback threw, with the error; the app got a 500 (502 for a fallback). */
+    handlerErrors(): {
+        call: RecordedCall;
+        error: unknown;
+    }[];
     unmatched(): RecordedCall[];
     /** Routes registered in this scenario that no call reached, except `optional()` ones. */
     unusedRoutes(): string[];

package/dist/stub.js

@@ -2,6 +2,7 @@ import http from "node:http";
 import { isDeepStrictEqual } from "node:util";
 import { describeGraphQL, graphqlErrors, graphqlOf } from "./graphql.js";
 import { timeline } from "./timeline.js";
+import { requestUrl } from "./request-url.js";
 /**
  * A streaming reply in Server-Sent Events format, as LLM APIs stream (Anthropic, OpenAI):
  * `stub("anthropic").on("POST", "/v1/messages").reply(sse([["message_start", {...}], ...]))`.
@@ -30,6 +31,8 @@ export class Stub {
     /** Appended to the 501 answer for a call nothing could answer. */
     #hint;
     #chaos;
+    /** Reply functions (and fallbacks) that threw: the app got a 500 / 502, the scenario must fail with the error. */
+    #errors = [];
     url = "";
     constructor(name) {
         this.name = name;
@@ -54,6 +57,7 @@ export class Stub {
     /**
      * Answer `method path`. `path` may contain `:name` segments (captured into
      * `call.params`) or be a RegExp; `method` may be `*`. Later routes win.
+     * A query in `path` (`/search?q=tea`) is a condition on those parameters; others may come along.
      */
     on(method, path, match = {}) {
         return this.#on(method, path, match);
@@ -77,7 +81,8 @@ export class Stub {
         };
         return gql;
     }
-    #on(method, path, match, label) {
+    #on(method, fullPath, fullMatch, label) {
+        const { path, match } = splitQuery(fullPath, fullMatch);
         const { pattern, paramNames } = compilePath(path);
         const route = {
             method: method.toUpperCase(),
@@ -179,12 +184,17 @@ export class Stub {
         this.#send(call, res, { status: fault.status, headers: retry, body: { error: "slicetest chaos", status: fault.status } });
     }
     /** Calls received so far, optionally filtered by method, path and conditions (same syntax as `on()`). */
-    calls(method, path, match = {}) {
+    calls(method, fullPath, fullMatch = {}) {
+        const { path, match } = fullPath === undefined ? { path: undefined, match: fullMatch } : splitQuery(fullPath, fullMatch);
         const compiled = path === undefined ? undefined : compilePath(path);
         return this.#calls.filter((c) => (!method || method === "*" || c.method === method.toUpperCase()) &&
             (!compiled || matchPath(path, compiled.pattern, c.path) !== undefined) &&
             matchConditions(match, c));
     }
+    /** Calls whose reply function or fallback threw, with the error; the app got a 500 (502 for a fallback). */
+    handlerErrors() {
+        return this.#errors;
+    }
     unmatched() {
         return this.#calls.filter((c) => !c.matched);
     }
@@ -239,6 +249,7 @@ export class Stub {
         this.#routes = [];
         this.#calls = [];
         this.#chaos = undefined;
+        this.#errors = [];
     }
     /**
      * Answer calls that no registered route matches, instead of failing with 501.
@@ -262,7 +273,7 @@ export class Stub {
         const raw = Buffer.concat(chunks);
         const body = raw.toString("utf8");
         const contentType = req.headers["content-type"] ?? "";
-        const url = new URL(req.url ?? "/", this.url);
+        const url = requestUrl(req.url, this.url);
         const call = {
             method: req.method ?? "GET",
             path: url.pathname,
@@ -303,6 +314,7 @@ export class Stub {
                 out = await this.#fallback?.(call);
             }
             catch (e) {
+                this.#errors.push({ call, error: e });
                 res.writeHead(502, { "content-type": "text/plain" }).end(e.message);
                 return;
             }
@@ -330,10 +342,15 @@ export class Stub {
             this.#send(call, res, typeof route.respond === "function" ? await route.respond(call) : route.respond);
         }
         catch (e) {
+            this.#errors.push({ call, error: e });
             res.writeHead(500).end(`slicetest: stub handler threw: ${e}`);
         }
     }
     #send(call, res, out) {
+        if (out.body instanceof ArrayBuffer || (ArrayBuffer.isView(out.body) && !(out.body instanceof Uint8Array))) {
+            const view = out.body;
+            out = { ...out, body: view instanceof ArrayBuffer ? new Uint8Array(view) : new Uint8Array(view.buffer, view.byteOffset, view.byteLength) };
+        }
         const raw = out.body === undefined || typeof out.body === "string" || out.body instanceof Uint8Array;
         const headers = { ...out.headers };
         if (!raw && !Object.keys(headers).some((h) => h.toLowerCase() === "content-type")) {
@@ -349,15 +366,29 @@ export class Stub {
         res.end(payload);
     }
 }
+/** `/search?q=tea` is the path `/search` with the query condition `q: "tea"`; `match.query` wins over the path's. */
+function splitQuery(path, match) {
+    if (typeof path !== "string" || !path.includes("?"))
+        return { path, match };
+    const [bare, search] = [path.slice(0, path.indexOf("?")), path.slice(path.indexOf("?") + 1)];
+    const params = new URLSearchParams(search);
+    const query = Object.fromEntries([...new Set(params.keys())].map((k) => [k, params.getAll(k).length > 1 ? params.getAll(k) : params.get(k)]));
+    return { path: bare || "/", match: { ...match, query: { ...query, ...match.query } } };
+}
 function compilePath(path) {
-    if (typeof path !== "string" || !path.includes("/:"))
+    if (typeof path !== "string" || !/\/[:*]/.test(path))
         return { pattern: undefined, paramNames: [] };
     const paramNames = [];
     const source = path
         .split("/")
         .map((seg) => {
+        // Like Express's `*`: the rest of the path, slashes included.
+        if (seg === "*") {
+            paramNames.push("*");
+            return "(.+)";
+        }
         if (!seg.startsWith(":"))
-            return seg.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            return encodeLiteral(seg).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
         paramNames.push(seg.slice(1));
         return "([^/]+)";
     })
@@ -367,7 +398,7 @@ function compilePath(path) {
 /** Returns captured params on a match, undefined otherwise. */
 function matchPath(path, pattern, actual, names = []) {
     if (typeof path === "string" && !pattern)
-        return path === actual ? {} : undefined;
+        return path === actual || encodeLiteral(path) === actual ? {} : undefined;
     const re = pattern ?? path;
     re.lastIndex = 0;
     const m = re.exec(actual);
@@ -377,6 +408,10 @@ function matchPath(path, pattern, actual, names = []) {
     names.forEach((n, i) => (params[n] = decodeSegment(m[i + 1])));
     return params;
 }
+/** A route written with a space or non-ASCII characters (`/検索`) is what the app sent percent-encoded (`/%E6%A4%9C…`). */
+function encodeLiteral(path) {
+    return path.replace(/[^\x21-\x7e]+/gu, encodeURIComponent);
+}
 /** A path segment decoded, or as sent when it isn't valid percent-encoding (`%zz`), instead of dropping the call. */
 function decodeSegment(segment) {
     try {
@@ -388,7 +423,7 @@ function decodeSegment(segment) {
 }
 function matchConditions(match, call) {
     for (const [k, m] of Object.entries(match.query ?? {})) {
-        if (!test(m, call.query.get(k) ?? undefined))
+        if (!testQuery(m, call.query, k))
             return false;
     }
     for (const [k, m] of Object.entries(match.headers ?? {})) {
@@ -417,9 +452,11 @@ function matchConditions(match, call) {
 /** The first condition of `match` that `call` fails, described; undefined when it meets them all. */
 function conditionMismatch(match, call) {
     for (const [k, m] of Object.entries(match.query ?? {})) {
-        const v = call.query.get(k) ?? undefined;
-        if (!test(m, v))
-            return `query ${k}: expected ${show(m)}, got ${v === undefined ? "nothing" : JSON.stringify(v)}`;
+        if (testQuery(m, call.query, k))
+            continue;
+        const all = call.query.getAll(k);
+        const got = all.length === 0 ? "nothing" : Array.isArray(m) || all.length > 1 ? JSON.stringify(all) : JSON.stringify(all[0]);
+        return `query ${k}: expected ${Array.isArray(m) ? `[${m.map(show).join(", ")}]` : show(m)}, got ${got}`;
     }
     for (const [k, m] of Object.entries(match.headers ?? {})) {
         const raw = call.headers[k.toLowerCase()];
@@ -525,6 +562,13 @@ function distance(a, b) {
     }
     return row[b.length];
 }
+/** A query condition: one matcher for the first value, or a list for every value of a repeated parameter, in order. */
+function testQuery(m, query, key) {
+    if (!Array.isArray(m))
+        return test(m, query.get(key) ?? undefined);
+    const values = query.getAll(key);
+    return values.length === m.length && m.every((x, i) => test(x, values[i]));
+}
 function test(m, value) {
     if (isAsymmetric(m))
         return m.asymmetricMatch(value);
@@ -558,6 +602,8 @@ function isAsymmetric(m) {
 function isForm(contentType) {
     return !!contentType && contentType.split(";")[0].trim().toLowerCase() === "application/x-www-form-urlencoded";
 }
+/** Keys kept as plain fields rather than nested into, so a body can't reach `Object.prototype`. */
+const UNSAFE_KEYS = new Set(["__proto__", "constructor", "prototype"]);
 /**
  * A form body as nested fields, the way Rack, PHP and Stripe read bracket keys: `a[b]=1` is
  * `{ a: { b: "1" } }`, `a[]=1&a[]=2` and `a[0]=1&a[1]=2` are arrays, and a plain key sent
@@ -567,12 +613,13 @@ export function parseForm(body) {
     const out = {};
     for (const [key, value] of new URLSearchParams(body)) {
         const m = /^([^[\]]+)((?:\[[^\]]*\])*)$/.exec(key);
-        if (!m || !m[2]) {
-            const prev = out[key];
-            out[key] = prev === undefined ? value : Array.isArray(prev) ? [...prev, value] : [prev, value];
+        const path = m?.[2] ? [m[1], ...[...m[2].matchAll(/\[([^\]]*)\]/g)].map((x) => x[1])] : undefined;
+        // `__proto__[x]=1` is sent by whatever the app forwards; it must not reach Object.prototype.
+        if (!path || path.some((seg) => UNSAFE_KEYS.has(seg))) {
+            const prev = Object.hasOwn(out, key) ? out[key] : undefined;
+            Object.defineProperty(out, key, { value: prev === undefined ? value : Array.isArray(prev) ? [...prev, value] : [prev, value], enumerable: true, writable: true, configurable: true });
             continue;
         }
-        const path = [m[1], ...[...m[2].matchAll(/\[([^\]]*)\]/g)].map((x) => x[1])];
         let node = out;
         for (let i = 0; i < path.length; i++) {
             const seg = path[i];
@@ -632,8 +679,9 @@ async function parseMultipart(raw, contentType) {
                 size: value.size,
                 ...(TEXTUAL.test(value.type) ? { text: await value.text() } : {}),
             };
-        const prev = out[key];
-        out[key] = prev === undefined ? v : Array.isArray(prev) ? [...prev, v] : [prev, v];
+        // `out[key]` would read Object's `constructor` and set the prototype for `__proto__`.
+        const prev = Object.hasOwn(out, key) ? out[key] : undefined;
+        Object.defineProperty(out, key, { value: prev === undefined ? v : Array.isArray(prev) ? [...prev, v] : [prev, v], enumerable: true, writable: true, configurable: true });
     }
     return out;
 }

package/dist/vitest.d.ts

@@ -13,4 +13,8 @@ export declare const YAML_SCENARIOS = "**/*.scenario.{yaml,yml}";
  * Vitest root), or nothing to read the slicetest.config.yaml next to the Vitest config.
  */
 export declare function slicetest(options?: SlicetestOptions | string): Plugin;
+/** @internal `include`: the CLI's test files, used as they are instead of extending Vitest's. */
+export declare function slicetestPlugin(options?: SlicetestOptions | string, cli?: {
+    include?: string[];
+}): Plugin;
 export type { SlicetestOptions } from "./config.js";

package/dist/vitest.js

@@ -30,6 +30,10 @@ const ext = path.extname(fileURLToPath(import.meta.url));
  * Vitest root), or nothing to read the slicetest.config.yaml next to the Vitest config.
  */
 export function slicetest(options) {
+    return slicetestPlugin(options);
+}
+/** @internal `include`: the CLI's test files, used as they are instead of extending Vitest's. */
+export function slicetestPlugin(options, cli = {}) {
     let root;
     return {
         name: "slicetest",
@@ -37,9 +41,9 @@ export function slicetest(options) {
             const root = path.resolve(config.root ?? process.cwd());
             // Mutated rather than returned: a returned list would replace Vitest's default include instead of extending it.
             const test = (config.test ??= {});
-            // `slicetest record` runs only its session file.
+            // `slicetest record` runs only its session file. Extending the CLI's include would run every scenario file.
             if (!process.env[SESSION_ENV])
-                test.include = [...(test.include ?? configDefaults.include), YAML_SCENARIOS];
+                test.include = cli.include ?? [...(test.include ?? configDefaults.include), YAML_SCENARIOS];
             const resolved = resolveOptions(typeof options === "object" ? options : loadConfigFile(root, options), root);
             return {
                 test: {

package/dist/webhook.d.ts

@@ -8,7 +8,7 @@ export interface HmacScheme {
     /** Prepended to the digest, e.g. `sha256=`. */
     prefix?: string;
 }
-export type WebhookProvider = "stripe" | "github" | "slack" | "shopify" | "standard" | "line" | "paddle" | "linear" | "gitlab" | "zoom" | "twitch" | "twilio" | HmacScheme;
+export type WebhookProvider = "stripe" | "github" | "slack" | "shopify" | "standard" | "line" | "paddle" | "linear" | "gitlab" | "zoom" | "twitch" | "twilio" | "typeform" | "notion" | "bitbucket" | "intercom" | HmacScheme;
 export interface WebhookOptions {
     provider: WebhookProvider;
     /** The signing secret the app is configured with. For `standard` (Svix), `whsec_<base64>` or the raw key. */
@@ -32,14 +32,14 @@ export interface WebhookOptions {
     headers?: Record<string, string>;
 }
 /** The providers `signWebhook` knows by name. */
-export declare const WEBHOOK_PROVIDERS: readonly ["stripe", "github", "slack", "shopify", "standard", "line", "paddle", "linear", "gitlab", "zoom", "twitch", "twilio"];
+export declare const WEBHOOK_PROVIDERS: readonly ["stripe", "github", "slack", "shopify", "standard", "line", "paddle", "linear", "gitlab", "zoom", "twitch", "twilio", "typeform", "notion", "bitbucket", "intercom"];
 /**
  * The headers a provider sends with `body`, signed with `secret` the way its
  * SDK verifies them: Stripe's `Stripe-Signature`, GitHub's
  * `X-Hub-Signature-256`, Slack's `v0` signature, Shopify's base64 HMAC,
  * Standard Webhooks (Svix, Resend, Clerk, …), LINE's `X-Line-Signature`,
  * Paddle Billing's `Paddle-Signature`, Linear, GitLab's token, Zoom's `v0`
- * signature and Twitch EventSub.
+ * signature, Twitch EventSub, Typeform, Notion, Bitbucket and Intercom.
  */
 export declare function signWebhook(body: string, opts: WebhookOptions): Record<string, string>;
 /** The bytes to send and their content type: objects as JSON (as a form for Twilio), URLSearchParams as a form (Slack commands), strings as-is. */