@oh-my-pi/pi-coding-agent 17.3.3 → 17.3.4

package/src/tools/read.ts

@@ -100,7 +100,7 @@ import {
 	isRemoteMountPath,
 	type SuffixMatchCache,
 } from "./read-path-resolution";
-import { readPdfImageMember, rewritePdfImagePlaceholders, splitPdfImageMemberReadPath } from "./read-pdf-images";
+import { type PdfImageReadTarget, renderPdfPageScreenshot, splitPdfImageReadPath } from "./read-pdf";
 import { isMultiRange, isRawSelector, type ParsedSelector, parseSel, selToOffsetLimit } from "./read-selector";
 import { readSqlite, resolveSqliteReadPath } from "./read-sqlite";
 import { isProseSummaryPath, renderSummary, routeReadThroughBridge, trySummarize } from "./read-summary";
@@ -398,8 +398,13 @@ type ReadParams = ReadToolInput;
  */
 export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 	readonly name = "read";
-	readonly approval = (args: unknown): ToolTier =>
-		pathTargetsSsh(String((args as { path?: unknown }).path ?? "")) ? "exec" : "read";
+	readonly approval = (args: unknown): ToolTier => {
+		let readPath = "";
+		if (args && typeof args === "object" && "path" in args) readPath = String(args.path ?? "");
+		if (pathTargetsSsh(readPath)) return "exec";
+		const target = splitPathAndSel(readPath);
+		return target.sel === undefined && splitPdfImageReadPath(readPath) ? "exec" : "read";
+	};
 	readonly label = "Read";
 	readonly loadMode = "essential";
 	description: string;
@@ -546,6 +551,40 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		return toolResult<ReadToolDetails>({ notes, displayReadTargets }).content(content).done();
 	}
 
