@poco-ai/agentero-dsh-pdf 0.0.0-stage → 0.1.0

package/lib/client/bookmark.d.ts

@@ -0,0 +1,34 @@
+/**
+ * PDF outline (bookmark) helpers for the sidebar panel.
+ *
+ * The panel edits a local tree and hands it back to the parent through
+ * `onSave`, so these helpers only deal with the in-memory shape: converting
+ * the reader's `PdfBookmarkObject[]`, resolving a destination page, and
+ * updating / removing a node. Writing the outline back into the PDF belongs to
+ * the parent.
+ */
+import { type PdfBookmarkObject } from '@embedpdf/models';
+/** One outline node while it is being edited in the sidebar. */
+export type EditableBookmark = {
+    id: string;
+    /** Original tree path; null for a new bookmark. */
+    origin: string | null;
+    originalTitle?: string;
+    title: string;
+    /** Only set for a new / explicitly retargeted bookmark (zero-based). */
+    pageIndex?: number;
+    target?: PdfBookmarkObject['target'];
+    children: EditableBookmark[];
+};
+/**
+ * Resolve the zero-based page index a PDF bookmark points to.
+ * Supports direct destinations and GoTo action destinations.
+ * Returns null for bookmarks with no target or unsupported action types.
+ */
+export declare function bookmarkPageIndex(node: Pick<PdfBookmarkObject, 'target'>): number | null;
+/** Convert the reader's bookmark tree into editable nodes. */
+export declare function editableBookmarks(nodes: PdfBookmarkObject[], prefix?: string): EditableBookmark[];
+/** Replace one node (or drop it when `update` returns null). */
+export declare function updateBookmark(nodes: EditableBookmark[], id: string, update: (node: EditableBookmark) => EditableBookmark | null): EditableBookmark[];
+/** Remove one node but promote its children to its position. */
+export declare function removeBookmark(nodes: EditableBookmark[], id: string): EditableBookmark[];

package/lib/client/button.d.ts

@@ -0,0 +1,16 @@
+import { type VariantProps } from "class-variance-authority";
+import type * as React from "react";
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "outline" | "secondary" | "ghost" | "destructive" | "link" | null | undefined;
+    size?: "default" | "xs" | "sm" | "lg" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type ButtonProps = React.ComponentProps<"button"> & VariantProps<typeof buttonVariants> & {
+    asChild?: boolean;
+};
+/**
+ * `forwardRef` matters: Tooltip/Popover triggers clone the child with an anchor
+ * ref. A plain function component drops that ref, so the popper never measured
+ * the trigger and the content stayed parked offscreen.
+ */
+declare const Button: React.ForwardRefExoticComponent<Omit<ButtonProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { Button, buttonVariants };

package/lib/client/chat-actions.d.ts

@@ -0,0 +1,7 @@
+import type { Context } from '@deepseek-ai/cordis';
+type SessionId = Parameters<Context['sessions']['binding']>[0];
+/** Bind PDF actions to their own sidebar session, even after navigation. */
+export declare function pdfChatActions(ctx: Context, sessionId: SessionId): {
+    ask(text: string): Promise<void>;
+};
+export {};

package/lib/client/cn.d.ts

@@ -0,0 +1,3 @@
+import { type ClassValue } from 'clsx';
+/** Tailwind class joiner used by the copied reader chrome. */
+export declare function cn(...inputs: ClassValue[]): string;

package/lib/client/comment-cards.d.ts

@@ -0,0 +1,35 @@
+import type { PropsLocale } from "@deepseek-ai/dsh-client-ui-slots";
+type PdfT = PropsLocale<"agentero.pdf">["t"];
+type CommentRect = {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+};
+export type CommentMark = {
+    id: string;
+    kind: string;
+    note: string;
+    rects: CommentRect[];
+    space: "norm" | "pt";
+    /** Vault-relative PNG for a visual region mark. */
+    asset?: string;
+};
+type CommentCardsProps = {
+    marks: readonly CommentMark[];
+    /** Rendered page height in CSS px. */
+    pageHeight: number;
+    /** PDF page size at scale 1, used to normalize point-space rects. */
+    pageSize: {
+        width: number;
+        height: number;
+    };
+    t: PdfT;
+};
+/**
+ * One static card per current-page mark that has a note or a crop, pinned to
+ * the page's right edge. Chrome only: the in-place editor, crop tool, and
+ * action bar stay out.
+ */
+export declare function CommentCards({ marks, pageHeight, pageSize, t }: CommentCardsProps): import("react").JSX.Element | null;
+export {};

