@pellux/goodvibes-sdk 0.18.3 → 0.18.12

package/dist/_internal/transport-http/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/_internal/transport-http/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/_internal/transport-http/reconnect.d.ts.map

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

@@ -0,0 +1,20 @@
+// Synced from packages/transport-http/src/reconnect.ts
+// Extracted from legacy source: 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/_internal/transport-http/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/_internal/transport-http/retry.d.ts.map

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

@@ -0,0 +1,46 @@
+// Synced from packages/transport-http/src/retry.ts
+// Extracted from legacy source: 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/_internal/transport-http/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/_internal/transport-http/sse-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse-stream.d.ts","sourceRoot":"","sources":["../../../src/_internal/transport-http/sse-stream.ts"],"names":[],"mappings":"AAGA,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/_internal/transport-http/sse-stream.js

@@ -0,0 +1,213 @@
+// Synced from packages/transport-http/src/sse-stream.ts
+// Extracted from legacy source: 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/_internal/transport-http/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/_internal/transport-http/sse.d.ts.map

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

@@ -0,0 +1,18 @@
+// Synced from packages/transport-http/src/sse.ts
+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/dist/_internal/transport-http.d.ts

@@ -0,0 +1,2 @@
+export * from './transport-http/index.js';
+//# sourceMappingURL=transport-http.d.ts.map

package/dist/_internal/transport-http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport-http.d.ts","sourceRoot":"","sources":["../../src/_internal/transport-http.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC"}

package/dist/_internal/transport-http.js

@@ -0,0 +1 @@
+export * from './transport-http/index.js';

package/dist/_internal/transport-realtime/domain-events.d.ts

@@ -0,0 +1,18 @@
+import { type RuntimeEventFeeds } from '../transport-core/index.js';
+type EventLike = {
+    readonly type: string;
+};
+export interface SerializedEventEnvelope<TEvent extends EventLike = EventLike> {
+    readonly type: string;
+    readonly timestamp?: number;
+    readonly ts?: number;
+    readonly traceId?: string;
+    readonly sessionId?: string;
+    readonly source?: string;
+    readonly payload: TEvent;
+}
+export type DomainEventConnector<TDomain extends string, TEvent extends EventLike = EventLike> = (domain: TDomain, onEnvelope: (envelope: SerializedEventEnvelope<TEvent>) => void) => void | Promise<() => void>;
+export type DomainEvents<TDomain extends string, TEvent extends EventLike = EventLike> = RuntimeEventFeeds<TDomain, TEvent>;
+export declare function createRemoteDomainEvents<TDomain extends string, TEvent extends EventLike = EventLike>(domains: readonly TDomain[], connect: DomainEventConnector<TDomain, TEvent>): DomainEvents<TDomain, TEvent>;
+export {};
+//# sourceMappingURL=domain-events.d.ts.map

package/dist/_internal/transport-realtime/domain-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-events.d.ts","sourceRoot":"","sources":["../../../src/_internal/transport-realtime/domain-events.ts"],"names":[],"mappings":"AAGA,OAAO,EAAkD,KAAK,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAEpH,KAAK,SAAS,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3C,MAAM,WAAW,uBAAuB,CAAC,MAAM,SAAS,SAAS,GAAG,SAAS;IAC3E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,MAAM,oBAAoB,CAC9B,OAAO,SAAS,MAAM,EACtB,MAAM,SAAS,SAAS,GAAG,SAAS,IAClC,CACF,MAAM,EAAE,OAAO,EACf,UAAU,EAAE,CAAC,QAAQ,EAAE,uBAAuB,CAAC,MAAM,CAAC,KAAK,IAAI,KAC5D,IAAI,GAAG,OAAO,CAAC,MAAM,IAAI,CAAC,CAAC;AAEhC,MAAM,MAAM,YAAY,CACtB,OAAO,SAAS,MAAM,EACtB,MAAM,SAAS,SAAS,GAAG,SAAS,IAClC,iBAAiB,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;AAmIvC,wBAAgB,wBAAwB,CACtC,OAAO,SAAS,MAAM,EACtB,MAAM,SAAS,SAAS,GAAG,SAAS,EAEpC,OAAO,EAAE,SAAS,OAAO,EAAE,EAC3B,OAAO,EAAE,oBAAoB,CAAC,OAAO,EAAE,MAAM,CAAC,GAC7C,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,CAK/B"}

package/dist/_internal/transport-realtime/domain-events.js

