@visual-z/xeno 0.8.4 → 0.9.0

package/src/vendor/pi-rich/exif-orientation.ts

@@ -1,182 +0,0 @@
-import type { PhotonImageType } from "./photon.ts";
-
-type Photon = typeof import("@silvia-odwyer/photon-node");
-
-function readOrientationFromTiff(bytes: Uint8Array, tiffStart: number): number {
-	if (tiffStart + 8 > bytes.length) return 1;
-
-	const byteOrder = (bytes[tiffStart] << 8) | bytes[tiffStart + 1];
-	const le = byteOrder === 0x4949;
-
-	const read16 = (pos: number): number => {
-		if (le) return bytes[pos] | (bytes[pos + 1] << 8);
-		return (bytes[pos] << 8) | bytes[pos + 1];
-	};
-
-	const read32 = (pos: number): number => {
-		if (le) return bytes[pos] | (bytes[pos + 1] << 8) | (bytes[pos + 2] << 16) | (bytes[pos + 3] << 24);
-		return ((bytes[pos] << 24) | (bytes[pos + 1] << 16) | (bytes[pos + 2] << 8) | bytes[pos + 3]) >>> 0;
-	};
-
-	const ifdOffset = read32(tiffStart + 4);
-	const ifdStart = tiffStart + ifdOffset;
-	if (ifdStart + 2 > bytes.length) return 1;
-
-	const entryCount = read16(ifdStart);
-	for (let i = 0; i < entryCount; i++) {
-		const entryPos = ifdStart + 2 + i * 12;
-		if (entryPos + 12 > bytes.length) return 1;
-
-		if (read16(entryPos) === 0x0112) {
-			const value = read16(entryPos + 8);
-			return value >= 1 && value <= 8 ? value : 1;
-		}
-	}
-
-	return 1;
-}
-
-function findJpegTiffOffset(bytes: Uint8Array): number {
-	let offset = 2;
-	while (offset < bytes.length - 1) {
-		if (bytes[offset] !== 0xff) return -1;
-		const marker = bytes[offset + 1];
-		if (marker === 0xff) {
-			offset++;
-			continue;
-		}
-
-		if (marker === 0xe1) {
-			if (offset + 4 >= bytes.length) return -1;
-			const segmentStart = offset + 4;
-			if (segmentStart + 6 > bytes.length) return -1;
-			if (hasExifHeader(bytes, segmentStart)) return segmentStart + 6;
-		}
-
-		if (offset + 4 > bytes.length) return -1;
-		const length = (bytes[offset + 2] << 8) | bytes[offset + 3];
-		offset += 2 + length;
-	}
-
-	return -1;
-}
-
-function findWebpTiffOffset(bytes: Uint8Array): number {
-	let offset = 12;
-	while (offset + 8 <= bytes.length) {
-		const chunkId = String.fromCharCode(bytes[offset], bytes[offset + 1], bytes[offset + 2], bytes[offset + 3]);
-		const chunkSize =
-			bytes[offset + 4] | (bytes[offset + 5] << 8) | (bytes[offset + 6] << 16) | (bytes[offset + 7] << 24);
-		const dataStart = offset + 8;
-
-		if (chunkId === "EXIF") {
-			if (dataStart + chunkSize > bytes.length) return -1;
-			// Some WebP files have "Exif\0\0" prefix before the TIFF header
-			const tiffStart = chunkSize >= 6 && hasExifHeader(bytes, dataStart) ? dataStart + 6 : dataStart;
-			return tiffStart;
-		}
-
-		// RIFF chunks are padded to even size
-		offset = dataStart + chunkSize + (chunkSize % 2);
-	}
-
-	return -1;
-}
-
-function hasExifHeader(bytes: Uint8Array, offset: number): boolean {
-	return (
-		bytes[offset] === 0x45 &&
-		bytes[offset + 1] === 0x78 &&
-		bytes[offset + 2] === 0x69 &&
-		bytes[offset + 3] === 0x66 &&
-		bytes[offset + 4] === 0x00 &&
-		bytes[offset + 5] === 0x00
-	);
-}
-
-function getExifOrientation(bytes: Uint8Array): number {
-	let tiffOffset = -1;
-
-	// JPEG: starts with FF D8
-	if (bytes.length >= 2 && bytes[0] === 0xff && bytes[1] === 0xd8) {
-		tiffOffset = findJpegTiffOffset(bytes);
-	}
-	// WebP: starts with RIFF....WEBP
-	else if (
-		bytes.length >= 12 &&
-		bytes[0] === 0x52 &&
-		bytes[1] === 0x49 &&
-		bytes[2] === 0x46 &&
-		bytes[3] === 0x46 &&
-		bytes[8] === 0x57 &&
-		bytes[9] === 0x45 &&
-		bytes[10] === 0x42 &&
-		bytes[11] === 0x50
-	) {
-		tiffOffset = findWebpTiffOffset(bytes);
-	}
-
-	if (tiffOffset === -1) return 1;
-	return readOrientationFromTiff(bytes, tiffOffset);
-}
-
-type DstIndexFn = (x: number, y: number, w: number, h: number) => number;
-
-function rotate90(photon: Photon, image: PhotonImageType, dstIndex: DstIndexFn): PhotonImageType {
-	const w = image.get_width();
-	const h = image.get_height();
-	const src = image.get_raw_pixels();
-	const dst = new Uint8Array(src.length);
-
-	for (let y = 0; y < h; y++) {
-		for (let x = 0; x < w; x++) {
-			const srcIdx = (y * w + x) * 4;
-			const dstIdx = dstIndex(x, y, w, h) * 4;
-			dst[dstIdx] = src[srcIdx];
-			dst[dstIdx + 1] = src[srcIdx + 1];
-			dst[dstIdx + 2] = src[srcIdx + 2];
-			dst[dstIdx + 3] = src[srcIdx + 3];
-		}
-	}
-
-	return new photon.PhotonImage(dst, h, w);
-}
-
-// Flip orientations mutate in-place. Rotations return a new image (caller must free the old one if different).
-export function applyExifOrientation(
-	photon: Photon,
-	image: PhotonImageType,
-	originalBytes: Uint8Array,
-): PhotonImageType {
-	const orientation = getExifOrientation(originalBytes);
-	if (orientation === 1) return image;
-
-	switch (orientation) {
-		case 2:
-			photon.fliph(image);
-			return image;
-		case 3:
-			photon.fliph(image);
-			photon.flipv(image);
-			return image;
-		case 4:
-			photon.flipv(image);
-			return image;
-		case 5: {
-			const rotated = rotate90(photon, image, (x, y, _w, h) => x * h + (h - 1 - y));
-			photon.fliph(rotated);
-			return rotated;
-		}
-		case 6:
-			return rotate90(photon, image, (x, y, _w, h) => x * h + (h - 1 - y));
-		case 7: {
-			const rotated = rotate90(photon, image, (x, y, w, h) => (w - 1 - x) * h + y);
-			photon.fliph(rotated);
-			return rotated;
-		}
-		case 8:
-			return rotate90(photon, image, (x, y, w, h) => (w - 1 - x) * h + y);
-		default:
-			return image;
-	}
-}

