@marktiderman/genesis-support 0.0.0-stage → 0.2.0

package/dist/copy-CuTArBFg.d.ts

@@ -0,0 +1,477 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+
+/**
+ * The Genesis support wire contract: what a support client (the web loader, a
+ * native app, any HTTP caller) and the `genesis-support-intake` Edge Function
+ * say to each other. One file, kept byte-identical in two places:
+ * `@marktiderman/genesis-support` (`src/contract.ts`) and the function template
+ * (`functions/genesis-support-intake/contract.ts`); a test fails when they drift.
+ *
+ * Dependency-free and additive: `CONTRACT_VERSION` changes only with a shape
+ * change, and a reader tolerates fields and widget types it doesn't know, so an
+ * old client keeps working.
+ */
+/** Bumped only on a shape change. Old clients must keep working. */
+declare const CONTRACT_VERSION: 1;
+/** The widget kinds a boot can turn on. */
+type WidgetType = "feedback" | "roadmap" | "changelog" | "survey" | "messaging";
+/** On the wire the type is open: a client switches on the known ones and ignores the rest. */
+type WidgetTypeWire = WidgetType | (string & {});
+/**
+ * How the person is known to the server.
+ * - `genesis-session`: signed in to the app's own Supabase (a user access token). The default.
+ * - `signed`: the app's backend mints a short-lived token for the person (reserved).
+ * - `anonymous`: a device id only (reserved; the database refuses writes without a session).
+ */
+type IdentityMode = "anonymous" | "signed" | "genesis-session";
+type LauncherPosition = "bottom-right" | "bottom-left" | "top-right" | "top-left";
+/** Theme hints a web launcher may use. Genesis apps use their own theme instead. */
+interface ThemeTokens {
+    colorBg?: string;
+    colorFg?: string;
+    colorPrimary?: string;
+    colorPrimaryFg?: string;
+    radius?: string;
+    fontFamily?: string;
+    launcherLabel?: string;
+    launcherPosition?: LauncherPosition;
+}
+/** One enabled widget and its public config (never a secret). */
+interface WidgetConfig {
+    type: WidgetTypeWire;
+    config: Record<string, unknown>;
+}
+/** The boot handshake (`GET`): world-readable, so only public values. */
+interface BootConfig {
+    contractVersion: number;
+    project: {
+        id: string;
+        name: string;
+    };
+    identityMode: IdentityMode;
+    theme: ThemeTokens;
+    widgets: WidgetConfig[];
+    flags: Record<string, boolean>;
+}
+type FeedbackReportType = "bug" | "idea" | "question" | "praise";
+type FeedbackStatus = "open" | "submitted" | "in_progress" | "addressed" | "wont_fix";
+type FindingSeverity = "low" | "medium" | "high" | "critical";
+declare const FEEDBACK_REPORT_TYPES: readonly FeedbackReportType[];
+declare const FEEDBACK_STATUSES: readonly FeedbackStatus[];
+/** Client to server: open a report. Screenshots go to storage, not in this body. */
+interface SubmitFeedbackInput {
+    type?: FeedbackReportType;
+    title?: string;
+    body: string;
+    route?: string;
+    appVersion?: string;
+    envType?: string;
+    severity?: FindingSeverity;
+    tags?: string[];
+    /** Small, free-form context (breadcrumbs, a pin on the page). At most 16 KB as JSON. */
+    context?: Record<string, unknown>;
+}
+/** Server to client: the report created. `findingId` is the report's id (one finding per report here). */
+interface SubmitFeedbackResult {
+    reportId: string;
+    findingId: string;
+    status: FeedbackStatus;
+}
+/** One of the caller's own reports. */
+interface FeedbackReportSummary {
+    id: string;
+    type: FeedbackReportType;
+    title: string;
+    status: FeedbackStatus;
+    route: string | null;
+    createdAt: string;
+    findingCount: number;
+}
+/** The operations the intake function multiplexes on (`{ op, ...args }`). */
+type FeedbackOp = "submit" | "list";
+/** Headers a client sends. The person's access token goes in `Authorization: Bearer …`. */
+declare const WIDGET_HEADERS: {
+    /** The project's publishable key (an identifier, not a secret). */
+    readonly key: "x-genesis-key";
+    /** `signed` mode: the minted short-lived token. */
+    readonly identity: "x-genesis-identity";
+    /** `anonymous` mode: the device id. */
+    readonly device: "x-genesis-device";
+    /** A proof-of-work or captcha token, for anonymous writes. */
+    readonly challenge: "x-genesis-challenge";
+    /** The contract version the client was built against. */
+    readonly contract: "x-genesis-contract";
+};
+/** Text limits, the same as the database's checks. */
+declare const LIMITS: {
+    readonly title: 300;
+    readonly body: 20000;
+    readonly route: 2000;
+    readonly appVersion: 200;
+    readonly tag: 60;
+    readonly tags: 50;
+    readonly contextBytes: 16384;
+};
+/**
+ * A route as a path only, safe to store and send: the query string and
+ * fragment (tokens, codes, emails) are dropped, and path segments that look
+ * private (an email, an id, a long token) become `:email`, `:id` or `:token`
+ * (`/users/jane@x.test/reset/abc123…` → `/users/:email/reset/:token`).
+ */
+declare function cleanRoute(route: string | null | undefined): string | undefined;
+type SubmitValidation = {
+    ok: true;
+    value: SubmitFeedbackInput;
+} | {
+    ok: false;
+    error: "invalid_args" | "payload_too_large";
+    field: string;
+};
+/** Checks a `submit` body the way the server does: known keys only, every limit. */
+declare function validateSubmitInput(raw: unknown): SubmitValidation;
+
+/**
+ * The feedback record and its two seams: a collector assembles the context
+ * (everything except what the person typed), a sink delivers the finished
+ * record. Platform-neutral; one default of each ships (`createContextCollector`,
+ * `createSupabaseSink`), and an app can swap either.
+ */
+
+/** What kind of feedback: a bug, an idea, a question or praise. */
+type FeedbackType = FeedbackReportType;
+declare const FEEDBACK_TYPES: readonly FeedbackType[];
+/** Where the person was and what they were running when they sent it. */
+interface FeedbackContext {
+    /** The version signature, `1.4.0 (37) · preview · 3f2a9c1b`. */
+    appVersion?: string;
+    /** The screen, as a path. Query strings and fragments are always dropped. */
+    route?: string;
+    /** `ios`, `android`, `web`. */
+    platform?: string;
+    /** Model, OS version, locale, screen size, update id… At most 4 KB as JSON. */
+    device?: Record<string, unknown>;
+    /**
+     * Who sent it, for sinks that need it. The Supabase sink ignores it: the
+     * database takes the person from the session, never from the request.
+     */
+    userId?: string;
+    /** Anything else small (breadcrumbs, a pin on the page). At most 16 KB as JSON. */
+    extra?: Record<string, unknown>;
+}
+type ScreenshotContentType = "image/png" | "image/jpeg" | "image/webp";
+/**
+ * A screenshot to attach. The record carries the bytes (or base64) and no
+ * URL: the destination stores it and keeps its own key, so nothing in the
+ * record expires.
+ */
+interface FeedbackAttachment {
+    kind: "screenshot";
+    contentType: ScreenshotContentType;
+    /** The image, base64 (no `data:` prefix; a data URI is accepted and stripped). */
+    base64?: string;
+    /** Or the bytes. */
+    bytes?: Uint8Array;
+    width?: number;
+    height?: number;
+}
+interface FeedbackRecord {
+    type: FeedbackType;
+    /** What the person wrote. */
+    message: string;
+    title?: string;
+    context: FeedbackContext;
+    attachments?: FeedbackAttachment[];
+}
+/** Everything but what the person typed. */
+interface ContextCollector {
+    collect(): Promise<FeedbackContext> | FeedbackContext;
+}
+/** What the destination kept. */
+interface FeedbackDelivery {
+    /** The saved report's id. */
+    id: string;
+    /** How many attachments the destination saved the report without (an upload failed, or it takes none). */
+    attachmentsDropped: number;
+}
+/** Takes a finished record to its destination. */
+interface FeedbackSink {
+    submit(record: FeedbackRecord): Promise<FeedbackDelivery>;
+}
+declare const DEVICE_MAX_BYTES = 4096;
+declare const EXTRA_MAX_BYTES = 16384;
+/** A value given as itself or as a function that reads it now. */
+type Lazy<T> = T | (() => T);
+interface ContextCollectorOptions {
+    appVersion?: Lazy<string | undefined>;
+    route?: Lazy<string | undefined>;
+    platform?: Lazy<string | undefined>;
+    device?: Lazy<Record<string, unknown> | undefined>;
+    userId?: Lazy<string | undefined>;
+    extra?: Lazy<Record<string, unknown> | undefined>;
+}
+/**
+ * The default collector: reads each value when feedback is sent, cleans the
+ * route, and drops a device or extra bag over its size cap rather than
+ * sending a report the database would refuse.
+ */
+declare function createContextCollector(options: ContextCollectorOptions): ContextCollector;
+/** Collectors merged left to right (a later one's values win; `device` and `extra` merge by key). */
+declare function composeCollectors(...collectors: ContextCollector[]): ContextCollector;
+/** The context as the database takes it: a clean route, short strings, bags under their caps. */
+declare function sanitizeContext(context: FeedbackContext): FeedbackContext;
+/** Base64 (or a `data:` URI) to bytes, without `atob` (Hermes, workers, Node all agree). */
+declare function base64ToBytes(input: string): Uint8Array;
+/** The bytes of an attachment, from `bytes` or `base64`. */
+declare function attachmentBytes(attachment: FeedbackAttachment): Uint8Array | null;
+
+/**
+ * The support client: the app's own Supabase (migration 0006 from
+ * `@marktiderman/genesis-supabase`) under row level security. Everything a
+ * person does (send feedback, read their reports and the replies, reply, vote
+ * on the idea board) and the Supabase sink for the feedback record.
+ */
+
+/** Any supabase-js client; the app's generated Database types don't need to list the support tables. */
+type SupportSupabase = SupabaseClient<any, any, any>;
+/** The storage bucket migration 0006 creates. */
+declare const SUPPORT_BUCKET = "genesis-support";
+/** A Supabase refusal, with its code (`GS429` rate limited, `42501` not allowed, …). */
+declare class SupportError extends Error {
+    readonly code: string | undefined;
+    readonly operation: string;
+    constructor(message: string, code: string | undefined, operation: string);
+    /** The database's rate limit (SQLSTATE GS429). */
+    get rateLimited(): boolean;
+}
+type IdeaStatus = "open" | "planned" | "in_progress" | "shipped" | "declined" | "hidden";
+interface SupportReport {
+    id: string;
+    type: FeedbackType;
+    title: string | null;
+    message: string;
+    status: FeedbackStatus;
+    /** The FeatureId staff linked it to. */
+    featureId: string | null;
+    route: string | null;
+    appVersion: string | null;
+    createdAt: string;
+    updatedAt: string;
+    lastStaffReplyAt: string | null;
+    lastUserReplyAt: string | null;
+    userReadAt: string | null;
+    staffReadAt: string | null;
+    /** A staff reply the person hasn't read. */
+    unread: boolean;
+}
+interface SupportReply {
+    id: string;
+    reportId: string;
+    body: string;
+    fromStaff: boolean;
+    /** Written by the signed-in person. */
+    mine: boolean;
+    createdAt: string;
+}
+interface SupportAttachmentView {
+    id: string;
+    path: string;
+    contentType: string;
+    width: number | null;
+    height: number | null;
+    /** A signed URL, valid for `signedUrlSeconds` (default an hour). Null when signing failed. */
+    url: string | null;
+}
+interface SupportIdea {
+    id: string;
+    title: string;
+    body: string | null;
+    status: IdeaStatus;
+    /** The FeatureId that delivers it (set when it ships). */
+    featureId: string | null;
+    shippedAt: string | null;
+    voteCount: number;
+    /** The signed-in person voted for it. */
+    voted: boolean;
+    /** The signed-in person suggested it. */
+    mine: boolean;
+    createdAt: string;
+}
+interface SupportClient extends FeedbackSink {
+    /** The signed-in person's reports, newest first. */
+    myReports(options?: {
+        limit?: number;
+    }): Promise<SupportReport[]>;
+    report(id: string): Promise<SupportReport | null>;
+    replies(reportId: string): Promise<SupportReply[]>;
+    reply(reportId: string, body: string): Promise<SupportReply>;
+    markRead(reportId: string): Promise<void>;
+    /** Deletes the person's own report; its screenshots are queued for removal. */
+    deleteReport(reportId: string): Promise<void>;
+    attachments(reportId: string): Promise<SupportAttachmentView[]>;
+    /** The board, most votes first. Hidden ideas are left out, the person's own included. */
+    ideas(options?: {
+        limit?: number;
+        statuses?: IdeaStatus[];
+    }): Promise<SupportIdea[]>;
+    suggestIdea(input: {
+        title: string;
+        body?: string;
+    }): Promise<SupportIdea>;
+    vote(ideaId: string): Promise<void>;
+    unvote(ideaId: string): Promise<void>;
+    /** "You asked, we shipped": shipped ideas the person suggested or voted for. */
+    shippedForMe(): Promise<SupportIdea[]>;
+}
+interface SupportClientOptions {
+    bucket?: string;
+    signedUrlSeconds?: number;
+    /** For the attachment file names. Default `crypto.randomUUID`. */
+    randomId?: () => string;
+}
+/** True when there is a staff reply newer than the person's last read. */
+declare function isUnread(row: {
+    lastStaffReplyAt: string | null;
+    userReadAt: string | null;
+}): boolean;
+/** The support client over the app's Supabase client. */
+declare function createSupportClient(supabase: SupportSupabase, options?: SupportClientOptions): SupportClient;
+/** The Supabase sink on its own (the support client is one). */
+declare function createSupabaseSink(supabase: SupportSupabase, options?: SupportClientOptions): FeedbackSink;
+
+/**
+ * Every string the support block shows, in English. Pass `copy` (any part of
+ * this shape) to translate or reword; what you leave out stays English.
+ */
+declare const supportCopy: {
+    settings: {
+        section: string;
+        sendFeedback: string;
+        help: string;
+        /** `{count}` new replies. */
+        unreadReplies: string;
+    };
+    feedback: {
+        title: string;
+        typeLabel: string;
+        types: {
+            bug: string;
+            idea: string;
+            question: string;
+            praise: string;
+        };
+        messageLabel: string;
+        messagePlaceholder: string;
+        screenshotLabel: string;
+        includeScreenshot: string;
+        screenshotHint: string;
+        annotate: string;
+        pin: string;
+        pinned: string;
+        removeScreenshot: string;
+        send: string;
+        sending: string;
+        sentTitle: string;
+        sentBody: string;
+        sentWithoutScreenshot: string;
+        failedTitle: string;
+        failedBody: string;
+        rateLimited: string;
+        signInFirst: string;
+        messageRequired: string;
+    };
+    annotate: {
+        title: string;
+        pen: string;
+        hide: string;
+        undo: string;
+        done: string;
+        cancel: string;
+        hint: string;
+        failed: string;
+    };
+    inbox: {
+        title: string;
+        sectionTitle: string;
+        emptyTitle: string;
+        emptyBody: string;
+        errorTitle: string;
+        errorBody: string;
+        sendFeedback: string;
+        ideaBoard: string;
+        shipped: string;
+        delete: string;
+        deleteConfirmTitle: string;
+        deleteConfirmBody: string;
+        cancel: string;
+        unread: string;
+    };
+    thread: {
+        title: string;
+        placeholder: string;
+        send: string;
+        read: string;
+        support: string;
+        closed: string;
+        emptyTitle: string;
+        emptyBody: string;
+        screenshot: string;
+        notFound: string;
+        you: string;
+        sending: string;
+        notSent: string;
+        retryHint: string;
+    };
+    status: {
+        open: string;
+        submitted: string;
+        in_progress: string;
+        addressed: string;
+        wont_fix: string;
+    };
+    ideas: {
+        title: string;
+        emptyTitle: string;
+        emptyBody: string;
+        suggest: string;
+        suggestTitle: string;
+        titleLabel: string;
+        titlePlaceholder: string;
+        bodyLabel: string;
+        submit: string;
+        vote: string;
+        voted: string;
+        /** `{count}` votes. */
+        votes: string;
+        oneVote: string;
+        statuses: {
+            open: string;
+            planned: string;
+            in_progress: string;
+            shipped: string;
+            declined: string;
+            hidden: string;
+        };
+    };
+    shipped: {
+        title: string;
+        emptyTitle: string;
+        emptyBody: string;
+        /** `{feature}`: the FeatureId it shipped as. */
+        shippedAs: string;
+    };
+};
+/** The shape a translation fills. */
+type SupportCopy = typeof supportCopy;
+/** Any part of the catalog. */
+type SupportCopyOverrides = {
+    [K in keyof SupportCopy]?: DeepPartial<SupportCopy[K]>;
+};
+type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends string ? string : DeepPartial<T[K]>;
+};
+/** The catalog with overrides merged over the English. */
+declare function resolveSupportCopy(overrides?: SupportCopyOverrides): SupportCopy;
+/** Fills `{name}` placeholders. */
+declare function fill(template: string, values: Readonly<Record<string, string | number>>): string;
+
+export { isUnread as $, type SupportCopyOverrides as A, type BootConfig as B, CONTRACT_VERSION as C, DEVICE_MAX_BYTES as D, EXTRA_MAX_BYTES as E, type FeedbackReportSummary as F, SupportError as G, type SupportIdea as H, type IdeaStatus as I, type SupportReply as J, type SupportReport as K, LIMITS as L, type SupportSupabase as M, type WidgetConfig as N, type WidgetType as O, type WidgetTypeWire as P, attachmentBytes as Q, base64ToBytes as R, type SubmitFeedbackInput as S, type ThemeTokens as T, cleanRoute as U, composeCollectors as V, WIDGET_HEADERS as W, createContextCollector as X, createSupabaseSink as Y, createSupportClient as Z, fill as _, type SubmitFeedbackResult as a, resolveSupportCopy as a0, sanitizeContext as a1, supportCopy as a2, validateSubmitInput as a3, type FeedbackSink as b, type ContextCollector as c, type ContextCollectorOptions as d, FEEDBACK_REPORT_TYPES as e, FEEDBACK_STATUSES as f, FEEDBACK_TYPES as g, type FeedbackAttachment as h, type FeedbackContext as i, type FeedbackDelivery as j, type FeedbackOp as k, type FeedbackRecord as l, type FeedbackReportType as m, type FeedbackStatus as n, type FeedbackType as o, type FindingSeverity as p, type IdentityMode as q, type LauncherPosition as r, type Lazy as s, SUPPORT_BUCKET as t, type ScreenshotContentType as u, type SubmitValidation as v, type SupportAttachmentView as w, type SupportClient as x, type SupportClientOptions as y, type SupportCopy as z };

