@elabs-ai/components-viewer 4.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Manuel Reimitz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS 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 OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,143 @@
+<!-- brand-ui:gen:readme:start -->
+<!-- Generated by scripts/gen-package-readmes.mjs — do not edit inside these markers. -->
+
+# `@elabs-ai/components-viewer`
+
+> FileViewer — any file (image, text, JSON, CSV) via a pluggable adapter registry.
+
+Part of **brand-ui**, a source-owned, token-driven React component system.
+These packages are **private** and are not published to any registry — they are
+consumed from this workspace. See `docs/CONSUMING.md`.
+
+## Install
+
+Inside this monorepo the packages resolve as workspace dependencies:
+
+```json
+"@elabs-ai/components-viewer": "workspace:*"
+```
+
+## Set up styling (do not skip)
+
+Components are Tailwind v4 classes backed by semantic tokens. Two lines in
+your CSS entry, or **everything renders unstyled** — the single most common
+mistake:
+
+```css
+@import "@elabs-ai/components-tokens/styles.css";
+@source "../node_modules/@elabs-ai/components-viewer/dist";
+```
+
+The `@source` line is required because Tailwind ignores `node_modules`. Add
+one per brand-ui package you render. Then wrap your app once:
+
+```tsx
+import { ThemeProvider } from "@elabs-ai/components-tokens";
+
+<ThemeProvider defaultTheme="light">{children}</ThemeProvider>;
+```
+
+## What's in it
+
+19 exported components — including `ACTIVE_HIGHLIGHT_SELECTOR`, `DEFAULT_ZOOM`, `FileViewer`, `FileViewerContent`, `FileViewerEmpty`.
+
+Don't guess the API — ask the CLI:
+
+```bash
+pnpm add -D @elabs-ai/components-cli
+pnpm exec brand-ui search <query>   # find a component
+pnpm exec brand-ui docs <Name>      # its real props, from source
+```
+
+## Using an AI coding agent?
+
+For Claude Code, install the plugin from this repo's checkout:
+
+```
+/plugin marketplace add .
+/plugin install brand-ui
+```
+
+`brand-ui docs <Name>` returns intent, composition, state→token mappings and
+anti-patterns — tell your agent to run it instead of guessing a prop. The CLI
+also runs as an MCP server (`brand-ui mcp`).
+
+## Full guide
+
+Tailwind and Next.js wiring, per-package extras, agent enablement and a
+prompt for migrating an existing project: `docs/CONSUMING.md`.
+
+## License
+
+UNLICENSED — private.
+
+<!-- brand-ui:gen:readme:end -->
+
+---
+
+## Package detail
+
+Renders a file — whatever it is, wherever it came from — themed and accessible.
+
+```tsx
+import { FileViewer } from "@elabs-ai/components-viewer";
+
+<div className="h-[600px]">
+  <FileViewer source={{ kind: "file", file }} />
+</div>;
+```
+
+### The input is always a `FileSource`
+
+One union from `@elabs-ai/components-ui` covers every way an app can
+be holding a file — a user's `File`, an in-memory `Blob` or `ArrayBuffer`, a
+string of content, or a remote URL. The `url` variant carries `init`, so a file
+behind auth is reachable:
+
+```tsx
+<FileViewer
+  source={{
+    kind: "url",
+    url: "https://files.internal/report.csv",
+    init: { headers: { Authorization: `Bearer ${token}` } },
+  }}
+/>
+```
+
+### Formats come from adapters, and adapters are pluggable
+
+Every format is an adapter in a registry: a small eager manifest (what it can
+open, what the toolbar should offer) plus a lazy loader. Nothing heavy is in the
+entry chunk, and an app that never opens a spreadsheet never downloads a
+spreadsheet parser.
+
+Register your own — or override a built-in by registering a higher priority for
+the same id:
+
+```tsx
+import { createRegistry, FileViewer } from "@elabs-ai/components-viewer";
+
+const registry = createRegistry();
+registry.register(myManifest, () => import("./my-adapter"));
+
+<FileViewer source={source} registry={registry} />;
+```
+
+### Parsers are optional peers
+
+Only install what you open. A format whose parser is absent renders a clear
+"can't open this here" state with a download action — never a module-resolution
+crash.
+
+| Format          | Peer to install |
+| --------------- | --------------- |
+| `.csv` / `.tsv` | `papaparse`     |
+
+Images, plain text and JSON need nothing — they use platform APIs.
+
+### Adapters emit data, not HTML
+
+An adapter returns a model (rows, a tree, a page) that brand-ui components
+render, so the viewer's chrome is fully token-driven and re-themes with the rest
+of your app. Document _content_ — a photo, a rendered page — renders as
+authored, because that is the file.

package/dist/chunk-2NQ4RSJ3.js

@@ -0,0 +1,18 @@
+"use client";
+import {
+  localizeRanges
+} from "./chunk-VO2273Z2.js";
+
+// src/components/marked-text.tsx
+import { MatchHighlight } from "@elabs-ai/components-ui";
+import { Fragment, jsx } from "react/jsx-runtime";
+function MarkedText({ text, marks, start }) {
+  const local = !marks || start === void 0 ? void 0 : localizeRanges(marks, start, start + text.length);
+  if (!local || local.ranges.length === 0) return /* @__PURE__ */ jsx(Fragment, { children: text });
+  return /* @__PURE__ */ jsx(MatchHighlight, { text, ranges: local.ranges, activeIndex: local.activeIndex });
+}
+
+export {
+  MarkedText
+};
+//# sourceMappingURL=chunk-2NQ4RSJ3.js.map

package/dist/chunk-2NQ4RSJ3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/marked-text.tsx"],"sourcesContent":["\"use client\";\n\n/**\n * One slice of text, with whatever marks land in it.\n *\n * The last step of the highlight funnel, and the same three lines in every\n * adapter that draws its text in pieces — a Word run, a spreadsheet cell, a\n * slide's bullet. Each of them holds document offsets for its own slice and\n * needs the ranges rebased before a `<mark>` layer can paint them, so the\n * rebase-then-paint pair is named once here rather than copied a fourth time\n * (`.claude/rules/design-first.md` — patterns over instances).\n *\n * `start === undefined` means \"this slice is not in the projection\" (an adapter\n * with no index, a cell past the truncation bound), which renders as plain text\n * rather than as an error: a document that cannot be addressed is still a\n * document that can be read.\n */\n\nimport { MatchHighlight } from \"@elabs-ai/components-ui\";\n\nimport { localizeRanges, type MarkRanges } from \"../core/highlight-marks\";\n\nexport interface MarkedTextProps {\n  text: string;\n  /** Marks in PROJECTION offsets — rebased here, not by the caller. */\n  marks: MarkRanges | undefined;\n  /** Where this slice begins in the projection. */\n  start: number | undefined;\n}\n\nexport function MarkedText({ text, marks, start }: MarkedTextProps) {\n  const local =\n    !marks || start === undefined ? undefined : localizeRanges(marks, start, start + text.length);\n  if (!local || local.ranges.length === 0) return <>{text}</>;\n  return <MatchHighlight text={text} ranges={local.ranges} activeIndex={local.activeIndex} />;\n}\n"],"mappings":";;;;;;AAkBA,SAAS,sBAAsB;AAemB;AAH3C,SAAS,WAAW,EAAE,MAAM,OAAO,MAAM,GAAoB;AAClE,QAAM,QACJ,CAAC,SAAS,UAAU,SAAY,SAAY,eAAe,OAAO,OAAO,QAAQ,KAAK,MAAM;AAC9F,MAAI,CAAC,SAAS,MAAM,OAAO,WAAW,EAAG,QAAO,gCAAG,gBAAK;AACxD,SAAO,oBAAC,kBAAe,MAAY,QAAQ,MAAM,QAAQ,aAAa,MAAM,aAAa;AAC3F;","names":[]}

package/dist/chunk-3U3MESBU.js