package/lib/client/embed-reader.d.ts

@@ -0,0 +1,48 @@
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import { type ReactNode } from 'react';
+import type { EditableBookmark } from './bookmark';
+import { type PdfPaperTone } from './page-theme';
+import type { PaintMark, PdfPageSize, PdfRect } from './pdf-panel';
+type PdfT = PropsLocale<'agentero.pdf'>['t'];
+export interface SelectionHit {
+    quote: string;
+    page: number;
+    /** Page-point rectangles from the live selection. */
+    rects: PdfRect[];
+    /** Page size at scale 1, for normalizing per-id mark anchors. */
+    pageWidth: number;
+    pageHeight: number;
+    screenX: number;
+    screenY: number;
+}
+interface EmbedReaderProps {
+    bytes: ArrayBuffer;
+    docId: string;
+    marks: readonly PaintMark[];
+    pdfTone: PdfPaperTone;
+    onSetPdfTone: (tone: PdfPaperTone) => void;
+    onSelect: (hit: SelectionHit) => void;
+    /** The live text selection went away; the floating menu must hide. */
+    onDeselect: () => void;
+    /** Persist the outline back into the PDF; resolves after the host wrote it. */
+    saveBookmarks: (nodes: EditableBookmark[]) => Promise<void>;
+    /** Translate one page's text through the host. */
+    translate: (text: string, signal?: AbortSignal) => Promise<string>;
+    loadLayout: (ref: string, signal?: AbortSignal) => Promise<unknown>;
+    /** Pinned translation chip, drawn inside the page so it scrolls with it. */
+    translatePin?: {
+        page: number;
+        rects: PdfRect[];
+        pageSize: PdfPageSize;
+        onOpen: (screen: {
+            x: number;
+            y: number;
+        }) => void;
+    };
+    menu: ReactNode;
+    /** Increment after a mark is saved so the blue selection does not cover it. */
+    selectionClearVersion: number;
+    t: PdfT;
+}
+export declare function EmbedReader(props: EmbedReaderProps): ReactNode;
+export {};

package/lib/client/engine.d.ts

@@ -0,0 +1,3 @@
+import { type PdfEngine } from '@embedpdf/models';
+/** One engine for the page. A failed start can be retried. */
+export declare function loadPdfEngine(): Promise<PdfEngine>;

package/lib/client/find.d.ts

@@ -0,0 +1,22 @@
+import type { ReactNode, RefObject } from 'react';
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+type PdfT = PropsLocale<'agentero.pdf'>['t'];
+/**
+ * In-document find (⌘F): the floating query bar, the debounced full-document
+ * search, and prev / next navigation that scrolls the focused hit into view.
+ *
+ * The bar lives inside the PDF host so the shortcut only opens it while the
+ * reader is hovered or focused; the hit highlights are rendered separately by
+ * {@link PdfSearchLayer} inside each page.
+ */
+export declare function PdfFindLayer({ docId, hostRef, t, }: {
+    docId: string;
+    hostRef: RefObject<HTMLDivElement | null>;
+    t: PdfT;
+}): ReactNode;
+/** Hit highlights for the current find query, one layer per rendered page. */
+export declare function PdfSearchLayer({ docId, pageIndex, }: {
+    docId: string;
+    pageIndex: number;
+}): ReactNode;
+export {};

package/lib/client/highlight-color-stack.d.ts

