@marinoscar/platform-web 0.1.0-next.3 → 0.1.0-next.4

package/dist/core/http/sse.js

@@ -0,0 +1,609 @@
+/**
+ * A fetch-based Server-Sent Events client.
+ *
+ * Issue #127, epic #109.
+ *
+ * =============================================================================
+ * WHY THIS FILE EXISTS AT ALL — `EventSource` CANNOT SEND AN AUTHORIZATION HEADER
+ * =============================================================================
+ *
+ * `GET /api/notifications/stream` is guarded by the ordinary bearer `@Auth()`,
+ * exactly like every other endpoint. The native `EventSource` constructor takes
+ * a URL and `withCredentials`, and NOTHING ELSE — there is no headers argument
+ * and no way to add one. So the browser's built-in SSE client cannot
+ * authenticate against that route.
+ *
+ * The two ways out, and why this is the one taken:
+ *
+ *   1. REJECTED — `?token=…` on the stream URL. The API refused this
+ *      deliberately (see the long note on `NotificationsController.stream`), and
+ *      the refusal is right: a URL query string is written verbatim into the
+ *      nginx access log, kept in browser history, and forwarded in `Referer` to
+ *      any third party the page later touches. That turns a live bearer
+ *      credential into something replayable out of a log file retained for
+ *      months and readable by people who are not supposed to hold sessions.
+ *      Cheap transport is not worth credentials in logs.
+ *
+ *   2. CHOSEN — `fetch()` with a real `Authorization` header, reading
+ *      `response.body` as a `ReadableStream` and parsing the SSE framing here.
+ *      `fetch` takes arbitrary headers; the cost is that everything
+ *      `EventSource` does for free — framing, reconnection, backoff — has to be
+ *      written, which is what the rest of this file is.
+ *
+ * WHY HAND-ROLLED RATHER THAN A DEPENDENCY (`@microsoft/fetch-event-source`).
+ * This worktree cannot take a new dependency, and on inspection it does not
+ * need one: the whole client is the parser below plus a retry loop, both of
+ * which are small, fully testable without a network, and — unlike a
+ * dependency — able to reuse the `PlatformHttpClient` token and refresh
+ * machinery directly rather than through a callback shim. A library would also
+ * bring its own opinions about 401 handling, which is precisely the part that
+ * has to match `core/http/client.ts` exactly.
+ *
+ * =============================================================================
+ * WHAT THIS CLIENT DOES NOT DO, AND MUST NOT BE MADE TO DO
+ * =============================================================================
+ *
+ * IT DOES NOT GUARANTEE DELIVERY. Anything the server publishes while this
+ * connection is down is GONE: the API holds no buffer, honours no
+ * `Last-Event-ID`, and has no replay log (`NotificationStreamService`'s header
+ * says so in as many words). This client therefore reports every (re)connection
+ * through `onOpen`, and ITS CALLER IS REQUIRED TO REFETCH on that signal. Do
+ * not add replay here; the `notifications` table is the source of truth and one
+ * indexed query after a gap is strictly more reliable than any cursor built on
+ * top of a stream.
+ *
+ * `lastEventId` is parsed and tracked because the SSE grammar has the field and
+ * a parser that silently dropped it would be wrong — but it is NOT sent back as
+ * `Last-Event-ID` on reconnect, because the server does not implement it and a
+ * header that looks like resumption but resumes nothing is worse than no header
+ * at all.
+ */
+import { ApiError } from './client.js';
+/**
+ * An incremental SSE stream parser.
+ *
+ * Fed decoded text in arbitrary chunks — a network read boundary can land
+ * anywhere, including in the middle of a UTF-8 sequence, in the middle of a
+ * field name, or between the CR and LF of one line terminator — and emits whole
+ * frames only. Every one of those splits is a real thing that happens under
+ * load and each has its own comment below.
+ *
+ * Deliberately a plain class with no I/O so the framing rules can be tested by
+ * calling a method with a string.
+ *
+ * @stability experimental
+ */
+export class SseParser {
+    /** Bytes seen but not yet terminated by a line ending. */
+    buffer = '';
+    /** The event-type buffer, per spec: reset to '' after every dispatch. */
+    eventType = '';
+    /** The data buffer, per spec: accumulated across `data:` lines. */
+    data = '';
+    /** This frame's `id:`, distinct from `lastEventId` below. */
+    frameId = null;
+    /**
+     * The last non-null `id:` seen on the stream.
+     *
+     * Public because it is genuinely part of the stream's state, and read by
+     * nothing today — see the header on why it is not sent back.
+     */
+    lastEventId = null;
+    /**
+     * The server's most recent `retry:` directive, in milliseconds, or `null`.
+     *
+     * A STREAM-LEVEL directive, not a per-frame one: it sets the reconnection
+     * delay for every subsequent reconnect until the server says otherwise, which
+     * is why it lives on the parser rather than on `SseFrame`. This API never
+     * sends one; it is honoured anyway because ignoring a server that asks to be
+     * reconnected to more slowly is how a client turns a struggling backend into
+     * a hammered one.
+     */
+    retryMs = null;
+    /**
+     * Feed one decoded chunk; get back every frame it completed.
+     *
+     * @param chunk - decoded text. MUST come from a streaming decoder — see
+     *        `TextDecoder({ stream: true })` at the call site. Decoding each
+     *        network chunk independently corrupts any multi-byte character that
+     *        straddles a chunk boundary, which for this API means a notification
+     *        body with an accent or an emoji in it arrives mangled roughly
+     *        whenever it is unlucky about packet size.
+     */
+    push(chunk) {
+        this.buffer += chunk;
+        const frames = [];
+        let start = 0;
+        let i = 0;
+        // Line terminators in SSE are CRLF, LF **or** bare CR — all three, which is
+        // why this is a hand-written scan rather than `split('\n')`.
+        while (i < this.buffer.length) {
+            const ch = this.buffer[i];
+            if (ch === '\n') {
+                this.handleLine(this.buffer.slice(start, i), frames);
+                i += 1;
+                start = i;
+            }
+            else if (ch === '\r') {
+                // A CR AT THE VERY END OF WHAT WE HOLD IS AMBIGUOUS: it is either a
+                // bare-CR terminator, or the first half of a CRLF whose LF is in the
+                // next network chunk. Treating it as a terminator now would emit the
+                // line and then treat the stray LF as an EMPTY line, dispatching a
+                // half-built frame. So stop, leave the CR in the buffer, and decide
+                // when more bytes arrive.
+                if (i === this.buffer.length - 1)
+                    break;
+                this.handleLine(this.buffer.slice(start, i), frames);
+                i += this.buffer[i + 1] === '\n' ? 2 : 1;
+                start = i;
+            }
+            else {
+                i += 1;
+            }
+        }
+        // Keep the unterminated remainder (including a trailing CR we stopped on).
+        this.buffer = this.buffer.slice(start);
+        return frames;
+    }
+    handleLine(line, frames) {
+        // A BLANK LINE IS THE DISPATCH SIGNAL. Not a separator to skip.
+        if (line === '') {
+            const frame = this.dispatch();
+            if (frame)
+                frames.push(frame);
+            return;
+        }
+        // A COMMENT. `: heartbeat` and the opening `: connected` both land here and
+        // are discarded, which is exactly what they are for: they are bytes on the
+        // wire that keep nginx and every NAT table in the path from reaping an idle
+        // connection, and they must NEVER surface to the page as a message. See
+        // `HEARTBEAT_INTERVAL_MS` in `notification-stream.service.ts`.
+        //
+        // They are not entirely inert to this client either — a comment arriving is
+        // a read completing, so it is what keeps the reconnect loop below from ever
+        // seeing an idle stream as a dead one.
+        if (line.startsWith(':'))
+            return;
+        const colon = line.indexOf(':');
+        let field;
+        let value;
+        if (colon === -1) {
+            // A field name with no value, e.g. a bare `data`. Legal, and means an
+            // empty value — NOT a line to ignore.
+            field = line;
+            value = '';
+        }
+        else {
+            field = line.slice(0, colon);
+            value = line.slice(colon + 1);
+            // EXACTLY ONE leading space is stripped, per spec. `data:  x` carries a
+            // value of ` x`, and trimming would corrupt payloads whose JSON was
+            // pretty-printed or whose text legitimately begins with whitespace.
+            if (value.startsWith(' '))
+                value = value.slice(1);
+        }
+        switch (field) {
+            case 'event':
+                this.eventType = value;
+                break;
+            case 'data':
+                // Multiple `data:` lines concatenate with `\n` between them. This is
+                // what makes a JSON payload containing a newline transmissible, and
+                // getting it wrong turns a multi-line frame into unparseable JSON.
+                this.data += value + '\n';
+                break;
+            case 'id':
+                // Per spec, an id containing a NUL is ignored rather than honoured.
+                if (!value.includes('\0')) {
+                    this.frameId = value;
+                    this.lastEventId = value;
+                }
+                break;
+            case 'retry':
+                // Digits only. `retry: soon` is ignored rather than becoming `NaN` and
+                // poisoning the backoff arithmetic into scheduling a reconnect that
+                // never fires.
+                if (/^\d+$/.test(value))
+                    this.retryMs = Number(value);
+                break;
+            default:
+                // Unknown field. Ignored, per spec — that is what makes it safe for the
+                // server to add fields later.
+                break;
+        }
+    }
+    dispatch() {
+        // AN EMPTY DATA BUFFER DISPATCHES NOTHING. Per spec, and load-bearing here:
+        // a run of blank lines, or a blank line following a comment-only exchange,
+        // must not manufacture an empty `message` event that a consumer then tries
+        // to `JSON.parse`.
+        if (this.data === '') {
+            this.eventType = '';
+            this.frameId = null;
+            return null;
+        }
+        const frame = {
+            event: this.eventType === '' ? 'message' : this.eventType,
+            // Strip the ONE trailing newline the accumulation above always adds.
+            // `trimEnd()` would be wrong: a payload legitimately ending in a blank
+            // line would lose it.
+            data: this.data.slice(0, -1),
+            id: this.frameId,
+        };
+        this.eventType = '';
+        this.data = '';
+        this.frameId = null;
+        return frame;
+    }
+}
+/**
+ * First reconnect delay. Doubles per consecutive failure up to the cap.
+ *
+ * The server may override it with a `retry:` directive; it sends none today.
+ */
+const RECONNECT_BASE_MS = 1_000;
+/**
+ * The backoff ceiling.
+ *
+ * 30 seconds, chosen against the heartbeat rather than plucked: the server
+ * proves liveness every 25s (`HEARTBEAT_INTERVAL_MS`), so a ceiling in the same
+ * order of magnitude means a tab recovers from a backend restart within about
+ * one heartbeat period of it coming back, while a hundred idle tabs still cost
+ * the backend only a handful of connection attempts per second between them.
+ */
+const RECONNECT_MAX_MS = 30_000;
+/**
+ * How long a connection must survive before its success is believed.
+ *
+ * A connection is judged by how long it LASTED, not by whether it connected —
+ * see `registerOutcome`, which is the only thing that reads this. Ten seconds
+ * is comfortably longer than an accept-then-drop cycle and comfortably shorter
+ * than the 25-second heartbeat, so any stream that has received even one
+ * heartbeat is well past it.
+ */
+const STABLE_CONNECTION_MS = 10_000;
+/**
+ * Open an SSE connection and keep it open, reconnecting with backoff until
+ * `close()` is called.
+ *
+ * Returns synchronously; the connection is established in the background. The
+ * returned `close()` aborts an in-flight request, cancels a pending retry, and
+ * detaches every listener — it is what an effect cleanup calls, and it must
+ * remain safe to call at any point in the lifecycle, including before the first
+ * fetch has resolved.
+ *
+ * @stability experimental
+ */
+export function connectSse(options) {
+    const { url, authorization, reauthenticate, onOpen, onFrame, onStateChange } = options;
+    let closed = false;
+    let attempt = 0;
+    let controller = null;
+    // Resolver for an in-progress backoff sleep, so `close()` and the `online`
+    // event can cut a 30-second wait short instead of leaving the app
+    // disconnected long after the reason to be disconnected has gone.
+    let wake = null;
+    const setState = (state) => {
+        if (!closed || state === 'closed')
+            onStateChange?.(state);
+    };
+    /**
+     * The network came back.
+     *
+     * Reconnect IMMEDIATELY and from a clean slate: a laptop that slept for an
+     * hour wakes deep in the backoff ceiling, and without this the user stares at
+     * a stale bell for up to 30 seconds after their connection is demonstrably
+     * fine. The attempt counter is reset too, because the failures that produced
+     * it were all the same failure — no network — and it has just been fixed.
+     */
+    const onOnline = () => {
+        attempt = 0;
+        wake?.();
+    };
+    if (typeof window !== 'undefined') {
+        window.addEventListener('online', onOnline);
+    }
+    /** A backoff wait that `close()` or `online` can interrupt. */
+    const sleep = (ms) => new Promise((resolve) => {
+        const timer = setTimeout(finish, ms);
+        function finish() {
+            clearTimeout(timer);
+            wake = null;
+            resolve();
+        }
+        wake = finish;
+    });
+    /**
+     * How long to wait before attempt number `attempt`.
+     *
+     * Exponential, capped, and JITTERED. The jitter is not decoration: every tab
+     * of every user disconnects at the same instant when the API restarts, so an
+     * un-jittered backoff reconnects them all in the same millisecond and turns
+     * one restart into a thundering herd against a process that has just started.
+     * Spreading each delay across the upper half of its window keeps the average
+     * wait honest while smearing the arrivals.
+     */
+    const backoffMs = () => {
+        const base = parser.retryMs ?? RECONNECT_BASE_MS;
+        const capped = Math.min(RECONNECT_MAX_MS, base * 2 ** attempt);
+        return capped * (0.5 + Math.random() * 0.5);
+    };
+    // Hoisted so `backoffMs` can read a `retry:` directive from the connection
+    // that just dropped. Replaced per attempt — a parser holding half a frame
+    // from a dead connection must never prepend it to the next one's first frame.
+    let parser = new SseParser();
+    /**
+     * When the current attempt's stream opened, or `null` if it never did.
+     *
+     * At `connectSse` scope rather than inside `attemptOnce` because BOTH exit
+     * paths have to consult it and only one of them is inside that function: a
+     * stream can end cleanly (the server completing every subscriber during a
+     * rolling deploy) or blow up mid-read (a socket reset), and the second lands
+     * in `run`'s catch.
+     */
+    let openedAt = null;
+    /**
+     * Record how the attempt that just ended went, for the backoff.
+     *
+     * THE ONE PLACE `attempt` MOVES, and the reason it is a function rather than
+     * an `attempt = 0` at the moment of connection: resetting on OPEN would
+     * defeat the backoff against the worst failure mode there is. A server that
+     * accepts the connection and then immediately drops it — a proxy still
+     * buffering the stream, an API mid-restart, a load balancer with a dead
+     * upstream — would reset the counter on every accept, and the client would
+     * hammer a struggling backend once a second forever while every log said the
+     * connection was succeeding.
+     *
+     * So success is measured by DURATION, not by having connected at all: only a
+     * stream that actually held open for `STABLE_CONNECTION_MS` earns a reset.
+     */
+    const registerOutcome = () => {
+        const stable = openedAt !== null && Date.now() - openedAt >= STABLE_CONNECTION_MS;
+        attempt = stable ? 0 : attempt + 1;
+    };
+    /**
+     * One connection attempt, from fetch to end-of-stream.
+     *
+     * @returns `'retry'` to reconnect after a backoff, `'immediate'` to reconnect
+     *          without one (credentials were just renewed, so the failure is
+     *          already understood and fixed), or `'stop'` to end the loop.
+     */
+    const attemptOnce = async () => {
+        controller = new AbortController();
+        parser = new SseParser();
+        // Cleared per attempt: a stale `openedAt` from the previous connection
+        // would make a fetch that never connected look like a stable one.
+        openedAt = null;
+        const headers = { Accept: 'text/event-stream' };
+        const auth = authorization();
+        if (auth)
+            headers.Authorization = auth;
+        const response = await fetch(url, {
+            headers,
+            signal: controller.signal,
+            // The refresh cookie, matching `PlatformHttpClient.request`. The bearer header
+            // above is what actually authenticates this route; the cookie is here so
+            // the two code paths cannot diverge in what they present.
+            credentials: 'include',
+            // A stream must never be served from cache. Without this a proxy or the
+            // browser can hand back a completed copy of a previous response, and the
+            // client sits "connected" to a body that ended long ago.
+            cache: 'no-store',
+        });
+        if (response.status === 401) {
+            // THE EXPECTED FAILURE, not an exceptional one: this connection is
+            // designed to outlive a 15-minute access token, so every long-lived tab
+            // lands here eventually. Renew once and reconnect without a backoff — the
+            // cause is known and already fixed, so making the user wait would be
+            // arbitrary. If renewal fails the session is genuinely over and the loop
+            // stops rather than hammering a logged-out backend forever.
+            //
+            // The body is explicitly discarded: an unread body holds the connection
+            // in the pool until GC, and this path can run many times per session.
+            await response.body?.cancel().catch(() => { });
+            const renewed = await reauthenticate();
+            return renewed ? 'immediate' : 'stop';
+        }
+        if (!response.ok || !response.body) {
+            await response.body?.cancel().catch(() => { });
+            // Everything else — 502 from a restarting API, 404 from a bad deploy, a
+            // response with no body at all — is a plain retry. No status is treated
+            // as permanent except the 401 above, because a client that gives up on a
+            // 502 stays dead after the backend recovers.
+            throw new Error(`Stream responded ${response.status}`);
+        }
+        // HEADERS HAVE ARRIVED, so the path is proven end to end — through nginx,
+        // through the guard, into the handler. The API forces this moment by
+        // sending `: connected` immediately (Nest's `SseStream` defers headers
+        // until the first message, so a silent server would leave this `await`
+        // pending indefinitely and no `onOpen` would ever fire).
+        openedAt = Date.now();
+        setState('open');
+        onOpen();
+        const reader = response.body.getReader();
+        // `{ stream: true }` on every decode — see `SseParser.push`.
+        const decoder = new TextDecoder();
+        try {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                for (const frame of parser.push(decoder.decode(value, { stream: true }))) {
+                    onFrame(frame);
+                }
+            }
+        }
+        finally {
+            // Releasing the lock lets the body be collected even when the loop exits
+            // by abort rather than by end-of-stream.
+            reader.releaseLock();
+        }
+        // The server ended the stream — a rolling deploy calling `complete()` on
+        // every subscriber (`onModuleDestroy`), or an idle proxy giving up.
+        // Reconnect, forgiving the backoff only if the connection actually held.
+        registerOutcome();
+        return 'retry';
+    };
+    const run = async () => {
+        setState('connecting');
+        while (!closed) {
+            let outcome = 'retry';
+            try {
+                outcome = await attemptOnce();
+            }
+            catch {
+                // EVERY failure lands here and is treated identically: an abort from
+                // `close()`, a DNS failure, a TLS error, a mid-stream socket reset. The
+                // `closed` check immediately below is what separates "we tore this
+                // down" from "the network did", and it is the only distinction that
+                // matters — nothing else changes what happens next, which is to wait
+                // and try again.
+                //
+                // Scored the same way a clean end is, so a connection that held for an
+                // hour and then had its socket reset retries promptly, while one that
+                // opens and explodes within a second backs off like any other failure.
+                registerOutcome();
+            }
+            if (closed)
+                break;
+            if (outcome === 'stop')
+                break;
+            setState('reconnecting');
+            if (outcome === 'retry')
+                await sleep(backoffMs());
+        }
+        setState('closed');
+    };
+    void run();
+    return {
+        close: () => {
+            // Idempotent: `closed` short-circuits, and abort/clearTimeout are both
+            // safe twice. React 18+ mounts effects twice in StrictMode, so a cleanup
+            // that could only run once would leave a second connection open in
+            // development and nowhere else — the worst possible place for a bug to
+            // hide.
+            if (closed)
+                return;
+            closed = true;
+            if (typeof window !== 'undefined') {
+                window.removeEventListener('online', onOnline);
+            }
+            // Cancel a pending backoff first so the loop wakes, observes `closed` and
+            // exits, rather than sitting on a timer for up to 30 seconds after the
+            // component that owned it has gone.
+            wake?.();
+            controller?.abort();
+        },
+    };
+}
+/**
+ * POST a JSON body and stream the `text/event-stream` answer, frame by frame.
+ *
+ * `connectSse` above is the wrong tool for a request/response stream and is
+ * deliberately left alone: it is GET-only, and it RECONNECTS — right for a
+ * notification feed that should live as long as the tab, exactly wrong for
+ * "generate one answer to this prompt", where a reconnect would re-submit the
+ * prompt and bill the user twice. So this is the other shape:
+ *
+ * - ONE request. No reconnect, ever. The promise resolves when the server ends
+ *   the stream.
+ * - ONE 401 retry, through `reauthenticate` — the same single refresh-and-retry
+ *   `PlatformHttpClient.request` does, so an access token that expired just before the
+ *   click does not surface as an error. A second 401 rejects.
+ * - A NON-2xx REJECTS WITH `ApiError`, the error every other call site already
+ *   catches, with `code`/`details` parsed from the JSON error body. The server
+ *   runs every gate (AI disabled, no key, model not enabled) BEFORE the first
+ *   byte precisely so those failures arrive here as ordinary JSON errors; a
+ *   failure AFTER streaming began arrives as a frame (`event: error`) instead,
+ *   and is the caller's to handle. Every non-2xx is handed to `onErrorResponse` on the
+ *   way past (the app's maintenance recogniser), exactly as the HTTP
+ *   client's `toError` does.
+ * - ABORT RESOLVES. A caller that aborts (a Stop button, an unmount) asked for
+ *   the stream to end; rejecting would make every such caller write a catch
+ *   that ignores `AbortError`.
+ *
+ * Same parser as `connectSse` (`SseParser`), same credential posture (a real
+ * `Authorization` header, never a token in the URL — see this file's header).
+ *
+ * @stability experimental
+ */
+export async function postSse(options) {
+    const { url, body, authorization, reauthenticate, onFrame, signal, onErrorResponse } = options;
+    const payload = JSON.stringify(body ?? {});
+    const send = () => {
+        const headers = {
+            'Content-Type': 'application/json',
+            Accept: 'text/event-stream',
+        };
+        const auth = authorization();
+        if (auth)
+            headers.Authorization = auth;
+        return fetch(url, {
+            method: 'POST',
+            headers,
+            body: payload,
+            signal,
+            credentials: 'include',
+            cache: 'no-store',
+        });
+    };
+    try {
+        let response = await send();
+        if (response.status === 401) {
+            await response.body?.cancel().catch(() => { });
+            await reauthenticate();
+            response = await send();
+        }
+        if (!response.ok) {
+            throw await toStreamError(response, onErrorResponse);
+        }
+        if (!response.body)
+            return;
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        const parser = new SseParser();
+        const deliver = (frames) => {
+            for (const frame of frames) {
+                onFrame(frame.event, parseFrameData(frame.data));
+            }
+        };
+        try {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                deliver(parser.push(decoder.decode(value, { stream: true })));
+            }
+            // Flush a final frame the server ended without a trailing newline on.
+            deliver(parser.push(decoder.decode() + '\n\n'));
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    catch (err) {
+        if (signal?.aborted || isAbortError(err))
+            return;
+        throw err;
+    }
+}
+function parseFrameData(data) {
+    try {
+        return JSON.parse(data);
+    }
+    catch {
+        return data;
+    }
+}
+function isAbortError(err) {
+    return (typeof err === 'object' &&
+        err !== null &&
+        'name' in err &&
+        err.name === 'AbortError');
+}
+async function toStreamError(response, onErrorResponse) {
+    const errorBody = (await response.json().catch(() => ({})));
+    onErrorResponse?.(response.status, errorBody);
+    return new ApiError(errorBody.message || `Stream responded ${response.status}`, response.status, errorBody.code, errorBody.details);
+}
+//# sourceMappingURL=sse.js.map

package/dist/core/http/sse.js.map

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

package/dist/core/index.d.ts

@@ -2,6 +2,14 @@ export { isPlatformApiError } from './api-client.js';
 export type { PlatformApiClient, PlatformApiError, PlatformBlobResponse, PlatformRequestOptions, PlatformSseOptions, } from './api-client.js';
 export type { PlatformViewer } from './viewer.js';
 export type { PlatformSettingsPage } from './settings-page.js';
-export { PlatformHostProvider, useOptionalPlatformHost, usePlatformApi, usePlatformHost, usePlatformViewer, } from './host.js';
+export { PageSlotsFrame, SLOT_DETAIL_PANEL_COLUMN_ID, SLOT_ROW_ACTIONS_COLUMN_ID, useTableSlotColumns } from './page-slots.js';
+export type { PageHeaderSlotProps, PageSectionsSlotProps, PageSlotsFrameProps, PageSlot, PageSlotsBase, SlotTableColumn, TableSlots, } from './page-slots.js';
+export { PlatformHostProvider, useOptionalPlatformHost, usePlatformApi, useOptionalPlatformPort, usePlatformHost, usePlatformPort, usePlatformViewer, } from './host.js';
 export type { PlatformWebHost } from './host.js';
+export { ApiError, PlatformHttpClient } from './http/client.js';
+export type { PlatformHttpBlobWithHeaders, PlatformHttpClientOptions, PlatformHttpErrorBody, PlatformHttpRequestOptions, SessionExpiredListener, } from './http/client.js';
+export { createPlatformApiClient, toHttpRequestOptions, toPlatformApiError } from './http/platform-api-client.js';
+export type { PlatformApiClientOptions } from './http/platform-api-client.js';
+export { SseParser, connectSse, postSse } from './http/sse.js';
+export type { PostSseErrorBody, PostSseOptions, SseConnection, SseFrame, SseOptions, SseState, } from './http/sse.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,YAAY,EACV,iBAAiB,EACjB,gBAAgB,EAChB,oBAAoB,EACpB,sBAAsB,EACtB,kBAAkB,GACnB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,YAAY,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAC/D,OAAO,EACL,oBAAoB,EACpB,uBAAuB,EACvB,cAAc,EACd,eAAe,EACf,iBAAiB,GAClB,MAAM,WAAW,CAAC;AACnB,YAAY,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,YAAY,EACV,iBAAiB,EACjB,gBAAgB,EAChB,oBAAoB,EACpB,sBAAsB,EACtB,kBAAkB,GACnB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,YAAY,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAI/D,OAAO,EAAE,cAAc,EAAE,2BAA2B,EAAE,0BAA0B,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAC/H,YAAY,EACV,mBAAmB,EACnB,qBAAqB,EACrB,mBAAmB,EACnB,QAAQ,EACR,aAAa,EACb,eAAe,EACf,UAAU,GACX,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,oBAAoB,EACpB,uBAAuB,EACvB,cAAc,EACd,uBAAuB,EACvB,eAAe,EACf,eAAe,EACf,iBAAiB,GAClB,MAAM,WAAW,CAAC;AACnB,YAAY,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAIjD,OAAO,EAAE,QAAQ,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAChE,YAAY,EACV,2BAA2B,EAC3B,yBAAyB,EACzB,qBAAqB,EACrB,0BAA0B,EAC1B,sBAAsB,GACvB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EAAE,uBAAuB,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAClH,YAAY,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAK9E,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAC/D,YAAY,EACV,gBAAgB,EAChB,cAAc,EACd,aAAa,EACb,QAAQ,EACR,UAAU,EACV,QAAQ,GACT,MAAM,eAAe,CAAC"}