@elench/testkit 0.1.82 → 0.1.83

package/lib/cli/tui/run-tree-state.test.mjs

@@ -0,0 +1,324 @@
+import { describe, expect, it } from "vitest";
+import { createRunTreeState } from "./run-tree-state.mjs";
+
+function makePlans(suites = []) {
+  return [
+    {
+      config: { name: "api" },
+      skipped: false,
+      suites: suites.length > 0 ? suites : [
+        {
+          name: "users",
+          type: "integration",
+          displayType: "int",
+          framework: "k6",
+          files: ["tests/api/users.int.testkit.ts", "tests/api/users-create.int.testkit.ts"],
+        },
+        {
+          name: "auth",
+          type: "integration",
+          displayType: "int",
+          framework: "k6",
+          files: ["tests/api/auth.int.testkit.ts"],
+        },
+      ],
+    },
+  ];
+}
+
+describe("run-tree-state", () => {
+  it("builds tree hierarchy from service plans", () => {
+    const state = createRunTreeState();
+    state.initFromPlans(makePlans());
+    const snap = state.getSnapshot();
+
+    expect(snap.services).toHaveLength(1);
+    expect(snap.services[0].name).toBe("api");
+    expect(snap.services[0].skipped).toBe(false);
+    expect(snap.services[0].types).toHaveLength(1);
+    expect(snap.services[0].types[0].type).toBe("int");
+    expect(snap.services[0].types[0].suites).toHaveLength(2);
+    expect(snap.services[0].types[0].suites[0].groupLabel).toBe("Users");
+    expect(snap.services[0].types[0].suites[0].visibleFiles).toHaveLength(2);
+    expect(snap.services[0].types[0].suites[1].groupLabel).toBe("Auth");
+  });
+
+  it("marks file running", () => {
+    const state = createRunTreeState();
+    state.initFromPlans(makePlans());
+    state.markFileRunning("api", "int:users", "tests/api/users.int.testkit.ts");
+    const snap = state.getSnapshot();
+    const file = snap.services[0].types[0].suites[0].visibleFiles.find(
+      (f) => f.path === "tests/api/users.int.testkit.ts"
+    );
+    expect(file.status).toBe("running");
+  });
+
+  it("collapses suite when all files pass", () => {
+    const state = createRunTreeState();
+    state.initFromPlans(makePlans());
+    state.setTotalFileCount(3);
+
+    state.markFileFinished(
+      { serviceName: "api", type: "integration", displayType: "int", framework: "k6", suiteName: "users", file: "tests/api/users.int.testkit.ts" },
+      { failed: false, durationMs: 1200 }
+    );
+    state.markFileFinished(
+      { serviceName: "api", type: "integration", displayType: "int", framework: "k6", suiteName: "users", file: "tests/api/users-create.int.testkit.ts" },
+      { failed: false, durationMs: 800 }
+    );
+
+    const snap = state.getSnapshot();
+    const suite = snap.services[0].types[0].suites[0];
+    expect(suite.collapsed).toBe(true);
+    expect(suite.collapseStatus).toBe("all_passed");
+    expect(suite.visibleFiles).toHaveLength(0);
+    expect(suite.totalDurationMs).toBe(2000);
+    expect(snap.completedCount).toBe(2);
+  });
+
+  it("collapses suite when all files skipped", () => {
+    const state = createRunTreeState();
+    state.initFromPlans(makePlans());
+
+    state.markFileFinished(
+      { serviceName: "api", type: "integration", displayType: "int", framework: "k6", suiteName: "users", file: "tests/api/users.int.testkit.ts" },
+      { status: "skipped", reason: "ci skip", durationMs: 0 }
+    );
+    state.markFileFinished(
+      { serviceName: "api", type: "integration", displayType: "int", framework: "k6", suiteName: "users", file: "tests/api/users-create.int.testkit.ts" },
+      { status: "skipped", reason: "ci skip", durationMs: 0 }
+    );
+
+    const snap = state.getSnapshot();
+    const suite = snap.services[0].types[0].suites[0];
+    expect(suite.collapsed).toBe(true);
+    expect(suite.collapseStatus).toBe("all_skipped");
+  });
+
+  it("keeps suite expanded when a file fails", () => {
+    const state = createRunTreeState();
+    state.initFromPlans(makePlans());
+
+    state.markFileFinished(
+      { serviceName: "api", type: "integration", displayType: "int", framework: "k6", suiteName: "users", file: "tests/api/users.int.testkit.ts" },
+      { failed: false, durationMs: 1200 }
+    );
+    state.markFileFinished(
+      { serviceName: "api", type: "integration", displayType: "int", framework: "k6", suiteName: "users", file: "tests/api/users-create.int.testkit.ts" },
+      { failed: true, error: "assertion failed", durationMs: 500, failureDetails: [] }
+    );
+
+    const snap = state.getSnapshot();
+    const suite = snap.services[0].types[0].suites[0];
+    expect(suite.collapsed).toBe(false);
+    // Only failed files visible when no running/pending
+    expect(suite.visibleFiles).toHaveLength(1);
+    expect(suite.visibleFiles[0].status).toBe("failed");
+    expect(suite.passedCount).toBe(1);
+  });
+
+  it("keeps suite expanded while files are running", () => {
+    const state = createRunTreeState();
+    state.initFromPlans(makePlans());
+
+    state.markFileRunning("api", "int:users", "tests/api/users.int.testkit.ts");
+    state.markFileFinished(
+      { serviceName: "api", type: "integration", displayType: "int", framework: "k6", suiteName: "users", file: "tests/api/users-create.int.testkit.ts" },
+      { failed: false, durationMs: 800 }
+    );
+
+    const snap = state.getSnapshot();
+    const suite = snap.services[0].types[0].suites[0];
+    expect(suite.collapsed).toBe(false);
+    expect(suite.visibleFiles).toHaveLength(2);
+  });
+
+  it("type collapses when all suites are collapsed", () => {
+    const state = createRunTreeState();
+    state.initFromPlans(makePlans());
+
+    // Pass all files in both suites
+    state.markFileFinished(
+      { serviceName: "api", type: "integration", displayType: "int", framework: "k6", suiteName: "users", file: "tests/api/users.int.testkit.ts" },
+      { failed: false, durationMs: 1000 }
+    );
+    state.markFileFinished(
+      { serviceName: "api", type: "integration", displayType: "int", framework: "k6", suiteName: "users", file: "tests/api/users-create.int.testkit.ts" },
+      { failed: false, durationMs: 500 }
+    );
+    state.markFileFinished(
+      { serviceName: "api", type: "integration", displayType: "int", framework: "k6", suiteName: "auth", file: "tests/api/auth.int.testkit.ts" },
+      { failed: false, durationMs: 2000 }
+    );
+
+    const snap = state.getSnapshot();
+    const type = snap.services[0].types[0];
+    expect(type.collapsed).toBe(true);
+  });
+
+  it("tracks completed and total counts", () => {
+    const state = createRunTreeState();
+    state.initFromPlans(makePlans());
+    state.setTotalFileCount(3);
+
+    expect(state.getSnapshot().totalCount).toBe(3);
+    expect(state.getSnapshot().completedCount).toBe(0);
+
+    state.markFileFinished(
+      { serviceName: "api", type: "integration", displayType: "int", framework: "k6", suiteName: "users", file: "tests/api/users.int.testkit.ts" },
+      { failed: false, durationMs: 100 }
+    );
+    expect(state.getSnapshot().completedCount).toBe(1);
+  });
+
+  it("handles skipped services", () => {
+    const state = createRunTreeState();
+    state.initFromPlans([{ config: { name: "web" }, skipped: true, suites: [] }]);
+    const snap = state.getSnapshot();
+    expect(snap.services[0].skipped).toBe(true);
+  });
+
+  it("markServiceSkipped updates existing service", () => {
+    const state = createRunTreeState();
+    state.initFromPlans(makePlans());
+    state.markServiceSkipped("api", "no matching types");
+    const snap = state.getSnapshot();
+    expect(snap.services[0].skipped).toBe(true);
+    expect(snap.services[0].skipReason).toBe("no matching types");
+  });
+
+  it("finish populates summaryData", () => {
+    const state = createRunTreeState();
+    state.initFromPlans(makePlans());
+
+    const mockResults = [
+      {
+        name: "api",
+        failed: false,
+        skipped: false,
+        suiteCount: 2,
+        completedSuiteCount: 2,
+        failedSuiteCount: 0,
+        skippedSuiteCount: 0,
+        totalFileCount: 3,
+        passedFileCount: 3,
+        failedFileCount: 0,
+        skippedFileCount: 0,
+        notRunFileCount: 0,
+        suites: [],
+        errors: [],
+      },
+    ];
+
+    state.finish(mockResults, 5000, null);
+    const snap = state.getSnapshot();
+    expect(snap.finished).toBe(true);
+    expect(snap.summaryData.result).toBe("PASSED");
+    expect(snap.summaryData.rows.length).toBeGreaterThanOrEqual(7);
+  });
+
+  it("subscribe fires callback on state mutations", () => {
+    const state = createRunTreeState();
+    state.initFromPlans(makePlans());
+    let callCount = 0;
+    state.subscribe(() => { callCount += 1; });
+
+    state.setTotalFileCount(3);
+    state.setPhase("running");
+    expect(callCount).toBe(2);
+  });
+
+  it("markPlannedSkip sets file status and increments completed", () => {
+    const state = createRunTreeState();
+    state.initFromPlans(makePlans());
+    state.setTotalFileCount(3);
+
+    state.markPlannedSkip({ serviceName: "api", file: "tests/api/users.int.testkit.ts", reason: "ci skip" });
+    const snap = state.getSnapshot();
+    const file = snap.services[0].types[0].suites[0].visibleFiles.find(
+      (f) => f.path === "tests/api/users.int.testkit.ts"
+    );
+    expect(file.status).toBe("skipped");
+    expect(snap.completedCount).toBe(1);
+  });
+
+  it("markRuntimeError marks file failed", () => {
+    const state = createRunTreeState();
+    state.initFromPlans(makePlans());
+
+    state.markRuntimeError(
+      { serviceName: "api", file: "tests/api/users.int.testkit.ts" },
+      "process crashed"
+    );
+    const snap = state.getSnapshot();
+    const file = snap.services[0].types[0].suites[0].visibleFiles.find(
+      (f) => f.path === "tests/api/users.int.testkit.ts"
+    );
+    expect(file.status).toBe("failed");
+    expect(file.error).toBe("process crashed");
+  });
+
+  it("tracks the selected failure after a file fails", () => {
+    const state = createRunTreeState();
+    state.initFromPlans(makePlans());
+
+    state.markFileFinished(
+      {
+        serviceName: "api",
+        type: "integration",
+        displayType: "int",
+        framework: "k6",
+        suiteName: "users",
+        file: "tests/api/users-create.int.testkit.ts",
+      },
+      { failed: true, error: "assertion failed", durationMs: 500, failureDetails: [] }
+    );
+
+    const snap = state.getSnapshot();
+    expect(snap.failures).toHaveLength(1);
+    expect(snap.selectedFailure.filePath).toBe("tests/api/users-create.int.testkit.ts");
+  });
+
+  it("cycles through failures", () => {
+    const state = createRunTreeState();
+    state.initFromPlans(makePlans());
+
+    state.markRuntimeError(
+      { serviceName: "api", file: "tests/api/users.int.testkit.ts" },
+      "process crashed"
+    );
+    state.markRuntimeError(
+      { serviceName: "api", file: "tests/api/auth.int.testkit.ts" },
+      "another crash"
+    );
+
+    const first = state.getSnapshot().selectedFailure.filePath;
+    state.selectNextFailure();
+    const second = state.getSnapshot().selectedFailure.filePath;
+    expect(second).not.toBe(first);
+    state.selectPreviousFailure();
+    expect(state.getSnapshot().selectedFailure.filePath).toBe(first);
+  });
+
+  it("records investigation transcript state", () => {
+    const state = createRunTreeState();
+    state.initFromPlans(makePlans());
+    state.markRuntimeError(
+      { serviceName: "api", file: "tests/api/users.int.testkit.ts" },
+      "process crashed"
+    );
+
+    state.beginInvestigation({ provider: "codex", userMessage: "Investigate this failure" });
+    state.appendAgentEvent({ type: "start" });
+    state.appendAgentEvent({ type: "status", message: "Inspecting repository" });
+    state.appendAgentEvent({ type: "delta", text: "Likely root cause." });
+    state.completeAgentSession({ finalText: "Likely root cause.", exitCode: 0 });
+
+    const snap = state.getSnapshot();
+    expect(snap.mode).toBe("investigating");
+    expect(snap.agentSession.status).toBe("complete");
+    expect(snap.agentSession.entries.some((entry) => entry.kind === "assistant")).toBe(true);
+    expect(snap.agentSession.finalText).toContain("Likely root cause");
+  });
+});

