@rose42/t3-feedback 0.1.0

package/dist/client/openInT3.d.ts

@@ -0,0 +1,28 @@
+import type { T3FeedbackOpenHandoff } from "../types.js";
+/** Named window reused so pair → thread stays in one tab. */
+export declare const T3_OPEN_WINDOW_NAME = "t3-code";
+/**
+ * Delay between opening `/pair#token=…` and navigating to the thread.
+ * Long enough for local auto-pair; short enough to feel snappy when already paired.
+ */
+export declare const T3_PAIR_THEN_THREAD_DELAY_MS = 1800;
+export type OpenInT3SeamlessOptions = {
+    threadId: string;
+    /** Bare thread URL used when minting fails or as progressive-enhancement href. */
+    fallbackUrl: string;
+    /** Vite middleware base, e.g. `/__t3-feedback`. */
+    endpoint: string;
+    fetchFn?: typeof fetch;
+    openWindow?: typeof window.open;
+    delayMs?: number;
+    schedule?: (fn: () => void, ms: number) => ReturnType<typeof setTimeout>;
+};
+/** Fetch a fresh pair+thread handoff from the Vite plugin. */
+export declare function fetchOpenHandoff(endpoint: string, threadId: string, fetchFn?: typeof fetch): Promise<T3FeedbackOpenHandoff>;
+/**
+ * Open T3 seamlessly: mint a one-time pairing link, open it in a named window,
+ * then navigate that window to the thread deep link.
+ */
+export declare function openInT3Seamless(options: OpenInT3SeamlessOptions): Promise<void>;
+/** True when the click should use the default browser link behavior (new tab modifiers). */
+export declare function shouldBypassSeamlessOpen(event: Pick<MouseEvent, "button" | "metaKey" | "ctrlKey" | "shiftKey" | "altKey">): boolean;

package/dist/client/openInT3.js

@@ -0,0 +1,81 @@
+/** Named window reused so pair → thread stays in one tab. */
+export const T3_OPEN_WINDOW_NAME = "t3-code";
+/**
+ * Delay between opening `/pair#token=…` and navigating to the thread.
+ * Long enough for local auto-pair; short enough to feel snappy when already paired.
+ */
+export const T3_PAIR_THEN_THREAD_DELAY_MS = 1800;
+function isHandoff(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const record = value;
+    return (typeof record.pairUrl === "string" &&
+        record.pairUrl.trim().length > 0 &&
+        typeof record.threadUrl === "string" &&
+        record.threadUrl.trim().length > 0);
+}
+/** Fetch a fresh pair+thread handoff from the Vite plugin. */
+export async function fetchOpenHandoff(endpoint, threadId, fetchFn = fetch) {
+    const params = new URLSearchParams({ threadId });
+    const res = await fetchFn(`${endpoint}/open?${params.toString()}`, {
+        headers: { Accept: "application/json" },
+    });
+    let parsed;
+    try {
+        parsed = await res.json();
+    }
+    catch {
+        parsed = undefined;
+    }
+    if (!res.ok || !isHandoff(parsed)) {
+        const errMsg = parsed &&
+            typeof parsed === "object" &&
+            "error" in parsed &&
+            typeof parsed.error === "string"
+            ? parsed.error
+            : `HTTP ${res.status}`;
+        throw new Error(errMsg);
+    }
+    return {
+        pairUrl: parsed.pairUrl.trim(),
+        threadUrl: parsed.threadUrl.trim(),
+        environmentId: typeof parsed.environmentId === "string"
+            ? parsed.environmentId.trim()
+            : "",
+    };
+}
+/**
+ * Open T3 seamlessly: mint a one-time pairing link, open it in a named window,
+ * then navigate that window to the thread deep link.
+ */
+export async function openInT3Seamless(options) {
+    const { threadId, fallbackUrl, endpoint, fetchFn = fetch, openWindow = ((url, target, features) => features === undefined
+        ? window.open(url, target)
+        : window.open(url, target, features)), delayMs = T3_PAIR_THEN_THREAD_DELAY_MS, schedule = setTimeout, } = options;
+    let handoff;
+    try {
+        handoff = await fetchOpenHandoff(endpoint, threadId, fetchFn);
+    }
+    catch {
+        openWindow(fallbackUrl, T3_OPEN_WINDOW_NAME);
+        return;
+    }
+    const pairWin = openWindow(handoff.pairUrl, T3_OPEN_WINDOW_NAME);
+    const threadUrl = handoff.threadUrl;
+    schedule(() => {
+        try {
+            if (pairWin && !pairWin.closed) {
+                pairWin.location.href = threadUrl;
+                return;
+            }
+        }
+        catch {
+            // Cross-origin or closed — fall through to named reopen.
+        }
+        openWindow(threadUrl, T3_OPEN_WINDOW_NAME);
+    }, delayMs);
+}
+/** True when the click should use the default browser link behavior (new tab modifiers). */
+export function shouldBypassSeamlessOpen(event) {
+    return event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey;
+}

