@opacedev/astro-ai-content-checker 0.3.1

package/dist/highlight.js

@@ -0,0 +1,155 @@
+// src/highlight.ts
+var BAND = {
+  "signal-likely-human": "human",
+  "signal-unclear": "unclear",
+  "signal-potentially-ai": "potential",
+  "signal-likely-ai": "likely",
+  "signal-strongly-ai": "strong"
+};
+var BAND_COLOURS = {
+  human: { ink: "#1c6e46", wash: "#d9f2e5" },
+  unclear: { ink: "#5c6360", wash: "#e6e0d6" },
+  potential: { ink: "#8a5a00", wash: "#f8e5c7" },
+  likely: { ink: "#a84a08", wash: "#f9dcc4" },
+  strong: { ink: "#96261b", wash: "#f6d7d0" }
+};
+var PAGE_MARK_CLASS = "oaci-page-mark";
+var STYLE_ID = "oaci-page-mark-style";
+var PAGE_MARK_CSS = `.${PAGE_MARK_CLASS}{background:var(--oaci-mark-wash,#f8e5c7);color:#12161a;border-radius:2px;box-shadow:0 0 0 2px var(--oaci-mark-wash,#f8e5c7);text-decoration:underline;text-decoration-color:var(--oaci-mark-ink,#8a5a00);text-decoration-thickness:2px;text-underline-offset:2px}@media(forced-colors:active){.${PAGE_MARK_CLASS}{background:Mark;color:MarkText;box-shadow:none}}`;
+var UNTOUCHABLE = /* @__PURE__ */ new Set(["TEXTAREA", "INPUT", "SELECT", "OPTION", "SCRIPT", "STYLE", "TEMPLATE", "NOSCRIPT"]);
+var isSeparator = (run) => run.start_utf16 === 0 && run.end_utf16 === 0;
+function slicesForRange(runs, start, end) {
+  const from = Math.max(0, start);
+  const to = end;
+  if (!Number.isFinite(from) || !Number.isFinite(to) || to <= from) return [];
+  const slices = [];
+  for (const run of runs) {
+    if (isSeparator(run)) continue;
+    if (run.visible_end_utf16 <= from || run.visible_start_utf16 >= to) continue;
+    const offset = Math.max(0, from - run.visible_start_utf16);
+    const finish = Math.min(run.text.length, to - run.visible_start_utf16);
+    const length = finish - offset;
+    if (length <= 0) continue;
+    slices.push({ path: [...run.node_path], offset, length, text: run.text.slice(offset, finish) });
+  }
+  return slices;
+}
+function resolvePath(root, path) {
+  let node = root;
+  for (const index of path) {
+    const children = node?.childNodes;
+    if (!children || index < 0 || index >= children.length) return null;
+    node = children[index];
+  }
+  return node ?? null;
+}
+function isWrappable(node, guard) {
+  let current = node.parentNode;
+  while (current) {
+    if (current === guard) return false;
+    const element = current;
+    const tag = typeof element.tagName === "string" ? element.tagName.toUpperCase() : "";
+    if (UNTOUCHABLE.has(tag)) return false;
+    if (tag.startsWith("ASTRO-DEV-TOOLBAR")) return false;
+    if (element.isContentEditable === true) return false;
+    if (typeof element.getAttribute === "function") {
+      const editable = element.getAttribute("contenteditable");
+      if (editable !== null && editable !== "false") return false;
+    }
+    current = current.parentNode;
+  }
+  return true;
+}
+function createPageHighlighter(options) {
+  const root = options.root;
+  const doc = options.document ?? root.ownerDocument ?? root;
+  const guard = options.guard ?? null;
+  const runs = options.runs;
+  let marks = [];
+  const ensureStyle = () => {
+    const head = doc.head ?? null;
+    if (!head || typeof head.querySelector !== "function") return;
+    if (head.querySelector(`#${STYLE_ID}`)) return;
+    const style = doc.createElement("style");
+    style.setAttribute("id", STYLE_ID);
+    style.textContent = PAGE_MARK_CSS;
+    head.appendChild(style);
+  };
+  const clear = () => {
+    for (const mark of marks.splice(0)) {
+      const parent = mark.parentNode;
+      if (!parent) continue;
+      parent.replaceChild(doc.createTextNode(mark.textContent ?? ""), mark);
+      if (typeof parent.normalize === "function") parent.normalize();
+    }
+  };
+  const scrollTo = (mark) => {
+    if (!mark) return;
+    const view = doc.defaultView ?? null;
+    const fallback = mark;
+    if (!view || typeof view.scrollBy !== "function" || typeof mark.getBoundingClientRect !== "function") {
+      if (typeof fallback.scrollIntoView === "function") fallback.scrollIntoView({ block: "center", inline: "nearest", behavior: "auto" });
+      return;
+    }
+    const height = view.innerHeight || 0;
+    const panel = options.avoid?.() ?? null;
+    const covering = panel && panel.width >= (view.innerWidth || 0) * 0.75 && panel.top <= 8;
+    const top = covering ? panel.bottom + 24 : 24;
+    const bottom = height - 24;
+    const rect = mark.getBoundingClientRect();
+    if (rect.top >= top && rect.bottom <= bottom) return;
+    const room = bottom - top;
+    const target = room > rect.height + 40 ? top + (room - rect.height) / 2 : top;
+    view.scrollBy({ top: rect.top - target, behavior: "auto" });
+  };
+  const show = (start, end, level) => {
+    clear();
+    const band = BAND[level] ?? "unclear";
+    const colours = BAND_COLOURS[band] ?? BAND_COLOURS.unclear;
+    const targets = [];
+    for (const slice of slicesForRange(runs, start, end)) {
+      const node = resolvePath(root, slice.path);
+      if (!node || node.nodeType !== 3) continue;
+      const text = node;
+      const value = text.nodeValue ?? "";
+      if (value.slice(slice.offset, slice.offset + slice.length) !== slice.text) continue;
+      if (!isWrappable(text, guard)) continue;
+      targets.push({ node: text, slice });
+    }
+    if (!targets.length) return 0;
+    ensureStyle();
+    for (const { node, slice } of targets) {
+      const parent = node.parentNode;
+      if (!parent) continue;
+      const value = node.nodeValue ?? "";
+      const before = value.slice(0, slice.offset);
+      const after = value.slice(slice.offset + slice.length);
+      const mark = doc.createElement("span");
+      mark.setAttribute("class", PAGE_MARK_CLASS);
+      mark.setAttribute("data-oaci-page-mark", String(band));
+      mark.setAttribute("style", `--oaci-mark-ink:${colours.ink};--oaci-mark-wash:${colours.wash}`);
+      mark.appendChild(doc.createTextNode(slice.text));
+      if (after) parent.insertBefore(doc.createTextNode(after), node.nextSibling);
+      parent.insertBefore(mark, node.nextSibling);
+      if (before) node.nodeValue = before;
+      else parent.removeChild(node);
+      marks.push(mark);
+    }
+    if (options.scroll !== false) scrollTo(marks[0]);
+    return marks.length;
+  };
+  return {
+    show,
+    clear,
+    get count() {
+      return marks.length;
+    }
+  };
+}
+export {
+  PAGE_MARK_CLASS,
+  PAGE_MARK_CSS,
+  createPageHighlighter,
+  resolvePath,
+  slicesForRange
+};

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import type { AstroIntegration } from 'astro';
+import { type ContentIntegrityAstroOptions } from './options.js';
+export type { ContentIntegrityAstroOptions } from './options.js';
+export { analyseHtml, visibleHtml } from './report.js';
+export declare const APP_ID = "opace-ai-content-checker";
+export default function contentIntegrity(userOptions?: ContentIntegrityAstroOptions): AstroIntegration;