package/lib/config-api/auth-fixtures.mjs

@@ -250,16 +250,21 @@ function resolveActorSession({ actorDefinition, actorIndex, contract, env }) {
   };
 
   if (contract.signup.enabled) {
-    runProfileRequest({
-      requestConfig: {
-        body: () => buildSignupBody(actorDefinition),
-        expect: contract.signup.expect,
-        method: "POST",
-        path: contract.signup.path,
-      },
-      context: { ...context, phase: "signup" },
-      label: `auth.fixture signup for actor "${actorDefinition.actorName}"`,
-    });
+    try {
+      runProfileRequest({
+        requestConfig: {
+          body: () => buildSignupBody(actorDefinition),
+          expect: contract.signup.expect,
+          method: "POST",
+          path: contract.signup.path,
+        },
+        context: { ...context, phase: "signup" },
+        label: `auth.fixture signup for actor "${actorDefinition.actorName}"`,
+      });
+    } catch {
+      // Provisioning is best-effort. Some apps report duplicate-account races as 500s
+      // instead of a clean 409, and a successful login is the authoritative signal.
+    }
   }
 
   const response = runProfileRequest({

package/lib/config-api/index.test.mjs

@@ -137,6 +137,60 @@ describe("config api", () => {
     expect(topology.actors.primary.organizationName).toBe("Testkit Sample App Primary Org");
   });
 
+  it("treats signup as best-effort when login still succeeds", () => {
+    registerRuntimeContext({
+      env: {
+        BASE: "http://api.test",
+        routeParams: {},
+      },
+      http: {
+        post(url, body) {
+          const payload = JSON.parse(body);
+          if (url.endsWith("/signup")) {
+            return {
+              status: 500,
+              body: JSON.stringify({ error: "Failed to create account" }),
+              headers: {},
+            };
+          }
+
+          return {
+            status: 200,
+            body: JSON.stringify({
+              data: {
+                organizations: [{ id: "org-primary" }],
+              },
+            }),
+            headers: {
+              "set-cookie": ["fixture_session=jwt-primary; Path=/"],
+            },
+          };
+        },
+      },
+    });
+
+    const fixture = auth.fixture({
+      contract: auth.contracts.jsonSession({
+        authCookie: "fixture_session",
+        organizationIdPath: "data.organizations[0].id",
+      }),
+      topology: auth.topologies.singleOrg({
+        namespace: "signup-race",
+        actors: ["primary"],
+      }),
+    });
+
+    const profiles = fixture.profiles({
+      default: auth.profile.actor("primary"),
+    });
+
+    const setup = profiles.default.auth.setup({ env: { BASE: "http://api.test", routeParams: {} } });
+    expect(setup.actors.primary.organizationId).toBe("org-primary");
+    expect(setup.actors.primary.jwt).toBe("jwt-primary");
+
+    clearRuntimeContext();
+  });
+
   it("defines file-local metadata plainly", () => {
     expect(defineFile({ skip: "Auth is stubbed", locks: ["background-workers"] })).toEqual({
       skip: "Auth is stubbed",

package/lib/discovery/index.mjs

@@ -494,7 +494,7 @@ function normalizePath(filePath) {
   return String(filePath).split(path.sep).join("/").replace(/^\.\/+/, "");
 }
 
-function fileDisplayName(filePath) {
+export function fileDisplayName(filePath) {
   const base = path.posix
     .basename(filePath)
     .replace(/(\.int|\.e2e|\.scenario|\.dal|\.load|\.pw)\.testkit\.ts$/, "");

package/lib/index.d.ts

@@ -2,6 +2,7 @@ import type {
   ActorRequestClient,
   HttpClient,
   HttpClientConfig,
+  RawRequestClient,
   RuntimeDb,
   RuntimeDalContext,
   RuntimeEnv,
@@ -33,11 +34,14 @@ export interface AuthAdapter<TSetup = unknown> {
 
 export interface SuiteActor<TSession = Record<string, unknown>> {
   email: string | null;
+  headers: RuntimeHeaders;
   index: number;
   key: string;
   name: string | null;
   organizationKey: string | null;
   organizationName: string | null;
+  rawHeaders: RuntimeHeaders;
+  rawReq: RawRequestClient;
   req: ActorRequestClient;
   session: TSession | null;
 }
@@ -55,7 +59,7 @@ export interface HttpSuiteContext<TSession = Record<string, unknown>> {
   actors: SuiteActors<TSession>;
   env: RuntimeEnv;
   req: HttpClient<TSession>;
-  rawReq: HttpClient["raw"];
+  rawReq: RawRequestClient;
 }
 
 export interface ScenarioStepResult {

package/lib/runner/orchestrator.mjs

@@ -85,6 +85,7 @@ export async function runAll(configs, typeValues, suiteSelectors, opts, allConfi
     execution,
     reporter
   );
+  reporter?.setServicePlans?.(servicePlans);
   const trackers = buildServiceTrackers(servicePlans, startedAt);
   let writeLiveSnapshot = () => {};
   const setupRegistry = createSetupOperationRegistry({ logRegistry, onChange: () => writeLiveSnapshot() });

package/lib/runtime/index.d.ts

@@ -141,9 +141,36 @@ export interface HttpClientConfig<TSetup = unknown> {
   sessionBundle?: AuthSessionBundle<TSetup> | null;
 }
 
-export interface ActorRequestClient {
+export interface MultipartFileInput {
+  contentType?: string;
+  data: unknown;
+  field: string;
+  filename?: string;
+}
+
+export interface MultipartPayload {
+  fields?: Record<string, unknown>;
+  files?: MultipartFileInput[];
+}
+
+export interface MultipartRequestClient {
+  patch(path: string, payload: MultipartPayload, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  post(path: string, payload: MultipartPayload, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  put(path: string, payload: MultipartPayload, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+}
+
+export interface RawRequestClient {
+  (
+    method: RuntimeMethod,
+    path: string,
+    body?: unknown,
+    extraHeaders?: RuntimeHeaders
+  ): RuntimeResponse;
+  as(actorName: string): RawRequestClient;
   delete(path: string, extraHeaders?: RuntimeHeaders): RuntimeResponse;
   get(path: string, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  headers(extraHeaders?: RuntimeHeaders): RuntimeHeaders;
+  multipart: MultipartRequestClient;
   patch(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
   post(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
   put(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
@@ -155,24 +182,53 @@ export interface ActorRequestClient {
   ): RuntimeResponse;
 }
 
-export interface HttpClient<TSetup = unknown> {
-  as(actorName: string): ActorRequestClient;
+export interface ActorRequestClient {
+  headers(extraHeaders?: RuntimeHeaders): RuntimeHeaders;
+  multipart: MultipartRequestClient;
+  raw(
+    method: RuntimeMethod,
+    path: string,
+    body?: unknown,
+    extraHeaders?: RuntimeHeaders
+  ): RuntimeResponse;
+  rawDelete(path: string, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  rawGet(path: string, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  rawHeaders(extraHeaders?: RuntimeHeaders): RuntimeHeaders;
+  rawMultipart: MultipartRequestClient;
+  rawPatch(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  rawPost(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  rawPut(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  rawReq: RawRequestClient;
   delete(path: string, extraHeaders?: RuntimeHeaders): RuntimeResponse;
   get(path: string, extraHeaders?: RuntimeHeaders): RuntimeResponse;
   patch(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
   post(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
   put(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
-  raw(
+  request(
     method: RuntimeMethod,
     path: string,
     body?: unknown,
     extraHeaders?: RuntimeHeaders
   ): RuntimeResponse;
+}
+
+export interface HttpClient<TSetup = unknown> {
+  as(actorName: string): ActorRequestClient;
+  headers(extraHeaders?: RuntimeHeaders): RuntimeHeaders;
+  multipart: MultipartRequestClient;
+  delete(path: string, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  get(path: string, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  patch(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  post(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  put(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
   rawDelete(path: string, extraHeaders?: RuntimeHeaders): RuntimeResponse;
   rawGet(path: string, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  rawHeaders(actorName?: string | null, extraHeaders?: RuntimeHeaders): RuntimeHeaders;
+  rawMultipart: MultipartRequestClient;
   rawPatch(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
   rawPost(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
   rawPut(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  raw: RawRequestClient;
   request(
     method: RuntimeMethod,
     path: string,
@@ -255,7 +311,7 @@ export declare function makeRawReq(
   baseUrl: string,
   routeHeaders?: RuntimeHeaders,
   getRawHeaders?: (context: HttpHeaderBuildContext<never>) => RuntimeHeaders | void
-): HttpClient["raw"];
+): RawRequestClient;
 
 export declare function expectStatus(
   response: RuntimeResponse,
@@ -283,6 +339,83 @@ export declare function expectJsonPath(
   predicate: (value: unknown) => boolean,
   label?: string | null
 ): boolean;
+export declare function expectErrorShape(
+  response: RuntimeResponse,
+  label?: string | null
+): boolean;
+export declare function expectErrorMessage(
+  response: RuntimeResponse,
+  label?: string | null
+): boolean;
+export declare function expectResponse(
+  response: RuntimeResponse,
+  predicate: (response: RuntimeResponse) => boolean,
+  label: string
+): boolean;
+export declare function expectValue<T>(
+  value: T,
+  predicate: (value: T) => boolean,
+  label: string
+): boolean;
+export declare function expectCondition(
+  predicate: () => boolean,
+  label: string
+): boolean;
+
+export declare function runAuthGateChecks(
+  rawReq: RawRequestClient,
+  scope: string,
+  descriptors: {
+    delete?: Array<string>;
+    get?: Array<string>;
+    patch?: Array<string | [string, unknown]>;
+    post?: Array<string | [string, unknown]>;
+    put?: Array<string | [string, unknown]>;
+    validateGetErrorShape?: boolean;
+  }
+): void;
+export declare function runPaginationChecks(
+  req: Pick<HttpClient, "get">,
+  endpoint: string,
+  options?: { auditLogsExtra?: boolean }
+): void;
+
+export interface RuntimeExpectNamespace {
+  condition: typeof expectCondition;
+  error: {
+    message: typeof expectErrorMessage;
+    shape: typeof expectErrorShape;
+  };
+  json: typeof expectJson;
+  jsonPath: typeof expectJsonPath;
+  notStatus: typeof expectNotStatus;
+  response: typeof expectResponse;
+  status: typeof expectStatus;
+  statusOneOf: typeof expectStatusOneOf;
+  value: typeof expectValue;
+}
+
+export interface RuntimeParseNamespace {
+  cookie(response: Pick<RuntimeResponse, "headers">, cookieName: string): string | null;
+  json<T = unknown>(response: Pick<RuntimeResponse, "body">): T;
+  safeJson: typeof safeJson;
+  sse(body: string): Array<{ event: string | null; data: unknown }>;
+  sseEvent<T = unknown>(body: string, eventName: string): T | null;
+}
+
+export interface RuntimeChecksNamespace {
+  authGate: typeof runAuthGateChecks;
+  pagination: typeof runPaginationChecks;
+}
+
+export interface RuntimeNetworkNamespace {
+  deterministicIp(seed: string | number, offset?: number): string;
+}
+
+export declare const expect: RuntimeExpectNamespace;
+export declare const parse: RuntimeParseNamespace;
+export declare const checks: RuntimeChecksNamespace;
+export declare const network: RuntimeNetworkNamespace;
 
 declare global {
   const __ENV: Record<string, string | undefined>;