@pellux/goodvibes-transport-http 0.18.3

package/README.md

@@ -0,0 +1,18 @@
+# @pellux/goodvibes-transport-http
+
+HTTP, JSON, path, and SSE helpers for GoodVibes SDK clients.
+
+Install:
+
+```bash
+npm install @pellux/goodvibes-transport-http
+```
+
+Exports include:
+- contract route invocation helpers
+- HTTP transport creation
+- header and auth token resolution helpers
+- retry/backoff helpers
+- SSE streaming helpers
+
+Use this package when you need lower-level HTTP/SSE control or when you are building a custom GoodVibes client on top of the synced contracts.

package/dist/auth.d.ts

@@ -0,0 +1,7 @@
+export type MaybePromise<T> = T | Promise<T>;
+export type AuthTokenResolver = () => MaybePromise<string | null | undefined>;
+export type HeaderResolver = () => MaybePromise<HeadersInit | undefined>;
+export declare function mergeHeaders(...sources: Array<HeadersInit | undefined>): Headers;
+export declare function resolveAuthToken(authToken: string | null | undefined, getAuthToken?: AuthTokenResolver): Promise<string | null>;
+export declare function resolveHeaders(headers: HeadersInit | undefined, getHeaders?: HeaderResolver): Promise<Headers>;
+//# sourceMappingURL=auth.d.ts.map

package/dist/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../src/auth.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAE7C,MAAM,MAAM,iBAAiB,GAAG,MAAM,YAAY,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC;AAE9E,MAAM,MAAM,cAAc,GAAG,MAAM,YAAY,CAAC,WAAW,GAAG,SAAS,CAAC,CAAC;AAuBzE,wBAAgB,YAAY,CAAC,GAAG,OAAO,EAAE,KAAK,CAAC,WAAW,GAAG,SAAS,CAAC,GAAG,OAAO,CAMhF;AAED,wBAAsB,gBAAgB,CACpC,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACpC,YAAY,CAAC,EAAE,iBAAiB,GAC/B,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAMxB;AAED,wBAAsB,cAAc,CAClC,OAAO,EAAE,WAAW,GAAG,SAAS,EAChC,UAAU,CAAC,EAAE,cAAc,GAC1B,OAAO,CAAC,OAAO,CAAC,CAGlB"}

package/dist/auth.js

@@ -0,0 +1,39 @@
+function appendHeaders(target, headers) {
+    if (!headers)
+        return;
+    if (headers instanceof Headers) {
+        headers.forEach((value, key) => {
+            target.set(key, value);
+        });
+        return;
+    }
+    if (Array.isArray(headers)) {
+        for (const [key, value] of headers) {
+            target.set(key, value);
+        }
+        return;
+    }
+    for (const [key, value] of Object.entries(headers)) {
+        if (value !== undefined) {
+            target.set(key, value);
+        }
+    }
+}
+export function mergeHeaders(...sources) {
+    const headers = new Headers();
+    for (const source of sources) {
+        appendHeaders(headers, source);
+    }
+    return headers;
+}
+export async function resolveAuthToken(authToken, getAuthToken) {
+    if (getAuthToken) {
+        const resolved = await getAuthToken();
+        return resolved ?? null;
+    }
+    return authToken ?? null;
+}
+export async function resolveHeaders(headers, getHeaders) {
+    const resolved = getHeaders ? await getHeaders() : undefined;
+    return mergeHeaders(headers, resolved);
+}

package/dist/backoff.d.ts

@@ -0,0 +1,16 @@
+export interface BackoffPolicy {
+    readonly maxAttempts?: number;
+    readonly baseDelayMs?: number;
+    readonly maxDelayMs?: number;
+    readonly backoffFactor?: number;
+}
+export interface ResolvedBackoffPolicy {
+    readonly maxAttempts: number;
+    readonly baseDelayMs: number;
+    readonly maxDelayMs: number;
+    readonly backoffFactor: number;
+}
+export declare function normalizeBackoffPolicy(policy: BackoffPolicy | undefined, defaults: ResolvedBackoffPolicy): ResolvedBackoffPolicy;
+export declare function computeBackoffDelay(attempt: number, policy: ResolvedBackoffPolicy): number;
+export declare function sleepWithSignal(delayMs: number, signal?: AbortSignal): Promise<void>;
+//# sourceMappingURL=backoff.d.ts.map

package/dist/backoff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backoff.d.ts","sourceRoot":"","sources":["../src/backoff.ts"],"names":[],"mappings":"AACA,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;CACjC;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,aAAa,GAAG,SAAS,EACjC,QAAQ,EAAE,qBAAqB,GAC9B,qBAAqB,CAOvB;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,qBAAqB,GAC5B,MAAM,CAKR;AAED,wBAAsB,eAAe,CACnC,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,IAAI,CAAC,CAoBf"}

package/dist/backoff.js

@@ -0,0 +1,37 @@
+export function normalizeBackoffPolicy(policy, defaults) {
+    return {
+        maxAttempts: Math.max(1, Math.floor(policy?.maxAttempts ?? defaults.maxAttempts)),
+        baseDelayMs: Math.max(0, Math.floor(policy?.baseDelayMs ?? defaults.baseDelayMs)),
+        maxDelayMs: Math.max(0, Math.floor(policy?.maxDelayMs ?? defaults.maxDelayMs)),
+        backoffFactor: Math.max(1, policy?.backoffFactor ?? defaults.backoffFactor),
+    };
+}
+export function computeBackoffDelay(attempt, policy) {
+    if (attempt <= 1)
+        return 0;
+    const exponent = Math.max(0, attempt - 2);
+    const delay = policy.baseDelayMs * (policy.backoffFactor ** exponent);
+    return Math.min(policy.maxDelayMs, Math.max(0, Math.floor(delay)));
+}
+export async function sleepWithSignal(delayMs, signal) {
+    if (delayMs <= 0)
+        return;
+    if (signal?.aborted) {
+        throw new DOMException('The operation was aborted.', 'AbortError');
+    }
+    await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            cleanup();
+            resolve();
+        }, delayMs);
+        const onAbort = () => {
+            clearTimeout(timer);
+            cleanup();
+            reject(new DOMException('The operation was aborted.', 'AbortError'));
+        };
+        const cleanup = () => {
+            signal?.removeEventListener('abort', onAbort);
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}

package/dist/contract-client.d.ts

@@ -0,0 +1,21 @@
+import type { HttpTransport } from './http.js';
+import { type ServerSentEventHandlers } from './sse-stream.js';
+export interface ContractRouteDefinition {
+    readonly method: string;
+    readonly path: string;
+}
+export interface ContractRouteLike {
+    readonly id: string;
+}
+export interface ContractInvokeOptions {
+    readonly signal?: AbortSignal;
+    readonly headers?: HeadersInit;
+}
+export interface ContractStreamOptions extends ContractInvokeOptions {
+    readonly handlers: ServerSentEventHandlers;
+}
+export declare function buildContractInput(primaryKey: string, primaryValue: string, input?: Record<string, unknown>): Record<string, unknown>;
+export declare function requireContractRoute<TRoute extends ContractRouteLike>(routes: readonly TRoute[], routeId: string, kind: string): TRoute;
+export declare function invokeContractRoute<T = unknown>(transport: HttpTransport, route: ContractRouteDefinition, input?: Record<string, unknown>, options?: ContractInvokeOptions): Promise<T>;
+export declare function openContractRouteStream(transport: HttpTransport, route: ContractRouteDefinition, input: Record<string, unknown> | undefined, options: ContractStreamOptions): Promise<() => void>;
+//# sourceMappingURL=contract-client.d.ts.map