@@ -0,0 +1,21 @@
+"use client";
+import {
+  PROTOCOL_VERSION
+} from "./chunk-AORNMH77.js";
+
+// src/adapters/csv/csv-manifest.ts
+var csvManifest = {
+  id: "csv",
+  protocol: PROTOCOL_VERSION,
+  extensions: ["csv", "tsv"],
+  mediaTypes: ["text/csv", "text/tab-separated-values"],
+  // Addressed against the PARSED grid (`gridToText`), not the raw bytes — see
+  // the adapter. No `rect`: a table cell has no page geometry to point at.
+  capabilities: { text: true, search: true, highlight: ["quote", "range"] },
+  requires: ["papaparse"]
+};
+
+export {
+  csvManifest
+};
+//# sourceMappingURL=chunk-3U3MESBU.js.map

package/dist/chunk-3U3MESBU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/adapters/csv/csv-manifest.ts"],"sourcesContent":["import type { AdapterManifest } from \"../../core/types\";\nimport { PROTOCOL_VERSION } from \"../../core/types\";\n\n/**\n * Eager, data-only (see `image-manifest.ts`).\n *\n * `requires` names the OPTIONAL peer this adapter dynamically imports. It is\n * what the \"install this to open that\" message names when the import cannot\n * resolve — the registry never installs anything itself.\n */\nexport const csvManifest: AdapterManifest = {\n  id: \"csv\",\n  protocol: PROTOCOL_VERSION,\n  extensions: [\"csv\", \"tsv\"],\n  mediaTypes: [\"text/csv\", \"text/tab-separated-values\"],\n  // Addressed against the PARSED grid (`gridToText`), not the raw bytes — see\n  // the adapter. No `rect`: a table cell has no page geometry to point at.\n  capabilities: { text: true, search: true, highlight: [\"quote\", \"range\"] },\n  requires: [\"papaparse\"],\n};\n"],"mappings":";;;;;;AAUO,IAAM,cAA+B;AAAA,EAC1C,IAAI;AAAA,EACJ,UAAU;AAAA,EACV,YAAY,CAAC,OAAO,KAAK;AAAA,EACzB,YAAY,CAAC,YAAY,2BAA2B;AAAA;AAAA;AAAA,EAGpD,cAAc,EAAE,MAAM,MAAM,QAAQ,MAAM,WAAW,CAAC,SAAS,OAAO,EAAE;AAAA,EACxE,UAAU,CAAC,WAAW;AACxB;","names":[]}

package/dist/chunk-4OFQYALG.js

@@ -0,0 +1,147 @@
+"use client";
+
+// src/core/use-page-control.ts
+import { useCallback, useState } from "react";
+function usePageControl(pageNumber, onPageChange, pageCount) {
+  const controlled = pageNumber !== void 0;
+  const [own, setOwn] = useState(1);
+  const raw = controlled ? pageNumber : own;
+  const current = pageCount > 0 ? Math.min(Math.max(1, raw), pageCount) : Math.max(1, raw);
+  const goToPage = useCallback(
+    (page) => {
+      const next = pageCount > 0 ? Math.min(Math.max(1, page), pageCount) : Math.max(1, page);
+      if (!controlled) setOwn(next);
+      onPageChange?.(next);
+    },
+    [controlled, onPageChange, pageCount]
+  );
+  return [current, goToPage];
+}
+
+// src/core/use-paged-scroll.ts
+import { useVirtualizer } from "@tanstack/react-virtual";
+import { useEffect, useLayoutEffect, useRef, useState as useState2 } from "react";
+
+// src/core/scroll-host.ts
+var SCROLL_HOST_SELECTOR = '[data-slot="file-viewer-content"]';
+function findScrollHost(node) {
+  if (!node) return null;
+  const shell = node.closest(SCROLL_HOST_SELECTOR);
+  if (shell) return shell;
+  const view = node.ownerDocument?.defaultView;
+  if (!view) return null;
+  let current = node.parentElement;
+  while (current) {
+    const { overflowY, overflowX } = view.getComputedStyle(current);
+    if (/(auto|scroll|overlay)/.test(overflowY) || /(auto|scroll|overlay)/.test(overflowX)) {
+      return current;
+    }
+    current = current.parentElement;
+  }
+  return null;
+}
+
+// src/core/use-paged-scroll.ts
+var EDGE_SLACK = 8;
+function usePagedScroll({
+  count,
+  listRef,
+  pageNumber,
+  goToPage,
+  estimateSize,
+  sizeKey
+}) {
+  const [host, setHost] = useState2(null);
+  const [scrollMargin, setScrollMargin] = useState2(0);
+  useEffect(() => {
+    const list = listRef.current;
+    const found = findScrollHost(list) ?? list?.parentElement ?? null;
+    setHost(found);
+    if (!list || !found) return;
+    setScrollMargin(
+      list.getBoundingClientRect().top - found.getBoundingClientRect().top + found.scrollTop
+    );
+  }, [listRef]);
+  const virtualizer = useVirtualizer({
+    count,
+    getScrollElement: () => host,
+    estimateSize,
+    overscan: 1,
+    scrollMargin,
+    measureElement: (element, entry, instance) => {
+      const measured = entry?.borderBoxSize?.[0]?.blockSize ?? element.getBoundingClientRect().height;
+      if (measured > 0) return measured;
+      const index = Number(element.getAttribute("data-index"));
+      return Number.isNaN(index) ? 0 : instance.options.estimateSize(index);
+    }
+  });
+  const items = virtualizer.getVirtualItems();
+  const scrollOffset = virtualizer.scrollOffset ?? 0;
+  const top = items.find((item) => item.start + item.size > scrollOffset + EDGE_SLACK);
+  const active = top ? top.index + 1 : 1;
+  const anchor = useRef({ index: 0, fraction: 0 });
+  useEffect(() => {
+    if (!top || top.size <= 0) return;
+    const fraction = (scrollOffset - top.start) / top.size;
+    anchor.current = { index: top.index, fraction: Math.min(fraction, 1) };
+  }, [top, scrollOffset]);
+  const reported = useRef(0);
+  const requested = useRef(0);
+  const lastActive = useRef(active);
+  useEffect(() => {
+    if (count === 0 || active === lastActive.current) return;
+    lastActive.current = active;
+    if (active === pageNumber) return;
+    reported.current = active;
+    goToPage(active);
+  }, [active, pageNumber, count, goToPage]);
+  useEffect(() => {
+    if (!host || count === 0 || requested.current === pageNumber) return;
+    requested.current = pageNumber;
+    if (pageNumber === reported.current || pageNumber === active) return;
+    virtualizer.scrollToIndex(pageNumber - 1, { align: "start" });
+  }, [host, pageNumber, active, count, virtualizer]);
+  const lastSizeKey = useRef(sizeKey);
+  useLayoutEffect(() => {
+    if (lastSizeKey.current === sizeKey) return;
+    lastSizeKey.current = sizeKey;
+    if (count === 0) return;
+    virtualizer.measure();
+    const { index, fraction } = anchor.current;
+    if (index === 0 && fraction <= 0) return;
+    const start = virtualizer.getOffsetForIndex(index, "start")?.[0];
+    if (start === void 0) return;
+    const size = virtualizer.measurementsCache[index]?.size ?? 0;
+    virtualizer.scrollToOffset(start + fraction * size, { align: "start" });
+  }, [sizeKey, count, virtualizer]);
+  return virtualizer;
+}
+
+// src/core/use-viewport-size.ts
+import { useEffect as useEffect2, useState as useState3 } from "react";
+function useViewportSize(ref) {
+  const [size, setSize] = useState3();
+  useEffect2(() => {
+    const host = findScrollHost(ref.current) ?? ref.current?.parentElement ?? ref.current;
+    if (!host || typeof ResizeObserver === "undefined") return;
+    const measure = () => {
+      const { clientWidth: width, clientHeight: height } = host;
+      if (width === 0 || height === 0) return;
+      setSize(
+        (current) => current && Math.abs(current.width - width) < 1 && Math.abs(current.height - height) < 1 ? current : { width, height }
+      );
+    };
+    measure();
+    const observer = new ResizeObserver(measure);
+    observer.observe(host);
+    return () => observer.disconnect();
+  }, [ref]);
+  return size;
+}
+
+export {
+  usePageControl,
+  usePagedScroll,
+  useViewportSize
+};
+//# sourceMappingURL=chunk-4OFQYALG.js.map

