@lightworkai.official/debug-capture 0.6.0

package/src/capture/stepCorrelation.ts

@@ -0,0 +1,160 @@
+// Joins the action trail to the network + console it produced.
+//
+// The bundle already captures everything needed to reproduce an issue, but as
+// three PARALLEL lists: "ขั้นตอน (7)", "Network 27", "Console 7". Reading it
+// means joining ~35 timestamped rows against 7 steps by eye to answer the only
+// question that matters — "which click broke it?". This does that join, so a
+// step reads "6. คลิก บันทึก · 3 คำขอ · POST /edocs 500" instead of sending the
+// reader to another tab to guess.
+//
+// Derived at RENDER time from timestamps already in the payload: no new capture,
+// no privacy change, and it works on tickets reported before this existed.
+
+import type {
+  ActionTrailEntry,
+  CapturedConsoleEntry,
+  CapturedRequest,
+} from '../types';
+
+export interface StepActivity {
+  /** ms since the previous step. Null on the first — nothing to measure from. */
+  elapsedMs: number | null;
+  /** Requests that STARTED while this step was the most recent one. */
+  requests: CapturedRequest[];
+  /** Subset that errored or came back >= 400 — usually the answer. */
+  failedRequests: CapturedRequest[];
+  /** error / exception / unhandledrejection logged in the same window. */
+  consoleErrors: CapturedConsoleEntry[];
+  /** Longest request in the window — surfaces the click that appeared to hang. */
+  slowestMs: number | null;
+}
+
+const ERROR_LEVELS = new Set(['error', 'exception', 'unhandledrejection']);
+
+/** A request counts as failed if it rejected outright or returned >= 400. */
+export function isFailedRequest(req: CapturedRequest): boolean {
+  if (req.error) return true;
+  return req.status !== null && req.status >= 400;
+}
+
+/** Epoch ms, or null when the timestamp is missing/unparseable — a bundle from
+ *  an older schema must degrade to "no correlation", never to NaN windows. */
+function timeOf(iso: string | undefined): number | null {
+  if (!iso) return null;
+  const ms = Date.parse(iso);
+  return Number.isNaN(ms) ? null : ms;
+}
+
+/** Path (no origin, no query) for compact display — the origin is identical on
+ *  every row and the query is often a long redacted filter string.
+ *
+ *  Decoded before display: `URL` percent-encodes non-ASCII, and these paths
+ *  routinely carry Thai, so the raw `pathname` would render as a wall of
+ *  `%E0%B9%84…` exactly where a human is trying to read which endpoint failed. */
+export function requestPath(url: string): string {
+  try {
+    const { pathname } = new URL(url, 'http://x');
+    try {
+      return decodeURIComponent(pathname);
+    } catch {
+      return pathname; // malformed escape sequence — better raw than thrown
+    }
+  } catch {
+    // split always yields at least one element; the ?? keeps the strict
+    // index check happy without pretending the array could be empty.
+    return url.split(/[?#]/)[0] ?? url;
+  }
+}
+
+/**
+ * Attribute network + console activity to the step that was current at the time.
+ *
+ * Step `i` owns `[at(i), at(i+1))`; the last step owns everything after it.
+ * Returns one entry per trail row, in the same order, so callers can index by
+ * position without a lookup.
+ *
+ * Activity BEFORE the first recorded step belongs to no step and is omitted:
+ * the trail is a bounded ring buffer, so the earliest rows are frequently
+ * mid-session and anything before them was caused by actions already evicted —
+ * attributing it to step 1 would invent a link that isn't there. The Network and
+ * Console sections still list every row.
+ */
+export function correlateActionTrail(
+  trail: readonly ActionTrailEntry[],
+  network: readonly CapturedRequest[],
+  consoleEntries: readonly CapturedConsoleEntry[],
+): StepActivity[] {
+  const empty = (elapsedMs: number | null): StepActivity => ({
+    elapsedMs,
+    requests: [],
+    failedRequests: [],
+    consoleErrors: [],
+    slowestMs: null,
+  });
+  if (trail.length === 0) return [];
+
+  const stepTimes = trail.map((entry) => timeOf(entry.at));
+
+  // Window end = the next step that HAS a usable timestamp. Skipping unparseable
+  // ones keeps a single bad row from swallowing the rest of the trail.
+  const windowEnd = (index: number): number => {
+    for (let i = index + 1; i < stepTimes.length; i += 1) {
+      const next = stepTimes[i];
+      if (next != null) return next;
+    }
+    return Number.POSITIVE_INFINITY;
+  };
+
+  return trail.map((_entry, index) => {
+    const start = stepTimes[index] ?? null;
+    const prev = (index > 0 ? stepTimes[index - 1] : null) ?? null;
+    // Clamp: a collapsed duplicate refreshes its row's timestamp to the LAST
+    // occurrence, which can put it after a row recorded later. A negative
+    // "elapsed" would read as time travel, so floor it at zero.
+    const elapsedMs =
+      start !== null && prev !== null ? Math.max(0, start - prev) : null;
+    if (start === null) return empty(elapsedMs);
+
+    const from = start;
+    const end = Math.max(from, windowEnd(index));
+    const inWindow = (ms: number | null): boolean =>
+      ms !== null && ms >= from && (ms < end || end === Number.POSITIVE_INFINITY);
+
+    const requests = network.filter((req) => inWindow(timeOf(req.startedAt)));
+    const consoleErrors = consoleEntries.filter(
+      (entry) => ERROR_LEVELS.has(entry.level) && inWindow(timeOf(entry.at)),
+    );
+    const durations = requests
+      .map((req) => req.durationMs)
+      .filter((ms): ms is number => typeof ms === 'number');
+
+    return {
+      elapsedMs,
+      requests,
+      failedRequests: requests.filter(isFailedRequest),
+      consoleErrors,
+      slowestMs: durations.length > 0 ? Math.max(...durations) : null,
+    };
+  });
+}
+
+/** True when a step produced nothing worth showing — lets the UI skip the row
+ *  rather than print a line of zeroes under every step. */
+export function isQuietStep(activity: StepActivity, gapThresholdMs: number): boolean {
+  return (
+    activity.requests.length === 0 &&
+    activity.consoleErrors.length === 0 &&
+    (activity.elapsedMs === null || activity.elapsedMs < gapThresholdMs)
+  );
+}
+
+/** Compact Thai duration: "1.4 วิ" / "12 วิ" / "2 นาที 5 วิ". */
+export function formatDuration(ms: number): string {
+  if (ms < 1000) return `${Math.round(ms)} มิลลิวินาที`;
+  const seconds = ms / 1000;
+  if (seconds < 10) return `${seconds.toFixed(1)} วิ`;
+  if (seconds < 60) return `${Math.round(seconds)} วิ`;
+  const minutes = Math.floor(seconds / 60);
+  const rest = Math.round(seconds % 60);
+  return rest === 0 ? `${minutes} นาที` : `${minutes} นาที ${rest} วิ`;
+}

package/src/config.ts

@@ -0,0 +1,299 @@
+/**
+ * Everything this library refuses to guess.
+ *
+ * The original read the app's env module, its user store and its API-header
+ * helper directly — three imports that made it un-shippable. They are callbacks
+ * now, and the rule they follow is: if a fact belongs to ONE app, the app
+ * supplies it.
+ *
+ * That includes the module vocabulary. The original hard-coded a map of Thai
+ * department names; a package that ships another organisation's org chart is
+ * not a package.
+ *
+ * Nothing here is secret. `realmKey` is public by design — the support ingest
+ * endpoint authenticates the widget with it and rate-limits per IP *and* per
+ * realm precisely because it travels in client code. Do not put a bearer token
+ * in `headers()`; it is captured into every bundle (redacted, but still).
+ */
+import type { DebugUser } from "./types";
+
+/** The shape of html-to-image's `toPng`, without depending on it. */
+export type ToPng = (node: HTMLElement, options?: Record<string, unknown>) => Promise<string>;
+
+export interface DebugCaptureConfig {
+  /** Support host origin, e.g. https://support.example.com */
+  host: string;
+  /** The realm's public embed key. */
+  realmKey: string;
+
+  app: {
+    /**
+     * What this app is called, in the words a support agent would use.
+     *
+     * It becomes the ticket's category, so a desk taking reports from several
+     * apps can filter by the one that broke. The module was doing that job,
+     * derived from the first path segment — which produced badges like "admin"
+     * and told a reader nothing about WHICH admin, of which app. A name the app
+     * states about itself cannot be wrong; one inferred from a URL usually is.
+     */
+    name: string;
+    /** Defaults to "0.0.0". Worth setting: it ties a report to a build. */
+    version?: string;
+    /**
+     * "production" | "uat" | "development" — free text; it is only reported.
+     *
+     * Inferred from the hostname when omitted, which gets localhost right and
+     * everything else wrong-but-harmless. A staging environment is worth naming
+     * yourself; nothing can guess the difference between uat and production
+     * from a URL.
+     */
+    environment?: string;
+  };
+
+  /** Who is using the app. Called at capture time, not at config time. */
+  user?: () => DebugUser;
+
+  /**
+   * Proof of who that is, minted by the HOST'S SERVER. Required only by the
+   * "my tickets" surface.
+   *
+   * `user()` above is a claim; this is evidence. Filing a report needs no
+   * evidence — the worst a false name buys is a mislabelled ticket — but reading
+   * reports back does, because `realmKey` is public and "show me the tickets for
+   * this email" behind a public key is an endpoint that reads everyone's.
+   *
+   * Your server signs a short-lived HS256 JWT with the realm's reporter secret:
+   *
+   *   jwt.sign({ sub: user.id, email: user.email, name: user.fullName },
+   *            process.env.SUPPORT_REPORTER_SECRET,
+   *            { algorithm: 'HS256', expiresIn: '1h' })
+   *
+   * The SECRET NEVER REACHES THE BROWSER. This callback fetches the finished
+   * token from your own backend; it is called per request, so cache it on your
+   * side until it is close to expiring.
+   *
+   * Returning null means "nobody is signed in" — the panel says so rather than
+   * failing.
+   */
+  identity?: () => string | null | Promise<string | null>;
+
+  /**
+   * Extra request headers the app sends, for the record — acting-as ids and
+   * the like. Redacted before it reaches a bundle.
+   */
+  headers?: () => Record<string, string>;
+
+  /**
+   * Which part of the app the user was in — สารบรรณ, ครุภัณฑ์, งบประมาณ.
+   *
+   * This becomes the ticket's category, because on a desk that supports web
+   * applications "which module broke" is the question worth filtering by. It
+   * falls back to `app.name`, so a single-module app still lands somewhere
+   * sensible without configuring anything.
+   *
+   * A DECLARED module is worth having; a guessed one is not. This used to
+   * default to the first path segment, which produced categories like "admin"
+   * — true of the URL and meaningless to whoever picks the report up. If the app
+   * cannot say, it should not guess, so the fallback is the app's own name.
+   *
+   * Return null for a path you have no name for. Most hosts declare a map of
+   * the screens they care about, and the rule this callback exists to enforce
+   * applies to THEM too: without a way to say "not one of mine", the only ways
+   * out are inventing a label or throwing, and a host that throws here looks
+   * like a host with no modules at all.
+   */
+  module?: (pathname: string) => { key: string; label: string } | null;
+
+  /** Anything else worth recording — feature flags, build id, tenant. */
+  extra?: () => Record<string, unknown>;
+
+  capture?: CaptureOptions;
+  redact?: RedactOptions;
+
+  /**
+   * A DOM-rendering screenshot fallback, for browsers without the Screen
+   * Capture API. Supplied by the host so this package never names a dependency
+   * it does not have — a bare `import('html-to-image')` here survives our build
+   * and then fails the CONSUMER's, because a minifier folds any runtime
+   * specifier back into a literal Rollup tries to resolve.
+   *
+   *   screenshotFallback: () => import('html-to-image').then((m) => m.toPng)
+   */
+  screenshotFallback?: () => Promise<ToPng | null>;
+
+  /** UI language. Only affects the built-in reporter's own strings. */
+  locale?: "th" | "en";
+}
+
+export interface CaptureOptions {
+  /** Rolling buffer sizes. */
+  maxRequests?: number;
+  maxConsoleEntries?: number;
+  maxActions?: number;
+  /** Per-response body cap, in characters. */
+  maxBodyChars?: number;
+  /**
+   * Origins whose RESPONSE BODIES may be captured. Same-origin is always
+   * included; anything else records method/status/duration only.
+   */
+  bodyOrigins?: string[];
+  /**
+   * CSS selectors for overlays worth recording when they appear — dialogs,
+   * menus, toasts. Defaults cover ARIA roles, which is most component libraries.
+   */
+  overlaySelectors?: string[];
+}
+
+export interface RedactOptions {
+  /** Extra header names to mask. Matched case-insensitively, as whole names. */
+  headers?: string[];
+  /** Extra query-string keys to mask. */
+  queryKeys?: string[];
+  /** Extra body keys to mask. Matched as a substring, like the built-ins. */
+  bodyKeys?: string[];
+}
+
+const DEFAULTS = {
+  maxRequests: 60,
+  maxConsoleEntries: 120,
+  maxActions: 80,
+  maxBodyChars: 20_000,
+};
+
+let current: DebugCaptureConfig | null = null;
+
+export function configureDebugCapture(config: DebugCaptureConfig): void {
+  current = config;
+}
+
+/**
+ * Throws rather than returning a default. A bundle assembled against a
+ * half-configured library would be submitted to nowhere and look like it
+ * worked — and that failure surfaces as a missing ticket, days later.
+ */
+export function getConfig(): DebugCaptureConfig {
+  if (!current) throw new Error("[debug-capture] configureDebugCapture() has not been called");
+  return current;
+}
+
+export function isConfigured(): boolean {
+  return current !== null;
+}
+
+/**
+ * The app's identity, with the parts it did not bother to state filled in.
+ *
+ * Everything optional in this library is optional because a sensible default
+ * exists — the config a host writes should be the things only that host knows.
+ */
+export function appInfo(): { name: string; version: string; environment: string } {
+  const app = getConfig().app;
+  return {
+    name: app.name,
+    version: app.version ?? "0.0.0",
+    environment: app.environment ?? guessEnvironment(),
+  };
+}
+
+function guessEnvironment(): string {
+  if (typeof window === "undefined") return "unknown";
+  const host = window.location.hostname;
+  if (host === "localhost" || host === "127.0.0.1" || host.endsWith(".local")) return "development";
+  return "production";
+}
+
+export function captureOption(key: keyof typeof DEFAULTS): number {
+  const value = current?.capture?.[key];
+  return typeof value === "number" ? value : DEFAULTS[key];
+}
+
+/**
+ * The host's module for this path, or nothing.
+ *
+ * Nothing, deliberately: an undeclared module is not the first path segment. See
+ * the note on `module` above.
+ */
+export function resolveModule(pathname: string): { key: string; label: string } | null {
+  const custom = current?.module;
+  if (!custom) return null;
+  try {
+    return custom(pathname) ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/** Redaction extras, always a usable shape even before configure() runs. */
+export function getRedactOptions(): Required<RedactOptions> {
+  const r = current?.redact;
+  return {
+    headers: r?.headers ?? [],
+    queryKeys: (r?.queryKeys ?? []).map((k) => k.toLowerCase()),
+    bodyKeys: (r?.bodyKeys ?? []).map((k) => k.toLowerCase()),
+  };
+}
+
+export function overlaySelectors(): string[] {
+  return current?.capture?.overlaySelectors ?? [];
+}
+
+/**
+ * Whether a response body from this URL may be stored.
+ *
+ * Same-origin always: the app's own API is the whole reason anyone opens a
+ * report. Anything else only if the host named it in `bodyOrigins` — a body
+ * from a third party the host merely calls is not ours to collect.
+ *
+ * The one exclusion is the WIDGET'S OWN traffic: `/ingest/*` on the support
+ * host. Those calls are this library talking to itself, and a report that
+ * contains the request which fetched the report's own config tells a reader
+ * nothing.
+ *
+ * It used to exclude the support host's WHOLE origin, as a guard against a
+ * report filed from a ticket screen storing ticket bodies that themselves carry
+ * earlier reports' captured data. That was too blunt by half: when the app IS
+ * the support product filing its own bugs, the support host is its
+ * own origin, so the guard dropped every body it had and reports arrived with
+ * nothing but URLs and timings.
+ *
+ * The compounding it worried about is already bounded, and was before: every
+ * body is truncated at `maxBodyChars` (20k), a response over 1 MB is never read
+ * at all, and `trimToBudget` caps the finished bundle at 2 MB. A second, much
+ * coarser cap on top of those cost far more than it saved.
+ */
+export function mayCaptureBody(url: string): boolean {
+  if (typeof window === "undefined") return false;
+  let target: URL;
+  try {
+    target = new URL(url, window.location.href);
+  } catch {
+    return false;
+  }
+  if (isWidgetTraffic(target)) return false;
+  if (target.origin === window.location.origin) return true;
+  return (current?.capture?.bodyOrigins ?? []).some((allowed) => {
+    try {
+      return new URL(allowed).origin === target.origin;
+    } catch {
+      return false;
+    }
+  });
+}
+
+/**
+ * This library talking to the support host — `/ingest/config`, `/ingest/me/…`.
+ *
+ * Matched by PATH as well as origin, deliberately. Matching the origin alone is
+ * what made a self-hosted support app unable to capture anything: its own API
+ * lives on that origin too.
+ */
+export function isWidgetTraffic(target: URL): boolean {
+  if (!current?.host) return false;
+  try {
+    if (new URL(current.host).origin !== target.origin) return false;
+  } catch {
+    // A malformed host is the consumer's problem, not a reason to throw here.
+    return false;
+  }
+  return target.pathname.startsWith("/ingest/");
+}

package/src/context.ts

@@ -0,0 +1,81 @@
+/**
+ * The safe session / page / environment context for a bundle.
+ *
+ * Everything app-specific arrives through config callbacks; this file only
+ * reads what the browser itself knows. No token is ever read, and the host's
+ * own headers go through the same redaction as captured traffic — a header the
+ * app considers routine ("X-Employee-Id") is fine, one that turns out to be a
+ * credential is not, and this cannot tell them apart.
+ */
+import { appInfo, getConfig, resolveModule } from "./config";
+import { redactHeaders } from "./capture/redact";
+import type { DebugContext } from "./types";
+
+interface PerfMemory {
+  usedJSHeapSize: number;
+  jsHeapSizeLimit: number;
+}
+
+function readPerformance(): DebugContext["performance"] {
+  const result: DebugContext["performance"] = {
+    memoryUsedMb: null,
+    memoryLimitMb: null,
+    domContentLoadedMs: null,
+    loadEventMs: null,
+  };
+  if (typeof performance === "undefined") return result;
+
+  const memory = (performance as Performance & { memory?: PerfMemory }).memory;
+  if (memory) {
+    result.memoryUsedMb = Math.round(memory.usedJSHeapSize / 1024 / 1024);
+    result.memoryLimitMb = Math.round(memory.jsHeapSizeLimit / 1024 / 1024);
+  }
+  const [nav] = performance.getEntriesByType("navigation") as PerformanceNavigationTiming[];
+  if (nav) {
+    result.domContentLoadedMs = Math.round(nav.domContentLoadedEventEnd);
+    result.loadEventMs = Math.round(nav.loadEventEnd);
+  }
+  return result;
+}
+
+/** Never throws: a context that half-collected still beats no report at all. */
+function safely<T>(read: (() => T) | undefined, fallback: T): T {
+  if (!read) return fallback;
+  try {
+    return read();
+  } catch {
+    return fallback;
+  }
+}
+
+export function collectContext(): DebugContext {
+  const config = getConfig();
+  const { pathname, search, href } = window.location;
+
+  return {
+    capturedAt: new Date().toISOString(),
+    route: { href, pathname, search },
+    module: resolveModule(pathname),
+    user: safely(config.user, {}),
+    apiHeaders: redactHeaders(safely(config.headers, {})),
+    app: {
+      name: appInfo().name,
+      version: appInfo().version,
+      environment: appInfo().environment,
+    },
+    client: {
+      userAgent: navigator.userAgent,
+      language: navigator.language,
+      platform: navigator.platform,
+      online: navigator.onLine,
+      viewport: {
+        width: window.innerWidth,
+        height: window.innerHeight,
+        dpr: window.devicePixelRatio,
+      },
+      screen: { width: window.screen.width, height: window.screen.height },
+    },
+    performance: readPerformance(),
+    extra: safely(config.extra, {}),
+  };
+}

package/src/embed.ts

@@ -0,0 +1,35 @@
+/**
+ * Script-tag build. For an app with no bundler — configure from a global and
+ * arm on load, so adding the reporter is two lines of HTML.
+ *
+ *   <script src="debug-capture.js"
+ *           data-host="https://support.example.com"
+ *           data-realm-key="pk_live_…"
+ *           data-app-name="ระบบสารบรรณ"
+ *           data-app-version="1.4.2"
+ *           data-environment="production"></script>
+ */
+import { configureDebugCapture } from "./config";
+import { installDebugCapture } from "./install";
+import { launch } from "./reporter";
+
+const script = document.currentScript as HTMLScriptElement | null;
+const data = script?.dataset ?? {};
+
+if (data.host && data.realmKey) {
+  configureDebugCapture({
+    host: data.host,
+    realmKey: data.realmKey,
+    app: {
+      name: data.appName ?? document.title ?? "app",
+      version: data.appVersion ?? "0.0.0",
+      environment: data.environment ?? "production",
+    },
+    locale: data.locale === "en" ? "en" : "th",
+  });
+  installDebugCapture();
+}
+
+// The only handle a no-bundler page gets. Call it from a button's onclick —
+// directly, so the click is still the active gesture when screen capture asks.
+(window as unknown as { lwReportProblem: typeof launch }).lwReportProblem = launch;

package/src/index.ts

@@ -0,0 +1,109 @@
+/**
+ * @lightworkai.official/debug-capture
+ *
+ * Rolling capture of what a user was doing — network, console, actions — plus a
+ * screenshot they can draw on, filed as a ticket on a Lightwork Support host.
+ *
+ * Extracted from an in-app reporter built for a single app. What changed is
+ * everything that made it one app's: the user store, the env module, the API
+ * client and a hard-coded Thai module vocabulary are all config now. Nothing in
+ * this package is confidential, and the realm key it takes is public by design.
+ */
+export { configureDebugCapture, isConfigured, getConfig, appInfo } from "./config";
+export type { DebugCaptureConfig, CaptureOptions, RedactOptions } from "./config";
+
+export { installDebugCapture } from "./install";
+export type { InstallOptions } from "./install";
+
+export { launch, onLaunch, onCrash, emitCrash } from "./reporter";
+
+export { buildBundle, bundleToMarkdown, hasCause, bundleFileName, toCurl } from "./bundle";
+export { submitBundle } from "./submit";
+export type { FiledTicket } from "./submit";
+export { errorSignature } from "./signature";
+export { trimToBudget, BUNDLE_BUDGET_BYTES } from "./budget";
+export { captureScreen } from "./screenshot";
+
+export { getNetworkLog } from "./capture/networkBuffer";
+export { getConsoleLog } from "./capture/consoleBuffer";
+export { getActionTrail, actionCountSuffix } from "./capture/actionTrail";
+export { correlateActionTrail, isQuietStep, isFailedRequest, requestPath, formatDuration } from "./capture/stepCorrelation";
+export type { StepActivity } from "./capture/stepCorrelation";
+export { redactBody, redactHeaders, redactLabel, redactUrl, REDACTED } from "./capture/redact";
+
+// NOT the element class: exporting it by name is what forced `extends
+// HTMLElement` to evaluate on import, and took down every server-rendered app.
+// `defineReporterElement()` builds it in the browser, where it exists.
+export { defineReporterElement, setErroredQueriesSource, REPORTER_TAG } from "./ui/element";
+export { showToast } from "./ui/toast";
+
+/*
+ * The annotator ENGINE, shared by every framework package.
+ *
+ * A canvas is imperative — there is no declarative way to draw on one — so this
+ * stays here rather than being rewritten three times. What each framework wraps
+ * around it is the chrome: a dialog, a toolbar, two buttons.
+ *
+ * Its labels come from the reporter dialog's own string bag, because they are
+ * the same words: กรอบ, ลูกศร, ไฮไลต์, ข้อความ.
+ */
+export { createAnnotator } from "./ui/annotator";
+export type { Annotator, AnnotatorTool } from "./ui/annotator";
+export { strings as reporterStrings } from "./ui/strings";
+export type { Strings as ReporterStrings } from "./ui/strings";
+export {
+  listMyTickets,
+  getMyTicket,
+  getMyTicketByNumber,
+  getMyTicketHistory,
+  replyToTicket,
+  editMyMessage,
+  reopenMyTicket,
+  uploadInlineImage,
+  getAttachmentUrl,
+  fetchRealmConfig,
+  TicketApiError,
+  NoIdentityError,
+} from "./mytickets/api";
+export type {
+  MyTicket,
+  MyTicketListItem,
+  MyTicketDetail,
+  TicketMessage,
+  TicketAttachment,
+  StatusEvent,
+  StatusColumn,
+  RealmConfig,
+} from "./mytickets/api";
+export {
+  ticketKey,
+  formatDateTime,
+  statusMaps,
+  hasSolution,
+  hasTeamReply,
+  responseRank,
+  compareBy,
+  matchesKeyword,
+  pageOf,
+  pageCount,
+  PAGE_SIZE,
+} from "./mytickets/format";
+export type { StatusMaps, Sort, SortKey } from "./mytickets/format";
+export {
+  toPlainText,
+  looksLikeHtml,
+  renderBody,
+  cleanHtml,
+  htmlIsEmpty,
+  ALLOWED_TAGS,
+  ALLOWED_ATTR,
+  isAllowedHref,
+  isAllowedImageSrc,
+} from "./mytickets/sanitize";
+export { NOTE_TOOLBAR, FULL_TOOLBAR } from "./mytickets/toolbar";
+export type { EditorTool } from "./mytickets/toolbar";
+export { ticketStrings } from "./mytickets/strings";
+export type { TicketStrings } from "./mytickets/strings";
+export { statusTone, STATUS_TONES } from "./mytickets/format";
+
+export type * from "./types";