@@ -0,0 +1,24 @@
+import { type Ref } from "react";
+import type { PropsLocale } from "@deepseek-ai/dsh-client-ui-slots";
+import { type HighlightColor } from "./palette";
+export declare const HIGHLIGHT_COLOR_STACK_COLLAPSED_W: number;
+export declare const HIGHLIGHT_COLOR_STACK_EXPANDED_W: number;
+type PdfT = PropsLocale<"agentero.pdf">["t"];
+type HighlightColorStackProps = {
+    ref?: Ref<HTMLFieldSetElement>;
+    onSelect: (color: HighlightColor) => void;
+    /** Currently active color (annotation recolor menu). */
+    activeColor?: HighlightColor;
+    /** Tooltip / expand direction relative to the toolbar. */
+    tooltipSide?: "top" | "bottom";
+    className?: string;
+    t: PdfT;
+};
+/**
+ * Semi-overlapping highlight color dots. Hover / focus-within fans them out
+ * to the left (right edge stays anchored near the toolbar divider) with a
+ * compact spring. Only this slot's width animates — parents should pin the
+ * toolbar by its right edge so sibling actions do not move.
+ */
+export declare function HighlightColorStack({ ref, onSelect, activeColor, tooltipSide, className, t, }: HighlightColorStackProps): import("react").JSX.Element;
+export {};

package/lib/client/index.d.ts

@@ -0,0 +1,31 @@
+import type { Context } from '@deepseek-ai/cordis';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        /** Opener registry from the host browser plugin. */
+        agentero: {
+            registerOpener(kind: 'paper' | 'note', opener: (id: string) => void): () => void;
+            request(url: string, init?: RequestInit): Promise<Response>;
+            getVault(): Promise<{
+                scope: string;
+            }>;
+        };
+    }
+}
+declare module '@deepseek-ai/dsh-client-ui-sidebar-right/client' {
+    interface SidebarRightTabParamsMap {
+        /** Paper directory passed when the library opens this page. */
+        'agentero.pdf': {
+            readonly ref?: string;
+        };
+    }
+}
+/** Browser plugin name. */
+export declare const name = "agentero-pdf";
+/** Slot services, the opener registry, and the session's right sidebar. */
+export declare const inject: string[];
+/**
+ * Register the PDF page in the session's right sidebar and the paper opener.
+ * The library still calls `agentero.open`. This opener focuses the one PDF tab.
+ * @param ctx - Browser plugin context.
+ */
+export declare function apply(ctx: Context): void;

package/lib/client/link-layer.d.ts

@@ -0,0 +1,27 @@
+import type { PdfAnnotationObject, PdfLinkAnnoObject, PdfLinkTarget } from '@embedpdf/models';
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import { type ReactNode } from 'react';
+type PdfT = PropsLocale<'agentero.pdf'>['t'];
+export declare function isLinkObject(object: PdfAnnotationObject): object is PdfLinkAnnoObject;
+/**
+ * Extract the destination page + anchor position from a link target, if any.
+ * Coordinates are PDF-native (origin bottom-left). `pdfX` is null when the
+ * destination only pins a row (FitH) or the viewer does not expose x.
+ */
+export declare function getLinkDestination(target: PdfLinkTarget | undefined): {
+    pageIndex: number;
+    pdfX: number | null;
+    pdfY: number;
+} | null;
+/**
+ * Transparent hit targets over each link rect. Positioned in page-percentage
+ * units so they track zoom for free.
+ */
+export declare function PdfLinkLayer({ docId, pageIndex, pageWidth, pageHeight, t, }: {
+    docId: string;
+    pageIndex: number;
+    pageWidth: number;
+    pageHeight: number;
+    t: PdfT;
+}): ReactNode;
+export {};

package/lib/client/link-target.d.ts

@@ -0,0 +1,2 @@
+import type { PdfLinkTarget } from '@embedpdf/models';
+export declare function linkTargetUrl(target: PdfLinkTarget | undefined): string | null;

package/lib/client/locale.d.ts