package/dist/client/readClipboardImage.d.ts

@@ -0,0 +1,2 @@
+/** Re-export headless clipboard helper from `@rose42/feedback-capture`. */
+export { readClipboardImageDataUrl } from "@rose42/feedback-capture";

package/dist/client/readClipboardImage.js

@@ -0,0 +1,2 @@
+/** Re-export headless clipboard helper from `@rose42/feedback-capture`. */
+export { readClipboardImageDataUrl } from "@rose42/feedback-capture";

package/dist/client/reportType.d.ts

@@ -0,0 +1,43 @@
+import type { FeedbackCapturePlugin, PageContext } from "@rose42/feedback-capture";
+export type FeedbackReportType = "bug" | "feedback" | "suggestion";
+/** Console ring buffer — full diagnostics (bug) only. */
+export declare const CONSOLE_LOGS_REPORT_TYPES: readonly ["bug"];
+/** App version — bug + UX reaction; omitted from lighter suggestions. */
+export declare const VERSION_REPORT_TYPES: readonly ["bug", "feedback"];
+/**
+ * Page-context fields kept per report type.
+ * - bug (full diagnostics): URL, viewport, UA, capturedAt
+ * - feedback (UX reaction): URL, viewport, capturedAt — no UA
+ * - suggestion (lighter product input): URL only
+ */
+export type PageContextForReport = {
+    url: string;
+    userAgent?: string;
+    viewport?: PageContext["viewport"];
+    capturedAt?: string;
+};
+/** Narrow a full page snapshot to the fields active for `reportType`. */
+export declare function pageContextForReportType(full: PageContext, reportType: FeedbackReportType): PageContextForReport;
+/** Which collect builtins are registered (drives report-type hint text). */
+export type ReportTypeHintCapabilities = {
+    pageContext: boolean;
+    consoleLogs: boolean;
+    /** Screenshot gallery / attachment uploads. */
+    attachments: boolean;
+};
+/**
+ * Panel hint for a report type, derived from registered plugins + page-context
+ * field filtering (same rules as collect).
+ */
+export declare function buildReportTypeHint(reportType: FeedbackReportType, caps: ReportTypeHintCapabilities): string;
+/** True when a plugin should collect for the given report type. */
+export declare function pluginAppliesToReportType(plugin: {
+    reportTypes?: readonly FeedbackReportType[];
+}, reportType: FeedbackReportType): boolean;
+/**
+ * Wrap `collect` so the plugin is omitted from the envelope when the selected
+ * report type is outside `reportTypes`.
+ */
+export declare function gatePluginByReportType<P extends FeedbackCapturePlugin & {
+    reportTypes?: readonly FeedbackReportType[];
+}>(plugin: P, getReportType: () => FeedbackReportType): P;

package/dist/client/reportType.js

