@lightworkai.official/debug-capture 0.6.0

package/dist/mytickets/api.d.ts

@@ -0,0 +1,115 @@
+/** A board column as the realm configured it. Only public lanes are returned. */
+export interface StatusColumn {
+    key: string;
+    label: string;
+    description: string;
+    color: string;
+    bucket: "active" | "closed";
+    awaitingReply: boolean;
+}
+export interface RealmConfig {
+    realm: {
+        id: string;
+        slug: string;
+        name: string;
+    };
+    timezone: string;
+    statusColumns: StatusColumn[];
+    featureFlags: {
+        selfServiceReopen?: boolean;
+        attachments?: boolean;
+        conversation?: boolean;
+    };
+    locale: {
+        default: string;
+        labels: Record<string, string>;
+    };
+}
+export interface TicketMessage {
+    id: string;
+    authorId: string | null;
+    authorName: string | null;
+    authorRole: "REPORTER" | "AGENT";
+    body: string;
+    createdAt: string;
+    editedAt: string | null;
+}
+export interface TicketAttachment {
+    id: string;
+    objectKey: string;
+    filename: string | null;
+    contentType: string | null;
+    sizeBytes: number | null;
+}
+export interface MyTicket {
+    id: string;
+    number: number;
+    title: string;
+    description: string | null;
+    category: string | null;
+    routeUrl: string | null;
+    status: string;
+    priority: string;
+    resolutionNote: string | null;
+    reopened: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface MyTicketListItem extends MyTicket {
+    messageCount: number;
+    /** How many replies came from the team — "has anyone answered me yet". */
+    agentReplyCount: number;
+    lastMessage: {
+        at: string;
+        authorRole: "REPORTER" | "AGENT";
+        preview: string;
+    } | null;
+}
+export interface MyTicketDetail extends MyTicket {
+    messages: TicketMessage[];
+    attachments: TicketAttachment[];
+}
+/** One recorded status change. Internal lanes are already resolved server-side. */
+export interface StatusEvent {
+    id: string;
+    fromStatus: string | null;
+    toStatus: string;
+    via: string;
+    createdAt: string;
+}
+/** Thrown with the server's own words, so a panel can say what went wrong. */
+export declare class TicketApiError extends Error {
+    readonly status: number;
+    constructor(message: string, status: number);
+}
+/** Raised when there is no signed-in reporter to ask about. */
+export declare class NoIdentityError extends Error {
+    constructor();
+}
+export declare function listMyTickets(): Promise<MyTicketListItem[]>;
+export declare function getMyTicket(id: string): Promise<MyTicketDetail>;
+export declare function getMyTicketByNumber(num: number): Promise<MyTicketDetail>;
+/**
+ * A short-lived URL for a file on one's own ticket.
+ *
+ * Fetched rather than pointed at: the endpoint needs the realm key and the
+ * identity token, and an `<img>` or an `<a download>` cannot send a header.
+ */
+export declare function getAttachmentUrl(attachmentId: string): Promise<{
+    url: string;
+    filename: string | null;
+}>;
+export declare function getMyTicketHistory(id: string): Promise<StatusEvent[]>;
+export declare function replyToTicket(id: string, body: string): Promise<TicketMessage>;
+/**
+ * Rewrite one's own reply.
+ *
+ * The server refuses any message the caller did not write — authorship, not
+ * role — so this cannot touch the team's side of the thread.
+ */
+export declare function editMyMessage(ticketId: string, messageId: string, body: string): Promise<TicketMessage>;
+export declare function reopenMyTicket(id: string, note?: string): Promise<MyTicket>;
+export declare function uploadInlineImage(id: string, dataUri: string, filename?: string): Promise<{
+    url: string;
+}>;
+export declare function fetchRealmConfig(): Promise<RealmConfig>;

package/dist/mytickets/format.d.ts

@@ -0,0 +1,84 @@
+/**
+ * The panel's decisions that are not DOM: how a ticket is named, dated, sorted,
+ * searched and described. Pure, so they can be tested without a browser — which
+ * matters here, because the DOM around them cannot be.
+ */
+import type { MyTicketListItem, StatusColumn } from "./api";
+/**
+ * `ROOT-1099`, from the realm's slug — the same key the board and the admin app
+ * print, so a reporter quoting a number is quoting the one support will search
+ * for. A realm with no usable slug falls back to `#1099` rather than inventing
+ * a prefix.
+ */
+export declare function ticketKey(slug: string | undefined, number: number): string;
+/**
+ * `24 พ.ค. 2568 13:00` — the original's `DD MMM BBBB HH:mm`, from the platform's
+ * own Intl rather than a date library this package will not depend on.
+ *
+ * Formatted in the REALM's timezone, not the reader's. A support desk in
+ * Bangkok and a reporter travelling in Berlin must not disagree about which day
+ * a ticket was filed, and the realm is the side that also runs the "today"
+ * filters.
+ */
+export declare function formatDateTime(iso: string | null | undefined, timezone: string, locale: "th" | "en" | undefined): string;
+/** Lookups over the realm's configured lanes, with sane answers for a key that isn't there. */
+export interface StatusMaps {
+    labelOf: (key: string) => string;
+    columnOf: (key: string) => StatusColumn | undefined;
+    isAwaitingReply: (key: string) => boolean;
+    isClosed: (key: string) => boolean;
+    /** Board order, for sorting a column of statuses the way the board reads. */
+    rankOf: (key: string) => number;
+    options: {
+        value: string;
+        label: string;
+    }[];
+}
+export declare function statusMaps(columns: StatusColumn[], allLabel: string): StatusMaps;
+/** Has the team written a solution note? */
+export declare function hasSolution(t: MyTicketListItem): boolean;
+/** Has anyone from the team replied at all? */
+export declare function hasTeamReply(t: MyTicketListItem): boolean;
+/** Solution beats a reply beats silence — the order the column sorts in. */
+export declare function responseRank(t: MyTicketListItem): number;
+export type SortKey = "number" | "title" | "module" | "status" | "response" | "createdAt" | "updatedAt";
+export interface Sort {
+    key: SortKey;
+    direction: "asc" | "desc";
+}
+/**
+ * Filter by what the reporter SEES.
+ *
+ * The haystack is the rendered row — key, title, module, status label — because
+ * that is what someone searching has in front of them. Searching the raw status
+ * key would match `IN_PROGRESS` for a lane the reader only ever saw called
+ * กำลังดำเนินการ.
+ */
+export declare function matchesKeyword(t: MyTicketListItem, keyword: string, slug: string | undefined, labelOf: (key: string) => string): boolean;
+/**
+ * Comparators for the orders a raw value compare gets wrong: status follows the
+ * board rather than the alphabet, dates are chronological rather than
+ * lexicographic, and the response column ranks by a signal that is not one field.
+ */
+export declare function compareBy(sort: Sort, maps: StatusMaps, slug: string | undefined): (a: MyTicketListItem, b: MyTicketListItem) => number;
+/** Rows per page — the original's `defaultPageSize`. */
+export declare const PAGE_SIZE = 10;
+export declare function pageOf<T>(rows: T[], page: number, size?: number): T[];
+export declare function pageCount(total: number, size?: number): number;
+/**
+ * The same ten colour tokens the board uses, as concrete pairs.
+ *
+ * A status arrives as DATA — a realm adds lanes whenever it likes — so a pill is
+ * coloured with an inline style from this map rather than a class a stylesheet
+ * could never know the name of. Keeping the values identical
+ * to the app's own STATUS_TONES is the point: a reporter and an agent looking at
+ * the same ticket should see the same colour for it.
+ */
+export declare const STATUS_TONES: Record<string, {
+    fg: string;
+    bg: string;
+}>;
+export declare function statusTone(token: string | undefined): {
+    fg: string;
+    bg: string;
+};

package/dist/mytickets/sanitize.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Rendering a ticket body inside somebody else's app.
+ *
+ * Bodies are HTML — the composer's formatting and its inline screenshots are the
+ * point of the thread, so stripping to text would lose what a reporter actually
+ * came to read. But that HTML was written by other people, and this package
+ * renders it inside a HOST application's page. Markup that ran there would run
+ * with the host's origin, against the host's session. A support widget must not
+ * be the way an app gets XSS.
+ *
+ * The support app solves this with DOMPurify. A package that every consumer
+ * installs cannot take that dependency for one screen, so this is the same
+ * POLICY over the platform's own parser: parse the string with DOMParser (never
+ * a regex), walk the result, and delete every node and attribute not on the
+ * list. Anything unrecognised is removed rather than escaped, and the walk is
+ * over an inert document, so nothing loads or executes while it happens.
+ */
+/** Tags an ordinary note actually uses. Everything else goes. */
+export declare const ALLOWED_TAGS: Set<string>;
+export declare const ALLOWED_ATTR: Set<string>;
+/** Links: ordinary web destinations only. No javascript:, no data:. */
+export declare function isAllowedHref(url: string): boolean;
+/**
+ * Image sources: OUR inline images and nothing else.
+ *
+ * Not a tightening for its own sake. Any other src turns every ticket into a
+ * tracking pixel aimed at whoever opens it — a body can be written by a stranger
+ * who filed a report, and the reader here is the reporter, on the host's page.
+ * Accepts the server-relative form and the same path already made absolute
+ * against the configured host.
+ */
+export declare function isAllowedImageSrc(url: string, host: string): boolean;
+export declare function looksLikeHtml(body: string): boolean;
+/** Tags out, line structure kept — for previews and anywhere text is all that fits. */
+export declare function toPlainText(body: string): string;
+/**
+ * Fill `target` with a safe rendering of `body`.
+ *
+ * A node rather than a string, deliberately: handing back HTML invites a caller
+ * to concatenate it with something else and re-parse the result, which is where
+ * sanitisers stop holding.
+ */
+export declare function renderBody(target: HTMLElement, body: string, host: string): void;
+/**
+ * The same walk, but returning a string — for content going OUT.
+ *
+ * `renderBody` deliberately hands back a node, because handing back HTML invites
+ * a caller to concatenate and re-parse it. This one exists for the single case
+ * where a string is the only possible answer: the composer has to put what
+ * somebody typed into a JSON body.
+ *
+ * It matters for the same reason the display side does, from the other
+ * direction. A contenteditable takes whatever the clipboard had in it — a
+ * pasted block of a web page arrives with its scripts, its styles and its
+ * tracking pixels intact — and posting that unfiltered would store it for
+ * every future reader of the thread.
+ */
+export declare function cleanHtml(html: string, host: string): string;
+/**
+ * True when there is nothing worth sending.
+ *
+ * An image alone counts as content — a screenshot with no words is the most
+ * common reply a reporter makes — but a contenteditable that has been typed in
+ * and cleared is full of empty tags and `&nbsp;`, and those are not.
+ */
+export declare function htmlIsEmpty(html: string): boolean;

