pi-usereq 0.49.0 → 0.51.0

package/pi.dev-src/pi-mono/coding-agent/src/utils/child-process.ts

@@ -1,86 +0,0 @@
-import type { ChildProcess } from "node:child_process";
-
-const EXIT_STDIO_GRACE_MS = 100;
-
-/**
- * Wait for a child process to terminate without hanging on inherited stdio handles.
- *
- * On Windows, daemonized descendants can inherit the child's stdout/stderr pipe
- * handles. In that case the child emits `exit`, but `close` can hang forever even
- * though the original process is already gone. We wait briefly for stdio to end,
- * then forcibly stop tracking the inherited handles.
- */
-export function waitForChildProcess(child: ChildProcess): Promise<number | null> {
-	return new Promise((resolve, reject) => {
-		let settled = false;
-		let exited = false;
-		let exitCode: number | null = null;
-		let postExitTimer: NodeJS.Timeout | undefined;
-		let stdoutEnded = child.stdout === null;
-		let stderrEnded = child.stderr === null;
-
-		const cleanup = () => {
-			if (postExitTimer) {
-				clearTimeout(postExitTimer);
-				postExitTimer = undefined;
-			}
-			child.removeListener("error", onError);
-			child.removeListener("exit", onExit);
-			child.removeListener("close", onClose);
-			child.stdout?.removeListener("end", onStdoutEnd);
-			child.stderr?.removeListener("end", onStderrEnd);
-		};
-
-		const finalize = (code: number | null) => {
-			if (settled) return;
-			settled = true;
-			cleanup();
-			child.stdout?.destroy();
-			child.stderr?.destroy();
-			resolve(code);
-		};
-
-		const maybeFinalizeAfterExit = () => {
-			if (!exited || settled) return;
-			if (stdoutEnded && stderrEnded) {
-				finalize(exitCode);
-			}
-		};
-
-		const onStdoutEnd = () => {
-			stdoutEnded = true;
-			maybeFinalizeAfterExit();
-		};
-
-		const onStderrEnd = () => {
-			stderrEnded = true;
-			maybeFinalizeAfterExit();
-		};
-
-		const onError = (err: Error) => {
-			if (settled) return;
-			settled = true;
-			cleanup();
-			reject(err);
-		};
-
-		const onExit = (code: number | null) => {
-			exited = true;
-			exitCode = code;
-			maybeFinalizeAfterExit();
-			if (!settled) {
-				postExitTimer = setTimeout(() => finalize(code), EXIT_STDIO_GRACE_MS);
-			}
-		};
-
-		const onClose = (code: number | null) => {
-			finalize(code);
-		};
-
-		child.stdout?.once("end", onStdoutEnd);
-		child.stderr?.once("end", onStderrEnd);
-		child.once("error", onError);
-		child.once("exit", onExit);
-		child.once("close", onClose);
-	});
-}

package/pi.dev-src/pi-mono/coding-agent/src/utils/clipboard-image.ts

