@fntio/infra-client-plugin-sdk 0.0.0-stage → 0.2.0

package/dist/browser/client.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLUGIN_READY_INTERVAL_MS = exports.PLUGIN_REFRESH_LEAD_MS = exports.PLUGIN_REFRESH_TIMEOUT_MS = exports.PLUGIN_SDK_VERSION = void 0;
+exports.connectToInfraClient = connectToInfraClient;
+const messages_1 = require("../contracts/messages");
+const transport_1 = require("../contracts/transport");
+const errors_1 = require("./errors");
+const http_1 = require("./http");
+const theme_apply_1 = require("./theme-apply");
+exports.PLUGIN_SDK_VERSION = "0.2.0";
+exports.PLUGIN_REFRESH_TIMEOUT_MS = 15_000;
+exports.PLUGIN_REFRESH_LEAD_MS = 30_000;
+exports.PLUGIN_READY_INTERVAL_MS = 1_000;
+function resolveEnvironment(options) {
+    const g = globalThis;
+    if (!options.hostWindow && g.window && g.window.parent === g.window) {
+        throw new errors_1.PluginSdkError("not_framed", "this page is not inside the portal's plugin frame");
+    }
+    const hostWindow = options.hostWindow ?? g.window?.parent;
+    const listenOn = options.listenOn ?? g.window;
+    const hostOrigin = options.hostOrigin ?? g.window?.location.origin;
+    const fetchImpl = options.fetch ?? (typeof g.fetch === "function" ? (input, init) => g.fetch(input, init) : undefined);
+    const missing = [
+        !hostWindow && "hostWindow", !listenOn && "listenOn", !hostOrigin && "hostOrigin", !fetchImpl && "fetch",
+    ].filter((name) => typeof name === "string");
+    if (!hostWindow || !listenOn || !hostOrigin || !fetchImpl) {
+        throw new errors_1.PluginSdkError("invalid_options", `outside a browser window, pass ${missing.join(", ")}`);
+    }
+    const doc = g.document;
+    const applyTheme = options.applyTheme === false ? null : options.applyTheme ?? (doc ? (theme) => (0, theme_apply_1.applyPluginTheme)(theme, doc) : null);
+    return { hostWindow, hostOrigin, listenOn, fetch: fetchImpl, applyTheme };
+}
+/** Only messages from the host window at the expected origin count; everything else is invisible. */
+function fromHost(event, env) {
+    if (event.source !== env.hostWindow || event.origin !== env.hostOrigin)
+        return null;
+    return (0, messages_1.inspectPluginMessage)(event.data);
+}
+/** Announce to the host and resolve once `init` arrives. Rejects with `handshake_timeout` (call
+ *  again to retry), `incompatible_host`, `not_framed` or `invalid_options`. */
+function connectToInfraClient(options = {}) {
+    let env;
+    try {
+        env = resolveEnvironment(options);
+    }
+    catch (error) {
+        return Promise.reject(error);
+    }
+    const instanceId = options.instanceId ?? (0, transport_1.newPluginProtocolId)("frame");
+    const timeoutMs = options.handshakeTimeoutMs ?? messages_1.PLUGIN_HANDSHAKE_TIMEOUT_MS;
+    return new Promise((resolve, reject) => {
+        let ticker;
+        let timer;
+        const cleanup = () => {
+            env.listenOn.removeEventListener("message", listener);
+            clearInterval(ticker);
+            clearTimeout(timer);
+        };
+        const fail = (error) => {
+            cleanup();
+            reject(error);
+        };
+        const announce = () => {
+            try {
+                env.hostWindow.postMessage((0, messages_1.createPluginMessage)("ready", instanceId, { sdkVersion: exports.PLUGIN_SDK_VERSION, protocolVersion: messages_1.PLUGIN_PROTOCOL_VERSION }), env.hostOrigin);
+            }
+            catch (error) {
+                fail(new errors_1.PluginSdkError("invalid_options", `cannot post to the host: ${error instanceof Error ? error.message : String(error)}`));
+            }
+        };
+        const listener = (event) => {
+            const seen = fromHost(event, env);
+            if (!seen)
+                return;
+            if (seen.kind === "incompatible") {
+                fail(new errors_1.PluginSdkError("incompatible_host", `the host speaks protocol version ${String(seen.version)}`));
+                return;
+            }
+            if (seen.kind !== "message" || seen.message.type !== "init" || seen.message.instanceId !== instanceId)
+                return;
+            cleanup();
+            const client = new PluginClient(env, instanceId, seen.message.payload, options);
+            if (env.applyTheme) {
+                env.applyTheme(client.theme());
+                client.on("themeChanged", env.applyTheme);
+            }
+            resolve(client);
+        };
+        env.listenOn.addEventListener("message", listener);
+        ticker = setInterval(announce, exports.PLUGIN_READY_INTERVAL_MS);
+        if (timeoutMs > 0) {
+            timer = setTimeout(() => fail(new errors_1.PluginSdkError("handshake_timeout", `no init from the host within ${timeoutMs} ms`)), timeoutMs);
+        }
+        announce(); // last: a throwing first attempt must find the ticker and timer to clear
+    });
+}
+class PluginClient {
+    env;
+    instanceId;
+    user;
+    plugin;
+    entry;
+    session;
+    api;
+    current;
+    access;
+    currentTheme;
+    /** The expiry we already asked the host to renew past, so a host that answers with the same
+     *  session is not asked again on every request for the rest of the lead window. */
+    askedFor = null;
+    ended = false;
+    pending = null;
+    listeners = new Map();
+    refreshTimeoutMs;
+    refreshLeadMs;
+    listener;
+    constructor(env, instanceId, init, options) {
+        this.env = env;
+        this.instanceId = instanceId;
+        this.user = init.user;
+        this.plugin = init.plugin;
+        this.entry = init.entry;
+        this.current = init.session;
+        this.access = { accounts: init.accounts, entryAvailable: true };
+        this.currentTheme = init.theme;
+        this.refreshTimeoutMs = options.refreshTimeoutMs ?? exports.PLUGIN_REFRESH_TIMEOUT_MS;
+        this.refreshLeadMs = options.refreshLeadMs ?? exports.PLUGIN_REFRESH_LEAD_MS;
+        this.session = {
+            current: () => this.current,
+            token: () => this.tokenForRequest(),
+            refresh: (reason) => this.refresh(reason),
+        };
+        this.api = (0, http_1.createPluginApi)({
+            apiBaseUrl: init.plugin.apiBaseUrl,
+            tokens: this.session,
+            accounts: () => this.access.accounts,
+            fetch: env.fetch,
+            assertActive: () => this.assertActive(),
+            onForbidden: options.accessRefreshOnForbidden === false ? undefined : () => this.requestAccessRefresh("forbidden"),
+        });
+        this.listener = (event) => {
+            const seen = fromHost(event, env);
+            if (seen?.kind === "message" && seen.message.instanceId === instanceId && (0, messages_1.isHostToPluginMessage)(seen.message))
+                this.handle(seen.message);
+        };
+        env.listenOn.addEventListener("message", this.listener);
+    }
+    state() {
+        return this.ended ? "ended" : "connected";
+    }
+    accounts() {
+        return this.access.accounts;
+    }
+    permissionsFor(accountNumber) {
+        return this.access.accounts.find((a) => a.accountNumber === accountNumber)?.permissions ?? [];
+    }
+    hasPermission(permission, accountNumber) {
+        return this.permissionsFor(accountNumber).includes(permission);
+    }
+    entryAvailable() {
+        return this.access.entryAvailable;
+    }
+    theme() {
+        return this.currentTheme;
+    }
+    requestAccessRefresh(reason = "manual") {
+        if (this.ended)
+            return;
+        this.post("requestAccessRefresh", { reason });
+    }
+    on(event, listener) {
+        let set = this.listeners.get(event);
+        if (!set)
+            this.listeners.set(event, (set = new Set()));
+        set.add(listener);
+        return () => set.delete(listener);
+    }
+    dispose() {
+        if (this.ended)
+            return;
+        this.teardown();
+        this.pending?.reject(new errors_1.PluginSdkError("disposed", "the plugin context was disposed"));
+        this.listeners.clear();
+    }
+    assertActive() {
+        if (this.ended)
+            throw new errors_1.PluginSdkError("session_ended", "the host ended this session");
+    }
+    post(type, payload, requestId) {
+        this.env.hostWindow.postMessage((0, messages_1.createPluginMessage)(type, this.instanceId, payload, requestId), this.env.hostOrigin);
+    }
+    /** Expired: wait for the host. Expiring: renew in the background, the current token still
+     *  carries the request. Fresh: send. */
+    async tokenForRequest() {
+        this.assertActive();
+        const remaining = this.current.expiresAt - Date.now();
+        if (remaining <= 0) {
+            await this.refresh("expiring");
+        }
+        else if (remaining <= this.refreshLeadMs && this.askedFor !== this.current.expiresAt) {
+            this.askedFor = this.current.expiresAt;
+            void this.refresh("expiring").catch(() => undefined);
+        }
+        return this.current.token;
+    }
+    refresh(reason) {
+        if (this.ended)
+            return Promise.reject(new errors_1.PluginSdkError("session_ended", "the host ended this session"));
+        if (this.pending)
+            return this.pending.promise;
+        let settleResolve;
+        let settleReject;
+        const promise = new Promise((resolve, reject) => {
+            settleResolve = resolve;
+            settleReject = reject;
+        });
+        let timer;
+        const finish = () => {
+            clearTimeout(timer);
+            this.pending = null;
+        };
+        const pending = {
+            promise,
+            resolve: (session) => {
+                finish();
+                settleResolve(session);
+            },
+            reject: (error) => {
+                finish();
+                settleReject(error);
+            },
+        };
+        if (this.refreshTimeoutMs > 0) {
+            timer = setTimeout(() => pending.reject(new errors_1.PluginSdkError("refresh_timeout", `no session from the host within ${this.refreshTimeoutMs} ms`)), this.refreshTimeoutMs);
+        }
+        this.pending = pending;
+        this.post("requestSessionRefresh", { reason }, (0, transport_1.newPluginProtocolId)("req"));
+        return promise;
+    }
+    handle(message) {
+        switch (message.type) {
+            case "sessionChanged":
+                // The host owns session truth: whatever it sends after our request is the answer.
+                this.current = message.payload;
+                this.pending?.resolve(message.payload);
+                this.emit("sessionChanged", message.payload);
+                return;
+            case "sessionEnded":
+                this.teardown();
+                this.pending?.reject(new errors_1.PluginSdkError("session_ended", `the host ended this session (${message.payload.reason})`));
+                this.emit("sessionEnded", message.payload);
+                this.listeners.clear();
+                return;
+            case "accessChanged":
+                this.access = message.payload;
+                this.emit("accessChanged", message.payload);
+                return;
+            case "themeChanged":
+                this.currentTheme = message.payload;
+                this.emit("themeChanged", message.payload);
+                return;
+            default:
+                return; // a repeated `init` for this instance carries nothing new
+        }
+    }
+    /** After this, no host message reaches the client again: an old frame's session cannot come back. */
+    teardown() {
+        this.ended = true;
+        this.env.listenOn.removeEventListener("message", this.listener);
+    }
+    emit(event, payload) {
+        const set = this.listeners.get(event);
+        if (!set)
+            return;
+        for (const listener of [...set]) {
+            try {
+                listener(payload);
+            }
+            catch (error) {
+                const report = globalThis.reportError;
+                if (typeof report === "function")
+                    report(error);
+                else
+                    setTimeout(() => { throw error; }, 0);
+            }
+        }
+    }
+}

