fix: op-gated gs warmup, fail-fast wasm instantiate, honest offline copy

Author: Scorpio3310

e2e/specs/pdf-tools.spec.ts

@@ -1,7 +1,8 @@
 /**
- * PT-01…16: pdf-lib tools — merge (order via page-size fingerprint), reorder,
+ * PT-01…18: pdf-lib tools — merge (order via page-size fingerprint), reorder,
  * page keep/remove grammar, toImages (ZIP vs single), fromImages (dims,
- * white-flattened alpha), AVIF acceptance, unlock/protect round-trip.
+ * white-flattened alpha), AVIF acceptance, unlock/protect round-trip,
+ * Ghostscript warm-up gating by op.
  */
 import { readFileSync, writeFileSync } from 'node:fs';
 import { basename } from 'node:path';
@@ -11,6 +12,7 @@ import {
 	compress,
 	downloadCombined,
 	downloadRow,
+	gotoPath,
 	gotoTab,
 	rasterizePdfInPage,
 	setDpi,
@@ -419,3 +421,26 @@ test('PT-16: /unlock-pdf and /protect-pdf pages preset the op and gate the CTA',
 		'true'
 	);
 });
+
+test('PT-18: file-drop warms Ghostscript only for ops that run it @smoke', async ({ page }) => {
+	// The 15 MB engine: /gs.wasm in dev, /_app/…/gs.<hash>.wasm in preview.
+	const gsWasmRequests: string[] = [];
+	page.on('request', (request) => {
+		const path = new URL(request.url()).pathname;
+		if (/\/gs(\.[\w-]+)?\.wasm$/.test(path)) gsWasmRequests.push(path);
+	});
+
+	// /merge-pdf presets op=merge (mergeCompress off): pdf-lib does the whole
+	// job, so the drop must not pull the Ghostscript engine. The warm fetch
+	// starts synchronously with the drop, so a short settle catches a regression.
+	await gotoPath(page, '/merge-pdf');
+	await upload(page, fx('merge-a.pdf'));
+	await page.waitForTimeout(1000);
+	expect(gsWasmRequests, 'merge drop must not warm gs').toEqual([]);
+
+	// Switching to Compress and dropping again must start the warm fetch during
+	// think time — and proves the matcher above still matches the real URL.
+	await setPdfOp(page, 'Compress');
+	await upload(page, fx('merge-b.pdf'));
+	await expect.poll(() => gsWasmRequests.length, { timeout: 15_000 }).toBeGreaterThan(0);
+});

src/lib/seo-body/home.ts

@@ -22,7 +22,7 @@ export const BODIES: Record<string, SeoBody> = {
 						['Ads', 'Banners around every step', 'None'],
 						['Price & limits', 'Daily caps, premium tiers', 'Free, no limits'],
 						['Source code', 'Closed', 'Open on GitHub'],
-						['Offline', 'Needs a connection', 'Works offline once loaded']
+						['Offline', 'Needs a connection', 'Works offline after first use']
 					]
 				}
 			},

src/lib/workers/archive.worker.ts

@@ -84,14 +84,25 @@ async function runSevenZip(
 		onLine?.(line);
 	};
 	const wasmModule = await getWasmModule();