@@ -0,0 +1,110 @@
+/** Console ring buffer — full diagnostics (bug) only. */
+export const CONSOLE_LOGS_REPORT_TYPES = ["bug"];
+/** App version — bug + UX reaction; omitted from lighter suggestions. */
+export const VERSION_REPORT_TYPES = [
+    "bug",
+    "feedback",
+];
+const REPORT_TYPE_PROFILE_TITLE = {
+    bug: "Full diagnostics",
+    feedback: "UX reaction",
+    suggestion: "Lighter product input",
+};
+/** Narrow a full page snapshot to the fields active for `reportType`. */
+export function pageContextForReportType(full, reportType) {
+    if (reportType === "suggestion") {
+        return { url: full.url };
+    }
+    if (reportType === "feedback") {
+        return {
+            url: full.url,
+            viewport: full.viewport,
+            capturedAt: full.capturedAt,
+        };
+    }
+    return {
+        url: full.url,
+        userAgent: full.userAgent,
+        viewport: full.viewport,
+        capturedAt: full.capturedAt,
+    };
+}
+function formatHintList(items, joiner = "and") {
+    if (items.length === 0)
+        return "";
+    if (items.length === 1)
+        return items[0];
+    if (items.length === 2)
+        return `${items[0]} ${joiner} ${items[1]}`;
+    return `${items.slice(0, -1).join(", ")}, ${joiner} ${items.at(-1)}`;
+}
+/**
+ * Panel hint for a report type, derived from registered plugins + page-context
+ * field filtering (same rules as collect).
+ */
+export function buildReportTypeHint(reportType, caps) {
+    const included = [];
+    const omitted = [];
+    if (caps.pageContext) {
+        included.push("URL");
+        const fields = pageContextForReportType({
+            url: "x",
+            userAgent: "x",
+            viewport: { width: 1, height: 1, devicePixelRatio: 1 },
+            capturedAt: "x",
+        }, reportType);
+        if (fields.viewport)
+            included.push("viewport");
+        else
+            omitted.push("viewport");
+        if (fields.userAgent)
+            included.push("UA");
+        else
+            omitted.push("UA");
+    }
+    if (caps.consoleLogs) {
+        if (pluginAppliesToReportType({ reportTypes: CONSOLE_LOGS_REPORT_TYPES }, reportType)) {
+            included.push("console logs");
+        }
+        else {
+            omitted.push("console");
+        }
+    }
+    if (caps.attachments) {
+        included.push("attachments");
+    }
+    const title = REPORT_TYPE_PROFILE_TITLE[reportType];
+    const list = formatHintList(included);
+    if (!list)
+        return `${title}.`;
+    if (reportType === "suggestion") {
+        return `${title}: ${list} only.`;
+    }
+    if (omitted.length > 0) {
+        return `${title}: ${list} - no ${formatHintList(omitted, "or")}.`;
+    }
+    return `${title}: ${list}.`;
+}
+/** True when a plugin should collect for the given report type. */
+export function pluginAppliesToReportType(plugin, reportType) {
+    const allowed = plugin.reportTypes;
+    if (!allowed || allowed.length === 0)
+        return true;
+    return allowed.includes(reportType);
+}
+/**
+ * Wrap `collect` so the plugin is omitted from the envelope when the selected
+ * report type is outside `reportTypes`.
+ */
+export function gatePluginByReportType(plugin, getReportType) {
+    if (!plugin.reportTypes?.length)
+        return plugin;
+    return {
+        ...plugin,
+        collect: async () => {
+            if (!pluginAppliesToReportType(plugin, getReportType()))
+                return undefined;
+            return plugin.collect();
+        },
+    };
+}

package/dist/client/selectBurstFrames.d.ts

@@ -0,0 +1,21 @@
+export type SelectBurstFramesCopy = {
+    hint: string;
+    confirmLabel: string;
+    cancelLabel: string;
+};
+export type SelectBurstFramesOptions = {
+    parent: HTMLElement;
+    frames: Array<{
+        dataUrl: string;
+    }>;
+    /** Max frames the user may select (remaining gallery slots). */
+    maxSelect: number;
+    /** Indices pre-checked (clamped to maxSelect). Default: first maxSelect. */
+    initiallySelected?: number[];
+    copy?: Partial<SelectBurstFramesCopy>;
+};
+/**
+ * Fullscreen filmstrip: toggle frames, confirm returns selected data URLs (time order).
+ * Cancel / Esc → `null`.
+ */
+export declare function selectBurstFrames(options: SelectBurstFramesOptions): Promise<string[] | null>;

package/dist/client/selectBurstFrames.js