package/dist/browser/errors.d.ts

@@ -0,0 +1,14 @@
+export type PluginSdkErrorCode = "not_framed" | "invalid_options" | "handshake_timeout" | "incompatible_host" | "refresh_timeout" | "session_ended" | "disposed" | "invalid_url" | "timeout" | "http";
+export declare class PluginSdkError extends Error {
+    readonly code: PluginSdkErrorCode;
+    constructor(code: PluginSdkErrorCode, message: string);
+}
+/** A non-2xx response from a JSON helper. `body` is the parsed JSON, the text, or undefined. */
+export declare class PluginApiError extends PluginSdkError {
+    readonly status: number;
+    readonly method: string;
+    readonly url: string;
+    readonly body: unknown;
+    constructor(status: number, method: string, url: string, body: unknown);
+}
+export declare function isPluginSdkError(value: unknown, code?: PluginSdkErrorCode): value is PluginSdkError;

package/dist/browser/errors.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginApiError = exports.PluginSdkError = void 0;
+exports.isPluginSdkError = isPluginSdkError;
+class PluginSdkError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "PluginSdkError";
+    }
+}
+exports.PluginSdkError = PluginSdkError;
+/** A non-2xx response from a JSON helper. `body` is the parsed JSON, the text, or undefined. */
+class PluginApiError extends PluginSdkError {
+    status;
+    method;
+    url;
+    body;
+    constructor(status, method, url, body) {
+        super("http", `${method} ${url} failed with ${status}`);
+        this.status = status;
+        this.method = method;
+        this.url = url;
+        this.body = body;
+        this.name = "PluginApiError";
+    }
+}
+exports.PluginApiError = PluginApiError;
+function isPluginSdkError(value, code) {
+    return value instanceof PluginSdkError && (code === undefined || value.code === code);
+}