package/dist/index.js

@@ -0,0 +1,43 @@
+import {
+  normaliseOptions
+} from "./shared-MMXWTX2U.js";
+import {
+  analyseHtml,
+  visibleHtml,
+  writeBuildReport
+} from "./shared-EX54KI6H.js";
+
+// src/index.ts
+import { fileURLToPath } from "node:url";
+var APP_ID = "opace-ai-content-checker";
+function contentIntegrity(userOptions = {}) {
+  const options = normaliseOptions(userOptions);
+  return {
+    name: "@opacedev/astro-ai-content-checker",
+    hooks: {
+      "astro:config:setup": ({ addDevToolbarApp, command }) => {
+        if (!options.toolbar || command !== "dev") return;
+        addDevToolbarApp({
+          id: APP_ID,
+          name: "Opace AI Content Checker & Detector for Astro",
+          // A single-colour line glyph, so it sits with Astro's own white rail
+          // icons instead of dropping a colour tile into their row. The full
+          // colour product mark stays inside the panel masthead.
+          icon: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.9" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M9 3.2h6a1.5 1.5 0 0 1 1.5 1.5v.6a1.5 1.5 0 0 1-1.5 1.5H9a1.5 1.5 0 0 1-1.5-1.5v-.6A1.5 1.5 0 0 1 9 3.2Z"/><path d="M16.5 4.7h1.9A1.6 1.6 0 0 1 20 6.3v13.1a1.6 1.6 0 0 1-1.6 1.6H5.6A1.6 1.6 0 0 1 4 19.4V6.3a1.6 1.6 0 0 1 1.6-1.6h1.9"/><path d="M8 10.4h5"/><path d="m8.3 15.2 2.3 2.3 5.1-5.6"/></svg>',
+          entrypoint: fileURLToPath(new URL("./toolbar.js", import.meta.url))
+        });
+      },
+      "astro:build:done": async ({ dir, logger }) => {
+        if (options.buildCheck === false) return;
+        const evidence = await writeBuildReport(dir, options);
+        logger.info(`Hash-only Opace AI Content Checker & Detector report: ${evidence.hash}`);
+      }
+    }
+  };
+}
+export {
+  APP_ID,
+  analyseHtml,
+  contentIntegrity as default,
+  visibleHtml
+};