@@ -0,0 +1,80 @@
+/** PDF panel copy, Chinese source. */
+export declare const zh: {
+    title: string;
+    empty: string;
+    loading: string;
+    loadFailed: string;
+    missing: string;
+    vaultMissing: string;
+    prev: string;
+    next: string;
+    page: string;
+    copy: string;
+    copied: string;
+    highlight: string;
+    comment: string;
+    translate: string;
+    ask: string;
+    menu: string;
+    commentHint: string;
+    askHint: string;
+    save: string;
+    send: string;
+    noSession: string;
+    markFailed: string;
+    asked: string;
+    askFailed: string;
+    askedMarkFailed: string;
+    translated: string;
+    goToPage: string;
+    zoom: string;
+    paperTone: string;
+    paperToneWhite: string;
+    paperToneDark: string;
+    colorGroup: string;
+    colorYellow: string;
+    colorGreen: string;
+    colorBlue: string;
+    colorPink: string;
+    colorPurple: string;
+    find: string;
+    findPlaceholder: string;
+    findNoResults: string;
+    findPrev: string;
+    findNext: string;
+    findClose: string;
+    linkAria: string;
+    outline: string;
+    outlineEmpty: string;
+    bookmarkAdd: string;
+    bookmarkTitle: string;
+    bookmarkApply: string;
+    bookmarkCancel: string;
+    bookmarkRename: string;
+    bookmarkDelete: string;
+    bookmarkSaving: string;
+    bookmarkFailed: string;
+    bookmarkPageTitle: string;
+    translatePage: string;
+    translateAll: string;
+    translating: string;
+    translation: string;
+    translationEmpty: string;
+    translationFailed: string;
+    translationRetry: string;
+    showOriginal: string;
+    translateFailed: string;
+    pin: string;
+    unpin: string;
+    close: string;
+};
+/** PDF panel copy, English. */
+export declare const en: {
+    [K in keyof typeof zh]: string;
+};
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** PDF panel copy. */
+        'agentero.pdf': keyof typeof zh;
+    }
+}

package/lib/client/outline.d.ts

@@ -0,0 +1,25 @@
+/**
+ * PDF outline (bookmarks) layer: the top-left toolbar chip that opens the
+ * outline panel, plus its inline-editable tree.
+ *
+ * The panel owns only its draft tree. Loading comes from the bookmark plugin
+ * capability and every add / rename / delete is persisted by the parent via
+ * `onSave`, which writes the outline back into the PDF.
+ */
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import { type ReactNode } from 'react';
+import { type EditableBookmark } from './bookmark';
+type PdfT = PropsLocale<'agentero.pdf'>['t'];
+type PdfOutlineLayerProps = {
+    docId: string;
+    /** One-based current page, used when adding a bookmark. */
+    currentPage: number;
+    /** One-based page navigation, handled by the parent's scroller. */
+    onGoToPage: (page: number) => void;
+    /** Persist the whole outline; the parent writes it back into the PDF. */
+    onSave: (nodes: EditableBookmark[]) => Promise<void>;
+    t: PdfT;
+};
+/** Top-left outline toggle + inline-editable outline panel. */
+export declare function PdfOutlineLayer({ docId, currentPage, onGoToPage, onSave, t, }: PdfOutlineLayerProps): ReactNode;
+export {};

package/lib/client/page-theme.d.ts

@@ -0,0 +1,36 @@
+/**
+ * PDF page paper tones and dark-mode raster styling.
+ *
+ * Page content has no color-scheme API, so paper colour is applied at the DOM
+ * layer over the pdf.js canvas.
+ *
+ * Only two paper tones exist: solid white and solid black. Black paper is a
+ * full invert so white raster areas land exactly on #000 and black text lands
+ * on #fff; hue-rotate keeps figure colors roughly correct. Partial inverts were
+ * dropped because they left the paper at an ambiguous grey.
+ */
+export type PdfPaperTone = "white" | "dark";
+/** Picker order: light first, black last. */
+export declare const PDF_PAPER_TONES: PdfPaperTone[];
+/** Page shell background, so loading/zoom gaps match the finished paper. */
+export declare const PDF_PAPER_SHELL_CLASS: Record<PdfPaperTone, string>;
+/** Swatch fill for the paper-tone picker. */
+export declare const PDF_PAPER_SWATCH_CLASS: Record<PdfPaperTone, string>;
+export declare function isPdfPaperTone(value: unknown): value is PdfPaperTone;
+/**
+ * Dark-mode page raster styling.
+ *
+ * Full invert: white paper becomes #000 and black ink becomes #fff, so the
+ * page reads as a solid black sheet instead of a grey wash. Hue-rotate keeps
+ * figure colors roughly correct.
+ */
+export declare const PDF_PAGE_RASTER_DARK_CLASS = "[filter:invert(1)_hue-rotate(180deg)]";
+/**
+ * Dark-mode annotation overlay styling.
+ *
+ * Highlight annotations keep their stored bright palette colors; in dark mode
+ * they sit on top of inverted black paper and can look glaring. A gentle
+ * brightness + saturation reduction keeps them readable without overwhelming
+ * the page.
+ */
+export declare const PDF_ANNOTATION_DARK_CLASS = "[filter:brightness(0.88)_saturate(0.85)]";

