pi-usereq 0.7.0 → 0.10.0

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

@@ -0,0 +1,86 @@
+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

@@ -0,0 +1,300 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,81 @@
+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

@@ -0,0 +1,183 @@
+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

@@ -0,0 +1,39 @@
+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;