package/dist/options.d.ts

@@ -0,0 +1,21 @@
+export interface ContentIntegrityAstroOptions {
+    toolbar?: boolean;
+    buildCheck?: 'report' | false;
+    failOn?: Array<'protected_fact_changed'>;
+    localService?: false;
+    reportDirectory?: string;
+    include?: string[];
+    exclude?: string[];
+    maxCharacters?: number;
+}
+export interface NormalisedOptions {
+    toolbar: boolean;
+    buildCheck: 'report' | false;
+    failOn: Array<'protected_fact_changed'>;
+    localService: false;
+    reportDirectory: string;
+    include: string[];
+    exclude: string[];
+    maxCharacters: number;
+}
+export declare function normaliseOptions(value?: ContentIntegrityAstroOptions): NormalisedOptions;

package/dist/options.js

@@ -0,0 +1,6 @@
+import {
+  normaliseOptions
+} from "./shared-MMXWTX2U.js";
+export {
+  normaliseOptions
+};

package/dist/receipt.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The content-free JSON receipt.
+ *
+ * A receipt records what ran and what it found: hashes, counts, levels, scores,
+ * method identities, versions, routes and limitations. It never carries the
+ * page text. Section passages are replaced by their UTF-16 locators, and no
+ * page URL or route path is written, so a receipt can be attached to a ticket
+ * or an audit trail without moving a draft.
+ */
+import type { CheckerResult } from '@opace/content-integrity-cycle5-browser';
+export declare const RECEIPT_VERSION = "astro-toolbar-content-free/2.0.0";
+/** Fails closed if a content-shaped field survives into a receipt. */
+export declare function assertContentFree(value: unknown, path?: string): void;
+/** Build the exact-result receipt with every content-bearing field removed. */
+export declare function buildContentFreeReceipt(result: CheckerResult, generatedAt?: string): Record<string, unknown>;