@@ -1,300 +0,0 @@
-import { spawnSync } from "child_process";
-import { randomUUID } from "crypto";
-import { readFileSync, unlinkSync } from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
-
-import { clipboard } from "./clipboard-native.js";
-import { loadPhoton } from "./photon.js";
-
-export type ClipboardImage = {
-	bytes: Uint8Array;
-	mimeType: string;
-};
-
-const SUPPORTED_IMAGE_MIME_TYPES = ["image/png", "image/jpeg", "image/webp", "image/gif"] as const;
-
-const DEFAULT_LIST_TIMEOUT_MS = 1000;
-const DEFAULT_READ_TIMEOUT_MS = 3000;
-const DEFAULT_POWERSHELL_TIMEOUT_MS = 5000;
-const DEFAULT_MAX_BUFFER_BYTES = 50 * 1024 * 1024;
-
-export function isWaylandSession(env: NodeJS.ProcessEnv = process.env): boolean {
-	return Boolean(env.WAYLAND_DISPLAY) || env.XDG_SESSION_TYPE === "wayland";
-}
-
-function baseMimeType(mimeType: string): string {
-	return mimeType.split(";")[0]?.trim().toLowerCase() ?? mimeType.toLowerCase();
-}
-
-export function extensionForImageMimeType(mimeType: string): string | null {
-	switch (baseMimeType(mimeType)) {
-		case "image/png":
-			return "png";
-		case "image/jpeg":
-			return "jpg";
-		case "image/webp":
-			return "webp";
-		case "image/gif":
-			return "gif";
-		default:
-			return null;
-	}
-}
-
-function selectPreferredImageMimeType(mimeTypes: string[]): string | null {
-	const normalized = mimeTypes
-		.map((t) => t.trim())
-		.filter(Boolean)
-		.map((t) => ({ raw: t, base: baseMimeType(t) }));
-
-	for (const preferred of SUPPORTED_IMAGE_MIME_TYPES) {
-		const match = normalized.find((t) => t.base === preferred);
-		if (match) {
-			return match.raw;
-		}
-	}
-
-	const anyImage = normalized.find((t) => t.base.startsWith("image/"));
-	return anyImage?.raw ?? null;
-}
-
-function isSupportedImageMimeType(mimeType: string): boolean {
-	const base = baseMimeType(mimeType);
-	return SUPPORTED_IMAGE_MIME_TYPES.some((t) => t === base);
-}
-
-/**
- * Convert unsupported image formats to PNG using Photon.
- * Returns null if conversion is unavailable or fails.
- */
-async function convertToPng(bytes: Uint8Array): Promise<Uint8Array | null> {
-	const photon = await loadPhoton();
-	if (!photon) {
-		return null;
-	}
-
-	try {
-		const image = photon.PhotonImage.new_from_byteslice(bytes);
-		try {
-			return image.get_bytes();
-		} finally {
-			image.free();
-		}
-	} catch {
-		return null;
-	}
-}
-
-function runCommand(
-	command: string,
-	args: string[],
-	options?: { timeoutMs?: number; maxBufferBytes?: number; env?: NodeJS.ProcessEnv },
-): { stdout: Buffer; ok: boolean } {
-	const timeoutMs = options?.timeoutMs ?? DEFAULT_READ_TIMEOUT_MS;
-	const maxBufferBytes = options?.maxBufferBytes ?? DEFAULT_MAX_BUFFER_BYTES;
-
-	const result = spawnSync(command, args, {
-		timeout: timeoutMs,
-		maxBuffer: maxBufferBytes,
-		env: options?.env,
-	});
-
-	if (result.error) {
-		return { ok: false, stdout: Buffer.alloc(0) };
-	}
-
-	if (result.status !== 0) {
-		return { ok: false, stdout: Buffer.alloc(0) };
-	}
-
-	const stdout = Buffer.isBuffer(result.stdout)
-		? result.stdout
-		: Buffer.from(result.stdout ?? "", typeof result.stdout === "string" ? "utf-8" : undefined);
-
-	return { ok: true, stdout };
-}
-
-function readClipboardImageViaWlPaste(): ClipboardImage | null {
-	const list = runCommand("wl-paste", ["--list-types"], { timeoutMs: DEFAULT_LIST_TIMEOUT_MS });
-	if (!list.ok) {
-		return null;
-	}
-
-	const types = list.stdout
-		.toString("utf-8")
-		.split(/\r?\n/)
-		.map((t) => t.trim())
-		.filter(Boolean);
-
-	const selectedType = selectPreferredImageMimeType(types);
-	if (!selectedType) {
-		return null;
-	}
-
-	const data = runCommand("wl-paste", ["--type", selectedType, "--no-newline"]);
-	if (!data.ok || data.stdout.length === 0) {
-		return null;
-	}
-
-	return { bytes: data.stdout, mimeType: baseMimeType(selectedType) };
-}
-
-function isWSL(env: NodeJS.ProcessEnv = process.env): boolean {
-	if (env.WSL_DISTRO_NAME || env.WSLENV) {
-		return true;
-	}
-
-	try {
-		const release = readFileSync("/proc/version", "utf-8");
-		return /microsoft|wsl/i.test(release);
-	} catch {
-		return false;
-	}
-}
-
-/**
- * On WSL, the Linux clipboard (Wayland/X11) does not receive image data from
- * Windows screenshots (Win+Shift+S). PowerShell can access the Windows clipboard
- * directly, so we use it as a fallback.
- */
-function readClipboardImageViaPowerShell(): ClipboardImage | null {
-	const tmpFile = join(tmpdir(), `pi-wsl-clip-${randomUUID()}.png`);
-
-	try {
-		const winPathResult = runCommand("wslpath", ["-w", tmpFile], { timeoutMs: DEFAULT_LIST_TIMEOUT_MS });
-		if (!winPathResult.ok) {
-			return null;
-		}
-
-		const winPath = winPathResult.stdout.toString("utf-8").trim();
-		if (!winPath) {
-			return null;
-		}
-
-		const psScript = [
-			"Add-Type -AssemblyName System.Windows.Forms",
-			"Add-Type -AssemblyName System.Drawing",
-			"$path = $env:PI_WSL_CLIPBOARD_IMAGE_PATH",
-			"$img = [System.Windows.Forms.Clipboard]::GetImage()",
-			"if ($img) { $img.Save($path, [System.Drawing.Imaging.ImageFormat]::Png); Write-Output 'ok' } else { Write-Output 'empty' }",
-		].join("; ");
-
-		const result = runCommand("powershell.exe", ["-NoProfile", "-Command", psScript], {
-			timeoutMs: DEFAULT_POWERSHELL_TIMEOUT_MS,
-			env: { ...process.env, PI_WSL_CLIPBOARD_IMAGE_PATH: winPath },
-		});
-		if (!result.ok) {
-			return null;
-		}
-
-		const output = result.stdout.toString("utf-8").trim();
-		if (output !== "ok") {
-			return null;
-		}
-
-		const bytes = readFileSync(tmpFile);
-		if (bytes.length === 0) {
-			return null;
-		}
-
-		return { bytes: new Uint8Array(bytes), mimeType: "image/png" };
-	} catch {
-		return null;
-	} finally {
-		try {
-			unlinkSync(tmpFile);
-		} catch {
-			// Ignore cleanup errors.
-		}
-	}
-}
-
-function readClipboardImageViaXclip(): ClipboardImage | null {
-	const targets = runCommand("xclip", ["-selection", "clipboard", "-t", "TARGETS", "-o"], {
-		timeoutMs: DEFAULT_LIST_TIMEOUT_MS,
-	});
-
-	let candidateTypes: string[] = [];
-	if (targets.ok) {
-		candidateTypes = targets.stdout
-			.toString("utf-8")
-			.split(/\r?\n/)
-			.map((t) => t.trim())
-			.filter(Boolean);
-	}
-
-	const preferred = candidateTypes.length > 0 ? selectPreferredImageMimeType(candidateTypes) : null;
-	const tryTypes = preferred ? [preferred, ...SUPPORTED_IMAGE_MIME_TYPES] : [...SUPPORTED_IMAGE_MIME_TYPES];
-
-	for (const mimeType of tryTypes) {
-		const data = runCommand("xclip", ["-selection", "clipboard", "-t", mimeType, "-o"]);
-		if (data.ok && data.stdout.length > 0) {
-			return { bytes: data.stdout, mimeType: baseMimeType(mimeType) };
-		}
-	}
-
-	return null;
-}
-
-async function readClipboardImageViaNativeClipboard(): Promise<ClipboardImage | null> {
-	if (!clipboard || !clipboard.hasImage()) {
-		return null;
-	}
-
-	const imageData = await clipboard.getImageBinary();
-	if (!imageData || imageData.length === 0) {
-		return null;
-	}
-
-	const bytes = imageData instanceof Uint8Array ? imageData : Uint8Array.from(imageData);
-	return { bytes, mimeType: "image/png" };
-}
-
-export async function readClipboardImage(options?: {
-	env?: NodeJS.ProcessEnv;
-	platform?: NodeJS.Platform;
-}): Promise<ClipboardImage | null> {
-	const env = options?.env ?? process.env;
-	const platform = options?.platform ?? process.platform;
-
-	if (env.TERMUX_VERSION) {
-		return null;
-	}
-
-	let image: ClipboardImage | null = null;
-
-	if (platform === "linux") {
-		const wsl = isWSL(env);
-		const wayland = isWaylandSession(env);
-
-		if (wayland || wsl) {
-			image = readClipboardImageViaWlPaste() ?? readClipboardImageViaXclip();
-		}
-
-		if (!image && wsl) {
-			image = readClipboardImageViaPowerShell();
-		}
-
-		if (!image && !wayland) {
-			image = await readClipboardImageViaNativeClipboard();
-		}
-	} else {
-		image = await readClipboardImageViaNativeClipboard();
-	}
-
-	if (!image) {
-		return null;
-	}
-
-	// Convert unsupported formats (e.g., BMP from WSLg) to PNG
-	if (!isSupportedImageMimeType(image.mimeType)) {
-		const pngBytes = await convertToPng(image.bytes);
-		if (!pngBytes) {
-			return null;
-		}
-		return { bytes: pngBytes, mimeType: "image/png" };
-	}
-
-	return image;
-}