package/dist/index.d.ts

@@ -0,0 +1,43 @@
+import { B as BootConfig, S as SubmitFeedbackInput, a as SubmitFeedbackResult, F as FeedbackReportSummary, b as FeedbackSink } from './copy-CuTArBFg.js';
+export { C as CONTRACT_VERSION, c as ContextCollector, d as ContextCollectorOptions, D as DEVICE_MAX_BYTES, E as EXTRA_MAX_BYTES, e as FEEDBACK_REPORT_TYPES, f as FEEDBACK_STATUSES, g as FEEDBACK_TYPES, h as FeedbackAttachment, i as FeedbackContext, j as FeedbackDelivery, k as FeedbackOp, l as FeedbackRecord, m as FeedbackReportType, n as FeedbackStatus, o as FeedbackType, p as FindingSeverity, I as IdeaStatus, q as IdentityMode, L as LIMITS, r as LauncherPosition, s as Lazy, t as SUPPORT_BUCKET, u as ScreenshotContentType, v as SubmitValidation, w as SupportAttachmentView, x as SupportClient, y as SupportClientOptions, z as SupportCopy, A as SupportCopyOverrides, G as SupportError, H as SupportIdea, J as SupportReply, K as SupportReport, M as SupportSupabase, T as ThemeTokens, W as WIDGET_HEADERS, N as WidgetConfig, O as WidgetType, P as WidgetTypeWire, Q as attachmentBytes, R as base64ToBytes, U as cleanRoute, V as composeCollectors, X as createContextCollector, Y as createSupabaseSink, Z as createSupportClient, _ as fill, $ as isUnread, a0 as resolveSupportCopy, a1 as sanitizeContext, a2 as supportCopy, a3 as validateSubmitInput } from './copy-CuTArBFg.js';
+export { S as SUPPORT_BLOCK_ID, a as SupportBlockOptions, b as SupportPaths, d as defineSupportBlock, s as supportContributions, c as supportPaths } from './block-fZjTS2sY.js';
+import '@supabase/supabase-js';
+import '@marktiderman/genesis-features/blocks';
+
+/**
+ * The HTTP client for the `genesis-support-intake` Edge Function: the wire
+ * contract (boot, submit, list) for code that doesn't hold a supabase-js
+ * client, such as a script-tag web loader or another backend. Zero
+ * dependencies, global `fetch`.
+ */
+
+interface IntakeClientConfig {
+    /** The app's Supabase URL (`https://<project>.supabase.co`, or the local one). */
+    endpoint: string;
+    /** The publishable key, sent as `apikey` and `x-genesis-key` (an identifier, not a secret). */
+    publishableKey: string;
+    /** The signed-in person's access token, read per request. */
+    getAccessToken?: () => string | null | undefined | Promise<string | null | undefined>;
+    /** The function's name, if you deployed it under another. */
+    functionName?: string;
+    fetchImpl?: typeof fetch;
+}
+/** A non-2xx answer (`status` 0: it never arrived). `code` is the function's `error`. */
+declare class IntakeError extends Error {
+    readonly status: number;
+    readonly code?: string | undefined;
+    constructor(message: string, status: number, code?: string | undefined);
+}
+interface IntakeClient {
+    boot(signal?: AbortSignal): Promise<BootConfig>;
+    submit(input: SubmitFeedbackInput, signal?: AbortSignal): Promise<SubmitFeedbackResult>;
+    list(signal?: AbortSignal): Promise<FeedbackReportSummary[]>;
+}
+declare function createIntakeClient(config: IntakeClientConfig): IntakeClient;
+/**
+ * A sink over the intake function. The function takes no screenshots (they
+ * go to storage with a session), so attachments are reported as dropped.
+ */
+declare function createIntakeSink(client: IntakeClient): FeedbackSink;
+
+export { BootConfig, FeedbackReportSummary, FeedbackSink, type IntakeClient, type IntakeClientConfig, IntakeError, SubmitFeedbackInput, SubmitFeedbackResult, createIntakeClient, createIntakeSink };