package/src/vendor/pi-rich/html.ts

@@ -1,51 +0,0 @@
-export interface DecodedHtmlEntity {
-	text: string;
-	length: number;
-}
-
-function decodeCodePoint(codePoint: number): string | undefined {
-	if (!Number.isInteger(codePoint) || codePoint < 0 || codePoint > 0x10ffff) {
-		return undefined;
-	}
-	return String.fromCodePoint(codePoint);
-}
-
-export function decodeHtmlEntity(entity: string): string | undefined {
-	switch (entity) {
-		case "amp":
-			return "&";
-		case "lt":
-			return "<";
-		case "gt":
-			return ">";
-		case "quot":
-			return '"';
-		case "apos":
-			return "'";
-	}
-
-	if (entity.startsWith("#x") || entity.startsWith("#X")) {
-		return decodeCodePoint(Number.parseInt(entity.slice(2), 16));
-	}
-
-	if (entity.startsWith("#")) {
-		return decodeCodePoint(Number.parseInt(entity.slice(1), 10));
-	}
-
-	return undefined;
-}
-
-export function decodeHtmlEntityAt(html: string, index: number): DecodedHtmlEntity | undefined {
-	const semicolonIndex = html.indexOf(";", index + 1);
-	if (semicolonIndex === -1 || semicolonIndex - index > 16) {
-		return undefined;
-	}
-
-	const entity = html.slice(index + 1, semicolonIndex);
-	const decoded = decodeHtmlEntity(entity);
-	if (decoded === undefined) {
-		return undefined;
-	}
-
-	return { text: decoded, length: semicolonIndex - index + 1 };
-}

package/src/vendor/pi-rich/image-convert.ts