+	// Emscripten's instantiateWasm has no error path through `done` — with the
+	// module pre-awaited the only failure left is an instantiate OOM, which
+	// would leave SevenZipFactory pending until the 10-min watchdog. Race the
+	// load against the rejection so the call fails fast, and drop the module
+	// memo in case the compiled module itself is the problem.
+	let failInstantiate!: (error: unknown) => void;
+	const instantiateFailed = new Promise<never>((_, reject) => (failInstantiate = reject));
 	const options: SevenZipFactoryOptions = {
 		// Instantiate from the pre-compiled module — the hook wins over
 		// wasmBinary in the glue and skips its per-call WebAssembly.instantiate
-		// (bytes) compile. No rejection channel exists here; with the module
-		// pre-awaited the only failure left is an instantiate OOM, which the
-		// no-progress watchdog turns into a worker restart.
+		// (bytes) compile.
 		instantiateWasm: (imports, done) => {
-			void WebAssembly.instantiate(wasmModule, imports).then((instance) => done(instance));
+			WebAssembly.instantiate(wasmModule, imports).then(
+				(instance) => done(instance),
+				(error) => {
+					wasmModulePromise = null;
+					failInstantiate(error);
+				}
+			);
 			return {};
 		},
 		print: push,
@@ -100,7 +111,7 @@ async function runSevenZip(
 		// prompt; the d.ts wants `number` but emscripten treats null as EOF.
 		stdin: (() => null) as unknown as () => number
 	};
-	const sz = await SevenZipFactory(options);
+	const sz = await Promise.race([SevenZipFactory(options), instantiateFailed]);
 	sz.FS.mkdir('/in');
 	sz.FS.mkdir('/out');
 	if (mounts?.length) {

src/lib/workers/gs.worker.ts

@@ -62,23 +62,38 @@ expose<WorkerContracts['gs']>({
 			if (tail.length > 50) tail.shift();
 		};
 
-		const gs = await loadGs({
-			instantiateWasm: (imports, done) => {
-				WebAssembly.instantiate(module, imports).then((instance) => done(instance));
-				return {};
-			},
-			print: (line: string) => {
-				record(line);
-				const total = /^Processing pages \d+ through (\d+)/.exec(line);
-				if (total) {
-					pageCount = Number(total[1]);
-					return;
-				}
-				const page = /^Page (\d+)/.exec(line);
-				if (page) progress({ page: Number(page[1]), pageCount } satisfies GsProgress);
-			},
-			printErr: record
-		});
+		// Emscripten's instantiateWasm has no error path through `done` — a
+		// rejection (OOM, mostly) would leave loadGs pending until the watchdog.
+		// Race the load against it so the call fails fast, and drop the module
+		// memo in case the compiled module itself is the problem.
+		let failInstantiate!: (error: unknown) => void;
+		const instantiateFailed = new Promise<never>((_, reject) => (failInstantiate = reject));
+		const gs = await Promise.race([
+			loadGs({
+				instantiateWasm: (imports, done) => {
+					WebAssembly.instantiate(module, imports).then(
+						(instance) => done(instance),
+						(error) => {
+							compiledPromise = null;
+							failInstantiate(error);
+						}
+					);
+					return {};
+				},
+				print: (line: string) => {
+					record(line);
+					const total = /^Processing pages \d+ through (\d+)/.exec(line);
+					if (total) {
+						pageCount = Number(total[1]);
+						return;
+					}
+					const page = /^Page (\d+)/.exec(line);
+					if (page) progress({ page: Number(page[1]), pageCount } satisfies GsProgress);
+				},
+				printErr: record
+			}),
+			instantiateFailed
+		]);
 
 		gs.FS.writeFile('/in.pdf', new Uint8Array(pdf));
 

src/routes/[[tool=tool]]/+page.svelte

@@ -302,7 +302,7 @@
 		// Warm this tab's engine now: a drop precedes the Compress click by
 		// seconds, so the worker + its wasm (the 15 MB gs module especially) load
 		// during think time instead of stalling behind a dead progress bar.
-		const warmKind = WARM_KIND[format];
+		const warmKind = warmKindFor(format);
 		if (warmKind) warmUp(warmKind);
 		// The settings panel + codec orchestration are interaction-gated chunks;
 		// load them now (a file just landed) so they're ready when the panel renders
@@ -339,23 +339,35 @@
 	};
 
 	// The primary worker each tab warms on file-drop (see handleFiles). Only the
-	// kind on the critical path is listed — pdf warms 'gs' (15 MB, the big win),
-	// not the secondary 'image' its fromImages op may also touch.
+	// kind on the critical path is listed; pdf resolves per op in warmKindFor —
+	// its worker depends on which tool page the drop lands on.
 	const WARM_KIND: Partial<Record<FileFormat, WorkerKind>> = {
 		jpg: 'image',
 		png: 'image',
 		webp: 'image',
 		gif: 'image',
 		heic: 'image',
 		svg: 'svg',
-		pdf: 'gs',
 		video: 'video',
 		audio: 'video',
 		font: 'font',
 		zip: 'archive',
 		exif: 'image'
 	};
 
+	// Ghostscript (a 15 MB wasm fetch + compile) backs only compress/unlock/
+	// protect — and merge when its "compress result" toggle is on. pages and
+	// toImages run on pdf-lib/pdf.js, which aren't pooled workers; fromImages'
+	// critical path is the image worker re-encoding the pages.
+	function warmKindFor(format: FileFormat): WorkerKind | null {
+		if (format !== 'pdf') return WARM_KIND[format] ?? null;
+		const { op, mergeCompress } = settings.pdf;
+		if (op === 'compress' || op === 'unlock' || op === 'protect') return 'gs';
+		if (op === 'merge') return mergeCompress ? 'gs' : null;
+		if (op === 'fromImages') return 'image';
+		return null;
+	}
+
 	async function handleCompress() {
 		// Snapshot the tab: activeTab is $derived from the route, so a read after
 		// an await sees the tab the user is LOOKING at, not the tab this run
@@ -954,7 +966,7 @@
 	<span class="font-medium text-ink">
 		<Icon name="lock" class="mr-0.5 inline size-3 align-[-0.14em]" />Files never leave your device.
 	</span>
-	Everything runs in your browser, nothing touches a server — it even works offline once loaded.
+	Everything runs in your browser, nothing touches a server — tools you've used even work offline.
 </p>
 
 <FormatInfo

src/routes/llms.txt/+server.ts

@@ -18,7 +18,7 @@ export function GET() {
 		'',
 		`> ${FULL_HOME.description}`,
 		'',
-		'Every tool runs entirely in the browser — files are never uploaded, there is no server-side processing, no account, no ads and no file-size limit. The app is free, open source (https://github.com/Scorpio3310/compress-pro), and keeps working offline once loaded — proof that nothing is sent anywhere.',
+		'Every tool runs entirely in the browser — files are never uploaded, there is no server-side processing, no account, no ads and no file-size limit. The app is free, open source (https://github.com/Scorpio3310/compress-pro), and tools keep working offline after their first use — proof that nothing is sent anywhere.',
 		'',
 		`Every tool page below has a plain-markdown twin for agents — append ".md" to its URL (homepage: ${SITE_URL}/index.md). The full content of every page in one document: ${SITE_URL}/llms-full.txt`,
 		'',

src/routes/privacy/+page.svelte

@@ -42,9 +42,9 @@
 		<p class="mt-3 max-w-xl">
 			Practically nothing. No accounts and no databases exist. Your browser’s localStorage keeps two
 			things on your own device: your theme choice and your last-used tool settings — never file
-			contents or file names. The compression engines are cached by the browser so repeat visits
-			load fast — which also means the app keeps working offline: the clearest proof that your files
-			are not being sent anywhere.
+			contents or file names. Each compression engine is cached by the browser on first use so
+			repeat visits load fast — which also means tools you've used keep working offline: the
+			clearest proof that your files are not being sent anywhere.
 		</p>
 	</div>