@velajs/testing 0.2.1 → 0.5.0

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.3.0 (2026-07-04)
+
+- `ComponentManager.init` call removed; provider overrides use the supported `Container.replaceProvider`; registers `DiscoveryService` mirroring bootstrap. Requires `@velajs/vela >=1.11.0`.
+
+
 ## 0.2.1 (2026-05-14)
 
 ### Fixes

package/dist/db/test-database.d.ts

@@ -0,0 +1,27 @@
+/**
+ * TestDatabase
+ *
+ * A minimal driver contract for database assertions in tests. Vela has no ORM
+ * in core, so the harness ships only this interface plus thin assertion
+ * wrappers (`module.assertDatabaseHas/Missing/Count`). A consumer — or a future
+ * `@velajs/crud` driver — provides the concrete implementation; the harness
+ * never couples to a specific database library.
+ *
+ * @example
+ * ```ts
+ * class MyTestDb implements TestDatabase {
+ *   async truncate() { ... }
+ *   async has(table, where) { ... }
+ *   async count(table) { ... }
+ * }
+ * await module.assertDatabaseHas(new MyTestDb(), 'user', { email: 'a@b.com' });
+ * ```
+ */
+export interface TestDatabase {
+    /** Remove all rows from every table (reset between tests). */
+    truncate(): Promise<void>;
+    /** Whether a row matching `where` exists in `table`. */
+    has(table: string, where: Record<string, unknown>): Promise<boolean>;
+    /** The number of rows in `table`. */
+    count(table: string): Promise<number>;
+}

package/dist/db/test-database.js

@@ -0,0 +1,19 @@
+/**
+ * TestDatabase
+ *
+ * A minimal driver contract for database assertions in tests. Vela has no ORM
+ * in core, so the harness ships only this interface plus thin assertion
+ * wrappers (`module.assertDatabaseHas/Missing/Count`). A consumer — or a future
+ * `@velajs/crud` driver — provides the concrete implementation; the harness
+ * never couples to a specific database library.
+ *
+ * @example
+ * ```ts
+ * class MyTestDb implements TestDatabase {
+ *   async truncate() { ... }
+ *   async has(table, where) { ... }
+ *   async count(table) { ... }
+ * }
+ * await module.assertDatabaseHas(new MyTestDb(), 'user', { email: 'a@b.com' });
+ * ```
+ */ export { };

package/dist/http/path-utils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Read the value at a dot-notation path (e.g. `data.user.id`).
+ * Returns `undefined` when any segment along the way is null/undefined.
+ */
+export declare function getValueAtPath(obj: unknown, path: string): unknown;
+/**
+ * Whether a dot-notation path exists on the object, even when the value at the
+ * path is `null`/`undefined`. Distinguishes "key present but null" from "key
+ * absent".
+ */
+export declare function hasValueAtPath(obj: unknown, path: string): boolean;

package/dist/http/path-utils.js

