@poe-platform/safe-bash 0.1.652 → 0.1.654

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

@@ -0,0 +1,54 @@
+export type Attr = readonly [string, readonly string[], readonly (readonly [string, string])[]];
+export type Target = readonly [string, string];
+type Tagged<T extends string, C> = {
+    readonly t: T;
+    readonly c: C;
+};
+type Empty<T extends string> = {
+    readonly t: T;
+};
+export type Inline = Tagged<"Str", string> | Empty<"Space" | "SoftBreak" | "LineBreak"> | Tagged<"Emph" | "Underline" | "Strong" | "Strikeout" | "Superscript" | "Subscript" | "SmallCaps", readonly Inline[]> | Tagged<"Quoted", readonly ["SingleQuote" | "DoubleQuote", readonly Inline[]]> | Tagged<"Cite", readonly [readonly Citation[], readonly Inline[]]> | Tagged<"Code", readonly [Attr, string]> | Tagged<"Math", readonly ["InlineMath" | "DisplayMath", string]> | Tagged<"RawInline", readonly [string, string]> | Tagged<"Link" | "Image", readonly [Attr, readonly Inline[], Target]> | Tagged<"Note", readonly Block[]> | Tagged<"Span", readonly [Attr, readonly Inline[]]>;
+export interface Citation {
+    readonly citationId: string;
+    readonly citationPrefix: readonly Inline[];
+    readonly citationSuffix: readonly Inline[];
+    readonly citationMode: "AuthorInText" | "SuppressAuthor" | "NormalCitation";
+    readonly citationNoteNum: number;
+    readonly citationHash: number;
+}
+export type Alignment = "AlignLeft" | "AlignRight" | "AlignCenter" | "AlignDefault";
+export type Caption = readonly [readonly Inline[] | null, readonly Block[]];
+export type ColSpec = readonly [Alignment, Empty<"ColWidthDefault"> | Tagged<"ColWidth", number>];
+export type Cell = readonly [Attr, Alignment, number, number, readonly Block[]];
+export type Row = readonly [Attr, readonly Cell[]];
+export type TableHead = readonly [Attr, readonly Row[]];
+export type TableBody = readonly [Attr, number, readonly Row[], readonly Row[]];
+export type Block = Tagged<"Plain" | "Para", readonly Inline[]> | Tagged<"LineBlock", readonly (readonly Inline[])[]> | Tagged<"CodeBlock", readonly [Attr, string]> | Tagged<"RawBlock", readonly [string, string]> | Tagged<"BlockQuote", readonly Block[]> | Tagged<"OrderedList", readonly [
+    readonly [
+        number,
+        ("DefaultStyle" | "Example" | "Decimal" | "LowerRoman" | "UpperRoman" | "LowerAlpha" | "UpperAlpha"),
+        "DefaultDelim" | "Period" | "OneParen" | "TwoParens"
+    ],
+    readonly (readonly Block[])[]
+]> | Tagged<"BulletList", readonly (readonly Block[])[]> | Tagged<"DefinitionList", readonly (readonly [readonly Inline[], readonly (readonly Block[])[]])[]> | Tagged<"Header", readonly [number, Attr, readonly Inline[]]> | Empty<"HorizontalRule"> | Tagged<"Div", readonly [Attr, readonly Block[]]> | Tagged<"Figure", readonly [Attr, Caption, readonly Block[]]> | Tagged<"Table", readonly [Attr, Caption, readonly ColSpec[], TableHead, readonly TableBody[], TableHead]>;
+export type MetaValue = MetaMap | Tagged<"MetaList", readonly MetaValue[]> | Tagged<"MetaBool", boolean> | Tagged<"MetaString", string> | Tagged<"MetaInlines", readonly Inline[]> | Tagged<"MetaBlocks", readonly Block[]>;
+/** Sidecars are never embedded in serialized document data. */
+export interface SourcePosition {
+    readonly path: string;
+    readonly source: string;
+    readonly line: number;
+    readonly column: number;
+}
+export interface LossDiagnostic {
+    readonly path: string;
+    readonly feature: string;
+    readonly message: string;
+}
+export declare function assertNever(value: never): never;
+export interface MetaMap {
+    readonly t: "MetaMap";
+    readonly c: {
+        readonly [key: string]: MetaValue;
+    };
+}
+export {};

