@fastbackr/core 0.0.0-stage → 0.0.3

package/LICENSE

@@ -0,0 +1,46 @@
+Fastbackr SDK License
+
+Copyright (c) 2026 OpsCom, Corp. All rights reserved.
+
+This license covers the "@fastbackr/core" npm package and its source code (the
+"Software"). The Software is not open source. By installing or using it you
+accept these terms.
+
+1. Grant. OpsCom, Corp. grants you a free, non-exclusive, non-transferable,
+   non-sublicensable license to install and use the Software, solely to connect
+   your websites and applications to the Fastbackr service.
+
+2. Redistribution. You may redistribute the Software only unmodified and only
+   as part of your own website or application. Bundling, minifying,
+   transpiling or tree-shaking the Software with your build tools, as part of
+   building your own website or application, is not a modification under
+   this license.
+
+3. Restrictions. Except as section 2 allows, you may not:
+   a. modify, adapt or translate the Software, or create derivative works of
+      it;
+   b. distribute, publish or make available any modified version of the
+      Software;
+   c. use the Software with any service other than the Fastbackr service;
+   d. sell, rent, lease or sublicense the Software on its own;
+   e. remove or alter this license or any copyright notice;
+   f. reverse engineer, decompile or disassemble the Software, except to the
+      extent applicable law expressly permits it despite this restriction.
+
+4. Ownership. The Software is licensed, not sold. OpsCom, Corp. keeps all
+   rights, title and interest in the Software not expressly granted here.
+
+5. Termination. This license ends automatically if you breach any of its
+   terms. On termination you must stop using the Software and remove it from
+   your websites and applications.
+
+6. No warranty. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+   EXPRESS OR IMPLIED, INCLUDING THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR
+   A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+
+7. Limitation of liability. IN NO EVENT SHALL OPSCOM, CORP. BE LIABLE FOR ANY
+   CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+   OF OR OTHER DEALINGS IN THE SOFTWARE.
+
+8. Governing law. This license is governed by the laws of the United States.

package/README.md

@@ -1,3 +1,18 @@
-# Temporary Holding Version
+# @fastbackr/core
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+What every Fastbackr SDK shares: the API's contract, the helper your server calls, and the browser
+logic a UI package draws on. React apps install it next to `@fastbackr/react`.
+
+| Import                     | Runs in     | What it is                                                      |
+| -------------------------- | ----------- | --------------------------------------------------------------- |
+| `@fastbackr/core/server`   | Your server | `createTokenHandler`, `createReviewerToken`, `FastbackrError`   |
+| `@fastbackr/core/contract` | Anywhere    | The API's request and response types and constants              |
+| `@fastbackr/core/boot`     | Browser     | What runs before the UI loads: `+` button, gesture, CSP warning |
+| `@fastbackr/core`          | Browser     | Tokens, the API client, anchors, select mode, the Shadow layer  |
+
+`boot` is kept small because it loads on every page view; the main entry arrives with the lazy UI.
+Neither draws panels: each UI package draws its own. See `packages/react/README.md` for setup.
+
+## License
+
+Free to install and use with the Fastbackr service. Modifying it is not allowed. See `LICENSE`.

package/dist/boot.d.ts

@@ -0,0 +1,22 @@
+import { $ as DEFAULT_ENDPOINT, et as normalizeEndpoint } from "./contract-DuT5YjZ3.js";
+import { a as rememberHidden, c as watchRevealGesture, n as GetToken, o as rememberVisible, r as isHidden, s as shouldRevealOnLoad, t as FastbackrOptions } from "./types-BV61V0KT.js";
+//#region src/csp.d.ts
+export declare function watchCsp(endpointOrigin: string, signal: AbortSignal): void;
+//#endregion
+//#region src/fab.d.ts
+export declare class Fab {
+  private readonly host;
+  private readonly root;
+  private wanted;
+  private readonly glow;
+  constructor(click: () => void);
+  show(): void;
+  flash(): void;
+  private place;
+  hide(): void;
+}
+//#endregion
+//#region src/token-route.d.ts
+export declare function tokenRoute(url?: string): GetToken;
+//#endregion
+export { DEFAULT_ENDPOINT, type FastbackrOptions, type GetToken, isHidden, normalizeEndpoint, rememberHidden, rememberVisible, shouldRevealOnLoad, watchRevealGesture };

