dsh-aha-tutor 1.7.0 → 1.9.0

package/lib/index.js

@@ -1,14 +1,14 @@
-import { $ as passageRange, A as verifyItemPrompt, At as plotToText, B as materialImages, C as quizPrompt, Ct as normalizeLesson, D as reworkPrompt, Dt as outlineForPrompt, E as revisePrompt, Et as normalizeQuestionnaire, F as generateText, G as readProgress, H as passagesFor, I as streamCounter, J as masteryPercent, K as applyEvidence, L as EMPTY_PROFILE, M as TutorError, Mt as newId, N as generateJson, O as shortPrompt, Ot as safeRelativePath, P as generateSteps, Q as formatPassages, R as emptyProgress, S as questionnairePrompt, St as normalizeItem, T as researchQueriesPrompt, Tt as normalizeProject, U as readMaterials, V as materialsSummary, W as readProfile, X as buildIndex, Y as recommendNext, Z as documentParts, _ as materialsRevisePrompt, _t as nextLesson, a as blueprintPrompt, at as boardToPlainText, b as projectReviewPrompt, bt as normalizeCheatsheet, c as correctionPrompt, ct as normalizeOp, d as digestPrompt, dt as courseProgress, et as search, f as flashcardsPrompt, ft as findLesson, g as materialBriefPrompt, gt as lessonAfter, h as lessonPrompt, ht as intakeSummary, i as assistPrompt, it as BOARD_LIMITS, j as verifyStepPrompt, jt as assertId, k as summaryPrompt, kt as text, l as detectLanguage, lt as blueprintOutline, m as handoutPrompt, mt as insertLesson, n as publishRuntime, nt as spreadPassages, o as challengePrompt, ot as estimateSpeechMs, p as gradePrompt, pt as flattenLessons, q as createConceptState, r as askPrompt, rt as extractJson, s as cheatsheetPrompt, st as normalizeBoard, tt as snippetOf, u as digestPartPrompt, ut as conceptIndex, v as practicePrompt, vt as normalizeBlueprint, w as reexplainPrompt, wt as normalizePractice, x as projectsPrompt, xt as normalizeHandout, y as profilePrompt, yt as normalizeCards, z as masteryFor } from "./runtime-DfoeKFPj.js";
+import { $ as documentParts, A as shortPrompt, At as safeRelativePath, B as emptyProgress, C as questionnairePrompt, Ct as normalizeHandout, D as researchQueriesPrompt, Dt as normalizeProject, E as reexplainPrompt, Et as normalizePractice, F as generateJson, G as readMaterials, H as materialImages, I as generateSteps, J as applyEvidence, K as readProfile, L as generateText, M as verifyItemPrompt, Mt as plotToText, N as verifyStepPrompt, Nt as assertId, O as revisePrompt, Ot as normalizeQuestionnaire, P as TutorError, Pt as newId, Q as buildIndex, R as streamCounter, S as projectsPrompt, St as normalizeCheatsheet, T as recognizePrompt, Tt as normalizeLesson, U as materialsSummary, V as masteryFor, W as passagesFor, X as masteryPercent, Y as createConceptState, Z as recommendNext, _ as materialBriefPrompt, _t as intakeSummary, a as assistPrompt, at as extractJson, b as profilePrompt, bt as normalizeBlueprint, c as cheatsheetPrompt, ct as estimateSpeechMs, d as digestPartPrompt, dt as blueprintOutline, et as formatPassages, f as digestPrompt, ft as conceptIndex, g as lessonPrompt, gt as insertLesson, h as handoutPrompt, ht as flattenLessons, i as askPrompt, it as spreadPassages, j as summaryPrompt, jt as text, k as reworkPrompt, kt as outlineForPrompt, l as correctionPrompt, lt as normalizeBoard, m as gradePrompt, mt as findLesson, n as publishRuntime, nt as search, o as blueprintPrompt, ot as BOARD_LIMITS, p as flashcardsPrompt, pt as courseProgress, q as readProgress, r as RECOGNIZE_EMPTY, rt as snippetOf, s as challengePrompt, st as boardToPlainText, tt as passageRange, u as detectLanguage, ut as normalizeOp, v as materialsRevisePrompt, vt as lessonAfter, w as quizPrompt, wt as normalizeItem, x as projectReviewPrompt, xt as normalizeCards, y as practicePrompt, yt as nextLesson, z as EMPTY_PROFILE } from "./runtime-C3yJfJTT.js";
 import { createRequire } from "node:module";
 import { dirname, join, relative, sep } from "node:path";
 import { credentialKey } from "@deepseek-ai/dsh-credentials";
 import { lstat, mkdir, readFile, readdir, realpath, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
+import zlib, { deflateSync } from "node:zlib";
 import { lookup } from "node:dns";
 import http from "node:http";
 import https from "node:https";
 import { isIP } from "node:net";
 import { pipeline } from "node:stream";
-import zlib from "node:zlib";
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
@@ -1081,6 +1081,484 @@ const USER_ERRORS$1 = [
 	"TutorError"
 ];
 //#endregion
+//#region src/host/page-image.js
+const MAX_PIXELS = 4e6;
+const MAX_EDGE = 2400;
+const OBJECT_WAIT_MS = 2e4;
+const IDENTITY = [
+	1,
+	0,
+	0,
+	1,
+	0,
+	0
+];
+function multiply(m, n) {
+	return [
+		m[0] * n[0] + m[2] * n[1],
+		m[1] * n[0] + m[3] * n[1],
+		m[0] * n[2] + m[2] * n[3],
+		m[1] * n[2] + m[3] * n[3],
+		m[0] * n[4] + m[2] * n[5] + m[4],
+		m[1] * n[4] + m[3] * n[5] + m[5]
+	];
+}
+function invert(m) {
+	const det = m[0] * m[3] - m[1] * m[2];
+	if (!det) return null;
+	return [
+		m[3] / det,
+		-m[1] / det,
+		-m[2] / det,
+		m[0] / det,
+		(m[2] * m[5] - m[3] * m[4]) / det,
+		(m[1] * m[4] - m[0] * m[5]) / det
+	];
+}
+const apply$1 = (m, x, y) => [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];
+function grayOf(color) {
+	const hex = /^#([0-9a-f]{6})$/iu.exec(String(color ?? ""))?.[1];
+	if (!hex) return 0;
+	const value = Number.parseInt(hex, 16);
+	return Math.round(((value >> 16) * 299 + (value >> 8 & 255) * 587 + (value & 255) * 114) / 1e3);
+}
+function placements(OPS, operatorList) {
+	const draws = [];
+	let ctm = IDENTITY;
+	let fill = 0;
+	const stack = [];
+	const push = () => stack.push({
+		ctm,
+		fill
+	});
+	const pop = () => {
+		const saved = stack.pop();
+		if (saved) ({ctm, fill} = saved);
+	};
+	const { fnArray, argsArray } = operatorList;
+	for (let index = 0; index < fnArray.length; index += 1) {
+		const args = argsArray[index] ?? [];
+		switch (fnArray[index]) {
+			case OPS.save:
+				push();
+				break;
+			case OPS.restore:
+			case OPS.paintFormXObjectEnd:
+			case OPS.endGroup:
+				pop();
+				break;
+			case OPS.transform:
+				ctm = multiply(ctm, args);
+				break;
+			case OPS.paintFormXObjectBegin:
+				push();
+				if (Array.isArray(args[0])) ctm = multiply(ctm, args[0]);
+				break;
+			case OPS.beginGroup:
+				push();
+				if (Array.isArray(args[0]?.matrix)) ctm = multiply(ctm, args[0].matrix);
+				break;
+			case OPS.setFillRGBColor:
+				fill = grayOf(args[0]);
+				break;
+			case OPS.paintImageXObject:
+				draws.push({
+					matrix: ctm,
+					image: args[0]
+				});
+				break;
+			case OPS.paintInlineImageXObject:
+				draws.push({
+					matrix: ctm,
+					image: args[0]
+				});
+				break;
+			case OPS.paintImageXObjectRepeat: {
+				const [image, scaleX, scaleY, positions = []] = args;
+				for (let at = 0; at + 1 < positions.length; at += 2) draws.push({
+					matrix: multiply(ctm, [
+						scaleX,
+						0,
+						0,
+						scaleY,
+						positions[at],
+						positions[at + 1]
+					]),
+					image
+				});
+				break;
+			}
+			case OPS.paintInlineImageXObjectGroup: {
+				const [image, map = []] = args;
+				for (const entry of map) draws.push({
+					matrix: multiply(ctm, entry.transform),
+					image,
+					region: {
+						x: entry.x,
+						y: entry.y,
+						w: entry.w,
+						h: entry.h
+					}
+				});
+				break;
+			}
+			case OPS.paintImageMaskXObject:
+				draws.push({
+					matrix: ctm,
+					mask: args[0],
+					fill
+				});
+				break;
+			case OPS.paintImageMaskXObjectGroup:
+				for (const mask of args[0] ?? []) draws.push({
+					matrix: multiply(ctm, mask.transform),
+					mask,
+					fill
+				});
+				break;
+			case OPS.paintImageMaskXObjectRepeat: {
+				const [mask, scaleX, skewX = 0, skewY = 0, scaleY, positions = []] = args;
+				for (let at = 0; at + 1 < positions.length; at += 2) draws.push({
+					matrix: multiply(ctm, [
+						scaleX,
+						skewX,
+						skewY,
+						scaleY,
+						positions[at],
+						positions[at + 1]
+					]),
+					mask,
+					fill
+				});
+				break;
+			}
+			case OPS.paintSolidColorImageMask:
+				draws.push({
+					matrix: ctm,
+					solid: fill
+				});
+				break;
+			default: break;
+		}
+	}
+	return draws;
+}
+async function resolve(page, value) {
+	if (typeof value !== "string") return value ?? null;
+	const objects = value.startsWith("g_") ? page.commonObjs : page.objs;
+	let timer;
+	try {
+		return await Promise.race([new Promise((done) => {
+			objects.get(value, done);
+		}), new Promise((done) => {
+			timer = setTimeout(() => done(null), OBJECT_WAIT_MS);
+		})]);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+function shrink(image, { factor = 1, mask = false, region } = {}) {
+	const { width, height, kind, data } = image;
+	const x0 = region?.x ?? 0;
+	const y0 = region?.y ?? 0;
+	const w = Math.max(1, Math.min(region?.w ?? width, width - x0));
+	const h = Math.max(1, Math.min(region?.h ?? height, height - y0));
+	const outW = Math.max(1, Math.ceil(w / factor));
+	const outH = Math.max(1, Math.ceil(h / factor));
+	const gray = new Uint8Array(outW * outH);
+	const alpha = new Uint8Array(outW * outH);
+	let opaque = true;
+	const bits = mask || kind === 1;
+	const stride = bits ? width + 7 >> 3 : width * (kind === 3 ? 4 : 3);
+	for (let oy = 0; oy < outH; oy += 1) {
+		const yStart = y0 + oy * factor;
+		const yEnd = Math.min(y0 + h, yStart + factor);
+		for (let ox = 0; ox < outW; ox += 1) {
+			const xStart = x0 + ox * factor;
+			const xEnd = Math.min(x0 + w, xStart + factor);
+			let level = 0;
+			let cover = 0;
+			let count = 0;
+			for (let y = yStart; y < yEnd; y += 1) {
+				const row = y * stride;
+				for (let x = xStart; x < xEnd; x += 1) {
+					count += 1;
+					if (bits) {
+						const set = data[row + (x >> 3)] >> 7 - (x & 7) & 1;
+						if (mask) cover += set ? 0 : 255;
+						else {
+							level += set ? 255 : 0;
+							cover += 255;
+						}
+					} else {
+						const at = row + x * (kind === 3 ? 4 : 3);
+						const value = (data[at] * 299 + data[at + 1] * 587 + data[at + 2] * 114) / 1e3;
+						const opacity = kind === 3 ? data[at + 3] : 255;
+						level += value * opacity;
+						cover += opacity;
+					}
+				}
+			}
+			const at = oy * outW + ox;
+			alpha[at] = count ? Math.round(cover / count) : 0;
+			if (alpha[at] < 255) opaque = false;
+			gray[at] = bits ? mask ? 0 : Math.round(level / count) : cover ? Math.round(level / cover) : 255;
+		}
+	}
+	return {
+		width: outW,
+		height: outH,
+		gray,
+		alpha,
+		opaque
+	};
+}
+function paint(page, full, picture, { fill = null } = {}) {
+	const inverse = invert(full);
+	if (!inverse) return;
+	const corners = [
+		[0, 0],
+		[1, 0],
+		[0, 1],
+		[1, 1]
+	].map(([x, y]) => apply$1(full, x, y));
+	const left = Math.max(0, Math.floor(Math.min(...corners.map((point) => point[0]))));
+	const right = Math.min(page.width, Math.ceil(Math.max(...corners.map((point) => point[0]))));
+	const top = Math.max(0, Math.floor(Math.min(...corners.map((point) => point[1]))));
+	const bottom = Math.min(page.height, Math.ceil(Math.max(...corners.map((point) => point[1]))));
+	const [ia, ib, ic, id, ie, iff] = inverse;
+	if (picture && Math.abs(ib) < 1e-9 && Math.abs(ic) < 1e-9) {
+		paintAligned(page, picture, {
+			left,
+			right,
+			top,
+			bottom,
+			ia,
+			id,
+			ie,
+			iff,
+			fill
+		});
+		return;
+	}
+	const { width, height, gray, alpha } = picture ?? {
+		width: 1,
+		height: 1
+	};
+	for (let y = top; y < bottom; y += 1) {
+		const py = y + .5;
+		for (let x = left; x < right; x += 1) {
+			const px = x + .5;
+			const u = ia * px + ic * py + ie;
+			const v = ib * px + id * py + iff;
+			if (u < 0 || u >= 1 || v < 0 || v >= 1) continue;
+			const at = y * page.width + x;
+			if (!picture) {
+				page.gray[at] = fill;
+				continue;
+			}
+			const fx = Math.min(width - 1, Math.max(0, u * width - .5));
+			const fy = Math.min(height - 1, Math.max(0, (1 - v) * height - .5));
+			const x1 = Math.floor(fx);
+			const y1 = Math.floor(fy);
+			const x2 = Math.min(width - 1, x1 + 1);
+			const y2 = Math.min(height - 1, y1 + 1);
+			const tx = fx - x1;
+			const ty = fy - y1;
+			const w1 = (1 - tx) * (1 - ty);
+			const w2 = tx * (1 - ty);
+			const w3 = (1 - tx) * ty;
+			const w4 = tx * ty;
+			const p1 = y1 * width + x1;
+			const p2 = y1 * width + x2;
+			const p3 = y2 * width + x1;
+			const p4 = y2 * width + x2;
+			const cover = alpha[p1] * w1 + alpha[p2] * w2 + alpha[p3] * w3 + alpha[p4] * w4;
+			if (!cover) continue;
+			const ink = fill ?? (gray[p1] * alpha[p1] * w1 + gray[p2] * alpha[p2] * w2 + gray[p3] * alpha[p3] * w3 + gray[p4] * alpha[p4] * w4) / cover;
+			const share = cover / 255;
+			page.gray[at] = Math.round(page.gray[at] * (1 - share) + ink * share);
+		}
+	}
+}
+function axisSamples(from, to, scale, offset, size, flip) {
+	const first = new Int32Array(to - from);
+	const second = new Int32Array(to - from);
+	const weight = new Float32Array(to - from);
+	for (let index = 0; index < to - from; index += 1) {
+		const unit = scale * (from + index + .5) + offset;
+		if (unit < 0 || unit >= 1) {
+			first[index] = -1;
+			continue;
+		}
+		const position = Math.min(size - 1, Math.max(0, (flip ? 1 - unit : unit) * size - .5));
+		first[index] = Math.floor(position);
+		second[index] = Math.min(size - 1, first[index] + 1);
+		weight[index] = position - first[index];
+	}
+	return {
+		first,
+		second,
+		weight
+	};
+}
+function paintAligned(page, picture, { left, right, top, bottom, ia, id, ie, iff, fill }) {
+	const { width, height, gray, alpha, opaque } = picture;
+	const columns = axisSamples(left, right, ia, ie, width, false);
+	const rows = axisSamples(top, bottom, id, iff, height, true);
+	for (let y = top; y < bottom; y += 1) {
+		const row = y - top;
+		if (rows.first[row] < 0) continue;
+		const r1 = rows.first[row] * width;
+		const r2 = rows.second[row] * width;
+		const ty = rows.weight[row];
+		const out = y * page.width;
+		for (let x = left; x < right; x += 1) {
+			const column = x - left;
+			const c1 = columns.first[column];
+			if (c1 < 0) continue;
+			const c2 = columns.second[column];
+			const tx = columns.weight[column];
+			const p1 = r1 + c1;
+			const p2 = r1 + c2;
+			const p3 = r2 + c1;
+			const p4 = r2 + c2;
+			if (opaque && fill === null) {
+				const above = gray[p1] + (gray[p2] - gray[p1]) * tx;
+				const below = gray[p3] + (gray[p4] - gray[p3]) * tx;
+				page.gray[out + x] = Math.round(above + (below - above) * ty);
+				continue;
+			}
+			const w1 = (1 - tx) * (1 - ty);
+			const w2 = tx * (1 - ty);
+			const w3 = (1 - tx) * ty;
+			const w4 = tx * ty;
+			const cover = alpha[p1] * w1 + alpha[p2] * w2 + alpha[p3] * w3 + alpha[p4] * w4;
+			if (!cover) continue;
+			const ink = fill ?? (gray[p1] * alpha[p1] * w1 + gray[p2] * alpha[p2] * w2 + gray[p3] * alpha[p3] * w3 + gray[p4] * alpha[p4] * w4) / cover;
+			const share = cover / 255;
+			page.gray[out + x] = Math.round(page.gray[out + x] * (1 - share) + ink * share);
+		}
+	}
+}
+function extent(full) {
+	const [x0, y0] = apply$1(full, 0, 0);
+	const [x1, y1] = apply$1(full, 1, 0);
+	const [x2, y2] = apply$1(full, 0, 1);
+	return {
+		across: Math.hypot(x1 - x0, y1 - y0),
+		down: Math.hypot(x2 - x0, y2 - y0)
+	};
+}
+async function pageImage(pdfjs, page) {
+	const operatorList = await page.getOperatorList({ annotationMode: pdfjs.AnnotationMode?.DISABLE });
+	const draws = placements(pdfjs.OPS, operatorList);
+	if (!draws.length) return null;
+	const base = page.getViewport({ scale: 1 });
+	const pictures = await Promise.all(draws.map((draw) => draw.solid !== void 0 ? null : resolve(page, draw.image ?? (typeof draw.mask?.data === "string" ? draw.mask.data : draw.mask))));
+	let density = 1;
+	for (const [index, draw] of draws.entries()) {
+		const decoded = pictures[index];
+		if (!decoded?.width) continue;
+		const size = extent(multiply(base.transform, draw.matrix));
+		if (size.across * size.down < base.width * base.height * .05) continue;
+		density = Math.max(density, Math.min((draw.region?.w ?? decoded.width) / Math.max(1, size.across), (draw.region?.h ?? decoded.height) / Math.max(1, size.down)));
+	}
+	const scale = Math.min(density, Math.sqrt(MAX_PIXELS / (base.width * base.height)), MAX_EDGE / Math.max(base.width, base.height));
+	const viewport = page.getViewport({ scale });
+	const bitmap = {
+		width: Math.max(1, Math.ceil(viewport.width)),
+		height: Math.max(1, Math.ceil(viewport.height))
+	};
+	bitmap.gray = new Uint8Array(bitmap.width * bitmap.height).fill(255);
+	let painted = false;
+	for (const [index, draw] of draws.entries()) {
+		const full = multiply(viewport.transform, draw.matrix);
+		if (draw.solid !== void 0) {
+			paint(bitmap, full, null, { fill: draw.solid });
+			painted = true;
+			continue;
+		}
+		const decoded = pictures[index];
+		const mask = Boolean(draw.mask);
+		const image = mask ? {
+			...draw.mask,
+			...decoded ?? {},
+			kind: 1
+		} : decoded;
+		if (!image?.data || !image.width || !image.height) continue;
+		if (!mask && ![
+			1,
+			2,
+			3
+		].includes(image.kind)) continue;
+		const size = extent(full);
+		paint(bitmap, full, shrink(image, {
+			factor: Math.max(1, Math.floor(Math.min((draw.region?.w ?? image.width) / Math.max(1, size.across), (draw.region?.h ?? image.height) / Math.max(1, size.down)))),
+			mask,
+			region: draw.region
+		}), { fill: mask ? draw.fill : null });
+		painted = true;
+	}
+	if (!painted) return null;
+	return {
+		mime: "image/png",
+		data: encodeGrayPng(bitmap.width, bitmap.height, bitmap.gray),
+		width: bitmap.width,
+		height: bitmap.height
+	};
+}
+const CRC_TABLE = (/* @__PURE__ */ new Uint32Array(256)).map((_, index) => {
+	let value = index;
+	for (let bit = 0; bit < 8; bit += 1) value = value & 1 ? 3988292384 ^ value >>> 1 : value >>> 1;
+	return value >>> 0;
+});
+function crc32(bytes) {
+	let value = 4294967295;
+	for (const byte of bytes) value = CRC_TABLE[(value ^ byte) & 255] ^ value >>> 8;
+	return (value ^ 4294967295) >>> 0;
+}
+function chunk(type, body) {
+	const head = Buffer.alloc(8);
+	head.writeUInt32BE(body.length, 0);
+	head.write(type, 4, "latin1");
+	const tail = Buffer.alloc(4);
+	tail.writeUInt32BE(crc32(Buffer.concat([head.subarray(4), body])), 0);
+	return Buffer.concat([
+		head,
+		body,
+		tail
+	]);
+}
+function encodeGrayPng(width, height, gray) {
+	const raw = Buffer.alloc((width + 1) * height);
+	for (let y = 0; y < height; y += 1) {
+		const out = y * (width + 1);
+		raw[out] = 2;
+		for (let x = 0; x < width; x += 1) raw[out + 1 + x] = gray[y * width + x] - (y ? gray[(y - 1) * width + x] : 0) & 255;
+	}
+	const header = Buffer.alloc(13);
+	header.writeUInt32BE(width, 0);
+	header.writeUInt32BE(height, 4);
+	header[8] = 8;
+	header[9] = 0;
+	return Buffer.concat([
+		Buffer.from([
+			137,
+			80,
+			78,
+			71,
+			13,
+			10,
+			26,
+			10
+		]),
+		chunk("IHDR", header),
+		chunk("IDAT", deflateSync(raw)),
+		chunk("IEND", Buffer.alloc(0))
+	]);
+}
+//#endregion
 //#region src/host/web-fetch.js
 const LOCAL_ADDRESS_MESSAGE = "Local network addresses are not supported";
 var AddressError = class extends Error {
@@ -1319,6 +1797,16 @@ const MAX_TEXT_CHARS = 2e6;
 const CHUNK_CHARS = 1600;
 const FETCH_TIMEOUT_MS = 2e4;
 const MAX_PAGE_BYTES = 6 * 1024 * 1024;
+const MIN_PAGE_TEXT = 30;
+const TEXT_PER_PICTURE = 150;
+const MIN_PICTURE_BYTES = 2048;
+const PICTURE_TYPES = Object.freeze({
+	png: "image/png",
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	gif: "image/gif",
+	webp: "image/webp"
+});
 const pageFetch = createGuardedFetch({ maxBytes: MAX_UPLOAD_BYTES });
 var MaterialError = class extends Error {
 	constructor(code, message) {
@@ -1459,6 +1947,71 @@ function finish(kind, title, chunks, extra = {}) {
 		...extra
 	};
 }
+const visibleLength = (value) => String(value ?? "").replace(/\s+/gu, "").length;
+async function readPictures(recognize, sources) {
+	if (!sources.length) return {
+		texts: [],
+		note: null,
+		available: true,
+		error: null
+	};
+	const tried = sources.slice(0, 200);
+	const results = recognize ? await recognize(tried) : null;
+	if (!results) return {
+		texts: [],
+		note: { unread: sources.length },
+		available: false,
+		error: null
+	};
+	const error = results.find((result) => result?.error)?.error ?? null;
+	const failed = tried.filter((source, index) => results[index]?.error).map((source) => source.where);
+	return {
+		texts: tried.map((source, index) => results[index]?.text ?? ""),
+		note: {
+			read: results.filter((result) => result && !result.error).length,
+			failed,
+			reason: error?.code ?? null,
+			left: sources.length - tried.length
+		},
+		available: true,
+		error
+	};
+}
+function resolvePart(base, target) {
+	const parts = target.startsWith("/") ? [] : base.split("/").filter(Boolean);
+	for (const piece of target.split("/")) if (piece === "..") parts.pop();
+	else if (piece && piece !== ".") parts.push(piece);
+	return parts.join("/");
+}
+async function partPictures(zip, part) {
+	const slash = part.lastIndexOf("/");
+	const folder = part.slice(0, slash);
+	const xml = await zip.file(part)?.async("string") ?? "";
+	const rels = await zip.file(`${folder}/_rels/${part.slice(slash + 1)}.rels`)?.async("string") ?? "";
+	const targets = /* @__PURE__ */ new Map();
+	for (const [, attributes] of rels.matchAll(/<Relationship\b([^>]*)>/gu)) {
+		const id = /\bId="([^"]+)"/u.exec(attributes)?.[1];
+		const target = /\bTarget="([^"]+)"/u.exec(attributes)?.[1];
+		if (!id || !target || !/\bType="[^"]*\/image"/u.test(attributes) || /\bTargetMode="External"/u.test(attributes)) continue;
+		targets.set(id, resolvePart(folder, decodeXml(target)));
+	}
+	const seen = /* @__PURE__ */ new Set();
+	const pictures = [];
+	for (const [, id] of xml.matchAll(/\br:(?:embed|id)="([^"]+)"/gu)) {
+		const path = targets.get(id);
+		if (!path || seen.has(path)) continue;
+		seen.add(path);
+		const mime = PICTURE_TYPES[path.split(".").pop().toLowerCase()];
+		const file = zip.file(path);
+		if (!mime || !file) continue;
+		const data = await file.async("nodebuffer");
+		if (data.length >= MIN_PICTURE_BYTES && data.length <= 10485760) pictures.push({
+			mime,
+			data
+		});
+	}
+	return pictures;
+}
 let pdfjsModule;
 async function loadPdfjs() {
 	pdfjsModule ??= import("pdfjs-dist/legacy/build/pdf.mjs");
@@ -1467,20 +2020,23 @@ async function loadPdfjs() {
 function pdfjsAssetUrls(root, { join: joinPath = join } = {}) {
 	return {
 		cMapUrl: `${joinPath(root, "cmaps")}/`,
-		standardFontDataUrl: `${joinPath(root, "standard_fonts")}/`
+		standardFontDataUrl: `${joinPath(root, "standard_fonts")}/`,
+		wasmUrl: `${joinPath(root, "wasm")}/`
 	};
 }
 function pdfjsAssets() {
 	return pdfjsAssetUrls(dirname(createRequire(import.meta.url).resolve("pdfjs-dist/package.json")));
 }
-async function extractPdf(bytes, { signal } = {}) {
+async function extractPdf(bytes, { signal, recognize } = {}) {
 	const pdfjs = await loadPdfjs();
-	const { cMapUrl, standardFontDataUrl } = pdfjsAssets();
+	const { cMapUrl, standardFontDataUrl, wasmUrl } = pdfjsAssets();
 	const task = pdfjs.getDocument({
 		data: new Uint8Array(bytes),
 		cMapUrl,
 		cMapPacked: true,
 		standardFontDataUrl,
+		wasmUrl,
+		maxImageSize: 1e8,
 		isEvalSupported: false,
 		disableFontFace: true,
 		useSystemFonts: false,
@@ -1494,12 +2050,12 @@ async function extractPdf(bytes, { signal } = {}) {
 		throw new MaterialError("unreadable", "This PDF could not be read");
 	}
 	try {
-		const chunks = [];
 		let title = "";
 		try {
 			const meta = await doc.getMetadata();
 			title = String(meta?.info?.Title ?? "").trim();
 		} catch {}
+		const texts = [];
 		for (let pageNumber = 1; pageNumber <= doc.numPages; pageNumber += 1) {
 			signal?.throwIfAborted();
 			const page = await doc.getPage(pageNumber);
@@ -1511,19 +2067,39 @@ async function extractPdf(bytes, { signal } = {}) {
 				pageText += item.hasEOL ? "\n" : "";
 			}
 			page.cleanup();
-			chunks.push(...chunkText(pageText, { page: pageNumber }));
+			texts.push(pageText);
+		}
+		const pictured = texts.flatMap((pageText, index) => visibleLength(pageText) < MIN_PAGE_TEXT ? [index + 1] : []);
+		const read = await readPictures(recognize, pictured.map((pageNumber) => ({
+			where: { page: pageNumber },
+			image: async () => {
+				signal?.throwIfAborted();
+				const page = await doc.getPage(pageNumber);
+				try {
+					return await pageImage(pdfjs, page);
+				} finally {
+					page.cleanup();
+				}
+			}
+		})));
+		if (pictured.length === doc.numPages && !read.note?.read) {
+			if (!read.available) throw new MaterialError("scan-needs-vision", "This PDF is a scan; reading it needs a model that can see images");
+			throw read.error ?? new MaterialError("no-text", "No text found in this PDF");
 		}
-		if (!chunks.length) throw new MaterialError("no-text", "No text found in this PDF (it may be a scan)");
+		const recognized = new Map(pictured.slice(0, read.texts.length).map((pageNumber, index) => [pageNumber, read.texts[index]]));
+		const chunks = texts.flatMap((pageText, index) => chunkText([pageText, recognized.get(index + 1)].filter(Boolean).join("\n\n"), { page: index + 1 }));
+		if (!chunks.length) throw read.error ?? new MaterialError("no-text", "No text found in this PDF");
 		return {
 			title,
 			pages: doc.numPages,
-			chunks
+			chunks,
+			ocr: read.note
 		};
 	} finally {
 		await Promise.resolve(task.destroy?.()).catch(() => void 0);
 	}
 }
-async function extractDocx(bytes) {
+async function extractDocx(bytes, { recognize } = {}) {
 	const mammoth = await import("mammoth");
 	const extract = mammoth.extractRawText ?? mammoth.default?.extractRawText;
 	let result;
@@ -1532,7 +2108,8 @@ async function extractDocx(bytes) {
 	} catch {
 		throw new MaterialError("unreadable", "This Word document could not be read");
 	}
-	const sections = String(result?.value ?? "").split(/\n{2,}/u);
+	const own = String(result?.value ?? "");
+	const sections = own.split(/\n{2,}/u);
 	const chunks = [];
 	let buffer = "";
 	let section = 1;
@@ -1544,9 +2121,31 @@ async function extractDocx(bytes) {
 		}
 		buffer += `${paragraph}\n\n`;
 	}
-	if (buffer.trim()) chunks.push(...chunkText(buffer, { section: `§${section}` }));
+	if (buffer.trim()) {
+		chunks.push(...chunkText(buffer, { section: `§${section}` }));
+		section += 1;
+	}
+	const JSZip = (await import("jszip")).default;
+	const pictures = await partPictures(await JSZip.loadAsync(bytes), "word/document.xml");
+	let note = null;
+	if (pictures.length && visibleLength(own) < TEXT_PER_PICTURE * pictures.length) {
+		const read = await readPictures(recognize, pictures.map((picture, index) => ({
+			where: { picture: index + 1 },
+			image: async () => picture
+		})));
+		if (!read.note?.read && visibleLength(own) < MIN_PAGE_TEXT) {
+			if (!read.available) throw new MaterialError("pictures-need-vision", "This document is pictures; reading them needs a model that can see images");
+			throw read.error ?? new MaterialError("no-text", "No text found in this document");
+		}
+		for (const [index, pictureText] of read.texts.entries()) chunks.push(...chunkText(pictureText, { section: `§${section + index}` }));
+		if (!chunks.length) throw read.error ?? new MaterialError("no-text", "No text found in this document");
+		note = read.note;
+	}
 	if (!chunks.length) throw new MaterialError("no-text", "No text found in this document");
-	return { chunks };
+	return {
+		chunks,
+		ocr: note
+	};
 }
 const XML_ENTITIES = {
 	amp: "&",
@@ -1566,7 +2165,7 @@ function slideText(xml) {
 		return [...paragraph.matchAll(/<a:t(?:\s[^>]*)?>([\s\S]*?)<\/a:t>/gu)].map((match) => decodeXml(match[1])).join("");
 	}).filter((line) => line.trim()).join("\n");
 }
-async function extractPptx(bytes) {
+async function extractPptx(bytes, { recognize } = {}) {
 	const JSZip = (await import("jszip")).default;
 	let zip;
 	try {
@@ -1576,19 +2175,40 @@ async function extractPptx(bytes) {
 	}
 	const slideNumber = (name) => Number(/(\d+)\.xml$/u.exec(name)?.[1] ?? 0);
 	const slides = Object.keys(zip.files).filter((name) => /^ppt\/slides\/slide\d+\.xml$/u.test(name)).sort((a, b) => slideNumber(a) - slideNumber(b));
-	const chunks = [];
+	const texts = [];
+	const sources = [];
+	let written = 0;
 	for (const name of slides) {
 		const number = slideNumber(name);
 		const body = slideText(await zip.file(name).async("string"));
 		const notesFile = zip.file(`ppt/notesSlides/notesSlide${number}.xml`);
 		const notes = notesFile ? slideText(await notesFile.async("string")) : "";
-		const combined = notes ? `${body}\n[notes] ${notes}` : body;
-		chunks.push(...chunkText(combined, { slide: number }));
+		texts.push({
+			number,
+			text: notes ? `${body}\n[notes] ${notes}` : body
+		});
+		if (visibleLength(body) < MIN_PAGE_TEXT) for (const picture of await partPictures(zip, name)) sources.push({
+			where: { slide: number },
+			image: async () => picture
+		});
+		else written += 1;
 	}
-	if (!chunks.length) throw new MaterialError("no-text", "No text found in these slides");
+	const read = await readPictures(recognize, sources);
+	if (sources.length && !written && !read.note?.read) {
+		if (!read.available) throw new MaterialError("pictures-need-vision", "These slides are pictures; reading them needs a model that can see images");
+		throw read.error ?? new MaterialError("no-text", "No text found in these slides");
+	}
+	const pictured = /* @__PURE__ */ new Map();
+	for (const [index, pictureText] of read.texts.entries()) {
+		const { slide } = sources[index].where;
+		pictured.set(slide, [pictured.get(slide), pictureText].filter(Boolean).join("\n\n"));
+	}
+	const chunks = texts.flatMap(({ number, text }) => chunkText([text, pictured.get(number)].filter(Boolean).join("\n\n"), { slide: number }));
+	if (!chunks.length) throw read.error ?? new MaterialError("no-text", "No text found in these slides");
 	return {
 		slides: slides.length,
-		chunks
+		chunks,
+		ocr: read.note
 	};
 }
 function extractPlain(bytes, kind) {
@@ -1607,30 +2227,46 @@ function extractPlain(bytes, kind) {
 		chunks
 	};
 }
-async function ingestFile({ name, bytes, signal }) {
+async function ingestFile({ name, bytes, signal, recognize }) {
 	if (!bytes?.length) throw new MaterialError("empty", "The file is empty");
 	if (bytes.length > 62914560) throw new MaterialError("too-large", "The file is larger than 60 MB");
 	const kind = detectKind(name, bytes);
 	const baseTitle = String(name ?? "").replace(/\.[^.]+$/u, "").slice(0, 120) || "Untitled";
 	if (kind === "image") {
 		if (bytes.length > 10485760) throw new MaterialError("image-too-large", "Images must be smaller than 10 MB");
-		return {
-			kind,
-			title: baseTitle,
-			chunks: [],
-			chars: 0,
-			truncated: false,
-			mime: imageMime(name, bytes)
-		};
+		const mime = imageMime(name, bytes);
+		const read = await readPictures(recognize, [{
+			where: { picture: 1 },
+			image: async () => ({
+				mime,
+				data: Buffer.from(bytes)
+			})
+		}]);
+		return finish(kind, baseTitle, chunkText(read.texts[0] ?? "", {}), {
+			mime,
+			...read.available ? { ocr: read.note } : {}
+		});
 	}
 	if (kind === "pdf") {
-		const result = await extractPdf(bytes, { signal });
-		return finish(kind, result.title || baseTitle, result.chunks, { pages: result.pages });
+		const result = await extractPdf(bytes, {
+			signal,
+			recognize
+		});
+		return finish(kind, result.title || baseTitle, result.chunks, {
+			pages: result.pages,
+			ocr: result.ocr
+		});
+	}
+	if (kind === "docx") {
+		const result = await extractDocx(bytes, { recognize });
+		return finish(kind, baseTitle, result.chunks, { ocr: result.ocr });
 	}
-	if (kind === "docx") return finish(kind, baseTitle, (await extractDocx(bytes)).chunks);
 	if (kind === "pptx") {
-		const result = await extractPptx(bytes);
-		return finish(kind, baseTitle, result.chunks, { slides: result.slides });
+		const result = await extractPptx(bytes, { recognize });
+		return finish(kind, baseTitle, result.chunks, {
+			slides: result.slides,
+			ocr: result.ocr
+		});
 	}
 	const result = extractPlain(bytes, kind);
 	return finish(kind, result.title || baseTitle, result.chunks);
@@ -1651,7 +2287,7 @@ function checkPublicUrl(value) {
 	}
 	return url;
 }
-async function ingestUrl(address, { fetchImpl = pageFetch, signal } = {}) {
+async function ingestUrl(address, { fetchImpl = pageFetch, signal, recognize } = {}) {
 	let url = checkPublicUrl(address);
 	let response;
 	for (let hop = 0; hop < 6; hop += 1) {
@@ -1685,7 +2321,8 @@ async function ingestUrl(address, { fetchImpl = pageFetch, signal } = {}) {
 		...await ingestFile({
 			name: `${url.pathname.split("/").pop() || "page"}.pdf`,
 			bytes,
-			signal
+			signal,
+			recognize
 		}),
 		kind: "url",
 		url: url.href
@@ -3071,7 +3708,7 @@ function correctedItem(old, raw) {
 		...raw,
 		kind: old.kind
 	}, 0);
-	if (!next || (old.options?.length ?? 0) !== (next.options?.length ?? 0)) return null;
+	if (!next || next.kind !== old.kind || (old.options?.length ?? 0) !== (next.options?.length ?? 0)) return null;
 	const redrawn = [
 		"svg",
 		"figure",
@@ -4454,14 +5091,17 @@ function createLlmPort({ getLlm, getDefault, getAttachments, prefs, logger }) {
 			return null;
 		}
 	}
-	async function content(user, images, prepared) {
+	async function content(user, images, prepared, required) {
 		const blocks = [{
 			type: "text",
 			text: String(user ?? "")
 		}];
-		if (!images?.length || prepared.inputModalities?.includes("image") !== true) return blocks;
+		if (!images?.length) return blocks;
 		const attachments = getAttachments();
-		if (typeof attachments?.saveImage !== "function") return blocks;
+		if (prepared.inputModalities?.includes("image") !== true || typeof attachments?.saveImage !== "function") {
+			if (required) throw new TutorError("llm-no-vision", "The selected model cannot see images. Pick one that can in Aha settings.");
+			return blocks;
+		}
 		for (const [index, image] of images.slice(0, 4).entries()) try {
 			const ref = await attachments.saveImage({
 				data: Buffer.from(image.base64, "base64"),
@@ -4473,11 +5113,12 @@ function createLlmPort({ getLlm, getDefault, getAttachments, prefs, logger }) {
 				attachment: ref
 			});
 		} catch (error) {
+			if (required) throw new TutorError("image-unusable", "This picture could not be given to the model.");
 			logger?.debug?.("aha-tutor could not attach an image: %s", error?.message);
 		}
 		return blocks;
 	}
-	async function attempt({ purpose, effort, system, user, images, maxTokens, signal, onText, onReasoning }) {
+	async function attempt({ purpose, effort, system, user, images, requireImages = false, maxTokens, signal, onText, onReasoning }) {
 		const llm = getLlm();
 		if (!llm) throw new TutorError("llm-missing", "DSH has no model service in this profile.");
 		const target = route(purpose);
@@ -4504,7 +5145,7 @@ function createLlmPort({ getLlm, getDefault, getAttachments, prefs, logger }) {
 		let finish = null;
 		const messages = [{
 			role: "user",
-			content: await content(user, images, prepared)
+			content: await content(user, images, prepared, requireImages)
 		}];
 		try {
 			for await (const chunk of prepared.stream({
@@ -6379,6 +7020,7 @@ const PREF_DEFAULTS = Object.freeze({
 	boardTheme: "auto",
 	boardFont: "hand",
 	boardView: "canvas",
+	textSize: "standard",
 	ttsProvider: "openai",
 	tts: Object.fromEntries(TTS_PROVIDERS.map((provider) => [provider, providerDefaults(provider)]))
 });
@@ -6410,6 +7052,11 @@ function cleanPrefs(input = {}, base = PREF_DEFAULTS) {
 	].includes(input.boardTheme)) next.boardTheme = input.boardTheme;
 	if (["hand", "standard"].includes(input.boardFont)) next.boardFont = input.boardFont;
 	if (["canvas", "pages"].includes(input.boardView)) next.boardView = input.boardView;
+	if ([
+		"standard",
+		"large",
+		"larger"
+	].includes(input.textSize)) next.textSize = input.textSize;
 	if (TTS_PROVIDERS.includes(input.ttsProvider)) next.ttsProvider = input.ttsProvider;
 	for (const provider of TTS_PROVIDERS) {
 		const patch = input.tts?.[provider];
@@ -6513,6 +7160,73 @@ function createSettingsService({ prefs, keys, llmPort }) {
 	};
 }
 //#endregion
+//#region src/host/recognize.js
+const AT_ONCE = 3;
+const STOPS = /* @__PURE__ */ new Set([
+	"llm-auth",
+	"llm-quota",
+	"llm-missing",
+	"llm-unavailable",
+	"llm-no-vision"
+]);
+const MAX_TOKENS = 6e3;
+async function visionPurpose(llm, signal) {
+	await llm.refreshCapabilities?.(signal);
+	return ["quick", "teach"].find((purpose) => llm.supportsImages?.(purpose)) ?? null;
+}
+function cleanTranscript(value) {
+	return String(value ?? "").trim().replace(/^```[\w-]*\n([\s\S]*?)\n```$/u, "$1").replaceAll(RECOGNIZE_EMPTY, "").trim();
+}
+function createRecognizer({ llm, signal, onProgress, atOnce = AT_ONCE }) {
+	let route = null;
+	async function read(purpose, image) {
+		const prompt = recognizePrompt();
+		return cleanTranscript(await llm.complete({
+			purpose,
+			effort: "lowest",
+			system: prompt.system,
+			user: prompt.user,
+			images: [{
+				mime: image.mime,
+				base64: Buffer.from(image.data).toString("base64")
+			}],
+			requireImages: true,
+			maxTokens: MAX_TOKENS,
+			signal
+		}));
+	}
+	return async (sources) => {
+		route ??= visionPurpose(llm, signal);
+		const purpose = await route;
+		if (!purpose) return null;
+		const results = new Array(sources.length).fill(null);
+		let next = 0;
+		let done = 0;
+		let stopped = null;
+		onProgress?.(0, sources.length);
+		const worker = async () => {
+			while (next < sources.length) {
+				const index = next;
+				next += 1;
+				signal?.throwIfAborted();
+				try {
+					if (stopped) throw stopped;
+					const image = await sources[index].image();
+					results[index] = { text: image ? await read(purpose, image) : "" };
+				} catch (error) {
+					if (signal?.aborted) throw signal.reason ?? error;
+					if (STOPS.has(error?.code)) stopped ??= error;
+					results[index] = { error };
+				}
+				done += 1;
+				onProgress?.(done, sources.length);
+			}
+		};
+		await Promise.all(Array.from({ length: Math.max(1, Math.min(atOnce, sources.length)) }, worker));
+		return results;
+	};
+}
+//#endregion
 //#region src/host/studio.js
 const ASSIST_MODES = [
 	"explain",
@@ -6535,6 +7249,7 @@ function createStudio({ store, llm, jobs, now = () => /* @__PURE__ */ new Date()
 			truncated: result.truncated === true,
 			mime: result.mime ?? null,
 			url: result.url ?? null,
+			ocr: result.ocr ?? null,
 			createdAt: stamp(),
 			brief: null,
 			...extra
@@ -6565,6 +7280,11 @@ function createStudio({ store, llm, jobs, now = () => /* @__PURE__ */ new Date()
 		await store.writeJson(store.paths.material(id), meta);
 		return meta;
 	}
+	const recognizer = (api) => createRecognizer({
+		llm,
+		signal: api.signal,
+		onProgress: (done, total) => api.progress(done, total, "recognizing")
+	});
 	function upload({ name, base64, bytes: raw }) {
 		const fileName = text(name, 200) || "file";
 		if (!raw && (typeof base64 !== "string" || !base64)) throw new TutorError("invalid", "No file data");
@@ -6575,7 +7295,8 @@ function createStudio({ store, llm, jobs, now = () => /* @__PURE__ */ new Date()
 			const result = await ingestFile({
 				name: fileName,
 				bytes,
-				signal: api.signal
+				signal: api.signal,
+				recognize: recognizer(api)
 			});
 			api.progress(1, 2, "summarizing");
 			return { material: await saveMaterial(result, {
@@ -6588,7 +7309,10 @@ function createStudio({ store, llm, jobs, now = () => /* @__PURE__ */ new Date()
 	function addUrl({ url }) {
 		return jobs.start("material/url", async (api) => {
 			api.progress(0, 2, "fetching");
-			const result = await ingestUrl(url, { signal: api.signal });
+			const result = await ingestUrl(url, {
+				signal: api.signal,
+				recognize: recognizer(api)
+			});
 			api.progress(1, 2, "summarizing");
 			return { material: await saveMaterial(result, { signal: api.signal }) };
 		});
@@ -6602,7 +7326,7 @@ function createStudio({ store, llm, jobs, now = () => /* @__PURE__ */ new Date()
 	async function searchMaterials({ query }) {
 		const wanted = text(query, 200);
 		if (!wanted) return { results: [] };
-		const metas = (await listMaterials()).filter((meta) => meta.kind !== "image");
+		const metas = (await listMaterials()).filter((meta) => meta.kind !== "image" || meta.chars > 0);
 		const key = metas.map((meta) => `${meta.id}:${meta.title}:${meta.chars ?? meta.pages ?? ""}`).join("|");
 		if (libraryIndex?.key !== key) {
 			const chunks = [];