@matterfact/embed 0.6.0 → 0.8.0

package/dist/chunk-PNSYFXXU.js

@@ -0,0 +1,791 @@
+"use client";
+
+// src/redact.ts
+var PII = [
+  /\b[\w.+-]+@[\w-]+\.[\w.]{2,}\b/g,
+  // email
+  /\b(?:\d[ -]?){13,19}\b/g,
+  // card-ish
+  /\b\d{3}[- ]?\d{2}[- ]?\d{4}\b/g,
+  // ssn — dashed, spaced, OR bare 9 digits
+  /\b\d{9,}\b/g,
+  // long bare digit runs: account / MRN / routing numbers
+  /(?:\+?\d{1,2}[\s.-]?)?\(?\d{3}\)?[\s.-]\d{3}[\s.-]\d{4}\b/g,
+  // us phone
+  /\b(?:sk|pk|rk|ak)_(?:live|test)_[A-Za-z0-9]{8,}\b/g,
+  // stripe-style api keys
+  /\beyJ[\w-]+\.[\w-]+\.[\w-]+\b/g
+  // jwt
+];
+function redact(text) {
+  let out = text;
+  for (const re of PII) out = out.replace(re, "[redacted]");
+  return out;
+}
+
+// src/adapters/hoist.ts
+function detectHoist(read) {
+  let rt;
+  try {
+    rt = read();
+  } catch {
+    return null;
+  }
+  if (!rt) return null;
+  const worthwhile = !!rt.route.name || rt.grids.length > 0 || rt.charts.length > 0 || rt.nav.length > 0;
+  return worthwhile ? rt : null;
+}
+function quote(s, max = 120) {
+  const clean = redact(s.replace(/\s+/g, " ").trim());
+  const capped = clean.length > max ? `${clean.slice(0, max - 1)}\u2026` : clean;
+  return `"${capped.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function cell(value) {
+  const s = value == null ? "" : String(value);
+  return `- cell ${quote(s)}`;
+}
+function pushRow(row, cols, out, pad) {
+  out.push(`${pad}- row:`);
+  for (const c of cols) out.push(`${pad}  ${cell(row[c.field])}`);
+}
+function renderGrid(grid, rowCap, out, depth) {
+  const pad = "  ".repeat(depth);
+  out.push(`${pad}- table ${quote(grid.title || "grid")}:`);
+  out.push(`${pad}  - rowgroup "columns":`);
+  for (const c of grid.columns)
+    out.push(`${pad}    - columnheader ${quote(c.header || c.field)}`);
+  if (grid.selected.length) {
+    out.push(`${pad}  - rowgroup "selected":`);
+    for (const r of grid.selected) pushRow(r, grid.columns, out, `${pad}    `);
+  }
+  const shown = grid.rows.slice(0, Math.max(0, rowCap));
+  out.push(`${pad}  - rowgroup "rows":`);
+  for (const r of shown) pushRow(r, grid.columns, out, `${pad}    `);
+  out.push(
+    `${pad}  - text: ${quote(`showing ${shown.length} of ${grid.totalCount} rows`)}`
+  );
+}
+function seriesSummary(name, data) {
+  if (!data.length) return `series ${name}: 0 points`;
+  let min = data[0];
+  let max = data[0];
+  for (const n of data) {
+    if (n < min) min = n;
+    if (n > max) max = n;
+  }
+  const last = data[data.length - 1];
+  return `series ${name}: ${data.length} points, min ${min}, max ${max}, last ${last}`;
+}
+function renderChart(chart, out, depth) {
+  const pad = "  ".repeat(depth);
+  out.push(`${pad}- figure ${quote(chart.title || "chart")}:`);
+  for (const s of chart.series) {
+    out.push(`${pad}  - text: ${quote(seriesSummary(s.name, s.data))}`);
+  }
+}
+function renderNav(groups, out, depth) {
+  const pad = "  ".repeat(depth);
+  for (const g of groups) {
+    if (!g.items.length) continue;
+    out.push(`${pad}- navigation ${quote(g.label)}:`);
+    for (const d of g.items) {
+      const mark = d.current ? " [current]" : "";
+      out.push(`${pad}  - link ${quote(d.label)}${mark} \u2192 ${redact(d.path)}`);
+    }
+  }
+}
+function flattenDestinations(rt) {
+  return rt.nav.flatMap((g) => g.items);
+}
+function buildNavigateTool(rt, policy) {
+  const destinations = flattenDestinations(rt);
+  const bySection = rt.nav.filter((g) => g.items.length).map((g) => `${g.label} (${g.items.map((d) => d.label).join(", ")})`).join("; ");
+  return {
+    name: "hoist.navigate",
+    description: redact(
+      `Navigate the user to a destination in the app. "destination" must be one of the destinations currently available, grouped by section: ${bySection || "(none available)"}.`
+    ),
+    inputSchema: {
+      type: "object",
+      properties: {
+        destination: {
+          type: "string",
+          enum: destinations.map((d) => d.label)
+        },
+        params: { type: "object" }
+      },
+      required: ["destination"]
+    },
+    readOnly: false,
+    // 'confirm' policy ⇒ the widget must show a confirm card every call; 'auto' ⇒ it
+    // may call without asking. See the confirm field's doc comment on HostTool.
+    confirm: policy === "auto" ? "auto" : "required"
+  };
+}
+function buildHoistContext(rt) {
+  const selected = rt.grids.reduce((n, g) => n + g.selected.length, 0);
+  const view = rt.route.name || rt.route.path || "this view";
+  const bits = [`Viewing ${view}`];
+  if (selected) bits.push(`${selected} selected`);
+  if (rt.grids.length) bits.push(`${rt.grids.length} grid(s)`);
+  if (rt.charts.length) bits.push(`${rt.charts.length} chart(s)`);
+  return {
+    route: rt.route.name ? redact(rt.route.name) : void 0,
+    description: redact(`${bits.join(", ")}.`)
+  };
+}
+function renderHoistSnapshot(rt, rowCap) {
+  const out = [];
+  renderNav(rt.nav, out, 0);
+  let truncated = false;
+  for (const g of rt.grids) {
+    if (g.rows.length > rowCap) truncated = true;
+    renderGrid(g, rowCap, out, 0);
+  }
+  for (const c of rt.charts) renderChart(c, out, 0);
+  return { yaml: out.join("\n"), truncated };
+}
+
+// src/adapters/hoist-runtime.ts
+function readHoistConfig(win) {
+  const cfg = win?.matterfact?.hoist;
+  const ex = cfg?.excludeModels;
+  return {
+    rows: typeof cfg?.rows === "number" && cfg.rows >= 0 ? cfg.rows : 50,
+    excludeModels: Array.isArray(ex) ? ex : []
+  };
+}
+function getModelsByClass(XH, name) {
+  const models = typeof XH?.getModels === "function" ? XH.getModels(name) : [];
+  return Array.isArray(models) ? models : [];
+}
+function className(m) {
+  return m?.constructor?.name ?? "";
+}
+function modelId(m) {
+  return String(m?.xhId ?? m?.id ?? m?.modelId ?? "");
+}
+function headerOf(c) {
+  return String(c?.headerName ?? c?.displayName ?? c?.field ?? c?.colId ?? "");
+}
+function collectHeaders(cols, prefix, out) {
+  for (const c of Array.isArray(cols) ? cols : []) {
+    const children = c?.children;
+    if (Array.isArray(children) && children.length) {
+      collectHeaders(children, [...prefix, headerOf(c)], out);
+    } else {
+      const id = String(c?.colId ?? c?.field ?? "");
+      if (id) out.set(id, [...prefix, headerOf(c)].filter(Boolean).join(" "));
+    }
+  }
+}
+function readColumns(g) {
+  const leaves = typeof g?.getVisibleLeafColumns === "function" ? g.getVisibleLeafColumns() : Array.isArray(g?.columns) ? g.columns : [];
+  const headers = /* @__PURE__ */ new Map();
+  collectHeaders(Array.isArray(g?.columns) ? g.columns : [], [], headers);
+  return (Array.isArray(leaves) ? leaves : []).map((c) => {
+    const field = String(c?.colId ?? c?.field ?? "");
+    return { field, header: headers.get(field) || headerOf(c) };
+  }).filter((c) => c.field);
+}
+function readRow(rec, cols) {
+  const row = {};
+  for (const c of cols)
+    row[c.field] = typeof rec?.get === "function" ? rec.get(c.field) : rec?.data?.[c.field];
+  return row;
+}
+function readGrid(g) {
+  const columns = readColumns(g);
+  const records = Array.isArray(g?.store?.records) ? g.store.records : [];
+  return {
+    id: modelId(g),
+    title: String(g?.title ?? ""),
+    columns,
+    selected: (Array.isArray(g?.selectedRecords) ? g.selectedRecords : []).map(
+      (r) => readRow(r, columns)
+    ),
+    rows: records.map((r) => readRow(r, columns)),
+    totalCount: typeof g?.store?.allCount === "number" ? g.store.allCount : records.length
+  };
+}
+function hasContent(g) {
+  return g.totalCount > 0 || g.selected.length > 0;
+}
+function readChart(c) {
+  const series = c?.series ?? c?.highchartsConfig?.series ?? [];
+  return {
+    id: modelId(c),
+    title: String(c?.title ?? c?.highchartsConfig?.title?.text ?? ""),
+    series: (Array.isArray(series) ? series : []).map((s) => ({
+      name: String(s?.name ?? ""),
+      data: (Array.isArray(s?.data) ? s.data : []).map((d) => typeof d === "number" ? d : Number(d?.y ?? d?.[1])).filter((n) => Number.isFinite(n))
+    }))
+  };
+}
+function humanize(seg) {
+  return seg.replace(/[_-]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/\b\w/g, (c) => c.toUpperCase()).trim();
+}
+function childrenOf(node) {
+  const k = node?.children;
+  return k ? Array.isArray(k) ? k : Array.from(k) : [];
+}
+function routeIndex(XH, params) {
+  const router = XH?.router;
+  const root = router?.rootNode ?? router?.config?.rootNode;
+  const out = /* @__PURE__ */ new Map();
+  if (!router || typeof router.buildPath !== "function" || !root) return out;
+  const walk = (node, prefix) => {
+    for (const c of childrenOf(node)) {
+      const seg = String(c?.name ?? "");
+      if (!seg) continue;
+      const name = prefix ? `${prefix}.${seg}` : seg;
+      let path = "";
+      try {
+        path = router.buildPath(name, params);
+      } catch {
+        path = "";
+      }
+      if (path && !out.has(seg)) out.set(seg, { path, name });
+      walk(c, name);
+    }
+  };
+  walk(root, "");
+  return out;
+}
+function readSitemap(XH, excluded, origin) {
+  const params = XH?.routerState?.params ?? {};
+  const currentName = String(XH?.routerState?.name ?? "");
+  const routes = routeIndex(XH, params);
+  if (!routes.size) return [];
+  const groups = [];
+  for (const tc of getModelsByClass(XH, "TabContainerModel")) {
+    if (excluded(tc)) continue;
+    const tabs = Array.isArray(tc?.tabs) ? tc.tabs : [];
+    const activeTabId = String(tc?.activeTabId ?? "");
+    const items = [];
+    let companyScoped = false;
+    for (const t of tabs) {
+      const id = String(t?.id ?? "");
+      const r = routes.get(id);
+      if (!id || !r) continue;
+      if (r.name.includes(".company.ticker.")) companyScoped = true;
+      items.push({
+        // Redact HERE, at the source — not in a downstream renderer. This is the
+        // one place a Hoist tab TITLE (host-page text, so potentially PII-shaped)
+        // becomes a `HoistDestination.label`, and that label is what EVERY
+        // consumer uses verbatim: renderNav's YAML, buildNavigateTool's
+        // description AND its inputSchema.enum, and executeHostTool's
+        // `.find(d => d.label === destination)` lookup. Redacting once here keeps
+        // all of them consistent by construction — an enum built from an
+        // ALREADY-redacted label can never leak PII a sibling renderer scrubbed
+        // (see Important #1), and a destination arg matching the redacted string
+        // (the only thing the agent ever saw) still resolves.
+        label: redact(String(t?.title ?? "") || humanize(id)),
+        // ABSOLUTE, against the HOST page's origin — not the router's bare path.
+        // This path's only job is to be a link the agent can hand the user, and
+        // the agent's answer renders inside our widget iframe, which is on OUR
+        // origin: a bare "/research" there resolves to app.matterfact.com/research
+        // (a dead link to the wrong app), which is exactly what shipped before.
+        // The adapter runs in the host page, so its own origin is the right one.
+        path: origin && r.path.startsWith("/") ? origin + r.path : r.path,
+        // The fully-qualified route name — what hoist.navigate hands XH.navigate.
+        // Always present: `r` only exists here because routes.get(id) resolved.
+        name: r.name,
+        current: id === activeTabId || r.name === currentName
+      });
+    }
+    if (!items.length) continue;
+    const ticker = String(params.ticker ?? "");
+    const label = companyScoped ? ticker ? `Company \xB7 ${ticker}` : "Company" : "Site";
+    groups.push({ label, items });
+  }
+  return groups;
+}
+function readHoistRuntime(win = typeof window !== "undefined" ? window : void 0) {
+  const XH = win?.XH;
+  if (!XH) return null;
+  const { excludeModels } = readHoistConfig(win);
+  const excluded = (m) => excludeModels.includes(className(m)) || excludeModels.includes(modelId(m));
+  const rs = XH.routerState ?? {};
+  return {
+    route: {
+      name: String(rs.name ?? ""),
+      path: String(rs.path ?? ""),
+      params: rs.params ?? {}
+    },
+    grids: getModelsByClass(XH, "GridModel").filter((m) => !excluded(m)).map(readGrid).filter(hasContent),
+    charts: getModelsByClass(XH, "ChartModel").filter((m) => !excluded(m)).map(readChart).filter((c) => c.series.length > 0),
+    nav: readSitemap(
+      XH,
+      excluded,
+      String(
+        win?.location?.origin ?? ""
+      )
+    )
+  };
+}
+function readActionsConfig(win) {
+  const navigate = win?.matterfact?.hoist?.actions?.navigate;
+  return {
+    navigate: navigate === "confirm" || navigate === "auto" ? navigate : "off"
+  };
+}
+function advertiseTools(win = typeof window !== "undefined" ? window : void 0) {
+  try {
+    const XH = win?.XH;
+    if (!XH) return [];
+    const { navigate } = readActionsConfig(win);
+    if (navigate === "off") return [];
+    const rt = readHoistRuntime(win);
+    if (!rt) return [];
+    return [buildNavigateTool(rt, navigate)];
+  } catch {
+    return [];
+  }
+}
+function executeHostTool(call, win = typeof window !== "undefined" ? window : void 0) {
+  try {
+    if (call.name !== "hoist.navigate") {
+      return { ok: false, error: "unknown tool" };
+    }
+    if (readActionsConfig(win).navigate === "off") {
+      return { ok: false, error: "navigation is disabled" };
+    }
+    const destination = String(call.args?.destination ?? "");
+    const rt = readHoistRuntime(win);
+    const item = rt ? flattenDestinations(rt).find((d) => d.label === destination) : void 0;
+    if (!item) return { ok: false, error: "unknown destination" };
+    const XH = win?.XH;
+    const params = {
+      ...XH?.routerState?.params ?? {},
+      ...call.args?.params ?? {}
+    };
+    if (typeof XH?.navigate === "function") {
+      XH.navigate(item.name, params);
+    } else if (typeof XH?.router?.navigate === "function") {
+      XH.router.navigate(item.name, params);
+    } else {
+      return { ok: false, error: "navigation unavailable" };
+    }
+    return { ok: true, result: redact(`navigated to ${destination}`) };
+  } catch (e) {
+    return {
+      ok: false,
+      error: redact(e instanceof Error ? e.message : "navigate failed")
+    };
+  }
+}
+
+// src/context.ts
+var widgetOrigin = "";
+var MAX_ACTIVITY = 40;
+var send = null;
+var activitySeq = 0;
+var activity = [];
+var lastUrl = "";
+var pageContextOn = true;
+var contextProvider;
+var navFire = null;
+var origPushState = null;
+var origReplaceState = null;
+var snapshotModule = null;
+function isPrivate(el) {
+  if (el.closest("[data-mf-private]")) return true;
+  const tag = el.tagName;
+  if (tag === "INPUT") {
+    const t = el.type;
+    if (t === "password" || t === "hidden") return true;
+  }
+  return false;
+}
+function artifactIdFromPath(pathname) {
+  const m = pathname.match(/^\/(?:embed\/)?artifacts\/(.+?)\/?$/);
+  return m ? decodeURIComponent(m[1]) : null;
+}
+function embeddedMatterfactEntities() {
+  if (!widgetOrigin) return [];
+  const out = [];
+  for (const frame of Array.from(document.querySelectorAll("iframe"))) {
+    let u;
+    try {
+      u = new URL(frame.getAttribute("src") || "", location.href);
+    } catch {
+      continue;
+    }
+    if (u.origin !== widgetOrigin) continue;
+    const id = artifactIdFromPath(u.pathname);
+    if (!id) continue;
+    if (out.some((e) => e.id === id)) continue;
+    out.push({
+      kind: "artifact",
+      id,
+      label: redact(frame.getAttribute("title") || "") || id
+    });
+  }
+  return out;
+}
+function opaqueFrameCount() {
+  return Array.from(document.querySelectorAll("iframe")).filter((f) => {
+    try {
+      const u = new URL(f.getAttribute("src") || "", location.href);
+      return u.origin !== location.origin && u.origin !== widgetOrigin;
+    } catch {
+      return false;
+    }
+  }).length;
+}
+function buildPageContext(declared) {
+  const found = embeddedMatterfactEntities();
+  const opaque = opaqueFrameCount();
+  return {
+    // Path only. A query string is where session ids, tokens and email addresses
+    // live; it is not ours to take.
+    url: location.origin + location.pathname,
+    path: location.pathname,
+    title: redact(document.title),
+    locale: document.documentElement.lang || void 0,
+    ...declared,
+    // After the spread: what we FOUND is additive to what the host DECLARED, never a
+    // replacement. A host that declares its own entities still gets the artifacts we
+    // spotted, and vice versa.
+    entities: [...declared.entities ?? [], ...found],
+    data: {
+      ...declared.data ?? {},
+      ...opaque ? { opaque_frames: opaque } : {}
+    }
+  };
+}
+function readPageContext() {
+  return buildPageContext(
+    window.matterfact?.context ?? {}
+  );
+}
+async function resolveDeclaredContext() {
+  const mf = window.matterfact;
+  if (contextProvider) {
+    const c = await contextProvider();
+    if (c) return c;
+  }
+  if (mf?.getPageContext) {
+    const c = await mf.getPageContext();
+    if (c) return c;
+  }
+  const hoist = detectHoist(() => readHoistRuntime());
+  if (hoist) return buildHoistContext(hoist);
+  return mf?.context ?? {};
+}
+async function publishContext() {
+  if (!pageContextOn) return;
+  const declared = await resolveDeclaredContext();
+  send?.({ type: "host.context", context: buildPageContext(declared) });
+}
+function provideContext() {
+  void publishContext();
+}
+function grantsFromIframeSrcs(srcs, origin) {
+  const out = [];
+  for (const raw of srcs) {
+    let u;
+    try {
+      u = new URL(raw || "", location.href);
+    } catch {
+      continue;
+    }
+    if (u.origin !== origin) continue;
+    const id = artifactIdFromPath(u.pathname);
+    if (!id) continue;
+    const owner = u.searchParams.get("owner") || "";
+    const token = u.searchParams.get("t") || "";
+    if (!owner || !token) continue;
+    if (out.some((g) => g.id === id)) continue;
+    out.push({ id, owner, token });
+  }
+  return out;
+}
+function readArtifactGrants() {
+  if (!widgetOrigin) return [];
+  const srcs = Array.from(document.querySelectorAll("iframe")).map(
+    (f) => f.getAttribute("src") || ""
+  );
+  return grantsFromIframeSrcs(srcs, widgetOrigin);
+}
+function publishArtifactGrants() {
+  send?.({ type: "host.artifactGrants", grants: readArtifactGrants() });
+}
+function pushActivity(e) {
+  activity.push({ ...e, seq: ++activitySeq, ts: Date.now() });
+  if (activity.length > MAX_ACTIVITY) activity.shift();
+  send?.({ type: "host.activity", events: [activity[activity.length - 1]] });
+}
+function controlLabel(el) {
+  const aria = el.getAttribute("aria-label");
+  if (aria) return aria;
+  const id = el.id;
+  if (id) {
+    const forLabel = document.querySelector(`label[for="${CSS.escape(id)}"]`);
+    const t = forLabel?.textContent?.trim();
+    if (t) return t;
+  }
+  const wrapping = el.closest("label")?.textContent?.trim();
+  if (wrapping) return wrapping;
+  const placeholder = el.getAttribute("placeholder");
+  if (placeholder) return placeholder;
+  return "";
+}
+var FORM_CONTROLS = /* @__PURE__ */ new Set(["INPUT", "SELECT", "TEXTAREA"]);
+function describe(el) {
+  const role = el.getAttribute("role") || el.tagName.toLowerCase();
+  const label = el.getAttribute("aria-label") || (FORM_CONTROLS.has(el.tagName) ? controlLabel(el) : el.innerText?.trim().slice(0, 60)) || el.getAttribute("title") || "";
+  return label ? `${role} "${redact(label)}"` : role;
+}
+var ACTIONABLE = 'a[href],button,input,select,textarea,summary,[role="button"],[role="link"],[role="menuitem"],[role="tab"],[role="option"],[role="checkbox"],[role="switch"],[role="radio"],[onclick],[tabindex]';
+function onClick(ev) {
+  const target = ev.target;
+  if (!target || !(target instanceof Element)) return;
+  const label = target.closest("label");
+  const labelled = label ? label.getAttribute("for") && document.getElementById(label.getAttribute("for")) || label.querySelector("input,select,textarea") : null;
+  const actionable = labelled ?? target.closest(ACTIONABLE);
+  if (!actionable || isPrivate(actionable)) return;
+  pushActivity({ type: "click", summary: `clicked ${describe(actionable)}` });
+}
+function onSubmit(ev) {
+  const el = ev.target;
+  if (!el || isPrivate(el)) return;
+  pushActivity({ type: "submit", summary: `submitted ${describe(el)}` });
+}
+function onChange(ev) {
+  const el = ev.target;
+  if (!el || !(el instanceof Element) || isPrivate(el)) return;
+  const tag = el.tagName;
+  const type = el.type;
+  if (tag === "INPUT" && (type === "password" || type === "hidden")) return;
+  let summary = `changed ${describe(el)}`;
+  if (tag === "SELECT") {
+    const opt = el.selectedOptions[0]?.text;
+    if (opt) summary = `${describe(el)} \u2192 "${redact(opt)}"`;
+  } else if (type === "checkbox" || type === "radio") {
+    summary = `${el.checked ? "checked" : "unchecked"} ${describe(el)}`;
+  }
+  pushActivity({ type: "input", summary });
+}
+function watchNavigation() {
+  const fire = () => {
+    const url = location.pathname;
+    if (url === lastUrl) return;
+    lastUrl = url;
+    pushActivity({ type: "nav", summary: `navigated to ${url}` });
+    void publishContext();
+    publishArtifactGrants();
+    send?.({
+      type: "host.tools",
+      tools: advertiseTools(typeof window !== "undefined" ? window : void 0)
+    });
+  };
+  navFire = fire;
+  for (const name of ["pushState", "replaceState"]) {
+    const orig = history[name];
+    if (name === "pushState") origPushState = orig;
+    else origReplaceState = orig;
+    history[name] = function(...args) {
+      const r = orig.apply(this, args);
+      fire();
+      return r;
+    };
+  }
+  window.addEventListener("popstate", fire);
+}
+var lastFocus = {};
+async function readFocus() {
+  const focus = {};
+  const sel = window.getSelection?.();
+  if (sel && !sel.isCollapsed) {
+    const anchor = sel.anchorNode?.parentElement ?? null;
+    if (!anchor || !anchor.closest("[data-mf-private]")) {
+      const text = sel.toString().trim().slice(0, 500);
+      if (text) focus.selection = redact(text);
+    }
+  }
+  const active = document.activeElement;
+  if (active && active !== document.body && !isPrivate(active) && !active.closest("[data-mf-private]")) {
+    const { snapshot } = await loadSnapshotModule();
+    void snapshot;
+    focus.focused = {
+      label: redact(describeControl(active)),
+      role: active.getAttribute("role") || active.tagName.toLowerCase()
+    };
+  }
+  const doc = document.documentElement;
+  const scrollable = doc.scrollHeight - doc.clientHeight;
+  focus.scroll = scrollable > 0 ? Math.round(doc.scrollTop / scrollable * 100) / 100 : 0;
+  return focus;
+}
+function describeControl(el) {
+  return describe(el);
+}
+async function loadSnapshotModule() {
+  const m = await import("./snapshot-UGTXZVB6.js");
+  snapshotModule = m;
+  return m;
+}
+var focusTimer = null;
+function scheduleFocus() {
+  if (focusTimer) return;
+  focusTimer = setTimeout(async () => {
+    focusTimer = null;
+    lastFocus = await readFocus();
+    send?.({ type: "host.focus", focus: lastFocus });
+  }, 250);
+}
+var snapshotSeq = 0;
+async function sendSnapshot(emit) {
+  if (!pageContextOn) return;
+  const hoist = detectHoist(() => readHoistRuntime());
+  if (hoist) {
+    const { rows } = readHoistConfig(
+      typeof window !== "undefined" ? window : void 0
+    );
+    const { yaml: yaml2, truncated: truncated2 } = renderHoistSnapshot(hoist, rows);
+    emit({
+      type: "host.snapshot",
+      snapshot: { yaml: redact(yaml2), seq: ++snapshotSeq, truncated: truncated2 }
+    });
+    lastFocus = { ...lastFocus, visibleRefs: [] };
+    emit({ type: "host.focus", focus: lastFocus });
+    return;
+  }
+  const { snapshot } = await loadSnapshotModule();
+  const { yaml, truncated, visibleRefs } = snapshot();
+  emit({
+    type: "host.snapshot",
+    snapshot: { yaml: redact(yaml), seq: ++snapshotSeq, truncated }
+  });
+  lastFocus = { ...lastFocus, visibleRefs };
+  emit({ type: "host.focus", focus: lastFocus });
+}
+async function sendRegion(ref, emit) {
+  if (!pageContextOn) return;
+  const { snapshotRegion, resolveRef } = await loadSnapshotModule();
+  const el = resolveRef(ref);
+  if (!el) {
+    emit({
+      type: "host.region",
+      ref,
+      yaml: "(this element is no longer on the page)"
+    });
+    return;
+  }
+  const { yaml } = snapshotRegion(el);
+  emit({ type: "host.region", ref, yaml: redact(yaml) });
+}
+async function callTool(call, emit) {
+  if (!pageContextOn) {
+    emit({
+      type: "host.toolResult",
+      callId: call.callId,
+      ok: false,
+      error: "host tools are disabled"
+    });
+    return;
+  }
+  const r = executeHostTool(
+    call,
+    typeof window !== "undefined" ? window : void 0
+  );
+  emit({
+    type: "host.toolResult",
+    callId: call.callId,
+    ok: r.ok,
+    result: r.result,
+    error: r.error
+  });
+}
+function stop() {
+  document.removeEventListener("click", onClick, { capture: true });
+  document.removeEventListener("submit", onSubmit, { capture: true });
+  document.removeEventListener("change", onChange, { capture: true });
+  document.removeEventListener("selectionchange", scheduleFocus);
+  document.removeEventListener("focusin", scheduleFocus, { capture: true });
+  window.removeEventListener("scroll", scheduleFocus, { capture: true });
+  if (navFire) {
+    window.removeEventListener("popstate", navFire);
+    navFire = null;
+  }
+  if (origPushState) {
+    history.pushState = origPushState;
+    origPushState = null;
+  }
+  if (origReplaceState) {
+    history.replaceState = origReplaceState;
+    origReplaceState = null;
+  }
+  if (focusTimer) {
+    clearTimeout(focusTimer);
+    focusTimer = null;
+  }
+  send = null;
+  contextProvider = void 0;
+  activity.length = 0;
+  lastFocus = {};
+  widgetOrigin = "";
+  snapshotModule?.clearRefs();
+}
+function start(emit, origin, pageContext = true, provider) {
+  stop();
+  send = emit;
+  widgetOrigin = origin || "";
+  lastUrl = location.pathname;
+  pageContextOn = pageContext;
+  contextProvider = provider;
+  if (pageContextOn) {
+    void publishContext();
+    publishArtifactGrants();
+    watchNavigation();
+    document.addEventListener("click", onClick, {
+      capture: true,
+      passive: true
+    });
+    document.addEventListener("submit", onSubmit, {
+      capture: true,
+      passive: true
+    });
+    document.addEventListener("change", onChange, {
+      capture: true,
+      passive: true
+    });
+    document.addEventListener("selectionchange", scheduleFocus, {
+      passive: true
+    });
+    document.addEventListener("focusin", scheduleFocus, {
+      capture: true,
+      passive: true
+    });
+    window.addEventListener("scroll", scheduleFocus, {
+      capture: true,
+      passive: true
+    });
+  }
+  const theme = matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+  emit({ type: "host.theme", mode: theme });
+  if (pageContextOn) {
+    const tools = advertiseTools(
+      typeof window !== "undefined" ? window : void 0
+    );
+    if (tools.length) emit({ type: "host.tools", tools });
+  }
+}
+
+export {
+  redact,
+  isPrivate,
+  artifactIdFromPath,
+  buildPageContext,
+  readPageContext,
+  provideContext,
+  grantsFromIframeSrcs,
+  sendSnapshot,
+  sendRegion,
+  callTool,
+  stop,
+  start
+};
+//# sourceMappingURL=chunk-PNSYFXXU.js.map