@@ -0,0 +1,37 @@
+// Ported from @stratal/testing (MIT, © Temitayo Fadojutimi).
+/**
+ * Read the value at a dot-notation path (e.g. `data.user.id`).
+ * Returns `undefined` when any segment along the way is null/undefined.
+ */ export function getValueAtPath(obj, path) {
+    const parts = path.split('.');
+    let current = obj;
+    for (const part of parts){
+        if (current === null || current === undefined) {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+/**
+ * Whether a dot-notation path exists on the object, even when the value at the
+ * path is `null`/`undefined`. Distinguishes "key present but null" from "key
+ * absent".
+ */ export function hasValueAtPath(obj, path) {
+    const parts = path.split('.');
+    let current = obj;
+    for (const part of parts){
+        if (current === null || current === undefined) {
+            return false;
+        }
+        if (typeof current !== 'object') {
+            return false;
+        }
+        const record = current;
+        if (!(part in record)) {
+            return false;
+        }
+        current = record[part];
+    }
+    return true;
+}

package/dist/http/test-http-client.d.ts

@@ -0,0 +1,37 @@
+import type { TestingModule } from '../testing-module.js';
+import { TestHttpRequest } from './test-http-request.js';
+/**
+ * TestHttpClient
+ *
+ * Fluent entry point for test HTTP requests. `forHost`/`withHeaders` return a
+ * new immutable client; the verb methods start a {@link TestHttpRequest}.
+ *
+ * @example
+ * ```ts
+ * const res = await module.http
+ *   .forHost('example.com')
+ *   .post('/users')
+ *   .withBody({ name: 'A' })
+ *   .send();
+ * res.assertCreated();
+ * ```
+ */
+export declare class TestHttpClient {
+    private readonly module;
+    private readonly host;
+    private readonly defaultHeaders;
+    constructor(module: TestingModule, host?: string | null, defaultHeaders?: Headers);
+    /**
+     * Return a new client bound to `host`. Also sets the `Host` header so domain
+     * routing works even when the runtime reads the header rather than the URL.
+     */
+    forHost(host: string): TestHttpClient;
+    /** Return a new client with additional default headers on every request. */
+    withHeaders(headers: Record<string, string>): TestHttpClient;
+    get(path: string): TestHttpRequest;
+    post(path: string): TestHttpRequest;
+    put(path: string): TestHttpRequest;
+    patch(path: string): TestHttpRequest;
+    delete(path: string): TestHttpRequest;
+    private createRequest;
+}

package/dist/http/test-http-client.js

@@ -0,0 +1,61 @@
+// Adapted from @stratal/testing (MIT, © Temitayo Fadojutimi). Stratal's i18n
+// `withLocale` is dropped (vela i18n differs — optional follow-up).
+import { TestHttpRequest } from "./test-http-request.js";
+/**
+ * TestHttpClient
+ *
+ * Fluent entry point for test HTTP requests. `forHost`/`withHeaders` return a
+ * new immutable client; the verb methods start a {@link TestHttpRequest}.
+ *
+ * @example
+ * ```ts
+ * const res = await module.http
+ *   .forHost('example.com')
+ *   .post('/users')
+ *   .withBody({ name: 'A' })
+ *   .send();
+ * res.assertCreated();
+ * ```
+ */ export class TestHttpClient {
+    module;
+    host;
+    defaultHeaders;
+    constructor(module, host = null, defaultHeaders = new Headers()){
+        this.module = module;
+        this.host = host;
+        this.defaultHeaders = defaultHeaders;
+    }
+    /**
+   * Return a new client bound to `host`. Also sets the `Host` header so domain
+   * routing works even when the runtime reads the header rather than the URL.
+   */ forHost(host) {
+        const headers = new Headers(this.defaultHeaders);
+        headers.set('Host', host);
+        return new TestHttpClient(this.module, host, headers);
+    }
+    /** Return a new client with additional default headers on every request. */ withHeaders(headers) {
+        const next = new Headers(this.defaultHeaders);
+        for (const [key, value] of Object.entries(headers)){
+            next.set(key, value);
+        }
+        return new TestHttpClient(this.module, this.host, next);
+    }
+    get(path) {
+        return this.createRequest('GET', path);
+    }
+    post(path) {
+        return this.createRequest('POST', path);
+    }
+    put(path) {
+        return this.createRequest('PUT', path);
+    }
+    patch(path) {
+        return this.createRequest('PATCH', path);
+    }
+    delete(path) {
+        return this.createRequest('DELETE', path);
+    }
+    createRequest(method, path) {
+        return new TestHttpRequest(method, path, this.defaultHeaders, this.module, this.host);
+    }
+}

package/dist/http/test-http-request.d.ts

@@ -0,0 +1,46 @@
+import type { ActingAsResolver, TestPrincipal, TestingModule } from '../testing-module.js';
+import { TestResponse } from './test-response.js';
+/**
+ * TestHttpRequest
+ *
+ * Fluent builder for a single test HTTP request. `send()` builds a `Request`
+ * and drives it through `module.fetch()` (the full Hono pipeline).
+ *
+ * @example
+ * ```ts
+ * const res = await module.http
+ *   .post('/users')
+ *   .withBody({ name: 'A' })
+ *   .withHeaders({ 'X-Trace': '1' })
+ *   .send();
+ * res.assertCreated();
+ * ```
+ */
+export declare class TestHttpRequest {
+    private readonly method;
+    private readonly path;
+    private readonly module;
+    private readonly host;
+    private body;
+    private readonly requestHeaders;
+    private principal;
+    private resolver;
+    constructor(method: string, path: string, headers: Headers, module: TestingModule, host?: string | null);
+    /** Set the request body (JSON-serialized on send). */
+    withBody(data: unknown): this;
+    /** Merge additional headers. */
+    withHeaders(headers: Record<string, string>): this;
+    /** Set `Content-Type: application/json`. */
+    asJson(): this;
+    /**
+     * Authenticate the request as `principal`. The `resolver` (or a default one
+     * registered via `module.setAuthResolver`) turns the principal into request
+     * headers. The resolver signature `(module, principal) => Promise<Headers>`
+     * is the cross-package contract sibling packages (e.g. `@velajs/better-auth`)
+     * build against.
+     */
+    actingAs(principal: TestPrincipal, resolver?: ActingAsResolver): this;
+    /** Build the `Request` and send it through `module.fetch()`. */
+    send(): Promise<TestResponse>;
+    private applyAuthentication;
+}

package/dist/http/test-http-request.js

@@ -0,0 +1,87 @@
+// Adapted from @stratal/testing (MIT, © Temitayo Fadojutimi): stratal's hard
+// AuthService import is replaced by a generic auth-resolver seam so
+// @velajs/testing stays free of optional-package dependencies.
+import { TestResponse } from "./test-response.js";
+/**
+ * TestHttpRequest
+ *
+ * Fluent builder for a single test HTTP request. `send()` builds a `Request`
+ * and drives it through `module.fetch()` (the full Hono pipeline).
+ *
+ * @example
+ * ```ts
+ * const res = await module.http
+ *   .post('/users')
+ *   .withBody({ name: 'A' })
+ *   .withHeaders({ 'X-Trace': '1' })
+ *   .send();
+ * res.assertCreated();
+ * ```
+ */ export class TestHttpRequest {
+    method;
+    path;
+    module;
+    host;
+    body = undefined;
+    requestHeaders;
+    principal = null;
+    resolver = null;
+    constructor(method, path, headers, module, host = null){
+        this.method = method;
+        this.path = path;
+        this.module = module;
+        this.host = host;
+        this.requestHeaders = new Headers(headers);
+    }
+    /** Set the request body (JSON-serialized on send). */ withBody(data) {
+        this.body = data;
+        return this;
+    }
+    /** Merge additional headers. */ withHeaders(headers) {
+        for (const [key, value] of Object.entries(headers)){
+            this.requestHeaders.set(key, value);
+        }
+        return this;
+    }
+    /** Set `Content-Type: application/json`. */ asJson() {
+        this.requestHeaders.set('Content-Type', 'application/json');
+        return this;
+    }
+    /**
+   * Authenticate the request as `principal`. The `resolver` (or a default one
+   * registered via `module.setAuthResolver`) turns the principal into request
+   * headers. The resolver signature `(module, principal) => Promise<Headers>`
+   * is the cross-package contract sibling packages (e.g. `@velajs/better-auth`)
+   * build against.
+   */ actingAs(principal, resolver) {
+        this.principal = principal;
+        this.resolver = resolver ?? null;
+        return this;
+    }
+    /** Build the `Request` and send it through `module.fetch()`. */ async send() {
+        await this.applyAuthentication();
+        const hasBody = this.body !== undefined && this.body !== null;
+        if (hasBody && !this.requestHeaders.has('Content-Type')) {
+            this.requestHeaders.set('Content-Type', 'application/json');
+        }
+        const url = new URL(this.path, `http://${this.host ?? 'localhost'}`);
+        const request = new Request(url.toString(), {
+            method: this.method,
+            headers: this.requestHeaders,
+            body: hasBody ? JSON.stringify(this.body) : null
+        });
+        const response = await this.module.fetch(request);
+        return new TestResponse(response);
+    }
+    async applyAuthentication() {
+        if (!this.principal) return;
+        const resolver = this.resolver ?? this.module.getAuthResolver();
+        if (!resolver) {
+            throw new Error('actingAs() requires an auth resolver. Pass one explicitly — ' + 'actingAs(principal, resolver) — or register a default with ' + 'module.setAuthResolver(resolver). For better-auth: ' + 'import { actingAs } from "@velajs/better-auth/testing".');
+        }
+        const headers = await resolver(this.module, this.principal);
+        for (const [key, value] of headers.entries()){
+            this.requestHeaders.set(key, value);
+        }
+    }
+}

package/dist/http/test-response.d.ts

@@ -0,0 +1,76 @@
+/**
+ * TestResponse
+ *
+ * Wraps a `Response` with fluent, chainable assertions. Synchronous status /
+ * header assertions return `this`; JSON assertions (which must read the body)
+ * return `Promise<this>`.
+ *
+ * @example
+ * ```ts
+ * const res = await module.http.get('/users/1').send();
+ * res.assertOk();
+ * await res.assertJsonPath('data.id', 1);
+ * ```
+ */
+export declare class TestResponse {
+    private readonly response;
+    private jsonData;
+    private textData;
+    constructor(response: Response);
+    /** The raw `Response`. */
+    get raw(): Response;
+    /** The response status code. */
+    get status(): number;
+    /** The response headers. */
+    get headers(): Headers;
+    /** Parse (and cache) the response body as JSON. */
+    json<T = unknown>(): Promise<T>;
+    /** Read (and cache) the response body as text. */
+    text(): Promise<string>;
+    /** Assert status is 200 OK. */
+    assertOk(): this;
+    /** Assert status is 201 Created. */
+    assertCreated(): this;
+    /** Assert status is 204 No Content. */
+    assertNoContent(): this;
+    /** Assert status is 400 Bad Request. */
+    assertBadRequest(): this;
+    /** Assert status is 401 Unauthorized. */
+    assertUnauthorized(): this;
+    /** Assert status is 403 Forbidden. */
+    assertForbidden(): this;
+    /** Assert status is 404 Not Found. */
+    assertNotFound(): this;
+    /** Assert status is 422 Unprocessable Entity. */
+    assertUnprocessable(): this;
+    /** Assert status is 500 Internal Server Error. */
+    assertServerError(): this;
+    /** Assert the response has the given status code. */
+    assertStatus(expected: number): this;
+    /** Assert the status is in the 2xx range. */
+    assertSuccessful(): this;
+    /** Assert each key in `expected` equals the corresponding top-level value. */
+    assertJson(expected: Record<string, unknown>): Promise<this>;
+    /** Assert the value at a dot-notation path equals `expected`. */
+    assertJsonPath(path: string, expected: unknown): Promise<this>;
+    /** Assert every path/value pair in `expectations` matches (batch assert). */
+    assertJsonPaths(expectations: Record<string, unknown>): Promise<this>;
+    /** Assert the top-level JSON object has every key in `structure`. */
+    assertJsonStructure(structure: string[]): Promise<this>;
+    /** Assert a path exists (value may be anything, including `null`). */
+    assertJsonPathExists(path: string): Promise<this>;
+    /** Assert a path does not exist. */
+    assertJsonPathMissing(path: string): Promise<this>;
+    /** Assert the value at a path satisfies a predicate. */
+    assertJsonPathMatches(path: string, matcher: (value: unknown) => boolean): Promise<this>;
+    /** Assert the string value at a path contains `substring`. */
+    assertJsonPathContains(path: string, substring: string): Promise<this>;
+    /** Assert the array value at a path includes `item`. */
+    assertJsonPathIncludes(path: string, item: unknown): Promise<this>;
+    /** Assert the array value at a path has `count` items. */
+    assertJsonPathCount(path: string, count: number): Promise<this>;
+    /** Assert a header is present, optionally equal to `expected`. */
+    assertHeader(name: string, expected?: string): this;
+    /** Assert a header is absent. */
+    assertHeaderMissing(name: string): this;
+}

package/dist/http/test-response.js

@@ -0,0 +1,166 @@
+// Ported from @stratal/testing (MIT, © Temitayo Fadojutimi), minus Macroable —
+// vela has no Macroable, so TestResponse is a plain class.
+import { expect } from "vitest";
+import { getValueAtPath, hasValueAtPath } from "./path-utils.js";
+/**
+ * TestResponse
+ *
+ * Wraps a `Response` with fluent, chainable assertions. Synchronous status /
+ * header assertions return `this`; JSON assertions (which must read the body)
+ * return `Promise<this>`.
+ *
+ * @example
+ * ```ts
+ * const res = await module.http.get('/users/1').send();
+ * res.assertOk();
+ * await res.assertJsonPath('data.id', 1);
+ * ```
+ */ export class TestResponse {
+    response;
+    jsonData = null;
+    textData = null;
+    constructor(response){
+        this.response = response;
+    }
+    /** The raw `Response`. */ get raw() {
+        return this.response;
+    }
+    /** The response status code. */ get status() {
+        return this.response.status;
+    }
+    /** The response headers. */ get headers() {
+        return this.response.headers;
+    }
+    /** Parse (and cache) the response body as JSON. */ async json() {
+        if (this.jsonData === null) {
+            this.jsonData = await this.response.clone().json();
+        }
+        return this.jsonData;
+    }
+    /** Read (and cache) the response body as text. */ async text() {
+        this.textData ??= await this.response.clone().text();
+        return this.textData;
+    }
+    // ============================================================
+    // Status assertions
+    // ============================================================
+    /** Assert status is 200 OK. */ assertOk() {
+        return this.assertStatus(200);
+    }
+    /** Assert status is 201 Created. */ assertCreated() {
+        return this.assertStatus(201);
+    }
+    /** Assert status is 204 No Content. */ assertNoContent() {
+        return this.assertStatus(204);
+    }
+    /** Assert status is 400 Bad Request. */ assertBadRequest() {
+        return this.assertStatus(400);
+    }
+    /** Assert status is 401 Unauthorized. */ assertUnauthorized() {
+        return this.assertStatus(401);
+    }
+    /** Assert status is 403 Forbidden. */ assertForbidden() {
+        return this.assertStatus(403);
+    }
+    /** Assert status is 404 Not Found. */ assertNotFound() {
+        return this.assertStatus(404);
+    }
+    /** Assert status is 422 Unprocessable Entity. */ assertUnprocessable() {
+        return this.assertStatus(422);
+    }
+    /** Assert status is 500 Internal Server Error. */ assertServerError() {
+        return this.assertStatus(500);
+    }
+    /** Assert the response has the given status code. */ assertStatus(expected) {
+        expect(this.response.status, `Expected status ${expected}, got ${this.response.status}`).toBe(expected);
+        return this;
+    }
+    /** Assert the status is in the 2xx range. */ assertSuccessful() {
+        expect(this.response.status >= 200 && this.response.status < 300, `Expected successful status (2xx), got ${this.response.status}`).toBe(true);
+        return this;
+    }
+    // ============================================================
+    // JSON assertions
+    // ============================================================
+    /** Assert each key in `expected` equals the corresponding top-level value. */ async assertJson(expected) {
+        const actual = await this.json();
+        for (const [key, value] of Object.entries(expected)){
+            expect(actual[key], `Expected JSON key "${key}" to be ${JSON.stringify(value)}, got ${JSON.stringify(actual[key])}`).toStrictEqual(value);
+        }
+        return this;
+    }
+    /** Assert the value at a dot-notation path equals `expected`. */ async assertJsonPath(path, expected) {
+        const json = await this.json();
+        const actual = getValueAtPath(json, path);
+        expect(actual, `Expected JSON path "${path}" to be ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`).toStrictEqual(expected);
+        return this;
+    }
+    /** Assert every path/value pair in `expectations` matches (batch assert). */ async assertJsonPaths(expectations) {
+        const json = await this.json();
+        for (const [path, expected] of Object.entries(expectations)){
+            const actual = getValueAtPath(json, path);
+            expect(actual, `Expected JSON path "${path}" to be ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`).toStrictEqual(expected);
+        }
+        return this;
+    }
+    /** Assert the top-level JSON object has every key in `structure`. */ async assertJsonStructure(structure) {
+        const json = await this.json();
+        for (const key of structure){
+            expect(key in json, `Expected JSON to have key "${key}", got keys: ${JSON.stringify(Object.keys(json))}`).toBe(true);
+        }
+        return this;
+    }
+    /** Assert a path exists (value may be anything, including `null`). */ async assertJsonPathExists(path) {
+        const json = await this.json();
+        expect(hasValueAtPath(json, path), `Expected JSON path "${path}" to exist`).toBe(true);
+        return this;
+    }
+    /** Assert a path does not exist. */ async assertJsonPathMissing(path) {
+        const json = await this.json();
+        expect(hasValueAtPath(json, path), `Expected JSON path "${path}" to not exist`).toBe(false);
+        return this;
+    }
+    /** Assert the value at a path satisfies a predicate. */ async assertJsonPathMatches(path, matcher) {
+        const json = await this.json();
+        const value = getValueAtPath(json, path);
+        expect(matcher(value), `Expected JSON path "${path}" to match predicate, got ${JSON.stringify(value)}`).toBe(true);
+        return this;
+    }
+    /** Assert the string value at a path contains `substring`. */ async assertJsonPathContains(path, substring) {
+        const json = await this.json();
+        const value = getValueAtPath(json, path);
+        expect(typeof value === 'string', `Expected JSON path "${path}" to be a string, got ${typeof value}`).toBe(true);
+        expect(value.includes(substring), `Expected JSON path "${path}" to contain "${substring}", got "${String(value)}"`).toBe(true);
+        return this;
+    }
+    /** Assert the array value at a path includes `item`. */ async assertJsonPathIncludes(path, item) {
+        const json = await this.json();
+        const value = getValueAtPath(json, path);
+        expect(Array.isArray(value), `Expected JSON path "${path}" to be an array, got ${typeof value}`).toBe(true);
+        expect(value.includes(item), `Expected JSON path "${path}" to include ${JSON.stringify(item)}`).toBe(true);
+        return this;
+    }
+    /** Assert the array value at a path has `count` items. */ async assertJsonPathCount(path, count) {
+        const json = await this.json();
+        const value = getValueAtPath(json, path);
+        expect(Array.isArray(value), `Expected JSON path "${path}" to be an array, got ${typeof value}`).toBe(true);
+        expect(value.length, `Expected JSON path "${path}" to have ${count} items, got ${value.length}`).toBe(count);
+        return this;
+    }
+    // ============================================================
+    // Header assertions
+    // ============================================================
+    /** Assert a header is present, optionally equal to `expected`. */ assertHeader(name, expected) {
+        const actual = this.response.headers.get(name);
+        expect(actual !== null, `Expected header "${name}" to be present`).toBe(true);
+        if (expected !== undefined) {
+            expect(actual, `Expected header "${name}" to be "${expected}", got "${actual}"`).toBe(expected);
+        }
+        return this;
+    }
+    /** Assert a header is absent. */ assertHeaderMissing(name) {
+        const actual = this.response.headers.get(name);
+        expect(actual, `Expected header "${name}" to be absent, but got "${actual}"`).toBeNull();
+        return this;
+    }
+}

package/dist/index.d.ts

@@ -1,3 +1,15 @@
 export { Test } from './test.js';
 export { TestingModule } from './testing-module.js';
+export type { ActingAsResolver, TestPrincipal } from './testing-module.js';
 export { TestingModuleBuilder, OverrideBy } from './testing-module.builder.js';
+export { TestHttpClient } from './http/test-http-client.js';
+export { TestHttpRequest } from './http/test-http-request.js';
+export { TestResponse } from './http/test-response.js';
+export { getValueAtPath, hasValueAtPath } from './http/path-utils.js';
+export { TestSseConnection } from './sse/test-sse-connection.js';
+export type { TestSseEvent } from './sse/test-sse-connection.js';
+export { TestSseRequest } from './sse/test-sse-request.js';
+export { TestWsConnection } from './ws/test-ws-connection.js';
+export { TestWsRequest, registerWsConnector, getWsConnector } from './ws/test-ws-request.js';
+export type { WsConnector } from './ws/test-ws-request.js';
+export type { TestDatabase } from './db/test-database.js';

package/dist/index.js

@@ -1,3 +1,14 @@
 export { Test } from "./test.js";
 export { TestingModule } from "./testing-module.js";
 export { TestingModuleBuilder, OverrideBy } from "./testing-module.builder.js";
+// HTTP
+export { TestHttpClient } from "./http/test-http-client.js";
+export { TestHttpRequest } from "./http/test-http-request.js";
+export { TestResponse } from "./http/test-response.js";
+export { getValueAtPath, hasValueAtPath } from "./http/path-utils.js";
+// SSE
+export { TestSseConnection } from "./sse/test-sse-connection.js";
+export { TestSseRequest } from "./sse/test-sse-request.js";
+// WebSocket (generic wrapper + pluggable transport seam)
+export { TestWsConnection } from "./ws/test-ws-connection.js";
+export { TestWsRequest, registerWsConnector, getWsConnector } from "./ws/test-ws-request.js";

package/dist/sse/test-sse-connection.d.ts

@@ -0,0 +1,46 @@
+/** A parsed Server-Sent Event. */
+export interface TestSseEvent {
+    data: string;
+    event?: string;
+    id?: string;
+    retry?: number;
+}
+/**
+ * TestSseConnection
+ *
+ * Reads a streaming `text/event-stream` response body and exposes queue-based
+ * wait/assert helpers over the parsed events.
+ *
+ * @example
+ * ```ts
+ * const sse = await module.sse('/stream/events').connect();
+ * await sse.assertEventData('ping');
+ * await sse.waitForEnd();
+ * ```
+ */
+export declare class TestSseConnection {
+    private readonly response;
+    private readonly eventQueue;
+    private eventWaiters;
+    private streamEnded;
+    private endWaiters;
+    constructor(response: Response);
+    /** The raw `Response`. */
+    get raw(): Response;
+    /** Wait for the next event (rejects after `timeout` ms). */
+    waitForEvent(timeout?: number): Promise<TestSseEvent>;
+    /** Wait for the stream to end (rejects after `timeout` ms). */
+    waitForEnd(timeout?: number): Promise<void>;
+    /** Collect all remaining events until the stream ends. */
+    collectEvents(timeout?: number): Promise<TestSseEvent[]>;
+    /** Assert the next event matches the expected partial shape. */
+    assertEvent(expected: Partial<TestSseEvent>, timeout?: number): Promise<void>;
+    /** Assert the next event's `data` equals `expected`. */
+    assertEventData(expected: string, timeout?: number): Promise<void>;
+    /** Assert the next event's `data` is JSON equal to `expected`. */
+    assertJsonEventData<T>(expected: T, timeout?: number): Promise<void>;
+    private startReading;
+    private endStream;
+    private parseEvent;
+    private dispatchEvent;
+}