@@ -1,49 +0,0 @@
-import { applyExifOrientation } from "./exif-orientation.ts";
-import { loadPhoton } from "./photon.ts";
-
-export async function convertImageBytesToPng(bytes: Uint8Array): Promise<Uint8Array | null> {
-	const photon = await loadPhoton();
-	if (!photon) {
-		// Photon not available, can't convert
-		return null;
-	}
-
-	try {
-		const rawImage = photon.PhotonImage.new_from_byteslice(bytes);
-		const image = applyExifOrientation(photon, rawImage, bytes);
-		if (image !== rawImage) rawImage.free();
-		try {
-			return new Uint8Array(image.get_bytes());
-		} finally {
-			image.free();
-		}
-	} catch {
-		// Conversion failed
-		return null;
-	}
-}
-
-/**
- * Convert image to PNG format for terminal display.
- * Kitty graphics protocol requires PNG format (f=100).
- */
-export async function convertToPng(
-	base64Data: string,
-	mimeType: string,
-): Promise<{ data: string; mimeType: string } | null> {
-	// Already PNG, no conversion needed
-	if (mimeType === "image/png") {
-		return { data: base64Data, mimeType };
-	}
-
-	const bytes = new Uint8Array(Buffer.from(base64Data, "base64"));
-	const pngBytes = await convertImageBytesToPng(bytes);
-	if (!pngBytes) {
-		return null;
-	}
-
-	return {
-		data: Buffer.from(pngBytes).toString("base64"),
-		mimeType: "image/png",
-	};
-}

package/src/vendor/pi-rich/image-resize-core.ts