package/lib/client/palette.d.ts

@@ -0,0 +1,25 @@
+/** PDF annotation color palette (highlight fill + underline bar). */
+export type HighlightColor = "yellow" | "green" | "blue" | "pink" | "purple";
+export declare const HIGHLIGHT_COLORS: HighlightColor[];
+export declare const DEFAULT_HIGHLIGHT_COLOR: HighlightColor;
+/**
+ * Hex colors for highlight swatches. Kept in sync with the translucent fills
+ * below so the on-page highlight matches the swatch.
+ */
+export declare const HIGHLIGHT_HEX: Record<HighlightColor, string>;
+/** Default fill opacity for highlight annotations. */
+export declare const HIGHLIGHT_OPACITY = 0.4;
+/** Same fill the annotation layer paints, as an rgba string. */
+export declare function highlightFill(color: HighlightColor): string;
+/** Ordered hex list for color presets. */
+export declare const HIGHLIGHT_HEX_LIST: string[];
+/** Map a stored hex color back to the nearest known palette key. */
+export declare function highlightColorFromHex(hex: string | undefined): HighlightColor;
+/** Coerce an arbitrary stored color string to a known palette key. */
+export declare function normalizeHighlightColor(color: string | undefined): HighlightColor;
+/** Solid dot class for the color picker swatch. */
+export declare function swatchColorClass(color: HighlightColor): string;
+/** Border-color class matching a highlight color (e.g. quoted-text rule). */
+export declare function swatchBorderClass(color: HighlightColor): string;
+/** Hover/edit emphasis overlay color. */
+export declare function highlightHoverOverlayColor(color: HighlightColor): string;

package/lib/client/pan-drag.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Drag-to-pan (momentary hand tool) for the PDF viewport.
+ *
+ * Matches the common PDF-reader interaction: hold the middle button, or hold
+ * Space and use the left button, and the page follows the cursor 1:1 on both
+ * axes until the button is released.
+ *
+ * The gesture writes native `scrollLeft` / `scrollTop` on the viewport element;
+ * the plugin viewport already coalesces the resulting scroll events into
+ * EmbedPDF's per-frame scroll metrics, so tiling, fit modes and floating card
+ * anchors stay in sync without further work.
+ */
+export type PanDragState = "idle" | "panning";
+/** Scroll container the gesture drives; structural so it stays testable. */
+export type PanDragTarget = Pick<HTMLElement, "addEventListener" | "removeEventListener" | "setPointerCapture" | "releasePointerCapture" | "hasPointerCapture" | "scrollLeft" | "scrollTop">;
+type PanDragGestureOptions = {
+    target: PanDragTarget;
+    /** True while Space is held, arming left-button drag as well. */
+    isLeftDragArmed: () => boolean;
+    /** True for targets that must keep their own pointer behavior (editors). */
+    isExcludedTarget: (target: EventTarget | null) => boolean;
+    /** Cursor feedback; `"panning"` for the duration of a drag. */
+    onStateChange?: (state: PanDragState) => void;
+};
+export type PanDragBinding = {
+    /** End an in-flight drag (window lost focus) without detaching listeners. */
+    cancel(): void;
+    dispose(): void;
+};
+export declare function bindPanDragGesture({ target, isLeftDragArmed, isExcludedTarget, onStateChange, }: PanDragGestureOptions): PanDragBinding;
+export {};

package/lib/client/pan-handler.d.ts

@@ -0,0 +1,20 @@
+import { type RefObject } from "react";
+type PanDragHandlerProps = {
+    /** PDF host; Space is claimed with the same ownership rule as `⌘F`. */
+    hostRef: RefObject<HTMLDivElement | null>;
+};
+/**
+ * Momentary hand tool: middle-button drag always pans, and holding Space arms
+ * the left button to behave exactly the same.
+ *
+ * Space is a bare key with no modifier, so claiming it needs an ownership rule:
+ * the hovered viewer wins (focus usually sits on a tab or a neighbouring panel
+ * while reading), otherwise the viewer when focus is inside its host or still
+ * neutral on `body` after a page click. Editable and button-like targets always
+ * keep their native behavior. The pointer gesture is not gated on ownership at
+ * all — a drag starts on whatever viewport the pointer is actually on.
+ *
+ * Must render inside the plugin `<Viewport>` (ViewportElementContext).
+ */
+export declare function PanDragHandler({ hostRef }: PanDragHandlerProps): null;
+export {};