@@ -0,0 +1,101 @@
+const DEFAULT_COPY = {
+    hint: "Select frames to attach. Click to toggle.",
+    confirmLabel: "Add selected",
+    cancelLabel: "Cancel",
+};
+function escapeHtml(value) {
+    return value
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;");
+}
+/**
+ * Fullscreen filmstrip: toggle frames, confirm returns selected data URLs (time order).
+ * Cancel / Esc → `null`.
+ */
+export function selectBurstFrames(options) {
+    const copy = { ...DEFAULT_COPY, ...options.copy };
+    const maxSelect = Math.max(0, Math.floor(options.maxSelect));
+    const selected = new Set();
+    if (options.initiallySelected?.length) {
+        for (const index of options.initiallySelected) {
+            if (index >= 0 && index < options.frames.length && selected.size < maxSelect) {
+                selected.add(index);
+            }
+        }
+    }
+    else {
+        const pre = Math.min(maxSelect, options.frames.length);
+        for (let i = 0; i < pre; i++)
+            selected.add(i);
+    }
+    return new Promise((resolve) => {
+        const overlay = document.createElement("div");
+        overlay.className = "t3f-burst-overlay";
+        overlay.setAttribute("role", "dialog");
+        overlay.setAttribute("aria-label", "Select frames");
+        overlay.innerHTML = `
+      <div class="t3f-burst-card">
+        <div class="t3f-burst-hint">${escapeHtml(copy.hint)}</div>
+        <div class="t3f-burst-meta"></div>
+        <div class="t3f-burst-strip"></div>
+        <div class="t3f-burst-actions">
+          <button type="button" class="t3f-btn" data-act="burst-cancel">${escapeHtml(copy.cancelLabel)}</button>
+          <button type="button" class="t3f-btn primary" data-act="burst-ok">${escapeHtml(copy.confirmLabel)}</button>
+        </div>
+      </div>
+    `;
+        const strip = overlay.querySelector(".t3f-burst-strip");
+        const meta = overlay.querySelector(".t3f-burst-meta");
+        const okBtn = overlay.querySelector('[data-act="burst-ok"]');
+        const syncMeta = () => {
+            meta.textContent = `${selected.size} / ${maxSelect} selected`;
+            okBtn.disabled = selected.size === 0;
+        };
+        const render = () => {
+            strip.replaceChildren();
+            options.frames.forEach((frame, index) => {
+                const btn = document.createElement("button");
+                btn.type = "button";
+                btn.className = "t3f-burst-item";
+                btn.setAttribute("aria-pressed", selected.has(index) ? "true" : "false");
+                const img = document.createElement("img");
+                img.src = frame.dataUrl;
+                img.alt = `Frame ${index + 1}`;
+                btn.append(img);
+                btn.addEventListener("click", () => {
+                    if (selected.has(index))
+                        selected.delete(index);
+                    else if (selected.size < maxSelect)
+                        selected.add(index);
+                    render();
+                });
+                strip.append(btn);
+            });
+            syncMeta();
+        };
+        const finish = (urls) => {
+            window.removeEventListener("keydown", onKeyDown, true);
+            overlay.remove();
+            resolve(urls);
+        };
+        const onKeyDown = (event) => {
+            if (event.key === "Escape") {
+                event.preventDefault();
+                event.stopImmediatePropagation();
+                finish(null);
+            }
+        };
+        overlay.querySelector('[data-act="burst-cancel"]')?.addEventListener("click", () => {
+            finish(null);
+        });
+        okBtn.addEventListener("click", () => {
+            const urls = [...selected].sort((a, b) => a - b).map((i) => options.frames[i].dataUrl);
+            finish(urls);
+        });
+        window.addEventListener("keydown", onKeyDown, true);
+        render();
+        options.parent.appendChild(overlay);
+    });
+}

package/dist/client/sessionThread.d.ts

@@ -0,0 +1,26 @@
+/** How long a prior send stays the soft-default “Continue” target. */
+export declare const SESSION_THREAD_TTL_MS: number;
+export type SessionThreadReportType = "bug" | "feedback" | "suggestion";
+/** Persisted sticky-within-route thread metadata (ask / session-route reuse). */
+export type SessionThreadRecord = {
+    threadId: string;
+    threadTitle: string;
+    reportType?: SessionThreadReportType;
+    lastSentAt: number;
+};
+export type ThreadDestination = "new" | "continue";
+/** sessionStorage key for the sticky-within-route thread record. */
+export declare function sessionThreadStorageKey(pathname: string): string;
+export declare function readSessionThreadRecord(pathname: string): SessionThreadRecord | undefined;
+/** @deprecated Prefer {@link readSessionThreadRecord}. */
+export declare function readSessionThreadId(pathname: string): string | undefined;
+export declare function writeSessionThreadRecord(pathname: string, record: SessionThreadRecord): void;
+/** @deprecated Prefer {@link writeSessionThreadRecord}. */
+export declare function writeSessionThreadId(pathname: string, threadId: string): void;
+/**
+ * Soft default for New vs Continue.
+ * Prefer Continue only when the last send on this route looks like the same job:
+ * within TTL and same report type. Never hides Continue when a record exists —
+ * callers still offer it; this only picks the default.
+ */
+export declare function defaultThreadDestination(record: SessionThreadRecord | undefined, reportType: SessionThreadReportType, now?: number, ttlMs?: number): ThreadDestination;

