@roj-ai/sdk 0.1.36 → 0.2.1

package/src/plugins/uploads/preprocessor.ts

@@ -9,6 +9,8 @@
  */
 
 import type { FileStore } from '~/core/file-store/types.js'
+import type { InferenceContext } from '~/core/llm/provider.js'
+import type { ArchiveBudget } from '~/lib/archive/index.js'
 import type { Result } from '~/lib/utils/result.js'
 
 // ============================================================================
@@ -21,6 +23,29 @@ import type { Result } from '~/lib/utils/result.js'
 export interface PreprocessorContext {
 	/** FileStore scoped to upload directory for writing derived files */
 	files: FileStore
+	/**
+	 * Cancels subprocesses, inference calls, and derived-file generation.
+	 * Implementations should settle promptly; the host stops awaiting after a bounded grace period.
+	 */
+	signal?: AbortSignal
+	/** Optional metadata required to pass cancellation through LLM providers. */
+	inferenceContext?: Omit<InferenceContext, 'signal'>
+	/** Shared extraction budget for all ZIPs nested within one upload. */
+	archiveBudget?: ArchiveBudget
+}
+
+const NEVER_ABORTED_SIGNAL = new AbortController().signal
+
+export function getPreprocessingSignal(ctx: PreprocessorContext): AbortSignal {
+	return ctx.signal ?? NEVER_ABORTED_SIGNAL
+}
+
+export function preprocessingAbortError(signal: AbortSignal): Error {
+	return signal.reason instanceof Error ? signal.reason : new Error('Processing cancelled')
+}
+
+export function throwIfPreprocessingAborted(signal: AbortSignal): void {
+	if (signal.aborted) throw preprocessingAbortError(signal)
 }
 
 // ============================================================================

package/src/plugins/uploads/preprocessors/image-classifier.ts

@@ -13,7 +13,14 @@ import type { Result } from '~/lib/utils/result.js'
 import { Err, Ok } from '~/lib/utils/result.js'
 import type { FileSystem } from '~/platform/fs.js'
 import type { Logger } from '../../../lib/logger/logger.js'