package/lib/client/pdf-bottom-bar.d.ts

@@ -0,0 +1,25 @@
+import type { PropsLocale } from "@deepseek-ai/dsh-client-ui-slots";
+import { type PdfPaperTone } from "./page-theme";
+type PdfT = PropsLocale<"agentero.pdf">["t"];
+type PdfBottomBarProps = {
+    /** Hidden until the document reports its page count. */
+    totalPages: number;
+    /** Editable page number (raw digits while typing). */
+    pageField: string;
+    onPageFieldChange: (value: string) => void;
+    /** True while the field owns focus, so scrolling does not clobber typing. */
+    pageFocusedRef: {
+        current: boolean;
+    };
+    onCommitPageField: () => void;
+    pdfTone: PdfPaperTone;
+    onSetPdfTone: (tone: PdfPaperTone) => void;
+    /** Current zoom scale (1 = 100% of the fit-to-width scale). */
+    zoomLevel: number;
+    /** Apply a zoom scale from the slider. */
+    onZoomChange: (zoom: number) => void;
+    t: PdfT;
+};
+/** Bottom bar: page field + zoom slider + PDF paper tone. */
+export declare const PdfBottomBar: import("react").MemoExoticComponent<({ totalPages, pageField, onPageFieldChange, pageFocusedRef, onCommitPageField, pdfTone, onSetPdfTone, zoomLevel, onZoomChange, t, }: PdfBottomBarProps) => import("react").JSX.Element | null>;
+export {};

package/lib/client/pdf-chrome-surface.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Shared PDF floating chrome surfaces (Apple-style materials).
+ *
+ * Small chips (toolbars / find / bottom bar) are lighter glass.
+ * Side panels are thicker (stronger blur + shadow).
+ * Selection cards stay near-opaque for long-form readability.
+ * Mark hosts with `data-pdf-chrome` so reduced-transparency can frost them.
+ */
+/** Compact HUD chips: top toolbars, bottom bar, find bar, page-edge tabs. */
+export declare const PDF_CHROME_CHIP = "border border-border/50 bg-background/80 shadow-sm ring-1 ring-black/5 backdrop-blur-md backdrop-saturate-150 supports-backdrop-blur:bg-background/60 dark:border-white/10 dark:ring-white/10";
+/** Auto-hide chrome: materialize (opacity + slight rise), not a plain fade. */
+export declare const PDF_CHROME_VIS = "transition-[opacity,transform] duration-200 ease-out motion-reduce:transition-opacity motion-reduce:duration-150";
+export declare const PDF_CHROME_VIS_SHOW = "translate-y-0 scale-100 opacity-100";
+export declare const PDF_CHROME_VIS_HIDE = "-translate-y-1 scale-[0.98] opacity-0 motion-reduce:translate-y-0 motion-reduce:scale-100";
+/**
+ * Left outline / references / figures panel.
+ * Heavier material than chips; enters from the left (spatial consistency).
+ */
+export declare const PDF_SIDE_PANEL = "absolute inset-y-0 left-0 z-20 w-80 select-none border-r border-border/50 bg-background/90 pt-11 pb-2 shadow-lg backdrop-blur-xl backdrop-saturate-150 supports-backdrop-blur:bg-background/75 motion-safe:animate-in motion-safe:fade-in-0 motion-safe:slide-in-from-left-2 motion-safe:duration-200 motion-reduce:animate-none";
+/** Icon-only selection menu — glassier than long-form cards. */
+export declare const PDF_SELECTION_MENU = "rounded-xl border border-border/50 bg-background/90 shadow-xl ring-1 ring-black/5 backdrop-blur-md backdrop-saturate-150 supports-backdrop-blur:bg-background/75 dark:ring-white/10";
+/** Ask / translate / preview cards — near-solid for dense text. */
+export declare const PDF_FLOAT_CARD = "rounded-xl border border-border/60 bg-background/95 text-foreground shadow-xl ring-1 ring-black/5 backdrop-blur-sm supports-backdrop-blur:bg-background/90 dark:ring-white/10";