package/dist/client/sessionThread.js

@@ -0,0 +1,93 @@
+const STORAGE_PREFIX = "t3-feedback:thread:";
+/** How long a prior send stays the soft-default “Continue” target. */
+export const SESSION_THREAD_TTL_MS = 15 * 60 * 1000;
+/** sessionStorage key for the sticky-within-route thread record. */
+export function sessionThreadStorageKey(pathname) {
+    return `${STORAGE_PREFIX}${pathname || "/"}`;
+}
+function isReportType(value) {
+    return value === "bug" || value === "feedback" || value === "suggestion";
+}
+function parseRecord(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return undefined;
+    if (trimmed.startsWith("{")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            const threadId = typeof parsed.threadId === "string" ? parsed.threadId.trim() : "";
+            if (!threadId)
+                return undefined;
+            const threadTitle = typeof parsed.threadTitle === "string" ? parsed.threadTitle.trim() : "";
+            const lastSentAt = typeof parsed.lastSentAt === "number" && Number.isFinite(parsed.lastSentAt)
+                ? parsed.lastSentAt
+                : 0;
+            return {
+                threadId,
+                threadTitle,
+                lastSentAt,
+                ...(isReportType(parsed.reportType) ? { reportType: parsed.reportType } : {}),
+            };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    // Legacy: plain thread id string.
+    return {
+        threadId: trimmed,
+        threadTitle: "",
+        lastSentAt: 0,
+    };
+}
+export function readSessionThreadRecord(pathname) {
+    try {
+        const value = sessionStorage.getItem(sessionThreadStorageKey(pathname));
+        if (!value)
+            return undefined;
+        return parseRecord(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** @deprecated Prefer {@link readSessionThreadRecord}. */
+export function readSessionThreadId(pathname) {
+    return readSessionThreadRecord(pathname)?.threadId;
+}
+export function writeSessionThreadRecord(pathname, record) {
+    try {
+        sessionStorage.setItem(sessionThreadStorageKey(pathname), JSON.stringify({
+            threadId: record.threadId,
+            threadTitle: record.threadTitle,
+            lastSentAt: record.lastSentAt,
+            ...(record.reportType ? { reportType: record.reportType } : {}),
+        }));
+    }
+    catch {
+        // Private mode / quota — reuse is best-effort.
+    }
+}
+/** @deprecated Prefer {@link writeSessionThreadRecord}. */
+export function writeSessionThreadId(pathname, threadId) {
+    writeSessionThreadRecord(pathname, {
+        threadId,
+        threadTitle: "",
+        lastSentAt: Date.now(),
+    });
+}
+/**
+ * Soft default for New vs Continue.
+ * Prefer Continue only when the last send on this route looks like the same job:
+ * within TTL and same report type. Never hides Continue when a record exists —
+ * callers still offer it; this only picks the default.
+ */
+export function defaultThreadDestination(record, reportType, now = Date.now(), ttlMs = SESSION_THREAD_TTL_MS) {
+    if (!record)
+        return "new";
+    if (now - record.lastSentAt > ttlMs)
+        return "new";
+    if (record.reportType !== reportType)
+        return "new";
+    return "continue";
+}

package/dist/client/threadPicker.d.ts

@@ -0,0 +1,20 @@
+import type { ThreadListItem } from "../types.js";
+/** Soft cap so huge projects stay scrollable without dumping hundreds of DOM nodes. */
+export declare const THREAD_PICKER_LIMIT = 48;
+export type FilterThreadListResult = {
+    items: ThreadListItem[];
+    /** Total matches before the display limit. */
+    matchedCount: number;
+    /** Working/open matches before the display limit. */
+    openMatchedCount: number;
+};
+/** Default search seed for the continue picker (route-shaped titles). */
+export declare function defaultThreadSearchQuery(pathname: string): string;
+/**
+ * Filter + rank threads for the continue picker.
+ * Selected id is pinned first; open/working next; then updatedAt desc / title.
+ */
+export declare function filterThreadListItems(items: ThreadListItem[], query: string, options?: {
+    selectedId?: string;
+    limit?: number;
+}): FilterThreadListResult;

package/dist/client/threadPicker.js

@@ -0,0 +1,51 @@
+/** Soft cap so huge projects stay scrollable without dumping hundreds of DOM nodes. */
+export const THREAD_PICKER_LIMIT = 48;
+/** Default search seed for the continue picker (route-shaped titles). */
+export function defaultThreadSearchQuery(pathname) {
+    const trimmed = pathname.trim();
+    return trimmed.length > 0 ? trimmed : "/";
+}
+function stateRank(state) {
+    if (state === "working")
+        return 0;
+    if (state === "unknown")
+        return 1;
+    return 2;
+}
+/**
+ * Filter + rank threads for the continue picker.
+ * Selected id is pinned first; open/working next; then updatedAt desc / title.
+ */
+export function filterThreadListItems(items, query, options = {}) {
+    const limit = options.limit ?? THREAD_PICKER_LIMIT;
+    const selectedId = options.selectedId?.trim() || undefined;
+    const needle = query.trim().toLowerCase();
+    const matched = needle
+        ? items.filter((item) => {
+            const title = item.title.toLowerCase();
+            const id = item.threadId.toLowerCase();
+            return title.includes(needle) || id.includes(needle);
+        })
+        : [...items];
+    matched.sort((a, b) => {
+        if (selectedId) {
+            if (a.threadId === selectedId && b.threadId !== selectedId)
+                return -1;
+            if (b.threadId === selectedId && a.threadId !== selectedId)
+                return 1;
+        }
+        const byState = stateRank(a.state) - stateRank(b.state);
+        if (byState !== 0)
+            return byState;
+        const aAt = a.updatedAt ?? "";
+        const bAt = b.updatedAt ?? "";
+        if (aAt !== bAt)
+            return bAt.localeCompare(aAt);
+        return a.title.localeCompare(b.title);
+    });
+    return {
+        items: matched.slice(0, limit),
+        matchedCount: matched.length,
+        openMatchedCount: matched.filter((t) => t.state === "working").length,
+    };
+}

package/dist/client/transport.d.ts

@@ -0,0 +1,11 @@
+import type { FeedbackTransport } from "@rose42/feedback-capture";
+export type T3FeedbackHttpTransportOptions = {
+    url: string;
+    /** Called on each send; return a thread id to reuse when present. */
+    getThreadId?: () => string | undefined;
+};
+/**
+ * POSTs `{ envelope, threadId? }` to the Vite middleware (ask / session-route reuse).
+ * Falls back to a bare envelope when `getThreadId` returns nothing.
+ */
+export declare function createT3FeedbackHttpTransport(options: T3FeedbackHttpTransportOptions): FeedbackTransport;

package/dist/client/transport.js

@@ -0,0 +1,35 @@
+/**
+ * POSTs `{ envelope, threadId? }` to the Vite middleware (ask / session-route reuse).
+ * Falls back to a bare envelope when `getThreadId` returns nothing.
+ */
+export function createT3FeedbackHttpTransport(options) {
+    const { url, getThreadId } = options;
+    return {
+        async send(envelope) {
+            const threadId = getThreadId?.();
+            const body = threadId !== undefined ? { envelope, threadId } : { envelope };
+            const res = await fetch(url, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(body),
+            });
+            let parsed = undefined;
+            try {
+                parsed = await res.json();
+            }
+            catch {
+                parsed = undefined;
+            }
+            if (!res.ok) {
+                const errMsg = parsed &&
+                    typeof parsed === "object" &&
+                    "error" in parsed &&
+                    typeof parsed.error === "string"
+                    ? parsed.error
+                    : `HTTP ${res.status}`;
+                throw new Error(errMsg);
+            }
+            return parsed;
+        },
+    };
+}