-import type { Preprocessor, PreprocessorContext, PreprocessorResult } from '../preprocessor.js'
+import {
+	getPreprocessingSignal,
+	preprocessingAbortError,
+	throwIfPreprocessingAborted,
+	type Preprocessor,
+	type PreprocessorContext,
+	type PreprocessorResult,
+} from '../preprocessor.js'
 
 /**
  * Anthropic vision API internally downsamples images to ~1568px long side.
@@ -92,7 +99,9 @@ export class ImageClassifierPreprocessor implements Preprocessor {
 		ctx: PreprocessorContext,
 	): Promise<Result<PreprocessorResult, Error>> {
 		const totalStart = Date.now()
+		const signal = getPreprocessingSignal(ctx)
 		try {
+			throwIfPreprocessingAborted(signal)
 			// Check + stat image file
 			if (!(await this.fs.exists(filePath))) {
 				return Err(new Error(`Image file not found: ${filePath}`))
@@ -110,11 +119,12 @@ export class ImageClassifierPreprocessor implements Preprocessor {
 
 			// Try vision inference
 			const inferenceStart = Date.now()
-			const description = await this.describeImage(filePath, mimeType)
+			const description = await this.describeImage(filePath, mimeType, ctx, signal)
 			const inferenceDurationMs = Date.now() - inferenceStart
 
 			if (description) {
 				// Save description to file
+				throwIfPreprocessingAborted(signal)
 				const writeResult = await ctx.files.write('description.txt', description)
 
 				this.logger.info('Image described successfully', {
@@ -143,6 +153,7 @@ export class ImageClassifierPreprocessor implements Preprocessor {
 				extractedContent: `[Image: ${filename}, ${this.formatSize(size)}, ${mimeType}]`,
 			})
 		} catch (error) {
+			if (signal.aborted) return Err(preprocessingAbortError(signal))
 			this.logger.error(
 				'Image classification failed',
 				error instanceof Error ? error : undefined,
@@ -164,34 +175,42 @@ export class ImageClassifierPreprocessor implements Preprocessor {
 	private async describeImage(
 		filePath: string,
 		mimeType: string,
+		ctx: PreprocessorContext,
+		signal: AbortSignal,
 	): Promise<string | null> {
 		try {
-			const { url: imageUrl, cleanup } = await this.prepareImageUrl(filePath, mimeType)
+			const { url: imageUrl, cleanup } = await this.prepareImageUrl(filePath, mimeType, signal)
 
 			try {
-				const inferenceCall = () => this.llmProvider.inference({
-					model: this.visionModel,
-					systemPrompt: 'You are an image description assistant. Describe images concisely in 1-2 sentences.',
-					messages: [
-						{
-							role: 'user',
-							content: [
-								{
-									type: 'text',
-									text: 'Please describe this image concisely in 1-2 sentences. Focus on the main subject and any text visible.',
-								},
-								{
-									type: 'image_url',
-									imageUrl: { url: imageUrl },
-								},
-							],
-						},
-					],
-					maxTokens: 200,
-					temperature: 0.3,
-				})
+				const inferenceCall = () => {
+					throwIfPreprocessingAborted(signal)
+					return this.llmProvider.inference({
+						model: this.visionModel,
+						systemPrompt: 'You are an image description assistant. Describe images concisely in 1-2 sentences.',
+						messages: [
+							{
+								role: 'user',
+								content: [
+									{
+										type: 'text',
+										text: 'Please describe this image concisely in 1-2 sentences. Focus on the main subject and any text visible.',
+									},
+									{
+										type: 'image_url',
+										imageUrl: { url: imageUrl },
+									},
+								],
+							},
+						],
+						maxTokens: 200,
+						temperature: 0.3,
+					}, ctx.inferenceContext ? {
+						...ctx.inferenceContext,
+						signal,
+					} : undefined)
+				}
 
-				const result = await (this.gate ? this.gate.run(inferenceCall) : inferenceCall())
+				const result = await (this.gate ? this.gate.run(inferenceCall, signal) : inferenceCall())
 
 				if (result.ok && result.value.content) {
 					return result.value.content.trim()
@@ -202,6 +221,7 @@ export class ImageClassifierPreprocessor implements Preprocessor {
 				await cleanup()
 			}
 		} catch (error) {
+			if (signal.aborted) throw preprocessingAbortError(signal)
 			this.logger.warn('Vision inference failed', {
 				error: error instanceof Error ? error.message : String(error),
 			})
@@ -221,17 +241,24 @@ export class ImageClassifierPreprocessor implements Preprocessor {
 	private async prepareImageUrl(
 		filePath: string,
 		mimeType: string,
+		signal: AbortSignal,
 	): Promise<{ url: string; cleanup: () => Promise<void> }> {
+		throwIfPreprocessingAborted(signal)
 		if (!this.imageResizer) {
 			return { url: `file://${filePath}`, cleanup: async () => {} }
 		}
 
+		let resizedTempFile: string | undefined
 		try {
 			const resized = await this.imageResizer.resize(filePath, mimeType, {
 				maxDimension: CLASSIFY_MAX_DIMENSION,
 				maxFileSizeBytes: CLASSIFY_MAX_FILE_SIZE_BYTES,
+				signal,
 			})
+			resizedTempFile = resized.tempFile
+			throwIfPreprocessingAborted(signal)
 			const buffer = await this.fs.readFile(resized.path)
+			throwIfPreprocessingAborted(signal)
 			const base64 = buffer.toString('base64')
 			return {
 				url: `data:${resized.mimeType};base64,${base64}`,
@@ -242,6 +269,10 @@ export class ImageClassifierPreprocessor implements Preprocessor {
 				},
 			}
 		} catch (error) {
+			if (resizedTempFile) {
+				await this.fs.unlink(resizedTempFile).catch(() => {})
+			}
+			if (signal.aborted) throw preprocessingAbortError(signal)
 			this.logger.warn('Pre-resize for classification failed, falling back to file:// URL', {
 				filePath,
 				error: error instanceof Error ? error.message : String(error),

package/src/plugins/uploads/preprocessors/markitdown-preprocessor.ts

@@ -23,7 +23,15 @@ import type { FileSystem } from '~/platform/fs.js'
 import type { ProcessRunner } from '~/platform/process.js'
 import type { FileStore } from '../../../core/file-store/types.js'
 import type { Logger } from '../../../lib/logger/logger.js'
-import type { Preprocessor, PreprocessorContext, PreprocessorRegistry, PreprocessorResult } from '../preprocessor.js'
+import {
+	getPreprocessingSignal,
+	preprocessingAbortError,
+	throwIfPreprocessingAborted,
+	type Preprocessor,
+	type PreprocessorContext,
+	type PreprocessorRegistry,
+	type PreprocessorResult,
+} from '../preprocessor.js'
 
 const MAX_IMAGES = 20
 const IMAGE_CLASSIFY_CONCURRENCY = 10
@@ -49,8 +57,8 @@ const MARKITDOWN_TIMEOUT_MS = 60_000
 const IMAGE_EXTRACT_TIMEOUT_MS = 5 * 60_000
 
 function makeExec(processRunner: ProcessRunner) {
-	return (cmd: string, args: string[], timeoutMs: number = MARKITDOWN_TIMEOUT_MS) =>
-		processRunner.execFile(cmd, args, { timeout: timeoutMs, maxBuffer: 50 * 1024 * 1024 })
+	return (cmd: string, args: string[], timeoutMs: number = MARKITDOWN_TIMEOUT_MS, signal?: AbortSignal) =>
+		processRunner.execFile(cmd, args, { timeout: timeoutMs, maxBuffer: 50 * 1024 * 1024, signal })
 }
 
 /** MIME types where markitdown converts to markdown (non-ZIP, non-image, non-PDF) */
