@dylanl1/dsh-plugin-pdf 0.1.2 → 0.1.3

package/dist/types/adapters/host/dsh/retrieval-prefetch.d.ts

@@ -0,0 +1,49 @@
+import type { OpenWorkingCopyDocument } from '../../../modules/working-copy/index.js';
+import type { RetrievalProgress } from '../../../modules/retrieval/index.js';
+export interface RetrievalPrefetchDocument extends Pick<OpenWorkingCopyDocument, 'sessionId' | 'id' | 'path' | 'contentVersion' | 'sourceDigest' | 'conflict'> {
+}
+export interface RetrievalPrefetchStatus {
+    revision: string;
+    state: 'idle' | 'running' | 'suspended' | 'disposed';
+    skippedDocuments: number;
+    failureCode?: string;
+    documents: Array<{
+        sessionId: string;
+        id: string;
+        contentVersion: string;
+        occurrence: number;
+        state: 'queued' | 'running' | 'ready' | 'failed' | 'cancelled';
+        progress?: RetrievalProgress;
+        failureCode?: string;
+    }>;
+}
+interface Ports {
+    /** Only real UI/model owners belong here; indexing leases are not owners. */
+    documents(): readonly RetrievalPrefetchDocument[];
+    /** A stable saved binding/registration identity, not mutable discovery metadata. */
+    selection(document: RetrievalPrefetchDocument): {
+        identity: string;
+        planId?: string;
+    } | undefined;
+    prepare(sessionId: string, input: {
+        documentId: string;
+        rebuild?: boolean;
+        indexPlanId?: string;
+    }, signal: AbortSignal, onProgress?: (progress: RetrievalProgress) => void): Promise<void>;
+    subscribe?(listener: () => void): () => void;
+    onChange?(status: RetrievalPrefetchStatus): void;
+    maxDocuments?: number;
+}
+/** One bounded, owner-aware background lane; foreground queries share the actual retrieval index. */
+export declare function createRetrievalPrefetch(ports: Ports): {
+    refresh: () => void;
+    status: () => RetrievalPrefetchStatus;
+    subscribe(listener: () => void): () => void;
+    start(sessionId: string, id: string): void;
+    rebuild(sessionId: string, id: string): void;
+    cancel(sessionId: string, id: string): void;
+    suspend(): Promise<void>;
+    resume(): void;
+    dispose(): Promise<void>;
+};
+export {};

package/dist/types/adapters/host/dsh/retrieval.d.ts

@@ -1,33 +1,152 @@
-import { type RetrievalCache, type RetrievalInput } from '../../../modules/retrieval/index.js';
+import { createRetrievalService, type RetrievalCache, type RetrievalInput, type RetrievalPrepareInput, type RetrievalProgress } from '../../../modules/retrieval/index.js';
 import { type AgentPageReadPort, type EvidenceReferenceStore } from '../../../modules/evidence/index.js';
 import type { WorkingCopyReadPort } from '../../../modules/working-copy/index.js';
 import { type EmbeddingRegistry } from '../../../embedding/index.js';
 import { type PdfSettings } from '../../../shared/contracts.js';
