@poe-platform/safe-bash 0.1.817 → 0.1.818

package/dist/image-ast/index.js

@@ -297,7 +297,7 @@ function checkLimitInputPixels(width, height, options) {
 }
 
 // src/image-pdf.ts
-import { PdfFileSource as PdfFileSource2, PdfRetainedDocument, PdfError, renderRetainedPagePixels } from "../pdf-ast/index.js";
+import { PdfFileSource as PdfFileSource2, PdfRetainedReader, PdfError, renderRetainedPagePixels } from "../pdf-ast/image.js";
 import { normalizePath } from "@poe-platform/safe-fs/contracts";
 
 // src/codecs/svg-transform.ts
@@ -1890,7 +1890,7 @@ async function openPdfImage(source, fs, directory, signal, options, storage) {
     if (failure) throw failure.error;
   };
   try {
-    document = await PdfRetainedDocument.open(retained, { fs, directory }, { signal, recovery: "repair", compactNumbers: !0, compactKeywords: !0, chunkBytes: 16384, maxNodes: 1 / 0, maxTokenBytes: 1 / 0, maxRecursionDepth: 1 / 0, maxPageTreeDepth: 1 / 0, xref: { arrayStorage: values, storedArrayKeys: ["Index"] }, valueArrays: { dictionaryStorage: values, deferDictionaryValues: !0, storedDictionaryKeys: ["Font", "XObject", "Properties"], storedDictionaryPaths: [["Resources", "*"]], containerStorage: values, stringStorage: values, storedStringKeys: ["ActualText"], arrayStorage: values, storedArrayKeys: ["Contents", "Annots", "Kids", "Widths", "W", "Differences", "ON", "OFF", "OCGs"], storedArrayPaths: [["ExtGState", "*", "D"]] } });
+    document = await PdfRetainedReader.open(retained, { fs, directory }, { signal, recovery: "repair", compactNumbers: !0, compactKeywords: !0, chunkBytes: 16384, maxNodes: 1 / 0, maxTokenBytes: 1 / 0, maxRecursionDepth: 1 / 0, maxPageTreeDepth: 1 / 0, xref: { arrayStorage: values, storedArrayKeys: ["Index"] }, valueArrays: { dictionaryStorage: values, deferDictionaryValues: !0, storedDictionaryKeys: ["Font", "XObject", "Properties"], storedDictionaryPaths: [["Resources", "*"]], containerStorage: values, stringStorage: values, storedStringKeys: ["ActualText"], arrayStorage: values, storedArrayKeys: ["Contents", "Annots", "Kids", "Widths", "W", "Differences", "ON", "OFF", "OCGs"], storedArrayPaths: [["ExtGState", "*", "D"]] } });
     let pages = 0, selected;
     for await (let page of document.pages())
       pages++, page.index <= Math.max(0, settings.page ?? 0) && (selected = page);

package/dist/mp4-ast/index.d.ts

@@ -12,6 +12,7 @@ export * from "./containers/streaming.js";
 export { decodeH264Samples } from "./h264.js";
 export { scanMp4SampleTable, type Mp4SampleTables, type Mp4TableRange, type Mp4SampleSpan, type Mp4SampleScanOptions } from "./mp4-sample-source.js";
 export { scanMp4Fragment, type Mp4FragmentDefaults, type Mp4FragmentState, type Mp4FragmentScanOptions } from "./mp4-fragment-source.js";
-export { scanMp4Packets, scanMp4Frames, type Mp4PacketScanOptions } from './mp4-packets-source.js';
+export { scanMp4Packets, scanMp4Frames, probeMp4Source, type Mp4SourceProbeOptions, type Mp4PacketScanOptions } from './mp4-packets-source.js';
 export { scanMp4CodecDescriptions } from './mp4-codec-source.js';
 export type { Mp4CodecMetadata } from './mp4-codec-metadata.js';
+export { probeMp4MetadataSource } from './mp4-metadata-source.js';

package/dist/mp4-ast/mp4-metadata-source.d.ts

@@ -0,0 +1,10 @@
+import { type Mp4BoxScanOptions } from './mp4-source.js';
+import { type MediaProbeSource, type MediaProbeSourceTags, type MediaProbeText, type MediaProbeSourceChapter } from './types.js';
+type MetadataOptions = Pick<Mp4BoxScanOptions, 'budget' | 'signal' | 'checkpoint'>;
+/** Probe-only tags and chapters. Caller retains the source until all field/row reads finish. */
+export declare function probeMp4MetadataSource(source: MediaProbeSource, durationSeconds: number, options?: MetadataOptions): Promise<{
+    tags: MediaProbeSourceTags;
+    chapters: AsyncIterable<MediaProbeSourceChapter>;
+}>;
+export declare function mp4SourceText(source: MediaProbeSource, offset: number, length: number, work: MetadataOptions, latin1?: boolean): MediaProbeText;
+export {};

package/dist/mp4-ast/mp4-packets-source.d.ts

@@ -1,5 +1,5 @@
 import { type Mp4SampleScanOptions } from './mp4-sample-source.js';
-import { type MediaProbePacket, type MediaProbeFrame, type MediaProbeSource, type MediaResourceLimits } from './types.js';
+import { type MediaProbePacket, type MediaProbeFrame, type MediaProbeSource, type MediaResourceLimits, type MediaProbeSourceRecords } from './types.js';
 export interface Mp4PacketScanOptions extends Omit<Mp4SampleScanOptions, 'type' | 'syncSamples'> {
     readonly limits?: MediaResourceLimits;
     /** A fresh caller-owned membership index for each track; its lifetime belongs to the caller. */
@@ -9,3 +9,10 @@ export interface Mp4PacketScanOptions extends Omit<Mp4SampleScanOptions, 'type'
 export declare function scanMp4Packets(source: MediaProbeSource, options?: Mp4PacketScanOptions): AsyncGenerator<MediaProbePacket, void>;
 /** Replay frame descriptors with bounded scalar codec metadata; no media decoding. */
 export declare function scanMp4Frames(source: MediaProbeSource, options?: Mp4PacketScanOptions): AsyncGenerator<MediaProbeFrame, void>;
+export interface Mp4SourceProbeOptions extends Mp4PacketScanOptions {
+    readonly filename?: string;
+    readonly showPackets?: boolean;
+    readonly showFrames?: boolean;
+}
+/** Bounded native metadata and replayable record sources. The caller owns input and indexes. */
+export declare function probeMp4Source(source: MediaProbeSource, options?: Mp4SourceProbeOptions): Promise<MediaProbeSourceRecords>;

package/dist/mp4-ast/types.d.ts

@@ -375,12 +375,30 @@ export type MediaProbeRecords = Omit<MediaProbeResult, "packets" | "frames"> & {
     readonly packets?: Iterable<MediaProbePacket> | undefined;
     readonly frames?: Iterable<MediaProbeFrame> | undefined;
 };
+/** Replayable bounded string chunks. The caller keeps backing alive through all reads.
+ * CSV quoting may read a field twice. Each invocation must return the same text.
+ */
+export interface MediaProbeText {
+    readonly kind: 'text';
+    chunks(): Iterable<string> | AsyncIterable<string>;
+}
+export type MediaProbeSourceTags = Readonly<Record<string, string | MediaProbeText>>;
+export type MediaProbeSourceStream = Omit<MediaProbeStream, 'tags'> & {
+    readonly tags?: MediaProbeSourceTags | undefined;
+};
+export type MediaProbeSourceFormat = Omit<MediaProbeFormat, 'tags'> & {
+    readonly tags?: MediaProbeSourceTags | undefined;
+};
+export type MediaProbeSourceChapter = Omit<MediaProbeResult['chapters'][number], 'tags'> & {
+    readonly tags: MediaProbeSourceTags;
+};
 /** Caller-backed, one-shot record sources. Consume before retiring the input source. */
-export type MediaProbeSourceRecords = Omit<MediaProbeResult, "streams" | "chapters" | "packets" | "frames"> & {
+export type MediaProbeSourceRecords = Omit<MediaProbeResult, "format" | "streams" | "chapters" | "packets" | "frames"> & {
     /** Retire plugin-owned backing after all requested records, including unselected sections. */
     readonly close?: () => Promise<void>;
-    readonly streams: Iterable<MediaProbeStream> | AsyncIterable<MediaProbeStream>;
-    readonly chapters: Iterable<MediaProbeResult["chapters"][number]> | AsyncIterable<MediaProbeResult["chapters"][number]>;
+    readonly format: MediaProbeSourceFormat;
+    readonly streams: Iterable<MediaProbeSourceStream> | AsyncIterable<MediaProbeSourceStream>;
+    readonly chapters: Iterable<MediaProbeSourceChapter> | AsyncIterable<MediaProbeSourceChapter>;
     readonly packets?: Iterable<MediaProbePacket> | AsyncIterable<MediaProbePacket> | undefined;
     readonly frames?: Iterable<MediaProbeFrame> | AsyncIterable<MediaProbeFrame> | undefined;
 };

package/dist/pdf-ast/ast.d.ts

@@ -253,6 +253,8 @@ export interface PdfStoredOperations {
 }
 /** A transparency-group mask evaluated in page coordinates at the gs operator. */
 export interface PdfSoftMask {
+    /** Identity within one retained page evaluation, preserved across capture records. */
+    readonly retainedId?: number;
     readonly subtype: "Alpha" | "Luminosity";
     readonly operations: readonly PdfPaintOperation[];
     readonly storedOperations?: PdfStoredOperations | undefined;

package/dist/pdf-ast/content/evaluator.d.ts

@@ -60,6 +60,7 @@ export declare function evalShadingFunctionSteps(doc: ParsedCosDocument, fnNode:
 export type PdfColorRequest = PdfResourceRequest | {
     readonly kind: "resolve";
     readonly node: PdfCosNode | undefined;
+    readonly storeRootDictionary?: boolean;
 } | {
     readonly kind: "decode";
     readonly stream: PdfCosStream;
@@ -76,9 +77,15 @@ export type PdfColorRequest = PdfResourceRequest | {
 };
 type ColorWork<T> = Generator<PdfColorRequest, T, unknown>;
 export type PdfMaskParameterRequest = PdfColorRequest | {
+    readonly kind: "numeric-array";
+    readonly node: PdfCosNode | undefined;
+    readonly owner: PdfCosDict;
+    readonly count: number;
+} | {
     readonly kind: "dictionary-value";
     readonly dict: PdfCosDict;
     readonly key: string;
+    readonly preserveDeferred?: boolean;
 } | {
     readonly kind: "transfer";
     readonly node: PdfCosNode;

package/dist/pdf-ast/content/retained-evaluator.d.ts

@@ -1,5 +1,5 @@
 import type { PdfIndexStorage } from "../cos/object-index.js";
-import type { PdfRetainedDocument } from "../retained-document.js";
+import type { PdfRetainedReader } from "../retained-reader.js";
 import { type PdfContentEvaluationOptions, type PdfEvaluationOperation } from "./evaluator.js";
 import type { PdfContentEvent } from "./parser.js";
 import type { ParseContentRangeOptions } from "./range-operator-parser.js";
@@ -21,4 +21,4 @@ export type PdfRetainedEvaluationParameters = Omit<PdfContentEvaluationOptions,
 /** Drive shared evaluation using retained input and caller-backed staging.
  * Paint operations are pulled on demand. With imageStorage, paths and images
  * use caller backing. Composite captures store replayable operation records there. */
-export declare function evaluateRetainedContentSteps(document: PdfRetainedDocument, content: AsyncIterable<Uint8Array> | Iterable<Uint8Array> | PdfRetainedContentEvents, params: PdfRetainedEvaluationParameters, storage: PdfIndexStorage, options?: PdfRetainedEvaluationOptions): AsyncGenerator<PdfEvaluationOperation, void, void>;
+export declare function evaluateRetainedContentSteps(document: PdfRetainedReader, content: AsyncIterable<Uint8Array> | Iterable<Uint8Array> | PdfRetainedContentEvents, params: PdfRetainedEvaluationParameters, storage: PdfIndexStorage, options?: PdfRetainedEvaluationOptions): AsyncGenerator<PdfEvaluationOperation, void, void>;

package/dist/pdf-ast/content/retained-page.d.ts

@@ -1,6 +1,6 @@
 import { type PdfCosDict } from "../ast.js";
 import type { PdfIndexStorage } from "../cos/object-index.js";
-import type { PdfRetainedDocument, PdfRetainedPage } from "../retained-document.js";
+import type { PdfRetainedReader, PdfRetainedPage } from "../retained-reader.js";
 import type { PdfContentEvent } from "./parser.js";
 import type { PdfRetainedEvaluationOptions } from "./retained-evaluator.js";
 export interface PdfRetainedPageEvaluationOptions extends PdfRetainedEvaluationOptions {
@@ -9,7 +9,7 @@ export interface PdfRetainedPageEvaluationOptions extends PdfRetainedEvaluationO
 /** Resources from all nonempty appearances precede base-page evaluation, just
  * as in the buffered API. A prepass avoids retaining an appearance plan or its
  * content: each cursor closes before the next annotation. */
-export declare function prepareRetainedPageContent(document: PdfRetainedDocument, page: PdfRetainedPage, pageResources: PdfCosDict, storage: PdfIndexStorage, options: PdfRetainedPageEvaluationOptions): Promise<{
+export declare function prepareRetainedPageContent(document: PdfRetainedReader, page: PdfRetainedPage, pageResources: PdfCosDict, storage: PdfIndexStorage, options: PdfRetainedPageEvaluationOptions): Promise<{
     resources: PdfCosDict;
     events: AsyncGenerator<PdfContentEvent, void, void>;
 }>;

package/dist/pdf-ast/extract/html-text-stream.d.ts

@@ -0,0 +1,14 @@
+import type { PdfIndexStorage } from "../cos/object-index.js";
+import type { PdfRetainedDocument, PdfRetainedPage } from "../retained-document.js";
+import type { PdfRawTextIndex } from "./raw-text-index.js";
+export interface PdfHtmlPageTextOptions {
+    readonly xml?: boolean;
+    readonly zoom?: number;
+    readonly height: number;
+    readonly signal?: AbortSignal;
+    /** Image markup belongs after XML font definitions and before page text. */
+    readonly images?: () => AsyncIterable<string>;
+}
+/** Format styled text with replayable caller-backed word and font indexes.
+ * The caller owns the document and text index throughout consumption. */
+export declare function streamHtmlPageText(document: PdfRetainedDocument, page: PdfRetainedPage, index: PdfRawTextIndex, storage: PdfIndexStorage, options: PdfHtmlPageTextOptions): AsyncGenerator<string, void, void>;

package/dist/pdf-ast/extract/logical-text-stream.d.ts

@@ -0,0 +1,14 @@
+import type { PdfStoredTextBlock } from './raw-text-index.js';
+export interface PdfLogicalTextOptions {
+    readonly crop?: readonly [number, number, number, number];
+    readonly rejoinHyphens?: boolean;
+    readonly chunkBytes?: number;
+    /** Formatter scratch only; the caller retains ownership of its text index. */
+    readonly maxWorkingBytes?: number;
+    readonly signal?: AbortSignal;
+}
+/** Stream an indexed hierarchy without retaining a line or word string. One
+ * trailing hyphen is delayed until the next surviving line determines joining. */
+export declare function streamLogicalTextChunks(index: {
+    blocks(): AsyncIterable<PdfStoredTextBlock>;
+}, options?: PdfLogicalTextOptions): AsyncGenerator<Uint8Array, void, void>;

package/dist/pdf-ast/extract/raw-text-index.d.ts

@@ -1,14 +1,19 @@
-import type { PdfPlacedGlyph, PdfRect } from "../ast.js";
+import { type PdfTextGlyph } from "./stored-text-glyphs.js";
+import type { PdfRect } from "../ast.js";
 import type { PdfIndexStorage } from "../cos/object-index.js";
 import type { ExtractTextOptions } from "./text.js";
 /** Retained extraction may borrow replacement text from caller-owned storage.
  * An explicit actualText string takes precedence. Keep storage alive until create completes. */
-export type PdfRawTextGlyph = PdfPlacedGlyph;
-export interface PdfRawTextIndexOptions extends Pick<ExtractTextOptions, "discardDiagonal" | "clipText"> {
+export type PdfRawTextGlyph = PdfTextGlyph;
+export interface PdfRawTextIndexOptions extends Pick<ExtractTextOptions, "discardDiagonal" | "clipText" | "mode" | "colSpacing"> {
     /** Page-rounded high-water allocation, including records and UTF-16 text. */
     readonly maxStorageBytes?: number;
+    /** Required page geometry for logical column classification. */
+    readonly pageWidth?: number;
+    /** Retain first-glyph font names on each word for styled extraction. */
+    readonly retainFontNames?: boolean;
     /** Fixed scratch: 81920 bytes for string inputs, 131072 when decoding stored
-     * replacements. Caller-owned glyph strings are not included. */
+     * replacements, 327680 for geometric order, 409600 for logical column order (three caches and normalization). Caller-owned glyph strings are not included. */
     readonly maxWorkingBytes?: number;
     readonly maxWords?: number;
     readonly maxLines?: number;
@@ -16,6 +21,7 @@ export interface PdfRawTextIndexOptions extends Pick<ExtractTextOptions, "discar
     readonly signal?: AbortSignal;
 }
 export interface PdfStoredTextWord {
+    fontName?(): AsyncGenerator<string, void, void>;
     readonly bbox: PdfRect;
     readonly fontSize: number;
     text(): AsyncGenerator<string, void, void>;
@@ -33,11 +39,13 @@ export interface PdfStoredTextBlock {
 /** A raw-order text hierarchy whose records and strings live on caller storage.
  * Iterators borrow the index lifetime; close after their final consumption. */
 export declare class PdfRawTextIndex {
+    private readonly storage;
     private readonly options;
     private readonly backing;
     private readonly signal;
     private readonly textBuffer;
     private allocated;
+    private orderStorage;
     private firstBlock;
     private blockCount;
     private closed;
@@ -55,5 +63,11 @@ export declare class PdfRawTextIndex {
     private words;
     private lines;
     blocks(): AsyncGenerator<PdfStoredTextBlock, void, void>;
+    /** Stream physical rows; sorting and merge arrays stay in caller backing.
+     * Replaying a row twice trims an arbitrarily long whitespace suffix without
+     * retaining it, while preserving all interior whitespace and fixed spacing. */
+    layoutText(options?: Pick<ExtractTextOptions, "fixedPitch" | "lineSpacing"> & {
+        readonly crop?: PdfRect;
+    }): AsyncGenerator<string, void, void>;
     close(): Promise<void>;
 }

package/dist/pdf-ast/extract/retained-color.d.ts

@@ -1,7 +1,7 @@
 import { type PdfCosDict, type PdfCosNode, type PdfCosStream, type PdfEvaluatedImage } from "../ast.js";
 import { type PdfEvaluationShadingRequest } from "../content/evaluator.js";
 import type { PdfIndexStorage } from "../cos/object-index.js";
-import type { PdfRetainedDocument } from "../retained-document.js";
+import type { PdfRetainedReader } from "../retained-reader.js";
 import { type ResolvedColorSpace } from "./images.js";
 export interface PdfRetainedColorOptions {
     /** Admission for retained color metadata, palette/function bytes and palette
@@ -17,19 +17,19 @@ export interface PdfRetainedColorOptions {
     readonly chunkBytes?: number;
     readonly signal?: AbortSignal;
 }
-export declare function resolveRetainedImageColor(document: PdfRetainedDocument, node: PdfCosNode | undefined, resources: PdfCosDict | undefined, storage: PdfIndexStorage, options?: PdfRetainedColorOptions): Promise<ResolvedColorSpace>;
+export declare function resolveRetainedImageColor(document: PdfRetainedReader, node: PdfCosNode | undefined, resources: PdfCosDict | undefined, storage: PdfIndexStorage, options?: PdfRetainedColorOptions): Promise<ResolvedColorSpace>;
 /** Keeps range-backed tint resources alive until the image owner closes. */
-export declare function openRetainedImageColor(document: PdfRetainedDocument, node: PdfCosNode | undefined, resources: PdfCosDict | undefined, storage: PdfIndexStorage, options?: PdfRetainedColorOptions): Promise<{
+export declare function openRetainedImageColor(document: PdfRetainedReader, node: PdfCosNode | undefined, resources: PdfCosDict | undefined, storage: PdfIndexStorage, options?: PdfRetainedColorOptions): Promise<{
     color: ResolvedColorSpace;
     close: () => Promise<void>;
 }>;
 /** Resolve the same vector colors as buffered evaluation using retained reads.
  * Palette/function state is admitted; unrelated resources and ICC payloads are
  * not read. The returned RGB value has no retained source lifetime. */
-export declare function convertRetainedContentColor(document: PdfRetainedDocument, node: PdfCosNode | undefined, name: string, components: readonly number[], resources: PdfCosDict | undefined, storage: PdfIndexStorage, options?: PdfRetainedColorOptions): Promise<[number, number, number]>;
+export declare function convertRetainedContentColor(document: PdfRetainedReader, node: PdfCosNode | undefined, name: string, components: readonly number[], resources: PdfCosDict | undefined, storage: PdfIndexStorage, options?: PdfRetainedColorOptions): Promise<[number, number, number]>;
 /** Resolve only mask backdrop and transfer state, without decoding the Form. */
-export declare function resolveRetainedMaskParameters(document: PdfRetainedDocument, mask: PdfCosDict, form: PdfCosStream, resources: PdfCosDict | undefined, storage: PdfIndexStorage, options?: PdfRetainedColorOptions): Promise<Pick<import("../ast.js").PdfSoftMask, "backdrop" | "transferMap">>;
+export declare function resolveRetainedMaskParameters(document: PdfRetainedReader, mask: PdfCosDict, form: PdfCosStream, resources: PdfCosDict | undefined, storage: PdfIndexStorage, options?: PdfRetainedColorOptions): Promise<Pick<import("../ast.js").PdfSoftMask, "backdrop" | "transferMap">>;
 export type PdfRetainedShadingSettings = Omit<PdfEvaluationShadingRequest, "kind" | "dict" | "stream">;
 /** Read only selected shading resources through retained access. Resource
  * snapshots, mesh geometry and the result surface are admitted to one owner. */
-export declare function renderRetainedShading(document: PdfRetainedDocument, node: PdfCosNode, settings: PdfRetainedShadingSettings, storage: PdfIndexStorage, options?: PdfRetainedColorOptions): Promise<PdfEvaluatedImage | undefined>;
+export declare function renderRetainedShading(document: PdfRetainedReader, node: PdfCosNode, settings: PdfRetainedShadingSettings, storage: PdfIndexStorage, options?: PdfRetainedColorOptions): Promise<PdfEvaluatedImage | undefined>;

package/dist/pdf-ast/extract/retained-decoded-image.d.ts

@@ -1,5 +1,5 @@
 import type { PdfIndexStorage } from "../cos/object-index.js";
-import type { PdfRetainedDocument } from "../retained-document.js";
+import type { PdfRetainedReader } from "../retained-reader.js";
 import type { ResolvedColorSpace } from "./images.js";
 import type { PdfRetainedImage } from "./retained-images.js";
 type Input = Pick<PdfRetainedImage, "dict" | "resources" | "contents">;
@@ -39,7 +39,7 @@ export declare class PdfRetainedDecodedImage {
     get globalsByteLength(): number | undefined;
     /** Read before rows finish or close releases this owner's staging. */
     nativeContents(kind?: "image" | "globals"): AsyncGenerator<Uint8Array, void, void>;
-    static open(document: PdfRetainedDocument, image: Input, storage: PdfIndexStorage, options?: PdfRetainedImageDecodeOptions): Promise<PdfRetainedDecodedImage>;
+    static open(document: PdfRetainedReader, image: Input, storage: PdfIndexStorage, options?: PdfRetainedImageDecodeOptions): Promise<PdfRetainedDecodedImage>;
     private static decode;
     rows(): AsyncGenerator<Uint8Array, void, void>;
     private consume;

package/dist/pdf-ast/extract/stored-text-glyphs.d.ts

@@ -0,0 +1,8 @@
+import { type PdfStoredBytes, type PdfPlacedGlyph } from "../ast.js";
+export type PdfTextGlyph = PdfPlacedGlyph & {
+    readonly storedUnicode?: PdfStoredBytes;
+    readonly storedFontName?: PdfStoredBytes;
+};
+export declare function glyphText(glyph: PdfTextGlyph, signal: AbortSignal): AsyncGenerator<string, void, void>;
+export declare function glyphFontName(glyph: PdfTextGlyph, signal: AbortSignal): AsyncGenerator<string, void, void>;
+export declare function sameReplacement(a: PdfPlacedGlyph, b: PdfPlacedGlyph, signal: AbortSignal): Promise<boolean>;

package/dist/pdf-ast/fonts/retained.d.ts

@@ -1,6 +1,6 @@
 import type { PdfCosDict, PdfPixelStorage } from "../ast.js";
 import type { PdfIndexStorage } from "../cos/object-index.js";
-import type { PdfRetainedDocument } from "../retained-document.js";
+import type { PdfRetainedReader } from "../retained-reader.js";
 import { type PdfFontAllocationOptions } from "./memory.js";
 import { type ResolvedPageFont } from "./resolve.js";
 export interface PdfRetainedFontOptions extends PdfFontAllocationOptions {
@@ -13,4 +13,4 @@ export interface PdfRetainedFontOptions extends PdfFontAllocationOptions {
 /** Resolve one font without loading the document or unrelated font programs.
  * Font programs and glyph scratch retain caller resource backing.
  * The caller owns font lifetime. */
-export declare function resolveRetainedFont(document: PdfRetainedDocument, storage: PdfIndexStorage, resources: PdfCosDict | undefined, name: string, options?: PdfRetainedFontOptions): Promise<ResolvedPageFont | undefined>;
+export declare function resolveRetainedFont(document: PdfRetainedReader, storage: PdfIndexStorage, resources: PdfCosDict | undefined, name: string, options?: PdfRetainedFontOptions): Promise<ResolvedPageFont | undefined>;

package/dist/pdf-ast/image.d.ts

@@ -0,0 +1,2 @@
+/** PDF image decoding and rendering without document-wide extraction. */
+export { PdfDocument, renderPdfPageToPng, PdfFileSource, PdfRetainedReader, PdfError, renderRetainedPagePixels, type PdfRetainedPage } from "./index.js";

package/dist/pdf-ast/image.js

@@ -0,0 +1,19 @@
+import {
+  PdfDocument,
+  PdfError,
+  PdfFileSource,
+  PdfRetainedReader,
+  renderPdfPageToPng,
+  renderRetainedPagePixels
+} from "../safe-bash/command-chunks/chunk-5WS6DXYE.js";
+import "../safe-bash/command-chunks/chunk-E6SK3OU2.js";
+import "../safe-bash/command-chunks/chunk-NUGQQDGE.js";
+import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
+export {
+  PdfDocument,
+  PdfError,
+  PdfFileSource,
+  PdfRetainedReader,
+  renderPdfPageToPng,
+  renderRetainedPagePixels
+};

package/dist/pdf-ast/index.d.ts

@@ -1,3 +1,4 @@
+export { streamHtmlPageText, type PdfHtmlPageTextOptions } from "./extract/html-text-stream.js";
 export type { PdfRetainedPageLabel } from "./extract/retained-page-labels.js";
 export { renderRetainedPagePixels, type PdfRetainedPixelOptions, type PdfRetainedPixels } from "./render/retained-page-pixels.js";
 export * from "./ast.js";
@@ -82,3 +83,5 @@ export { QpdfJsonValues } from "./cos/qpdf-json-values.js";
 export { QpdfJsonDocument, type ApplyQpdfJsonOptions } from "./cos/qpdf-json-document.js";
 export type { RetainedAppendAttachment } from "./edit/retained-append-attachments.js";
 export { parseRetainedFormData } from "./edit/retained-form-data.js";
+export { streamLogicalTextChunks, type PdfLogicalTextOptions } from "./extract/logical-text-stream.js";
+export { encodePostscriptPageChunks } from "./render/postscript.js";