package/dist/browser/http.d.ts

@@ -0,0 +1,72 @@
+import { PluginAccountContext, PluginSession } from "../contracts/messages";
+export type PluginQuery = Record<string, string | number | boolean | undefined>;
+export interface PluginRequestOptions {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: BodyInit | null;
+    query?: PluginQuery;
+    signal?: AbortSignal;
+    /** Aborts the request, body read included (`PluginSdkError` code `timeout`). Never retried. */
+    timeoutMs?: number;
+}
+export type PluginJsonOptions = Omit<PluginRequestOptions, "method" | "body">;
+export interface PluginApi {
+    /** `fetch` from the iframe with the current bearer token attached, one retry after an
+     *  authentication-layer 401. Returns the raw `Response`; no status check. */
+    request(path: string, options?: PluginRequestOptions): Promise<Response>;
+    get<T = unknown>(path: string, options?: PluginJsonOptions): Promise<T>;
+    post<T = unknown>(path: string, body?: unknown, options?: PluginJsonOptions): Promise<T>;
+    put<T = unknown>(path: string, body?: unknown, options?: PluginJsonOptions): Promise<T>;
+    patch<T = unknown>(path: string, body?: unknown, options?: PluginJsonOptions): Promise<T>;
+    delete<T = unknown>(path: string, options?: PluginJsonOptions): Promise<T>;
+    /** The URL a plugin API path resolves to, for callers bringing their own HTTP client. */
+    url(path: string, query?: PluginQuery): string;
+}
+export interface PluginTokenProvider {
+    current(): PluginSession;
+    /** The current bearer token. Renewal through the host runs in the background while the token is
+     *  still valid and is awaited only once it has expired. */
+    token(): Promise<string>;
+    /** Ask the host to renew. Concurrent callers share one round trip. */
+    refresh(reason: "unauthorized" | "expiring"): Promise<PluginSession>;
+}
+export type FetchLike = (input: string, init: RequestInit) => Promise<Response>;
+export interface PluginApiDeps {
+    readonly apiBaseUrl: string;
+    readonly tokens: PluginTokenProvider;
+    readonly accounts: () => readonly PluginAccountContext[];
+    readonly fetch: FetchLike;
+    readonly assertActive: () => void;
+    readonly onForbidden?: () => void;
+}
+/** Relative paths under the plugin's own API root only, so a well-behaved plugin cannot send the bearer
+ *  token to another origin or the core API by mistake (a `..` segment would climb out). A guardrail, not
+ *  a boundary: the page is same-origin with the portal (README "Trust model"). */
+export declare function resolvePluginApiUrl(apiBaseUrl: string, path: string, query?: PluginQuery): string;
+export declare function isReplayableBody(body: unknown): boolean;
+/** The account a plugin API URL acts on: every route mounts under `<apiBaseUrl>/accounts/<accountNumber>`.
+ *  `null` for a URL outside that shape, which names no account. */
+export declare function pluginRequestAccount(apiBaseUrl: string, url: string): string | null;
+export interface UnauthorizedRefreshInput {
+    readonly body: unknown;
+    /** `pluginRequestAccount` of the request. */
+    readonly account: string | null;
+    /** The caller's accounts as they stand when the rule is asked, not as they stood at send. */
+    readonly permitted: readonly Pick<PluginAccountContext, "accountNumber">[];
+}
+export interface UnauthorizedRetryInput extends UnauthorizedRefreshInput {
+    readonly rejectedToken: string;
+    readonly retryToken: string;
+}
+/** Is a 401 worth asking the host to renew for? Only when the request could be sent again at all:
+ *  the body must be re-readable, and the account the request acts on must still be one the
+ *  caller may use (access can be revoked while the request or the renewal is in flight). A request
+ *  that names no account is not held to the list. */
+export declare function shouldRefreshAfterUnauthorized(input: UnauthorizedRefreshInput): boolean;
+/** The one rule for re-sending a request the authorizer rejected with 401 (`context.api` and the
+ *  Angular interceptor both use it): the renewal must have produced a different token, and the
+ *  conditions that allowed the refresh must still hold after it. An authorizer 401 is decided
+ *  before the plugin's handler runs, so that replay repeats nothing; a plugin whose own handler
+ *  answers 401 breaks that assumption, which is why handlers must use domain 4xx codes instead. */
+export declare function canRetryAfterUnauthorized(input: UnauthorizedRetryInput): boolean;
+export declare function createPluginApi(deps: PluginApiDeps): PluginApi;

