@gate-forge/pack-playwright 0.7.0 → 0.8.0

package/dist/vitest/index.js

@@ -0,0 +1,356 @@
+/**
+ * The gateforge Vitest helper (plan 2026-09-25 phase 4): the in-test
+ * half of the Vitest+supertest witness channel.
+ *
+ * `gateforgeSupertest(request)` wraps the suite's own supertest import
+ * and returns a tagged request function:
+ * - `await gate(appBaseUrl)` resolves the running test's session and
+ *   returns a supertest builder whose traffic is REWRITTEN from the app
+ *   origin onto that test's session proxy origin (resolved from the
+ *   supervisor through the exact `(workerIndex, testId)` identity the
+ *   pack's Vitest reporter spools) — every exchange is attributed to
+ *   THAT session, the same `session-proxy` channel the Playwright
+ *   fixture uses. Chain `.get/.post/.send` on the awaited builder
+ *   exactly as without gateforge.
+ * - `gate(app)` — the IN-PROCESS mode, where supertest calls the app
+ *   function/object directly — is REFUSED with a clear message and the
+ *   run fails. An in-process call never crosses the proxy, so it can
+ *   never be witnessed evidence; silently passing it would be a
+ *   counterfeit green.
+ *
+ * Without supervised wiring (`GATEFORGE_WITNESS_URL` /
+ * `GATEFORGE_RUN_TOKEN` / `GATEFORGE_STATE_DIR` / `GATEFORGE_RUN_ID`)
+ * a tagged call fails loudly — never silently unwitnessed.
+ */
+import { isAbsolute, relative } from 'node:path';
+import { getCurrentTest } from 'vitest/suite';
+import { humanMessage } from '@gate-forge/core';
+import { onTestFinished } from 'vitest';
+import { appendSpoolEvent, spoolPathFor } from '../supervisor/spool.js';
+import { claimInjectionsFor } from '../runner-claims.js';
+import { vitestWorkerSlot } from './worker-slot.js';
+/** Env the runner child receives from the adapter's allowlist. */
+const ENV_WITNESS_URL = 'GATEFORGE_WITNESS_URL';
+const ENV_RUN_TOKEN = 'GATEFORGE_RUN_TOKEN';
+const ENV_APP_BASE_URL = 'GATEFORGE_APP_BASE_URL';
+const ENV_STATE_DIR = 'GATEFORGE_STATE_DIR';
+const ENV_RUN_ID = 'GATEFORGE_RUN_ID';
+const RUN_HEADER = 'x-gateforge-run';
+/**
+ * How long a tagged call waits for the drain to open the session. The
+ * wait starts AFTER the test spooled its own begin, so it bounds the
+ * supervisor's own work (one 50ms poll plus the witness round trip),
+ * never the runner's event delivery. An unanswered resolve still fails
+ * the test loudly — never a silent untagged pass.
+ */
+const SESSION_RESOLVE_TIMEOUT_MS = 5_000;
+/** Poll cadence for the session resolve (supervisor→witness latency). */
+const SESSION_RESOLVE_POLL_MS = 50;
+/** Tests whose worker-side end is already announced (one per test). */
+const WORKER_END_ANNOUNCED = new Set();
+/** Session credentials resolved per test id (one HTTP round-trip each). */
+const RESOLVED_BY_TEST_ID = new Map();
+/**
+ * The title path of the running test: the suite chain's names, then the
+ * leaf title (the same join the pack's Vitest reporter spools).
+ */
+function titlePathOfCurrent(current) {
+    const segments = [];
+    let ancestor = current.suite ?? current.parent;
+    while (typeof ancestor === 'object' && ancestor !== null) {
+        const suite = ancestor;
+        if (suite.type !== 'suite')
+            break;
+        segments.unshift(suite.name ?? '');
+        ancestor = suite.suite ?? suite.parent;
+    }
+    segments.push(current.name);
+    return segments;
+}
+/**
+ * The reconciliation identity of the RUNNING test, exactly as the pack's
+ * Vitest reporter spools it: `<repo-relative posix file>#<titlePath>`.
+ *
+ * Returns:
+ *   CurrentIdentity | null: the identity, or null outside a test.
+ */
+function currentIdentity() {
+    const current = getCurrentTest();
+    if (current === undefined || current === null)
+        return null;
+    const file = current.file !== undefined && current.file !== null
+        ? fileRelativize(String(current.file.filepath))
+        : null;
+    if (file === null)
+        return null;
+    const titlePath = titlePathOfCurrent(current);
+    return { file, titlePath, testId: `${file}#${titlePath.join('>')}` };
+}
+/**
+ * Appends the running test's own `testBegin` to the run's lifecycle
+ * spool so the trusted drain can open its session without waiting for
+ * the runner's main-process reporter (see the call site). Best effort
+ * by contract: a failed append only means the reporter's own begin
+ * still has to arrive, never a crash and never a silent pass.
+ *
+ * Args:
+ *   identity: the running test's reconciliation identity.
+ *
+ * Returns:
+ *   void: nothing; the append is fire-and-forget.
+ */
+function spoolTestBegin(identity) {
+    const stateDir = process.env[ENV_STATE_DIR];
+    const runId = process.env[ENV_RUN_ID];
+    if (stateDir === undefined || stateDir === '' || runId === undefined || runId === '')
+        return;
+    const claims = claimInjectionsFor(stateDir, identity.testId);
+    appendSpoolEvent(spoolPathFor(stateDir, runId), {
+        kind: 'testBegin',
+        testId: identity.testId,
+        // The SAME derived slot the pack's reporter writes (see
+        // ./worker-slot.ts): vitest runs files in parallel, so a flat slot
+        // would make two running tests fight over one session.
+        workerIndex: vitestWorkerSlot(identity.file),
+        file: identity.file,
+        titlePath: identity.titlePath,
+        project: null,
+        ...(claims.length > 0 ? { claims } : {}),
+    });
+}
+/**
+ * Spools the running test's own `testEnd` — the WORKER-side end, with
+ * NO outcome (only the runner's main process knows the result, and only
+ * its reporter may state it).
+ *
+ * Vitest runs the tests of one file one at a time in one worker, and
+ * the main process reports each finished test back over IPC: on a
+ * loaded machine that report can trail by seconds. The next test's
+ * begin therefore used to queue behind the PREVIOUS test's end, and its
+ * session resolve timed out. Announcing the end here, in the same
+ * process and the same order as the begin, removes that dependency: the
+ * drain releases the worker slot and opens the next session at once,
+ * while this test's outcome still arrives (and seals) from the
+ * reporter's own end.
+ *
+ * Registered through `onTestFinished`, which vitest runs after the test
+ * body AND after every `afterEach` hook and cleanup — the last worker
+ * callback before the test's result is final, so no consumer hook can
+ * lose its session to it. Best effort like the begin: a failed append
+ * only means the reporter's own end still governs the seal.
+ *
+ * Args:
+ *   identity: the finished test's reconciliation identity.
+ *
+ * Returns:
+ *   void: nothing; the append is fire-and-forget.
+ */
+function spoolWorkerTestEnd(identity) {
+    const stateDir = process.env[ENV_STATE_DIR];
+    const runId = process.env[ENV_RUN_ID];
+    if (stateDir === undefined || stateDir === '' || runId === undefined || runId === '')
+        return;
+    appendSpoolEvent(spoolPathFor(stateDir, runId), {
+        kind: 'testEnd',
+        testId: identity.testId,
+        workerIndex: vitestWorkerSlot(identity.file),
+        file: identity.file,
+        titlePath: identity.titlePath,
+        project: null,
+        // No `outcome`: this event says the test is over, never how it went.
+    });
+}
+/**
+ * Registers the worker-side end for the RUNNING test (once per test:
+ * a repeated registration is a re-delivery the drain ignores).
+ *
+ * Args:
+ *   identity: the running test's reconciliation identity.
+ *
+ * Returns:
+ *   void: nothing; the registration is best effort.
+ */
+function announceWorkerTestEnd(identity) {
+    if (WORKER_END_ANNOUNCED.has(identity.testId))
+        return;
+    WORKER_END_ANNOUNCED.add(identity.testId);
+    try {
+        onTestFinished(() => {
+            spoolWorkerTestEnd(identity);
+        });
+    }
+    catch {
+        // Outside a test (or in a vitest that does not expose the hook):
+        // the reporter's own end still seals the session, so this is a
+        // missing optimisation, never a wrong verdict.
+    }
+}
+/** Repo-relative posix form of an absolute module path (process.cwd()). */
+function fileRelativize(path) {
+    const clean = path.replace(/^file:\/\//, '');
+    return (isAbsolute(clean) ? relative(process.cwd(), clean) : clean).split('\\').join('/');
+}
+/**
+ * Resolves the supervisor-issued session credential for the RUNNING
+ * test (polls briefly: the drain opens the session asynchronously after
+ * the reporter's testBegin event lands).
+ *
+ * Returns:
+ *   Promise<SessionCredential>: the open session's credential.
+ *
+ * Throws:
+ *   Error: when the wiring is absent, the test is not a gateforge-tagged
+ *   vitest test, or no open session answers — fail closed.
+ */
+async function resolveCurrentSession() {
+    const witnessUrl = process.env[ENV_WITNESS_URL];
+    const runToken = process.env[ENV_RUN_TOKEN];
+    if (witnessUrl === undefined ||
+        witnessUrl === '' ||
+        runToken === undefined ||
+        runToken === '' ||
+        process.env['GATEFORGE_STATE_DIR'] === undefined ||
+        process.env['GATEFORGE_RUN_ID'] === undefined) {
+        throw new Error(humanMessage({
+            type: 'witness-wiring-missing',
+            detail: 'this vitest test addresses the witness without the supervised wiring ' +
+                `(missing ${ENV_WITNESS_URL} / ${ENV_RUN_TOKEN} / GATEFORGE_STATE_DIR / GATEFORGE_RUN_ID)`,
+            nextAction: 'run under gateforge test-gates or the VitestRunnerAdapter',
+        }));
+    }
+    const identity = currentIdentity();
+    if (identity === null) {
+        throw new Error(humanMessage({
+            type: 'witness-session-unknown-test',
+            detail: 'gateforgeSupertest can only tag traffic inside a running vitest test',
+            nextAction: 'call it from the test body',
+        }));
+    }
+    const cached = RESOLVED_BY_TEST_ID.get(identity.testId);
+    if (cached !== undefined)
+        return cached;
+    // The lifecycle `testBegin` the drain opens this session from is
+    // normally spooled by the pack's reporter — which runs in vitest's
+    // MAIN process, whose event delivery trails the worker by as much as
+    // the whole test (its transform and reporter work is not the test's).
+    // The running test therefore announces its OWN begin before it waits:
+    // the spool is the untrusted runner's channel either way, the drain's
+    // open is idempotent for a repeated begin of the same test, and the
+    // witness still refuses any identity outside the registered expected
+    // set — so this races the reporter, it never widens what the suite can
+    // prove.
+    spoolTestBegin(identity);
+    // The same reasoning, mirrored for the END of this test: the reporter
+    // in the main process may be seconds behind, and the NEXT test of
+    // this file would otherwise queue its begin behind that report. The
+    // worker announces its own end (without an outcome — the reporter
+    // alone states the verdict), so the drain can free the slot now.
+    announceWorkerTestEnd(identity);
+    const deadline = Date.now() + SESSION_RESOLVE_TIMEOUT_MS;
+    let lastDetail = 'no answer';
+    while (Date.now() < deadline) {
+        const response = await fetch(`${witnessUrl.replace(/\/$/, '')}/sessions/resolve`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json', [RUN_HEADER]: runToken },
+            body: JSON.stringify({ testId: identity.testId, workerIndex: vitestWorkerSlot(identity.file) }),
+        });
+        if (response.ok) {
+            const body = (await response.json());
+            if (typeof body.sessionId === 'string' && body.sessionId !== '') {
+                const credential = {
+                    sessionId: body.sessionId,
+                    sessionToken: String(body.sessionToken ?? ''),
+                    proxyUrl: typeof body.proxyUrl === 'string' && body.proxyUrl !== '' ? body.proxyUrl : null,
+                };
+                RESOLVED_BY_TEST_ID.set(identity.testId, credential);
+                return credential;
+            }
+            lastDetail = 'malformed resolve response';
+        }
+        else if (response.status !== 404) {
+            lastDetail = `HTTP ${String(response.status)} from /sessions/resolve`;
+        }
+        await new Promise((resolveSleep) => setTimeout(resolveSleep, SESSION_RESOLVE_POLL_MS));
+    }
+    throw new Error(humanMessage({
+        type: 'witness-session-unresolved',
+        detail: `no open witness session answered for test '${identity.testId}' within ${String(SESSION_RESOLVE_TIMEOUT_MS)}ms (${lastDetail})`,
+        nextAction: 'run under the supervised window so the drain opens a session per started test',
+    }));
+}
+/**
+ * Rewrites an app-origin URL onto the session proxy origin (same
+ * loopback discipline as the Playwright page routing): the path, query,
+ * and hash stay exactly as the suite addressed them.
+ *
+ * A base URL with no path of its own (`http://127.0.0.1:3000`) becomes
+ * the bare proxy ORIGIN, never `<origin>/`: supertest concatenates the
+ * per-request path onto the address it is handed, so a trailing slash
+ * here would address `//api/accounts`.
+ */
+function rewriteThroughProxy(target, proxyUrl, appBaseUrl) {
+    if (appBaseUrl === '')
+        return target;
+    try {
+        const app = new URL(appBaseUrl);
+        const proxy = new URL(proxyUrl);
+        const parsed = new URL(target, appBaseUrl);
+        if (parsed.origin !== app.origin)
+            return target;
+        const bare = parsed.pathname === '/' && parsed.search === '' && parsed.hash === '';
+        return `${proxy.origin}${bare ? '' : parsed.pathname}${parsed.search}${parsed.hash}`;
+    }
+    catch {
+        return target;
+    }
+}
+/**
+ * Wraps the suite's supertest entry with the gateforge session channel.
+ *
+ * Args:
+ *   request: the suite's own supertest import (the callable). Only the
+ *     URL-string host mode is supported: in-process supertest calls the
+ *     app directly, which bypasses the witness proxy entirely.
+ *
+ * Returns:
+ *   (target: string) => Promise<SupertestTest>: the tagged request
+ *   factory. Pass it the app base URL (or an absolute URL) and AWAIT
+ *   it: the session must be resolved from the supervisor before any
+ *   request is addressed, so the suite reads
+ *   `await (await gate(app)).post('/api/accounts').send(...)`. A
+ *   non-string target (the app itself) throws immediately with the
+ *   refusal, before any request is sent.
+ */
+export function gateforgeSupertest(request) {
+    if (typeof request !== 'function') {
+        throw new TypeError('gateforgeSupertest expects the supertest callable (the default export)');
+    }
+    return (target) => {
+        if (typeof target !== 'string' || target.trim() === '') {
+            // The in-process mode fails LOUDLY: supertest would call the app
+            // function/object directly, no packet ever crosses the session
+            // proxy, and the "pass" would be counterfeit.
+            throw new Error(humanMessage({
+                type: 'in-process-client-refused',
+                detail: 'supertest was handed the app itself (in-process mode), which bypasses the gateforge ' +
+                    'session proxy entirely — such a request can never be witnessed evidence, so it is ' +
+                    'refused instead of silently passing',
+                nextAction: 'pass the app base URL (await gate(baseUrl)), not the app instance',
+            }));
+        }
+        const appBaseUrl = process.env[ENV_APP_BASE_URL] ?? '';
+        return (async () => {
+            const credential = await resolveCurrentSession();
+            if (credential.proxyUrl === null) {
+                throw new Error(humanMessage({
+                    type: 'witness-proxy-missing',
+                    detail: 'the witness issued no per-session proxy for this run — the run must wire an ' +
+                        'observation proxy so supertest traffic can be attributed to the session',
+                    nextAction: 'wire the witness with proxyTarget (test-gates does this for strict runs)',
+                }));
+            }
+            return request(rewriteThroughProxy(target, credential.proxyUrl, appBaseUrl));
+        })();
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/vitest/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/vitest/index.ts"],"names":[],"mappings":"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"}

package/dist/vitest/reporter.d.ts

@@ -0,0 +1,83 @@
+/**
+ * TEST SEAM (inert unless set): the absolute path of a BARRIER FILE
+ * this reporter waits for before it spools ANY `testEnd`.
+ *
+ * The lag between a worker finishing a test and this reporter seeing
+ * its result is exactly the race a serial project must survive, and it
+ * is load-dependent — a timing assertion can never pin it. The barrier
+ * makes that lag deterministic: whoever lifts the file holds the
+ * previous test's end for exactly as long as it wants, with no sleep,
+ * no CPU load and no wall-clock guess. Unset in every real run, so a
+ * supervised run is byte-for-byte the same run.
+ */
+export declare const VITEST_END_BARRIER_ENV = "GATEFORGE_VITEST_END_BARRIER";
+/** One observed Vitest test entity (structural subset of vitest's TestCase). */
+interface VitestTestCase {
+    /** The runner-assigned test id (a string in vitest 3.x). */
+    readonly id: string;
+    /** The leaf test title. */
+    readonly name: string;
+    /** The suite chain (vitest 3.x entities carry `parent`). */
+    readonly parent?: {
+        readonly name: string;
+        readonly type: string;
+        readonly parent?: unknown;
+    } | null;
+    /** Legacy alias for the suite chain (tasks carry `suite`). */
+    readonly suite?: {
+        readonly name: string;
+        readonly type: string;
+        readonly suite?: unknown;
+    } | null;
+    /** The owning module. */
+    readonly module: {
+        readonly moduleId: string;
+    };
+    /** The observed result (state is `passed`/`failed`/`skipped` when done). */
+    readonly result?: () => {
+        readonly state?: string;
+        readonly errors?: readonly unknown[];
+    } | undefined;
+    /** The raw task (retryCount lives on `task.result.retryCount`). */
+    readonly task?: {
+        readonly result?: {
+            readonly retryCount?: number;
+        } | null;
+    };
+}
+/**
+ * The gateforge Vitest reporter. No options today; the constructor
+ * signature is Vitest's custom-reporter contract (options object).
+ */
+export default class GateforgeVitestReporter {
+    private readonly stateDir;
+    private readonly spoolFile;
+    private readonly flagsFile;
+    private readonly endBarrier;
+    private retriesDetected;
+    constructor(_options?: object);
+    /** Spools one lifecycle event (never crashes the run on failure). */
+    private appendEvent;
+    /** testBegin: the trusted drain opens the session for this identity. */
+    onTestCaseReady(testCase: VitestTestCase): void;
+    /**
+     * testEnd: the observed outcome plus the attempt count (a
+     * runner-assisted retry shows up as retryCount > 0 and is recorded in
+     * the runner-flags document, which the adapter surfaces as
+     * `retriesDetected` — required retries are zero). When the test-seam
+     * end barrier is set, the event is held until the barrier file
+     * appears: the worker's lifecycle then races this reporter exactly as
+     * it does on a loaded machine, but deterministically.
+     */
+    onTestCaseResult(testCase: VitestTestCase): Promise<void>;
+    /** Seals the runner-flags document with the observed retry signal. */
+    onTestRunEnd(): void;
+    /**
+     * Mapped obligation ids for one reconciliation key (from the
+     * CLI-written claim-injections document; malformed documents
+     * contribute nothing).
+     */
+    private claimsFor;
+}
+export {};
+//# sourceMappingURL=reporter.d.ts.map

package/dist/vitest/reporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reporter.d.ts","sourceRoot":"","sources":["../../src/vitest/reporter.ts"],"names":[],"mappings":"AAqCA;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,sBAAsB,iCAAiC,CAAC;AA+BrE,gFAAgF;AAChF,UAAU,cAAc;IACtB,4DAA4D;IAC5D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,2BAA2B;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,4DAA4D;IAC5D,QAAQ,CAAC,MAAM,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;IACrG,8DAA8D;IAC9D,QAAQ,CAAC,KAAK,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;IACnG,yBAAyB;IACzB,QAAQ,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;IAC/C,4EAA4E;IAC5E,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM;QAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,OAAO,EAAE,CAAA;KAAE,GAAG,SAAS,CAAC;IACtG,mEAAmE;IACnE,QAAQ,CAAC,IAAI,CAAC,EAAE;QAAE,QAAQ,CAAC,MAAM,CAAC,EAAE;YAAE,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;SAAE,GAAG,IAAI,CAAA;KAAE,CAAC;CAC/E;AAmDD;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,uBAAuB;IAC1C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgB;IACzC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgB;IAC1C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgB;IAC1C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgB;IAC3C,OAAO,CAAC,eAAe,CAAS;gBAEpB,QAAQ,GAAE,MAAW;IAUjC,qEAAqE;IACrE,OAAO,CAAC,WAAW;IAUnB,wEAAwE;IACxE,eAAe,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI;IAkB/C;;;;;;;;OAQG;IACG,gBAAgB,CAAC,QAAQ,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IA0B/D,sEAAsE;IACtE,YAAY,IAAI,IAAI;IAcpB;;;;OAIG;IACH,OAAO,CAAC,SAAS;CAKlB"}

package/dist/vitest/reporter.js

@@ -0,0 +1,211 @@
+/**
+ * The gateforge Vitest reporter (plan 2026-09-25 phase 4): the
+ * runner-side half of the Vitest+supertest witness channel.
+ *
+ * While the supervised Vitest run executes, this reporter writes the
+ * same lifecycle spool events the Playwright reporter writes
+ * (testBegin / testEnd with the test identity, outcome, attempt) plus a
+ * runner-flags document recording runner-assisted retries — the
+ * TRUSTED CLI drain reads the spool and performs the witness's
+ * supervisor calls (session open/seal); this process holds no
+ * supervisor rights at all.
+ *
+ * Identity: a test's reconciliation key is
+ * `<repo-relative posix file>#<title path joined by '>'>` — the same
+ * key shape every runner adapter uses. The in-test helper
+ * (`@gate-forge/pack-playwright/vitest`) resolves its session by the
+ * EXACT identity this reporter writes, so the two must never drift.
+ *
+ * The reporter is INERT without supervised wiring: without the
+ * run-scoped `GATEFORGE_STATE_DIR`/`GATEFORGE_RUN_ID` variables every
+ * hook is a no-op, so a plain `vitest run` behaves exactly as without
+ * the reporter.
+ *
+ * Loaded by the VitestRunnerAdapter through `--reporter=<this module>`;
+ * Vitest instantiates custom reporters with `new`.
+ */
+import { appendFileSync, existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { canonicalOf } from '../json.js';
+import { failureDiagnosisOf } from '../diagnosis.js';
+import { claimInjectionsFor } from '../runner-claims.js';
+import { vitestWorkerSlot } from './worker-slot.js';
+/** Env the runner child receives from the adapter's allowlist. */
+const ENV_STATE_DIR = 'GATEFORGE_STATE_DIR';
+const ENV_RUN_ID = 'GATEFORGE_RUN_ID';
+/**
+ * TEST SEAM (inert unless set): the absolute path of a BARRIER FILE
+ * this reporter waits for before it spools ANY `testEnd`.
+ *
+ * The lag between a worker finishing a test and this reporter seeing
+ * its result is exactly the race a serial project must survive, and it
+ * is load-dependent — a timing assertion can never pin it. The barrier
+ * makes that lag deterministic: whoever lifts the file holds the
+ * previous test's end for exactly as long as it wants, with no sleep,
+ * no CPU load and no wall-clock guess. Unset in every real run, so a
+ * supervised run is byte-for-byte the same run.
+ */
+export const VITEST_END_BARRIER_ENV = 'GATEFORGE_VITEST_END_BARRIER';
+/** Bound on the barrier wait (a barrier nobody lifts must never hang the run). */
+const END_BARRIER_TIMEOUT_MS = 60_000;
+/** Poll cadence while the barrier is closed (the wait is on a file, never on a guess). */
+const END_BARRIER_POLL_MS = 25;
+/** The runner-flags document the adapter merges into its envelope. */
+const RUNNER_FLAGS_FILE = 'runner-flags.json';
+/**
+ * Waits until the end-barrier file exists (see {@link VITEST_END_BARRIER_ENV}).
+ *
+ * Returns at once when the seam is unset or the file is already there;
+ * a barrier nobody lifts times out with a warning instead of hanging
+ * the runner forever.
+ *
+ * Returns:
+ *   Promise<void>: resolves once the barrier is open (or the bound elapsed).
+ */
+async function awaitEndBarrier(barrier) {
+    if (barrier === null || barrier === '')
+        return;
+    const deadline = Date.now() + END_BARRIER_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        if (existsSync(barrier))
+            return;
+        await new Promise((resolveSleep) => setTimeout(resolveSleep, END_BARRIER_POLL_MS));
+    }
+    console.warn(`[gateforge] the vitest reporter end barrier '${barrier}' was never lifted; continuing`);
+}
+/**
+ * The title path of one test entity: the suite chain's names, then the
+ * leaf title (the same join `vitest list --json` prints with ' > ').
+ */
+function titlePathOf(testCase) {
+    const segments = [];
+    let current = testCase.parent ?? testCase.suite;
+    while (typeof current === 'object' && current !== null) {
+        const suite = current;
+        if (suite.type !== 'suite')
+            break;
+        segments.unshift(suite.name);
+        current = suite.parent ?? suite.suite;
+    }
+    segments.push(testCase.name);
+    return segments;
+}
+/**
+ * The reconciliation identity of one test entity: repo-relative posix
+ * file plus the title path, keyed `<file>#<titlePath.join('>')>`.
+ */
+function identityOf(testCase) {
+    const file = relative(process.cwd(), testCase.module.moduleId).split('\\').join('/');
+    const titlePath = titlePathOf(testCase);
+    return { file, titlePath, testId: `${file}#${titlePath.join('>')}` };
+}
+/**
+ * The gateforge Vitest reporter. No options today; the constructor
+ * signature is Vitest's custom-reporter contract (options object).
+ */
+export default class GateforgeVitestReporter {
+    stateDir;
+    spoolFile;
+    flagsFile;
+    endBarrier;
+    retriesDetected = false;
+    constructor(_options = {}) {
+        const stateDir = process.env[ENV_STATE_DIR];
+        const runId = process.env[ENV_RUN_ID];
+        const wired = stateDir !== undefined && stateDir !== '' && runId !== undefined && runId !== '';
+        this.stateDir = wired ? stateDir : null;
+        this.spoolFile = wired ? join(stateDir, 'spool', runId, 'events.jsonl') : null;
+        this.flagsFile = wired ? join(stateDir, 'vitest', runId, RUNNER_FLAGS_FILE) : null;
+        this.endBarrier = process.env[VITEST_END_BARRIER_ENV] ?? null;
+    }
+    /** Spools one lifecycle event (never crashes the run on failure). */
+    appendEvent(event) {
+        if (this.spoolFile === null)
+            return;
+        try {
+            mkdirSync(dirname(this.spoolFile), { recursive: true });
+            appendFileSync(this.spoolFile, `${canonicalOf(event)}\n`, 'utf8');
+        }
+        catch (error) {
+            console.warn(`[gateforge] cannot append to the lifecycle spool: ${error.message}`);
+        }
+    }
+    /** testBegin: the trusted drain opens the session for this identity. */
+    onTestCaseReady(testCase) {
+        if (this.spoolFile === null)
+            return;
+        const identity = identityOf(testCase);
+        // The slot is derived from the file both processes agree on (see
+        // ./worker-slot.ts): vitest runs FILES in parallel, so one flat slot
+        // would collide two running tests and fail a genuinely parallel
+        // project closed.
+        this.appendEvent({
+            kind: 'testBegin',
+            testId: identity.testId,
+            workerIndex: vitestWorkerSlot(identity.file),
+            file: identity.file,
+            titlePath: identity.titlePath,
+            project: null,
+            ...this.claimsFor(identity),
+        });
+    }
+    /**
+     * testEnd: the observed outcome plus the attempt count (a
+     * runner-assisted retry shows up as retryCount > 0 and is recorded in
+     * the runner-flags document, which the adapter surfaces as
+     * `retriesDetected` — required retries are zero). When the test-seam
+     * end barrier is set, the event is held until the barrier file
+     * appears: the worker's lifecycle then races this reporter exactly as
+     * it does on a loaded machine, but deterministically.
+     */
+    async onTestCaseResult(testCase) {
+        if (this.spoolFile === null)
+            return;
+        await awaitEndBarrier(this.endBarrier);
+        const identity = identityOf(testCase);
+        const result = testCase.result?.();
+        const state = result?.state;
+        const outcome = state === 'passed' || state === 'failed' || state === 'skipped' ? state : 'failed';
+        const retryCount = testCase.task?.result?.retryCount ?? 0;
+        if (retryCount > 0)
+            this.retriesDetected = true;
+        this.appendEvent({
+            kind: 'testEnd',
+            testId: identity.testId,
+            workerIndex: vitestWorkerSlot(identity.file),
+            file: identity.file,
+            titlePath: identity.titlePath,
+            project: null,
+            outcome,
+            attempt: retryCount + 1,
+            // Additive diagnosis for a non-passing test: the CI progress
+            // stream and the failures artifact are the only readers, and the
+            // CLI screens the message before printing or writing it.
+            ...(outcome === 'passed' ? {} : (failureDiagnosisOf(result?.errors) ?? {})),
+        });
+    }
+    /** Seals the runner-flags document with the observed retry signal. */
+    onTestRunEnd() {
+        if (this.flagsFile === null)
+            return;
+        try {
+            mkdirSync(dirname(this.flagsFile), { recursive: true });
+            writeFileSync(this.flagsFile, `${canonicalOf({ schemaVersion: 1, retriesDetected: this.retriesDetected })}\n`, 'utf8');
+        }
+        catch (error) {
+            console.warn(`[gateforge] cannot write the runner flags: ${error.message}`);
+        }
+    }
+    /**
+     * Mapped obligation ids for one reconciliation key (from the
+     * CLI-written claim-injections document; malformed documents
+     * contribute nothing).
+     */
+    claimsFor(identity) {
+        if (this.stateDir === null)
+            return {};
+        const claims = claimInjectionsFor(this.stateDir, identity.testId);
+        return claims.length > 0 ? { claims } : {};
+    }
+}
+//# sourceMappingURL=reporter.js.map