package/dist/receipt.js

@@ -0,0 +1,100 @@
+// src/receipt.ts
+var RECEIPT_VERSION = "astro-toolbar-content-free/2.0.0";
+var FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["passage", "draft", "excerpt", "candidate", "source_text", "content_text", "route_path"]);
+var CHECKED_KEYS = /* @__PURE__ */ new Set(["content", "text", "url", "href"]);
+var POLICY_TOKEN = /^[A-Za-z0-9_.:+-]{1,40}$/u;
+function assertContentFree(value, path = "receipt") {
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => assertContentFree(item, `${path}[${index}]`));
+    return;
+  }
+  if (typeof value !== "object" || value === null) return;
+  for (const [key, item] of Object.entries(value)) {
+    const suspect = FORBIDDEN_KEYS.has(key) || CHECKED_KEYS.has(key) && !(typeof item === "string" && POLICY_TOKEN.test(item)) && item !== null && item !== void 0;
+    if (suspect) throw new Error(`Receipt field ${path}.${key} could carry page content.`);
+    assertContentFree(item, `${path}.${key}`);
+  }
+}
+function buildContentFreeReceipt(result, generatedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  const ai = result.axes.ai_pattern;
+  const receipt = {
+    schema_version: result.schema_version,
+    contract_version: result.contract_version,
+    receipt_version: RECEIPT_VERSION,
+    result_id: result.result_id,
+    profile: result.profile,
+    surface: "Astro dev toolbar",
+    generated_at: result.generated_at,
+    written_at: generatedAt,
+    contains_content: false,
+    source: {
+      content_hash: result.source.content_hash,
+      normalised_hash: result.source.normalised_hash,
+      content_type: result.source.content_type,
+      language: result.source.language,
+      word_count: result.source.word_count,
+      character_count: result.source.character_count,
+      section_count: result.source.section_count
+    },
+    route: {
+      kind: result.route.kind,
+      location: result.route.location,
+      content_transfer: result.route.content_transfer,
+      privacy_route: result.route.privacy_route,
+      consent: result.route.consent,
+      retention: result.route.retention,
+      model: result.route.model
+    },
+    axes: {
+      ai_pattern: {
+        assessment_status: ai.assessment_status,
+        method_status: ai.method_status,
+        source: ai.source,
+        raw_score: ai.raw_score,
+        raw_margin: ai.raw_margin,
+        display_score: ai.display_score,
+        score_scale: ai.score_scale,
+        level: ai.level,
+        primary_display_threshold: ai.primary_display_threshold,
+        secondary_display_threshold: ai.secondary_display_threshold,
+        flagged: ai.flagged,
+        flag_reason: ai.flag_reason,
+        strongest_section_index: ai.strongest_section_index,
+        reason: ai.reason,
+        limitations: ai.limitations
+      },
+      text_integrity: result.axes.text_integrity,
+      editorial: result.axes.editorial
+    },
+    sections: result.sections.map((section) => ({
+      index: section.index,
+      start_utf16: section.start_utf16,
+      end_utf16: section.end_utf16,
+      word_count: section.word_count,
+      raw_score: section.raw_score,
+      raw_margin: section.raw_margin,
+      display_score: section.display_score,
+      level: section.level,
+      evidence: section.evidence.map((item) => ({ id: item.id, kind: item.kind, basis: item.basis ?? null }))
+    })),
+    methods: result.methods.map((method) => ({
+      id: method.id,
+      category: method.category,
+      provider_or_method: method.provider_or_method,
+      version: method.version,
+      status: method.status,
+      privacy_route: method.privacy_route,
+      limitations: method.limitations
+    })),
+    provenance: result.provenance,
+    abuse_controls: result.abuse_controls,
+    limitations: [...result.limitations, "No page text, page URL or route path is retained in this receipt."]
+  };
+  assertContentFree(receipt);
+  return receipt;
+}
+export {
+  RECEIPT_VERSION,
+  assertContentFree,
+  buildContentFreeReceipt
+};