package/dist/pandoc/ast.d.ts

@@ -0,0 +1,14 @@
+import type { Document } from "./types.js";
+export { AstError } from "./errors.js";
+export interface AstLimits {
+    readonly depth: number;
+    readonly nodes: number;
+    readonly text: number;
+    readonly attributes: number;
+    readonly tableCells: number;
+    readonly references: number;
+    readonly resourceBytes: number;
+}
+/** Identity normalization retains a bounded owned AST by design. */
+export declare function normalizeDocument(value: unknown, options?: Partial<AstLimits>): Document;
+export declare function normalizeDocumentCooperatively(value: unknown, options: Partial<AstLimits>, cooperate: (units: number) => Promise<void>, reserve?: (key: keyof AstLimits, units: number) => void): Promise<Document>;

package/dist/pandoc/cli.d.ts

@@ -0,0 +1,13 @@
+import type { ConversionOptions, InputSource } from "./types.js";
+export interface CommandInputs {
+    readonly cwd?: string;
+    readonly stdin?: AsyncIterable<Uint8Array> | Iterable<Uint8Array>;
+    readFile?(path: string, signal: AbortSignal): Promise<Uint8Array>;
+    writeFile?(path: string, bytes: Uint8Array, signal: AbortSignal): Promise<void>;
+}
+/** Parsing creates lazy inputs. Only the validated converter may acquire them. */
+export declare function parseConversionArgs(args: readonly string[], files: CommandInputs, signal: AbortSignal): {
+    options: ConversionOptions;
+    operands: readonly InputSource[] | undefined;
+    destination?: string;
+};

package/dist/pandoc/engine.d.ts

@@ -0,0 +1,5 @@
+export { PandocError } from "./errors.js";
+import type { ConversionContext, ConversionOptions, ConversionResult, Document, InputSource, ReadOptions, WriteOptions } from "./types.js";
+export declare function readDocument(input: InputSource, options: ReadOptions, context: ConversionContext): Promise<Document>;
+export declare function writeDocument(document: Document, options: WriteOptions, context: ConversionContext): Promise<ConversionResult>;
+export declare function convert(inputs: readonly InputSource[], options: ConversionOptions, context: ConversionContext): Promise<ConversionResult>;

package/dist/pandoc/errors.d.ts

@@ -0,0 +1,13 @@
+import type { Diagnostic, DiagnosticCode, Operation } from "./types.js";
+export declare class AstError extends Error {
+    readonly code: "E_AST" | "E_LIMIT";
+    readonly path: string;
+    constructor(code: "E_AST" | "E_LIMIT", path: string, message: string);
+}
+export declare class PandocError extends Error implements Diagnostic {
+    readonly code: DiagnosticCode;
+    readonly operation: Operation;
+    readonly format?: string | undefined;
+    readonly location?: string | undefined;
+    constructor(code: DiagnosticCode, operation: Operation, message: string, format?: string | undefined, location?: string | undefined);
+}

package/dist/pandoc/execution.d.ts