package/dist/mytickets/strings.d.ts

@@ -0,0 +1,74 @@
+/**
+ * The tickets panel's own words, kept apart from the reporter dialog's so
+ * neither grows the other's vocabulary. Thai wording is the original's, verbatim
+ * where the original had one.
+ */
+export interface TicketStrings {
+    title: string;
+    intro: string;
+    searchPlaceholder: string;
+    searchLabel: string;
+    allStatuses: string;
+    count: (n: number) => string;
+    colNumber: string;
+    colTitle: string;
+    colModule: string;
+    colStatus: string;
+    colResponse: string;
+    colCreated: string;
+    colUpdated: string;
+    awaitingReply: string;
+    hasSolution: string;
+    hasReply: string;
+    noReply: string;
+    empty: string;
+    emptyFiltered: string;
+    loading: string;
+    listFailed: string;
+    detailFailed: string;
+    signedOut: string;
+    back: string;
+    reportedBy: string;
+    conversation: string;
+    resolution: string;
+    noMessages: string;
+    you: string;
+    team: string;
+    /** The role chip beside a reporter's name, as the original prints it. */
+    reporterRole: string;
+    edited: string;
+    edit: string;
+    saveEdit: string;
+    cancel: string;
+    replyPlaceholder: string;
+    bold: string;
+    italic: string;
+    underline: string;
+    strike: string;
+    code: string;
+    blockquote: string;
+    bulletList: string;
+    orderedList: string;
+    link: string;
+    linkPrompt: string;
+    linkNeedsSelection: string;
+    linkInvalid: string;
+    attachImage: string;
+    uploading: string;
+    send: string;
+    sending: string;
+    sent: string;
+    sendFailed: string;
+    reopen: string;
+    reopenHint: string;
+    reopening: string;
+    reopened: string;
+    reopenFailed: string;
+    close: string;
+    retry: string;
+    page: string;
+    of: (page: number, pages: number) => string;
+    prev: string;
+    next: string;
+}
+export declare function ticketStrings(locale: "th" | "en" | undefined): TicketStrings;