package/dist/browser/http.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePluginApiUrl = resolvePluginApiUrl;
+exports.isReplayableBody = isReplayableBody;
+exports.pluginRequestAccount = pluginRequestAccount;
+exports.shouldRefreshAfterUnauthorized = shouldRefreshAfterUnauthorized;
+exports.canRetryAfterUnauthorized = canRetryAfterUnauthorized;
+exports.createPluginApi = createPluginApi;
+const errors_1 = require("./errors");
+/** Relative paths under the plugin's own API root only, so a well-behaved plugin cannot send the bearer
+ *  token to another origin or the core API by mistake (a `..` segment would climb out). A guardrail, not
+ *  a boundary: the page is same-origin with the portal (README "Trust model"). */
+function resolvePluginApiUrl(apiBaseUrl, path, query) {
+    const escapes = path.split(/[/?#]/).includes("..");
+    if (/^[a-z][a-z0-9+.-]*:/i.test(path) || path.startsWith("//") || escapes) {
+        throw new errors_1.PluginSdkError("invalid_url", `plugin API paths are relative to ${apiBaseUrl}; got ${path}`);
+    }
+    const relative = path.replace(/^\/+/, "");
+    const base = apiBaseUrl.replace(/\/+$/, "");
+    let url = relative ? `${base}/${relative}` : base;
+    if (query) {
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(query))
+            if (value !== undefined)
+                params.set(key, String(value));
+        const encoded = params.toString();
+        if (encoded)
+            url += (url.includes("?") ? "&" : "?") + encoded;
+    }
+    return url;
+}
+function isReplayableBody(body) {
+    return body == null || typeof body === "string" || typeof ReadableStream === "undefined" || !(body instanceof ReadableStream);
+}
+/** The account a plugin API URL acts on: every route mounts under `<apiBaseUrl>/accounts/<accountNumber>`.
+ *  `null` for a URL outside that shape, which names no account. */
+function pluginRequestAccount(apiBaseUrl, url) {
+    // Compared by path: one side may be written absolute and the other relative, and a mismatch in form
+    // must not read as "names no account", which would skip the revoked-account check.
+    const path = (value) => {
+        try {
+            return new URL(value, "http://plugin.invalid").pathname;
+        }
+        catch {
+            return value;
+        }
+    };
+    const base = path(apiBaseUrl).replace(/\/+$/, "");
+    const target = path(url);
+    if (!target.startsWith(`${base}/`))
+        return null;
+    return /^\/accounts\/(\d{12})(?:\/|$)/.exec(target.slice(base.length))?.[1] ?? null;
+}
+/** Is a 401 worth asking the host to renew for? Only when the request could be sent again at all:
+ *  the body must be re-readable, and the account the request acts on must still be one the
+ *  caller may use (access can be revoked while the request or the renewal is in flight). A request
+ *  that names no account is not held to the list. */
+function shouldRefreshAfterUnauthorized(input) {
+    return isReplayableBody(input.body) && (input.account === null || input.permitted.some((a) => a.accountNumber === input.account));
+}
+/** The one rule for re-sending a request the authorizer rejected with 401 (`context.api` and the
+ *  Angular interceptor both use it): the renewal must have produced a different token, and the
+ *  conditions that allowed the refresh must still hold after it. An authorizer 401 is decided
+ *  before the plugin's handler runs, so that replay repeats nothing; a plugin whose own handler
+ *  answers 401 breaks that assumption, which is why handlers must use domain 4xx codes instead. */
+function canRetryAfterUnauthorized(input) {
+    return shouldRefreshAfterUnauthorized(input) && input.rejectedToken !== input.retryToken;
+}
+const timedOut = () => new errors_1.PluginSdkError("timeout", "the request timed out");
+/** `AbortSignal.timeout`/`any` are recent (Safari 17.4, Firefox 124); fall back to a controller so a
+ *  plugin on an older browser gets the timeout rather than a TypeError. */
+function requestSignal(user, timeoutMs) {
+    if (!timeoutMs)
+        return user;
+    if (typeof AbortSignal.timeout === "function" && (!user || typeof AbortSignal.any === "function")) {
+        const timeout = AbortSignal.timeout(timeoutMs);
+        return user ? AbortSignal.any([user, timeout]) : timeout;
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(timedOut()), timeoutMs);
+    const forward = () => {
+        clearTimeout(timer);
+        controller.abort(user?.reason);
+    };
+    if (user?.aborted)
+        forward();
+    else
+        user?.addEventListener("abort", forward, { once: true });
+    return controller.signal;
+}
+/** `AbortSignal.timeout` rejects with a DOMException named TimeoutError; callers get the SDK code. */
+function mapTimeout(error) {
+    return typeof error === "object" && error !== null && error.name === "TimeoutError" ? timedOut() : error;
+}
+async function parseBody(response) {
+    if (response.status === 204 || response.status === 205)
+        return undefined;
+    const text = await response.text();
+    if (!text)
+        return undefined;
+    if (/json/i.test(response.headers.get("content-type") ?? "")) {
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return text;
+        }
+    }
+    return text;
+}
+function createPluginApi(deps) {
+    const url = (path, query) => resolvePluginApiUrl(deps.apiBaseUrl, path, query);
+    const perform = async (target, method, options) => {
+        deps.assertActive();
+        const replayable = () => ({ body: options.body, account: pluginRequestAccount(deps.apiBaseUrl, target), permitted: deps.accounts() });
+        const signal = requestSignal(options.signal, options.timeoutMs);
+        const send = (token) => deps.fetch(target, {
+            method,
+            headers: { ...options.headers, Authorization: `Bearer ${token}` },
+            body: options.body ?? undefined,
+            signal,
+        });
+        try {
+            const token = await deps.tokens.token();
+            let response = await send(token);
+            if (response.status === 401 && shouldRefreshAfterUnauthorized(replayable())) {
+                deps.assertActive();
+                const renewed = await deps.tokens.refresh("unauthorized");
+                if (canRetryAfterUnauthorized({ ...replayable(), rejectedToken: token, retryToken: renewed.token }))
+                    response = await send(renewed.token);
+            }
+            if (response.status === 403)
+                deps.onForbidden?.();
+            return response;
+        }
+        catch (error) {
+            throw mapTimeout(error);
+        }
+    };
+    const request = (path, options = {}) => perform(url(path, options.query), (options.method ?? "GET").toUpperCase(), options);
+    const json = async (method, path, body, options = {}) => {
+        const target = url(path, options.query);
+        const headers = { Accept: "application/json", ...options.headers };
+        let payload;
+        if (body !== undefined) {
+            headers["Content-Type"] = "application/json";
+            payload = JSON.stringify(body);
+        }
+        const response = await perform(target, method, { ...options, headers, body: payload });
+        let parsed;
+        try {
+            parsed = await parseBody(response);
+        }
+        catch (error) {
+            throw mapTimeout(error);
+        }
+        if (!response.ok)
+            throw new errors_1.PluginApiError(response.status, method, target, parsed);
+        return parsed;
+    };
+    return {
+        request,
+        url,
+        get: (path, options) => json("GET", path, undefined, options),
+        post: (path, body, options) => json("POST", path, body, options),
+        put: (path, body, options) => json("PUT", path, body, options),
+        patch: (path, body, options) => json("PATCH", path, body, options),
+        delete: (path, options) => json("DELETE", path, undefined, options),
+    };
+}