package/dist/boot.js

@@ -0,0 +1,94 @@
+import { g as normalizeEndpoint, h as DEFAULT_ENDPOINT, n as DEFAULT_TOKEN_ROUTE } from "./contract-CzTIqzyE.js";
+import { n as errorFromResponse } from "./error-rNSfYFOm.js";
+import { a as rememberHidden, c as watchRevealGesture, o as rememberVisible, r as isHidden, s as shouldRevealOnLoad } from "./gesture-CSkNZJqY.js";
+//#region src/csp.ts
+function blocksEndpoint(event, endpointOrigin) {
+	if (event.effectiveDirective !== "connect-src" && event.effectiveDirective !== "default-src") return false;
+	try {
+		return new URL(event.blockedURI).origin === endpointOrigin;
+	} catch {
+		return false;
+	}
+}
+function cspMessage(endpointOrigin) {
+	return `Fastbackr: this page's Content-Security-Policy blocks ${endpointOrigin}, so feedback cannot load. Add it to connect-src, for example: connect-src 'self' ${endpointOrigin}`;
+}
+function watchCsp(endpointOrigin, signal) {
+	let logged = false;
+	document.addEventListener("securitypolicyviolation", (event) => {
+		if (logged || !blocksEndpoint(event, endpointOrigin)) return;
+		logged = true;
+		console.error(cspMessage(endpointOrigin));
+	}, { signal });
+}
+//#endregion
+//#region src/fab.ts
+const CSS = ":host{all:initial}button{position:fixed;right:16px;bottom:16px;z-index:2147483646;box-sizing:border-box;width:52px;height:52px;padding:8px;border:0;border-radius:50%;background:#fff;cursor:pointer;box-shadow:0 0 0 1px #090b0c1a,0 20px 25px -5px #0000001a,0 8px 10px -6px #0000001a}span{display:grid;place-items:center;width:36px;height:36px;border-radius:50%;background:#9ae600;color:#35530e}svg{width:24px;height:24px}button:hover span{background:#b4f033}button{animation:fade-in .25s ease-out}@keyframes fade-in{from{opacity:0}}button:focus-visible{outline:3px solid #9ca8ab80;outline-offset:0}i{position:fixed;right:14px;bottom:14px;z-index:2147483645;width:56px;height:56px;border-radius:50%;pointer-events:none;animation:glow .3s linear both}i::before,i::after{content:'';position:absolute;inset:0;border-radius:50%;background:conic-gradient(transparent,#ff3b30 4%,#ff9500 7%,#ffcc00 10%,#34c759 13%,#007aff 16%,#af52de 19%,transparent 23%)}i::before{filter:blur(10px);opacity:.75}i.flash{animation-duration:2s}@keyframes glow{from{rotate:0deg;opacity:0}15%,80%{opacity:1}to{rotate:360deg;opacity:0}}@media (min-width:640px){button{right:22px;bottom:22px}i{right:20px;bottom:20px}}@media (prefers-reduced-motion:reduce){button{animation:none}i{display:none}}@media print{button,i{display:none}}";
+const PLUS = "<span><svg viewBox=\"0 0 24 24\" fill=\"currentColor\" aria-hidden=\"true\"><path d=\"M11 11V5H13V11H19V13H13V19H11V13H5V11H11Z\"/></svg></span>";
+var Fab = class {
+	host = document.createElement("div");
+	root;
+	wanted = false;
+	glow = document.createElement("i");
+	constructor(click) {
+		this.host.dataset.fastbackrRoot = "";
+		this.root = this.host.attachShadow({ mode: "open" });
+		const style = document.createElement("style");
+		style.textContent = CSS;
+		const button = document.createElement("button");
+		button.type = "button";
+		button.innerHTML = PLUS;
+		button.setAttribute("aria-label", "Leave feedback");
+		button.title = "Leave feedback";
+		button.addEventListener("click", click);
+		this.glow.addEventListener("animationend", () => this.glow.remove());
+		this.root.append(style, this.glow, button);
+	}
+	show() {
+		this.wanted = true;
+		if (!document.body) {
+			document.addEventListener("DOMContentLoaded", () => this.place(), { once: true });
+			return;
+		}
+		this.place();
+	}
+	flash() {
+		this.glow.remove();
+		this.glow.className = "flash";
+		this.root.prepend(this.glow);
+	}
+	place() {
+		if (this.wanted && !this.host.isConnected) document.body.append(this.host);
+	}
+	hide() {
+		this.wanted = false;
+		this.glow.remove();
+		this.host.remove();
+	}
+};
+//#endregion
+//#region src/token-route.ts
+function tokenRoute(url = DEFAULT_TOKEN_ROUTE) {
+	return async (guest) => {
+		const body = guest ? { guest: {
+			id: guest.id,
+			name: guest.name
+		} } : {};
+		const response = await fetch(url, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(body),
+			cache: "no-store",
+			credentials: "same-origin"
+		});
+		if (response.status === 401) return null;
+		if (!response.ok) {
+			const error = await errorFromResponse(response);
+			if (error.code === "guest_access_off") return null;
+			throw error;
+		}
+		return await response.json();
+	};
+}
+//#endregion
+export { DEFAULT_ENDPOINT, Fab, isHidden, normalizeEndpoint, rememberHidden, rememberVisible, shouldRevealOnLoad, tokenRoute, watchCsp, watchRevealGesture };

