@vedivad/typst-web-service 0.15.4 → 0.17.1

package/dist/index.d.ts

@@ -1,540 +1,258 @@
-/** LSP Position (0-based line and character). */
-interface LspPosition {
-    line: number;
-    character: number;
-}
-/** LSP Range. */
-interface LspRange {
-    start: LspPosition;
-    end: LspPosition;
-}
-/** LSP Diagnostic as returned by tinymist. */
-interface LspDiagnostic {
-    range: LspRange;
-    severity?: number;
-    message: string;
-    source?: string;
-}
-/** LSP MarkupContent (markdown or plaintext). */
-interface LspMarkupContent {
-    kind: "markdown" | "plaintext";
-    value: string;
-}
-/** LSP CompletionItem (subset actually populated by tinymist). */
-interface LspCompletionItem {
-    label: string;
-    kind?: number;
-    detail?: string;
-    documentation?: string | LspMarkupContent;
-    insertText?: string;
-    /** LSP InsertTextFormat: 1 = PlainText, 2 = Snippet (TextMate syntax). */
-    insertTextFormat?: number;
-    filterText?: string;
-    sortText?: string;
-    textEdit?: {
-        range: LspRange;
-        newText: string;
-    };
-}
-/** LSP CompletionList. */
-interface LspCompletionList {
-    isIncomplete: boolean;
-    items: LspCompletionItem[];
+/** UTF-16 string offset (CodeMirror position) -> UTF-8 byte offset (typsten). */
+declare function cmOffsetToByte(text: string, offset: number): number;
+/** UTF-8 byte offset (typsten) -> UTF-16 string offset (CodeMirror position). */
+declare function byteToCmOffset(text: string, byte: number): number;
+
+/**
+ * Project file paths. `/main.typ` form, leading slash, forward slashes only.
+ * `@preview/...` package paths bypass this (they are pushed to the VFS verbatim).
+ */
+/** `/path/to/file.typ`, leading-slash, forward slashes only. */
+type Path = string;
+/** Ensure a path starts with a leading slash. Idempotent. */
+declare function normalizePath(path: string): Path;
+
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * A highlighted source span: a half-open byte range and its CSS class.
+ */
+interface HlSpan {
+    from: number;
+    to: number;
+    /**
+     * Typst\'s own stable highlight class, e.g. `typ-key`, `typ-func`, `typ-str`
+     * (see `Tag::css_class`). The editor uses it verbatim as the decoration class.
+     */
+    tag: string;
 }
-/** Response shape for `textDocument/completion`. */
-type LspCompletionResponse = LspCompletionList | LspCompletionItem[] | null;
-/** LSP Hover contents — legacy and current forms tinymist may emit. */
-type LspHoverContents = string | LspMarkupContent | (string | {
-    language: string;
+
+/**
+ * A hover tooltip.
+ */
+interface Hover {
+    kind: HoverKind;
     value: string;
-})[];
-/** Response shape for `textDocument/hover`. */
-interface LspHover {
-    contents: LspHoverContents;
-    range?: LspRange;
 }
 
-interface TypstAnalyzerOptions {
-    /**
-     * Explicit Worker instance. When omitted, an inlined blob worker is created automatically.
-     * Use this for Vite apps:
-     *   `await TypstAnalyzer.create({ worker: new Worker(new URL('typst-web-service/analyzer-worker', import.meta.url), { type: 'module' }) })`
-     */
-    worker?: Worker;
+/**
+ * A single compiler diagnostic, ready for an editor.
+ */
+interface Diagnostic {
+    severity: Severity;
+    message: string;
+    hints: string[];
     /**
-     * URL to the tinymist WASM binary.
-     * Required — there is no default CDN URL for tinymist-web.
+     * `None` when the span is detached or cannot be resolved.
      */
-    wasmUrl: string;
+    location: Location | undefined;
 }
+
 /**
- * Manages a tinymist language server in a Web Worker. Provides LSP-based
- * completion and hover for Typst documents.
- *
- *   const analyzer = await TypstAnalyzer.create({ wasmUrl: '...' });
+ * A single completion candidate.
  */
-declare class TypstAnalyzer {
-    private readonly proxy;
-    private readonly worker;
-    private versionCounter;
-    /**
-     * Last content pushed to the worker per URI. Presence is the source of
-     * truth for "is this URI opened on the worker?"; value drives own-RPC dedup.
-     */
-    private readonly content;
-    private constructor();
-    static create(options: TypstAnalyzerOptions): Promise<TypstAnalyzer>;
-    didOpen(uri: string, content: string): Promise<void>;
-    didClose(uri: string): Promise<void>;
-    /**
-     * Notify the analyzer that a document has changed. Skips the RPC when the
-     * content matches what the worker last saw.
-     */
-    didChange(uri: string, content: string): Promise<void>;
-    /**
-     * Batch document changes. Splits inputs into opens (first-time URIs) and
-     * changes (already-open URIs) and sends them in a single worker roundtrip.
-     * Skips unchanged documents; returns without an RPC if nothing is pending.
-     */
-    didChangeMany(docs: Record<string, string>): Promise<void>;
-    /**
-     * Batch document closes. Filters to currently-open URIs and sends the set
-     * in a single worker roundtrip.
-     */
-    didCloseMany(uris: string[]): Promise<void>;
+interface Completion {
+    kind: CompletionKind;
+    label: string;
     /**
-     * Request completion at `position` for `uri`, with `content` as the current
-     * document state. Bundles the didChange notification with the request in one
-     * worker roundtrip; degrades to a plain completion request when the worker
-     * already has this exact content.
+     * Insertion text, possibly with snippet placeholders like `${body}`.
+     * Falls back to `label` when `None`.
      */
-    completion(uri: string, content: string, position: LspPosition): Promise<LspCompletionResponse>;
+    apply: string | undefined;
+    detail: string | undefined;
+}
+
+/**
+ * The completions at a cursor, plus where the replacement starts.
+ */
+interface CompletionResponse {
     /**
-     * Request hover at `position` for `uri`, with `content` as the current
-     * document state. Bundles the didChange notification with the request in one
-     * worker roundtrip; degrades to a plain hover request when the worker
-     * already has this exact content.
+     * Byte offset where the replacement begins; the editor replaces `from..cursor`.
      */
-    hover(uri: string, content: string, position: LspPosition): Promise<LspHover | null>;
-    destroy(): void;
+    from: number;
+    completions: Completion[];
 }
 
 /**
- * Two addressing schemes live in this codebase. This file is the only place
- * that knows how they relate. Keeping the vocabulary and conversions colocated
- * means a new contributor can read one file and understand the model.
- *
- * 1. Path          — "/main.typ". Always leading-slash, always forward slashes.
- *                    Used by the compiler VFS, the `TypstProject` public API,
- *                    and the `typstFilePath` facet. Addresses a file within
- *                    the project.
- *
- * 2. AnalyzerUri   — "untitled:project/main.typ". What tinymist's LSP expects.
- *                    Derived from a Path plus the analyzer URI root.
- *
- * The types below are type aliases, not branded/opaque types. That's
- * deliberate: callers can pass string literals where a Path is expected
- * without wrapping, and the aliases only serve as self-documenting
- * signatures. Ingress points still need to call `normalizePath` to defend
- * against un-normalized input — the alias does not imply the string has
- * been normalized.
+ * The kind of thing a completion inserts.
  */
-/** `/path/to/file.typ` — leading-slash, forward slashes only. */
-type Path = string;
-/** `untitled:project/path/to/file.typ` — what tinymist's LSP consumes. */
-type AnalyzerUri = string;
-/** Ensure a path starts with a leading slash. Idempotent. */
-declare function normalizePath(path: string): Path;
+type CompletionKind = "syntax" | "func" | "type" | "param" | "constant" | "path" | "package" | "label" | "font" | "symbol";
+
 /**
- * Normalize an analyzer URI root. Ensures leading slash, strips trailing
- * slashes. Special-cases "/" → "" so URIs don't end up with a leading
- * `untitled://`.
+ * The outcome of a compile: one `PageInfo` per renderable page plus all
+ * diagnostics. `compile()` does NOT render, pages are drawn on demand via
+ * `render_page`/`render_pages`. Diagnostics are DATA, not errors (the editor
+ * needs them on success as warnings and on failure as errors), so this is never
+ * a `Result` and never throws. On a failed compile the `pages` describe the
+ * last successful document (the last-good preview is kept), so the presence of
+ * an error diagnostic means `pages` is stale.
  */
-declare function normalizeRoot(rootPath: string): string;
+interface CompileResult {
+    pages: PageInfo[];
+    diagnostics: Diagnostic[];
+}
+
 /**
- * Build the analyzer URI for a given project path. `root` is expected to
- * already be normalized (see `normalizeRoot`).
- *
- *   pathToAnalyzerUri("/main.typ", "/project") -> "untitled:project/main.typ"
+ * The width and height of a rendered page, in points.
  */
-declare function pathToAnalyzerUri(path: Path, root: string): AnalyzerUri;
-
-/** Source range for a diagnostic. All values are 0-indexed. */
-interface DiagnosticRange {
-    startLine: number;
-    startCol: number;
-    endLine: number;
-    endCol: number;
-}
-interface DiagnosticMessage {
-    package: string;
-    path: string;
-    severity: "Error" | "Warning" | "Info";
-    range: DiagnosticRange;
-    message: string;
+interface PageInfo {
+    width: number;
+    height: number;
 }
 
-interface CompileResult {
-    diagnostics: DiagnosticMessage[];
-    /** Vector artifact bytes from the compiler, usable with TypstRenderer for SVG rendering. */
-    vector?: Uint8Array;
-}
-interface TypstCompilerOptions {
-    /**
-     * Explicit Worker instance. When omitted, an inlined blob worker is created automatically.
-     * Use this for Vite apps to get proper source maps:
-     *   `await TypstCompiler.create({ worker: new Worker(new URL('typst-web-service/compiler-worker', import.meta.url)) })`
-     */
-    worker?: Worker;
-    /**
-     * URL to the typst-ts-web-compiler WASM binary.
-     * Defaults to the matching version on jsDelivr CDN.
-     * Override with a local asset URL for offline support or faster load:
-     *   `new URL('@myriaddreamin/typst-ts-web-compiler/pkg/typst_ts_web_compiler_bg.wasm', import.meta.url).href`
-     */
-    wasmUrl?: string;
-    /** Font URLs to load into the Typst compiler. Defaults to Roboto from jsDelivr. */
-    fonts?: string[];
-    /**
-     * Enable fetching @preview/ packages from packages.typst.org on demand.
-     * Default: true.
-     */
-    packages?: boolean;
-}
 /**
- * Manages a Typst compiler worker. Create one instance and share it across
- * all extensions (linter, autocomplete, preview, etc.).
+ * Where a diagnostic points, when its span resolves to a real location.
  *
- *   await TypstCompiler.create()                                   // blob worker, defaults
- *   await TypstCompiler.create({ wasmUrl: '...' })                 // blob worker, custom WASM
- *   await TypstCompiler.create({ worker: myWorker })               // explicit Worker (Vite)
- *   await TypstCompiler.create({ worker: myWorker, fonts: [...] }) // explicit Worker + options
+ * Offsets are UTF-8 byte indices (Typst-native); `line`/`column` are 1-based
+ * (editor convention). Note these are code-point based; exact UTF-16 mapping
+ * for JS editors is a later refinement.
  */
-declare class TypstCompiler {
-    private readonly proxy;
-    private readonly worker;
-    private readonly encoder;
-    /** Last text content pushed per path. Drives own-RPC dedup. Invalidated by binary writes. */
-    private readonly content;
-    private constructor();
-    static create(options?: TypstCompilerOptions): Promise<TypstCompiler>;
-    /**
-     * Compile whatever is currently in the VFS (populated via
-     * setText/setBinary/setJson/setMany). Defaults to compiling "/main.typ";
-     * override with `entry`.
-     */
-    compile(entry?: string): Promise<CompileResult>;
-    /**
-     * Compile to PDF. Operates on whatever is currently in the VFS (populated
-     * via setText/setBinary/setJson/setMany). Defaults to compiling "/main.typ";
-     * override with `entry`.
-     */
-    compilePdf(entry?: string): Promise<Uint8Array>;
-    /**
-     * Add or overwrite a text file in the virtual compiler filesystem. Skips
-     * the worker RPC when `source` matches the last value pushed for `path`.
-     */
-    setText(path: string, source: string): Promise<void>;
-    /** Add or overwrite a JSON file in the virtual compiler filesystem. */
-    setJson(path: string, value: unknown, replacer?: (this: unknown, key: string, value: unknown) => unknown, space?: string | number): Promise<void>;
-    /**
-     * Add or overwrite multiple files in the virtual compiler filesystem in a
-     * single worker roundtrip. Strings are UTF-8 encoded; Uint8Arrays are
-     * passed through. Text entries unchanged since their last push are skipped;
-     * binary entries always push and invalidate the text cache for their path.
-     */
-    setMany(files: Record<string, string | Uint8Array>): Promise<void>;
-    /** Add or overwrite a binary file in the virtual compiler filesystem. */
-    setBinary(path: string, content: ArrayBuffer | ArrayBufferView): Promise<void>;
-    /** Remove a file from the virtual compiler filesystem. */
-    remove(path: string): Promise<void>;
-    /** Clear all virtual files from the compiler filesystem. */
-    clear(): Promise<void>;
-    destroy(): void;
-}
-
-interface FormatConfig {
-    /** Number of spaces per indentation level. Default: 2 */
-    tab_spaces?: number;
-    /** Maximum line width. Default: 80 */
-    max_width?: number;
-    /** Maximum consecutive blank lines allowed. */
-    blank_lines_upper_bound?: number;
-    /** Collapse consecutive whitespace in markup to a single space. */
-    collapse_markup_spaces?: boolean;
-    /** Sort import items alphabetically. */
-    reorder_import_items?: boolean;
-    /** Wrap text in markup to fit within max_width. Implies collapse_markup_spaces. */
-    wrap_text?: boolean;
-}
-interface FormatRangeResult {
-    /** Start index (UTF-16) of the actual formatted range. */
+interface Location {
+    file: string;
     start: number;
-    /** End index (UTF-16) of the actual formatted range. */
     end: number;
-    /** The formatted text for the range. */
-    text: string;
+    line: number;
+    column: number;
 }
+
 /**
- * Typst code formatter powered by typstyle.
- *
- * Runs on the main thread — typstyle is lightweight and fast.
- * The WASM module is loaded lazily on first format call.
- * Requires a bundler that supports WASM imports (e.g. Vite, webpack).
- *
- *   const formatter = TypstFormatter.create({ tab_spaces: 2, max_width: 80 });
- *   const formatted = await formatter.format(source);
+ * Whether a diagnostic is a fatal error or a non-fatal warning.
  */
-declare class TypstFormatter {
-    private config;
-    private constructor();
-    static create(config?: FormatConfig): TypstFormatter;
-    /** Format an entire Typst source string. */
-    format(source: string): Promise<string>;
-    /** Format a range within a Typst source string. Indices are UTF-16 code units. */
-    formatRange(source: string, start: number, end: number): Promise<FormatRangeResult>;
+type Severity = "error" | "warning";
+
+/**
+ * Whether a hover tooltip is prose or Typst code.
+ */
+type HoverKind = "text" | "code";
+
+/** A rendered page: its index, dimensions (in points), and standalone SVG. */
+interface RenderedSvgPage {
+    index: number;
+    width: number;
+    height: number;
+    svg: string;
 }
 
-interface TypstProjectOptions {
-    compiler: TypstCompiler;
-    /**
-     * Optional analyzer. When provided, text file operations also sync with the
-     * analyzer so completions / hover reflect the current state.
-     */
-    analyzer?: TypstAnalyzer;
+interface TypstProjectCreateOptions {
     /** Default entry file path. Default: "/main.typ". */
     entry?: string;
-    /**
-     * Prefix used to build the `untitled:` URIs handed to the analyzer.
-     * Default: "/project". A path of `/main.typ` becomes
-     * `untitled:project/main.typ`. Only affects URI construction — the compiler
-     * and project VFS use the raw paths unchanged.
-     */
-    analyzerUriRoot?: string;
-    /**
-     * Scheduling for auto-compiles after VFS mutations. Mutations debounce by
-     * `debounceMs`; `maxWaitMs` caps how long the debounce can keep deferring
-     * during sustained edits so the user still sees progress.
-     */
+    /** Auto-compile scheduling after VFS mutations. */
     autoCompile?: AutoCompileOptions;
 }
 interface AutoCompileOptions {
-    /**
-     * Idle time (ms) after the last VFS mutation before a compile fires.
-     * Default: 0 — compile fires on the next macrotask. Set higher (e.g. 150) to
-     * coalesce rapid edits.
-     */
+    /** Idle time (ms) after the last mutation before a compile fires. Default: 0. */
     debounceMs?: number;
-    /**
-     * Maximum time (ms) the debounce is allowed to defer a compile during
-     * sustained mutation bursts. Default: 0 (no cap — pure debounce).
-     */
+    /** Max time (ms) the debounce may defer during sustained edits. Default: 0. */
     maxWaitMs?: number;
 }
+type CompileListener = (result: CompileResult) => void;
 /**
- * Coordinates a compiler + analyzer pair for multi-file Typst projects.
- *
- * Owns the project's virtual filesystem state. Editors push incremental
- * `setText` updates as the user types; the project mirrors those edits to
- * both the compiler's shadow VFS and the analyzer's open-document set, then
- * compiles or services LSP requests against the current state.
+ * Multi-file Typst project backed by a single typsten wasm worker. Owns the
+ * VFS; editors push `setText` edits as the user types; the project mirrors them
+ * to the worker, fetches `@preview` packages on demand, and compiles or renders
+ * against the current state.
  *
- *   const project = new TypstProject({ compiler, analyzer });
- *   await project.setMany({ "/main.typ": "...", "/utils.typ": "..." });
- *   const result = await project.compile();
+ *   const project = await TypstProject.create();
+ *   await project.setMany({ "/main.typ": "..." });
+ *   const { pages } = await project.compile();
+ *   const svg = await project.renderPage(0);
  */
-type CompileListener = (result: CompileResult) => void;
 declare class TypstProject {
-    private readonly compiler;
-    private readonly analyzer?;
-    private readonly analyzerUriRoot;
+    private readonly engine;
+    private readonly worker;
     /**
-     * Tracked text files: path → latest content observed. Presence in this map
-     * is the source of truth for "is this a tracked text file?"; insertion
-     * order drives the `files` getter. Per-sink dedup lives in the compiler and
-     * analyzer.
+     * Tracked project files: the text content for a text file, or `null` for a
+     * binary one. Drives dedup, `getText`, `files`, and `clear`. (Cached `@preview`
+     * package files live only in the worker VFS, never here.)
      */
-    private readonly contentByPath;
+    private readonly tracked;
     private readonly compileListeners;
     private readonly scheduler;
+    private readonly packageLoader;
     private compileVersion;
     private _lastResult;
     private _entry;
     private destroyed;
-    private invokeListener;
-    constructor(options: TypstProjectOptions);
+    private constructor();
+    /** Create a project: spin up the worker, init the wasm, set the entry. */
+    static create(options?: TypstProjectCreateOptions): Promise<TypstProject>;
+    private scheduleCompile;
     /**
-     * Schedule an auto-compile after VFS mutations. Coalesces rapid calls via
-     * the configured debounce/throttle. Errors surface through `onCompile`
-     * listeners via a synthetic diagnostic; callers awaiting a specific compile
-     * should call `compile()` directly.
+     * Mirror text into the VFS without scheduling a compile. Returns the in-flight
+     * write to await, or `null` if the content is unchanged (deduped to a no-op).
      */
-    private scheduleCompile;
-    /** Current entry file path. Assign to change the sticky entry used by subsequent `compile()` calls. */
+    private writeText;
+    /** Mirror binary bytes into the VFS (always writes; binaries are not deduped). */
+    private writeBinary;
     get entry(): Path;
     set entry(path: Path);
-    /** Whether an analyzer is attached. */
-    get hasAnalyzer(): boolean;
-    /**
-     * Most recent compile result, or `undefined` before the first compile has
-     * settled. Useful for lazy-mounted UI that subscribes after boot and needs
-     * an initial value.
-     */
+    /** Most recent compile result, or `undefined` before the first compile. */
     get lastResult(): CompileResult | undefined;
-    /**
-     * Snapshot of tracked text file paths, in insertion order. Updated by
-     * `setText`, `setMany`, `remove`, and `clear`. Returns a fresh array — mutate
-     * freely without affecting project state.
-     */
+    /** Tracked text file paths, in insertion order (fresh array). */
     get files(): Path[];
-    /**
-     * Current text content for a tracked file, or `undefined` if the path was
-     * never written via `setText`/`setMany` (or was removed). Read-through to the
-     * project's sync cache — lets consumers avoid shadowing the VFS themselves.
-     */
+    /** Current text for a tracked file, or `undefined` (binary or absent). */
     getText(path: Path): string | undefined;
-    /**
-     * Add or overwrite a text file. Goes to the compiler's VFS and, when an
-     * analyzer is attached, to the analyzer as a document change. No-op when
-     * the tracked path already has this exact content — skips both worker RPCs
-     * and the auto-scheduled compile.
-     */
+    /** Add or overwrite a text file. No-op if unchanged. */
     setText(path: Path, content: string): Promise<void>;
-    /**
-     * Add or overwrite a JSON file. The analyzer does not track data files, but
-     * if `path` was previously tracked as text the analyzer document is closed
-     * and the text entry retired so the three views stay consistent.
-     */
-    setJson(path: Path, value: unknown): Promise<void>;
-    /**
-     * Add or overwrite a binary file. If `path` was previously tracked as text,
-     * the analyzer document is closed and the text entry retired in the same
-     * call so the compiler / analyzer / project views stay consistent.
-     */
+    /** Add or overwrite a binary file (retires any text tracking for the path). */
     setBinary(path: Path, content: ArrayBuffer | ArrayBufferView): Promise<void>;
-    /**
-     * Batch set multiple files. Strings route to both compiler and analyzer;
-     * Uint8Array entries go to the compiler only. Strings matching the last
-     * tracked content for their path are skipped on both sinks. Binary entries
-     * always go through (no content cache, so no dedup).
-     */
+    /** Batch set files. Strings dedup against tracked content; binaries always write. */
     setMany(files: Record<Path, string | Uint8Array>): Promise<void>;
-    /**
-     * Remove a file. Always removed from the compiler's VFS; also closed on the
-     * analyzer when it was previously tracked as text.
-     */
+    /** Remove a file from the VFS. */
     remove(path: Path): Promise<void>;
-    /** Clear all files from both compiler VFS and analyzer document set. */
+    /** Remove all tracked project files (cached `@preview` packages are kept). */
     clear(): Promise<void>;
     /**
-     * Subscribe to compile results. Fires after every `compile()` whose result is
-     * still current (stale results from out-of-order concurrent compiles are
-     * dropped). If a compile has already settled, the most recent result is
-     * delivered synchronously so late-mounted listeners aren't stuck blank until
-     * the next compile. Returns an unsubscribe function.
+     * Register a font (TTF/OTF, or TTC collection bytes) so compilation can use
+     * it, then recompile. The engine bundles default body, math, and monospace
+     * fonts; use this to add families it does not ship (e.g. CJK or a custom
+     * font). Fonts persist for the project's lifetime.
+     */
+    addFont(bytes: Uint8Array): Promise<void>;
+    /**
+     * Subscribe to compile results. Late subscribers get `lastResult` synchronously.
+     * Returns an unsubscribe function.
      */
     onCompile(listener: CompileListener): () => void;
     /**
-     * Compile the current VFS state using the sticky entry. Errors from the
-     * underlying compiler are converted into a synthetic error diagnostic so
-     * callers and listeners always receive a `CompileResult`. Listeners are
-     * notified only for the most recent compile — results from an earlier call
-     * that resolves after a later one are suppressed.
-     *
-     * VFS mutations (`setText`, `remove`, etc.) auto-schedule a debounced
-     * compile; call this directly only when you need an awaitable handle on the
-     * result (e.g., to flush before rendering to PDF).
+     * Compile the current VFS state. Fetches any referenced `@preview` packages
+     * first. Errors become a synthetic diagnostic. Listeners fire only for the
+     * most recent compile (stale results are dropped).
      */
     compile(): Promise<CompileResult>;
-    /** Compile the current VFS state to PDF using the sticky entry. */
-    compilePdf(): Promise<Uint8Array>;
-    private requireAnalyzer;
+    /** Render a single page of the last compile to SVG, or `undefined`. */
+    renderPage(index: number): Promise<string | undefined>;
     /**
-     * Request completion for `path` at `position`, using `source` as the
-     * current document state. Pure analyzer query — neither the compiler VFS
-     * nor project tracking (`files`/`getText`) is touched. Throws when no
-     * analyzer is attached.
+     * Render pages `[start, end)` as `RenderedSvgPage`s (index + dims + svg),
+     * zipping the SVG strings with the page metadata from the last compile.
      */
-    completion(path: Path, source: string, position: LspPosition): Promise<LspCompletionResponse>;
+    renderedPages(start: number, end: number): Promise<RenderedSvgPage[]>;
     /**
-     * Request hover for `path` at `position`, using `source` as the current
-     * document state. Pure analyzer query — neither the compiler VFS nor
-     * project tracking is touched. Throws when no analyzer is attached.
+     * Export the last compile as a PDF, or `undefined` if nothing has compiled
+     * yet. The bytes are a fresh `Uint8Array` (copied across the worker boundary).
      */
-    hover(path: Path, source: string, position: LspPosition): Promise<LspHover | null>;
+    exportPdf(): Promise<Uint8Array | undefined>;
+    /** Completions at a CodeMirror `offset` in `path`, using `source` as the live buffer. */
+    completion(path: Path, source: string, offset: number, explicit?: boolean): Promise<CompletionResponse | undefined>;
+    /** Hover tooltip at a CodeMirror `offset` in `path`, using `source` as the live buffer. */
+    hover(path: Path, source: string, offset: number): Promise<Hover | undefined>;
+    /** Format `source` (the live buffer for `path`); returns the formatted text or `undefined`. */
+    format(path: Path, source: string): Promise<string | undefined>;
     /**
-     * Tear down the project and the services it owns. Destroys the attached
-     * compiler and analyzer, drops all listeners, and clears VFS tracking state.
-     * Idempotent — calling twice is a no-op. After destruction, further calls on
-     * the project are not supported; construct a new one.
-     *
-     * If you need to share a compiler or analyzer across projects, destroy them
-     * yourself and don't call this method — the project does not provide an
-     * ownership toggle.
+     * Syntax-highlight `source` over the CodeMirror window `[from, to)` (UTF-16
+     * offsets; defaults to the whole string). Returns spans whose `from`/`to` are
+     * CodeMirror offsets, ready to drive decorations. Stateless: the worker parses
+     * `source` directly via typst-syntax, so this neither reads nor mutates the
+     * VFS and works for any text (the live buffer, a hover code snippet).
      */
-    destroy(): void;
-}
-
-interface TypstRendererOptions {
+    highlight(source: string, from?: number, to?: number): Promise<HlSpan[]>;
     /**
-     * Explicit Worker instance. When omitted, an inlined blob worker is created
-     * automatically. Use this for Vite apps to get proper source maps:
-     *   `TypstRenderer.create({ worker: new Worker(new URL('typst-web-service/renderer-worker', import.meta.url)) })`
+     * Syntax-highlight `source` to nested `<span class="typ-*">` HTML for a static
+     * context (e.g. a hover tooltip). Stateless, like `highlight`.
      */
-    worker?: Worker;
-    /** URL to the typst-ts-renderer WASM binary. Defaults to jsDelivr CDN. */
-    wasmUrl?: string;
-}
-interface RenderedSvgPage {
-    /** Zero-based page index within the document. */
-    index: number;
-    /** Page width in typographic points. */
-    width: number;
-    /** Page height in typographic points. */
-    height: number;
-    /** Standalone SVG string for just this page. */
-    svg: string;
-}
-/**
- * Converts Typst vector artifacts to SVG strings, off the main thread.
- *
- * Wraps `@myriaddreamin/typst.ts`'s renderer hosted in a Web Worker — the
- * WASM init, vector → SVG conversion, and base64 image-embedding all happen
- * off-thread. Returned SVG strings cross via Comlink; page splitting runs on
- * the main thread (Workers don't have `DOMParser`).
- *
- *   const renderer = TypstRenderer.create();
- *   const svg = await renderer.renderSvg(vector);
- */
-declare class TypstRenderer {
-    #private;
-    private constructor();
-    static create(options?: TypstRendererOptions): TypstRenderer;
-    /** Terminate the worker. The instance is unusable afterwards. */
+    highlightHtml(source: string): Promise<string>;
+    /** Tear down the worker and drop all state. Idempotent. */
     destroy(): void;
-    /**
-     * Render a Typst vector artifact to a single merged SVG string.
-     *
-     * Ownership of `vector.buffer` transfers to the worker (zero-copy).
-     * Don't reuse the vector after passing it in — accessing its bytes from
-     * the main thread after this call is undefined behavior.
-     *
-     * Concurrent calls are serialized in the worker: while a render is in
-     * flight, the most recent `vector` becomes the next render and any
-     * intermediate calls are dropped. All overlapping callers share one
-     * returned promise that resolves with the LAST rendered SVG — your
-     * specific vector may have been superseded.
-     */
-    renderSvg(vector: Uint8Array): Promise<string>;
-    /**
-     * Render a Typst vector artifact into one self-contained SVG string per
-     * physical page. The merged SVG is split by `<g class="typst-page">`
-     * children; each group's `data-page-width` / `data-page-height` give the
-     * page-local viewBox. Shared `<defs>` / `<style>` are duplicated into each
-     * page so the output SVGs render independently. Returns an empty array if
-     * the document has no page groups.
-     */
-    renderSvgPages(vector: Uint8Array): Promise<RenderedSvgPage[]>;
 }
 
-export { type AnalyzerUri, type CompileResult, type DiagnosticMessage, type DiagnosticRange, type FormatConfig, type FormatRangeResult, type LspCompletionItem, type LspCompletionList, type LspCompletionResponse, type LspDiagnostic, type LspHover, type LspHoverContents, type LspMarkupContent, type LspPosition, type LspRange, type Path, type RenderedSvgPage, TypstAnalyzer, type TypstAnalyzerOptions, TypstCompiler, type TypstCompilerOptions, TypstFormatter, TypstProject, type TypstProjectOptions, TypstRenderer, type TypstRendererOptions, normalizePath, normalizeRoot, pathToAnalyzerUri };
+export { type AutoCompileOptions, type CompileListener, type CompileResult, type Completion, type CompletionKind, type CompletionResponse, type Diagnostic, type HlSpan, type Hover, type HoverKind, type Location, type PageInfo, type Path, type RenderedSvgPage, type Severity, TypstProject, type TypstProjectCreateOptions, byteToCmOffset, cmOffsetToByte, normalizePath };