package/dist/contract-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-client.d.ts","sourceRoot":"","sources":["../src/contract-client.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAA6B,KAAK,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAE1F,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAC9B,QAAQ,CAAC,OAAO,CAAC,EAAE,WAAW,CAAC;CAChC;AAED,MAAM,WAAW,qBAAsB,SAAQ,qBAAqB;IAClE,QAAQ,CAAC,QAAQ,EAAE,uBAAuB,CAAC;CAC5C;AAED,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAKzB;AAED,wBAAgB,oBAAoB,CAAC,MAAM,SAAS,iBAAiB,EACnE,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,GACX,MAAM,CAMR;AAED,wBAAgB,mBAAmB,CAAC,CAAC,GAAG,OAAO,EAC7C,SAAS,EAAE,aAAa,EACxB,KAAK,EAAE,uBAAuB,EAC9B,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAAC,CAAC,CAAC,CAQZ;AAED,wBAAsB,uBAAuB,CAC3C,SAAS,EAAE,aAAa,EACxB,KAAK,EAAE,uBAAuB,EAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC1C,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,MAAM,IAAI,CAAC,CAYrB"}

package/dist/contract-client.js

@@ -0,0 +1,31 @@
+import { openServerSentEventStream } from './sse-stream.js';
+export function buildContractInput(primaryKey, primaryValue, input) {
+    return {
+        [primaryKey]: primaryValue,
+        ...(input ?? {}),
+    };
+}
+export function requireContractRoute(routes, routeId, kind) {
+    const route = routes.find((candidate) => candidate.id === routeId);
+    if (!route) {
+        throw new Error(`Unknown ${kind} "${routeId}"`);
+    }
+    return route;
+}
+export function invokeContractRoute(transport, route, input, options = {}) {
+    const resolved = transport.resolveContractRequest(route.method, route.path, input);
+    return transport.requestJson(resolved.url, {
+        method: resolved.method,
+        body: resolved.body,
+        headers: options.headers,
+        signal: options.signal,
+    });
+}
+export async function openContractRouteStream(transport, route, input, options) {
+    const resolved = transport.resolveContractRequest(route.method, route.path, input);
+    return await openServerSentEventStream(transport.fetchImpl, resolved.url, options.handlers, {
+        authToken: transport.authToken,
+        headers: options.headers,
+        signal: options.signal,
+    });
+}

package/dist/http-core.d.ts

@@ -0,0 +1,55 @@
+import { type AuthTokenResolver, type HeaderResolver } from './auth.js';
+import { type HttpRetryPolicy } from './retry.js';
+import { type TransportPaths } from './paths.js';
+export type { HttpRetryPolicy } from './retry.js';
+export type JsonValue = string | number | boolean | null | {
+    readonly [key: string]: JsonValue;
+} | readonly JsonValue[];
+export type JsonObject = {
+    readonly [key: string]: JsonValue;
+};
+export interface HttpJsonTransportOptions {
+    readonly baseUrl: string;
+    readonly authToken?: string | null;
+    readonly getAuthToken?: AuthTokenResolver;
+    readonly fetch?: typeof fetch;
+    readonly fetchImpl?: typeof fetch;
+    readonly headers?: HeadersInit;
+    readonly getHeaders?: HeaderResolver;
+    readonly retry?: HttpRetryPolicy;
+}
+export interface HttpJsonRequestOptions {
+    readonly method?: string;
+    readonly body?: unknown;
+    readonly headers?: HeadersInit;
+    readonly signal?: AbortSignal;
+    readonly retry?: false | HttpRetryPolicy;
+}
+export interface ResolvedContractRequest {
+    readonly url: string;
+    readonly method: string;
+    readonly body?: Record<string, unknown>;
+}
+export interface TransportJsonError {
+    readonly status: number;
+    readonly body: unknown;
+    readonly url: string;
+    readonly method: string;
+}
+export interface HttpJsonTransport {
+    readonly baseUrl: string;
+    readonly authToken?: string | null;
+    readonly fetchImpl: typeof fetch;
+    readonly paths: TransportPaths;
+    buildUrl(path: string): string;
+    getAuthToken(): Promise<string | null>;
+    requestJson<T>(pathOrUrl: string, options?: HttpJsonRequestOptions): Promise<T>;
+    resolveContractRequest(method: string, path: string, input?: Record<string, unknown>): ResolvedContractRequest;
+}
+export declare function createJsonRequestInit(token: string | null | undefined, body?: unknown, method?: string, headers?: HeadersInit, signal?: AbortSignal, defaultHeaders?: HeadersInit): RequestInit;
+export declare const createJsonInit: typeof createJsonRequestInit;
+export declare function createFetch(fetchImpl?: typeof fetch, fallbackFetch?: typeof fetch): typeof fetch;
+export declare function readJsonBody(response: Response): Promise<unknown>;
+export declare function requestJson<T>(fetchImpl: typeof fetch, url: string, init?: RequestInit): Promise<T>;
+export declare function createHttpJsonTransport(options: HttpJsonTransportOptions): HttpJsonTransport;
+//# sourceMappingURL=http-core.d.ts.map

package/dist/http-core.d.ts.map

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

package/dist/http-core.js

