@goflowstate/widget-sdk 0.3.0 → 0.3.2

package/dist/canvas-widget-sdk.js

@@ -1,4 +1,4 @@
-// @goflowstate/widget-sdk v0.3.0
+// @goflowstate/widget-sdk v0.3.2
 // https://github.com/goflowstate/goflowstate-sdk
 
 "use strict";
@@ -7,6 +7,9 @@ var CanvasWidgetSDK = (() => {
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __esm = (fn, res) => function __init() {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  };
   var __export = (target, all) => {
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
@@ -21,6 +24,18 @@ var CanvasWidgetSDK = (() => {
   };
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+  // no-rasterizer:modern-screenshot
+  var modern_screenshot_exports = {};
+  __export(modern_screenshot_exports, {
+    domToCanvas: () => domToCanvas
+  });
+  var domToCanvas;
+  var init_modern_screenshot = __esm({
+    "no-rasterizer:modern-screenshot"() {
+      domToCanvas = () => Promise.reject(new Error("no rasterizer in the script-tag bundle"));
+    }
+  });
+
   // src/sdk.ts
   var sdk_exports = {};
   __export(sdk_exports, {
@@ -62,6 +77,787 @@ var CanvasWidgetSDK = (() => {
     };
   }
 
+  // src/feedback.ts
+  var FEEDBACK_HOST_ATTR = "data-fs-feedback-host";
+  var SCREENSHOT_MAX_BYTES = 15e4;
+  var SCREENSHOT_MAX_SIDE = 1280;
+  var CAPTURE_TIMEOUT_MS = 4e3;
+  function parseColor(raw) {
+    const value = (raw ?? "").trim().toLowerCase();
+    if (!value || value === "transparent") return null;
+    const hex = /^#([0-9a-f]{3,8})$/.exec(value);
+    if (hex) {
+      const h = hex[1];
+      const full = h.length <= 4 ? h.split("").map((c) => c + c).join("") : h;
+      if (full.length !== 6 && full.length !== 8) return null;
+      const n = (i) => parseInt(full.slice(i, i + 2), 16);
+      return [n(0), n(2), n(4), full.length === 8 ? n(6) / 255 : 1];
+    }
+    const fn = /^rgba?\(([^)]+)\)$/.exec(value);
+    if (!fn) return null;
+    const parts = fn[1].split(/[\s,/]+/).filter(Boolean);
+    if (parts.length < 3) return null;
+    const channel = (p) => p.endsWith("%") ? parseFloat(p) * 255 / 100 : parseFloat(p);
+    const alpha = parts[3] === void 0 ? 1 : parts[3].endsWith("%") ? parseFloat(parts[3]) / 100 : parseFloat(parts[3]);
+    const out = [channel(parts[0]), channel(parts[1]), channel(parts[2]), alpha];
+    return out.some((v) => Number.isNaN(v)) ? null : out;
+  }
+  var opaque = (c) => c !== null && c[3] >= 0.9;
+  var css = (c, alpha = c[3]) => alpha >= 1 ? `rgb(${Math.round(c[0])}, ${Math.round(c[1])}, ${Math.round(c[2])})` : `rgba(${Math.round(c[0])}, ${Math.round(c[1])}, ${Math.round(c[2])}, ${alpha})`;
+  var mix = (a, b, t) => [
+    a[0] + (b[0] - a[0]) * t,
+    a[1] + (b[1] - a[1]) * t,
+    a[2] + (b[2] - a[2]) * t,
+    1
+  ];
+  var luminance = (c) => {
+    const lin = (v) => {
+      const s = v / 255;
+      return s <= 0.03928 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
+    };
+    return 0.2126 * lin(c[0]) + 0.7152 * lin(c[1]) + 0.0722 * lin(c[2]);
+  };
+  var contrast = (a, b) => {
+    const [hi, lo] = [luminance(a), luminance(b)].sort((x, y) => y - x);
+    return (hi + 0.05) / (lo + 0.05);
+  };
+  var WHITE = [255, 255, 255, 1];
+  var BLACK = [17, 17, 20, 1];
+  var styleOf = (el) => getComputedStyle(el);
+  var rootVar = (doc, names) => {
+    for (const el of [doc.documentElement, doc.body]) {
+      if (!el) continue;
+      const style = styleOf(el);
+      for (const name of names) {
+        const value = style.getPropertyValue(name).trim();
+        if (value) return value;
+      }
+    }
+    return "";
+  };
+  var visible = (el) => {
+    const rect = el.getBoundingClientRect();
+    const style = styleOf(el);
+    return style.display !== "none" && style.visibility !== "hidden" && rect.width * rect.height >= 0;
+  };
+  var inOurs = (el) => el.closest(`[${FEEDBACK_HOST_ATTR}]`) !== null;
+  var primaryButton = (doc, ground) => {
+    let best = null;
+    let bestArea = -1;
+    doc.querySelectorAll(
+      'button, [role="button"], input[type="submit"], a[class*="btn"], a[class*="cta"]'
+    ).forEach((el) => {
+      if (inOurs(el) || !visible(el)) return;
+      const fill = parseColor(styleOf(el).backgroundColor);
+      if (!opaque(fill) || contrast(fill, ground) < 1.25) return;
+      const rect = el.getBoundingClientRect();
+      const area = rect.width * rect.height;
+      if (area > bestArea) {
+        best = el;
+        bestArea = area;
+      }
+    });
+    return best;
+  };
+  function readFlowTheme(doc = document) {
+    const body = doc.body;
+    const stage = body.querySelector(":scope > :not(script):not(style):not([data-fs-feedback-host])");
+    const bodyStyle = styleOf(body);
+    const sampledGround = [stage, body, doc.documentElement].map((el) => el ? parseColor(styleOf(el).backgroundColor) : null).find(opaque);
+    const sampledInk = parseColor((stage ? styleOf(stage) : bodyStyle).color) ?? parseColor(bodyStyle.color);
+    const tokenGround = parseColor(rootVar(doc, ["--sb-ground", "--sb-bg", "--color-ink-050"]));
+    const ink0 = parseColor(rootVar(doc, ["--fs-feedback-ink"])) ?? sampledInk;
+    let ground = parseColor(rootVar(doc, ["--fs-feedback-ground"])) ?? sampledGround ?? (tokenGround && opaque(tokenGround) ? tokenGround : null) ?? (ink0 && luminance(ink0) > 0.5 ? BLACK : WHITE);
+    ground = [ground[0], ground[1], ground[2], 1];
+    const dark = luminance(ground) < 0.35;
+    let ink = ink0 && contrast([ink0[0], ink0[1], ink0[2], 1], ground) >= 4.5 ? ink0 : dark ? WHITE : BLACK;
+    ink = [ink[0], ink[1], ink[2], 1];
+    const button = primaryButton(doc, ground);
+    const buttonStyle = button ? styleOf(button) : null;
+    const pinnedCta = parseColor(rootVar(doc, ["--fs-feedback-cta"]));
+    const tokenCta = parseColor(rootVar(doc, ["--sb-cta", "--sb-accent", "--color-cream"]));
+    const sampledCta = buttonStyle ? parseColor(buttonStyle.backgroundColor) : null;
+    const cta = pinnedCta ?? sampledCta ?? (tokenCta && contrast(tokenCta, ground) >= 1.25 ? tokenCta : null) ?? ink;
+    const pinnedCtaInk = parseColor(rootVar(doc, ["--fs-feedback-cta-ink"]));
+    const sampledCtaInk = !pinnedCta && sampledCta && buttonStyle ? parseColor(buttonStyle.color) : null;
+    const ctaInk = pinnedCtaInk ?? (sampledCtaInk && contrast(sampledCtaInk, cta) >= 3 ? sampledCtaInk : null) ?? (luminance(cta) > 0.4 ? BLACK : WHITE);
+    const heading = Array.from(doc.querySelectorAll('h1, h2, [class*="title"]')).find(
+      (el) => !inOurs(el) && visible(el)
+    );
+    const headingStyle = heading ? styleOf(heading) : null;
+    const fontBody = rootVar(doc, ["--fs-feedback-font"]) || (stage ? styleOf(stage).fontFamily : "") || bodyStyle.fontFamily || rootVar(doc, ["--sb-font-body", "--font-body"]) || "system-ui, sans-serif";
+    const fontDisplay = rootVar(doc, ["--fs-feedback-font-display"]) || headingStyle?.fontFamily || rootVar(doc, ["--sb-font-display", "--sb-font-title", "--font-display"]) || fontBody;
+    const field = Array.from(
+      doc.querySelectorAll('textarea, input[type="text"], input:not([type])')
+    ).find((el) => !inOurs(el) && visible(el));
+    const px = (value) => {
+      const n = parseFloat(value ?? "");
+      return Number.isFinite(n) ? n : null;
+    };
+    const cornerOf = (style) => style ? px(style.borderTopLeftRadius || style.borderRadius) : null;
+    const buttonRadius = cornerOf(buttonStyle);
+    const fieldRadius = cornerOf(field ? styleOf(field) : null);
+    const radius = rootVar(doc, ["--fs-feedback-radius"]) || `${Math.min(fieldRadius ?? Math.min(buttonRadius ?? 16, 22), 28)}px`;
+    return {
+      ground: css(ground),
+      surface: css(dark ? mix(ground, WHITE, 0.07) : mix(ground, WHITE, 0.6)),
+      ink: css(ink),
+      inkDim: css(mix(ink, ground, 0.32)),
+      line: css(ink, 0.16),
+      fill: css(ink, 0.05),
+      cta: css([cta[0], cta[1], cta[2], 1]),
+      ctaInk: css([ctaInk[0], ctaInk[1], ctaInk[2], 1]),
+      fontBody,
+      fontDisplay,
+      displayWeight: headingStyle?.fontWeight || "500",
+      radius,
+      buttonRadius: buttonRadius === null ? "999px" : `${Math.min(buttonRadius, 999)}px`,
+      dark
+    };
+  }
+  var dataUrlBytes = (url) => Math.floor((url.length - url.indexOf(",") - 1) * 3 / 4);
+  function encodeScreenshot(canvas) {
+    let source = canvas;
+    for (let pass = 0; pass < 3; pass += 1) {
+      for (const quality of [0.82, 0.7, 0.58, 0.46, 0.34]) {
+        const url = source.toDataURL("image/jpeg", quality);
+        if (url.startsWith("data:image/jpeg") && dataUrlBytes(url) <= SCREENSHOT_MAX_BYTES)
+          return url;
+      }
+      const smaller = document.createElement("canvas");
+      smaller.width = Math.max(1, Math.round(source.width * 0.75));
+      smaller.height = Math.max(1, Math.round(source.height * 0.75));
+      const ctx = smaller.getContext("2d");
+      if (!ctx) return null;
+      ctx.drawImage(source, 0, 0, smaller.width, smaller.height);
+      source = smaller;
+    }
+    return null;
+  }
+  async function captureViewport(ground) {
+    const { domToCanvas: domToCanvas2 } = await Promise.resolve().then(() => (init_modern_screenshot(), modern_screenshot_exports));
+    const width = window.innerWidth;
+    const height = window.innerHeight;
+    const scale = Math.min(
+      window.devicePixelRatio || 1,
+      SCREENSHOT_MAX_SIDE / Math.max(width, height)
+    );
+    const canvas = await domToCanvas2(document.documentElement, {
+      width,
+      height,
+      scale,
+      backgroundColor: ground,
+      style: { transform: `translate(${-window.scrollX}px, ${-window.scrollY}px)` },
+      filter: (node) => !(node instanceof Element && node.hasAttribute(FEEDBACK_HOST_ATTR))
+    });
+    return encodeScreenshot(canvas);
+  }
+  var withTimeout = (work, ms) => new Promise((resolve) => {
+    const timer = setTimeout(() => resolve(null), ms);
+    work.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      () => {
+        clearTimeout(timer);
+        resolve(null);
+      }
+    );
+  });
+  var PLACEMENT_BASE = 16;
+  var PLACEMENT_STEP = 8;
+  var PLACEMENT_PAD = 8;
+  var PLACEMENT_MAX_SHARE = 0.6;
+  var PLACEMENT_READ_COST = 240;
+  var EMPTY = 0;
+  var READ = 1;
+  var TAP = 2;
+  var SAMPLES = 5;
+  function choosePlacement(box, viewportHeight, at) {
+    const max = Math.max(PLACEMENT_BASE, viewportHeight * PLACEMENT_MAX_SHARE);
+    const span = box.size + PLACEMENT_PAD * 2;
+    const offsets = Array.from({ length: SAMPLES }, (_, i) => span * i / (SAMPLES - 1));
+    const x0 = box.left - PLACEMENT_PAD;
+    let best = PLACEMENT_BASE;
+    let bestCost = Infinity;
+    for (let bottom = PLACEMENT_BASE; bottom <= max; bottom += PLACEMENT_STEP) {
+      if (bottom >= bestCost) break;
+      const y0 = box.top - (bottom - box.bottom) - PLACEMENT_PAD;
+      let worst = EMPTY;
+      for (const dy of offsets) {
+        for (const dx of offsets) {
+          const found = at(x0 + dx, y0 + dy);
+          if (found > worst) worst = found;
+          if (worst === TAP) break;
+        }
+        if (worst === TAP) break;
+      }
+      if (worst === TAP) continue;
+      const cost = bottom + (worst === READ ? PLACEMENT_READ_COST : 0);
+      if (cost < bestCost) {
+        bestCost = cost;
+        best = bottom;
+      }
+    }
+    return best;
+  }
+  var TAPPABLE = 'a[href],button,input,select,textarea,summary,label,[role="button"],[role="link"],[role="tab"],[role="switch"],[role="checkbox"],[role="radio"],[role="slider"],[role="option"],[tabindex]:not([tabindex="-1"]),[contenteditable=""],[contenteditable="true"],[onclick]';
+  var PICTURE = "img,svg,canvas,video,picture";
+  var SURFACE_SHARE = 0.8;
+  function occupancyReader(host, doc = document) {
+    if (typeof doc.elementsFromPoint !== "function") return () => EMPTY;
+    const view = doc.defaultView;
+    const width = view?.innerWidth ?? 1;
+    const height = view?.innerHeight ?? 1;
+    const seen = /* @__PURE__ */ new Map();
+    const read = (el) => {
+      const known = seen.get(el);
+      if (known) return known;
+      const style = view ? view.getComputedStyle(el) : null;
+      let tap = el.matches(TAPPABLE) || style?.cursor === "pointer";
+      if (tap) {
+        const r = el.getBoundingClientRect();
+        if (r.width * r.height >= width * height * SURFACE_SHARE) tap = false;
+      }
+      const text = [];
+      if (typeof doc.createRange === "function") {
+        for (const node of Array.from(el.childNodes)) {
+          if (node.nodeType !== 3 || !node.nodeValue || !node.nodeValue.trim()) continue;
+          const range = doc.createRange();
+          range.selectNodeContents(node);
+          if (typeof range.getClientRects === "function")
+            text.push(...Array.from(range.getClientRects()));
+        }
+      }
+      const ground = parseColor(style?.backgroundColor);
+      const image = style?.backgroundImage ?? "";
+      const reading = {
+        tap,
+        picture: el.matches(PICTURE) || el.closest("svg") !== null,
+        text,
+        opaque: ground !== null && ground[3] >= 0.5 || image !== "" && image !== "none"
+      };
+      seen.set(el, reading);
+      return reading;
+    };
+    return (x, y) => {
+      const cx = Math.min(Math.max(x, 0), width - 1);
+      const cy = Math.min(Math.max(y, 0), height - 1);
+      const stack = doc.elementsFromPoint(cx, cy).filter((el) => el !== host && el !== doc.documentElement && el !== doc.body);
+      for (let el = stack[0] ?? null; el && el !== doc.body; el = el.parentElement) {
+        if (read(el).tap) return TAP;
+      }
+      for (const el of stack) {
+        const r = read(el);
+        if (r.picture || r.text.some((t) => cx >= t.left && cx <= t.right && cy >= t.top && cy <= t.bottom))
+          return READ;
+        if (r.opaque) break;
+      }
+      return EMPTY;
+    };
+  }
+  var BUTTON_SIZE = 44;
+  var TAB_WIDTH = 26;
+  var TAB_HEIGHT = 54;
+  var EDGE_MARGIN = 12;
+  var DOCK_PAST = 14;
+  var SPOT_KEY = "fs-feedback-spot";
+  var projectMomentum = (v, deceleration = 0.992) => v / 1e3 * deceleration / (1 - deceleration);
+  var rubberband = (overshoot, dimension, constant = 0.55) => overshoot * dimension * constant / (dimension + constant * Math.abs(overshoot));
+  var clampY = (y, height, view) => Math.min(
+    Math.max(y, view.top + EDGE_MARGIN),
+    Math.max(view.top + EDGE_MARGIN, view.height - view.bottom - EDGE_MARGIN - height)
+  );
+  function restingSpot(state, left, y, view) {
+    if (state === "float") {
+      return {
+        state,
+        x: left ? EDGE_MARGIN : view.width - BUTTON_SIZE - EDGE_MARGIN,
+        y: clampY(y, BUTTON_SIZE, view)
+      };
+    }
+    return { state, x: left ? 0 : view.width - TAB_WIDTH, y: clampY(y, TAB_HEIGHT, view) };
+  }
+  function settleRelease(from, velocity, view) {
+    const py = from.y + projectMomentum(velocity.y);
+    if (from.state !== "float") return restingSpot(from.state, from.state === "dock-left", py, view);
+    const px = from.x + projectMomentum(velocity.x);
+    const maxX = view.width - BUTTON_SIZE;
+    const tabY = py + (BUTTON_SIZE - TAB_HEIGHT) / 2;
+    if (px < -DOCK_PAST || from.x < 3) return restingSpot("dock-left", true, tabY, view);
+    if (px > maxX + DOCK_PAST || from.x > maxX - 3)
+      return restingSpot("dock-right", false, tabY, view);
+    return restingSpot("float", px + BUTTON_SIZE / 2 < view.width / 2, py, view);
+  }
+  var BUG_ICON = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><rect x="8" y="7" width="8" height="12" rx="4"/><path d="M9.5 7a2.5 2.5 0 0 1 5 0M12 11v8M4 13h4M16 13h4M5 7l3.2 2.4M19 7l-3.2 2.4M5 20l3.2-2.6M19 20l-3.2-2.6"/></svg>';
+  var STYLE = `
+:host { all: initial; }
+* { box-sizing: border-box; }
+.bug {
+  position: fixed; z-index: 2147483000; left: 0; top: 0;
+  width: 44px; height: 44px; border-radius: 22px; padding: 0; margin: 0;
+  display: var(--fs-feedback-display, grid); place-items: center; cursor: grab;
+  background: var(--surface); color: var(--ink); border: 1px solid var(--line);
+  box-shadow: 0 10px 24px rgba(0, 0, 0, 0.2), 0 2px 5px rgba(0, 0, 0, 0.12);
+  -webkit-tap-highlight-color: transparent; touch-action: none; user-select: none; -webkit-user-select: none;
+  will-change: transform;
+}
+@supports ((-webkit-backdrop-filter: blur(1px)) or (backdrop-filter: blur(1px))) {
+  .bug {
+    background: color-mix(in srgb, var(--surface) 74%, transparent);
+    -webkit-backdrop-filter: blur(14px) saturate(160%); backdrop-filter: blur(14px) saturate(160%);
+  }
+}
+.bug svg { width: 20px; height: 20px; pointer-events: none; }
+.bug.down svg { transform: scale(0.9); }
+.bug.dragging { cursor: grabbing; box-shadow: 0 18px 36px rgba(0, 0, 0, 0.26), 0 3px 8px rgba(0, 0, 0, 0.14); }
+.bug[data-state^="dock"] { width: 26px; height: 54px; box-shadow: 0 2px 8px rgba(0, 0, 0, 0.14); opacity: 0.92; }
+.bug[data-state="dock-right"] { border-radius: 16px 0 0 16px; border-right-width: 0; }
+.bug[data-state="dock-left"] { border-radius: 0 16px 16px 0; border-left-width: 0; }
+.bug[data-state^="dock"] svg { width: 16px; height: 16px; }
+.probe {
+  position: fixed; visibility: hidden; pointer-events: none; width: 0; height: 0;
+  padding: env(safe-area-inset-top, 0px) 0 env(safe-area-inset-bottom, 0px) 0;
+}
+.tuck { align-self: center; font-size: 13px; color: var(--ink-dim); }
+@media (prefers-reduced-transparency: reduce) {
+  .bug { background: var(--surface); -webkit-backdrop-filter: none; backdrop-filter: none; }
+}
+@media (prefers-contrast: more) {
+  .bug { background: var(--surface); border-color: var(--ink); -webkit-backdrop-filter: none; backdrop-filter: none; }
+}
+.bug:focus-visible, .send:focus-visible, .link:focus-visible, textarea:focus-visible {
+  outline: 2px solid var(--ink); outline-offset: 2px;
+}
+.scrim { position: fixed; inset: 0; z-index: 2147483001; background: rgba(0, 0, 0, 0.42); }
+.sheet {
+  position: fixed; left: 0; right: 0; bottom: 0; z-index: 2147483002;
+  margin: 0 auto; max-width: 480px;
+  background: var(--surface); color: var(--ink); border: 1px solid var(--line); border-bottom: 0;
+  border-radius: calc(var(--radius) + 6px) calc(var(--radius) + 6px) 0 0;
+  padding: 12px 18px calc(20px + env(safe-area-inset-bottom, 0px));
+  display: flex; flex-direction: column; gap: 12px;
+  font-family: var(--font-body); font-size: 15px; line-height: 1.4;
+}
+.grab { width: 36px; height: 4px; border-radius: 2px; background: var(--line); align-self: center; }
+h2 { margin: 0; font-family: var(--font-display); font-weight: var(--display-weight); font-size: 19px; line-height: 1.2; }
+.shot { display: flex; gap: 12px; align-items: center; font-size: 13px; color: var(--ink-dim); }
+.shot img { width: 50px; max-height: 108px; object-fit: cover; object-position: top; border-radius: 8px; border: 1px solid var(--line); }
+.link { background: none; border: 0; padding: 0; font: inherit; color: var(--ink); text-decoration: underline; text-underline-offset: 3px; cursor: pointer; }
+textarea {
+  width: 100%; min-height: 84px; resize: none; font: inherit; font-size: 16px; color: var(--ink);
+  background: var(--fill); border: 1px solid var(--line); border-radius: var(--radius); padding: 13px 15px;
+}
+textarea::placeholder { color: var(--ink-dim); }
+.send {
+  font: inherit; font-weight: 500; cursor: pointer; border: 0; padding: 14px;
+  background: var(--cta); color: var(--cta-ink); border-radius: var(--button-radius);
+}
+.send[disabled] { opacity: 0.5; cursor: default; }
+.status { margin: 0; font-size: 13px; color: var(--ink-dim); min-height: 1.4em; }
+[hidden] { display: none !important; }
+@media (prefers-reduced-motion: no-preference) {
+  .bug {
+    transition: width 0.22s cubic-bezier(0.2, 0.8, 0.2, 1), height 0.22s cubic-bezier(0.2, 0.8, 0.2, 1),
+      border-radius 0.22s cubic-bezier(0.2, 0.8, 0.2, 1), box-shadow 0.22s ease;
+  }
+  .bug svg { transition: transform 0.1s ease-out, width 0.22s ease, height 0.22s ease; }
+  .sheet { animation: rise 0.22s ease-out; }
+  @keyframes rise { from { transform: translateY(24px); opacity: 0; } to { transform: none; opacity: 1; } }
+}
+`;
+  var mounted = null;
+  var feedbackOptedOut = (doc = document) => doc.documentElement.getAttribute("data-fs-feedback") === "off";
+  var SCROLL_OPTIONS = { capture: true, passive: true };
+  function mountFlowFeedback(options) {
+    if (typeof document === "undefined" || !document.body) return null;
+    if (mounted) return mounted;
+    if (feedbackOptedOut()) return null;
+    const host = document.createElement("div");
+    host.setAttribute(FEEDBACK_HOST_ATTR, "");
+    const root = host.attachShadow({ mode: "open" });
+    root.innerHTML = `<style>${STYLE}</style>
+<button type="button" class="bug" data-state="float" aria-label="Send feedback on this page">${BUG_ICON}</button>
+<div class="probe" aria-hidden="true"></div>
+<div class="scrim" hidden></div>
+<div class="sheet" role="dialog" aria-modal="true" aria-labelledby="fsf-title" hidden>
+  <div class="grab" aria-hidden="true"></div>
+  <h2 id="fsf-title">Feedback on this page</h2>
+  <div class="shot" hidden><img alt="Screenshot of this page" /><span><span>Screenshot attached</span><br /><button type="button" class="link remove">Remove screenshot</button></span></div>
+  <textarea aria-labelledby="fsf-title" placeholder="What should change?" maxlength="2000"></textarea>
+  <p class="status" role="status" aria-live="polite"></p>
+  <button type="button" class="send" disabled>Send feedback</button>
+  <button type="button" class="link tuck">Tuck the button to the side</button>
+</div>`;
+    const q = (selector) => root.querySelector(selector);
+    const bug = q(".bug");
+    const scrim = q(".scrim");
+    const sheet = q(".sheet");
+    const shot = q(".shot");
+    const img = q(".shot img");
+    const remove = q(".remove");
+    const text = q("textarea");
+    const status = q(".status");
+    const send = q(".send");
+    const tuck = q(".tuck");
+    const probe = q(".probe");
+    let theme = readFlowTheme();
+    let screenshot = null;
+    let busy = false;
+    let closeTimer = null;
+    let placeTimer = null;
+    let autoBottom = PLACEMENT_BASE;
+    let spot = { state: "float", x: 0, y: 0 };
+    let placedByPerson = false;
+    let velocity = { x: 0, y: 0 };
+    let frame = 0;
+    const px = (name) => {
+      const raw = getComputedStyle(host).getPropertyValue(name).trim();
+      const n = raw ? parseFloat(raw) : NaN;
+      return Number.isFinite(n) ? n : null;
+    };
+    const viewport = () => {
+      const style = getComputedStyle(probe);
+      return {
+        width: window.innerWidth,
+        height: window.innerHeight,
+        top: parseFloat(style.paddingTop) || 0,
+        bottom: parseFloat(style.paddingBottom) || 0
+      };
+    };
+    const draw = () => {
+      bug.style.transform = `translate3d(${spot.x}px, ${spot.y}px, 0)`;
+    };
+    const setState = (next) => {
+      spot.state = next;
+      bug.dataset.state = next;
+    };
+    const remember = (spot2) => {
+      if (!placedByPerson) return;
+      try {
+        const view = viewport();
+        const width = spot2.state === "float" ? BUTTON_SIZE : TAB_WIDTH;
+        localStorage.setItem(
+          SPOT_KEY,
+          JSON.stringify({
+            state: spot2.state,
+            left: spot2.x + width / 2 < view.width / 2,
+            y: view.height > 0 ? spot2.y / view.height : 0
+          })
+        );
+      } catch {
+      }
+    };
+    const still = () => typeof window.matchMedia === "function" && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+    const springTo = (to, flicked) => {
+      cancelAnimationFrame(frame);
+      frame = 0;
+      setState(to.state);
+      remember(to);
+      if (still() || typeof requestAnimationFrame !== "function") {
+        spot = { ...to };
+        velocity = { x: 0, y: 0 };
+        draw();
+        return;
+      }
+      const omega = 2 * Math.PI / 0.4;
+      const k = omega * omega;
+      const c = 2 * (flicked ? 0.8 : 1) * omega;
+      let last = performance.now();
+      const tick = (now) => {
+        const dt = Math.min(0.032, (now - last) / 1e3);
+        last = now;
+        velocity.x += (-k * (spot.x - to.x) - c * velocity.x) * dt;
+        velocity.y += (-k * (spot.y - to.y) - c * velocity.y) * dt;
+        spot.x += velocity.x * dt;
+        spot.y += velocity.y * dt;
+        const close2 = Math.abs(spot.x - to.x) < 0.3 && Math.abs(spot.y - to.y) < 0.3 && Math.hypot(velocity.x, velocity.y) < 6;
+        if (close2) {
+          spot = { ...to };
+          velocity = { x: 0, y: 0 };
+          frame = 0;
+          draw();
+          return;
+        }
+        draw();
+        frame = requestAnimationFrame(tick);
+      };
+      frame = requestAnimationFrame(tick);
+    };
+    const place = () => {
+      placeTimer = null;
+      if (!sheet.hidden || bug.hidden || drag || frame) return;
+      const view = viewport();
+      if (placedByPerson || spot.state !== "float") {
+        const width = spot.state === "float" ? BUTTON_SIZE : TAB_WIDTH;
+        spot = restingSpot(spot.state, spot.x + width / 2 < view.width / 2, spot.y, view);
+        draw();
+        return;
+      }
+      const right = px("--fs-feedback-right") ?? 14;
+      const left = view.width - right - BUTTON_SIZE;
+      const pinned = px("--fs-feedback-bottom");
+      if (pinned === null && typeof document.elementsFromPoint === "function") {
+        autoBottom = choosePlacement(
+          {
+            left,
+            top: view.height - view.bottom - autoBottom - BUTTON_SIZE,
+            size: BUTTON_SIZE,
+            bottom: autoBottom
+          },
+          view.height,
+          occupancyReader(host)
+        );
+      }
+      const bottom = pinned ?? autoBottom;
+      spot = { state: "float", x: left, y: view.height - view.bottom - bottom - BUTTON_SIZE };
+      draw();
+    };
+    const schedulePlace = () => {
+      if (placeTimer) clearTimeout(placeTimer);
+      placeTimer = setTimeout(place, 150);
+    };
+    let drag = null;
+    let suppressClick = false;
+    const onDown = (event) => {
+      if (!sheet.hidden || busy) return;
+      bug.setPointerCapture?.(event.pointerId);
+      cancelAnimationFrame(frame);
+      frame = 0;
+      velocity = { x: 0, y: 0 };
+      drag = {
+        id: event.pointerId,
+        ox: event.clientX - spot.x,
+        oy: event.clientY - spot.y,
+        sx: event.clientX,
+        sy: event.clientY,
+        moved: false,
+        history: [{ t: event.timeStamp, x: event.clientX, y: event.clientY }]
+      };
+      bug.classList.add("down");
+    };
+    const onMove = (event) => {
+      if (!drag || event.pointerId !== drag.id) return;
+      const dx = event.clientX - drag.sx;
+      const dy = event.clientY - drag.sy;
+      if (!drag.moved && Math.hypot(dx, dy) < 8) return;
+      if (!drag.moved) {
+        drag.moved = true;
+        bug.classList.add("dragging");
+      }
+      drag.history.push({ t: event.timeStamp, x: event.clientX, y: event.clientY });
+      if (drag.history.length > 6) drag.history.shift();
+      const view = viewport();
+      if (spot.state !== "float") {
+        const inward = spot.state === "dock-left" ? dx : -dx;
+        if (inward <= 18) {
+          spot = restingSpot(spot.state, spot.state === "dock-left", event.clientY - drag.oy, view);
+          draw();
+          return;
+        }
+        setState("float");
+        drag.ox = BUTTON_SIZE / 2;
+        drag.oy = BUTTON_SIZE / 2;
+      }
+      let x = event.clientX - drag.ox;
+      let y = event.clientY - drag.oy;
+      const maxX = view.width - BUTTON_SIZE;
+      const maxY = view.height - BUTTON_SIZE;
+      if (x < 0) x = rubberband(x, 60);
+      else if (x > maxX) x = maxX + rubberband(x - maxX, 60);
+      if (y < 0) y = rubberband(y, 80);
+      else if (y > maxY) y = maxY + rubberband(y - maxY, 80);
+      spot.x = x;
+      spot.y = y;
+      draw();
+    };
+    const onUp = (event) => {
+      if (!drag || event.pointerId !== drag.id) return;
+      const ended = drag;
+      drag = null;
+      bug.classList.remove("down", "dragging");
+      if (!ended.moved) return;
+      suppressClick = true;
+      setTimeout(() => {
+        suppressClick = false;
+      }, 0);
+      const first = ended.history[0];
+      const last = ended.history[ended.history.length - 1];
+      const dt = Math.max(1, last.t - first.t);
+      const paused = event.timeStamp - last.t > 90;
+      velocity = paused ? { x: 0, y: 0 } : { x: (last.x - first.x) / dt * 1e3, y: (last.y - first.y) / dt * 1e3 };
+      placedByPerson = true;
+      springTo(settleRelease(spot, velocity, viewport()), Math.hypot(velocity.x, velocity.y) > 350);
+    };
+    const observer = typeof MutationObserver === "function" ? new MutationObserver((records) => {
+      if (records.some((r) => r.target !== host)) schedulePlace();
+    }) : null;
+    const paint = () => {
+      theme = readFlowTheme();
+      const vars = {
+        "--surface": theme.surface,
+        "--ink": theme.ink,
+        "--ink-dim": theme.inkDim,
+        "--line": theme.line,
+        "--fill": theme.fill,
+        "--cta": theme.cta,
+        "--cta-ink": theme.ctaInk,
+        "--font-body": theme.fontBody,
+        "--font-display": theme.fontDisplay,
+        "--display-weight": theme.displayWeight,
+        "--radius": theme.radius,
+        "--button-radius": theme.buttonRadius
+      };
+      for (const [name, value] of Object.entries(vars)) host.style.setProperty(name, value);
+      host.style.colorScheme = theme.dark ? "dark" : "light";
+    };
+    const sync = () => {
+      send.disabled = busy || text.value.trim().length === 0;
+    };
+    const setShot = (url) => {
+      screenshot = url;
+      shot.hidden = url === null;
+      if (url) img.src = url;
+      else img.removeAttribute("src");
+    };
+    const close = () => {
+      if (closeTimer) clearTimeout(closeTimer);
+      closeTimer = null;
+      sheet.hidden = true;
+      scrim.hidden = true;
+      bug.hidden = false;
+      setShot(null);
+      text.value = "";
+      status.textContent = "";
+      busy = false;
+      sync();
+      schedulePlace();
+    };
+    const open = async () => {
+      if (!sheet.hidden || busy) return;
+      busy = true;
+      paint();
+      bug.hidden = true;
+      const capture = options.capture ?? (() => captureViewport(theme.ground));
+      const url = await withTimeout(Promise.resolve().then(capture), CAPTURE_TIMEOUT_MS);
+      busy = false;
+      setShot(url);
+      tuck.hidden = spot.state !== "float";
+      scrim.hidden = false;
+      sheet.hidden = false;
+      sync();
+      text.focus();
+    };
+    const submit = async () => {
+      const message = text.value.trim();
+      if (!message || busy) return;
+      busy = true;
+      sync();
+      status.textContent = "";
+      try {
+        await options.submit({
+          message,
+          ...screenshot ? { screenshot } : {},
+          ...document.body.dataset.pageKey ? { pageKey: document.body.dataset.pageKey } : {},
+          pagePath: window.location.pathname.slice(-200),
+          viewport: { width: window.innerWidth, height: window.innerHeight }
+        });
+        status.textContent = "Sent.";
+        closeTimer = setTimeout(() => {
+          close();
+          bug.focus();
+        }, 1200);
+      } catch {
+        busy = false;
+        status.textContent = "That did not send. Try again.";
+        sync();
+      }
+    };
+    bug.addEventListener("click", () => {
+      if (!suppressClick) void open();
+    });
+    bug.addEventListener("pointerdown", onDown);
+    bug.addEventListener("pointermove", onMove);
+    bug.addEventListener("pointerup", onUp);
+    bug.addEventListener("pointercancel", onUp);
+    tuck.addEventListener("click", () => {
+      const view = viewport();
+      const left = spot.x + BUTTON_SIZE / 2 < view.width / 2;
+      close();
+      placedByPerson = true;
+      springTo(
+        restingSpot(
+          left ? "dock-left" : "dock-right",
+          left,
+          spot.y + (BUTTON_SIZE - TAB_HEIGHT) / 2,
+          view
+        ),
+        false
+      );
+    });
+    scrim.addEventListener("click", close);
+    remove.addEventListener("click", () => setShot(null));
+    text.addEventListener("input", sync);
+    send.addEventListener("click", () => void submit());
+    sheet.addEventListener("keydown", (event) => {
+      if (event.key === "Escape") {
+        close();
+        bug.focus();
+      }
+      event.stopPropagation();
+    });
+    document.body.appendChild(host);
+    paint();
+    try {
+      const saved = JSON.parse(localStorage.getItem(SPOT_KEY) ?? "null");
+      if (saved && typeof saved.y === "number" && (saved.state === "float" || saved.state === "dock-left" || saved.state === "dock-right")) {
+        const view = viewport();
+        placedByPerson = true;
+        setState(saved.state);
+        spot = restingSpot(saved.state, saved.left === true, saved.y * view.height, view);
+      }
+    } catch {
+    }
+    place();
+    schedulePlace();
+    observer?.observe(document.body, {
+      childList: true,
+      subtree: true,
+      attributes: true,
+      attributeFilter: ["class", "style", "hidden"]
+    });
+    window.addEventListener("resize", schedulePlace);
+    window.addEventListener("load", schedulePlace);
+    window.addEventListener("scroll", schedulePlace, SCROLL_OPTIONS);
+    document.addEventListener("transitionend", schedulePlace, SCROLL_OPTIONS);
+    document.addEventListener("animationend", schedulePlace, SCROLL_OPTIONS);
+    options.onReady?.();
+    mounted = {
+      host,
+      refresh: () => {
+        if (sheet.hidden) paint();
+      },
+      open,
+      close,
+      unmount: () => {
+        if (closeTimer) clearTimeout(closeTimer);
+        if (placeTimer) clearTimeout(placeTimer);
+        cancelAnimationFrame(frame);
+        observer?.disconnect();
+        window.removeEventListener("resize", schedulePlace);
+        window.removeEventListener("load", schedulePlace);
+        window.removeEventListener("scroll", schedulePlace, SCROLL_OPTIONS);
+        document.removeEventListener("transitionend", schedulePlace, SCROLL_OPTIONS);
+        document.removeEventListener("animationend", schedulePlace, SCROLL_OPTIONS);
+        host.remove();
+        mounted = null;
+      }
+    };
+    return mounted;
+  }
+  var unmountFlowFeedback = () => mounted?.unmount();
+
   // src/session.ts
   function readSessionLaunchParams() {
     if (typeof window === "undefined") return null;
@@ -149,11 +945,13 @@ var CanvasWidgetSDK = (() => {
     apiBase;
     tokenPromise;
     opener;
+    hostOrigin;
     constructor(params, opener) {
       this.slug = params.slug;
       this.webBase = params.webBase;
       this.mobileBase = params.mobileBase ?? null;
       this.apiBase = params.apiBase;
+      this.hostOrigin = hostOriginOf(params);
       this.opener = opener ?? parentOpener(hostOriginOf(params));
       this.tokenPromise = this.acquireTicket(params).then((t) => this.redeem(t));
     }
@@ -187,13 +985,32 @@ var CanvasWidgetSDK = (() => {
       }
       const json = await res.json();
       const data = json.data;
-      const view = toStateView(data.state ?? data);
+      const wire = data.state ?? data;
+      const view = toStateView(wire);
       this.latestClaims = view.viewer?.claims ?? null;
+      this.syncFeedback(wire.feedbackEnabled === true);
       return view;
     }
     get claims() {
       return this.latestClaims;
     }
+    /** Flow feedback: every state read says whether the bug icon is on for this ring. On, the
+     *  icon mounts once and re-reads the page's look on each read; off, it leaves. */
+    syncFeedback(enabled) {
+      if (typeof document === "undefined") return;
+      if (!enabled) {
+        unmountFlowFeedback();
+        return;
+      }
+      const handle = mountFlowFeedback({
+        submit: (report) => this.request("feedback", report),
+        onReady: () => {
+          if (window.parent !== window)
+            window.parent.postMessage({ type: "flowstate:feedback-ready" }, this.hostOrigin);
+        }
+      });
+      handle?.refresh();
+    }
     join() {
       return this.call("/enter", { method: "POST" });
     }