package/dist/report.d.ts

@@ -0,0 +1,55 @@
+import type { NormalisedOptions } from './options.js';
+declare const STABLE_TIME = "2000-01-01T00:00:00.000Z";
+export declare function visibleHtml(html: string, maxCharacters?: number): string;
+export interface HashOnlyRouteReport {
+    route_id: string;
+    source_hash: string;
+    word_count: number;
+    summary: Record<string, number>;
+    methods: Array<{
+        id: string;
+        version: string;
+        status: string;
+        limitations: string[];
+    }>;
+    protected_counts: Record<string, number>;
+    pattern_counts: Record<string, number>;
+    truncated: boolean;
+}
+export interface AstroIntegrityReport {
+    schema_version: '1.0';
+    contract_version: '1.0.0';
+    package_version: '0.3.1';
+    /** Build support, never the full checker. The interactive toolbar is the checker. */
+    profile: 'build_scan';
+    mode: 'report_only';
+    privacy_route: 'browser';
+    contains_content: false;
+    generated_at: typeof STABLE_TIME;
+    /** The three result axes, with the model axis honestly unassessed. */
+    axes: {
+        ai_pattern: {
+            assessment_status: 'not_assessed';
+            reason: string;
+            limitations: string[];
+        };
+        text_integrity: {
+            method_status: 'per_route';
+            reason: string;
+        };
+        editorial: {
+            method_status: 'per_route';
+            reason: string;
+        };
+    };
+    routes: HashOnlyRouteReport[];
+    limitations: string[];
+}
+export declare function shouldInclude(path: string, options: Pick<NormalisedOptions, 'include' | 'exclude'>): boolean;
+export declare function analyseHtml(html: string, opaqueRoute: string, maxCharacters?: number): Promise<HashOnlyRouteReport>;
+export declare function writeBuildReport(outputUrl: URL, options: NormalisedOptions): Promise<{
+    json: string;
+    html: string;
+    hash: string;
+}>;
+export {};

package/dist/report.js

@@ -0,0 +1,12 @@
+import {
+  analyseHtml,
+  shouldInclude,
+  visibleHtml,
+  writeBuildReport
+} from "./shared-EX54KI6H.js";
+export {
+  analyseHtml,
+  shouldInclude,
+  visibleHtml,
+  writeBuildReport
+};

package/dist/sections.js