package/dist/contract-CzTIqzyE.js

@@ -0,0 +1,82 @@
+//#region src/endpoint.ts
+const DEFAULT_ENDPOINT = "https://api.fastbackr.com";
+function normalizeEndpoint(value) {
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		throw new TypeError(`Fastbackr endpoint must be an absolute URL, got "${value}".`);
+	}
+	if (url.protocol !== "https:" && url.protocol !== "http:") throw new TypeError(`Fastbackr endpoint must use http or https, got "${url.protocol}".`);
+	if (url.search || url.hash) throw new TypeError("Fastbackr endpoint must not carry a query or hash.");
+	return `${url.origin}${url.pathname}`.replace(/\/+$/, "");
+}
+//#endregion
+//#region src/contract.ts
+const API_VERSION = "v1";
+const ROUTES = {
+	tokens: "/v1/tokens",
+	threads: "/v1/threads",
+	thread: "/v1/threads/:id",
+	messages: "/v1/threads/:id/messages",
+	relocate: "/v1/threads/:id/relocate",
+	suggestion: "/v1/threads/:id/suggestion",
+	screenshot: "/v1/threads/:id/screenshot"
+};
+const paths = {
+	tokens: () => ROUTES.tokens,
+	threads: () => ROUTES.threads,
+	thread: (id) => `${ROUTES.threads}/${encodeURIComponent(id)}`,
+	messages: (id) => `${ROUTES.threads}/${encodeURIComponent(id)}/messages`,
+	relocate: (id) => `${ROUTES.threads}/${encodeURIComponent(id)}/relocate`,
+	suggestion: (id) => `${ROUTES.threads}/${encodeURIComponent(id)}/suggestion`,
+	screenshot: (id) => `${ROUTES.threads}/${encodeURIComponent(id)}/screenshot`
+};
+const LIMITS = {
+	bodyChars: 1e4,
+	anchorBytes: 32768,
+	pathChars: 2048,
+	titleChars: 300,
+	shortChars: 200,
+	requestBytes: 65536,
+	relocateBytes: 2097152,
+	screenshotBytes: 1048576,
+	pathSteps: 100,
+	stepClasses: 6,
+	listItems: 500,
+	ancestorHints: 6,
+	selectorCandidates: 4,
+	selectorChars: 1e3,
+	tagNameChars: 60,
+	reviewerIdChars: 200,
+	reviewerNameChars: 200,
+	emailChars: 320,
+	excerptChars: 140
+};
+const SENSITIVE_QUERY_KEY = /token|password|secret|credential|authorization|__done_/i;
+const GUEST_ACCESS = [
+	"off",
+	"write-only",
+	"read-write"
+];
+const TOKEN_ALGORITHM = "HS256";
+const TOKEN_TTL_SECONDS = 3600;
+const DEFAULT_TOKEN_ROUTE = "/api/fastbackr";
+const THREAD_STATUSES = ["open", "done"];
+const SUGGESTION_DECISIONS = ["accept", "reject"];
+const SCREENSHOT_TYPES = ["image/webp", "image/jpeg"];
+const SCREENSHOT_WINDOW_SECONDS = 600;
+const ERROR_CODES = [
+	"invalid_request",
+	"invalid_content_type",
+	"request_too_large",
+	"unauthorized",
+	"forbidden",
+	"origin_denied",
+	"guest_access_off",
+	"not_found",
+	"rate_limited",
+	"internal"
+];
+//#endregion
+export { LIMITS as a, SCREENSHOT_WINDOW_SECONDS as c, THREAD_STATUSES as d, TOKEN_ALGORITHM as f, normalizeEndpoint as g, DEFAULT_ENDPOINT as h, GUEST_ACCESS as i, SENSITIVE_QUERY_KEY as l, paths as m, DEFAULT_TOKEN_ROUTE as n, ROUTES as o, TOKEN_TTL_SECONDS as p, ERROR_CODES as r, SCREENSHOT_TYPES as s, API_VERSION as t, SUGGESTION_DECISIONS as u };