package/dist/chunk-4OFQYALG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/use-page-control.ts","../src/core/use-paged-scroll.ts","../src/core/scroll-host.ts","../src/core/use-viewport-size.ts"],"sourcesContent":["\"use client\";\n\n/**\n * The page half of the renderer contract, as one hook.\n *\n * `AdapterRendererProps.pageNumber` is optional on purpose: inside a\n * `FileViewerProvider` the shell owns the page so a control can live anywhere,\n * but a `Renderer` mounted on its own — a test, an embed that wants nothing but\n * the canvas — must still be able to turn a page. That is the ordinary\n * controlled/uncontrolled trio (`component-api.md`), and both paginated adapters\n * need exactly the same six lines of it.\n */\n\nimport { useCallback, useState } from \"react\";\n\n/**\n * @param pageNumber The controlled page, or `undefined` for uncontrolled.\n * @param onPageChange Reported on every navigation, controlled or not.\n * @param pageCount Upper bound. `0` while the count is not known yet.\n * @returns The page to render, and the function that navigates to another.\n */\nexport function usePageControl(\n  pageNumber: number | undefined,\n  onPageChange: ((page: number) => void) | undefined,\n  pageCount: number,\n): readonly [number, (page: number) => void] {\n  const controlled = pageNumber !== undefined;\n  const [own, setOwn] = useState(1);\n\n  // Clamped on READ, not on write: a controlled owner that has not yet heard\n  // about a shorter document would otherwise render page 40 of 12 and blank the\n  // canvas, and clamping its prop back at it would fight the owner.\n  const raw = controlled ? pageNumber : own;\n  const current = pageCount > 0 ? Math.min(Math.max(1, raw), pageCount) : Math.max(1, raw);\n\n  const goToPage = useCallback(\n    (page: number) => {\n      const next = pageCount > 0 ? Math.min(Math.max(1, page), pageCount) : Math.max(1, page);\n      // Mirroring the platform: a controlled value is never written locally.\n      if (!controlled) setOwn(next);\n      onPageChange?.(next);\n    },\n    [controlled, onPageChange, pageCount],\n  );\n\n  return [current, goToPage] as const;\n}\n","\"use client\";\n\n/**\n * Continuous scrolling for a paginated document, over the shell's own viewport.\n *\n * ## Why the pages are virtualized\n *\n * A 900-page PDF is 900 canvases, 900 text layers and 900 rasterization jobs. A\n * plain stack would allocate all of them before the first page appeared. Only the\n * pages near the viewport are mounted, so the cost is a function of the WINDOW,\n * not of the document.\n *\n * ## Why the virtualizer scrolls someone else's element\n *\n * `FileViewerContent` is the one scroll boundary (`viewer-components.md`), so the\n * list is a CHILD of the scrolling box rather than being one. That is what\n * `scrollMargin` is for: every measurement is offset by where the list starts\n * inside the pane, which is the pane's own padding.\n *\n * ## The page number is a two-way binding, and that is the whole difficulty\n *\n * The shell owns `pageNumber` (ADR 0026), so it flows two ways: the reader\n * scrolls and the pager must follow; the reader types \"7\" and the document must\n * scroll. Naively wiring both makes them fight — a scroll reports page 3, the\n * prop becomes 3, and the \"the prop changed, scroll to it\" effect snaps the\n * reader back to the top of page 3 mid-gesture. Each direction therefore\n * remembers what it last said, and ignores an echo of its own words.\n */\n\nimport { useVirtualizer, type Virtualizer } from \"@tanstack/react-virtual\";\nimport { useEffect, useLayoutEffect, useRef, useState, type RefObject } from \"react\";\n\nimport { findScrollHost } from \"./scroll-host\";\n\n/**\n * Slack under the viewport's top edge, in CSS pixels.\n *\n * Without it the page whose last pixel row is still visible counts as the page\n * being read, so the pager flickers back a page at every boundary.\n */\nconst EDGE_SLACK = 8;\n\nexport interface PagedScrollOptions {\n  /** Pages in the document. `0` disables the virtualizer entirely. */\n  count: number;\n  /**\n   * The element the pages are laid out in. Must be a descendant of the scroll\n   * host — its `offsetTop` is what `scrollMargin` is derived from.\n   */\n  listRef: RefObject<HTMLElement | null>;\n  /** The page the shell wants shown, 1-based. */\n  pageNumber: number;\n  /** Report the page the reader scrolled to, 1-based. */\n  goToPage: (page: number) => void;\n  /** Height of page `index` at the current scale, in CSS pixels. */\n  estimateSize: (index: number) => number;\n  /**\n   * A value that changes whenever EVERY page's size changes — the scale, in\n   * practice. Every cached measurement is thrown away and the reader is put back\n   * where they were reading, at the new size.\n   */\n  sizeKey?: unknown;\n}\n\n/**\n * @returns The virtualizer. Render `getVirtualItems()` inside `listRef`'s\n * element, sized to `getTotalSize()`, translated by `start - scrollMargin`.\n */\nexport function usePagedScroll({\n  count,\n  listRef,\n  pageNumber,\n  goToPage,\n  estimateSize,\n  sizeKey,\n}: PagedScrollOptions): Virtualizer<HTMLElement, Element> {\n  // Resolved after mount rather than passed in: a renderer may be composed into\n  // the shell, into a consumer's own frame, or mounted bare in a test, and only\n  // the DOM knows which. State (not a ref) so the virtualizer re-reads it.\n  const [host, setHost] = useState<HTMLElement | null>(null);\n  const [scrollMargin, setScrollMargin] = useState(0);\n  useEffect(() => {\n    const list = listRef.current;\n    const found = findScrollHost(list) ?? list?.parentElement ?? null;\n    setHost(found);\n    if (!list || !found) return;\n    // Deliberately geometric rather than `offsetTop`: `offsetTop` is measured\n    // from the nearest POSITIONED ancestor, and the scrolling pane is not one —\n    // so it would report the distance to some outer frame and put every page at\n    // the wrong offset. This is the list's true start inside the scrolled\n    // content, which is the pane's own padding.\n    setScrollMargin(\n      list.getBoundingClientRect().top - found.getBoundingClientRect().top + found.scrollTop,\n    );\n  }, [listRef]);\n\n  const virtualizer = useVirtualizer({\n    count,\n    getScrollElement: () => host,\n    estimateSize,\n    overscan: 1,\n    scrollMargin,\n    measureElement: (element, entry, instance) => {\n      const measured =\n        entry?.borderBoxSize?.[0]?.blockSize ?? element.getBoundingClientRect().height;\n      // A hidden pane measures zero, and so does a layout-less environment.\n      // Recording that would collapse the page to nothing and — because the\n      // measurement is cached — leave it collapsed after the pane is shown\n      // again. Keeping the estimate is the same guard `useViewportSize` carries,\n      // for the same reason.\n      if (measured > 0) return measured;\n      const index = Number(element.getAttribute(\"data-index\"));\n      return Number.isNaN(index) ? 0 : instance.options.estimateSize(index);\n    },\n  });\n\n  const items = virtualizer.getVirtualItems();\n  const scrollOffset = virtualizer.scrollOffset ?? 0;\n\n  // The page under the viewport's top edge — the one a reader would name if you\n  // asked what page they are on.\n  const top = items.find((item) => item.start + item.size > scrollOffset + EDGE_SLACK);\n  const active = top ? top.index + 1 : 1;\n\n  // Where the reader is WITHIN that page, so a scale change can put them back.\n  // Recorded on every scroll rather than captured at the moment of the change:\n  // by then the measurements have already been reset.\n  const anchor = useRef({ index: 0, fraction: 0 });\n  useEffect(() => {\n    if (!top || top.size <= 0) return;\n    // Deliberately NOT clamped at the low end. At the very top of a document the\n    // reader is ABOVE page 1's start — the pane's own padding sits between them —\n    // and flooring that to 0 would scroll the padding away the first time the\n    // scale resolves, so simply opening a file nudges the view.\n    const fraction = (scrollOffset - top.start) / top.size;\n    anchor.current = { index: top.index, fraction: Math.min(fraction, 1) };\n  }, [top, scrollOffset]);\n\n  // ── The page number, in both directions ──────────────────────────────────\n  // Both start at 0 — a page number that cannot occur — so the FIRST value of\n  // `pageNumber` still counts as something the shell asked for. A shell that\n  // mounts already pointing at page 140 (a deep link, a citation restored from a\n  // URL) has made a request that nothing has honoured yet.\n  const reported = useRef(0);\n  const requested = useRef(0);\n\n  const lastActive = useRef(active);\n  useEffect(() => {\n    // Only a CHANGE in the page under the top edge is news. Reporting the\n    // initial value would answer the deep link above with \"you are on page 1\"\n    // before the scroll that honours it has even been attempted.\n    if (count === 0 || active === lastActive.current) return;\n    lastActive.current = active;\n    if (active === pageNumber) return;\n    reported.current = active;\n    goToPage(active);\n  }, [active, pageNumber, count, goToPage]);\n\n  useEffect(() => {\n    // `host` is resolved in an effect, so the first pass through here has\n    // nothing to scroll — and virtual-core silently drops a scroll with no\n    // element. Waiting for it is what makes the mount-time request land.\n    if (!host || count === 0 || requested.current === pageNumber) return;\n    requested.current = pageNumber;\n    // Our own report coming back around. Scrolling here would fight the gesture\n    // that produced it.\n    if (pageNumber === reported.current || pageNumber === active) return;\n    virtualizer.scrollToIndex(pageNumber - 1, { align: \"start\" });\n  }, [host, pageNumber, active, count, virtualizer]);\n\n  // ── Re-anchor after a scale change ───────────────────────────────────────\n  const lastSizeKey = useRef(sizeKey);\n  useLayoutEffect(() => {\n    if (lastSizeKey.current === sizeKey) return;\n    lastSizeKey.current = sizeKey;\n    if (count === 0) return;\n\n    // Measured heights describe the OLD scale, so keeping them would place every\n    // page at the wrong offset until it happened to be re-measured.\n    virtualizer.measure();\n\n    const { index, fraction } = anchor.current;\n    // At the very top there is no reading position to preserve, and scrolling to\n    // page 1's own start would scroll the pane's top padding away — so simply\n    // opening a file and letting its fit resolve would nudge the view.\n    if (index === 0 && fraction <= 0) return;\n    const start = virtualizer.getOffsetForIndex(index, \"start\")?.[0];\n    if (start === undefined) return;\n    const size = virtualizer.measurementsCache[index]?.size ?? 0;\n    virtualizer.scrollToOffset(start + fraction * size, { align: \"start\" });\n  }, [sizeKey, count, virtualizer]);\n\n  return virtualizer;\n}\n","/**\n * Finding the element a renderer actually scrolls inside.\n *\n * `FileViewerContent` is THE scroll boundary (`viewer-components.md`), and now\n * that page and zoom chrome lives in the shell (ADR 0026) even the PDF adapter\n * no longer has fixed controls of its own to justify a second viewport. But a\n * renderer still has to MEASURE that box — a fit-to-width scale is a function of\n * the viewport's width, and a virtualized page list is a function of its height.\n *\n * Resolved from the DOM rather than passed as a prop because a renderer may be\n * mounted anywhere: inside the shell, inside a consumer's own frame, or bare in\n * a test. Same shape as extend-hq/ui's `resolveScrollAreaViewport`.\n */\n\n/** The `data-slot` the shell's scrolling pane carries. */\nexport const SCROLL_HOST_SELECTOR = '[data-slot=\"file-viewer-content\"]';\n\n/**\n * The nearest scrolling ancestor of `node`.\n *\n * Prefers the shell's pane by its stable `data-slot`; falls back to the first\n * ancestor whose computed overflow actually scrolls, so a renderer composed into\n * someone else's frame still measures the right box. `null` when nothing\n * scrolls — the caller should then fall back to its own element.\n */\nexport function findScrollHost(node: Element | null | undefined): HTMLElement | null {\n  if (!node) return null;\n  const shell = node.closest<HTMLElement>(SCROLL_HOST_SELECTOR);\n  if (shell) return shell;\n\n  const view = node.ownerDocument?.defaultView;\n  if (!view) return null;\n  let current = node.parentElement;\n  while (current) {\n    const { overflowY, overflowX } = view.getComputedStyle(current);\n    if (/(auto|scroll|overlay)/.test(overflowY) || /(auto|scroll|overlay)/.test(overflowX)) {\n      return current;\n    }\n    current = current.parentElement;\n  }\n  return null;\n}\n","\"use client\";\n\n/**\n * The size of the box a renderer scrolls inside, kept current.\n *\n * Needed because a fit-to-width scale is a function of the VIEWPORT, not of the\n * document: only the renderer can compute it, and only by measuring. Measures\n * the container rather than the window (`window.innerWidth` would be wrong the\n * moment a viewer sits in a resizable pane, a dialog or a split workspace).\n */\n\nimport { useEffect, useState, type RefObject } from \"react\";\n\nimport { findScrollHost } from \"./scroll-host\";\n\nexport interface ViewportSize {\n  width: number;\n  height: number;\n}\n\n/**\n * @param ref An element inside the scrolling box — typically the renderer's root.\n * @returns The scroll host's content size, or `undefined` until it is measured.\n */\nexport function useViewportSize(ref: RefObject<HTMLElement | null>): ViewportSize | undefined {\n  const [size, setSize] = useState<ViewportSize>();\n\n  useEffect(() => {\n    const host = findScrollHost(ref.current) ?? ref.current?.parentElement ?? ref.current;\n    if (!host || typeof ResizeObserver === \"undefined\") return;\n\n    const measure = () => {\n      const { clientWidth: width, clientHeight: height } = host;\n      // A hidden pane measures zero. Re-fitting to a zero-width viewport would\n      // rasterize a zero-width page and clear the canvas — and nothing would\n      // measure again when the pane is shown, because its size did not change\n      // from the observer's point of view. Ignoring the reading keeps the last\n      // good one. (The guard extend-hq/ui's `useElementWidth` carries too.)\n      if (width === 0 || height === 0) return;\n      setSize((current) =>\n        current && Math.abs(current.width - width) < 1 && Math.abs(current.height - height) < 1\n          ? current\n          : { width, height },\n      );\n    };\n\n    measure();\n    const observer = new ResizeObserver(measure);\n    observer.observe(host);\n    return () => observer.disconnect();\n  }, [ref]);\n\n  return size;\n}\n"],"mappings":"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","names":["useState","useState","useEffect","useState","useState","useEffect"]}