@@ -0,0 +1,181 @@
+// src/sections.ts
+function stripLabel(number, total, level, score) {
+  return [`Section ${number} of ${total}`, level, score].filter(Boolean).join(" \xB7 ");
+}
+function neighbour(index, total, step) {
+  const next = index + step;
+  return next < 0 || next >= total ? null : next;
+}
+function tintStatus(marks) {
+  if (marks > 0) return `Shown on the page: ${marks} passage${marks === 1 ? "" : "s"} tinted in the band colour.`;
+  return "This passage could not be found on the page as it is now, so nothing was tinted. The evidence below is still the passage the model read.";
+}
+var NOOP = {
+  total: 0,
+  open: null,
+  show() {
+  },
+  close() {
+  },
+  toggled() {
+  },
+  destroy() {
+  }
+};
+function installSectionAccordion(root, options = {}) {
+  const strip = root.querySelector(".oaci-strip");
+  const list = strip?.querySelector(".oaci-strip__list");
+  const rows = list ? [...list.childNodes].filter((node) => node.nodeType === 1 && node.tagName === "LI") : [];
+  const dives = root.querySelector(".oaci-dives");
+  if (!strip || !list || !rows.length || !dives) return NOOP;
+  const doc = root.ownerDocument;
+  const total = rows.length;
+  const listeners = [];
+  const on = (node, type, handler) => {
+    node.addEventListener(type, handler);
+    listeners.push(() => node.removeEventListener(type, handler));
+  };
+  const intro = dives.querySelector(".oaci-dives__intro");
+  const head = strip.querySelector(".oaci-strip__head");
+  if (intro && head) head.appendChild(intro);
+  for (const dive of dives.querySelectorAll(".oaci-dive")) {
+    const index = Number(dive.getAttribute("data-oaci-section"));
+    const row = Number.isInteger(index) ? rows[index] : void 0;
+    if (!row) continue;
+    dive.setAttribute("class", `${dive.getAttribute("class") ?? ""} oacit-dive-inline`.trim());
+    row.appendChild(dive);
+  }
+  dives.remove();
+  const bars = rows.map((row) => row.querySelector(".oaci-strip__bar"));
+  const panels = rows.map((row) => row.querySelector(".oaci-dive"));
+  bars.forEach((bar, index) => {
+    bar?.setAttribute("aria-expanded", "false");
+    const panel = panels[index];
+    if (panel) panel.hidden = true;
+  });
+  const make = (tag, className, attributes = {}, text = "") => {
+    const node = doc.createElement(tag);
+    node.setAttribute("class", className);
+    for (const [name, value] of Object.entries(attributes)) node.setAttribute(name, value);
+    if (text) node.appendChild(doc.createTextNode(text));
+    return node;
+  };
+  const nav = make("div", "oacit-secnav", { "data-oacit-secnav": "" });
+  nav.hidden = true;
+  const step = (direction, label, glyph) => {
+    const button = make("button", "oacit-secnav__step", {
+      type: "button",
+      "data-oacit-secnav-step": direction,
+      "aria-label": label
+    });
+    button.appendChild(make("span", "oacit-secnav__glyph", { "aria-hidden": "true" }, glyph));
+    return button;
+  };
+  const previous = step("-1", "Previous section", "\u2039");
+  const following = step("1", "Next section", "\u203A");
+  const now = make("p", "oacit-secnav__now", { "data-oacit-secnav-now": "" });
+  const closeButton = make("button", "oacit-secnav__close", { type: "button", "data-oacit-secnav-close": "" }, "Close");
+  const tint = make("p", "oacit-secnav__tint", { "data-oacit-secnav-tint": "", role: "status" });
+  for (const child of [previous, now, following, closeButton, tint]) nav.appendChild(child);
+  strip.insertBefore(nav, list);
+  const steps = [previous, following];
+  const offsetHost = options.offsetHost ?? options.scroller ?? null;
+  const heightOf = (node) => node && Number.isFinite(node.offsetHeight) ? node.offsetHeight : 0;
+  const measure = () => {
+    if (!offsetHost || typeof offsetHost.style?.setProperty !== "function") return;
+    offsetHost.style.setProperty("--oacit-head-h", `${heightOf(offsetHost.querySelector(".oacit-head"))}px`);
+    offsetHost.style.setProperty("--oacit-secnav-h", `${nav.hidden ? 0 : heightOf(nav)}px`);
+  };
+  let open = null;
+  const pin = (index) => {
+    const scroller = options.scroller;
+    const row = rows[index];
+    if (!scroller || !row) return;
+    if (typeof scroller.getBoundingClientRect !== "function" || typeof row.getBoundingClientRect !== "function") return;
+    const above = heightOf(scroller.querySelector(".oacit-head")) + (nav.hidden ? 0 : heightOf(nav));
+    const delta = row.getBoundingClientRect().top - scroller.getBoundingClientRect().top - above;
+    scroller.scrollTop += delta;
+  };
+  const paint = () => {
+    if (open === null) {
+      nav.hidden = true;
+      measure();
+      return;
+    }
+    const bar = bars[open];
+    const level = bar?.querySelector(".oaci-strip__band")?.textContent?.trim() ?? "";
+    const score = bar?.querySelector(".oaci-strip__score")?.textContent?.trim() ?? "";
+    now.textContent = stripLabel(open + 1, total, level, score);
+    for (const step2 of steps) {
+      const target = neighbour(open, total, Number(step2.getAttribute("data-oacit-secnav-step")));
+      step2.disabled = target === null;
+    }
+    nav.hidden = false;
+    measure();
+  };
+  const apply = (index) => {
+    open = index;
+    rows.forEach((row, position) => {
+      const expanded = position === index;
+      row.toggleAttribute("data-oacit-open", expanded);
+      bars[position]?.setAttribute("aria-expanded", String(expanded));
+      const panel = panels[position];
+      if (panel) panel.hidden = !expanded;
+    });
+    paint();
+  };
+  const show = (index) => {
+    if (index < 0 || index >= total) return;
+    apply(index);
+    tint.textContent = tintStatus(options.onOpen ? options.onOpen(index) : 0);
+    pin(index);
+  };
+  const close = () => {
+    apply(null);
+    tint.textContent = "";
+    options.onClose?.();
+  };
+  const toggled = (index, expanded) => {
+    if (!expanded) {
+      close();
+      return;
+    }
+    show(index);
+  };
+  for (const step2 of steps) {
+    on(step2, "click", () => {
+      if (open === null) return;
+      const target = neighbour(open, total, Number(step2.getAttribute("data-oacit-secnav-step")));
+      if (target === null) return;
+      show(target);
+    });
+  }
+  on(closeButton, "click", () => {
+    const returning = open;
+    close();
+    if (returning !== null) bars[returning]?.focus();
+  });
+  apply(null);
+  measure();
+  return {
+    get total() {
+      return total;
+    },
+    get open() {
+      return open;
+    },
+    show,
+    close,
+    toggled,
+    destroy() {
+      for (const remove of listeners.splice(0)) remove();
+      options.onClose?.();
+    }
+  };
+}
+export {
+  installSectionAccordion,
+  neighbour,
+  stripLabel,
+  tintStatus
+};