+import { type PdfPageContent } from './page-content.js';
 /** Host integration owns authorization snapshots and ref signing; retrieval owns only derived indexes. */
 export declare function createPdfRetrieval(workspaces: WorkingCopyReadPort, pages: AgentPageReadPort, references: EvidenceReferenceStore, options?: {
     cache?: RetrievalCache;
     embeddings?: EmbeddingRegistry;
     settings?: () => PdfSettings;
+    limits?: Parameters<typeof createRetrievalService>[0]['limits'];
+    content?: PdfPageContent;
+    /** Resolve the caller's session policy and re-read the actual source, including ready-cache hits. */
+    freshSource?(sessionId: string, documentId: string, signal: AbortSignal): Promise<void>;
     retain?: (sessionId: string, documentId: string, signal: AbortSignal) => Promise<() => void>;
 }): {
-    availability(_sessionId: string, signal: AbortSignal): Promise<{
+    availability: (_sessionId: string, signal: AbortSignal, _documentId?: string) => Promise<{
         status: "unavailable";
         reason: string;
     } | {
         status: "available";
-        reason?: undefined;
     }>;
+    prepare(sessionId: string, input: RetrievalPrepareInput, signal: AbortSignal, onProgress?: (progress: RetrievalProgress) => void): Promise<void>;
     search(sessionId: string, input: RetrievalInput, signal: AbortSignal): Promise<{
+        coverage: {
+            qualityWarningsOmitted?: {
+                warningTypes: number;
+                affectedPageCount: number;
+                candidatePages: number[];
+            } | undefined;
+            qualityWarnings: {
+                message: string;
+                affectedPageCount: number;
+                candidatePages: number[];
+                sampleOtherPages: number[];
+                omittedPageCount: number;
+            }[];
+            indexedPages: number;
+            totalPages: number;
+            noTextPages: number[];
+            ocrPages: number[];
+            imageDescriptionPages: number[];
+            failedPages: {
+                page: number;
+                attempts: number;
+                code: string;
+            }[];
+            embeddedChunks: number;
+            totalChunks: number;
+            visual: "not-indexed" | "image-descriptions";
+        };
         documentId: string;
         path: string;
         contentVersion: string;
         sourceDigest: string;
         sourceVersion: string;
         revision: number;
-        candidates: {
+        candidates: ({
             page: number;
             quote: string;
             score: number;
+            source: "ocr-text" | "image-description";
+            blockId: string;
+            annotationStatus: "unavailable";
+            evidence: {
+                refId: string;
+                documentId: string;
+                sourcePath: string;
+                sourceDigest: string;
+                sourceVersion: string;
+                contentVersion: string;
+                revision: number;
+                page: number;
+                renderedImageSha256: string;
+                locator: {
+                    kind: "page-only";
+                } | {
+                    kind: "pdf-region";
+                    rectPdf: [number, number, number, number];
+                };
+                limitations: string[];
+                source: "direct-image";
+                snapshot: {
+                    kind: "attachment";
+                    attachmentId: string;
+                    mediaType: "image/png" | "image/jpeg" | "image/webp" | "image/gif";
+                    bytes: number;
+                    width: number;
+                    height: number;
+                    storedImageSha256?: string | undefined;
+                };
+                precision: "page-only" | "approximate-geometry";
+            } | {
+                refId: string;
+                documentId: string;
+                sourcePath: string;
+                sourceDigest: string;
+                sourceVersion: string;
+                contentVersion: string;
+                revision: number;
+                page: number;
+                renderedImageSha256: string;
+                locator: {
+                    kind: "page-only";
+                } | {
+                    kind: "pdf-region";
+                    rectPdf: [number, number, number, number];
+                };
+                limitations: string[];
+                source: "ocr-text";
+                snapshot: {
+                    kind: "derived-text";
+                    text: string;
+                    sha256: string;
+                    backendId: string;
+                    backendVersion?: string | undefined;
+                    model?: string | undefined;
+                };
+                precision: "page-only" | "approximate-geometry";
+            } | {
+                refId: string;
+                documentId: string;
+                sourcePath: string;
+                sourceDigest: string;
+                sourceVersion: string;
+                contentVersion: string;
+                revision: number;
+                page: number;
+                renderedImageSha256: string;
+                locator: {
+                    kind: "page-only";
+                } | {
+                    kind: "pdf-region";
+                    rectPdf: [number, number, number, number];
+                };
+                limitations: string[];
+                source: "auxiliary-vision";
+                snapshot: {
+                    kind: "derived-text";
+                    text: string;
+                    sha256: string;
+                    backendId: string;
+                    backendVersion?: string | undefined;
+                    model?: string | undefined;
+                };
+                precision: "page-only" | "approximate-geometry";
+            };
+        } | {
             annotationStatus: string;
             evidence: {
                 refId: string;
@@ -54,7 +173,12 @@ export declare function createPdfRetrieval(workspaces: WorkingCopyReadPort, page
                 extraction?: "local-ocr" | undefined;
                 pageTextDigest?: string | undefined;
             };
-        }[];
+            blockId?: string | undefined;
+            page: number;
+            quote: string;
+            score: number;
+            source: string;
+        })[];
         limitations: string[];
         status: "building" | "complete" | "incomplete";
         requestedMode: import("../../../modules/retrieval/types.js").RetrievalMode;
@@ -65,27 +189,10 @@ export declare function createPdfRetrieval(workspaces: WorkingCopyReadPort, page
             fromPage: number;
             toPage: number;
         };
-        coverage: {
-            indexedPages: number;
-            totalPages: number;
-            noTextPages: number[];
-            ocrPages: number[];
-            failedPages: {
-                page: number;
-                attempts: number;
-                code: string;
-            }[];
-            qualityWarnings: {
-                page: number;
-                warnings: string[];
-            }[];
-            embeddedChunks: number;
-            totalChunks: number;
-            visual: "not-indexed";
-        };
         nextCursor?: string;
     }>;
-    cancelSession: (sessionId: string) => void;
-    dispose: () => Promise<void>;
+    cancelSession(sessionId: string): void;
+    rebuild: () => Promise<void>;
+    dispose(): Promise<void>;
 };
 export type PdfRetrieval = ReturnType<typeof createPdfRetrieval>;

package/dist/types/adapters/host/dsh/translation-model.d.ts

@@ -1,3 +1,4 @@
+import type { ReasoningEffortId } from '@deepseek-ai/dsh-llm';
 import { type TranslationEngine } from '../../../translation/types.js';
 export interface DshTranslationModelRoute {
     provider: string;
@@ -8,7 +9,8 @@ export interface DshTranslationModelRoute {
 export interface DshTranslationLlm {
     stream(options: DshTranslationGenerateOptions): AsyncIterable<DshTranslationChunk>;
 }
-export interface DshTranslationGenerateOptions extends DshTranslationModelRoute {
+export interface DshTranslationGenerateOptions extends Omit<DshTranslationModelRoute, 'reasoningEffort'> {
+    reasoningEffort?: ReasoningEffortId;
     system: string;
     messages: {
         role: 'user';
@@ -43,9 +45,5 @@ export interface DshModelTranslationOptions {
     resolveContext(sessionId: string, signal?: AbortSignal): DshTranslationModelRoute | Promise<DshTranslationModelRoute>;
     maxOutputTokens: number;
 }
-type TranslationMode = 'word' | 'phrase' | 'sentence';
-/** A conservative UI-selection heuristic, independent of untrusted text instructions. */
-export declare function classifyTranslationSelection(text: string): TranslationMode;
 /** Reuse the configured DSH adapter and credentials for a request containing only selected text. */
 export declare function createDshModelTranslationEngine(options: DshModelTranslationOptions): TranslationEngine;
-export {};

package/dist/types/adapters/host/ocr/local-backend.d.ts

@@ -0,0 +1,4 @@
+import type { HostOcrBackend } from '../../../modules/ocr/index.js';
+import type { TextRecovery } from './local-text-recovery.js';
+/** The owner disposes the shared local worker adapter after unregistering this backend. */
+export declare function createLocalTesseractOcrBackend(recovery: TextRecovery): HostOcrBackend;

package/dist/types/contracts/indexing.d.ts

@@ -0,0 +1,156 @@
+import { z } from 'zod';
+export declare const PDF_INDEXING_METHOD = "pdf.indexing";
+/** Documents choose content sources; engine selection belongs to global settings. */
+export declare const documentIndexPolicySchema: z.ZodObject<{
+    indexScanPages: z.ZodBoolean;
+    indexImageDescriptions: z.ZodBoolean;
+}, z.core.$strict>;
+export type PdfDocumentIndexPolicy = z.infer<typeof documentIndexPolicySchema>;
+export declare const documentIndexSettingsSchema: z.ZodObject<{
+    documentId: z.ZodString;
+    revision: z.ZodNumber;
+    policy: z.ZodObject<{
+        indexScanPages: z.ZodBoolean;
+        indexImageDescriptions: z.ZodBoolean;
+    }, z.core.$strict>;
+    activePolicy: z.ZodObject<{
+        indexScanPages: z.ZodBoolean;
+        indexImageDescriptions: z.ZodBoolean;
+    }, z.core.$strict>;
+    enabled: z.ZodBoolean;
+    activeEnabled: z.ZodBoolean;
+    pending: z.ZodBoolean;
+    impact: z.ZodEnum<{
+        embedding: "embedding";
+        none: "none";
+        content: "content";
+        configuration: "configuration";
+    }>;
+}, z.core.$strict>;
+export type PdfDocumentIndexSettings = z.infer<typeof documentIndexSettingsSchema>;
+export declare const indexingProgressSchema: z.ZodObject<{
+    indexedPages: z.ZodNumber;
+    totalPages: z.ZodNumber;
+    embeddedChunks: z.ZodNumber;
+    totalChunks: z.ZodNumber;
+    phase: z.ZodOptional<z.ZodEnum<{
+        embedding: "embedding";
+        restoring: "restoring";
+        extracting: "extracting";
+        ready: "ready";
+    }>>;
+    reusedChunks: z.ZodOptional<z.ZodNumber>;
+    computedChunks: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const indexingTaskSchema: z.ZodObject<{
+    documentId: z.ZodString;
+    title: z.ZodString;
+    occurrence: z.ZodNumber;
+    state: z.ZodEnum<{
+        cancelled: "cancelled";
+        ready: "ready";
+        failed: "failed";
+        queued: "queued";
+        running: "running";
+    }>;
+    progress: z.ZodOptional<z.ZodObject<{
+        indexedPages: z.ZodNumber;
+        totalPages: z.ZodNumber;
+        embeddedChunks: z.ZodNumber;
+        totalChunks: z.ZodNumber;
+        phase: z.ZodOptional<z.ZodEnum<{
+            embedding: "embedding";
+            restoring: "restoring";
+            extracting: "extracting";
+            ready: "ready";
+        }>>;
+        reusedChunks: z.ZodOptional<z.ZodNumber>;
+        computedChunks: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    failureCode: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const indexingSnapshotSchema: z.ZodObject<{
+    revision: z.ZodString;
+    enabled: z.ZodBoolean;
+    tasks: z.ZodArray<z.ZodObject<{
+        documentId: z.ZodString;
+        title: z.ZodString;
+        occurrence: z.ZodNumber;
+        state: z.ZodEnum<{
+            cancelled: "cancelled";
+            ready: "ready";
+            failed: "failed";
+            queued: "queued";
+            running: "running";
+        }>;
+        progress: z.ZodOptional<z.ZodObject<{
+            indexedPages: z.ZodNumber;
+            totalPages: z.ZodNumber;
+            embeddedChunks: z.ZodNumber;
+            totalChunks: z.ZodNumber;
+            phase: z.ZodOptional<z.ZodEnum<{
+                embedding: "embedding";
+                restoring: "restoring";
+                extracting: "extracting";
+                ready: "ready";
+            }>>;
+            reusedChunks: z.ZodOptional<z.ZodNumber>;
+            computedChunks: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        failureCode: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    documents: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        documentId: z.ZodString;
+        revision: z.ZodNumber;
+        policy: z.ZodObject<{
+            indexScanPages: z.ZodBoolean;
+            indexImageDescriptions: z.ZodBoolean;
+        }, z.core.$strict>;
+        activePolicy: z.ZodObject<{
+            indexScanPages: z.ZodBoolean;
+            indexImageDescriptions: z.ZodBoolean;
+        }, z.core.$strict>;
+        enabled: z.ZodBoolean;
+        activeEnabled: z.ZodBoolean;
+        pending: z.ZodBoolean;
+        impact: z.ZodEnum<{
+            embedding: "embedding";
+            none: "none";
+            content: "content";
+            configuration: "configuration";
+        }>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export declare const indexingRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    action: z.ZodLiteral<"status">;
+    sessionId: z.ZodString;
+    revision: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"start">;
+    sessionId: z.ZodString;
+    documentId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"rebuild">;
+    sessionId: z.ZodString;
+    documentId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"cancel">;
+    sessionId: z.ZodString;
+    documentId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"configure">;
+    sessionId: z.ZodString;
+    documentId: z.ZodString;
+    revision: z.ZodNumber;
+    policy: z.ZodObject<{
+        indexScanPages: z.ZodBoolean;
+        indexImageDescriptions: z.ZodBoolean;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"defaults">;
+    sessionId: z.ZodString;
+    documentId: z.ZodString;
+    revision: z.ZodNumber;
+}, z.core.$strict>], "action">;
+export type PdfIndexingTask = z.infer<typeof indexingTaskSchema>;
+export type PdfIndexingSnapshot = z.infer<typeof indexingSnapshotSchema>;

package/dist/types/embedding/registry.d.ts

@@ -13,7 +13,8 @@ export declare class EmbeddingRegistry {
         id: string;
         name: string;
         version: string;
-        execution: "disabled" | "local" | "remote";
+        execution: "disabled" | "local" | "remote" | "service";
+        capabilities?: ("ocr-text" | "image-description")[] | undefined;
         configurationFields?: {
             key: string;
             label: string;

package/dist/types/embedding/types.d.ts

@@ -9,7 +9,7 @@ export interface EmbeddingModel {
     engineId: string;
     engineVersion: string;
     model: string;
-    /** Change whenever the served weights/tokenizer change, including local replacements. */
+    /** Provider-owned version/encoding identity; never requires a user-facing revision setting. */
     modelRevision: string;
     dimensions: number;
     maxBatchSize: number;
@@ -18,6 +18,9 @@ export interface EmbeddingModel {
     /** Includes query instructions, document encoding and normalization version. */
     encoding: string;
     fingerprint: string;
+    /** Optional identity of document vectors only. Excludes query instructions
+     * and transport limits; providers own and must attest its encoding contract. */
+    documentFingerprint?: string;
 }
 export interface EmbeddingRequest {
     texts: readonly string[];
@@ -38,8 +41,13 @@ export interface EmbeddingEngine {
     /** Synchronous, side-effect-free description used to key derived indexes. */
     describe(config: EngineConfiguration): EmbeddingModel;
     availability?(config: EngineConfiguration, signal: AbortSignal): Promise<EmbeddingAvailability>;
-    embed(request: EmbeddingEngineRequest, config: EngineConfiguration): Promise<readonly (readonly number[])[]>;
+    embed(request: EmbeddingEngineRequest, config: EngineConfiguration): Promise<EmbeddingEngineOutput>;
 }
+/** A provider may report the exact model identity verified for this operation. */
+export type EmbeddingEngineOutput = readonly (readonly number[])[] | {
+    vectors: readonly (readonly number[])[];
+    model: EmbeddingModel;
+};
 export interface EmbeddingLimits {
     timeoutMs: number;
     maxBatchSize: number;

package/dist/types/entrypoints/image-understanding-host.d.ts

@@ -2,7 +2,7 @@ import { Context } from '@deepseek-ai/cordis';
 import { z } from 'zod';
 import { type PdfImageEvidenceResolver } from '../adapters/host/dsh/index.js';
 import { HostImageUnderstandingService } from '../modules/image-understanding/index.js';
-export type { ImageUnderstandingBackend, ImageUnderstandingAvailability, ImageUnderstandingPreparation, ImageUnderstandingRequest } from '../modules/image-understanding/index.js';
+export type { ImageUnderstandingBackend, ImageUnderstandingAvailability, ImageUnderstandingResult, ImageUnderstandingRequest } from '../modules/image-understanding/index.js';
 export { HostImageUnderstandingService } from '../modules/image-understanding/index.js';
 declare module '@deepseek-ai/cordis' {
     interface Context {
@@ -10,18 +10,12 @@ declare module '@deepseek-ai/cordis' {
         pdfImageEvidence: PdfImageEvidenceResolver;
     }
 }
-/** Independent Host extension. Other plugins may register a derived-text backend. */
+/** Independent Host extension. Other plugins register image-to-text implementations. */
 export declare const name = "image-understanding";
 export declare const provide = "imageUnderstanding";
 export declare const inject: string[];
 export declare const Config: z.ZodDefault<z.ZodObject<{
     backend: z.ZodDefault<z.ZodString>;
-    auxiliaryVision: z.ZodOptional<z.ZodObject<{
-        provider: z.ZodString;
-        model: z.ZodString;
-        reasoningEffort: z.ZodOptional<z.ZodString>;
-        maxOutputTokens: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
 }, z.core.$strip>>;
 export type Config = z.infer<typeof Config>;
 export declare function apply(ctx: Context, config: Config): void;

package/dist/types/host/image-understanding-plugin.d.ts

@@ -1,2 +1,2 @@
 export { name, provide, inject, Config, HostImageUnderstandingService, apply } from '../entrypoints/image-understanding-host.js';
-export type { ImageUnderstandingBackend, ImageUnderstandingAvailability, ImageUnderstandingPreparation, ImageUnderstandingRequest } from '../entrypoints/image-understanding-host.js';
+export type { ImageUnderstandingBackend, ImageUnderstandingAvailability, ImageUnderstandingResult, ImageUnderstandingRequest } from '../entrypoints/image-understanding-host.js';

package/dist/types/modules/document/index.d.ts

@@ -2,3 +2,10 @@ export { pageRenderPlan, ocrRegionRenderPlan } from './native-render-plan.js';
 export { recoveredPageText, RECOVERED_TEXT_WARNING } from './text-recovery.js';
 export type { NativeRenderPlan } from './native-render-plan.js';
 export { digestPdfBytes, encodePdfBaseline, decodePdfBaseline } from './source.js';
+export { PAGE_CONTENT_VERSION, NATIVE_PAGE_CONTENT_EXTRACTION_VERSION, MAX_PAGE_CONTENT_TEXT, MAX_PAGE_CONTENT_SPANS, PageContentSchema, PageContentBlockSchema, PageRepresentationSchema, pageContentRectSchema, pageContentDigest, pageContentBlockId, pageRepresentationId, createPageRepresentation, appendPageRepresentation, parsePageContent } from './page-content.js';
+export type { PageContent, PageContentBlock, PageContentIdentity, PageRepresentation, PageRepresentationProducer } from './page-content.js';
+export { buildNativePageContent } from './page-content-native.js';
+export type { BuildNativePageContentInput } from './page-content-native.js';
+export { nativePageContentText } from './page-content-text.js';
+export { fatalContentError } from './page-content-error.js';
+export { ocrPageContentSpans } from './page-content-ocr.js';

package/dist/types/modules/document/page-content-error.d.ts

@@ -0,0 +1,3 @@
+/** Source authority, stale snapshots and cancellation cannot become a successful
+ * partial extraction. Contributor adapters may wrap these typed failures. */
+export declare function fatalContentError(error: unknown): unknown | undefined;

package/dist/types/modules/document/page-content-native.d.ts

@@ -0,0 +1,10 @@
+import type { PdfRect } from '../../core/pdf-types.js';
+import type { NativeTextContent } from '../../shared/native.js';
+import { type PageContent, type PageContentIdentity } from './page-content.js';
+export interface BuildNativePageContentInput extends PageContentIdentity {
+    pageRect: PdfRect;
+    /** Null means extraction was unavailable; an empty content layer is a valid scanned/blank page. */
+    content: NativeTextContent | null;
+}
+/** Preserve joinPageText's exact extraction order and UTF-16 offsets. No figure segmentation is inferred. */
+export declare function buildNativePageContent(input: BuildNativePageContentInput): PageContent;

package/dist/types/modules/document/page-content-ocr.d.ts

@@ -0,0 +1,5 @@
+import type { OcrOutput } from '../../ocr/types.js';
+import type { PdfPageInfo } from '../../core/pdf-types.js';
+import type { PageRepresentation } from './page-content.js';
+/** Preserve recognized source offsets and convert page pixels to unrotated PDF coordinates once. */
+export declare function ocrPageContentSpans(output: OcrOutput, geometry: PdfPageInfo, width: number, height: number): NonNullable<PageRepresentation['spans']>;

package/dist/types/modules/document/page-content-text.d.ts

@@ -0,0 +1,12 @@
+import type { NativeTextContent } from '../../shared/native.js';
+type TextItem = NativeTextContent['items'][number];
+/**
+ * Preserve native extraction order and exact joined-text offsets. Only obvious
+ * layout gaps/font changes add boundaries; ordinary wrapped lines remain one
+ * paragraph. These are content boundaries, never certified reading-order geometry.
+ */
+export declare function nativePageContentText(items: readonly TextItem[]): {
+    text: string;
+    paragraphBreaks: number[];
+};
+export {};