@@ -97,7 +105,7 @@ export class MarkitdownPreprocessor implements Preprocessor {
 	private readonly logger: Logger
 	private readonly fs: FileSystem
 	private readonly processRunner: ProcessRunner
-	private readonly exec: (cmd: string, args: string[], timeoutMs?: number) => Promise<{ stdout: string; stderr: string }>
+	private readonly exec: (cmd: string, args: string[], timeoutMs?: number, signal?: AbortSignal) => Promise<{ stdout: string; stderr: string }>
 
 	constructor(config: MarkitdownPreprocessorConfig) {
 		this.registry = config.registry
@@ -113,10 +121,12 @@ export class MarkitdownPreprocessor implements Preprocessor {
 		ctx: PreprocessorContext,
 	): Promise<Result<PreprocessorResult, Error>> {
 		const totalStart = Date.now()
+		const signal = getPreprocessingSignal(ctx)
+		throwIfPreprocessingAborted(signal)
 
 		this.logger.info('Markitdown processing started', { filePath, mimeType })
 
-		const contentPathResult = ctx.files.realPath('content.md')
+		const contentPathResult = await ctx.files.containedPath('content.md')
 		if (!contentPathResult.ok) {
 			return Err(new Error('Failed to resolve output path'))
 		}
@@ -126,12 +136,13 @@ export class MarkitdownPreprocessor implements Preprocessor {
 		// independent, so there's no reason to serialize them. For documents
 		// where pandoc extraction isn't applicable, the image task resolves
 		// immediately.
-		const markdownTask = this.runMarkitdown(filePath, mimeType, contentPathResult.value)
+		const markdownTask = this.runMarkitdown(filePath, mimeType, contentPathResult.value, signal)
 		const imageTask = PANDOC_EXTRACT_MIMES.has(mimeType)
-			? this.extractImagesWithPandoc(filePath, mimeType, ctx)
+			? this.extractImagesWithPandoc(filePath, mimeType, ctx, signal)
 			: Promise.resolve<Array<{ relativePath: string; description: string }>>([])
 
 		const [markdownResult, images] = await Promise.all([markdownTask, imageTask])
+		if (signal.aborted) return Err(preprocessingAbortError(signal))
 
 		if (!markdownResult.ok) return markdownResult
 
@@ -166,11 +177,13 @@ export class MarkitdownPreprocessor implements Preprocessor {
 		filePath: string,
 		mimeType: string,
 		outputPath: string,
+		signal: AbortSignal,
 	): Promise<Result<string, Error>> {
 		const markitdownStart = Date.now()
 		try {
-			await this.exec('markitdown', [filePath, '-o', outputPath])
+			await this.exec('markitdown', [filePath, '-o', outputPath], MARKITDOWN_TIMEOUT_MS, signal)
 		} catch (error) {
+			if (signal.aborted) return Err(preprocessingAbortError(signal))
 			const message = error instanceof Error ? error.message : String(error)
 			this.logger.error(
 				'markitdown CLI failed',
@@ -182,6 +195,7 @@ export class MarkitdownPreprocessor implements Preprocessor {
 			}
 			return Err(new Error(`markitdown failed: ${message}`))
 		}
+		if (signal.aborted) return Err(preprocessingAbortError(signal))
 
 		let markdown = ''
 		try {
@@ -204,9 +218,11 @@ export class MarkitdownPreprocessor implements Preprocessor {
 		filePath: string,
 		mimeType: string,
 		ctx: PreprocessorContext,
+		signal: AbortSignal,
 	): Promise<Array<{ relativePath: string; description: string }>> {
+		if (signal.aborted) return []
 		const mediaStore = ctx.files.scoped('media')
-		const mediaDirResult = mediaStore.realPath('')
+		const mediaDirResult = await mediaStore.containedPath('')
 		if (!mediaDirResult.ok) return []
 
 		const format = PANDOC_FORMAT_MAP[mimeType]
@@ -219,8 +235,10 @@ export class MarkitdownPreprocessor implements Preprocessor {
 				'pandoc',
 				['-f', format, '-t', 'gfm', filePath, '-o', '/dev/null', `--extract-media=${mediaDirResult.value}`],
 				IMAGE_EXTRACT_TIMEOUT_MS,
+				signal,
 			)
 		} catch (error) {
+			if (signal.aborted) return []
 			extractSucceeded = false
 			this.logger.warn('pandoc --extract-media failed (will classify any partial output)', {
 				filePath,
@@ -228,6 +246,7 @@ export class MarkitdownPreprocessor implements Preprocessor {
 				error: error instanceof Error ? error.message : String(error),
 			})
 		}
+		if (signal.aborted) return []
 		if (extractSucceeded) {
 			this.logger.info('pandoc --extract-media complete', {
 				filePath,
@@ -302,12 +321,13 @@ export function shouldClassifyImage(meta: { width: number; height: number; sizeB
 export async function getImageDimensions(
 	filePath: string,
 	processRunner: ProcessRunner,
+	signal?: AbortSignal,
 ): Promise<{ width: number; height: number } | null> {
 	try {
 		const { stdout } = await processRunner.execFile(
 			'vipsheader',
 			['-f', 'width', '-f', 'height', filePath],
-			{ timeout: 10_000 },
+			{ timeout: 10_000, signal },
 		)
 		const lines = stdout.trim().split('\n')
 		if (lines.length < 2) return null
@@ -315,7 +335,8 @@ export async function getImageDimensions(
 		const height = parseInt(lines[1], 10)
 		if (!Number.isFinite(width) || !Number.isFinite(height)) return null
 		return { width, height }
-	} catch {
+	} catch (error) {
+		if (signal?.aborted) throw error
 		return null
 	}
 }
@@ -329,6 +350,8 @@ export async function classifyExtractedImages(
 	fs: FileSystem,
 	processRunner: ProcessRunner,
 ): Promise<Array<{ relativePath: string; description: string }>> {
+	const signal = getPreprocessingSignal(ctx)
+	if (signal.aborted) return []
 	const listResult = await imageStore.list('', { maxDepth: 3 })
 	if (!listResult.ok) return []
 
@@ -336,7 +359,8 @@ export async function classifyExtractedImages(
 
 	// Stat + density filter, then keep the top MAX_IMAGES by file size.
 	const inspected = await mapWithConcurrency(candidates, 8, async (entry) => {
-		const pathResult = imageStore.realPath(entry.name)
+		if (signal.aborted) return null
+		const pathResult = await imageStore.containedPath(entry.name)
 		if (!pathResult.ok) return null
 
 		let sizeBytes = 0
@@ -346,7 +370,7 @@ export async function classifyExtractedImages(
 			return null
 		}
 
-		const dims = await getImageDimensions(pathResult.value, processRunner)
+		const dims = await getImageDimensions(pathResult.value, processRunner, signal)
 		if (!dims) {
 			// Unknown dims — include but warn; better to classify than silently drop.
 			return { name: entry.name, sizeBytes, width: 0, height: 0, kept: true }
@@ -357,7 +381,7 @@ export async function classifyExtractedImages(
 	})
 
 	const filtered = inspected
-		.filter((r): r is NonNullable<typeof r> => r !== null && r.kept)
+		.filter((r): r is NonNullable<typeof r> => r?.kept === true)
 		.sort((a, b) => b.sizeBytes - a.sizeBytes)
 		.slice(0, MAX_IMAGES)
 
@@ -373,7 +397,8 @@ export async function classifyExtractedImages(
 	}
 
 	const settled = await mapWithConcurrency(filtered, IMAGE_CLASSIFY_CONCURRENCY, async (imgFile) => {
-		const imgPathResult = imageStore.realPath(imgFile.name)
+		if (signal.aborted) return null
+		const imgPathResult = await imageStore.containedPath(imgFile.name)
 		if (!imgPathResult.ok) return null
 
 		const imgMime = guessImageMime(imgFile.name)
@@ -382,6 +407,7 @@ export async function classifyExtractedImages(
 		const classifier = registry.getForMimeType(imgMime)
 		if (classifier) {
 			const classifyResult = await classifier.process(imgPathResult.value, imgMime, {
+				...ctx,
 				files: ctx.files.scoped(`${relativePrefix}/${imgFile.name}-meta`),
 			})
 			if (classifyResult.ok && classifyResult.value.extractedContent) {

package/src/plugins/uploads/preprocessors/pdf-preprocessor.ts

@@ -20,13 +20,22 @@
  *    layers before the vision call.
  */
 
+import { sleep } from '../../../lib/utils/sleep.js'
 import { dirname } from 'node:path'
 import type { Result } from '~/lib/utils/result.js'
 import { Err, Ok } from '~/lib/utils/result.js'
 import type { FileSystem } from '~/platform/fs.js'
 import type { ProcessRunner } from '~/platform/process.js'
 import type { Logger } from '../../../lib/logger/logger.js'
-import type { Preprocessor, PreprocessorContext, PreprocessorRegistry, PreprocessorResult } from '../preprocessor.js'
+import {
+	getPreprocessingSignal,
+	preprocessingAbortError,
+	throwIfPreprocessingAborted,
+	type Preprocessor,
+	type PreprocessorContext,
+	type PreprocessorRegistry,
+	type PreprocessorResult,
+} from '../preprocessor.js'
 import {
 	getImageDimensions,
 	guessImageMime,
@@ -74,12 +83,14 @@ export class PdfPreprocessor implements Preprocessor {
 		ctx: PreprocessorContext,
 	): Promise<Result<PreprocessorResult, Error>> {
 		const totalStart = Date.now()
+		const signal = getPreprocessingSignal(ctx)
+		throwIfPreprocessingAborted(signal)
 		this.logger.info('PDF processing started', { filePath })
 
-		const contentPathResult = ctx.files.realPath('content.md')
+		const contentPathResult = await ctx.files.containedPath('content.md')
 		if (!contentPathResult.ok) return Err(new Error('Failed to resolve content output path'))
 
-		const imagesDirResult = ctx.files.scoped('images').realPath('')
+		const imagesDirResult = await ctx.files.scoped('images').containedPath('')
 		if (!imagesDirResult.ok) return Err(new Error('Failed to resolve images output path'))
 
 		await this.fs.mkdir(dirname(contentPathResult.value), { recursive: true })
@@ -88,9 +99,10 @@ export class PdfPreprocessor implements Preprocessor {
 		// Run text extraction and image extraction (with streaming classification)
 		// in parallel. They share no state and don't block each other.
 		const [textResult, images] = await Promise.all([
-			this.extractText(filePath, contentPathResult.value),
+			this.extractText(filePath, contentPathResult.value, signal),
 			this.extractAndClassifyImages(filePath, imagesDirResult.value, ctx),
 		])
+		if (signal.aborted) return Err(preprocessingAbortError(signal))
 
 		const markdown = textResult.ok ? textResult.value : ''
 
@@ -127,19 +139,21 @@ export class PdfPreprocessor implements Preprocessor {
 	 * `-layout` preserves the original visual layout (columns, tables),
 	 * which is what users typically expect when looking at PDFs.
 	 */
-	private async extractText(filePath: string, outputPath: string): Promise<Result<string, Error>> {
+	private async extractText(filePath: string, outputPath: string, signal: AbortSignal): Promise<Result<string, Error>> {
 		const start = Date.now()
 		try {
 			await this.processRunner.execFile(
 				'pdftotext',
 				['-layout', filePath, outputPath],
-				{ timeout: PDFTOTEXT_TIMEOUT_MS, maxBuffer: 50 * 1024 * 1024 },
+				{ timeout: PDFTOTEXT_TIMEOUT_MS, maxBuffer: 50 * 1024 * 1024, signal },
 			)
 		} catch (error) {
+			if (signal.aborted) return Err(preprocessingAbortError(signal))
 			const message = error instanceof Error ? error.message : String(error)
 			this.logger.warn('pdftotext failed', { filePath, durationMs: Date.now() - start, error: message })
 			return Err(new Error(`pdftotext failed: ${message}`))
 		}
+		if (signal.aborted) return Err(preprocessingAbortError(signal))
 
 		let text = ''
 		try {
@@ -178,6 +192,7 @@ export class PdfPreprocessor implements Preprocessor {
 		imagesDir: string,
 		ctx: PreprocessorContext,
 	): Promise<Array<{ relativePath: string; description: string }>> {
+		const signal = getPreprocessingSignal(ctx)
 		const extractStart = Date.now()
 		const seen = new Set<string>()
 		const acceptedQueue: Array<{ name: string; sizeBytes: number; width: number; height: number }> = []
@@ -202,6 +217,7 @@ export class PdfPreprocessor implements Preprocessor {
 		const classifyOne = async (name: string): Promise<{ relativePath: string; description: string } | null> => {
 			await acquire()
 			try {
+				if (signal.aborted) return null
 				const mime = guessImageMime(name)
 				const fullPath = `${imagesDir}/${name}`
 				const imageStore = ctx.files.scoped('images')
@@ -210,6 +226,7 @@ export class PdfPreprocessor implements Preprocessor {
 				const classifier = this.registry.getForMimeType(mime)
 				if (classifier) {
 					const result = await classifier.process(fullPath, mime, {
+						...ctx,
 						files: ctx.files.scoped(`images/${name}-meta`),
 					})
 					if (result.ok && result.value.extractedContent) {
@@ -224,7 +241,7 @@ export class PdfPreprocessor implements Preprocessor {
 		}
 
 		const inspectAndMaybeClassify = async (name: string) => {
-			if (seen.has(name) || stopAccepting) return
+			if (signal.aborted || seen.has(name) || stopAccepting) return
 			seen.add(name)
 
 			if (!IMAGE_EXT_RE.test(name)) {
@@ -240,7 +257,8 @@ export class PdfPreprocessor implements Preprocessor {
 				return
 			}
 
-			const dims = await getImageDimensions(fullPath, this.processRunner)
+			const dims = await getImageDimensions(fullPath, this.processRunner, signal)
+			if (signal.aborted) return
 			const hasDims = dims !== null
 			const passesFilter = hasDims
 				? shouldClassifyImage({ width: dims.width, height: dims.height, sizeBytes })
@@ -272,7 +290,7 @@ export class PdfPreprocessor implements Preprocessor {
 		const pdfimagesPromise = this.processRunner.execFile(
 			'pdfimages',
 			['-all', filePath, `${imagesDir}/img`],
-			{ timeout: PDFIMAGES_TIMEOUT_MS, maxBuffer: 1024 * 1024 },
+			{ timeout: PDFIMAGES_TIMEOUT_MS, maxBuffer: 1024 * 1024, signal },
 		).then(() => true).catch((error) => {
 			this.logger.warn('pdfimages failed (will classify any partial output)', {
 				filePath,
@@ -284,13 +302,15 @@ export class PdfPreprocessor implements Preprocessor {
 
 		let extractionDone = false
 		const poll = async () => {
-			while (!extractionDone) {
+			while (!extractionDone && !signal.aborted) {
 				await this.scanAndDispatch(imagesDir, inspectAndMaybeClassify)
-				await sleep(STREAM_POLL_INTERVAL_MS)
+				await sleep(STREAM_POLL_INTERVAL_MS, signal)
 			}
 			// Final sweep — pick up anything that landed between the last poll
 			// and pdfimages exiting.
-			await this.scanAndDispatch(imagesDir, inspectAndMaybeClassify)
+			if (!signal.aborted) {
+				await this.scanAndDispatch(imagesDir, inspectAndMaybeClassify)
+			}
 		}
 
 		const pollPromise = poll()
@@ -336,7 +356,3 @@ export class PdfPreprocessor implements Preprocessor {
 		await Promise.all(entries.map(handle))
 	}
 }
-
-function sleep(ms: number): Promise<void> {
-	return new Promise(resolve => setTimeout(resolve, ms))
-}