package/dist/share.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Sharing a reading without sharing the page.
+ *
+ * A share here is a summary: the level, the per-section scores already on
+ * screen, the word count, the date and the model version. No page text, no URL
+ * and no route path travels. The payload rides in the URL fragment, which a
+ * browser never sends to a server, and the honesty line travels with every
+ * summary so a level cannot be quoted without its limits.
+ *
+ * The wire shape matches the website checker's `#shared=` fragment exactly, so a
+ * summary produced in the toolbar opens as a read-only result on the product
+ * page. `v:1` fixes the level ordering forever.
+ */
+import type { CheckerResult } from '@opace/content-integrity-cycle5-browser';
+export declare const CHECKER_URL = "https://opace.agency/tools/ai/content-verification-integrity/checker/";
+export declare const HONESTY_LINE = "No AI checker can prove who wrote a text \u2014 this is a pattern reading.";
+/** Fixed by the wire format. Withheld readings produced no level and are never shared. */
+declare const SHAREABLE_LEVELS: readonly ["signal-likely-human", "signal-unclear", "signal-potentially-ai", "signal-likely-ai", "signal-strongly-ai"];
+export type ShareableLevel = (typeof SHAREABLE_LEVELS)[number];
+export declare const LEVEL_NAMES: Readonly<Record<ShareableLevel, string>>;
+export interface ShareSummary {
+    levelId: ShareableLevel;
+    /** `score` is the four-decimal wire value; `display` is the exact string the reading printed. */
+    sections: Array<{
+        index: number;
+        score: number;
+        display: string;
+        levelId: ShareableLevel;
+    }>;
+    display: string;
+    words: number;
+    date: string;
+    version: string;
+}
+/**
+ * Build a summary from the canonical content-free share payload the core
+ * already asserts carries no draft. The page text is deliberately not a
+ * parameter, so no excerpt can reach a share by accident.
+ */
+export declare function buildShareSummary(result: CheckerResult): ShareSummary | undefined;
+/** Encode a summary as the base64url payload the website's `#shared=` reader accepts. */
+export declare function encodeShared(summary: ShareSummary): string;
+/** The full shareable link: the canonical product page plus the content-free fragment. */
+export declare const shareUrl: (summary: ShareSummary) => string;
+/** The plain-text summary offered alongside the link. Counts and levels only. */
+export declare function shareText(summary: ShareSummary): string;
+export {};