package/dist/index.js

@@ -0,0 +1,74 @@
+export { SUPPORT_BLOCK_ID, SUPPORT_BUCKET, SupportError, createSupabaseSink, createSupportClient, defineSupportBlock, isUnread, supportContributions, supportPaths } from './chunk-4VFYVQUF.js';
+import { WIDGET_HEADERS, CONTRACT_VERSION } from './chunk-ZV4KJBUF.js';
+export { CONTRACT_VERSION, DEVICE_MAX_BYTES, EXTRA_MAX_BYTES, FEEDBACK_REPORT_TYPES, FEEDBACK_STATUSES, FEEDBACK_TYPES, LIMITS, WIDGET_HEADERS, attachmentBytes, base64ToBytes, cleanRoute, composeCollectors, createContextCollector, fill, resolveSupportCopy, sanitizeContext, supportCopy, validateSubmitInput } from './chunk-ZV4KJBUF.js';
+
+// src/intake.ts
+var IntakeError = class extends Error {
+  constructor(message, status, code) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "IntakeError";
+  }
+  status;
+  code;
+};
+function createIntakeClient(config) {
+  const url = `${config.endpoint.replace(/\/$/, "")}/functions/v1/${config.functionName ?? "genesis-support-intake"}`;
+  const f = config.fetchImpl ?? fetch;
+  async function headers() {
+    const token = await config.getAccessToken?.();
+    return {
+      apikey: config.publishableKey,
+      [WIDGET_HEADERS.key]: config.publishableKey,
+      [WIDGET_HEADERS.contract]: String(CONTRACT_VERSION),
+      ...token ? { authorization: `Bearer ${token}` } : {}
+    };
+  }
+  async function send(init) {
+    let res;
+    try {
+      res = await f(url, init);
+    } catch (error) {
+      throw new IntakeError(error instanceof Error ? error.message : "network request failed", 0, "transport_error");
+    }
+    if (!res.ok) {
+      let code;
+      try {
+        code = (await res.json()).error;
+      } catch {
+      }
+      throw new IntakeError(code ?? `${res.status} ${res.statusText}`, res.status, code);
+    }
+    return await res.json();
+  }
+  const post = async (op, args, signal) => (
+    // `op` last, so an `op` in args can never pick the operation.
+    send({ method: "POST", headers: { ...await headers(), "content-type": "application/json" }, body: JSON.stringify({ ...args, op }), signal })
+  );
+  return {
+    boot: async (signal) => send({ method: "GET", headers: await headers(), signal }),
+    submit: (input, signal) => post("submit", input, signal),
+    list: (signal) => post("list", {}, signal)
+  };
+}
+function createIntakeSink(client) {
+  return {
+    async submit(record) {
+      const result = await client.submit({
+        type: record.type,
+        title: record.title,
+        body: record.message,
+        route: record.context.route,
+        appVersion: record.context.appVersion,
+        envType: record.context.platform,
+        context: record.context.extra
+      });
+      return { id: result.reportId, attachmentsDropped: record.attachments?.length ?? 0 };
+    }
+  };
+}
+
+export { IntakeError, createIntakeClient, createIntakeSink };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/intake.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["/**\n * The HTTP client for the `genesis-support-intake` Edge Function: the wire\n * contract (boot, submit, list) for code that doesn't hold a supabase-js\n * client, such as a script-tag web loader or another backend. Zero\n * dependencies, global `fetch`.\n */\nimport {\n  CONTRACT_VERSION,\n  WIDGET_HEADERS,\n  type BootConfig,\n  type FeedbackOp,\n  type FeedbackReportSummary,\n  type SubmitFeedbackInput,\n  type SubmitFeedbackResult,\n} from \"./contract\";\nimport type { FeedbackSink } from \"./record\";\n\nexport interface IntakeClientConfig {\n  /** The app's Supabase URL (`https://<project>.supabase.co`, or the local one). */\n  endpoint: string;\n  /** The publishable key, sent as `apikey` and `x-genesis-key` (an identifier, not a secret). */\n  publishableKey: string;\n  /** The signed-in person's access token, read per request. */\n  getAccessToken?: () => string | null | undefined | Promise<string | null | undefined>;\n  /** The function's name, if you deployed it under another. */\n  functionName?: string;\n  fetchImpl?: typeof fetch;\n}\n\n/** A non-2xx answer (`status` 0: it never arrived). `code` is the function's `error`. */\nexport class IntakeError extends Error {\n  constructor(\n    message: string,\n    readonly status: number,\n    readonly code?: string,\n  ) {\n    super(message);\n    this.name = \"IntakeError\";\n  }\n}\n\nexport interface IntakeClient {\n  boot(signal?: AbortSignal): Promise<BootConfig>;\n  submit(input: SubmitFeedbackInput, signal?: AbortSignal): Promise<SubmitFeedbackResult>;\n  list(signal?: AbortSignal): Promise<FeedbackReportSummary[]>;\n}\n\nexport function createIntakeClient(config: IntakeClientConfig): IntakeClient {\n  const url = `${config.endpoint.replace(/\\/$/, \"\")}/functions/v1/${config.functionName ?? \"genesis-support-intake\"}`;\n  const f = config.fetchImpl ?? fetch;\n\n  async function headers(): Promise<Record<string, string>> {\n    const token = await config.getAccessToken?.();\n    return {\n      apikey: config.publishableKey,\n      [WIDGET_HEADERS.key]: config.publishableKey,\n      [WIDGET_HEADERS.contract]: String(CONTRACT_VERSION),\n      ...(token ? { authorization: `Bearer ${token}` } : {}),\n    };\n  }\n\n  async function send<T>(init: RequestInit): Promise<T> {\n    let res: Response;\n    try {\n      res = await f(url, init);\n    } catch (error) {\n      throw new IntakeError(error instanceof Error ? error.message : \"network request failed\", 0, \"transport_error\");\n    }\n    if (!res.ok) {\n      let code: string | undefined;\n      try {\n        code = ((await res.json()) as { error?: string }).error;\n      } catch {\n        // not JSON\n      }\n      throw new IntakeError(code ?? `${res.status} ${res.statusText}`, res.status, code);\n    }\n    return (await res.json()) as T;\n  }\n\n  const post = async <T,>(op: FeedbackOp, args: object, signal?: AbortSignal) =>\n    // `op` last, so an `op` in args can never pick the operation.\n    send<T>({ method: \"POST\", headers: { ...(await headers()), \"content-type\": \"application/json\" }, body: JSON.stringify({ ...args, op }), signal });\n\n  return {\n    boot: async (signal) => send<BootConfig>({ method: \"GET\", headers: await headers(), signal }),\n    submit: (input, signal) => post<SubmitFeedbackResult>(\"submit\", input, signal),\n    list: (signal) => post<FeedbackReportSummary[]>(\"list\", {}, signal),\n  };\n}\n\n/**\n * A sink over the intake function. The function takes no screenshots (they\n * go to storage with a session), so attachments are reported as dropped.\n */\nexport function createIntakeSink(client: IntakeClient): FeedbackSink {\n  return {\n    async submit(record) {\n      const result = await client.submit({\n        type: record.type,\n        title: record.title,\n        body: record.message,\n        route: record.context.route,\n        appVersion: record.context.appVersion,\n        envType: record.context.platform,\n        context: record.context.extra,\n      });\n      return { id: result.reportId, attachmentsDropped: record.attachments?.length ?? 0 };\n    },\n  };\n}\n"]}