package/dist/chunk-5OMONA2G.js

@@ -0,0 +1,87 @@
+"use client";
+import {
+  PROTOCOL_VERSION
+} from "./chunk-AORNMH77.js";
+
+// src/adapters/code/code-language.ts
+var LANGUAGE_BY_EXTENSION = {
+  bash: "shellscript",
+  c: "c",
+  cc: "cpp",
+  cjs: "javascript",
+  cpp: "cpp",
+  cs: "csharp",
+  css: "css",
+  cts: "typescript",
+  dart: "dart",
+  diff: "diff",
+  dockerfile: "docker",
+  go: "go",
+  gql: "graphql",
+  graphql: "graphql",
+  groovy: "groovy",
+  h: "c",
+  hcl: "hcl",
+  hpp: "cpp",
+  htm: "html",
+  html: "html",
+  ini: "ini",
+  java: "java",
+  js: "javascript",
+  jsx: "jsx",
+  kt: "kotlin",
+  kts: "kotlin",
+  less: "less",
+  lua: "lua",
+  makefile: "make",
+  mjs: "javascript",
+  mts: "typescript",
+  patch: "diff",
+  php: "php",
+  pl: "perl",
+  proto: "proto",
+  ps1: "powershell",
+  py: "python",
+  r: "r",
+  rb: "ruby",
+  rs: "rust",
+  sass: "sass",
+  scala: "scala",
+  scss: "scss",
+  sh: "shellscript",
+  sql: "sql",
+  svelte: "svelte",
+  swift: "swift",
+  tf: "terraform",
+  toml: "toml",
+  ts: "typescript",
+  tsx: "tsx",
+  vue: "vue",
+  xml: "xml",
+  yaml: "yaml",
+  yml: "yaml",
+  zsh: "shellscript"
+};
+var CODE_EXTENSIONS = Object.keys(LANGUAGE_BY_EXTENSION);
+function languageFor(fileName) {
+  const name = fileName.toLowerCase();
+  const dot = name.lastIndexOf(".");
+  const extension = dot > 0 ? name.slice(dot + 1) : name;
+  const map = LANGUAGE_BY_EXTENSION;
+  return map[extension] ?? map[name];
+}
+
+// src/adapters/code/code-manifest.ts
+var codeManifest = {
+  id: "code",
+  protocol: PROTOCOL_VERSION,
+  extensions: CODE_EXTENSIONS,
+  capabilities: { text: true, search: true, highlight: ["quote", "range"] },
+  requires: ["shiki"]
+};
+
+export {
+  languageFor,
+  codeManifest
+};
+//# sourceMappingURL=chunk-5OMONA2G.js.map