@@ -0,0 +1,47 @@
+import type { AdapterContext, ConversionContext, Diagnostic, DiagnosticCode, Limits, Operation } from "./types.js";
+/** Finite hard ceilings; callers may only lower them. No ambient environment settings. */
+export declare const defaultLimits: Limits;
+type Chunks = AsyncIterable<Uint8Array> | Iterable<Uint8Array>;
+export declare class ExecutionContext implements AdapterContext {
+    readonly operation: Operation;
+    readonly context: ConversionContext;
+    readonly limits: Limits;
+    readonly signal: AbortSignal | undefined;
+    readonly resources: AdapterContext["resources"];
+    private readonly usage;
+    private readonly cursors;
+    private readonly notices;
+    private readonly cleanups;
+    private readonly closedSignal;
+    private failure;
+    private closing;
+    private outputComplete;
+    private completingOutput;
+    private outputStarted;
+    private pendingOutput;
+    private sinceYield;
+    constructor(operation: Operation, context: ConversionContext);
+    fail(code: DiagnosticCode, message: string): never;
+    checkpoint(units?: number): void;
+    bound(key: keyof Limits, actual: number): void;
+    charge(key: keyof Limits, units: number): void;
+    remaining(key: keyof Limits): number;
+    cooperate(units?: number): Promise<void>;
+    progress(id: string, cursor: number): void;
+    decodeEntity(code: number): string;
+    /** Decode only parser-selected RTF text runs, never control/binary sections. */
+    decodeCodepage(bytes: Uint8Array, codepage?: 1252 | 28591): Promise<string>;
+    retainBinaryBlock(bytes: Uint8Array): Uint8Array;
+    report(diagnostic: Diagnostic): void;
+    snapshotDiagnostics(): readonly Diagnostic[];
+    /** Cancellation races awaited capabilities; it cannot preempt synchronous host JavaScript. */
+    call<T>(callback: () => Promise<T>): Promise<T>;
+    consume(chunks: Chunks, accept: (bytes: Uint8Array) => Promise<void>, budgets?: readonly (keyof Limits)[]): Promise<void>;
+    acquire(chunks: Chunks, additionalBudget?: keyof Limits): Promise<Uint8Array>;
+    decodeUtf8(chunks: Chunks): Promise<string>;
+    emit(bytes: Uint8Array): Promise<void>;
+    completeOutput(): Promise<void>;
+    close(): Promise<void>;
+}
+export declare function createExecutionContext(operation: Operation, context?: ConversionContext): ExecutionContext;
+export {};

package/dist/pandoc/formats/index.d.ts

@@ -0,0 +1,2 @@
+import type { FormatDescriptor } from "../formats.js";
+export declare const coreFormats: readonly FormatDescriptor[];

package/dist/pandoc/formats.d.ts

@@ -0,0 +1,76 @@
+import type { ConversionContext, Limits, Operation, ReaderCapability, WriterCapability } from "./types.js";
+export { coreFormats } from "./formats/index.js";
+export type Direction = "read" | "write";
+export interface FormatDescriptor {
+    /** Defaults to one operand. Explicit document mode merges ASTs in order. */
+    readonly operands?: "join" | "documents";
+    readonly name: string;
+    readonly aliases?: Partial<Record<Direction, readonly string[]>>;
+    readonly read: boolean;
+    readonly write: boolean;
+    readonly media: "text" | "binary";
+    readonly inputEncoding: "utf8" | "bytes";
+    readonly inputBudget?: keyof Limits;
+    readonly suffixes: readonly string[];
+    readonly extensions: Readonly<Record<string, boolean>>;
+    readonly options: Readonly<Record<Direction, readonly string[]>>;
+    readonly reader?: ReaderCapability;
+    readonly writer?: WriterCapability;
+}
+export interface FormatCapability extends Omit<FormatDescriptor, "read" | "write" | "reader" | "writer"> {
+    readonly read: {
+        readonly allowed: boolean;
+        readonly available: boolean;
+    };
+    readonly write: {
+        readonly allowed: boolean;
+        readonly available: boolean;
+    };
+}
+export interface FormatSelection {
+    readonly descriptor: FormatDescriptor;
+    readonly extensions: Readonly<Record<string, boolean>>;
+}
+export declare function createFormatRegistry(descriptors?: readonly FormatDescriptor[], context?: ConversionContext, operation?: Operation): {
+    parse: (source: string, direction?: Direction) => FormatSelection;
+    resolve(source: string, direction: Direction): {
+        reader: ReaderCapability | undefined;
+        writer: WriterCapability | undefined;
+        descriptor: FormatDescriptor;
+        extensions: Readonly<Record<string, boolean>>;
+    };
+    list(direction: Direction): readonly string[];
+    listExtensions(source: string, direction?: Direction): readonly string[];
+    infer(path: string, direction: Direction): string;
+    validateOptions(source: string, direction: Direction, options: readonly string[]): void;
+    capabilities: readonly Readonly<{
+        read: Readonly<{
+            allowed: boolean;
+            available: boolean;
+        }>;
+        write: Readonly<{
+            allowed: boolean;
+            available: boolean;
+        }>;
+        suffixes: readonly string[];
+        extensions: Readonly<{
+            [x: string]: boolean;
+        }>;
+        options: Readonly<{
+            read: readonly string[];
+            write: readonly string[];
+        }>;
+        aliases?: Readonly<{
+            write?: readonly string[];
+            read?: readonly string[];
+        }>;
+        operands?: "join" | "documents";
+        name: string;
+        media: "text" | "binary";
+        inputEncoding: "utf8" | "bytes";
+        inputBudget?: keyof Limits;
+        reader?: ReaderCapability;
+        writer?: WriterCapability;
+    }>[];
+};
+export declare const formatCapabilities: readonly FormatCapability[];