@@ -0,0 +1,116 @@
+import { createRuntimeEventFeeds } from '../transport-core/index.js';
+function addListener(map, type, listener) {
+    const listeners = map.get(type) ?? new Set();
+    listeners.add(listener);
+    map.set(type, listeners);
+    return () => {
+        const existing = map.get(type);
+        if (!existing)
+            return;
+        existing.delete(listener);
+        if (existing.size === 0) {
+            map.delete(type);
+        }
+    };
+}
+function hasAnyListener(map) {
+    for (const listeners of map.values()) {
+        if (listeners.size > 0)
+            return true;
+    }
+    return false;
+}
+function isExpectedDisconnectError(error) {
+    return (error instanceof DOMException && error.name === 'AbortError') || (typeof error === 'object'
+        && error !== null
+        && 'name' in error
+        && error.name === 'AbortError');
+}
+function toEventEnvelope(envelope) {
+    return {
+        type: envelope.type,
+        ts: typeof envelope.ts === 'number'
+            ? envelope.ts
+            : typeof envelope.timestamp === 'number'
+                ? envelope.timestamp
+                : Date.now(),
+        traceId: typeof envelope.traceId === 'string' ? envelope.traceId : 'transport-trace',
+        sessionId: typeof envelope.sessionId === 'string' ? envelope.sessionId : 'transport',
+        source: typeof envelope.source === 'string' ? envelope.source : 'transport',
+        payload: envelope.payload,
+    };
+}
+function createRemoteDomainEventFeed(domain, connect) {
+    const payloadListeners = new Map();
+    const envelopeListeners = new Map();
+    let disconnect = null;
+    let connectPromise = null;
+    let disconnectPending = false;
+    const hasListeners = () => (hasAnyListener(payloadListeners)
+        || hasAnyListener(envelopeListeners));
+    const maybeConnect = () => {
+        if (disconnect || connectPromise)
+            return;
+        connectPromise = Promise.resolve(connect(domain, (envelope) => {
+            const eventType = typeof envelope.type === 'string' ? envelope.type : '';
+            if (!eventType)
+                return;
+            const payload = envelope.payload;
+            const typedEnvelope = toEventEnvelope(envelope);
+            for (const listener of payloadListeners.get(eventType) ?? []) {
+                listener(payload);
+            }
+            for (const listener of envelopeListeners.get(eventType) ?? []) {
+                listener(typedEnvelope);
+            }
+        })).then((cleanup) => {
+            if (typeof cleanup !== 'function')
+                return;
+            if (disconnectPending && !hasListeners()) {
+                cleanup();
+                return;
+            }
+            disconnect = cleanup;
+        }).catch((error) => {
+            if (!isExpectedDisconnectError(error)) {
+                throw error;
+            }
+        }).finally(() => {
+            connectPromise = null;
+            disconnectPending = false;
+        });
+    };
+    const maybeDisconnect = () => {
+        if (hasListeners())
+            return;
+        if (disconnect) {
+            disconnect();
+            disconnect = null;
+            return;
+        }
+        if (connectPromise) {
+            disconnectPending = true;
+        }
+    };
+    return {
+        on(type, listener) {
+            const unsubscribe = addListener(payloadListeners, type, listener);
+            maybeConnect();
+            return () => {
+                unsubscribe();
+                maybeDisconnect();
+            };
+        },
+        onEnvelope(type, listener) {
+            const unsubscribe = addListener(envelopeListeners, type, listener);
+            maybeConnect();
+            return () => {
+                unsubscribe();
+                maybeDisconnect();
+            };
+        },
+    };
+}
+export function createRemoteDomainEvents(domains, connect) {
+    return createRuntimeEventFeeds(domains, (domain) => createRemoteDomainEventFeed(domain, connect));
+}

package/dist/_internal/transport-realtime/index.d.ts

@@ -0,0 +1,6 @@
+export type { DomainEventConnector, DomainEvents, SerializedEventEnvelope, } from './domain-events.js';
+export { createRemoteDomainEvents } from './domain-events.js';
+export type { RemoteRuntimeEvents, SerializedRuntimeEnvelope } from './runtime-events.js';
+export { buildEventSourceUrl, buildWebSocketUrl, createEventSourceConnector, createRemoteRuntimeEvents, createWebSocketConnector, } from './runtime-events.js';
+export type { RuntimeEventConnectorOptions } from './runtime-events.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/_internal/transport-realtime/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/_internal/transport-realtime/index.ts"],"names":[],"mappings":"AACA,YAAY,EACV,oBAAoB,EACpB,YAAY,EACZ,uBAAuB,GACxB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,YAAY,EAAE,mBAAmB,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAC1F,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,0BAA0B,EAC1B,yBAAyB,EACzB,wBAAwB,GACzB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/_internal/transport-realtime/index.js