+	async #readPdfPageScreenshot(options: {
+		readPath: string;
+		absolutePdfPath: string;
+		page: number;
+		pdfFileSize: number;
+		suffixResolution?: { from: string; to: string };
+		signal?: AbortSignal;
+	}): Promise<AgentToolResult<ReadToolDetails>> {
+		const { readPath, absolutePdfPath, page, pdfFileSize, suffixResolution, signal } = options;
+		const screenshot = await renderPdfPageScreenshot(this.session, absolutePdfPath, page, signal);
+		const screenshotFile = Bun.file(screenshot.dest);
+		const screenshotMetadata = await readImageMetadata(screenshot.dest);
+		const loaded = await this.#loadImageContent({
+			readPath,
+			absolutePath: screenshot.dest,
+			mimeType: screenshot.mimeType,
+			imageMetadata: screenshotMetadata,
+			fileSize: screenshotFile.size,
+		});
+		if (suffixResolution) {
+			const firstText = loaded.content.find((entry): entry is TextContent => entry.type === "text");
+			if (firstText) firstText.text = prependSuffixResolutionNotice(firstText.text, suffixResolution);
+		}
+		const image = loaded.content.find((entry): entry is ImageContent => entry.type === "image");
+		const details: ReadToolDetails = {
+			...loaded.details,
+			resolvedPath: absolutePdfPath,
+			contentType: image?.mimeType ?? screenshot.mimeType,
+			fileSize: pdfFileSize,
+			suffixResolution,
+		};
+		return toolResult(details).content(loaded.content).sourcePath(loaded.sourcePath).done();
+	}
+
 	/**
 	 * Build content blocks for an on-disk image file: an `inspect_image`
 	 * metadata note when inspection is active, otherwise the decoded image
@@ -892,7 +931,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 
 		// Prefer a literal filesystem match over selector interpretation so real
 		// POSIX filenames containing selector-looking suffixes win over structured
-		// archive / sqlite / pdf-image dispatch. A selector promoted from local://
+		// archive / sqlite / unsupported PDF-image dispatch. A selector promoted from local://
 		// remains separate so it cannot be mistaken for part of the resolved path.
 		const literalSplit =
 			promotedSelector === undefined
@@ -903,6 +942,8 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				? readPath.includes(":") && (await probeLiteralPathExists(readPath, this.session.cwd)) !== "missing"
 				: literalSplit.sel === undefined && splitPathAndSel(readPath).sel !== undefined;
 
+		let pdfImageRead: PdfImageReadTarget | null = null;
+
 		if (!rawPathIsLiteral) {
 			const archivePath = await resolveArchiveReadPath(this.session, readPath, suffixCache, signal);
 			if (archivePath) {
@@ -925,39 +966,14 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				return readSqlite(sqlitePath, signal);
 			}
 
-			const pdfImageMemberPath = splitPdfImageMemberReadPath(readPath);
-			if (pdfImageMemberPath) {
-				let absolutePdfPath = resolveReadPath(pdfImageMemberPath.pdfPath, this.session.cwd);
-				let suffixResolution: { from: string; to: string } | undefined;
-				try {
-					const stat = await Bun.file(absolutePdfPath).stat();
-					if (stat.isDirectory())
-						throw new ToolError(`Path '${pdfImageMemberPath.pdfPath}' is a directory, not a PDF file`);
-				} catch (error) {
-					if (!isNotFoundError(error) || isRemoteMountPath(absolutePdfPath)) throw error;
-					const suffixMatch = await findSuffixMatchCached(
-						this.session,
-						suffixCache,
-						pdfImageMemberPath.pdfPath,
-						signal,
-					);
-					if (!suffixMatch) throw new ToolError(`Path '${pdfImageMemberPath.pdfPath}' not found`);
-					absolutePdfPath = suffixMatch.absolutePath;
-					suffixResolution = { from: pdfImageMemberPath.pdfPath, to: suffixMatch.displayPath };
-				}
-				return readPdfImageMember(
-					this.session,
-					this.#autoResizeImages,
-					absolutePdfPath,
-					pdfImageMemberPath.pdfPath,
-					pdfImageMemberPath.member,
-					suffixResolution,
-					signal,
-				);
-			}
+			const pdfCandidate = literalSplit.sel === undefined ? splitPdfImageReadPath(readPath) : null;
+			pdfImageRead =
+				pdfCandidate && (await probeLiteralPathExists(readPath, this.session.cwd)) === "missing"
+					? pdfCandidate
+					: null;
 		}
 
-		const localTarget = literalSplit;
+		const localTarget = pdfImageRead ? { path: pdfImageRead.pdfPath, sel: undefined } : literalSplit;
 		const localReadPath = localTarget.path;
 		const parsed = parseSel(localTarget.sel);
 
@@ -1036,6 +1052,17 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			return this.#readFileConflicts(absolutePath, suffixResolution, signal);
 		}
 
+		if (pdfImageRead) {
+			return this.#readPdfPageScreenshot({
+				readPath,
+				absolutePdfPath: absolutePath,
+				page: pdfImageRead.page,
+				pdfFileSize: fileSize,
+				suffixResolution,
+				signal,
+			});
+		}
+
 		const imageMetadata = await readImageMetadata(absolutePath);
 		const mimeType = imageMetadata?.mimeType;
 		const ext = path.extname(absolutePath).toLowerCase();
@@ -1102,8 +1129,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			// Convert document via markit.
 			const result = await convertFileWithMarkit(absolutePath, signal);
 			if (result.ok) {
-				const renderedContent =
-					ext === ".pdf" ? rewritePdfImagePlaceholders(result.content, resolvedDisplayPath) : result.content;
+				const renderedContent = result.content;
 				// Route the converted markdown through the in-memory text builder
 				// so line-range selectors (`file.pdf:50-100`, `:5-16,40-80`) and
 				// raw mode apply against the converted output. Without this,

package/src/utils/external-editor.ts

@@ -33,6 +33,27 @@ export interface OpenInEditorOptions {
 	trimTrailingNewline?: boolean;
 }
 
+/** Subprocess argv and Windows quoting mode used to launch an external editor. */
+export interface EditorSpawnCommand {
+	cmd: string[];
+	windowsVerbatimArguments: boolean;
+}
+
+/** Resolves shell argv without letting the host runtime re-quote the editor command. */
+export function resolveEditorSpawnCommand(
+	editorCmd: string,
+	tmpFile: string,
+	platform: NodeJS.Platform = process.platform,
+): EditorSpawnCommand {
+	const windows = platform === "win32";
+	// cmd.exe strips the outer /s /c quote pair; Bun must pass the embedded
+	// editor/path quotes verbatim instead of applying argv escaping to them.
+	const cmd = windows
+		? ["cmd.exe", "/d", "/s", "/c", `"${editorCmd} "${tmpFile}""`]
+		: [$which("sh") ?? "sh", "-c", `${editorCmd} "$1"`, "sh", tmpFile];
+	return { cmd, windowsVerbatimArguments: windows };
+}
+
 /**
  * Opens `content` in the user's external editor and returns the edited text.
  * Returns `null` if the editor exits with a non-zero code.
@@ -50,15 +71,13 @@ export async function openInEditor(
 	try {
 		await Bun.write(tmpFile, content);
 
+		const spawnCommand = resolveEditorSpawnCommand(editorCmd, tmpFile);
 		const [stdin, stdout, stderr] = options?.stdio ?? ["inherit", "inherit", "inherit"];
-		const cmd =
-			process.platform === "win32"
-				? ["cmd", "/c", `${editorCmd} "${tmpFile}"`]
-				: [$which("sh") ?? "sh", "-c", `${editorCmd} "$1"`, "sh", tmpFile];
-		const child = Bun.spawn(cmd, {
+		const child = Bun.spawn(spawnCommand.cmd, {
 			stdin,
 			stdout,
 			stderr,
+			windowsVerbatimArguments: spawnCommand.windowsVerbatimArguments,
 		});
 		const exitCode = await child.exited;
 		if (exitCode === 0) {

package/src/utils/markit.ts

@@ -1,5 +1,5 @@
 import * as path from "node:path";
-import { logger, untilAborted } from "@oh-my-pi/pi-utils";
+import { untilAborted } from "@oh-my-pi/pi-utils";
 import type { ConversionResult, Markit, StreamInfo } from "../markit";
 import { ToolAbortError } from "../tools/tool-errors";
 import {
@@ -8,7 +8,6 @@ import {
 	readMarkitConversionCache,
 	writeMarkitConversionCache,
 } from "./markit-cache";
-import { loadEmbeddedMupdfWasm } from "./mupdf-wasm-embed";
 
 /**
  * File extensions markit can actually convert to markdown — one per registered
@@ -31,53 +30,16 @@ export interface MarkitConversionResult {
 
 export interface MarkitFileConversionOptions {
 	/**
-	 * Directory the PDF converter writes extracted images/diagrams into. When
-	 * set, each embedded image is rendered to `<id>.png` and referenced by path
-	 * in the markdown; when unset, markit emits an `<!-- image: <id> ... -->`
-	 * placeholder comment instead.
+	 * Directory converters may use for extracted image or diagram files. Since
+	 * those files are conversion side effects, conversions using this option
+	 * bypass the markdown cache.
 	 */
 	imageDir?: string;
 }
 