package/dist/contract-DuT5YjZ3.d.ts

@@ -0,0 +1,230 @@
+//#region src/endpoint.d.ts
+declare const DEFAULT_ENDPOINT = "https://api.fastbackr.com";
+declare function normalizeEndpoint(value: string): string;
+//#endregion
+//#region src/contract.d.ts
+declare const API_VERSION = "v1";
+declare const ROUTES: {
+  readonly tokens: "/v1/tokens";
+  readonly threads: "/v1/threads";
+  readonly thread: "/v1/threads/:id";
+  readonly messages: "/v1/threads/:id/messages";
+  readonly relocate: "/v1/threads/:id/relocate";
+  readonly suggestion: "/v1/threads/:id/suggestion";
+  readonly screenshot: "/v1/threads/:id/screenshot";
+};
+type Route = (typeof ROUTES)[keyof typeof ROUTES];
+declare const paths: {
+  readonly tokens: () => string;
+  readonly threads: () => string;
+  readonly thread: (id: string) => string;
+  readonly messages: (id: string) => string;
+  readonly relocate: (id: string) => string;
+  readonly suggestion: (id: string) => string;
+  readonly screenshot: (id: string) => string;
+};
+declare const LIMITS: {
+  readonly bodyChars: 10000;
+  readonly anchorBytes: number;
+  readonly pathChars: 2048;
+  readonly titleChars: 300;
+  readonly shortChars: 200;
+  readonly requestBytes: number;
+  readonly relocateBytes: number;
+  readonly screenshotBytes: number;
+  readonly pathSteps: 100;
+  readonly stepClasses: 6;
+  readonly listItems: 500;
+  readonly ancestorHints: 6;
+  readonly selectorCandidates: 4;
+  readonly selectorChars: 1000;
+  readonly tagNameChars: 60;
+  readonly reviewerIdChars: 200;
+  readonly reviewerNameChars: 200;
+  readonly emailChars: 320;
+  readonly excerptChars: 140;
+};
+declare const SENSITIVE_QUERY_KEY: RegExp;
+declare const GUEST_ACCESS: readonly ["off", "write-only", "read-write"];
+type GuestAccess = (typeof GUEST_ACCESS)[number];
+type Reviewer = Readonly<{
+  id: string;
+  name: string;
+  email?: string;
+  verified: boolean;
+}>;
+type GuestIdentity = Readonly<{
+  id: string;
+  name: string;
+}>;
+declare const TOKEN_ALGORITHM = "HS256";
+declare const TOKEN_TTL_SECONDS: number;
+type TokenClaims = Readonly<{
+  sub: string;
+  pid: string;
+  name: string;
+  email?: string;
+  verified: boolean;
+  iat: number;
+  exp: number;
+}>;
+type CreateTokenRequest = Readonly<{
+  user: Reviewer;
+}>;
+type Features = Readonly<{
+  screenshots: boolean;
+}>;
+type CreateTokenResponse = Readonly<{
+  token: string;
+  expiresAt: string;
+  user: Reviewer;
+  features?: Features;
+}>;
+declare const DEFAULT_TOKEN_ROUTE = "/api/fastbackr";
+type TokenRouteRequest = Readonly<{
+  guest?: GuestIdentity;
+}>;
+type PageContext = Readonly<{
+  key: string;
+  path: string;
+  title: string;
+}>;
+type AnchorHint = Readonly<{
+  tagName: string;
+  stableId?: string;
+  label?: string;
+}>;
+type AnchorRegion = Readonly<{
+  xRatio: number;
+  yRatio: number;
+  widthRatio: number;
+  heightRatio: number;
+}>;
+type ElementSignature = Readonly<{
+  tag: string;
+  id?: string;
+  stableId?: string;
+  role?: string;
+  classes?: readonly string[];
+  textHash?: string;
+}>;
+type PathStep = ElementSignature & Readonly<{
+  index: number;
+}>;
+type SkeletonNode = ElementSignature & Readonly<{
+  children?: readonly SkeletonNode[];
+}>;
+type Anchor = Readonly<{
+  version: 1;
+  kind: "element";
+  stableId?: string;
+  componentLabel?: string;
+  tagName: string;
+  role?: string;
+  accessibleLabel?: string;
+  textExcerpt?: string;
+  elementId?: string;
+  ancestorHints: readonly AnchorHint[];
+  selectorCandidates: readonly string[];
+  boundary: "element" | "marked-component";
+  clickOffset: Readonly<{
+    xRatio: number;
+    yRatio: number;
+  }>;
+  capturedRect: Readonly<{
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  }>;
+  region?: AnchorRegion;
+  viewport?: Readonly<{
+    width: number;
+    height: number;
+  }>;
+  path?: readonly PathStep[];
+}>;
+declare const THREAD_STATUSES: readonly ["open", "done"];
+type ThreadStatus = (typeof THREAD_STATUSES)[number];
+type Thread = Readonly<{
+  id: string;
+  number: number;
+  pageKey: string;
+  path: string;
+  title: string;
+  anchor: Anchor;
+  status: ThreadStatus;
+  createdAt: string;
+  updatedAt: string;
+  authorName: string;
+  authorVerified: boolean;
+  excerpt: string;
+  messageCount: number;
+  hasScreenshot: boolean;
+  suggestion?: AnchorSuggestion;
+}>;
+type AnchorSuggestion = Readonly<{
+  id: string;
+  anchor: Anchor;
+  confidence: number;
+}>;
+type Message = Readonly<{
+  id: string;
+  authorName: string;
+  authorVerified: boolean;
+  body: string;
+  createdAt: string;
+}>;
+type ListThreadsQuery = Readonly<{
+  status?: ThreadStatus | "all";
+  page?: string;
+}>;
+type ListThreadsResponse = Readonly<{
+  items: readonly Thread[];
+}>;
+type CreateThreadRequest = Readonly<{
+  page: PageContext;
+  anchor: Anchor;
+  body: string;
+}>;
+type CreateThreadResponse = Thread;
+type ThreadDetail = Readonly<{
+  thread: Thread;
+  messages: readonly Message[];
+}>;
+type GetThreadResponse = ThreadDetail;
+type UpdateThreadRequest = Readonly<{
+  status: ThreadStatus;
+}>;
+type UpdateThreadResponse = Thread;
+type CreateMessageRequest = Readonly<{
+  body: string;
+}>;
+type CreateMessageResponse = Message;
+type RelocateRequest = Readonly<{
+  breakAt: number;
+  skeleton: SkeletonNode;
+}>;
+type RelocateResponse = Readonly<{
+  suggestion: AnchorSuggestion | null;
+}>;
+declare const SUGGESTION_DECISIONS: readonly ["accept", "reject"];
+type SuggestionDecision = (typeof SUGGESTION_DECISIONS)[number];
+type DecideSuggestionRequest = Readonly<{
+  suggestionId: string;
+  decision: SuggestionDecision;
+}>;
+type DecideSuggestionResponse = Thread;
+declare const SCREENSHOT_TYPES: readonly ["image/webp", "image/jpeg"];
+type ScreenshotType = (typeof SCREENSHOT_TYPES)[number];
+declare const SCREENSHOT_WINDOW_SECONDS: number;
+declare const ERROR_CODES: readonly ["invalid_request", "invalid_content_type", "request_too_large", "unauthorized", "forbidden", "origin_denied", "guest_access_off", "not_found", "rate_limited", "internal"];
+type ErrorCode = (typeof ERROR_CODES)[number];
+type ErrorEnvelope = Readonly<{
+  error: Readonly<{
+    code: ErrorCode;
+    message: string;
+  }>;
+}>;
+//#endregion
+export { DEFAULT_ENDPOINT as $, ROUTES as A, SkeletonNode as B, GuestIdentity as C, Message as D, ListThreadsResponse as E, SCREENSHOT_TYPES as F, Thread as G, THREAD_STATUSES as H, SCREENSHOT_WINDOW_SECONDS as I, TokenClaims as J, ThreadDetail as K, SENSITIVE_QUERY_KEY as L, RelocateResponse as M, Reviewer as N, PageContext as O, Route as P, paths as Q, SUGGESTION_DECISIONS as R, GuestAccess as S, ListThreadsQuery as T, TOKEN_ALGORITHM as U, SuggestionDecision as V, TOKEN_TTL_SECONDS as W, UpdateThreadRequest as X, TokenRouteRequest as Y, UpdateThreadResponse as Z, ErrorCode as _, AnchorSuggestion as a, GUEST_ACCESS as b, CreateThreadRequest as c, CreateTokenResponse as d, normalizeEndpoint as et, DEFAULT_TOKEN_ROUTE as f, ElementSignature as g, ERROR_CODES as h, AnchorRegion as i, RelocateRequest as j, PathStep as k, CreateThreadResponse as l, DecideSuggestionResponse as m, Anchor as n, CreateMessageRequest as o, DecideSuggestionRequest as p, ThreadStatus as q, AnchorHint as r, CreateMessageResponse as s, API_VERSION as t, CreateTokenRequest as u, ErrorEnvelope as v, LIMITS as w, GetThreadResponse as x, Features as y, ScreenshotType as z };