package/dist/chunk-5OMONA2G.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/adapters/code/code-language.ts","../src/adapters/code/code-manifest.ts"],"sourcesContent":["/**\n * Extension → Shiki language id.\n *\n * A pure data module on purpose: `code-manifest.ts` derives the extensions it\n * claims from this map, so the list the registry matches on and the list the\n * highlighter can actually tokenize can never drift apart. Adding a language is\n * one line here.\n *\n * What is deliberately ABSENT is as load-bearing as what is present. `json`,\n * `csv`, `md` and `svg` are claimed by their own adapters — a JSON file gets a\n * collapsible tree, not a coloured wall of text — and an extension listed in two\n * manifests would be decided by registration order rather than by design.\n */\n\nimport type { BundledLanguage } from \"shiki\";\n\n/**\n * Shiki's own language ids.\n *\n * `satisfies Record<string, BundledLanguage>` is the point of the annotation: a\n * typo'd grammar name fails typecheck HERE, rather than at runtime as a file\n * that silently refuses to highlight. Type-only import, so this stays a pure\n * data module with no edge to the engine.\n */\nconst LANGUAGE_BY_EXTENSION = {\n  bash: \"shellscript\",\n  c: \"c\",\n  cc: \"cpp\",\n  cjs: \"javascript\",\n  cpp: \"cpp\",\n  cs: \"csharp\",\n  css: \"css\",\n  cts: \"typescript\",\n  dart: \"dart\",\n  diff: \"diff\",\n  dockerfile: \"docker\",\n  go: \"go\",\n  gql: \"graphql\",\n  graphql: \"graphql\",\n  groovy: \"groovy\",\n  h: \"c\",\n  hcl: \"hcl\",\n  hpp: \"cpp\",\n  htm: \"html\",\n  html: \"html\",\n  ini: \"ini\",\n  java: \"java\",\n  js: \"javascript\",\n  jsx: \"jsx\",\n  kt: \"kotlin\",\n  kts: \"kotlin\",\n  less: \"less\",\n  lua: \"lua\",\n  makefile: \"make\",\n  mjs: \"javascript\",\n  mts: \"typescript\",\n  patch: \"diff\",\n  php: \"php\",\n  pl: \"perl\",\n  proto: \"proto\",\n  ps1: \"powershell\",\n  py: \"python\",\n  r: \"r\",\n  rb: \"ruby\",\n  rs: \"rust\",\n  sass: \"sass\",\n  scala: \"scala\",\n  scss: \"scss\",\n  sh: \"shellscript\",\n  sql: \"sql\",\n  svelte: \"svelte\",\n  swift: \"swift\",\n  tf: \"terraform\",\n  toml: \"toml\",\n  ts: \"typescript\",\n  tsx: \"tsx\",\n  vue: \"vue\",\n  xml: \"xml\",\n  yaml: \"yaml\",\n  yml: \"yaml\",\n  zsh: \"shellscript\",\n} as const satisfies Record<string, BundledLanguage>;\n\n/** Every extension the code adapter claims, lowercase and without the dot. */\nexport const CODE_EXTENSIONS = Object.keys(LANGUAGE_BY_EXTENSION);\n\n/**\n * The Shiki language for a file name, or `undefined` when nothing matches.\n *\n * Matches the extension first, then the whole (lowercased) file name — that is\n * what catches `Dockerfile` and `Makefile`, which carry their language in the\n * name and have no extension at all.\n */\nexport function languageFor(fileName: string): BundledLanguage | undefined {\n  const name = fileName.toLowerCase();\n  const dot = name.lastIndexOf(\".\");\n  const extension = dot > 0 ? name.slice(dot + 1) : name;\n  const map: Record<string, BundledLanguage> = LANGUAGE_BY_EXTENSION;\n  return map[extension] ?? map[name];\n}\n","import type { AdapterManifest } from \"../../core/types\";\nimport { PROTOCOL_VERSION } from \"../../core/types\";\nimport { CODE_EXTENSIONS } from \"./code-language\";\n\n/**\n * Eager, data-only (see `image-manifest.ts`).\n *\n * Claims EXTENSIONS only — never the `code` category. That is what keeps the\n * plain-text adapter as the backstop: a `.log`, a `.env` or an unknown\n * extension still opens as text instead of failing to find a grammar, and a\n * consumer who never installs Shiki loses highlighting rather than the file.\n */\nexport const codeManifest: AdapterManifest = {\n  id: \"code\",\n  protocol: PROTOCOL_VERSION,\n  extensions: CODE_EXTENSIONS,\n  capabilities: { text: true, search: true, highlight: [\"quote\", \"range\"] },\n  requires: [\"shiki\"],\n};\n"],"mappings":";;;;;;AAwBA,IAAM,wBAAwB;AAAA,EAC5B,MAAM;AAAA,EACN,GAAG;AAAA,EACH,IAAI;AAAA,EACJ,KAAK;AAAA,EACL,KAAK;AAAA,EACL,IAAI;AAAA,EACJ,KAAK;AAAA,EACL,KAAK;AAAA,EACL,MAAM;AAAA,EACN,MAAM;AAAA,EACN,YAAY;AAAA,EACZ,IAAI;AAAA,EACJ,KAAK;AAAA,EACL,SAAS;AAAA,EACT,QAAQ;AAAA,EACR,GAAG;AAAA,EACH,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AAAA,EACL,MAAM;AAAA,EACN,KAAK;AAAA,EACL,MAAM;AAAA,EACN,IAAI;AAAA,EACJ,KAAK;AAAA,EACL,IAAI;AAAA,EACJ,KAAK;AAAA,EACL,MAAM;AAAA,EACN,KAAK;AAAA,EACL,UAAU;AAAA,EACV,KAAK;AAAA,EACL,KAAK;AAAA,EACL,OAAO;AAAA,EACP,KAAK;AAAA,EACL,IAAI;AAAA,EACJ,OAAO;AAAA,EACP,KAAK;AAAA,EACL,IAAI;AAAA,EACJ,GAAG;AAAA,EACH,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,MAAM;AAAA,EACN,OAAO;AAAA,EACP,MAAM;AAAA,EACN,IAAI;AAAA,EACJ,KAAK;AAAA,EACL,QAAQ;AAAA,EACR,OAAO;AAAA,EACP,IAAI;AAAA,EACJ,MAAM;AAAA,EACN,IAAI;AAAA,EACJ,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AAAA,EACL,MAAM;AAAA,EACN,KAAK;AAAA,EACL,KAAK;AACP;AAGO,IAAM,kBAAkB,OAAO,KAAK,qBAAqB;AASzD,SAAS,YAAY,UAA+C;AACzE,QAAM,OAAO,SAAS,YAAY;AAClC,QAAM,MAAM,KAAK,YAAY,GAAG;AAChC,QAAM,YAAY,MAAM,IAAI,KAAK,MAAM,MAAM,CAAC,IAAI;AAClD,QAAM,MAAuC;AAC7C,SAAO,IAAI,SAAS,KAAK,IAAI,IAAI;AACnC;;;ACvFO,IAAM,eAAgC;AAAA,EAC3C,IAAI;AAAA,EACJ,UAAU;AAAA,EACV,YAAY;AAAA,EACZ,cAAc,EAAE,MAAM,MAAM,QAAQ,MAAM,WAAW,CAAC,SAAS,OAAO,EAAE;AAAA,EACxE,UAAU,CAAC,OAAO;AACpB;","names":[]}