package/dist/browser/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./client";
+export * from "./http";
+export * from "./errors";
+export * from "./theme-apply";
+export * from "../contracts/messages";
+export * from "../contracts/theme";
+export * from "../contracts/transport";
+export * from "../contracts/discovery";
+export { pluginApiBaseUrl } from "../contracts/paths";
+export type { PluginPermission, PluginRouteMethod } from "../contracts/manifest";
+export type { PluginPrincipalType } from "../contracts/authorizer";

package/dist/browser/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pluginApiBaseUrl = void 0;
+// Entry point for plugin frontends. Must stay free of Node, CDK and AWS server imports.
+__exportStar(require("./client"), exports);
+__exportStar(require("./http"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./theme-apply"), exports);
+__exportStar(require("../contracts/messages"), exports);
+__exportStar(require("../contracts/theme"), exports);
+__exportStar(require("../contracts/transport"), exports);
+__exportStar(require("../contracts/discovery"), exports);
+var paths_1 = require("../contracts/paths");
+Object.defineProperty(exports, "pluginApiBaseUrl", { enumerable: true, get: function () { return paths_1.pluginApiBaseUrl; } });

package/dist/browser/theme-apply.d.ts

@@ -0,0 +1,22 @@
+import { PluginTheme } from "../contracts/theme";
+export declare const PLUGIN_THEME_STYLE_ID = "infra-client-plugin-theme";
+export interface PluginThemeNode {
+    textContent: string | null;
+}
+export interface PluginThemeStyleElement extends PluginThemeNode {
+    id: string;
+}
+/** The slice of `Document` theme application touches; a real `Document` satisfies it. */
+export interface PluginThemeDocument {
+    readonly documentElement: {
+        setAttribute(name: string, value: string): void;
+    };
+    readonly head: {
+        appendChild(node: PluginThemeNode): unknown;
+    };
+    getElementById(id: string): PluginThemeNode | null;
+    createElement(tagName: "style"): PluginThemeStyleElement;
+}
+/** Writes the theme into one `<style>` element (replaced on every call) and stamps
+ *  `data-theme="light|dark"` on the root element for appearance-specific plugin CSS. */
+export declare function applyPluginTheme(theme: PluginTheme, doc: PluginThemeDocument): void;

package/dist/browser/theme-apply.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLUGIN_THEME_STYLE_ID = void 0;
+exports.applyPluginTheme = applyPluginTheme;
+const theme_1 = require("../contracts/theme");
+exports.PLUGIN_THEME_STYLE_ID = "infra-client-plugin-theme";
+/** Writes the theme into one `<style>` element (replaced on every call) and stamps
+ *  `data-theme="light|dark"` on the root element for appearance-specific plugin CSS. */
+function applyPluginTheme(theme, doc) {
+    const css = (0, theme_1.pluginThemeCss)(theme);
+    const existing = doc.getElementById(exports.PLUGIN_THEME_STYLE_ID);
+    if (existing) {
+        existing.textContent = css;
+    }
+    else {
+        const element = doc.createElement("style");
+        element.id = exports.PLUGIN_THEME_STYLE_ID;
+        element.textContent = css;
+        doc.head.appendChild(element);
+    }
+    doc.documentElement.setAttribute("data-theme", theme.appearance);
+}