package/dist/mytickets/toolbar.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Which controls a rich composer offers.
+ *
+ * A list rather than a fixed set, because the original itself has two —
+ * `NOTE_TOOLBAR` for replies and a longer one for articles — and the support app's
+ * admin composer wants a few more than a reporter's does. The alternative was a
+ * second editor component, which is the thing this package exists to stop.
+ */
+export type EditorTool = "bold" | "italic" | "underline" | "strike" | "code" | "bulletList" | "orderedList" | "blockquote" | "link" | "image";
+/** The original's own NOTE_TOOLBAR — what a reporter replying to a ticket gets. */
+export declare const NOTE_TOOLBAR: EditorTool[];
+/**
+ * Everything, for a staff composer. Adds the three the admin side had grown on
+ * its own — strike, code and blockquote — so adopting this component costs the
+ * app nothing it already had.
+ */
+export declare const FULL_TOOLBAR: EditorTool[];

package/dist/reporter.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The bus between "something happened" and "the reporter opens".
+ *
+ * Replaces the original's zustand store. Not because zustand is bad, but
+ * because it is React's: this package is consumed by Vue and Angular apps too,
+ * and a state library in the core would be a framework choice imposed on all of
+ * them for the sake of two callbacks and a Set.
+ *
+ * `launch` must be called INSIDE the user's gesture. Screen capture asks the
+ * browser for permission, and a browser only grants that to a real click — an
+ * await before it and the request is refused with no useful error.
+ */
+import type { DebugReason } from "./types";
+type Listener = (reason: DebugReason) => void;
+/** The reporter UI subscribes here. */
+export declare function onLaunch(fn: Listener): () => void;
+/** Open the reporter. Call from inside a click handler — see the note above. */
+export declare function launch(reason?: DebugReason): void;
+/**
+ * A crash was caught. Deliberately NOT the same channel as `launch`: opening a
+ * screen-capture prompt on its own, with no gesture behind it, is both refused
+ * by the browser and rude. A listener turns this into an invitation — a toast
+ * with a button — and that button calls `launch`.
+ */
+export declare function onCrash(fn: Listener): () => void;
+export declare function emitCrash(reason: DebugReason): void;
+export {};