package/dist/chunk-AORNMH77.js

@@ -0,0 +1,58 @@
+"use client";
+
+// src/core/types.ts
+var PROTOCOL_VERSION = 1;
+
+// src/core/errors.ts
+var ViewerError = class extends Error {
+  code;
+  fileName;
+  packages;
+  constructor(code, message, options = {}) {
+    super(message, { cause: options.cause });
+    this.name = "ViewerError";
+    this.code = code;
+    this.fileName = options.fileName;
+    this.packages = options.packages;
+  }
+};
+function isViewerError(value) {
+  return value instanceof ViewerError || value instanceof Error && value.name === "ViewerError";
+}
+function isAbort(value) {
+  if (isViewerError(value)) return value.code === "aborted";
+  return value instanceof Error && (value.name === "AbortError" || value.name === "TimeoutError");
+}
+function toViewerError(value, fallbackCode, options = {}) {
+  if (isViewerError(value)) return value;
+  if (isAbort(value)) {
+    return new ViewerError("aborted", "The file load was cancelled.", { ...options, cause: value });
+  }
+  const message = value instanceof Error ? value.message : String(value);
+  return new ViewerError(fallbackCode, message, { ...options, cause: value });
+}
+function isModuleNotFound(value) {
+  if (!(value instanceof Error)) return false;
+  if ("code" in value && value.code === "ERR_MODULE_NOT_FOUND") return true;
+  return /cannot find module|failed to resolve|dynamically imported module|module not found/i.test(
+    value.message
+  );
+}
+function parserMissingError(adapterId, packages, options = {}) {
+  return new ViewerError(
+    "parser-missing",
+    packages.length > 0 ? `The "${adapterId}" adapter needs ${packages.join(", ")}, which is not installed.` : `The "${adapterId}" adapter could not be loaded.`,
+    { ...options, packages }
+  );
+}
+
+export {
+  PROTOCOL_VERSION,
+  ViewerError,
+  isViewerError,
+  isAbort,
+  toViewerError,
+  isModuleNotFound,
+  parserMissingError
+};
+//# sourceMappingURL=chunk-AORNMH77.js.map