package/pi.dev-src/pi-mono/coding-agent/src/utils/clipboard-native.ts

@@ -1,22 +0,0 @@
-import { createRequire } from "module";
-
-export type ClipboardModule = {
-	setText: (text: string) => Promise<void>;
-	hasImage: () => boolean;
-	getImageBinary: () => Promise<Array<number>>;
-};
-
-const require = createRequire(import.meta.url);
-let clipboard: ClipboardModule | null = null;
-
-const hasDisplay = process.platform !== "linux" || Boolean(process.env.DISPLAY || process.env.WAYLAND_DISPLAY);
-
-if (!process.env.TERMUX_VERSION && hasDisplay) {
-	try {
-		clipboard = require("@mariozechner/clipboard") as ClipboardModule;
-	} catch {
-		clipboard = null;
-	}
-}
-
-export { clipboard };

package/pi.dev-src/pi-mono/coding-agent/src/utils/clipboard.ts

@@ -1,81 +0,0 @@
-import { execSync, spawn } from "child_process";
-import { platform } from "os";
-import { isWaylandSession } from "./clipboard-image.js";
-import { clipboard } from "./clipboard-native.js";
-
-type NativeClipboardExecOptions = {
-	input: string;
-	timeout: number;
-	stdio: ["pipe", "ignore", "ignore"];
-};
-
-function copyToX11Clipboard(options: NativeClipboardExecOptions): void {
-	try {
-		execSync("xclip -selection clipboard", options);
-	} catch {
-		execSync("xsel --clipboard --input", options);
-	}
-}
-
-export async function copyToClipboard(text: string): Promise<void> {
-	// Always emit OSC 52 - works over SSH/mosh, harmless locally
-	const encoded = Buffer.from(text).toString("base64");
-	process.stdout.write(`\x1b]52;c;${encoded}\x07`);
-
-	try {
-		if (clipboard) {
-			await clipboard.setText(text);
-			return;
-		}
-	} catch {
-		// Fall through to platform-specific clipboard tools.
-	}
-
-	// Also try native tools (best effort for local sessions)
-	const p = platform();
-	const options: NativeClipboardExecOptions = { input: text, timeout: 5000, stdio: ["pipe", "ignore", "ignore"] };
-
-	try {
-		if (p === "darwin") {
-			execSync("pbcopy", options);
-		} else if (p === "win32") {
-			execSync("clip", options);
-		} else {
-			// Linux. Try Termux, Wayland, or X11 clipboard tools.
-			if (process.env.TERMUX_VERSION) {
-				try {
-					execSync("termux-clipboard-set", options);
-					return;
-				} catch {
-					// Fall back to Wayland or X11 tools.
-				}
-			}
-
-			const hasWaylandDisplay = Boolean(process.env.WAYLAND_DISPLAY);
-			const hasX11Display = Boolean(process.env.DISPLAY);
-			const isWayland = isWaylandSession();
-			if (isWayland && hasWaylandDisplay) {
-				try {
-					// Verify wl-copy exists (spawn errors are async and won't be caught)
-					execSync("which wl-copy", { stdio: "ignore" });
-					// wl-copy with execSync hangs due to fork behavior; use spawn instead
-					const proc = spawn("wl-copy", [], { stdio: ["pipe", "ignore", "ignore"] });
-					proc.stdin.on("error", () => {
-						// Ignore EPIPE errors if wl-copy exits early
-					});
-					proc.stdin.write(text);
-					proc.stdin.end();
-					proc.unref();
-				} catch {
-					if (hasX11Display) {
-						copyToX11Clipboard(options);
-					}
-				}
-			} else if (hasX11Display) {
-				copyToX11Clipboard(options);
-			}
-		}
-	} catch {
-		// Ignore - OSC 52 already emitted as fallback
-	}
-}