-interface MuPdfWasmModuleConfig {
-	print?: (...values: unknown[]) => void;
-	printErr?: (...values: unknown[]) => void;
-	wasmBinary?: Uint8Array;
-}
-
-function logMuPdfWasmOutput(stream: "stdout" | "stderr", values: unknown[]): void {
-	const message = values.length === 1 && typeof values[0] === "string" ? values[0] : values.map(String).join(" ");
-	logger.debug("mupdf wasm output", { stream, message });
-}
-
-// `$libmupdf_wasm_Module` is declared globally (as `any`) by the mupdf package.
-// Install print hooks before the WASM module initializes so its stdout/stderr
-// route to the file logger instead of corrupting the TUI.
-function installMuPdfWasmLogger(): void {
-	const moduleConfig: MuPdfWasmModuleConfig = globalThis.$libmupdf_wasm_Module ?? {};
-	moduleConfig.print = (...values: unknown[]) => logMuPdfWasmOutput("stdout", values);
-	moduleConfig.printErr = (...values: unknown[]) => logMuPdfWasmOutput("stderr", values);
-	globalThis.$libmupdf_wasm_Module = moduleConfig;
-}
-
-// Hand the WASM module its bytes directly when the compiled binary embedded them
-// (scripts/embed-mupdf-wasm.ts); a single-file binary has no node_modules for
-// mupdf to read `mupdf-wasm.wasm` from. Source/npm builds get undefined here and
-// mupdf loads its own wasm. Must run before the mupdf module evaluates.
-function installEmbeddedMupdfWasm(): void {
-	const wasmBinary = loadEmbeddedMupdfWasm();
-	if (!wasmBinary) return;
-	const moduleConfig: MuPdfWasmModuleConfig = globalThis.$libmupdf_wasm_Module ?? {};
-	moduleConfig.wasmBinary = wasmBinary;
-	globalThis.$libmupdf_wasm_Module = moduleConfig;
-}
-
-installMuPdfWasmLogger();
-
 let markit: () => Markit | Promise<Markit> = async () => {
-	// Lazy: keep the document engine (mammoth/mupdf) off the startup
-	// import graph — it loads only when a document is first converted.
-	installEmbeddedMupdfWasm();
+	// Lazy: keep the document engine off the startup import graph — it loads
+	// only when a document is first converted.
 	const promise = import("../markit").then(({ Markit }) => {
 		const instance = new Markit();
 		markit = () => instance;

package/dist/types/markit/converters/pdf/columns.d.ts

@@ -1,35 +0,0 @@
-/**
- * Multi-column layout detection and text box reordering.
- *
- * Many PDFs (legal documents, datasheets, academic papers) use two-column
- * layouts. Without column detection, text boxes are ordered by Y position
- * only, interleaving left and right column content.
- *
- * Algorithm:
- *   1. Collect left edges of all text boxes on the page
- *   2. Find the largest horizontal gap between consecutive left edges
- *   3. If gap > MIN_GAP_RATIO of the text width and both sides have
- *      enough boxes → multi-column detected
- *   4. Assign each text box to a column based on its center X
- *   5. Return columns in reading order (left-to-right, top-to-bottom)
- *
- * This only detects the column structure. The caller is responsible for
- * processing each column's text boxes independently (table detection,
- * rendering, etc.).
- */
-import type { TextBox } from "./types.js";
-export interface ColumnLayout {
-    /** Number of columns detected (1 = single column, 2+ = multi-column). */
-    columnCount: number;
-    /** Text boxes grouped by column, in reading order (left to right). */
-    columns: TextBox[][];
-    /** X positions of column boundaries (between columns). */
-    boundaries: number[];
-}
-/**
- * Detect column layout and return text boxes grouped by column.
- *
- * For single-column pages, returns all boxes in one group.
- * For multi-column pages, returns boxes split by column in reading order.
- */
-export declare function detectColumns(textBoxes: TextBox[]): ColumnLayout;

package/dist/types/markit/converters/pdf/extract.d.ts

@@ -1,10 +0,0 @@
-import type { ImageRegion, PageContent } from "./types.js";
-/**
- * Render an image region from a PDF page as a PNG buffer.
- * Uses mupdf's DrawDevice to render just the cropped area at 2x resolution.
- */
-export declare function renderImageRegion(input: Uint8Array, region: ImageRegion): Promise<Uint8Array>;
-/**
- * Extract text boxes and vector segments from all pages of a PDF buffer.
- */
-export declare function extractPages(input: Uint8Array): Promise<PageContent[]>;

package/dist/types/markit/converters/pdf/grid.d.ts

@@ -1,25 +0,0 @@
-/**
- * Table grid detection from vector segments and text boxes.
- *
- * Ported from @oharato/pdf2md-ts with TypeScript types and without
- * CJK-specific borderless table heuristics. The core algorithm:
- *
- * 1. Classify segments as horizontal or vertical lines
- * 2. Group horizontal Y-lines into table groups (split by vertical gaps)
- * 3. For each group:
- *    a. Full grid (H+V lines): build cells from grid intersections,
- *       place text via raycasting
- *    b. H-line only (no V lines): infer columns from text X positions
- * 4. Prune empty rows/cols
- *
- * Coordinate system: PDF native (bottom-left origin, Y increases upward).
- */
-import type { Segment, TableGrid, TextBox } from "./types.js";
-export interface GridResult {
-    grids: TableGrid[];
-    consumedIds: string[];
-}
-/**
- * Detect all table grids on a single page from its text boxes and segments.
- */
-export declare function resolveTableGrids(pageNumber: number, textBoxes: TextBox[], segments: Segment[]): GridResult;

package/dist/types/markit/converters/pdf/headers.d.ts

@@ -1,24 +0,0 @@
-/**
- * Running header/footer detection and removal.
- *
- * Many PDFs have repeated text at the top or bottom of every page:
- * document titles, chapter names, page numbers, copyright notices.
- * These pollute the markdown output as false headings or noise.
- *
- * Algorithm:
- *   1. For each page, bucket text boxes by Y position (top/bottom zones)
- *   2. Collect the text content at each zone across all pages
- *   3. Text appearing on >20% of pages OR 8+ consecutive pages is a
- *      running header/footer
- *   4. Remove matching text boxes before further processing
- */
-import type { PageContent } from "./types.js";
-/**
- * Detect and remove running headers and footers from all pages.
- * Mutates the pages array in place, removing header/footer text boxes.
- *
- * Uses two strategies:
- *   1. Global frequency: text appearing on > 20% of all pages
- *   2. Consecutive runs: text appearing on 8+ consecutive pages
- */
-export declare function stripHeadersFooters(pages: PageContent[]): void;

package/dist/types/markit/converters/pdf/render.d.ts

@@ -1,24 +0,0 @@
-/**
- * Markdown rendering for PDF pages.
- *
- * Converts table grids and free text boxes into markdown, handling:
- * - Table grid → markdown table (`| col | col |`)
- * - Free text → paragraphs with heading detection (by font size)
- * - Content ordering (top-to-bottom via Y coordinate)
- * - Paragraph wrap merging (lines broken across PDF line boundaries)
- * - Page number removal
- *
- * Ported from @oharato/pdf2md-ts, stripped of CJK/TDnet-specific logic.
- */
-import type { TableGrid, TextBox } from "./types.js";
-/**
- * Render a TableGrid as a markdown table.
- */
-export declare function renderTableToMarkdown(table: TableGrid): string;
-/**
- * Render one page's content: free text and tables interleaved top-to-bottom.
- */
-export declare function renderPageContent(freeTextBoxes: TextBox[], tables: TableGrid[], imageBlocks?: Array<{
-    topY: number;
-    markdown: string;
-}>, allTextBoxes?: TextBox[]): string;

package/dist/types/markit/converters/pdf/types.d.ts

@@ -1,75 +0,0 @@
-/** Bounding box in PDF coordinate space (origin = bottom-left). */
-export type Bounds = {
-    left: number;
-    right: number;
-    /** Higher value = higher on the page. */
-    top: number;
-    bottom: number;
-};
-/** A text fragment with position and font metadata. */
-export type TextBox = {
-    id: string;
-    text: string;
-    bounds: Bounds;
-    pageNumber: number;
-    /** Dominant font size in points. */
-    fontSize: number;
-    /** True if rendered bold (font name or rendering mode). */
-    isBold: boolean;
-};
-/** A horizontal or vertical line segment extracted from vector graphics. */
-export type Segment = {
-    id: string;
-    x1: number;
-    y1: number;
-    x2: number;
-    y2: number;
-};
-/** A single cell in a resolved table grid. */
-export type TableCell = {
-    row: number;
-    col: number;
-    text: string;
-    rowSpan: number;
-    colSpan: number;
-};
-/** A resolved table grid ready for markdown rendering. */
-export type TableGrid = {
-    pageNumber: number;
-    rows: number;
-    cols: number;
-    cells: TableCell[];
-    warnings: string[];
-    /** Top Y coordinate (PDF space: larger = higher on page). */
-    topY: number;
-    /** True for tables detected without vector borders. */
-    isBorderless: boolean;
-};
-/** An image/diagram region detected on a page. */
-export type ImageRegion = {
-    id: string;
-    pageNumber: number;
-    /** Bounding box in mupdf coordinates (top-left origin). */
-    bbox: {
-        x: number;
-        y: number;
-        w: number;
-        h: number;
-    };
-    /** Y position in PDF coordinates (bottom-left) for ordering. */
-    topY: number;
-};
-/** Result of extracting content from a single PDF page. */
-export type PageContent = {
-    pageNumber: number;
-    textBoxes: TextBox[];
-    segments: Segment[];
-    images: ImageRegion[];
-};
-/** A block of rendered content (text paragraph or table). */
-export type ContentBlock = {
-    topY: number;
-    content: string;
-    /** True if this line has wide gaps between text boxes (column headers). */
-    isTabular?: boolean;
-};

package/dist/types/tools/read-pdf-images.d.ts

@@ -1,12 +0,0 @@
-import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import type { ToolSession } from "../sdk.js";
-import type { ReadToolDetails } from "./read.js";
-export declare function rewritePdfImagePlaceholders(markdown: string, pdfPath: string): string;
-export declare function splitPdfImageMemberReadPath(readPath: string): {
-    pdfPath: string;
-    member: string;
-} | null;
-export declare function readPdfImageMember(session: ToolSession, autoResizeImages: boolean, absolutePdfPath: string, pdfDisplayPath: string, member: string, suffixResolution: {
-    from: string;
-    to: string;
-} | undefined, signal?: AbortSignal): Promise<AgentToolResult<ReadToolDetails>>;

package/dist/types/utils/mupdf-wasm-embed.d.ts

@@ -1 +0,0 @@
-export declare function loadEmbeddedMupdfWasm(): Uint8Array | undefined;

package/scripts/embed-mupdf-wasm.ts

@@ -1,67 +0,0 @@
-#!/usr/bin/env bun
-
-// Embeds mupdf's `mupdf-wasm.wasm` into the compiled single-file binary.
-//
-// mupdf loads its wasm by reading the `mupdf-wasm.wasm` sibling of its own
-// module via `new URL(..., import.meta.url)` + `readFileSync`. A `bun --compile`
-// binary has no node_modules, so that read fails (`ENOENT .../mupdf-wasm.wasm`),
-// and marking mupdf `--external` instead makes `bun --compile` eagerly fail to
-// resolve the package at startup (the static `import * as mupdf` lives in a lazy
-// chunk but is hoisted). So the binary build bundles mupdf and embeds the wasm
-// bytes here, handing them to the WASM module as `$libmupdf_wasm_Module.wasmBinary`
-// (see src/utils/markit.ts).
-//
-// `--generate` copies the wasm next to src/utils/mupdf-wasm-embed.ts and rewrites
-// that module to import it via `with { type: "file" }`; `--reset` restores the
-// checked-in placeholder and removes the copy. The npm `dist/cli.js` bundle never
-// runs this — it keeps mupdf external and loads the wasm from node_modules.
-
-import * as fs from "node:fs/promises";
-import { createRequire } from "node:module";
-import * as path from "node:path";
-
-const utilsDir = path.join(import.meta.dir, "..", "src", "utils");
-const helperPath = path.join(utilsDir, "mupdf-wasm-embed.ts");
-const wasmCopyPath = path.join(utilsDir, "mupdf-wasm.wasm");
-
-const placeholder = `// AUTOGENERATED -- managed by scripts/embed-mupdf-wasm.ts. Do not edit by hand.
-//
-// Compiled single-file binaries cannot let mupdf resolve its \`mupdf-wasm.wasm\`
-// sibling from the read-only bunfs, so the binary build (scripts/build-binary.ts
-// and scripts/ci-release-build-binaries.ts) regenerates this module to embed the
-// wasm bytes via \`with { type: "file" }\` and copies the wasm next to it. Source
-// checkouts, \`bun test\`, and the npm \`dist/cli.js\` bundle keep mupdf external and
-// load the wasm from node_modules, so this placeholder returns undefined and the
-// build resets back to it afterward.
-export function loadEmbeddedMupdfWasm(): Uint8Array | undefined {
-\treturn undefined;
-}
-`;
-
-const generated = `// AUTOGENERATED -- managed by scripts/embed-mupdf-wasm.ts. Do not edit or commit.
-import { readFileSync } from "node:fs";
-import wasmPath from "./mupdf-wasm.wasm" with { type: "file" };
-
-export function loadEmbeddedMupdfWasm(): Uint8Array | undefined {
-\treturn readFileSync(wasmPath);
-}
-`;
-
-if (process.argv.includes("--reset")) {
-	await Bun.write(helperPath, placeholder);
-	try {
-		await fs.unlink(wasmCopyPath);
-	} catch (err) {
-		if ((err as NodeJS.ErrnoException).code !== "ENOENT") throw err;
-	}
-	process.exit(0);
-}
-
-const wasmSource = path.join(path.dirname(createRequire(import.meta.url).resolve("mupdf")), "mupdf-wasm.wasm");
-const wasmFile = Bun.file(wasmSource);
-if (!(await wasmFile.exists())) {
-	throw new Error(`mupdf wasm not found at ${wasmSource}; run \`bun install\` first.`);
-}
-await Bun.write(wasmCopyPath, wasmFile);
-await Bun.write(helperPath, generated);
-console.log(`Embedded mupdf wasm (${wasmFile.size} bytes) into ${path.relative(process.cwd(), wasmCopyPath)}`);

package/src/markit/converters/pdf/columns.ts

@@ -1,103 +0,0 @@
-// Adapted from markit-ai (MIT). See ../../NOTICE.
-
-/**
- * Multi-column layout detection and text box reordering.
- *
- * Many PDFs (legal documents, datasheets, academic papers) use two-column
- * layouts. Without column detection, text boxes are ordered by Y position
- * only, interleaving left and right column content.
- *
- * Algorithm:
- *   1. Collect left edges of all text boxes on the page
- *   2. Find the largest horizontal gap between consecutive left edges
- *   3. If gap > MIN_GAP_RATIO of the text width and both sides have
- *      enough boxes → multi-column detected
- *   4. Assign each text box to a column based on its center X
- *   5. Return columns in reading order (left-to-right, top-to-bottom)
- *
- * This only detects the column structure. The caller is responsible for
- * processing each column's text boxes independently (table detection,
- * rendering, etc.).
- */
-import type { TextBox } from "./types";
-
-export interface ColumnLayout {
-	/** Number of columns detected (1 = single column, 2+ = multi-column). */
-	columnCount: number;
-	/** Text boxes grouped by column, in reading order (left to right). */
-	columns: TextBox[][];
-	/** X positions of column boundaries (between columns). */
-	boundaries: number[];
-}
-
-/**
- * Minimum gap as a fraction of the total text width to consider a column
- * boundary. A two-column layout typically has ~50% gap; we use a lower
- * threshold to catch asymmetric columns.
- */
-const MIN_GAP_RATIO = 0.15;
-/** Minimum number of text boxes on each side of the gap. */
-const MIN_BOXES_PER_COLUMN = 4;
-/** Minimum gap in absolute points to avoid splitting on small whitespace. */
-const MIN_GAP_PTS = 40;
-
-/**
- * Detect column layout and return text boxes grouped by column.
- *
- * For single-column pages, returns all boxes in one group.
- * For multi-column pages, returns boxes split by column in reading order.
- */
-export function detectColumns(textBoxes: TextBox[]): ColumnLayout {
-	if (textBoxes.length < MIN_BOXES_PER_COLUMN * 2) {
-		return { columnCount: 1, columns: [textBoxes], boundaries: [] };
-	}
-	// Collect unique left edges (rounded to avoid float noise)
-	const lefts = [...new Set(textBoxes.map(tb => Math.round(tb.bounds.left)))].sort((a, b) => a - b);
-	if (lefts.length < 2) {
-		return { columnCount: 1, columns: [textBoxes], boundaries: [] };
-	}
-	const textXMin = lefts[0];
-	const textXMax = Math.max(...textBoxes.map(tb => Math.round(tb.bounds.right)));
-	const textWidth = textXMax - textXMin;
-	if (textWidth <= 0) {
-		return { columnCount: 1, columns: [textBoxes], boundaries: [] };
-	}
-	// Find the largest gap between consecutive left-edge positions
-	let maxGap = 0;
-	let gapLeft = 0;
-	let gapRight = 0;
-	for (let i = 1; i < lefts.length; i++) {
-		const gap = lefts[i] - lefts[i - 1];
-		if (gap > maxGap) {
-			maxGap = gap;
-			gapLeft = lefts[i - 1];
-			gapRight = lefts[i];
-		}
-	}
-	const gapRatio = maxGap / textWidth;
-	if (gapRatio < MIN_GAP_RATIO || maxGap < MIN_GAP_PTS) {
-		return { columnCount: 1, columns: [textBoxes], boundaries: [] };
-	}
-	// Split point is the midpoint of the gap
-	const splitX = (gapLeft + gapRight) / 2;
-	// Assign boxes to columns based on center X
-	const leftCol: TextBox[] = [];
-	const rightCol: TextBox[] = [];
-	for (const tb of textBoxes) {
-		const cx = (tb.bounds.left + tb.bounds.right) / 2;
-		if (cx < splitX) {
-			leftCol.push(tb);
-		} else {
-			rightCol.push(tb);
-		}
-	}
-	// Validate both columns have enough content
-	if (leftCol.length < MIN_BOXES_PER_COLUMN || rightCol.length < MIN_BOXES_PER_COLUMN) {
-		return { columnCount: 1, columns: [textBoxes], boundaries: [] };
-	}
-	return {
-		columnCount: 2,
-		columns: [leftCol, rightCol],
-		boundaries: [splitX],
-	};
-}