@specific.dev/spectest 0.87.0 → 0.88.1

package/dist/components/supabase-functions-reach.js

@@ -0,0 +1,155 @@
+// What the edge functions can load from the project — the pure part.
+//
+// The edge runtime serves each function from the project root, mounted
+// whole so that a monorepo function's `../../packages/shared/mod.ts`
+// resolves where it sits. Whole is right for the runtime and wrong for
+// the reach: with the root in a build context and a volume, every file of
+// the project could "reach" the functions, and a change to `docs/` could
+// never skip a run. So the component works out the **module graph** the
+// functions can load, statically, and hands the build context and the
+// reach exactly that: the functions directory, and every directory a
+// relative import or a local import-map entry leads to, followed
+// transitively. Directories rather than files, so a sibling module a
+// dynamic `import()` picks at run time comes along.
+//
+// What it cannot see: a computed specifier that leaves the directories
+// found (`import(\`../../${x}/mod.ts\`)`), and a `Deno.readTextFile` of a
+// path outside them. Both are rare in a function, and both are the same
+// class of hole as a test reading the workspace through `node:fs`. A tree
+// too large to walk within the budget is answered with the whole project,
+// the safe side.
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+/** Files the walk parses for imports. */
+const SOURCE_EXT = /\.(?:[mc]?[jt]sx?)$/;
+/** Names never walked into. */
+const SKIP = new Set(["node_modules", ".git", ".spectest", "dist", "build", ".next"]);
+/** The walk gives up past this many files and answers with the root. */
+const FILE_BUDGET = 20_000;
+const IMPORT_RE = /\b(?:import|export)\b[^;'"`]*?\bfrom\s*['"]([^'"]+)['"]|\bimport\s*['"]([^'"]+)['"]|\bimport\(\s*['"]([^'"]+)['"]\s*\)/g;
+/** Specifiers a source text imports, as written. */
+export function importSpecifiers(text) {
+    const out = [];
+    for (const m of text.matchAll(IMPORT_RE))
+        out.push(m[1] ?? m[2] ?? m[3] ?? "");
+    return out.filter((s) => s.length > 0);
+}
+/** Local targets an import map (`deno.json` `imports`, `import_map.json`)
+ *  names, as written: relative values, and root-relative `/…` ones. */
+export function importMapLocalTargets(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return [];
+    }
+    const imports = parsed?.imports;
+    if (typeof imports !== "object" || imports === null)
+        return [];
+    return Object.values(imports).filter((v) => typeof v === "string" && (v.startsWith("./") || v.startsWith("../") || v.startsWith("/")));
+}
+function toPosix(p) {
+    return sep === "/" ? p : p.split(sep).join("/");
+}
+/**
+ * The directories, project-relative and sorted, that the functions under
+ * `fnRelPath` can load modules from: `fnRelPath` itself, and every
+ * directory a relative import or a local import-map entry leads to,
+ * transitively. `["."]` when the walk runs out of budget. A directory
+ * nested under another in the answer is dropped.
+ */
+export function functionsReach(root, fnRelPath) {
+    const rootAbs = resolve(root);
+    const dirs = new Set();
+    const queue = [resolve(rootAbs, fnRelPath)];
+    let budget = FILE_BUDGET;
+    const inRoot = (p) => p === rootAbs || p.startsWith(rootAbs + sep);
+    const enqueue = (target) => {
+        if (!inRoot(target) || !existsSync(target))
+            return;
+        let st;
+        try {
+            st = statSync(target);
+        }
+        catch {
+            return;
+        }
+        const dir = st.isDirectory() ? target : dirname(target);
+        if (![...dirs].some((d) => dir === d || dir.startsWith(d + sep)))
+            queue.push(dir);
+    };
+    const follow = (fromDir, spec) => {
+        if (spec.startsWith("./") || spec.startsWith("../"))
+            enqueue(resolve(fromDir, spec));
+        else if (spec.startsWith("/"))
+            enqueue(resolve(rootAbs, spec.slice(1)));
+    };
+    while (queue.length > 0) {
+        const dir = queue.shift();
+        if ([...dirs].some((d) => dir === d || dir.startsWith(d + sep)))
+            continue;
+        if (!existsSync(dir))
+            continue;
+        dirs.add(dir);
+        // Every file below it, parsed for what it imports.
+        const stack = [dir];
+        while (stack.length > 0) {
+            const d = stack.pop();
+            let entries;
+            try {
+                entries = readdirSync(d, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            for (const e of entries) {
+                const p = join(d, e.name);
+                if (e.isDirectory()) {
+                    if (!SKIP.has(e.name))
+                        stack.push(p);
+                    continue;
+                }
+                if (!e.isFile())
+                    continue;
+                if (--budget < 0)
+                    return ["."];
+                if (e.name === "deno.json" || e.name === "import_map.json") {
+                    for (const t of importMapLocalTargets(safeRead(p)))
+                        follow(d, t.endsWith("/") ? t.slice(0, -1) : t);
+                    continue;
+                }
+                if (!SOURCE_EXT.test(e.name))
+                    continue;
+                for (const spec of importSpecifiers(safeRead(p)))
+                    follow(d, spec);
+            }
+        }
+    }
+    // Minimal, project-relative, sorted.
+    const rel = [...dirs].map((d) => (d === rootAbs ? "." : toPosix(relative(rootAbs, d))));
+    const minimal = rel.filter((d) => !rel.some((o) => o !== d && (o === "." || d.startsWith(o + "/"))));
+    return [...new Set(minimal)].sort();
+}
+function safeRead(p) {
+    try {
+        return readFileSync(p, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+/** The `exclude` list that narrows a root build context to `dirs`: drop
+ *  everything, then re-include each directory and its subtree, then drop
+ *  again what no context should carry (a re-included `packages/shared`
+ *  would otherwise bring its `node_modules` along). */
+export function excludeAllBut(dirs) {
+    if (dirs.includes("."))
+        return [];
+    return ["**", ...dirs.flatMap((d) => [`!${d}`, `!${d}/**`]), ...REEXCLUDE];
+}
+/** Re-excluded after the re-includes: the names the default ignore drops. */
+const REEXCLUDE = ["**/node_modules/**", "**/.git/**", "**/.spectest/**", "**/__pycache__/**", "**/.venv/**"];
+// Keep `isAbsolute` referenced for callers that pass absolute fnRelPath by
+// mistake: the walk resolves it against the root either way.
+void isAbsolute;

package/dist/components/supabase.js

@@ -50,6 +50,7 @@
 // (`sb.url`, `sb.dbUrl`) embeds it — a mismatch errors at load.
 import { createHmac } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
+import { excludeAllBut, functionsReach } from "./supabase-functions-reach.js";
 import { readdir, stat } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { serviceGroup, } from "../index.js";
@@ -137,6 +138,9 @@ function providerCredentials(providerName, declared, env) {
  * cache rides into the image as a layer — so at run time the worker resolves
  * those URLs locally and never reaches for the network.
  *
+ * The context is the module graph the functions can load (the functions
+ * directory and what its imports lead to, `functionsReach`), copied whole
+ * so a monorepo function's `../../packages/…` resolves at bundle time too.
  * One synthetic entrypoint imports every function, so the whole set is one
  * graph rather than one per function. Bundling is best-effort: a function that
  * fails to bundle (a type error, an import that only resolves at run time)
@@ -146,13 +150,13 @@ function providerCredentials(providerName, declared, env) {
 function functionsDockerfile(fnRelPath) {
     return `FROM ${IMAGES.functions}
 ENV DENO_DIR=${DENO_DIR}
-COPY ${fnRelPath} /warm/functions
+COPY . /warm/repo
 RUN set -eu; \
     : > /warm/all.ts; \
-    for d in /warm/functions/*/; do \
+    for d in /warm/repo/${fnRelPath}/*/; do \
       [ -f "$d/index.ts" ] || continue; \
       n=$(basename "$d"); \
-      printf 'import "./functions/%s/index.ts";\\n' "$n" >> /warm/all.ts; \
+      printf 'import "./repo/${fnRelPath}/%s/index.ts";\\n' "$n" >> /warm/all.ts; \
     done; \
     edge-runtime bundle --entrypoint /warm/all.ts --output /tmp/warm.eszip --quiet || true; \
     rm -rf /tmp/warm.eszip /warm
@@ -1247,6 +1251,10 @@ export function supabase(opts = {}) {
             ? `${REPO_MOUNT}/${fnDir.slice(root.length + 1)}`
             : `${REPO_MOUNT}/supabase/functions`;
     const migrationsPath = inDir("migrations");
+    // The directories the functions can load modules from: the functions
+    // directory and what its imports lead to (`supabase-functions-reach.ts`).
+    // The build context and the reach are narrowed to exactly these.
+    const fnReachDirs = withFunctions ? functionsReach(root, fnRelPath) : [];
     // ── config file (config.toml / config.json) ───────────────────────────
     // The CLI's own project config, mapped onto the stack. Read at build time:
     // the values become container config, so they must be in hand before the
@@ -1415,8 +1423,20 @@ export function supabase(opts = {}) {
             const realtimeHost = `realtime-dev.${g.key("realtime")}`;
             const parts = {};
             // ── db ──────────────────────────────────────────────────────────
+            // What the stack reads from the project: the Supabase folder
+            // (config.toml, migrations, seed, functions) and the mail templates,
+            // which may sit anywhere in the repo. Declared as inputs so a change
+            // to any of them is never taken as one that can affect no test; the
+            // migrations volume carries the folder too, but only when there is
+            // a migrations directory, and a config-only project must count as
+            // well.
+            const inputs = [
+                ...(opts.dir !== undefined && !opts.dir.startsWith("/") ? [opts.dir] : []),
+                ...templateBodies.map(([, spec]) => spec.path).filter((t) => !t.startsWith("/")),
+            ];
             const dbDef = {
                 image: { type: "registry", reference: opts.db?.image ?? IMAGES.db },
+                ...(inputs.length > 0 ? { inputs } : {}),
                 // `args` (not `command`): keep the image's docker-entrypoint.sh so it
                 // runs initdb + its baked init-scripts before starting.
                 args: [
@@ -1721,6 +1741,12 @@ export function supabase(opts = {}) {
                     image: {
                         type: "dockerfile",
                         content: functionsDockerfile(fnRelPath),
+                        // The root, narrowed to the module graph: only the functions
+                        // directory and what its imports lead to enter the context, so
+                        // a change anywhere else neither uploads nor counts as reaching
+                        // the functions.
+                        context: ".",
+                        exclude: excludeAllBut(fnReachDirs),
                     },
                     // The **project root**, mounted with the functions directory in its
                     // real position underneath. Mounting only `supabase/functions`
@@ -1729,8 +1755,10 @@ export function supabase(opts = {}) {
                     // (`../../../../packages/…`), and that only resolves if the
                     // directory sits where it sits in the repo. Read-only: the runtime
                     // only reads sources, and a function writing into its own directory
-                    // would be writing into the user's checkout.
-                    volumes: [{ source: projectRootPath(), target: REPO_MOUNT, readOnly: true }],
+                    // would be writing into the user's checkout. For the reach the
+                    // mount is exempt: what the functions can load is the module graph
+                    // above, which the build context already states.
+                    volumes: [{ source: projectRootPath(), target: REPO_MOUNT, readOnly: true, reachExempt: true }],
                     // Our router (see FUNCTIONS_MAIN_TS) sits outside that mount, so
                     // the project never has to carry a `main/` function of ours.
                     files: [{ path: "/home/deno/main/index.ts", content: FUNCTIONS_MAIN_TS }],

package/dist/daemon.js

@@ -28,8 +28,9 @@ import { COVERAGE_CONTAINER_DIR, coverageBundleRef, coverageHostDir, encodeCover
 import { configureBrowserCoverage } from "./browser-coverage.js";
 import { INVENTORY_REPORT, NODE_COVERAGE_MARKERS_SUBDIR, NODE_COVERAGE_SCRIPTS_SUBDIR, applyCoverageAdapters, coverageAdapters, coverageReportsMode, validateCoverage, } from "./coverage.js";
 import { serviceForHost as hostToService } from "./harness/browser-coverage.js";
-import { acquirePersistentBrowser, mobileKey } from "./browser.js";
+import { acquirePersistentBrowser, acquirePersistentDesktop, mobileKey } from "./browser.js";
 import { isMobileApp, openPersistentMobile } from "./mobile.js";
+import { isDesktopApp } from "./desktop.js";
 // Pure ingress hostname matching, ported out of this file (see
 // harness/hostmatch.ts). Keeping ONE implementation is the point: the
 // exact-then-longest-suffix rule and the one-label certificate rule are
@@ -3585,7 +3586,8 @@ async function computeProjectReachInner(all) {
     for (const svc of all) {
         const src = {
             service: svc.name,
-            volumeSources: (svc.volumes ?? []).flatMap((v) => (v.source ? [v.source] : [])),
+            volumeSources: (svc.volumes ?? []).flatMap((v) => (v.source && !v.reachExempt ? [v.source] : [])),
+            ...(svc.inputs && svc.inputs.length > 0 ? { inputs: [...svc.inputs] } : {}),
         };
         if (svc.image.type === "dockerfile") {
             try {
@@ -3753,6 +3755,7 @@ function newBrowserSession(testStart, idScope, frame = "browser", artifacts, nam
         record,
         recorder: {
             sessionId: record.sessionId,
+            frame,
             ...(name ? { sessionName: name } : {}),
             recordStep(step) {
                 if (closed)
@@ -3777,6 +3780,33 @@ function newBrowserSession(testStart, idScope, frame = "browser", artifacts, nam
         },
     };
 }
+/** Same desktop recording path for test runs and interactive evals. */
+function desktopOpener(start, scope, sessions, detaches, artifacts) {
+    const memo = new Map();
+    return async (app, options = {}) => {
+        if (!isDesktopApp(app))
+            throw new Error("ctx.desktop(app): pass ctx.svc.app from an electron() service");
+        const window = options.window ?? 0;
+        const key = JSON.stringify([app.endpoint, window]);
+        const existing = memo.get(key);
+        if (existing)
+            return existing;
+        const session = newBrowserSession(start, scope, "desktop", artifacts, window === 0 ? app.name : `${app.name} · window ${window + 1}`);
+        const { browser, detach, desktopChrome } = await acquirePersistentDesktop(app.endpoint, window, session.recorder);
+        session.record.desktopChrome = desktopChrome;
+        session.record.initialUrl = browser.url();
+        sessions.push(session);
+        detaches.push(async () => { await detach(); session.markClosed(); });
+        const close = browser.close.bind(browser);
+        browser.close = async () => {
+            await close();
+            if (memo.get(key) === browser)
+                memo.delete(key);
+        };
+        memo.set(key, browser);
+        return browser;
+    };
+}
 /** New terminal session bookkeeping for a single `ctx.terminal(...)` call. */
 function newTerminalSession(testStart, service, command, cols, rows, idScope) {
     const record = {
@@ -4648,6 +4678,7 @@ async function runOne(testCase) {
         openTerminal: recordedOpenTerminal,
         browser: trackedOpenBrowser,
         mobile: trackedOpenMobile,
+        desktop: desktopOpener(start, testCase.id, sessions, browserDetaches),
         mcp: openMcp,
         testName: testCase.name,
         parent,
@@ -5132,6 +5163,7 @@ async function evalCode(code, secrets) {
         openTerminal: evalOpenTerminal,
         browser: trackedOpenBrowser,
         mobile: trackedOpenMobile,
+        desktop: desktopOpener(start, "eval", sessions, browserDetaches, artifactCollector),
         mcp: openMcp,
         testName: "eval",
         parent: undefined,

package/dist/desktop-recorder.d.ts

@@ -0,0 +1 @@
+export declare const DESKTOP_INPUT_SYNC_SCRIPT: string;

package/dist/desktop-recorder.js

@@ -0,0 +1,30 @@
+// A late recorder cannot interpose on setters React cached during mounting.
+// Reconcile controls at action boundaries, without changing the app's DOM or
+// descriptors. Normal rrweb Input events win; synthesize only missing changes.
+export const DESKTOP_INPUT_SYNC_SCRIPT = String.raw `(() => {
+  if (window.__spectestSyncInputs) return;
+  const known = new WeakMap();
+  window.__spectestSyncInputs = (timestamp = Date.now()) => {
+    const rec = window.__spectestRec;
+    const events = window.__spectestRrwebEvents;
+    if (!rec?.mirror || !events) return;
+    const inputs = new Map();
+    for (const event of events) {
+      if (event.type === 3 && event.data?.source === 5) inputs.set(event.data.id, event.data);
+    }
+    for (const element of document.querySelectorAll('input, textarea, select')) {
+      const type = element.hasAttribute('data-rr-is-password') ? 'password' : element.type?.toLowerCase();
+      if (type === 'file' || element.closest('.rr-block, .rr-ignore')) continue;
+      const id = rec.mirror.getId(element);
+      if (!(id > 0)) continue;
+      const text = type === 'password' ? '*'.repeat(element.value.length) : element.value;
+      const isChecked = (type === 'checkbox' || type === 'radio') ? element.checked : false;
+      const current = { text, isChecked };
+      const previous = inputs.get(id) ?? known.get(element);
+      known.set(element, current);
+      if (!previous || (previous.text === text && previous.isChecked === isChecked)) continue;
+      events.push({ type: 3, data: { source: 5, id, text, isChecked }, timestamp });
+    }
+  };
+  window.__spectestSyncInputs();
+})();`;

package/dist/desktop.d.ts

@@ -0,0 +1,42 @@
+import type { Browser } from "./browser.js";
+export declare const DESKTOP_APP: unique symbol;
+/** An Electron service handle produced by electron(). */
+export interface DesktopApp {
+    readonly [DESKTOP_APP]: true;
+    readonly endpoint: string;
+    readonly name: string;
+}
+/** Real renderer window: user input, locators, assertions, and replay capture.
+ * close() closes this window only. Native OS dialogs are outside DOM replay. */
+export interface Desktop extends Browser {
+}
+/** Observed window configuration at the start of a replay session. */
+export interface DesktopChrome {
+    titleBarStyle: string;
+    frame: boolean;
+    trafficLightPosition: {
+        x: number;
+        y: number;
+    } | null;
+    titleBarOverlay: boolean | {
+        height?: number;
+        color?: string;
+        symbolColor?: string;
+    };
+    roundedCorners: boolean;
+    buttonVisibility: boolean | null;
+    titlebarArea?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+export interface DesktopOptions {
+    /** Zero-based window creation order. Defaults to the first window.
+     * Open additional windows using the app UI before selecting them.
+     * A closed window keeps its index; other windows never change identity. */
+    window?: number;
+}
+export declare function desktopApp(endpoint: string, name: string): DesktopApp;
+export declare function isDesktopApp(value: unknown): value is DesktopApp;

package/dist/desktop.js

@@ -0,0 +1,10 @@
+export const DESKTOP_APP = Symbol.for("spectest.desktopApp");
+export function desktopApp(endpoint, name) {
+    return { [DESKTOP_APP]: true, endpoint, name };
+}
+export function isDesktopApp(value) {
+    return typeof value === "object" && value !== null &&
+        value[DESKTOP_APP] === true &&
+        typeof value.endpoint === "string" &&
+        typeof value.name === "string";
+}

package/dist/harness/reach.d.ts

@@ -25,6 +25,10 @@ export interface ReachSource {
     /** Volume sources, project-relative; an absolute source is not a
      *  project path and is skipped. */
     volumeSources?: string[];
+    /** The service's declared `inputs`: project files or directories it
+     *  consumes some other way (packaged at setup, read at load). A
+     *  directory covers its subtree. */
+    inputs?: string[];
 }
 /**
  * The project's reach: every project file (`files`, project-relative)

package/dist/harness/reach.js

@@ -142,7 +142,7 @@ export function projectReach(files, sources) {
             if (rel)
                 out.add(rel);
         }
-        for (const v of s.volumeSources ?? []) {
+        for (const v of [...(s.volumeSources ?? []), ...(s.inputs ?? [])]) {
             if (v.startsWith("/"))
                 continue;
             const src = normRel(v);
@@ -236,7 +236,7 @@ export function sourceOf(sources, path) {
         for (const e of s.extraFiles ?? [])
             if (normRel(e) === p)
                 return s;
-        for (const v of s.volumeSources ?? []) {
+        for (const v of [...(s.volumeSources ?? []), ...(s.inputs ?? [])]) {
             if (v.startsWith("/"))
                 continue;
             const src = normRel(v);

package/dist/index.d.ts

@@ -19,6 +19,8 @@ export type { UrlPattern } from "./url-match.js";
 import type { UrlPattern } from "./url-match.js";
 export type { Mobile, MobileApp } from "./mobile.js";
 import type { Mobile, MobileApp } from "./mobile.js";
+export type { Desktop, DesktopApp, DesktopOptions } from "./desktop.js";
+import type { Desktop, DesktopApp, DesktopOptions } from "./desktop.js";
 export type { Terminal, TerminalOpts, TerminalResult } from "./terminal.js";
 import type { Terminal, TerminalOpts, TerminalResult } from "./terminal.js";
 export { type CoverageAdapter, type CoverageCaptureContext, type CoverageConfigureInfo, type CoverageLoadContext, type ServiceCoverage, } from "./coverage.js";
@@ -141,6 +143,13 @@ export interface ServiceConfig {
     tls?: readonly ServiceTls[];
     /** Bind-mounted volumes for state that survives snapshot/fork. */
     volumes?: readonly VolumeMount[];
+    /**
+     * @internal Spectest's own components only: project files or
+     * directories the service consumes outside its build context and
+     * volumes (a lambda's `source`, Supabase's folder). Project-relative; a
+     * directory covers its subtree. The reach counts them.
+     */
+    inputs?: readonly string[];
     /**
      * Opt this service in to **code coverage collection** (experimental).
      *
@@ -814,7 +823,7 @@ export type ServiceImage = {
  * Runs in `defineEnvironment`, and in the daemon's runtime `startService`
  * twin, inside the VM, where the repo sits at the project root. Existence
  * checks go through the project-file resolver, so the same rules as
- * `ctx.readProjectFile` apply (a `spectest/.envignore`d path is refused
+ * `ctx.readProjectFile` apply (a `spectest/.specignore`d path is refused
  * instead of read stale).
  */
 export declare function validateServiceImage(serviceName: string, image: ServiceImage): ServiceImage;
@@ -841,6 +850,13 @@ export interface VolumeMount {
      * so unlike a volume directory it is never created or wiped by spectest.
      */
     source?: string;
+    /**
+     * @internal Spectest's own components only. The mount does not count
+     * for the project's reach: what the service can load from it is stated
+     * some other way (a narrowed build context, `inputs`). Never set this
+     * for a mount the service reads freely.
+     */
+    reachExempt?: boolean;
     /** Container path. */
     target: string;
     readOnly?: boolean;
@@ -1295,6 +1311,16 @@ export interface TestContext<P = undefined, S extends ServicesMap = ServicesMap,
      * like named desktop browsers.
      */
     mobile(app: MobileApp, name?: string): Promise<Mobile>;
+    /** Drive a real Electron renderer window through locators and user input.
+     * Acquires the app started by electron(); keeps its live state across forks.
+     * Each test gets a self-contained graphical replay. Selecting another window
+     * does not create a new app or isolate its storage from sibling windows.
+     *
+     * const app = await ctx.desktop(ctx.svc.app);
+     * await app.getByRole("textbox", { name: "New note" }).fill("Hello");
+     * await app.getByRole("button", { name: "Add note" }).click();
+     */
+    desktop(app: DesktopApp, options?: DesktopOptions): Promise<Desktop>;
     /** The test's display name. */
     readonly testName: string;
     /**

package/dist/index.js

@@ -253,7 +253,7 @@ const BUILD_TARGET_RE = /^[^\s]+$/;
  * Runs in `defineEnvironment`, and in the daemon's runtime `startService`
  * twin, inside the VM, where the repo sits at the project root. Existence
  * checks go through the project-file resolver, so the same rules as
- * `ctx.readProjectFile` apply (a `spectest/.envignore`d path is refused
+ * `ctx.readProjectFile` apply (a `spectest/.specignore`d path is refused
  * instead of read stale).
  */
 export function validateServiceImage(serviceName, image) {
@@ -322,6 +322,11 @@ function validateEnvironmentConfig(config) {
             }
         }
         validateCoverage(name, svc.coverage);
+        for (const input of svc.inputs ?? []) {
+            if (typeof input !== "string" || input.trim() === "" || input.startsWith("/") || input.split("/").includes("..")) {
+                throw new Error(`service "${name}" has an invalid \`inputs\` entry ${JSON.stringify(input)} — a project-relative file or directory path`);
+            }
+        }
         for (const raw of svc.hostnames ?? []) {
             const h = raw.toLowerCase();
             if (!HOSTNAME_RE.test(hostPatternBody(h))) {

package/dist/project-files.js

@@ -12,14 +12,14 @@
 // is correct for every file that is IN that hash. It can be behind for the two
 // kinds of file the hash excludes: `spectest/tests/**` (excluded so a test-only
 // edit keeps the fast start) and anything a project lists in
-// `spectest/.envignore`.
+// `spectest/.specignore`.
 //
 // Hence the rule below: a path under `spectest/` resolves against the app copy
 // first, because that copy is always current — this is what lets a fixture live
 // in `spectest/tests/fixtures/` and still be found after it was added. Any
 // other path resolves against /workspace, which the hash keeps current.
 //
-// The remaining hole is a file that `.envignore` excludes AND that sits outside
+// The remaining hole is a file that `.specignore` excludes AND that sits outside
 // `spectest/`: /workspace holds whatever the cold start uploaded, so a later
 // edit is invisible. Nothing can repair those bytes at read time, so we refuse
 // to read them instead of returning stale content. The control plane writes the
@@ -31,8 +31,8 @@ export const WORKSPACE = process.env.SPECTEST_WORKSPACE ?? "/workspace";
 /** The app dir; the user's `spectest/` sits directly under it. */
 export const APP_DIR = process.env.SPECTEST_APP_DIR ?? "/opt/spectest/app";
 /** Paths (repo-relative) the warm-template hash skipped because of
- *  `spectest/.envignore`. Written by the control plane at env start; absent
- *  when the project ships no `.envignore`. */
+ *  `spectest/.specignore`. Written by the control plane at env start; absent
+ *  when the project ships no `.specignore`. */
 const ENV_IGNORED_FILE = "/run/spectest-env-ignored.json";
 let _envIgnored;
 function envIgnored() {
@@ -44,7 +44,7 @@ function envIgnored() {
         paths = raw.paths ?? [];
     }
     catch {
-        /* No file (no .envignore, or an older env) — nothing to refuse. */
+        /* No file (no .specignore, or an older env) — nothing to refuse. */
     }
     _envIgnored = new Set(paths);
     return _envIgnored;
@@ -90,7 +90,7 @@ export function resolveProjectPath(p, opts = {}) {
             return app;
     }
     if (envIgnored().has(rel)) {
-        throw new Error(`project file "${p}" is excluded by spectest/.envignore, so the copy in the VM ` +
+        throw new Error(`project file "${p}" is excluded by the environment cache ignore rules, so the copy in the VM ` +
             `is whatever a cold start uploaded and can be out of date. Move it under ` +
             `spectest/tests/ (still cache-free, and always re-uploaded), or drop the pattern.`);
     }

package/dist/recorder.d.ts

@@ -464,6 +464,8 @@ export interface BrowserEvent extends BaseEvent {
      * bundle to look the session up in.
      */
     sessionName?: string;
+    /** Presentation kind; Electron and mobile share the browser event transport. */
+    frame?: "browser" | "mobile" | "desktop";
     /**
      * Wall-clock `Date.now()` captured at the moment this op *finished*.
      * Lives in the same time base as rrweb's `event.timestamp` fields,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specific.dev/spectest",
-  "version": "0.87.0",
+  "version": "0.88.1",
   "description": "Spectest SDK for defining test environments in TypeScript.",
   "type": "module",
   "main": "./dist/index.js",