package/lib/client/pdf-panel.d.ts

@@ -0,0 +1,66 @@
+import type { InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import { type ReactNode } from 'react';
+import type { EditableBookmark } from './bookmark';
+import { type HighlightColor } from './palette';
+export interface PaintRect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export interface PaintMark {
+    id: string;
+    kind: string;
+    page: number;
+    rects: PaintRect[];
+    space: 'norm' | 'pt';
+    note: string;
+    /** Highlight palette key, when the store carries one. */
+    color?: HighlightColor;
+    /** Host image URL tied to the source knowledge base. */
+    asset?: string;
+}
+/** Page rectangle in PDF points, the shape the selection plugin reports. */
+export interface PdfRect {
+    origin: {
+        x: number;
+        y: number;
+    };
+    size: {
+        width: number;
+        height: number;
+    };
+}
+export interface PdfPageSize {
+    width: number;
+    height: number;
+}
+export interface MarkAdd {
+    ref: string;
+    kind: 'highlight' | 'ask' | 'translate';
+    quote: string;
+    page: number;
+    /** Page-point selection rectangles; lets the host write without the CLI. */
+    rects?: PdfRect[];
+    pageSize?: PdfPageSize;
+    color?: HighlightColor;
+    comment?: string;
+    question?: string;
+}
+export interface PdfInjected {
+    loadPdf: (ref: string) => Promise<ArrayBuffer>;
+    loadMarks: (ref: string) => Promise<PaintMark[]>;
+    addMark: (body: MarkAdd) => Promise<string | undefined>;
+    /** Send a question and citation as a new conversation turn. */
+    ask: (text: string) => Promise<void>;
+    /** Write the PDF outline back to the file; resolves after the host saved it. */
+    saveBookmarks: (ref: string, nodes: EditableBookmark[]) => Promise<void>;
+    loadLayout: (ref: string, signal?: AbortSignal) => Promise<unknown>;
+    /** Translate one page's text; rejects with the host error message. */
+    translate: (text: string, signal?: AbortSignal) => Promise<string>;
+}
+type PdfPanelProps = PropsRuntime<'sidebar.right.pane.tab'> & InjectFace<PdfInjected> & PropsLocale<'agentero.pdf'>;
+export declare function paperRef(params: unknown): string;
+export declare function PdfTitle({ useTabInfo, t }: PropsRuntime<'sidebar.right.pane.tab.title'> & PropsLocale<'agentero.pdf'>): ReactNode;
+export declare function PdfPanel(props: PdfPanelProps): ReactNode;
+export {};

package/lib/client/pdf-toolbar.d.ts

@@ -0,0 +1,11 @@
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ReactNode } from 'react';
+type PdfT = PropsLocale<'agentero.pdf'>['t'];
+/** Top-right chrome: full-text translate. */
+export declare function PdfToolbar({ translating, translateOpen, onToggleTranslate, t, }: {
+    translating: boolean;
+    translateOpen: boolean;
+    onToggleTranslate: () => void;
+    t: PdfT;
+}): ReactNode;
+export {};

package/lib/client/popover.d.ts

@@ -0,0 +1,10 @@
+import { Popover as PopoverPrimitive } from "radix-ui";
+import type * as React from "react";
+declare function Popover({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Root>): React.JSX.Element;
+declare function PopoverTrigger({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Trigger>): React.JSX.Element;
+declare function PopoverContent({ className, align, sideOffset, ...props }: React.ComponentProps<typeof PopoverPrimitive.Content>): React.JSX.Element;
+declare function PopoverAnchor({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Anchor>): React.JSX.Element;
+declare function PopoverHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function PopoverTitle({ className, ...props }: React.ComponentProps<"h2">): React.JSX.Element;
+declare function PopoverDescription({ className, ...props }: React.ComponentProps<"p">): React.JSX.Element;
+export { Popover, PopoverAnchor, PopoverContent, PopoverDescription, PopoverHeader, PopoverTitle, PopoverTrigger, };