package/dist/contract.d.ts

@@ -0,0 +1,2 @@
+import { $ as DEFAULT_ENDPOINT, A as ROUTES, B as SkeletonNode, C as GuestIdentity, D as Message, E as ListThreadsResponse, F as SCREENSHOT_TYPES, G as Thread, H as THREAD_STATUSES, I as SCREENSHOT_WINDOW_SECONDS, J as TokenClaims, K as ThreadDetail, L as SENSITIVE_QUERY_KEY, M as RelocateResponse, N as Reviewer, O as PageContext, P as Route, Q as paths, R as SUGGESTION_DECISIONS, S as GuestAccess, T as ListThreadsQuery, U as TOKEN_ALGORITHM, V as SuggestionDecision, W as TOKEN_TTL_SECONDS, X as UpdateThreadRequest, Y as TokenRouteRequest, Z as UpdateThreadResponse, _ as ErrorCode, a as AnchorSuggestion, b as GUEST_ACCESS, c as CreateThreadRequest, d as CreateTokenResponse, f as DEFAULT_TOKEN_ROUTE, g as ElementSignature, h as ERROR_CODES, i as AnchorRegion, j as RelocateRequest, k as PathStep, l as CreateThreadResponse, m as DecideSuggestionResponse, n as Anchor, o as CreateMessageRequest, p as DecideSuggestionRequest, q as ThreadStatus, r as AnchorHint, s as CreateMessageResponse, t as API_VERSION, u as CreateTokenRequest, v as ErrorEnvelope, w as LIMITS, x as GetThreadResponse, y as Features, z as ScreenshotType } from "./contract-DuT5YjZ3.js";
+export { API_VERSION, Anchor, AnchorHint, AnchorRegion, AnchorSuggestion, CreateMessageRequest, CreateMessageResponse, CreateThreadRequest, CreateThreadResponse, CreateTokenRequest, CreateTokenResponse, DEFAULT_ENDPOINT, DEFAULT_TOKEN_ROUTE, DecideSuggestionRequest, DecideSuggestionResponse, ERROR_CODES, ElementSignature, ErrorCode, ErrorEnvelope, Features, GUEST_ACCESS, GetThreadResponse, GuestAccess, GuestIdentity, LIMITS, ListThreadsQuery, ListThreadsResponse, Message, PageContext, PathStep, ROUTES, RelocateRequest, RelocateResponse, Reviewer, Route, SCREENSHOT_TYPES, SCREENSHOT_WINDOW_SECONDS, SENSITIVE_QUERY_KEY, SUGGESTION_DECISIONS, ScreenshotType, SkeletonNode, SuggestionDecision, THREAD_STATUSES, TOKEN_ALGORITHM, TOKEN_TTL_SECONDS, Thread, ThreadDetail, ThreadStatus, TokenClaims, TokenRouteRequest, UpdateThreadRequest, UpdateThreadResponse, paths };