@@ -0,0 +1,2 @@
+export { createRemoteDomainEvents } from './domain-events.js';
+export { buildEventSourceUrl, buildWebSocketUrl, createEventSourceConnector, createRemoteRuntimeEvents, createWebSocketConnector, } from './runtime-events.js';

package/dist/_internal/transport-realtime/runtime-events.d.ts

@@ -0,0 +1,20 @@
+import { type RuntimeEventDomain } from '../contracts/index.js';
+import { type AuthTokenResolver, type StreamReconnectPolicy } from '../transport-http/index.js';
+import { type DomainEventConnector, type DomainEvents, type SerializedEventEnvelope } from './domain-events.js';
+type RuntimeEventRecord = {
+    readonly type: string;
+};
+export type SerializedRuntimeEnvelope<TEvent extends RuntimeEventRecord = RuntimeEventRecord> = SerializedEventEnvelope<TEvent>;
+export type RemoteRuntimeEvents<TEvent extends RuntimeEventRecord = RuntimeEventRecord> = DomainEvents<RuntimeEventDomain, TEvent>;
+export interface RuntimeEventConnectorOptions {
+    readonly reconnect?: StreamReconnectPolicy;
+    readonly onError?: (error: unknown) => void;
+}
+type AuthTokenSource = string | null | undefined | AuthTokenResolver;
+export declare function createRemoteRuntimeEvents<TEvent extends RuntimeEventRecord = RuntimeEventRecord>(connect: DomainEventConnector<RuntimeEventDomain, TEvent>): RemoteRuntimeEvents<TEvent>;
+export declare function buildEventSourceUrl(baseUrl: string, domain: RuntimeEventDomain): string;
+export declare function buildWebSocketUrl(baseUrl: string, domains: readonly RuntimeEventDomain[]): string;
+export declare function createEventSourceConnector(baseUrl: string, token: AuthTokenSource, fetchImpl: typeof fetch, options?: RuntimeEventConnectorOptions): DomainEventConnector<RuntimeEventDomain, RuntimeEventRecord>;
+export declare function createWebSocketConnector(baseUrl: string, token: AuthTokenSource, WebSocketImpl: typeof WebSocket, options?: RuntimeEventConnectorOptions): DomainEventConnector<RuntimeEventDomain, RuntimeEventRecord>;
+export {};
+//# sourceMappingURL=runtime-events.d.ts.map

package/dist/_internal/transport-realtime/runtime-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-events.d.ts","sourceRoot":"","sources":["../../../src/_internal/transport-realtime/runtime-events.ts"],"names":[],"mappings":"AAEA,OAAO,EAAyB,KAAK,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AACvF,OAAO,EAAoB,KAAK,iBAAiB,EAAE,KAAK,qBAAqB,EAA6D,MAAM,4BAA4B,CAAC;AAE7K,OAAO,EAEL,KAAK,oBAAoB,EACzB,KAAK,YAAY,EACjB,KAAK,uBAAuB,EAC7B,MAAM,oBAAoB,CAAC;AAE5B,KAAK,kBAAkB,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpD,MAAM,MAAM,yBAAyB,CAAC,MAAM,SAAS,kBAAkB,GAAG,kBAAkB,IAC1F,uBAAuB,CAAC,MAAM,CAAC,CAAC;AAElC,MAAM,MAAM,mBAAmB,CAAC,MAAM,SAAS,kBAAkB,GAAG,kBAAkB,IACpF,YAAY,CAAC,kBAAkB,EAAE,MAAM,CAAC,CAAC;AAE3C,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,SAAS,CAAC,EAAE,qBAAqB,CAAC;IAC3C,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CAC7C;AAED,KAAK,eAAe,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,iBAAiB,CAAC;AASrE,wBAAgB,yBAAyB,CAAC,MAAM,SAAS,kBAAkB,GAAG,kBAAkB,EAC9F,OAAO,EAAE,oBAAoB,CAAC,kBAAkB,EAAE,MAAM,CAAC,GACxD,mBAAmB,CAAC,MAAM,CAAC,CAK7B;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,kBAAkB,GACzB,MAAM,CAIR;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,SAAS,kBAAkB,EAAE,GACrC,MAAM,CAQR;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,eAAe,EACtB,SAAS,EAAE,OAAO,KAAK,EACvB,OAAO,GAAE,4BAAiC,GACzC,oBAAoB,CAAC,kBAAkB,EAAE,kBAAkB,CAAC,CAiB9D;AAED,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,eAAe,EACtB,aAAa,EAAE,OAAO,SAAS,EAC/B,OAAO,GAAE,4BAAiC,GACzC,oBAAoB,CAAC,kBAAkB,EAAE,kBAAkB,CAAC,CAuF9D"}