@@ -1,164 +0,0 @@
-import { applyExifOrientation } from "./exif-orientation.ts";
-import { loadPhoton } from "./photon.ts";
-
-export interface ImageResizeOptions {
-	maxWidth?: number; // Default: 2000
-	maxHeight?: number; // Default: 2000
-	maxBytes?: number; // Default: 4.5MB of base64 payload (below Anthropic's 5MB limit)
-	jpegQuality?: number; // Default: 80
-}
-
-export interface ResizedImage {
-	data: string; // base64
-	mimeType: string;
-	originalWidth: number;
-	originalHeight: number;
-	width: number;
-	height: number;
-	wasResized: boolean;
-}
-
-// 4.5MB of base64 payload. Provides headroom below Anthropic's 5MB limit.
-const DEFAULT_MAX_BYTES = 4.5 * 1024 * 1024;
-
-const DEFAULT_OPTIONS: Required<ImageResizeOptions> = {
-	maxWidth: 2000,
-	maxHeight: 2000,
-	maxBytes: DEFAULT_MAX_BYTES,
-	jpegQuality: 80,
-};
-
-interface EncodedCandidate {
-	data: string;
-	encodedSize: number;
-	mimeType: string;
-}
-
-function encodeCandidate(buffer: Uint8Array, mimeType: string): EncodedCandidate {
-	const data = Buffer.from(buffer).toString("base64");
-	return {
-		data,
-		encodedSize: Buffer.byteLength(data, "utf-8"),
-		mimeType,
-	};
-}
-
-/**
- * Resize an image to fit within the specified max dimensions and encoded file size.
- * Returns null if the image cannot be resized below maxBytes.
- *
- * Uses Photon (Rust/WASM) for image processing. If Photon is not available,
- * returns null.
- *
- * Strategy for staying under maxBytes:
- * 1. First resize to maxWidth/maxHeight
- * 2. Try both PNG and JPEG formats, pick the smaller one
- * 3. If still too large, try JPEG with decreasing quality
- * 4. If still too large, progressively reduce dimensions until 1x1
- */
-export async function resizeImageInProcess(
-	inputBytes: Uint8Array,
-	mimeType: string,
-	options?: ImageResizeOptions,
-): Promise<ResizedImage | null> {
-	const opts = { ...DEFAULT_OPTIONS, ...options };
-	const inputBase64Size = Math.ceil(inputBytes.byteLength / 3) * 4;
-
-	const photon = await loadPhoton();
-	if (!photon) {
-		return null;
-	}
-
-	let image: ReturnType<typeof photon.PhotonImage.new_from_byteslice> | undefined;
-	try {
-		const rawImage = photon.PhotonImage.new_from_byteslice(inputBytes);
-		image = applyExifOrientation(photon, rawImage, inputBytes);
-		if (image !== rawImage) rawImage.free();
-
-		const originalWidth = image.get_width();
-		const originalHeight = image.get_height();
-		const format = mimeType.split("/")[1] ?? "png";
-
-		// Check if already within all limits (dimensions AND encoded size)
-		if (originalWidth <= opts.maxWidth && originalHeight <= opts.maxHeight && inputBase64Size < opts.maxBytes) {
-			return {
-				data: Buffer.from(inputBytes).toString("base64"),
-				mimeType: mimeType || `image/${format}`,
-				originalWidth,
-				originalHeight,
-				width: originalWidth,
-				height: originalHeight,
-				wasResized: false,
-			};
-		}
-
-		// Calculate initial dimensions respecting max limits
-		let targetWidth = originalWidth;
-		let targetHeight = originalHeight;
-
-		if (targetWidth > opts.maxWidth) {
-			targetHeight = Math.round((targetHeight * opts.maxWidth) / targetWidth);
-			targetWidth = opts.maxWidth;
-		}
-		if (targetHeight > opts.maxHeight) {
-			targetWidth = Math.round((targetWidth * opts.maxHeight) / targetHeight);
-			targetHeight = opts.maxHeight;
-		}
-
-		function tryEncodings(width: number, height: number, jpegQualities: number[]): EncodedCandidate[] {
-			const resized = photon!.resize(image!, width, height, photon!.SamplingFilter.Lanczos3);
-
-			try {
-				const candidates: EncodedCandidate[] = [encodeCandidate(resized.get_bytes(), "image/png")];
-				for (const quality of jpegQualities) {
-					candidates.push(encodeCandidate(resized.get_bytes_jpeg(quality), "image/jpeg"));
-				}
-				return candidates;
-			} finally {
-				resized.free();
-			}
-		}
-
-		const qualitySteps = Array.from(new Set([opts.jpegQuality, 85, 70, 55, 40]));
-		let currentWidth = targetWidth;
-		let currentHeight = targetHeight;
-
-		while (true) {
-			const candidates = tryEncodings(currentWidth, currentHeight, qualitySteps);
-			for (const candidate of candidates) {
-				if (candidate.encodedSize < opts.maxBytes) {
-					return {
-						data: candidate.data,
-						mimeType: candidate.mimeType,
-						originalWidth,
-						originalHeight,
-						width: currentWidth,
-						height: currentHeight,
-						wasResized: true,
-					};
-				}
-			}
-
-			if (currentWidth === 1 && currentHeight === 1) {
-				break;
-			}
-
-			const nextWidth = currentWidth === 1 ? 1 : Math.max(1, Math.floor(currentWidth * 0.75));
-			const nextHeight = currentHeight === 1 ? 1 : Math.max(1, Math.floor(currentHeight * 0.75));
-			if (nextWidth === currentWidth && nextHeight === currentHeight) {
-				break;
-			}
-
-			currentWidth = nextWidth;
-			currentHeight = nextHeight;
-		}
-
-		return null;
-	} catch {
-		return null;
-	} finally {
-		if (image) {
-			image.free();
-		}
-	}
-}

package/src/vendor/pi-rich/image-resize-worker.ts

@@ -1,42 +0,0 @@
-import { parentPort } from "node:worker_threads";
-import { type ImageResizeOptions, type ResizedImage, resizeImageInProcess } from "./image-resize-core.ts";
-
-interface ResizeImageWorkerRequest {
-	inputBytes: Uint8Array;
-	mimeType: string;
-	options?: ImageResizeOptions;
-}
-
-interface ResizeImageWorkerResponse {
-	result?: ResizedImage | null;
-	error?: string;
-}
-
-function isResizeImageWorkerRequest(value: unknown): value is ResizeImageWorkerRequest {
-	if (!value || typeof value !== "object") return false;
-	const record = value as Record<string, unknown>;
-	return record.inputBytes instanceof Uint8Array && typeof record.mimeType === "string";
-}
-
-const port = parentPort;
-if (!port) {
-	throw new Error("image resize worker requires parentPort");
-}
-
-port.once("message", (message: unknown) => {
-	void (async () => {
-		try {
-			if (!isResizeImageWorkerRequest(message)) {
-				throw new Error("Invalid image resize worker request");
-			}
-			const result = await resizeImageInProcess(message.inputBytes, message.mimeType, message.options);
-			const response: ResizeImageWorkerResponse = { result };
-			port.postMessage(response);
-		} catch (error) {
-			const response: ResizeImageWorkerResponse = {
-				error: error instanceof Error ? error.message : String(error),
-			};
-			port.postMessage(response);
-		}
-	})();
-});