package/dist/pandoc/index.d.ts

@@ -0,0 +1,14 @@
+export { convert, readDocument, writeDocument, PandocError } from "./engine.js";
+export { createFormatRegistry, coreFormats, formatCapabilities } from "./formats.js";
+export type { FormatCapability, FormatDescriptor, FormatSelection, Direction } from "./formats.js";
+export type { AdapterContext, ConversionContext, ConversionOptions, MetadataObject, MetadataValue, ConversionResult, Diagnostic, DiagnosticCode, Document, Input, InputSource, StreamingInput, Limits, Node, Operation, OutputCapability, StreamingOutputCapability, ReadOptions, ReaderCapability, Resource, ResourceCapability, ResourceFileSystem, SerializedDocument, WriteOptions, PdfOptions, EpubOptions, WriterCapability } from "./types.js";
+export { normalizeDocument, normalizeDocumentCooperatively, AstError } from "./ast.js";
+export { createExecutionContext, ExecutionContext, defaultLimits } from "./execution.js";
+export type { AstLimits } from "./ast.js";
+export { assertNever } from "./ast-types.js";
+export type { Attr, Target, Inline, Block, MetaValue, Citation, Alignment, Caption, ColSpec, Cell, Row, TableHead, TableBody, SourcePosition, LossDiagnostic } from "./ast-types.js";
+export { inspectFormats, inspectCommand } from "./inspection.js";
+export { createFormatInspectionCommand, createPandocCommand } from "./safe-bash.js";
+export type { FormatInspectionContext, PandocCommandContext } from "./safe-bash.js";
+export { parseConversionArgs } from "./cli.js";
+export type { CommandInputs } from "./cli.js";

package/dist/pandoc/inspection.d.ts

@@ -0,0 +1,5 @@
+import type { ConversionContext } from "./types.js";
+/** Information modes are validated without acquiring conversion inputs. */
+export declare function inspectCommand(args: readonly string[], context?: ConversionContext): string | undefined;
+/** SDK counterpart of the three format inspection flags. No input/output I/O. */
+export declare function inspectFormats(args: readonly string[], context?: ConversionContext): string;

package/dist/pandoc/safe-bash.d.ts

@@ -0,0 +1,38 @@
+import type { ConversionContext, ResourceFileSystem } from "./types.js";
+import type { CommandInputs } from "./cli.js";
+/** Structural subset of safe-bash CommandContext: no filesystem or ambient host access. */
+export interface FormatInspectionContext {
+    readonly args: readonly string[];
+    readonly signal: AbortSignal;
+    readonly stdout: {
+        write(bytes: Uint8Array): Promise<void>;
+    };
+    readonly stderr: {
+        write(bytes: Uint8Array): Promise<void>;
+    };
+}
+export interface PandocCommandContext extends FormatInspectionContext, CommandInputs {
+    readonly fs?: ResourceFileSystem & {
+        readFile(path: string, options?: {
+            signal?: AbortSignal;
+        }): Promise<Uint8Array>;
+    };
+    readonly stdin: AsyncIterable<Uint8Array> | Iterable<Uint8Array>;
+}
+/** Opt-in conversion adapter. File access requires explicit injected callbacks;
+ * all conversion and limits belong to the SDK. It never invokes native tools. */
+export declare function createPandocCommand(capabilities?: Omit<ConversionContext, "output" | "signal" | "resources" | "resourceFiles" | "resourceCwd">): {
+    name: string;
+    description: string;
+    execute(context: PandocCommandContext): Promise<{
+        exitCode: number;
+    }>;
+};
+/** Opt-in safe-bash command for registry inspection; conversion command wiring is separate. */
+export declare function createFormatInspectionCommand(capabilities?: ConversionContext): {
+    name: string;
+    description: string;
+    execute(context: FormatInspectionContext): Promise<{
+        exitCode: number;
+    }>;
+};