package/dist/screenshot.d.ts

@@ -0,0 +1,7 @@
+import type { ScreenshotMethod } from './types';
+export interface ScreenshotResult {
+    dataUrl: string | null;
+    method: ScreenshotMethod;
+}
+export declare function captureScreen(): Promise<ScreenshotResult>;
+export declare function compressScreenshot(dataUrl: string): Promise<string>;

package/dist/signature.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The dedup key: the failed API call that most likely caused the crash.
+ *
+ * `METHOD /path/:id STATUS`, e.g. `PUT /documents/:id 500`. Two users hitting
+ * the same broken endpoint produce the same key, so the backend merges their
+ * reports into one parent with duplicates under it — which is what stops an
+ * outage from arriving as forty separate tickets.
+ *
+ * The only normalisation is templating record ids out of the URL PATH, which is
+ * bounded, like a route pattern. No fuzzy text matching: a signature that merges
+ * two unrelated failures is worse than no signature, because the second report
+ * disappears under the first and nobody reads it.
+ *
+ * Returns null for a manual report or when there is no clear failure. We never
+ * guess — an unmerged ticket is a small cost, a wrongly merged one is a lost bug.
+ */
+import type { DebugBundle } from "./types";
+export declare function errorSignature(bundle: DebugBundle): string | null;

package/dist/submit.d.ts

@@ -0,0 +1,8 @@
+import type { DebugBundle } from "./types";
+export interface FiledTicket {
+    id: string;
+    number: number;
+    status: string;
+}
+export declare function toBase64(bytes: Uint8Array): string;
+export declare function submitBundle(title: string, bundle: DebugBundle): Promise<FiledTicket>;

package/dist/types.d.ts