package/dist/contract.js

@@ -0,0 +1,2 @@
+import { a as LIMITS, c as SCREENSHOT_WINDOW_SECONDS, d as THREAD_STATUSES, f as TOKEN_ALGORITHM, h as DEFAULT_ENDPOINT, i as GUEST_ACCESS, l as SENSITIVE_QUERY_KEY, m as paths, n as DEFAULT_TOKEN_ROUTE, o as ROUTES, p as TOKEN_TTL_SECONDS, r as ERROR_CODES, s as SCREENSHOT_TYPES, t as API_VERSION, u as SUGGESTION_DECISIONS } from "./contract-CzTIqzyE.js";
+export { API_VERSION, DEFAULT_ENDPOINT, DEFAULT_TOKEN_ROUTE, ERROR_CODES, GUEST_ACCESS, LIMITS, ROUTES, SCREENSHOT_TYPES, SCREENSHOT_WINDOW_SECONDS, SENSITIVE_QUERY_KEY, SUGGESTION_DECISIONS, THREAD_STATUSES, TOKEN_ALGORITHM, TOKEN_TTL_SECONDS, paths };

package/dist/error-rNSfYFOm.js

@@ -0,0 +1,36 @@
+import { r as ERROR_CODES } from "./contract-CzTIqzyE.js";
+//#region src/error.ts
+var FastbackrError = class extends Error {
+	status;
+	code;
+	constructor(status, code, message, options) {
+		super(message, options);
+		this.name = "FastbackrError";
+		this.status = status;
+		this.code = code;
+	}
+};
+const KNOWN_CODES = new Set(ERROR_CODES);
+function isErrorCode(value) {
+	return typeof value === "string" && KNOWN_CODES.has(value);
+}
+function codeForStatus(status) {
+	switch (status) {
+		case 400: return "invalid_request";
+		case 401: return "unauthorized";
+		case 403: return "forbidden";
+		case 404: return "not_found";
+		case 413: return "request_too_large";
+		case 415: return "invalid_content_type";
+		case 429: return "rate_limited";
+		default: return "internal";
+	}
+}
+async function errorFromResponse(response) {
+	const envelope = (await response.json().catch(() => null))?.error;
+	const code = isErrorCode(envelope?.code) ? envelope.code : codeForStatus(response.status);
+	const message = typeof envelope?.message === "string" && envelope.message ? envelope.message : `Fastbackr answered ${response.status}.`;
+	return new FastbackrError(response.status, code, message);
+}
+//#endregion
+export { errorFromResponse as n, FastbackrError as t };