package/src/vendor/pi-rich/image-resize.ts

@@ -1,123 +0,0 @@
-import { Worker } from "node:worker_threads";
-import { type ImageResizeOptions, type ResizedImage, resizeImageInProcess } from "./image-resize-core.ts";
-
-export type { ImageResizeOptions, ResizedImage } from "./image-resize-core.ts";
-
-interface ResizeImageWorkerResponse {
-	result?: ResizedImage | null;
-	error?: string;
-}
-
-function toTransferableBytes(input: Uint8Array): Uint8Array<ArrayBuffer> {
-	// Transfer detaches the buffer, so transfer a worker-owned copy and leave the
-	// caller's bytes intact.
-	return new Uint8Array(input);
-}
-
-function isResizeImageWorkerResponse(value: unknown): value is ResizeImageWorkerResponse {
-	return value !== null && typeof value === "object";
-}
-
-function createResizeWorker(workerSpecifier: string | URL): Worker {
-	return new Worker(workerSpecifier);
-}
-
-async function resizeImageInWorker(
-	workerSpecifier: string | URL,
-	inputBytes: Uint8Array,
-	mimeType: string,
-	options?: ImageResizeOptions,
-): Promise<ResizedImage | null> {
-	const worker = createResizeWorker(workerSpecifier);
-	try {
-		const inputBytesForWorker = toTransferableBytes(inputBytes);
-		return await new Promise<ResizedImage | null>((resolve, reject) => {
-			let settled = false;
-			const settle = (result: ResizedImage | null): void => {
-				if (settled) return;
-				settled = true;
-				resolve(result);
-			};
-			const fail = (error: Error): void => {
-				if (settled) return;
-				settled = true;
-				reject(error);
-			};
-
-			worker.once("message", (message: unknown) => {
-				if (!isResizeImageWorkerResponse(message)) {
-					fail(new Error("Invalid image resize worker response"));
-					return;
-				}
-				if (message.error) {
-					fail(new Error(message.error));
-					return;
-				}
-				settle(message.result ?? null);
-			});
-			worker.once("error", fail);
-			worker.once("exit", (code) => {
-				if (!settled) {
-					fail(new Error(`Image resize worker exited with code ${code}`));
-				}
-			});
-			worker.postMessage(
-				{
-					inputBytes: inputBytesForWorker,
-					mimeType,
-					options,
-				},
-				[inputBytesForWorker.buffer],
-			);
-		});
-	} finally {
-		void worker.terminate().catch(() => undefined);
-	}
-}
-
-/**
- * Resize an image to fit within the specified max dimensions and encoded file size.
- * Runs Photon in a worker thread so WASM decoding, resizing, and encoding do not
- * block the TUI event loop. If the worker cannot be loaded (for example in some
- * Bun compiled executable layouts), fall back to in-process resizing so image
- * reads still work.
- */
-export async function resizeImage(
-	inputBytes: Uint8Array,
-	mimeType: string,
-	options?: ImageResizeOptions,
-): Promise<ResizedImage | null> {
-	const isTypeScriptRuntime = import.meta.url.endsWith(".ts");
-	const workerUrl = new URL(
-		isTypeScriptRuntime ? "./image-resize-worker.ts" : "./image-resize-worker.js",
-		import.meta.url,
-	);
-
-	// Bun compiled executables resolve worker entrypoints by string path, not via
-	// new URL(..., import.meta.url). Try the string path first under Bun so the
-	// release binary uses the embedded worker instead of falling back in-process.
-	if (typeof process.versions.bun === "string") {
-		try {
-			return await resizeImageInWorker("./src/utils/image-resize-worker.ts", inputBytes, mimeType, options);
-		} catch {}
-	}
-
-	try {
-		return await resizeImageInWorker(workerUrl, inputBytes, mimeType, options);
-	} catch {
-		return resizeImageInProcess(inputBytes, mimeType, options);
-	}
-}
-
-/**
- * Format a dimension note for resized images.
- * This helps the model understand the coordinate mapping.
- */
-export function formatDimensionNote(result: ResizedImage): string | undefined {
-	if (!result.wasResized) {
-		return undefined;
-	}
-
-	const scale = result.originalWidth / result.width;
-	return `[Image: original ${result.originalWidth}x${result.originalHeight}, displayed at ${result.width}x${result.height}. Multiply coordinates by ${scale.toFixed(2)} to map to original image.]`;
-}