@@ -0,0 +1,175 @@
+/**
+ * The shape of a debug bundle.
+ *
+ * A bundle is a redacted, client-side snapshot of what the user was doing when
+ * something went wrong — recent network requests, console output, the trail of
+ * actions that led there, page/session context, a cause summary, and a
+ * screenshot. It is assembled entirely in the browser so support can reproduce
+ * an issue without a round of "what were you clicking".
+ *
+ * What changed on the way out of the original in-app reporter: anything that
+ * described ONE app — a Thai unit hierarchy, a permission-bypass dev flag, a
+ * fixed module vocabulary — is gone. Those arrive through config now, because a
+ * library that ships another company's org chart is not a library.
+ */
+export type CaptureVia = "fetch" | "xhr";
+export interface CapturedRequest {
+    id: string;
+    /** ISO timestamp when the request started. */
+    startedAt: string;
+    method: string;
+    /** Redacted URL (sensitive query params masked). */
+    url: string;
+    /** Redacted request headers. */
+    requestHeaders: Record<string, string>;
+    /** Redacted + truncated request body (JSON string / marker / null). */
+    requestBody: string | null;
+    status: number | null;
+    statusText: string | null;
+    /** Redacted response headers. */
+    responseHeaders?: Record<string, string>;
+    /**
+     * Redacted response body, in full up to a per-response cap — not a snippet.
+     * Only captured for origins the consumer allowed: see `capture.bodyOrigins`.
+     */
+    responseSnippet?: string | null;
+    durationMs: number | null;
+    /** Populated when the request rejected (network error / abort). */
+    error?: string;
+    via: CaptureVia;
+}
+export type ConsoleLevel = "log" | "info" | "warn" | "error" | "debug";
+export type ConsoleEntryKind = ConsoleLevel | "exception" | "unhandledrejection";
+export interface CapturedConsoleEntry {
+    id: string;
+    at: string;
+    level: ConsoleEntryKind;
+    /** Human-readable, truncated message. */
+    message: string;
+}
+export type ActionKind = "click" | "input" | "navigate" | "submit" | "ui";
+export interface ActionTrailEntry {
+    id: string;
+    at: string;
+    kind: ActionKind;
+    /** Human-readable description, e.g. `click ปุ่ม "บันทึกร่าง"`. */
+    detail: string;
+    /** Consecutive identical actions are collapsed; this is how many. */
+    count?: number;
+    /** Where a click leads — from the link's href or the nearest click target. */
+    source?: string;
+    /**
+     * A small, sanitized+redacted `outerHTML` of the clicked element, so a reader
+     * can see the ACTUAL control rather than a text label. Omitted when too large.
+     *
+     * MUST be re-sanitized before rendering. It is attacker-influenced markup that
+     * has travelled between origins.
+     */
+    html?: string;
+    /**
+     * The same control a moment later, once it visibly changed — disabled, busy,
+     * relabelled, or gone. A button's resting state says what was pressed; this
+     * says what pressing it DID, which is the half that was missing.
+     */
+    afterHtml?: string;
+    /** One-line summary of that change, present even if `afterHtml` was dropped. */
+    afterNote?: string;
+}
+export type DebugReasonType = "manual" | "runtime-error" | "unhandledrejection" | "framework-error";
+export interface DebugReason {
+    type: DebugReasonType;
+    message?: string;
+    stack?: string;
+}
+/** A failed data-layer query the host chose to report (react-query, Apollo, …). */
+export interface ErroredQuery {
+    key: string;
+    error: string;
+}
+export interface FailedRequestSummary {
+    method: string;
+    url: string;
+    status: number | null;
+    error?: string;
+    at: string;
+}
+/** The "smoking gun" — surfaced at the top of the report. */
+export interface CauseSummary {
+    failedRequests: FailedRequestSummary[];
+    errors: string[];
+    erroredQueries: ErroredQuery[];
+}
+/**
+ * Who was using the app. Every field optional: the library cannot know what a
+ * host knows about its users, and a half-filled identity is worth more than a
+ * shape the host has to lie to satisfy.
+ */
+export interface DebugUser {
+    id?: string | null;
+    email?: string | null;
+    fullName?: string | null;
+    /** Department / unit / team — whatever the host calls the thing. */
+    unit?: string | null;
+    roles?: string[];
+}
+export interface DebugContext {
+    capturedAt: string;
+    route: {
+        href: string;
+        pathname: string;
+        search: string;
+    };
+    /** Which part of the app this was, when the host declares one. */
+    module: {
+        key: string;
+        label: string;
+    } | null;
+    user: DebugUser;
+    /** Host-supplied request headers, redacted. Acting-as context and the like. */
+    apiHeaders: Record<string, string>;
+    app: {
+        name: string;
+        version: string;
+        environment: string;
+    };
+    client: {
+        userAgent: string;
+        language: string;
+        platform: string;
+        online: boolean;
+        viewport: {
+            width: number;
+            height: number;
+            dpr: number;
+        };
+        screen: {
+            width: number;
+            height: number;
+        };
+    };
+    performance: {
+        memoryUsedMb: number | null;
+        memoryLimitMb: number | null;
+        domContentLoadedMs: number | null;
+        loadEventMs: number | null;
+    };
+    /** Anything else the host wants on the record — feature flags, build id, … */
+    extra: Record<string, unknown>;
+}
+export type ScreenshotMethod = "display-media" | "html-to-image" | "none" | "cancelled";
+export interface DebugBundle {
+    context: DebugContext;
+    reason: DebugReason;
+    note: string;
+    cause: CauseSummary;
+    actionTrail: ActionTrailEntry[];
+    network: CapturedRequest[];
+    console: CapturedConsoleEntry[];
+    /** PNG data URL, or null if capture failed / was skipped. */
+    screenshotDataUrl: string | null;
+    screenshotMethod: ScreenshotMethod;
+    meta: {
+        generatedBy: string;
+        schemaVersion: number;
+    };
+}