package/dist/gesture-CSkNZJqY.js

@@ -0,0 +1,60 @@
+//#region src/gesture.ts
+function editable(event) {
+	return event.composedPath().some((node) => node instanceof Element && (node.matches("input,textarea,select,[role=\"textbox\"]") || node instanceof HTMLElement && node.isContentEditable));
+}
+function plainKey(event) {
+	return !(event.repeat || event.isComposing || editable(event) || event.ctrlKey || event.metaKey || event.altKey);
+}
+const GESTURE_GAP_MS = 2e3;
+const GESTURE_KEY = "f";
+const GESTURE_COUNT = 3;
+function watchRevealGesture(reveal, signal) {
+	let count = 0;
+	let last = 0;
+	document.addEventListener("keydown", (event) => {
+		if (!plainKey(event) || event.key.toLowerCase() !== GESTURE_KEY) {
+			count = 0;
+			return;
+		}
+		const now = performance.now();
+		count = now - last > GESTURE_GAP_MS ? 1 : count + 1;
+		last = now;
+		if (count === GESTURE_COUNT) {
+			count = 0;
+			reveal();
+		}
+	}, { signal });
+	window.addEventListener("blur", () => {
+		count = 0;
+	}, { signal });
+}
+const THREAD_LINK_KEY = "__done_thread";
+const VISIBLE_KEY = "fastbackr:visible";
+function rememberVisible(visible) {
+	try {
+		if (visible) sessionStorage.setItem(VISIBLE_KEY, "1");
+		else sessionStorage.removeItem(VISIBLE_KEY);
+	} catch {}
+}
+const HIDDEN_KEY = "fastbackr:hidden";
+function rememberHidden(hidden) {
+	try {
+		if (hidden) localStorage.setItem(HIDDEN_KEY, "1");
+		else localStorage.removeItem(HIDDEN_KEY);
+	} catch {}
+}
+function isHidden() {
+	try {
+		return localStorage.getItem(HIDDEN_KEY) === "1";
+	} catch {
+		return false;
+	}
+}
+function shouldRevealOnLoad() {
+	try {
+		if (sessionStorage.getItem(VISIBLE_KEY) === "1") return true;
+	} catch {}
+	return new URL(location.href).searchParams.has(THREAD_LINK_KEY);
+}
+//#endregion
+export { rememberHidden as a, watchRevealGesture as c, plainKey as i, editable as n, rememberVisible as o, isHidden as r, shouldRevealOnLoad as s, THREAD_LINK_KEY as t };