package/dist/chunk-AORNMH77.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/types.ts","../src/core/errors.ts"],"sourcesContent":["/**\n * The adapter protocol — what a format plugin declares, what it produces, and\n * what renders it.\n *\n * ## The two halves, and why they are split\n *\n * A registry entry is an eager {@link AdapterManifest} plus a lazy loader. The\n * manifest is plain data available the moment the registry is created, so the\n * chrome can decide which controls to show and whether a file is openable at all\n * **without downloading a parser**. The loader is a `() => import(…)` that pulls\n * the parser AND its renderer together, only once a file of that kind is opened.\n *\n * ## Adapters emit DATA, not HTML (ADR 0024 §3)\n *\n * An adapter's `load()` returns an {@link AdapterDocument} — a model — and ships\n * a `Renderer` that draws it with brand-ui components. No adapter returns an\n * HTML string, so no adapter can smuggle a colour, a font or a border past the\n * token layer. This is the single decision that keeps the viewer themeable.\n */\n\nimport type {\n  DocumentAddressKind,\n  FileCategory,\n  ProseHeadingLevel,\n  ResolvedFileSource,\n} from \"@elabs-ai/components-ui\";\nimport type { ComponentType } from \"react\";\n\nimport type { ResolvedHighlight } from \"./highlight\";\nimport type { TextIndex } from \"./text-index\";\n\n/**\n * The adapter protocol version. Bumped only when the shapes below change in a\n * way an existing adapter would not survive; an adapter declaring a different\n * version is rejected with a named error rather than crashing at render.\n */\nexport const PROTOCOL_VERSION = 1;\n\n/**\n * A quarter-turn clockwise rotation applied to the whole document.\n *\n * Document-level, not per-page: turning one page of a scan and leaving the rest\n * is an AUTHORING act (it changes the file), and this package reads files.\n */\nexport type DocumentRotation = 0 | 90 | 180 | 270;\n\n/** Scale the content to a dimension of the viewport instead of to a fixed number. */\nexport type ZoomFit = \"fit-width\" | \"fit-page\";\n\n/** One page's size at scale 1, in CSS pixels. */\nexport interface PageSize {\n  width: number;\n  height: number;\n}\n\n/**\n * What the chrome asks a renderer to draw at.\n *\n * A fit mode is a REQUEST, not a scale: only the renderer knows how wide its own\n * viewport is and how big the page is, so it resolves the request and reports the\n * number back through {@link AdapterRendererProps.onZoomResolved}. Resolving it\n * in the provider would mean the shell measuring a box it does not own.\n */\nexport type ZoomLevel = number | ZoomFit;\n\n/** What the chrome may offer for a format, known before any parser is fetched. */\nexport interface AdapterCapabilities {\n  /** The document is paginated — show the pager. */\n  pages?: boolean;\n  /** The rendered content can be scaled — show the zoom control. */\n  zoom?: boolean;\n  /** The rendered content can be rotated. */\n  rotate?: boolean;\n  /**\n   * The document exposes text that can be searched.\n   *\n   * An OVERRIDE, not the source of truth: the shell offers find-in-document\n   * whenever a format has both a text projection and a text-based\n   * {@link AdapterCapabilities.highlight} kind, and reads this only when an\n   * adapter says otherwise. Left as the source of truth it would deny the find\n   * box to PDF — the format readers most expect it on — purely because that\n   * manifest predates the feature and never declared the flag.\n   *\n   * It overrides in the OFF direction only, so a declared `true` is inert: it\n   * cannot grant find to a format with no text or no range-painting renderer,\n   * because the box would then have nothing to show for a match.\n   */\n  search?: boolean;\n  /**\n   * Which {@link DocumentAddress} kinds this adapter's `Renderer` can actually\n   * paint. Absent means none.\n   *\n   * On the EAGER manifest on purpose: an app can decide whether to show a\n   * \"jump to the cited passage\" affordance before it downloads pdf.js.\n   *\n   * It is a promise the renderer has to keep — `pnpm viewer-highlight:check`\n   * fails a manifest that declares a kind its adapter never exercises.\n   */\n  highlight?: readonly DocumentAddressKind[];\n  /** The document has an outline/table of contents for the sidebar. */\n  outline?: boolean;\n  /** The document can produce page thumbnails for the sidebar. */\n  thumbnails?: boolean;\n  /** A plain-text projection exists — enables the raw/source toggle and copy. */\n  text?: boolean;\n}\n\n/**\n * What an adapter can open. At least one of `extensions` / `mediaTypes` /\n * `categories` must be present, or nothing will ever route to it.\n */\nexport interface AdapterManifest {\n  /**\n   * Stable identity and the OVERRIDE key: registering a different loader under\n   * an existing id replaces it, which is how a consumer swaps a built-in.\n   */\n  id: string;\n  /** Must equal {@link PROTOCOL_VERSION}. */\n  protocol: number;\n  /**\n   * Tie-break when several adapters claim the same file. Built-ins are `0`;\n   * register above it to win, below it to act only as a fallback.\n   */\n  priority?: number;\n  /** Extensions claimed, lowercase and without the dot. The most specific match. */\n  extensions?: string[];\n  /** MIME types claimed. A trailing slash makes it a prefix (`\"image/\"`). */\n  mediaTypes?: string[];\n  /** Coarse categories claimed. The broadest match — a catch-all fallback. */\n  categories?: FileCategory[];\n  /** Which chrome controls apply. Absent keys are `false`. */\n  capabilities?: AdapterCapabilities;\n  /**\n   * Optional peer packages this adapter dynamically imports. Purely\n   * informational to the registry — it is what the \"install this to open that\"\n   * message names when the import fails to resolve.\n   */\n  requires?: string[];\n}\n\n/**\n * An adapter's parsed output. Adapters EXTEND this with their own payload; the\n * fields here are the parts the shell itself understands, so it can drive the\n * pager, the search box and the raw toggle without knowing the format.\n */\nexport interface AdapterDocument {\n  /** Adapter-defined discriminant, matched by that adapter's own `Renderer`. */\n  readonly kind: string;\n  /** Page count for a paginated document. Omit for single-surface formats. */\n  readonly pageCount?: number;\n  /**\n   * Each page's size at scale 1, in document order.\n   *\n   * What lets a continuously-scrolling renderer reserve the right height for a\n   * page it has not drawn yet, so the scrollbar means something from the first\n   * frame instead of growing as pages arrive. May be SHORTER than\n   * {@link AdapterDocument.pageCount} — measuring 900 pages up front costs 900\n   * round-trips to a worker, so an adapter is free to describe the pages it\n   * already touched and let the renderer assume the rest match.\n   */\n  readonly pageSizes?: readonly PageSize[];\n  /** Plain-text projection, when the format has one. Powers search, copy and the raw view. */\n  readonly text?: string;\n  /**\n   * Whether {@link AdapterDocument.text} is CAPPED rather than complete.\n   *\n   * Changes what \"we couldn't find that passage\" means: absent from the whole\n   * document, or simply past the part we previewed. Those deserve different\n   * sentences, and only the adapter knows which one is true.\n   */\n  readonly textTruncated?: boolean;\n  /**\n   * The map from {@link AdapterDocument.text} back into this adapter's own\n   * model, so a character range can become a block, a page or a cell.\n   *\n   * The `ref` type is the adapter's business — its own `Renderer` is the only\n   * thing that reads it, which is why it is `unknown` here.\n   */\n  readonly textIndex?: TextIndex<unknown>;\n}\n\n/** Everything an adapter is given while loading a document. */\nexport interface AdapterLoadContext {\n  /** Cancels the load — always honour it; a stale parse must not win a race. */\n  signal?: AbortSignal;\n  /** Report determinate progress in `0..1` where the format allows it. */\n  onProgress?: (fraction: number) => void;\n}\n\n/** A parser instance. One per document — adapters may hold per-document state. */\nexport interface FileAdapter {\n  load(source: ResolvedFileSource, context: AdapterLoadContext): Promise<AdapterDocument>;\n  /** Release anything the document holds (workers, object URLs, decoded buffers). */\n  dispose?(): void;\n}\n\n/** Props every adapter `Renderer` receives. */\nexport interface AdapterRendererProps {\n  /** The value this adapter's own `load()` returned — narrow it by `kind`. */\n  document: AdapterDocument;\n  /** The source, for identity, `alt` text and download actions. */\n  source: ResolvedFileSource;\n  className?: string;\n  /**\n   * The heading rung a document's own top-level heading renders at.\n   *\n   * A viewed file carries its OWN heading tree, and that tree has to be\n   * relative to the page hosting it: a README's `#` inside an app that already\n   * has an `<h1>` would otherwise put two `h1`s in a screen reader's flat\n   * heading list. `FileViewerContent` passes the provider's value; an adapter\n   * that renders headings offsets by it (`clampHeadingLevel(own + base - 1)`),\n   * and one that renders none ignores it. Same seam as\n   * `@elabs-ai/components-ai`'s `MarkdownView baseHeadingLevel`.\n   *\n   * Optional, so adding it is not a `PROTOCOL_VERSION` change.\n   */\n  baseHeadingLevel?: ProseHeadingLevel;\n  /**\n   * The parts of the document to mark, already located — citations from the\n   * app and the viewer's own find-in-document matches, in document order.\n   *\n   * The shell has done LOCATE (a quote is now a character range); the renderer\n   * does MAP and PAINT, because only it knows that offsets 812–847 are the\n   * second half of block 14. An adapter renders only the entries whose `status`\n   * is `\"resolved\"` and whose `address.kind` it declared, and ignores the rest\n   * — the shell is what tells the reader about a miss.\n   *\n   * Optional, so adding it is not a `PROTOCOL_VERSION` change.\n   */\n  highlights?: readonly ResolvedHighlight[];\n  /**\n   * Which highlight the viewer is pointed at. The renderer scrolls it into\n   * view, pages to it if the format paginates, and draws it distinctly.\n   *\n   * Also present as `active` on the entry itself; this is the shortcut for a\n   * renderer that only needs to know whether anything changed.\n   */\n  activeHighlightId?: string | null;\n  /**\n   * Which page the reader is on, 1-based — the provider's, not the renderer's.\n   *\n   * Page, zoom and rotation are PROVIDER state (ADR 0026) so a control can live\n   * anywhere: the shell's own toolbar, an app's page header, a deep link. While\n   * these were `useState` inside each renderer nothing outside the canvas could\n   * read or drive them.\n   *\n   * Uncontrolled when absent — a renderer used outside a `FileViewerProvider`\n   * keeps its own page, so it still works standalone. Optional, so adding it is\n   * not a `PROTOCOL_VERSION` change.\n   */\n  pageNumber?: number;\n  /**\n   * Report a page the RENDERER navigated to on its own — turning to a cited\n   * page, or (once pages scroll continuously) the page scrolled into view. The\n   * provider is what keeps the pager's number honest.\n   */\n  onPageChange?: (page: number) => void;\n  /** The scale, or a fit mode to resolve. Absent means the renderer's own default. */\n  zoom?: ZoomLevel;\n  /**\n   * Report the scale a {@link ZoomFit} actually resolved to.\n   *\n   * Only a renderer knows this — it is the one measuring its viewport. Without\n   * it the chrome cannot show a percentage for a fitted page, and the reader's\n   * next \"zoom in\" would step from the last fixed stop rather than from what is\n   * on screen. A renderer that never resolves a fit mode never calls it.\n   */\n  onZoomResolved?: (scale: number) => void;\n  /** Quarter-turns clockwise. Ignored by renderers whose manifest omits `rotate`. */\n  rotation?: DocumentRotation;\n}\n\n/**\n * What an adapter module exports. `manifest` is re-declared here so the registry\n * can verify the loaded module is the one the eager manifest promised.\n */\nexport interface AdapterModule {\n  manifest: AdapterManifest;\n  /** Fresh instance per document — never a shared singleton. */\n  create(): FileAdapter;\n  Renderer: ComponentType<AdapterRendererProps>;\n}\n\n/** A lazy adapter loader. Always `() => import(\"…\")` so nothing heavy is eager. */\nexport type AdapterLoader = () => Promise<AdapterModule | { default: AdapterModule }>;\n","/**\n * Typed failures, so the UI can decide what to SHOW without string-matching a\n * message.\n *\n * The `message` on these errors is developer-facing — it goes to the console and\n * to bug reports. Everything the user reads is looked up from {@link ViewerErrorCode}\n * through `t()` (ADR 0017), which is why the code, not the prose, is the contract.\n */\n\n/** Why a file could not be shown. */\nexport type ViewerErrorCode =\n  /** No registered adapter claims this file. */\n  | \"unsupported-format\"\n  /** An adapter was built against a different registry protocol. */\n  | \"protocol-mismatch\"\n  /** The adapter exists but its optional peer dependency is not installed. */\n  | \"parser-missing\"\n  /** The bytes could not be obtained (network, permissions, a revoked blob). */\n  | \"read-failed\"\n  /** The bytes arrived but the parser rejected them. */\n  | \"parse-failed\"\n  /** The load was cancelled — a new source, or an unmounted view. */\n  | \"aborted\";\n\nexport interface ViewerErrorOptions extends ErrorOptions {\n  /** The file this is about, for the developer-facing message. */\n  fileName?: string;\n  /** For `parser-missing`: the packages a consumer has to install. */\n  packages?: string[];\n}\n\n/** A failure a `FileViewer` can render, carrying a machine-readable {@link ViewerErrorCode}. */\nexport class ViewerError extends Error {\n  readonly code: ViewerErrorCode;\n  readonly fileName?: string;\n  readonly packages?: string[];\n\n  constructor(code: ViewerErrorCode, message: string, options: ViewerErrorOptions = {}) {\n    super(message, { cause: options.cause });\n    this.name = \"ViewerError\";\n    this.code = code;\n    this.fileName = options.fileName;\n    this.packages = options.packages;\n  }\n}\n\n/** True for a {@link ViewerError}, without relying on `instanceof` across bundles. */\nexport function isViewerError(value: unknown): value is ViewerError {\n  return value instanceof ViewerError || (value instanceof Error && value.name === \"ViewerError\");\n}\n\n/** True when the failure is a cancellation rather than something to report. */\nexport function isAbort(value: unknown): boolean {\n  if (isViewerError(value)) return value.code === \"aborted\";\n  return value instanceof Error && (value.name === \"AbortError\" || value.name === \"TimeoutError\");\n}\n\n/**\n * Wrap an unknown throw as a {@link ViewerError}, preserving an existing one and\n * mapping an abort to the `aborted` code so callers do not report cancellations\n * as failures.\n */\nexport function toViewerError(\n  value: unknown,\n  fallbackCode: ViewerErrorCode,\n  options: ViewerErrorOptions = {},\n): ViewerError {\n  if (isViewerError(value)) return value;\n  if (isAbort(value)) {\n    return new ViewerError(\"aborted\", \"The file load was cancelled.\", { ...options, cause: value });\n  }\n  const message = value instanceof Error ? value.message : String(value);\n  return new ViewerError(fallbackCode, message, { ...options, cause: value });\n}\n\n/**\n * A dynamic `import()` of an OPTIONAL peer that is not installed.\n *\n * Bundlers and Node report this differently (`ERR_MODULE_NOT_FOUND`,\n * `Cannot find module`, `Failed to resolve module specifier`, Vite's\n * `Failed to fetch dynamically imported module`), so match on the shapes rather\n * than one runtime's wording. A false positive here is cheap — the user is told\n * to install a package instead of seeing a raw parse error — and a false\n * negative is the anyview failure mode this exists to avoid: an unhelpful\n * module-resolution stack trace where a \"install papaparse to open CSV files\"\n * message belongs.\n */\nexport function isModuleNotFound(value: unknown): boolean {\n  if (!(value instanceof Error)) return false;\n  if (\"code\" in value && value.code === \"ERR_MODULE_NOT_FOUND\") return true;\n  return /cannot find module|failed to resolve|dynamically imported module|module not found/i.test(\n    value.message,\n  );\n}\n\n/**\n * The `parser-missing` error, worded the same wherever the peer turns out to be\n * absent.\n *\n * There are TWO such places, which is why this is a function and not a literal\n * at one call site. The registry catches it when the adapter MODULE cannot be\n * fetched; `FileViewerProvider` catches it when the module loaded fine and the\n * adapter's own `await import(\"mammoth\")` — inside `load()`, where every parser\n * engine is actually reached — rejects. Without the second, a consumer who\n * skipped an optional peer was told their file was damaged and offered a retry\n * that could never work.\n */\nexport function parserMissingError(\n  adapterId: string,\n  packages: string[],\n  options: ViewerErrorOptions = {},\n): ViewerError {\n  return new ViewerError(\n    \"parser-missing\",\n    packages.length > 0\n      ? `The \"${adapterId}\" adapter needs ${packages.join(\", \")}, which is not installed.`\n      : `The \"${adapterId}\" adapter could not be loaded.`,\n    { ...options, packages },\n  );\n}\n"],"mappings":";;;AAoCO,IAAM,mBAAmB;;;ACJzB,IAAM,cAAN,cAA0B,MAAM;AAAA,EAC5B;AAAA,EACA;AAAA,EACA;AAAA,EAET,YAAY,MAAuB,SAAiB,UAA8B,CAAC,GAAG;AACpF,UAAM,SAAS,EAAE,OAAO,QAAQ,MAAM,CAAC;AACvC,SAAK,OAAO;AACZ,SAAK,OAAO;AACZ,SAAK,WAAW,QAAQ;AACxB,SAAK,WAAW,QAAQ;AAAA,EAC1B;AACF;AAGO,SAAS,cAAc,OAAsC;AAClE,SAAO,iBAAiB,eAAgB,iBAAiB,SAAS,MAAM,SAAS;AACnF;AAGO,SAAS,QAAQ,OAAyB;AAC/C,MAAI,cAAc,KAAK,EAAG,QAAO,MAAM,SAAS;AAChD,SAAO,iBAAiB,UAAU,MAAM,SAAS,gBAAgB,MAAM,SAAS;AAClF;AAOO,SAAS,cACd,OACA,cACA,UAA8B,CAAC,GAClB;AACb,MAAI,cAAc,KAAK,EAAG,QAAO;AACjC,MAAI,QAAQ,KAAK,GAAG;AAClB,WAAO,IAAI,YAAY,WAAW,gCAAgC,EAAE,GAAG,SAAS,OAAO,MAAM,CAAC;AAAA,EAChG;AACA,QAAM,UAAU,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AACrE,SAAO,IAAI,YAAY,cAAc,SAAS,EAAE,GAAG,SAAS,OAAO,MAAM,CAAC;AAC5E;AAcO,SAAS,iBAAiB,OAAyB;AACxD,MAAI,EAAE,iBAAiB,OAAQ,QAAO;AACtC,MAAI,UAAU,SAAS,MAAM,SAAS,uBAAwB,QAAO;AACrE,SAAO,qFAAqF;AAAA,IAC1F,MAAM;AAAA,EACR;AACF;AAcO,SAAS,mBACd,WACA,UACA,UAA8B,CAAC,GAClB;AACb,SAAO,IAAI;AAAA,IACT;AAAA,IACA,SAAS,SAAS,IACd,QAAQ,SAAS,mBAAmB,SAAS,KAAK,IAAI,CAAC,8BACvD,QAAQ,SAAS;AAAA,IACrB,EAAE,GAAG,SAAS,SAAS;AAAA,EACzB;AACF;","names":[]}