package/pi.dev-src/pi-mono/coding-agent/src/utils/exif-orientation.ts

@@ -1,183 +0,0 @@
-import type { PhotonImageType } from "./photon.js";
-
-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 -1;
-			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/pi.dev-src/pi-mono/coding-agent/src/utils/frontmatter.ts

@@ -1,39 +0,0 @@
-import { parse } from "yaml";
-
-type ParsedFrontmatter<T extends Record<string, unknown>> = {
-	frontmatter: T;
-	body: string;
-};
-
-const normalizeNewlines = (value: string): string => value.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-
-const extractFrontmatter = (content: string): { yamlString: string | null; body: string } => {
-	const normalized = normalizeNewlines(content);
-
-	if (!normalized.startsWith("---")) {
-		return { yamlString: null, body: normalized };
-	}
-
-	const endIndex = normalized.indexOf("\n---", 3);
-	if (endIndex === -1) {
-		return { yamlString: null, body: normalized };
-	}
-
-	return {
-		yamlString: normalized.slice(4, endIndex),
-		body: normalized.slice(endIndex + 4).trim(),
-	};
-};
-
-export const parseFrontmatter = <T extends Record<string, unknown> = Record<string, unknown>>(
-	content: string,
-): ParsedFrontmatter<T> => {
-	const { yamlString, body } = extractFrontmatter(content);
-	if (!yamlString) {
-		return { frontmatter: {} as T, body };
-	}
-	const parsed = parse(yamlString);
-	return { frontmatter: (parsed ?? {}) as T, body };
-};
-
-export const stripFrontmatter = (content: string): string => parseFrontmatter(content).body;