package/dist/pandoc/types.d.ts

@@ -0,0 +1,229 @@
+import type { FormatSelection } from "./formats.js";
+import type { Block, Inline, MetaValue } from "./ast-types.js";
+import type { PageBox, SuppliedFont } from "../pdf/index.js";
+export type Node = Block | Inline;
+export interface Resource {
+    readonly id: string;
+    readonly bytes: Uint8Array;
+}
+export interface Document {
+    readonly blocks: readonly Block[];
+    readonly metadata: Readonly<Record<string, MetaValue>>;
+    readonly resources: readonly Resource[];
+    readonly language?: string;
+    readonly direction?: "ltr" | "rtl" | "auto";
+}
+export interface Input {
+    readonly source?: string;
+    readonly bytes: Uint8Array;
+    /** Present for UTF-8 formats after per-input BOM/newline normalization. */
+    readonly text?: string;
+    /** VFS source directory for image resolution; source is the diagnostic identity. */
+    readonly base?: string;
+}
+export interface StreamingInput {
+    readonly source?: string;
+    readonly chunks: AsyncIterable<Uint8Array> | Iterable<Uint8Array>;
+    readonly base?: string;
+}
+export type InputSource = Input | StreamingInput;
+export type SerializedDocument = {
+    readonly kind: "text";
+    readonly text: string;
+} | {
+    readonly kind: "binary";
+    readonly bytes: Uint8Array;
+};
+export type ConversionResult = SerializedDocument & {
+    readonly diagnostics: readonly Diagnostic[];
+};
+export type Operation = "read" | "write" | "convert";
+export type DiagnosticCode = "E_FORMAT_REQUIRED" | "E_FORMAT" | "E_EXTENSION" | "E_OPTION" | "E_METADATA" | "E_CAPABILITY" | "E_UNSUPPORTED_FEATURE" | "E_AST" | "E_ENCODING" | "E_PARSE" | "E_LIMIT" | "E_CANCELLED" | "E_IO" | "E_RESOURCE" | "E_INTERNAL" | "E_WARNINGS" | "W_TABLE_LOSS" | "W_PRESENTATION_LOSS" | "W_LAYOUT_UNMEASURED" | "W_RAW_CONTENT" | "W_METADATA_CONFLICT" | "W_RESOURCE_MISSING";
+export interface Diagnostic {
+    readonly code: DiagnosticCode;
+    readonly operation: Operation;
+    readonly message: string;
+    readonly format?: string | undefined;
+    readonly location?: string | undefined;
+}
+export interface Limits {
+    readonly inputBytes: number;
+    readonly resourceBytes: number;
+    readonly outputBytes: number;
+    readonly nodes: number;
+    readonly depth: number;
+    readonly work: number;
+    readonly retainedBytes: number;
+    readonly text: number;
+    readonly attributes: number;
+    readonly tableCells: number;
+    /** Delimited reader ceilings: decoded UTF-16 units per field, records including header, columns. */
+    readonly tableFieldText: number;
+    readonly tableRows: number;
+    readonly tableColumns: number;
+    readonly resources: number;
+    readonly diagnostics: number;
+    readonly references: number;
+    readonly entities: number;
+    readonly entityBytes: number;
+    readonly compressedBytes: number;
+    readonly expandedBytes: number;
+    readonly parts: number;
+    readonly xmlDepth: number;
+    readonly xmlNodes: number;
+    readonly binaryBytes: number;
+    readonly macros: number;
+    readonly includes: number;
+    readonly directives: number;
+    readonly fonts: number;
+    readonly glyphs: number;
+    readonly pages: number;
+    readonly objects: number;
+    readonly images: number;
+    readonly layoutWork: number;
+}
+export interface ReadOptions {
+    readonly from: string;
+}
+export interface PdfOptions {
+    readonly pageSize?: "a4" | "letter";
+    readonly orientation?: "portrait" | "landscape";
+    readonly margin?: number;
+    /** Only mono is currently supplied; other named families fail E_CAPABILITY. */
+    readonly font?: "serif" | "sans" | "mono";
+    readonly fontSize?: number;
+    readonly lineHeight?: number;
+}
+export interface EpubOptions {
+    readonly title?: string;
+    readonly language?: string;
+    readonly identifier?: string;
+    /** Split before headings at this level or shallower; 1 through 6. */
+    readonly chapterLevel?: number;
+}
+export interface WriteOptions {
+    /** Opt into format metadata defaults; absent means strict explicit metadata. */
+    readonly yes?: boolean;
+    readonly pdf?: PdfOptions;
+    readonly epub?: EpubOptions;
+    /** PDF-only geometry in points, equivalent to --pdf-page WIDTH,HEIGHT,MARGIN. */
+    readonly pdfPage?: PageBox;
+    /** Ordered supplied sfnt sources; replaces the packaged font. CLI: repeat --pdf-font PATH. */
+    readonly pdfFonts?: readonly InputSource[];
+    /** Ordered VFS directories, replacing the source-directory search when present. */
+    readonly resourcePath?: readonly string[];
+    /** Extract image resources into this VFS directory; never download media implicitly. */
+    readonly extractMedia?: string;
+    readonly failIfWarnings?: boolean;
+    /** Ordered parsed JSON maps. Later values win; null deletes a key. */
+    readonly metadataJson?: readonly MetadataObject[];
+    /** Explicit JSON inputs only. No ambient files are loaded. */
+    readonly metadataFiles?: readonly InputSource[];
+    readonly wrap?: "none";
+    readonly to: string;
+    readonly standalone?: boolean;
+    readonly metadata?: Readonly<Record<string, MetaValue>>;
+    readonly rawContent?: "reject" | "escape" | "retain";
+    /** Strict by default; explicitly permit diagnosed table text projections. */
+    readonly lossy?: boolean;
+}
+export interface ConversionOptions extends ReadOptions, WriteOptions {
+}
+export interface MetadataObject {
+    readonly [key: string]: MetadataValue;
+}
+export type MetadataValue = string | number | boolean | null | readonly MetadataValue[] | MetadataObject;
+/** Explicit trusted adapters; their format conformance is not established by this seam. */
+export interface AdapterContext {
+    readonly yes?: boolean | undefined;
+    readonly pdf?: PdfOptions | undefined;
+    readonly epub?: EpubOptions | undefined;
+    readonly pdfPage?: PageBox | undefined;
+    readonly pdfFonts?: readonly SuppliedFont[] | undefined;
+    /** Parser origin sidecar; never serialized into the AST. */
+    resourceTarget?(target: object, line: number, origin?: {
+        readonly base?: string;
+        readonly source?: string;
+    }): void;
+    readonly operation?: Operation;
+    readonly lossy?: boolean;
+    readonly standalone?: boolean;
+    readonly rawContent?: "reject" | "escape" | "retain" | undefined;
+    readonly signal: AbortSignal | undefined;
+    readonly limits: Limits;
+    readonly resources: ResourceCapability | undefined;
+    checkpoint(units?: number): void;
+    /** Reserve aggregate capacity before allocating or extending parser/writer data. */
+    charge(key: keyof Limits, units: number): void;
+    /** Check a gauge (e.g. nesting depth) without accumulating it. */
+    bound(key: keyof Limits, actual: number): void;
+    cooperate(units?: number): Promise<void>;
+    decodeUtf8(chunks: AsyncIterable<Uint8Array> | Iterable<Uint8Array>): Promise<string>;
+    /** Reserve entity expansion before constructing its Unicode scalar. */
+    decodeEntity(code: number): string;
+    decodeCodepage(bytes: Uint8Array, codepage?: 1252 | 28591): Promise<string>;
+    retainBinaryBlock(bytes: Uint8Array): Uint8Array;
+    report(diagnostic: Diagnostic): void;
+    /** Strictly advancing cursor for pagination and other iterative layouts. */
+    progress(id: string, cursor: number): void;
+}
+export interface ResourceCapability {
+    resolve(id: string, base: string | undefined, signal: AbortSignal | undefined): Promise<Uint8Array>;
+}
+export interface ReaderCapability {
+    readonly format: string;
+    read(input: Input, context: AdapterContext, selection?: FormatSelection): Promise<Document>;
+}
+export interface WriterCapability {
+    readonly format: string;
+    readonly math?: "source";
+    write(document: Document, context: AdapterContext, selection?: FormatSelection): Promise<SerializedDocument>;
+}
+/** publish must provide atomic publication; it receives owned bytes and must honor cancellation. */
+export interface OutputCapability {
+    publish(bytes: Uint8Array, signal: AbortSignal | undefined): Promise<void>;
+}
+/** Streaming hosts may expose partial output on failure; close must report commit failure. */
+export interface StreamingOutputCapability {
+    write(bytes: Uint8Array, signal: AbortSignal | undefined): Promise<void>;
+    close(signal: AbortSignal | undefined): Promise<void>;
+    abort(reason: unknown): Promise<void>;
+}
+export interface ConversionContext {
+    /** Only this configured filesystem may supply/extract local image resources. */
+    readonly resourceFiles?: ResourceFileSystem;
+    readonly resourceCwd?: string;
+    readonly reader?: ReaderCapability;
+    readonly writer?: WriterCapability;
+    readonly resources?: ResourceCapability;
+    readonly output?: OutputCapability | StreamingOutputCapability;
+    readonly limits?: Partial<Limits>;
+    readonly signal?: AbortSignal;
+    /** Trusted event-loop scheduler, chiefly for deterministic host/test integration. */
+    readonly yield?: () => Promise<void>;
+}
+/** Structural VFS subset. ENOENT alone permits search continuation. Providers
+ * retain authority over their namespace; lexical checks are not a sandbox.
+ * Without provider transactions, completed writes survive later failures. */
+export interface ResourceFileSystem {
+    lstat(path: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<{
+        readonly type: string;
+    }>;
+    readStream?(path: string, options?: {
+        signal?: AbortSignal;
+    }): AsyncIterable<Uint8Array> | Iterable<Uint8Array>;
+    readFile?(path: string, options?: {
+        signal?: AbortSignal;
+        maxBytes?: number;
+    }): Promise<Uint8Array>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    writeFile(path: string, bytes: Uint8Array, options?: {
+        signal?: AbortSignal;
+        flag?: "wx";
+    }): Promise<void>;
+}

package/dist/pdf/default-font.d.ts

@@ -0,0 +1,4 @@
+export declare function suppliedDefaultFont(admit?: (bytes: number) => void): {
+    id: string;
+    bytes: Uint8Array<ArrayBuffer>;
+};

package/dist/pdf/errors.d.ts

@@ -0,0 +1,4 @@
+export declare class PdfError extends Error {
+    readonly code: "E_LIMIT" | "E_CAPABILITY" | "E_CANCELLED";
+    constructor(code: "E_LIMIT" | "E_CAPABILITY" | "E_CANCELLED", message: string);
+}

package/dist/pdf/index.d.ts

@@ -0,0 +1,32 @@
+import type { LayoutDocument, PdfContext, PdfLimits } from "./model.js";
+export type * from "./model.js";
+export { PdfError } from "./errors.js";
+export declare function pdfCapabilities(): {
+    readonly profile: "PDF-1.7-supplied-fonts-ltr";
+    readonly reference: "Adobe PDF Reference sixth edition, November 2006";
+    readonly scripts: readonly ["Latin", "Greek", "Cyrillic"];
+    readonly fonts: readonly ["sfnt-TrueType-glyf"];
+    readonly png: "static-noninterlaced-8bit";
+    readonly jpeg: "8bit-gray-rgb-adobe-cmyk";
+    readonly images: readonly ["png", "jpeg"];
+    readonly tables: "rectangular-unspanned";
+    readonly encryption: false;
+    readonly javascript: false;
+    readonly attachments: false;
+    readonly accessibility: {
+        readonly tagged: false;
+        readonly readingOrder: "not-guaranteed";
+        readonly pdfUA: false;
+    };
+    readonly conformance: {
+        readonly pdfA: false;
+    };
+    readonly text: {
+        readonly unicodeMapping: "supported-scalars";
+        readonly extraction: "not-guaranteed";
+        readonly searchable: "not-guaranteed";
+    };
+};
+export declare const defaultPdfLimits: Readonly<PdfLimits>;
+export declare function renderPdf(document: LayoutDocument, context?: PdfContext): Promise<Uint8Array>;
+export { suppliedDefaultFont } from "./default-font.js";

package/dist/pdf/model.d.ts

@@ -0,0 +1,92 @@
+/** Coordinates and dimensions are PDF points; flow uses top-down placement. */
+export interface PageBox {
+    readonly width: number;
+    readonly height: number;
+    readonly margin: number;
+}
+export interface SuppliedFont {
+    readonly id: string;
+    readonly bytes: Uint8Array;
+}
+export interface TextRun {
+    readonly text: string;
+    readonly font?: string;
+    readonly size?: number;
+    readonly link?: string;
+}
+export interface PaginationConstraints {
+    readonly breakBefore?: boolean;
+    readonly keepTogether?: boolean;
+}
+export interface Paragraph extends PaginationConstraints {
+    /** Optional flat outline entry targeting the first placed line. */
+    readonly outline?: string;
+    readonly kind: "paragraph";
+    readonly runs: readonly TextRun[];
+    readonly spaceAfter?: number;
+    readonly keepWithNext?: boolean;
+    readonly indent?: number;
+    readonly widows?: number;
+    readonly orphans?: number;
+    readonly longWord?: "wrap" | "error";
+}
+export interface ImageBlock extends PaginationConstraints {
+    readonly kind: "image";
+    readonly bytes: Uint8Array;
+    readonly media: "png" | "jpeg";
+    readonly width: number;
+    readonly height: number;
+    readonly fit?: "contain" | "natural";
+}
+/** Rectangular unspanned tables; leading header rows repeat on continuation pages. */
+export interface TableBlock extends PaginationConstraints {
+    readonly kind: "table";
+    readonly rows: readonly (readonly Paragraph[])[];
+    readonly widths: readonly number[];
+    readonly headerRows?: number;
+    readonly rowSplit?: "error" | "lines";
+}
+export type LayoutBlock = Paragraph | ImageBlock | TableBlock;
+export interface PdfMetadata {
+    readonly title?: string;
+    readonly author?: string;
+    readonly subject?: string;
+    readonly keywords?: readonly string[];
+}
+export interface LayoutDocument {
+    readonly metadata?: PdfMetadata;
+    readonly page?: PageBox;
+    readonly lineHeight?: number;
+    readonly fonts: readonly SuppliedFont[];
+    readonly blocks: readonly LayoutBlock[];
+}
+export interface PdfLimits {
+    readonly fontBytes: number;
+    readonly fonts: number;
+    readonly glyphs: number;
+    readonly pages: number;
+    readonly objects: number;
+    readonly images: number;
+    readonly imageBytes: number;
+    readonly decodedImageBytes: number;
+    readonly layoutWork: number;
+    readonly outputBytes: number;
+}
+export interface PdfContext {
+    /** Top-down boxes of emitted content, for consumers inspecting layout. Page is one-based. */
+    readonly onPlacement?: (box: Placement) => void;
+    readonly signal?: AbortSignal | undefined;
+    readonly limits?: Partial<PdfLimits>;
+    /** Called before each admitted allocation/work unit, permitting shared host budgets. */
+    readonly charge?: (key: keyof PdfLimits, amount: number) => void;
+    readonly yield?: () => Promise<void>;
+}
+export interface Placement {
+    readonly kind: "text" | "image" | "cell";
+    readonly page: number;
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+    readonly text?: string;
+}