package/dist/chunk-BCF3RWRL.js

@@ -0,0 +1,18 @@
+"use client";
+import {
+  PROTOCOL_VERSION
+} from "./chunk-AORNMH77.js";
+
+// src/adapters/json/json-manifest.ts
+var jsonManifest = {
+  id: "json",
+  protocol: PROTOCOL_VERSION,
+  extensions: ["json"],
+  mediaTypes: ["application/json"],
+  capabilities: { text: true, search: true }
+};
+
+export {
+  jsonManifest
+};
+//# sourceMappingURL=chunk-BCF3RWRL.js.map

package/dist/chunk-BCF3RWRL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/adapters/json/json-manifest.ts"],"sourcesContent":["import type { AdapterManifest } from \"../../core/types\";\nimport { PROTOCOL_VERSION } from \"../../core/types\";\n\n/** Eager, data-only (see `image-manifest.ts`). */\nexport const jsonManifest: AdapterManifest = {\n  id: \"json\",\n  protocol: PROTOCOL_VERSION,\n  extensions: [\"json\"],\n  mediaTypes: [\"application/json\"],\n  capabilities: { text: true, search: true },\n};\n"],"mappings":";;;;;;AAIO,IAAM,eAAgC;AAAA,EAC3C,IAAI;AAAA,EACJ,UAAU;AAAA,EACV,YAAY,CAAC,MAAM;AAAA,EACnB,YAAY,CAAC,kBAAkB;AAAA,EAC/B,cAAc,EAAE,MAAM,MAAM,QAAQ,KAAK;AAC3C;","names":[]}