package/dist/ui/annotator.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Draw on the screenshot before filing it.
+ *
+ * "The button on the right" is not a bug report; a red box around it is. This is
+ * the highest-value thing in the widget, because it turns a picture of a whole
+ * screen into a picture of the problem.
+ *
+ * The original does this with fabric.js and gets selection, handles and a delete
+ * control for free. This is plain canvas — fabric is ~290 kB, and a scene graph
+ * to draw four shapes is not a cost every host app should carry. What it must
+ * NOT be is a downgrade, so everything a person actually does to an annotation
+ * is here: draw, select, move, resize from any handle, delete from the ✕ on the
+ * selection, retype a label, clear.
+ *
+ * Rotation is the one thing fabric gives that this does not. Nobody rotates a
+ * box drawn around a broken button.
+ */
+export type AnnotatorTool = "rect" | "arrow" | "highlight" | "text";
+export interface Annotator {
+    setTool(tool: AnnotatorTool | null): void;
+    deleteSelected(): void;
+    clear(): void;
+    /** The annotated image at FULL resolution — never the on-screen scale. */
+    toDataUrl(): string;
+    hasShapes(): boolean;
+    hasSelection(): boolean;
+    destroy(): void;
+}
+export declare function createAnnotator(canvas: HTMLCanvasElement, image: HTMLImageElement, 
+/**
+ * The drawing or the active tool changed — the toolbar mirrors both, so it
+ * has to hear about a tool being consumed as well as a shape being added.
+ */
+notify: () => void): Annotator;

package/dist/ui/arrow.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Where an arrow's shaft stops and its head begins.
+ *
+ * The shaft used to run all the way to the tip with the head painted over it,
+ * which leaves a spur: the shaft has width, the head's base edge is angled, and
+ * the corners of a thick line poke out past that edge on one side. It reads as a
+ * notch in the arrowhead, and once seen it cannot be unseen.
+ *
+ * So the shaft stops at the head's base instead. Pure geometry, kept out of the
+ * canvas so it can be checked without one.
+ */
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface ArrowPath {
+    /** Null when the arrow is shorter than its own head — then it is head only. */
+    shaft: {
+        from: Point;
+        to: Point;
+    } | null;
+    /** Tip first, then the two base corners. */
+    head: [Point, Point, Point];
+}
+export declare function arrowPath(from: Point, to: Point, headLength: number): ArrowPath;

package/dist/ui/element.d.ts

@@ -0,0 +1,9 @@
+import type { ErroredQuery } from "../types";
+export declare const REPORTER_TAG = "lw-debug-reporter";
+export declare function setErroredQueriesSource(read: () => ErroredQuery[]): void;
+/**
+ * Idempotent, and the ONLY thing that touches HTMLElement. A second app-wide
+ * mount must not throw on a taken tag name, and a server must be able to import
+ * this module without evaluating a browser class.
+ */
+export declare function defineReporterElement(): void;