@@ -0,0 +1,217 @@
+// Synced from goodvibes-tui/src/runtime/transports/http-json-transport.ts
+import { sleepWithSignal } from './backoff.js';
+import { mergeHeaders, resolveAuthToken, resolveHeaders } from './auth.js';
+import { getHttpRetryDelay, isRetryableHttpStatus, isRetryableNetworkError, resolveHttpRetryPolicy, } from './retry.js';
+import { buildUrl, createTransportPaths } from './paths.js';
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function applyHeaderSource(target, source) {
+    if (!source)
+        return;
+    if (source instanceof Headers) {
+        source.forEach((value, key) => {
+            target[key] = value;
+        });
+        return;
+    }
+    if (Array.isArray(source)) {
+        for (const [key, value] of source) {
+            target[key] = value;
+        }
+        return;
+    }
+    for (const [key, value] of Object.entries(source)) {
+        if (value !== undefined) {
+            target[key] = value;
+        }
+    }
+}
+function mergeHeaderRecord(...sources) {
+    const merged = {};
+    for (const source of sources) {
+        applyHeaderSource(merged, source);
+    }
+    return merged;
+}
+function readErrorMessage(status, url, body) {
+    if (isRecord(body) && typeof body.error === 'string' && body.error.trim()) {
+        return body.error.trim();
+    }
+    if (typeof body === 'string' && body.trim()) {
+        return body.trim();
+    }
+    return `Transport request failed with status ${status} for ${url}`;
+}
+function createTransportError(status, url, method, body) {
+    return Object.assign(new Error(readErrorMessage(status, url, body)), {
+        transport: {
+            status,
+            body,
+            url,
+            method,
+        },
+    });
+}
+function createNetworkTransportError(error, url, method) {
+    const message = error instanceof Error && error.message.trim()
+        ? error.message.trim()
+        : `Transport request failed before receiving a response for ${url}`;
+    return Object.assign(new Error(message), {
+        cause: error,
+        transport: {
+            status: 0,
+            body: { error: message },
+            url,
+            method,
+        },
+    });
+}
+function toStringValue(value, key) {
+    if (value === undefined || value === null) {
+        throw new Error(`Missing required path parameter "${key}"`);
+    }
+    return String(value);
+}
+function addQueryValue(url, key, value) {
+    if (value === undefined)
+        return;
+    if (value === null) {
+        url.searchParams.append(key, 'null');
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            addQueryValue(url, key, item);
+        }
+        return;
+    }
+    if (typeof value === 'object') {
+        url.searchParams.append(key, JSON.stringify(value));
+        return;
+    }
+    url.searchParams.append(key, String(value));
+}
+function splitContractInput(path, input = {}) {
+    const remaining = { ...input };
+    const interpolatedPath = path.replace(/\{([^}]+)\}/g, (_match, key) => {
+        const value = toStringValue(remaining[key], key);
+        delete remaining[key];
+        return encodeURIComponent(value);
+    });
+    return { interpolatedPath, remaining };
+}
+export function createJsonRequestInit(token, body, method = 'GET', headers = {}, signal, defaultHeaders = {}) {
+    return {
+        method,
+        credentials: 'include',
+        signal,
+        headers: mergeHeaderRecord(defaultHeaders, token ? { Authorization: `Bearer ${token}` } : undefined, body !== undefined ? { 'Content-Type': 'application/json' } : undefined, headers),
+        ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
+    };
+}
+export const createJsonInit = createJsonRequestInit;
+export function createFetch(fetchImpl, fallbackFetch) {
+    const resolved = fetchImpl ?? fallbackFetch ?? globalThis.fetch;
+    if (typeof resolved !== 'function') {
+        throw new Error('Fetch implementation is required');
+    }
+    return resolved.bind(globalThis);
+}
+export async function readJsonBody(response) {
+    const text = await response.text();
+    if (!text.trim())
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+export async function requestJson(fetchImpl, url, init = {}) {
+    let response;
+    try {
+        response = await fetchImpl(url, init);
+    }
+    catch (error) {
+        throw createNetworkTransportError(error, url, init.method ?? 'GET');
+    }
+    const body = await readJsonBody(response);
+    if (!response.ok) {
+        throw createTransportError(response.status, url, init.method ?? 'GET', body);
+    }
+    return body;
+}
+export function createHttpJsonTransport(options) {
+    const baseUrl = options.baseUrl.trim();
+    const fetchImpl = createFetch(options.fetchImpl, options.fetch);
+    const authToken = options.authToken ?? null;
+    const defaultHeaders = options.headers;
+    const retryPolicy = options.retry;
+    const paths = createTransportPaths(baseUrl);
+    const requestJsonForTransport = async (pathOrUrl, requestOptions = {}) => {
+        const url = pathOrUrl.startsWith('http://') || pathOrUrl.startsWith('https://')
+            ? pathOrUrl
+            : buildUrl(baseUrl, pathOrUrl);
+        const method = requestOptions.method ?? (requestOptions.body === undefined ? 'GET' : 'POST');
+        const resolvedRetry = resolveHttpRetryPolicy(retryPolicy, requestOptions.retry);
+        let attempt = 0;
+        while (true) {
+            attempt += 1;
+            const token = await resolveAuthToken(authToken, options.getAuthToken);
+            const headers = await resolveHeaders(defaultHeaders, options.getHeaders);
+            try {
+                return await requestJson(fetchImpl, url, createJsonRequestInit(token, requestOptions.body, method, mergeHeaders(headers, requestOptions.headers), requestOptions.signal));
+            }
+            catch (error) {
+                const status = typeof error === 'object' && error !== null && 'transport' in error
+                    ? error.transport?.status
+                    : undefined;
+                const shouldRetry = attempt < resolvedRetry.maxAttempts && ((typeof status === 'number' && status > 0 && isRetryableHttpStatus(method, status, resolvedRetry))
+                    || (typeof status === 'number' && status === 0 && isRetryableNetworkError(method, resolvedRetry)));
+                if (!shouldRetry) {
+                    throw error;
+                }
+                await sleepWithSignal(getHttpRetryDelay(attempt + 1, resolvedRetry), requestOptions.signal);
+            }
+        }
+    };
+    const resolveContractRequest = (method, path, input = {}) => {
+        const { interpolatedPath, remaining } = splitContractInput(path, input);
+        const upperMethod = method.toUpperCase();
+        const url = new URL(buildUrl(baseUrl, interpolatedPath));
+        if (upperMethod === 'GET' || upperMethod === 'HEAD') {
+            for (const [key, value] of Object.entries(remaining)) {
+                addQueryValue(url, key, value);
+            }
+            return {
+                url: url.toString(),
+                method: upperMethod,
+            };
+        }
+        const body = isPlainObject(remaining) && Object.keys(remaining).length > 0 ? remaining : undefined;
+        return {
+            url: url.toString(),
+            method: upperMethod,
+            ...(body ? { body } : {}),
+        };
+    };
+    return {
+        baseUrl: paths.baseUrl,
+        authToken,
+        fetchImpl,
+        paths,
+        buildUrl(path) {
+            return buildUrl(baseUrl, path);
+        },
+        async getAuthToken() {
+            return await resolveAuthToken(authToken, options.getAuthToken);
+        },
+        requestJson: requestJsonForTransport,
+        resolveContractRequest,
+    };
+}

package/dist/http.d.ts

@@ -0,0 +1,12 @@
+import { type AuthTokenResolver, type HeaderResolver, type MaybePromise, mergeHeaders, resolveAuthToken, resolveHeaders } from './auth.js';
+import { type BackoffPolicy, type ResolvedBackoffPolicy, computeBackoffDelay, normalizeBackoffPolicy, sleepWithSignal } from './backoff.js';
+import { type HttpRetryPolicy, type ResolvedHttpRetryPolicy, DEFAULT_HTTP_RETRY_POLICY, getHttpRetryDelay, isRetryableHttpStatus, isRetryableNetworkError, normalizeHttpRetryPolicy, resolveHttpRetryPolicy } from './retry.js';
+import { type ResolvedStreamReconnectPolicy, type StreamReconnectPolicy, DEFAULT_STREAM_RECONNECT_POLICY, getStreamReconnectDelay, normalizeStreamReconnectPolicy } from './reconnect.js';
+import { createFetch, createJsonInit, createJsonRequestInit, readJsonBody, type HttpJsonRequestOptions, type HttpJsonTransport, type HttpJsonTransportOptions, type JsonObject, type JsonValue, type ResolvedContractRequest } from './http-core.js';
+export type { AuthTokenResolver, BackoffPolicy, HeaderResolver, HttpJsonRequestOptions, HttpRetryPolicy, JsonObject, JsonValue, MaybePromise, ResolvedBackoffPolicy, ResolvedContractRequest, ResolvedHttpRetryPolicy, ResolvedStreamReconnectPolicy, StreamReconnectPolicy, };
+export type HttpTransportOptions = HttpJsonTransportOptions;
+export type HttpTransport = HttpJsonTransport;
+export { createFetch, createJsonInit, createJsonRequestInit, readJsonBody, mergeHeaders, resolveAuthToken, resolveHeaders, computeBackoffDelay, normalizeBackoffPolicy, sleepWithSignal, DEFAULT_HTTP_RETRY_POLICY, getHttpRetryDelay, isRetryableHttpStatus, isRetryableNetworkError, normalizeHttpRetryPolicy, resolveHttpRetryPolicy, DEFAULT_STREAM_RECONNECT_POLICY, getStreamReconnectDelay, normalizeStreamReconnectPolicy, };
+export declare function normalizeTransportError(error: unknown): Error;
+export declare function createHttpTransport(options: HttpTransportOptions): HttpTransport;
+//# sourceMappingURL=http.d.ts.map

package/dist/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../src/http.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,YAAY,EACZ,gBAAgB,EAChB,cAAc,EACf,MAAM,WAAW,CAAC;AACnB,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,qBAAqB,EAC1B,mBAAmB,EACnB,sBAAsB,EACtB,eAAe,EAChB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAC5B,yBAAyB,EACzB,iBAAiB,EACjB,qBAAqB,EACrB,uBAAuB,EACvB,wBAAwB,EACxB,sBAAsB,EACvB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,KAAK,6BAA6B,EAClC,KAAK,qBAAqB,EAC1B,+BAA+B,EAC/B,uBAAuB,EACvB,8BAA8B,EAC/B,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,WAAW,EAEX,cAAc,EACd,qBAAqB,EACrB,YAAY,EACZ,KAAK,sBAAsB,EAC3B,KAAK,iBAAiB,EACtB,KAAK,wBAAwB,EAC7B,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,uBAAuB,EAC7B,MAAM,gBAAgB,CAAC;AAExB,YAAY,EACV,iBAAiB,EACjB,aAAa,EACb,cAAc,EACd,sBAAsB,EACtB,eAAe,EACf,UAAU,EACV,SAAS,EACT,YAAY,EACZ,qBAAqB,EACrB,uBAAuB,EACvB,uBAAuB,EACvB,6BAA6B,EAC7B,qBAAqB,GACtB,CAAC;AACF,MAAM,MAAM,oBAAoB,GAAG,wBAAwB,CAAC;AAC5D,MAAM,MAAM,aAAa,GAAG,iBAAiB,CAAC;AAC9C,OAAO,EACL,WAAW,EACX,cAAc,EACd,qBAAqB,EACrB,YAAY,EACZ,YAAY,EACZ,gBAAgB,EAChB,cAAc,EACd,mBAAmB,EACnB,sBAAsB,EACtB,eAAe,EACf,yBAAyB,EACzB,iBAAiB,EACjB,qBAAqB,EACrB,uBAAuB,EACvB,wBAAwB,EACxB,sBAAsB,EACtB,+BAA+B,EAC/B,uBAAuB,EACvB,8BAA8B,GAC/B,CAAC;AAsBF,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CAkB7D;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,oBAAoB,GAAG,aAAa,CAmBhF"}

package/dist/http.js

@@ -0,0 +1,51 @@
+import { ConfigurationError, ContractError, createHttpStatusError } from '@pellux/goodvibes-errors';
+import { mergeHeaders, resolveAuthToken, resolveHeaders, } from './auth.js';
+import { computeBackoffDelay, normalizeBackoffPolicy, sleepWithSignal, } from './backoff.js';
+import { DEFAULT_HTTP_RETRY_POLICY, getHttpRetryDelay, isRetryableHttpStatus, isRetryableNetworkError, normalizeHttpRetryPolicy, resolveHttpRetryPolicy, } from './retry.js';
+import { DEFAULT_STREAM_RECONNECT_POLICY, getStreamReconnectDelay, normalizeStreamReconnectPolicy, } from './reconnect.js';
+import { createFetch, createHttpJsonTransport, createJsonInit, createJsonRequestInit, readJsonBody, } from './http-core.js';
+export { createFetch, createJsonInit, createJsonRequestInit, readJsonBody, mergeHeaders, resolveAuthToken, resolveHeaders, computeBackoffDelay, normalizeBackoffPolicy, sleepWithSignal, DEFAULT_HTTP_RETRY_POLICY, getHttpRetryDelay, isRetryableHttpStatus, isRetryableNetworkError, normalizeHttpRetryPolicy, resolveHttpRetryPolicy, DEFAULT_STREAM_RECONNECT_POLICY, getStreamReconnectDelay, normalizeStreamReconnectPolicy, };
+function isTransportError(error) {
+    return Boolean(error
+        && typeof error === 'object'
+        && 'transport' in error
+        && error.transport
+        && typeof error.transport.status === 'number'
+        && typeof error.transport.url === 'string');
+}
+export function normalizeTransportError(error) {
+    if (isTransportError(error)) {
+        return createHttpStatusError(error.transport.status, error.transport.url, typeof error.transport.method === 'string' ? error.transport.method : 'GET', error.transport.body);
+    }
+    if (error instanceof Error) {
+        if (error.message === 'Fetch implementation is required' || error.message === 'Transport baseUrl is required') {
+            return new ConfigurationError(error.message);
+        }
+        if (error.message.startsWith('Missing required path parameter')) {
+            return new ContractError(error.message);
+        }
+    }
+    return error instanceof Error ? error : new Error(String(error));
+}
+export function createHttpTransport(options) {
+    const transport = createHttpJsonTransport(options);
+    return {
+        ...transport,
+        async requestJson(pathOrUrl, requestOptions = {}) {
+            try {
+                return await transport.requestJson(pathOrUrl, requestOptions);
+            }
+            catch (error) {
+                throw normalizeTransportError(error);
+            }
+        },
+        resolveContractRequest(method, path, input = {}) {
+            try {
+                return transport.resolveContractRequest(method, path, input);
+            }
+            catch (error) {
+                throw normalizeTransportError(error);
+            }
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export type { ContractInvokeOptions, ContractRouteDefinition, ContractRouteLike, ContractStreamOptions, } from './contract-client.js';
+export { buildContractInput, invokeContractRoute, openContractRouteStream, requireContractRoute, } from './contract-client.js';
+export type { HttpJsonRequestOptions, HttpTransport, HttpTransportOptions, JsonObject, JsonValue, ResolvedContractRequest, } from './http.js';
+export { createFetch, createHttpTransport, createJsonInit, createJsonRequestInit, normalizeTransportError, readJsonBody, } from './http.js';
+export type { ServerSentEventHandlers, ServerSentEventOptions } from './sse.js';
+export { openServerSentEventStream } from './sse.js';
+export type { ServerSentEventHandlers as RawServerSentEventHandlers, ServerSentEventOptions as RawServerSentEventOptions } from './sse-stream.js';
+export { openServerSentEventStream as openRawServerSentEventStream } from './sse-stream.js';
+export type { AuthTokenResolver, HeaderResolver, MaybePromise } from './auth.js';
+export { mergeHeaders, resolveAuthToken, resolveHeaders } from './auth.js';
+export type { BackoffPolicy, ResolvedBackoffPolicy } from './backoff.js';
+export { computeBackoffDelay, normalizeBackoffPolicy, sleepWithSignal } from './backoff.js';
+export type { HttpRetryPolicy, ResolvedHttpRetryPolicy } from './retry.js';
+export { DEFAULT_HTTP_RETRY_POLICY, getHttpRetryDelay, isRetryableHttpStatus, isRetryableNetworkError, normalizeHttpRetryPolicy, resolveHttpRetryPolicy } from './retry.js';
+export type { StreamReconnectPolicy, ResolvedStreamReconnectPolicy } from './reconnect.js';
+export { DEFAULT_STREAM_RECONNECT_POLICY, getStreamReconnectDelay, normalizeStreamReconnectPolicy } from './reconnect.js';
+export type { TransportPaths } from './paths.js';
+export { buildUrl, createTransportPaths, normalizeBaseUrl } from './paths.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,qBAAqB,EACrB,uBAAuB,EACvB,iBAAiB,EACjB,qBAAqB,GACtB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,uBAAuB,EACvB,oBAAoB,GACrB,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EACV,sBAAsB,EACtB,aAAa,EACb,oBAAoB,EACpB,UAAU,EACV,SAAS,EACT,uBAAuB,GACxB,MAAM,WAAW,CAAC;AACnB,OAAO,EACL,WAAW,EACX,mBAAmB,EACnB,cAAc,EACd,qBAAqB,EACrB,uBAAuB,EACvB,YAAY,GACb,MAAM,WAAW,CAAC;AACnB,YAAY,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAChF,OAAO,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAC;AACrD,YAAY,EAAE,uBAAuB,IAAI,0BAA0B,EAAE,sBAAsB,IAAI,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AAClJ,OAAO,EAAE,yBAAyB,IAAI,4BAA4B,EAAE,MAAM,iBAAiB,CAAC;AAC5F,YAAY,EAAE,iBAAiB,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AACjF,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3E,YAAY,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AACzE,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC5F,YAAY,EAAE,eAAe,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAC3E,OAAO,EAAE,yBAAyB,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAC5K,YAAY,EAAE,qBAAqB,EAAE,6BAA6B,EAAE,MAAM,gBAAgB,CAAC;AAC3F,OAAO,EAAE,+BAA+B,EAAE,uBAAuB,EAAE,8BAA8B,EAAE,MAAM,gBAAgB,CAAC;AAC1H,YAAY,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,EAAE,QAAQ,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,9 @@
+export { buildContractInput, invokeContractRoute, openContractRouteStream, requireContractRoute, } from './contract-client.js';
+export { createFetch, createHttpTransport, createJsonInit, createJsonRequestInit, normalizeTransportError, readJsonBody, } from './http.js';
+export { openServerSentEventStream } from './sse.js';
+export { openServerSentEventStream as openRawServerSentEventStream } from './sse-stream.js';
+export { mergeHeaders, resolveAuthToken, resolveHeaders } from './auth.js';
+export { computeBackoffDelay, normalizeBackoffPolicy, sleepWithSignal } from './backoff.js';
+export { DEFAULT_HTTP_RETRY_POLICY, getHttpRetryDelay, isRetryableHttpStatus, isRetryableNetworkError, normalizeHttpRetryPolicy, resolveHttpRetryPolicy } from './retry.js';
+export { DEFAULT_STREAM_RECONNECT_POLICY, getStreamReconnectDelay, normalizeStreamReconnectPolicy } from './reconnect.js';
+export { buildUrl, createTransportPaths, normalizeBaseUrl } from './paths.js';

package/dist/paths.d.ts

@@ -0,0 +1,32 @@
+export interface TransportPaths {
+    readonly baseUrl: string;
+    readonly statusUrl: string;
+    readonly controlPlaneUrl: string;
+    readonly controlPlaneAuthUrl: string;
+    readonly controlPlaneEventsUrl: string;
+    readonly controlPlaneMethodsUrl: string;
+    readonly sessionsUrl: string;
+    readonly tasksUrl: string;
+    readonly approvalsUrl: string;
+    readonly providersUrl: string;
+    readonly accountsUrl: string;
+    readonly localAuthUrl: string;
+    readonly telemetryUrl: string;
+    readonly telemetryEventsUrl: string;
+    readonly telemetryErrorsUrl: string;
+    readonly telemetryTracesUrl: string;
+    readonly telemetryMetricsUrl: string;
+    readonly telemetryStreamUrl: string;
+    readonly telemetryOtlpTracesUrl: string;
+    readonly telemetryOtlpLogsUrl: string;
+    readonly telemetryOtlpMetricsUrl: string;
+    readonly remoteUrl: string;
+    readonly remoteContractUrl: string;
+    readonly peerRequestsUrl: string;
+    readonly peerListUrl: string;
+    readonly remoteWorkUrl: string;
+}
+export declare function normalizeBaseUrl(baseUrl: string): string;
+export declare function buildUrl(baseUrl: string, path: string): string;
+export declare function createTransportPaths(baseUrl: string): TransportPaths;
+//# sourceMappingURL=paths.d.ts.map

package/dist/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../src/paths.ts"],"names":[],"mappings":"AACA,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAC;IACvC,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC;IACxC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC;IACxC,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAC;IACtC,QAAQ,CAAC,uBAAuB,EAAE,MAAM,CAAC;IACzC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAMxD;AAED,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAG9D;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,CA8BpE"}

package/dist/paths.js

@@ -0,0 +1,42 @@
+export function normalizeBaseUrl(baseUrl) {
+    const normalized = baseUrl.trim();
+    if (!normalized) {
+        throw new Error('Transport baseUrl is required');
+    }
+    return normalized.endsWith('/') ? normalized.slice(0, -1) : normalized;
+}
+export function buildUrl(baseUrl, path) {
+    const normalized = normalizeBaseUrl(baseUrl);
+    return new URL(path, `${normalized}/`).toString();
+}
+export function createTransportPaths(baseUrl) {
+    const normalized = normalizeBaseUrl(baseUrl);
+    return {
+        baseUrl: normalized,
+        statusUrl: buildUrl(normalized, '/status'),
+        controlPlaneUrl: buildUrl(normalized, '/api/control-plane'),
+        controlPlaneAuthUrl: buildUrl(normalized, '/api/control-plane/auth'),
+        controlPlaneEventsUrl: buildUrl(normalized, '/api/control-plane/events'),
+        controlPlaneMethodsUrl: buildUrl(normalized, '/api/control-plane/methods'),
+        sessionsUrl: buildUrl(normalized, '/api/sessions'),
+        tasksUrl: buildUrl(normalized, '/api/tasks'),
+        approvalsUrl: buildUrl(normalized, '/api/approvals'),
+        providersUrl: buildUrl(normalized, '/api/providers'),
+        accountsUrl: buildUrl(normalized, '/api/accounts'),
+        localAuthUrl: buildUrl(normalized, '/api/local-auth'),
+        telemetryUrl: buildUrl(normalized, '/api/v1/telemetry'),
+        telemetryEventsUrl: buildUrl(normalized, '/api/v1/telemetry/events'),
+        telemetryErrorsUrl: buildUrl(normalized, '/api/v1/telemetry/errors'),
+        telemetryTracesUrl: buildUrl(normalized, '/api/v1/telemetry/traces'),
+        telemetryMetricsUrl: buildUrl(normalized, '/api/v1/telemetry/metrics'),
+        telemetryStreamUrl: buildUrl(normalized, '/api/v1/telemetry/stream'),
+        telemetryOtlpTracesUrl: buildUrl(normalized, '/api/v1/telemetry/otlp/v1/traces'),
+        telemetryOtlpLogsUrl: buildUrl(normalized, '/api/v1/telemetry/otlp/v1/logs'),
+        telemetryOtlpMetricsUrl: buildUrl(normalized, '/api/v1/telemetry/otlp/v1/metrics'),
+        remoteUrl: buildUrl(normalized, '/api/remote'),
+        remoteContractUrl: buildUrl(normalized, '/api/remote/node-host/contract'),
+        peerRequestsUrl: buildUrl(normalized, '/api/remote/pair/requests'),
+        peerListUrl: buildUrl(normalized, '/api/remote/peers'),
+        remoteWorkUrl: buildUrl(normalized, '/api/remote/work'),
+    };
+}

package/dist/reconnect.d.ts

@@ -0,0 +1,11 @@
+import { type BackoffPolicy, type ResolvedBackoffPolicy } from './backoff.js';
+export interface StreamReconnectPolicy extends BackoffPolicy {
+    readonly enabled?: boolean;
+}
+export interface ResolvedStreamReconnectPolicy extends ResolvedBackoffPolicy {
+    readonly enabled: boolean;
+}
+export declare const DEFAULT_STREAM_RECONNECT_POLICY: ResolvedStreamReconnectPolicy;
+export declare function normalizeStreamReconnectPolicy(policy?: StreamReconnectPolicy): ResolvedStreamReconnectPolicy;
+export declare function getStreamReconnectDelay(attempt: number, policy: ResolvedStreamReconnectPolicy): number;
+//# sourceMappingURL=reconnect.d.ts.map

package/dist/reconnect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconnect.d.ts","sourceRoot":"","sources":["../src/reconnect.ts"],"names":[],"mappings":"AACA,OAAO,EAA+C,KAAK,aAAa,EAAE,KAAK,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAE3H,MAAM,WAAW,qBAAsB,SAAQ,aAAa;IAC1D,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,6BAA8B,SAAQ,qBAAqB;IAC1E,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED,eAAO,MAAM,+BAA+B,EAAE,6BAM7C,CAAC;AAEF,wBAAgB,8BAA8B,CAC5C,MAAM,CAAC,EAAE,qBAAqB,GAC7B,6BAA6B,CAM/B;AAED,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,6BAA6B,GACpC,MAAM,CAER"}

package/dist/reconnect.js

@@ -0,0 +1,19 @@
+// Synced from goodvibes-tui/src/runtime/transports/stream-reconnect.ts
+import { computeBackoffDelay, normalizeBackoffPolicy } from './backoff.js';
+export const DEFAULT_STREAM_RECONNECT_POLICY = {
+    enabled: false,
+    maxAttempts: Number.POSITIVE_INFINITY,
+    baseDelayMs: 500,
+    maxDelayMs: 5_000,
+    backoffFactor: 2,
+};
+export function normalizeStreamReconnectPolicy(policy) {
+    const normalized = normalizeBackoffPolicy(policy, DEFAULT_STREAM_RECONNECT_POLICY);
+    return {
+        ...normalized,
+        enabled: policy?.enabled ?? DEFAULT_STREAM_RECONNECT_POLICY.enabled,
+    };
+}
+export function getStreamReconnectDelay(attempt, policy) {
+    return computeBackoffDelay(attempt, policy);
+}

package/dist/retry.d.ts

@@ -0,0 +1,18 @@
+import { type BackoffPolicy, type ResolvedBackoffPolicy } from './backoff.js';
+export interface HttpRetryPolicy extends BackoffPolicy {
+    readonly retryOnStatuses?: readonly number[];
+    readonly retryOnMethods?: readonly string[];
+    readonly retryOnNetworkError?: boolean;
+}
+export interface ResolvedHttpRetryPolicy extends ResolvedBackoffPolicy {
+    readonly retryOnStatuses: readonly number[];
+    readonly retryOnMethods: readonly string[];
+    readonly retryOnNetworkError: boolean;
+}
+export declare const DEFAULT_HTTP_RETRY_POLICY: ResolvedHttpRetryPolicy;
+export declare function normalizeHttpRetryPolicy(policy?: HttpRetryPolicy): ResolvedHttpRetryPolicy;
+export declare function resolveHttpRetryPolicy(defaultPolicy?: HttpRetryPolicy, override?: false | HttpRetryPolicy): ResolvedHttpRetryPolicy;
+export declare function getHttpRetryDelay(attempt: number, policy: ResolvedHttpRetryPolicy): number;
+export declare function isRetryableHttpStatus(method: string, status: number, policy: ResolvedHttpRetryPolicy): boolean;
+export declare function isRetryableNetworkError(method: string, policy: ResolvedHttpRetryPolicy): boolean;
+//# sourceMappingURL=retry.d.ts.map

package/dist/retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../src/retry.ts"],"names":[],"mappings":"AACA,OAAO,EAA+C,KAAK,aAAa,EAAE,KAAK,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAE3H,MAAM,WAAW,eAAgB,SAAQ,aAAa;IACpD,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7C,QAAQ,CAAC,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5C,QAAQ,CAAC,mBAAmB,CAAC,EAAE,OAAO,CAAC;CACxC;AAED,MAAM,WAAW,uBAAwB,SAAQ,qBAAqB;IACpE,QAAQ,CAAC,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5C,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,QAAQ,CAAC,mBAAmB,EAAE,OAAO,CAAC;CACvC;AAED,eAAO,MAAM,yBAAyB,EAAE,uBAQvC,CAAC;AAEF,wBAAgB,wBAAwB,CACtC,MAAM,CAAC,EAAE,eAAe,GACvB,uBAAuB,CAQzB;AAED,wBAAgB,sBAAsB,CACpC,aAAa,CAAC,EAAE,eAAe,EAC/B,QAAQ,CAAC,EAAE,KAAK,GAAG,eAAe,GACjC,uBAAuB,CAazB;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,uBAAuB,GAC9B,MAAM,CAER;AAED,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,uBAAuB,GAC9B,OAAO,CAGT;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,uBAAuB,GAC9B,OAAO,CAET"}

package/dist/retry.js

@@ -0,0 +1,45 @@
+// Synced from goodvibes-tui/src/runtime/transports/http-retry.ts
+import { computeBackoffDelay, normalizeBackoffPolicy } from './backoff.js';
+export const DEFAULT_HTTP_RETRY_POLICY = {
+    maxAttempts: 1,
+    baseDelayMs: 250,
+    maxDelayMs: 2_000,
+    backoffFactor: 2,
+    retryOnStatuses: [408, 429, 500, 502, 503, 504],
+    retryOnMethods: ['GET', 'HEAD', 'OPTIONS'],
+    retryOnNetworkError: true,
+};
+export function normalizeHttpRetryPolicy(policy) {
+    const normalized = normalizeBackoffPolicy(policy, DEFAULT_HTTP_RETRY_POLICY);
+    return {
+        ...normalized,
+        retryOnStatuses: [...(policy?.retryOnStatuses ?? DEFAULT_HTTP_RETRY_POLICY.retryOnStatuses)],
+        retryOnMethods: [...(policy?.retryOnMethods ?? DEFAULT_HTTP_RETRY_POLICY.retryOnMethods)].map((method) => method.toUpperCase()),
+        retryOnNetworkError: policy?.retryOnNetworkError ?? DEFAULT_HTTP_RETRY_POLICY.retryOnNetworkError,
+    };
+}
+export function resolveHttpRetryPolicy(defaultPolicy, override) {
+    if (override === false) {
+        return normalizeHttpRetryPolicy({ maxAttempts: 1 });
+    }
+    const base = normalizeHttpRetryPolicy(defaultPolicy);
+    if (!override)
+        return base;
+    return {
+        ...base,
+        ...normalizeBackoffPolicy(override, base),
+        retryOnStatuses: override.retryOnStatuses ? [...override.retryOnStatuses] : base.retryOnStatuses,
+        retryOnMethods: override.retryOnMethods ? override.retryOnMethods.map((method) => method.toUpperCase()) : base.retryOnMethods,
+        retryOnNetworkError: override.retryOnNetworkError ?? base.retryOnNetworkError,
+    };
+}
+export function getHttpRetryDelay(attempt, policy) {
+    return computeBackoffDelay(attempt, policy);
+}
+export function isRetryableHttpStatus(method, status, policy) {
+    return policy.retryOnMethods.includes(method.toUpperCase())
+        && policy.retryOnStatuses.includes(status);
+}
+export function isRetryableNetworkError(method, policy) {
+    return policy.retryOnMethods.includes(method.toUpperCase()) && policy.retryOnNetworkError;
+}

package/dist/sse-stream.d.ts

@@ -0,0 +1,22 @@
+import { type AuthTokenResolver } from './auth.js';
+import { type StreamReconnectPolicy } from './reconnect.js';
+export interface ServerSentEventHandlers {
+    readonly onEvent?: (eventName: string, payload: unknown) => void;
+    readonly onReady?: (payload: unknown) => void;
+    readonly onError?: (error: unknown) => void;
+    readonly onReconnect?: (input: {
+        readonly attempt: number;
+        readonly delayMs: number;
+    }) => void;
+}
+export interface ServerSentEventOptions {
+    readonly signal?: AbortSignal;
+    readonly headers?: HeadersInit;
+    readonly authToken?: string | null;
+    readonly getAuthToken?: AuthTokenResolver;
+    readonly lastEventId?: string | null;
+    readonly reconnect?: StreamReconnectPolicy;
+}
+export declare function isAbortError(error: unknown): boolean;
+export declare function openServerSentEventStream(fetchImpl: typeof fetch, url: string, handlers: ServerSentEventHandlers, options?: ServerSentEventOptions): Promise<() => void>;
+//# sourceMappingURL=sse-stream.d.ts.map

package/dist/sse-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse-stream.d.ts","sourceRoot":"","sources":["../src/sse-stream.ts"],"names":[],"mappings":"AAEA,OAAO,EAAkC,KAAK,iBAAiB,EAAE,MAAM,WAAW,CAAC;AACnF,OAAO,EAGL,KAAK,qBAAqB,EAC3B,MAAM,gBAAgB,CAAC;AAGxB,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IACjE,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IAC9C,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IAC5C,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE;QAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;CAChG;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAC9B,QAAQ,CAAC,OAAO,CAAC,EAAE,WAAW,CAAC;IAC/B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,QAAQ,CAAC,YAAY,CAAC,EAAE,iBAAiB,CAAC;IAC1C,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,QAAQ,CAAC,SAAS,CAAC,EAAE,qBAAqB,CAAC;CAC5C;AAWD,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CASpD;AA8BD,wBAAsB,yBAAyB,CAC7C,SAAS,EAAE,OAAO,KAAK,EACvB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,uBAAuB,EACjC,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAAC,MAAM,IAAI,CAAC,CAkLrB"}

package/dist/sse-stream.js

@@ -0,0 +1,212 @@
+// Synced from goodvibes-tui/src/runtime/transports/sse-stream.ts
+import { sleepWithSignal } from './backoff.js';
+import { mergeHeaders, resolveAuthToken } from './auth.js';
+import { getStreamReconnectDelay, normalizeStreamReconnectPolicy, } from './reconnect.js';
+function readEventPayload(data) {
+    if (!data.trim())
+        return null;
+    try {
+        return JSON.parse(data);
+    }
+    catch {
+        return data;
+    }
+}
+export function isAbortError(error) {
+    return (error instanceof DOMException && error.name === 'AbortError') || (typeof error === 'object'
+        && error !== null
+        && 'name' in error
+        && error.name === 'AbortError');
+}
+function createStreamError(status, url, body) {
+    const message = body.trim()
+        ? `Unable to open SSE stream: ${status} ${body}`.trim()
+        : `Unable to open SSE stream: ${status}`;
+    return Object.assign(new Error(message), {
+        transport: {
+            status,
+            body,
+            url,
+            method: 'GET',
+        },
+    });
+}
+function reportStreamError(error, handlers) {
+    if (handlers.onError) {
+        handlers.onError(error);
+        return;
+    }
+    queueMicrotask(() => {
+        throw error;
+    });
+}
+export async function openServerSentEventStream(fetchImpl, url, handlers, options = {}) {
+    const outerController = new AbortController();
+    const reconnectPolicy = normalizeStreamReconnectPolicy(options.reconnect);
+    let lastEventId = options.lastEventId ?? null;
+    let activeController = null;
+    let stopped = false;
+    let reconnectAttempts = 0;
+    let readySettled = false;
+    if (options.signal) {
+        options.signal.addEventListener('abort', () => outerController.abort(), { once: true });
+    }
+    const readyPromise = new Promise((resolve, reject) => {
+        const settleReady = (error) => {
+            if (readySettled)
+                return;
+            readySettled = true;
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve();
+            }
+        };
+        const runConnection = async () => {
+            const controller = new AbortController();
+            activeController = controller;
+            outerController.signal.addEventListener('abort', () => controller.abort(), { once: true });
+            const token = await resolveAuthToken(options.authToken ?? null, options.getAuthToken);
+            const headers = mergeHeaders({ Accept: 'text/event-stream' }, options.headers, token ? { Authorization: `Bearer ${token}` } : undefined, lastEventId ? { 'Last-Event-ID': lastEventId } : undefined);
+            let response;
+            try {
+                response = await fetchImpl(url, {
+                    method: 'GET',
+                    credentials: 'include',
+                    signal: controller.signal,
+                    headers,
+                });
+            }
+            catch (error) {
+                const wrapped = createStreamError(0, url, error instanceof Error ? error.message : String(error));
+                if (!readySettled) {
+                    settleReady(wrapped);
+                    return;
+                }
+                throw wrapped;
+            }
+            if (!response.ok || !response.body) {
+                const body = await response.text().catch(() => '');
+                const wrapped = createStreamError(response.status, url, body);
+                if (!readySettled) {
+                    settleReady(wrapped);
+                    return;
+                }
+                throw wrapped;
+            }
+            settleReady();
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = '';
+            let eventName = '';
+            let data = '';
+            const flush = () => {
+                if (!eventName && !data.trim()) {
+                    eventName = '';
+                    data = '';
+                    return;
+                }
+                const payload = readEventPayload(data);
+                if (eventName === 'ready') {
+                    handlers.onReady?.(payload);
+                }
+                else {
+                    handlers.onEvent?.(eventName || 'message', payload);
+                }
+                eventName = '';
+                data = '';
+            };
+            const consumeLine = (line) => {
+                if (!line) {
+                    flush();
+                    return;
+                }
+                if (line.startsWith(':'))
+                    return;
+                if (line.startsWith('id:')) {
+                    const candidate = line.slice(3).trim();
+                    if (candidate) {
+                        lastEventId = candidate;
+                    }
+                    return;
+                }
+                if (line.startsWith('event:')) {
+                    eventName = line.slice(6).trim();
+                    return;
+                }
+                if (line.startsWith('data:')) {
+                    data += `${data ? '\n' : ''}${line.slice(5).trim()}`;
+                }
+            };
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    let newlineIndex = buffer.indexOf('\n');
+                    while (newlineIndex >= 0) {
+                        const line = buffer.slice(0, newlineIndex).replace(/\r$/, '');
+                        buffer = buffer.slice(newlineIndex + 1);
+                        consumeLine(line);
+                        newlineIndex = buffer.indexOf('\n');
+                    }
+                }
+                if (buffer.trim()) {
+                    consumeLine(buffer.replace(/\r$/, ''));
+                    flush();
+                }
+                if (reconnectPolicy.enabled && !controller.signal.aborted && !outerController.signal.aborted && !stopped) {
+                    throw createStreamError(response.status, url, 'Stream closed unexpectedly');
+                }
+            }
+            finally {
+                controller.abort();
+                if (activeController === controller) {
+                    activeController = null;
+                }
+            }
+        };
+        const loop = async () => {
+            while (!outerController.signal.aborted && !stopped) {
+                try {
+                    await runConnection();
+                    reconnectAttempts = 0;
+                    return;
+                }
+                catch (error) {
+                    if (isAbortError(error) || outerController.signal.aborted || stopped) {
+                        return;
+                    }
+                    const nextAttempt = reconnectAttempts + 1;
+                    const shouldReconnect = reconnectPolicy.enabled && nextAttempt < reconnectPolicy.maxAttempts;
+                    if (!shouldReconnect) {
+                        reportStreamError(error, handlers);
+                        return;
+                    }
+                    reconnectAttempts = nextAttempt;
+                    const delayMs = getStreamReconnectDelay(nextAttempt + 1, reconnectPolicy);
+                    handlers.onReconnect?.({ attempt: nextAttempt, delayMs });
+                    handlers.onError?.(error);
+                    try {
+                        await sleepWithSignal(delayMs, outerController.signal);
+                    }
+                    catch (sleepError) {
+                        if (!isAbortError(sleepError)) {
+                            reportStreamError(sleepError, handlers);
+                        }
+                        return;
+                    }
+                }
+            }
+        };
+        void loop();
+    });
+    await readyPromise;
+    return () => {
+        stopped = true;
+        activeController?.abort();
+        outerController.abort();
+    };
+}

package/dist/sse.d.ts

@@ -0,0 +1,7 @@
+import { type ServerSentEventHandlers, type ServerSentEventOptions as CoreServerSentEventOptions } from './sse-stream.js';
+import { type HttpTransport } from './http.js';
+export type { ServerSentEventHandlers };
+export interface ServerSentEventOptions extends Omit<CoreServerSentEventOptions, 'authToken'> {
+}
+export declare function openServerSentEventStream(transport: HttpTransport, pathOrUrl: string, handlers: ServerSentEventHandlers, options?: ServerSentEventOptions): Promise<() => void>;
+//# sourceMappingURL=sse.d.ts.map

package/dist/sse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../src/sse.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8D,KAAK,uBAAuB,EAAE,KAAK,sBAAsB,IAAI,0BAA0B,EAAE,MAAM,iBAAiB,CAAC;AACtL,OAAO,EAAE,KAAK,aAAa,EAA2B,MAAM,WAAW,CAAC;AAExE,YAAY,EAAE,uBAAuB,EAAE,CAAC;AACxC,MAAM,WAAW,sBAAuB,SAAQ,IAAI,CAAC,0BAA0B,EAAE,WAAW,CAAC;CAAG;AAEhG,wBAAsB,yBAAyB,CAC7C,SAAS,EAAE,aAAa,EACxB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,uBAAuB,EACjC,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAAC,MAAM,IAAI,CAAC,CAarB"}

package/dist/sse.js

@@ -0,0 +1,17 @@
+import { openServerSentEventStream as openServerSentEventStreamCore } from './sse-stream.js';
+import { normalizeTransportError } from './http.js';
+export async function openServerSentEventStream(transport, pathOrUrl, handlers, options = {}) {
+    const url = pathOrUrl.startsWith('http://') || pathOrUrl.startsWith('https://')
+        ? pathOrUrl
+        : transport.buildUrl(pathOrUrl);
+    try {
+        return await openServerSentEventStreamCore(transport.fetchImpl, url, handlers, {
+            ...options,
+            authToken: transport.authToken,
+            getAuthToken: transport.getAuthToken.bind(transport),
+        });
+    }
+    catch (error) {
+        throw normalizeTransportError(error);
+    }
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@pellux/goodvibes-transport-http",
+  "version": "0.18.3",
+  "description": "HTTP, JSON, path, and SSE transport primitives for GoodVibes client integrations.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mgd34msu/goodvibes-sdk.git"
+  },
+  "bugs": {
+    "url": "https://github.com/mgd34msu/goodvibes-sdk/issues"
+  },
+  "homepage": "https://github.com/mgd34msu/goodvibes-sdk",
+  "keywords": [
+    "goodvibes",
+    "sdk",
+    "http",
+    "sse",
+    "transport"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@pellux/goodvibes-errors": "0.18.3"
+  }
+}