@suzumiyaaoba/mdxr 0.7.0 → 0.8.0

package/dist/cli.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { $g as REPORT_SPECS, A_ as parseDiff, Bv as parseLineRange, Dh as RESEARCH_CLAIM_SCHEMA, Eh as PERFORMANCE_TARGET_SCHEMA, Ev as numOf, Gv as isComponent, Ha as shadcnModules, Hv as SKIP_LANGS, Iv as parseProps, Jv as own, Kv as isRecord, Nm as PlanHeader, Nv as takeUsedIcons, Oh as performanceDetails, Pv as DocContext, Rv as fenceFilename, Th as PERFORMANCE_LABELS, Tv as attrTrue, Vv as splitPathLines, Wv as langForPath, Xg as calculate, Xv as urlScheme, Yv as safeHref, __ as parseJson, b_ as tableRecords, bm as plotModel, dp as dependencyMatrixModel, e_ as reportModel, fp as queryPlanModel, g_ as numberValue, h_ as isDataRecord, hv as textList, kh as performanceResult, m_ as display, mp as flameModel, mv as numList, n_ as schemaRows, p_ as columnsOf, pp as diagramModel, qv as nonEmpty, rv as isStatus, t as builtinComponents, t_ as comparisonModel, tv as STATUSES, up as bundleModel, v_ as readRecords, wh as CLAIM_LABELS, y_ as records, ym as PLOT_NAMES, zv as fenceLang } from "./ui-BhvyxJNU.mjs";
+import { $g as REPORT_SPECS, A_ as parseDiff, Bv as parseLineRange, Dh as RESEARCH_CLAIM_SCHEMA, Eh as PERFORMANCE_TARGET_SCHEMA, Ev as numOf, Gv as isComponent, Ha as shadcnModules, Hv as SKIP_LANGS, Iv as parseProps, Jv as own, Kv as isRecord$1, Nm as PlanHeader, Nv as takeUsedIcons, Oh as performanceDetails, Pv as DocContext, Rv as fenceFilename, Th as PERFORMANCE_LABELS, Tv as attrTrue, Vv as splitPathLines, Wv as langForPath, Xg as calculate, Xv as urlScheme, Yv as safeHref, __ as parseJson, b_ as tableRecords, bm as plotModel, dp as dependencyMatrixModel, e_ as reportModel, fp as queryPlanModel, g_ as numberValue, h_ as isDataRecord, hv as textList, kh as performanceResult, m_ as display, mp as flameModel, mv as numList, n_ as schemaRows, p_ as columnsOf, pp as diagramModel, qv as nonEmpty, rv as isStatus, t as builtinComponents, t_ as comparisonModel, tv as STATUSES, up as bundleModel, v_ as readRecords, wh as CLAIM_LABELS, y_ as records, ym as PLOT_NAMES, zv as fenceLang } from "./ui-BhvyxJNU.mjs";
 import { a as loadUserModule, c as srcDir, i as importBundledCode, n as loadConfig, o as resolveModuleEntry, r as SHARED_PACKAGES, s as pkgRoot } from "./config-HGfE6JlG.mjs";
 import module from "node:module";
-import fsp, { access, readFile, readdir, writeFile } from "node:fs/promises";
+import fsp, { access, mkdir, readFile, readdir, rename, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { cac } from "cac";
 import { directiveToMarkdown } from "mdast-util-directive";
@@ -27,9 +27,9 @@ import { Fragment, createElement } from "react";
 import { icons } from "@iconify-json/lucide";
 import { icons as icons$1 } from "@iconify-json/vscode-icons";
 import { differenceInCalendarDays, isValid, parseISO } from "date-fns";
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { build } from "esbuild";
-import os from "node:os";
+import os, { homedir } from "node:os";
 import { spawn } from "node:child_process";
 import { once } from "node:events";
 import { compile } from "@mdx-js/mdx";
@@ -40,6 +40,10 @@ import { createHighlighter } from "shiki";
 import { compile as compile$1, optimize } from "@tailwindcss/node";
 import { Scanner } from "@tailwindcss/oxide";
 import http from "node:http";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { connect } from "node:net";
+import { WebSocket } from "ws";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
 //#region src/format-error.ts
 /**
 * Validate the `--format` flag: omitted and "text" mean human-readable
@@ -98,7 +102,7 @@ const textContent$1 = (node) => {
 /** A JSX attribute's string value, or undefined when absent/empty/non-string. */
 const jsxAttr = (node, name) => {
 	if (!Array.isArray(node.attributes)) return;
-	for (const a of node.attributes) if (isRecord(a) && a.name === name && typeof a.value === "string" && a.value !== "") return a.value;
+	for (const a of node.attributes) if (isRecord$1(a) && a.name === name && typeof a.value === "string" && a.value !== "") return a.value;
 };
 /**
 * `Record` → `mdxJsxAttribute[]`. null/undefined/"" values are dropped —
@@ -120,10 +124,10 @@ const toMdxElement = (node, kind, name, attrs) => {
 * The mdast→hast bridge turns hProperties into element props.
 */
 const setHProperty = (node, key, value) => {
-	const data = isRecord(node.data) ? node.data : {};
+	const data = isRecord$1(node.data) ? node.data : {};
 	node.data = data;
 	data.hProperties = {
-		...isRecord(data.hProperties) ? data.hProperties : {},
+		...isRecord$1(data.hProperties) ? data.hProperties : {},
 		[key]: value
 	};
 };
@@ -1033,7 +1037,7 @@ const CONTAINER_COMPONENTS = {
 	vuln: "Vuln",
 	waterfall: "Waterfall"
 };
-const isDirective = (n) => "name" in n && typeof n.name === "string" && "attributes" in n && isRecord(n.attributes) && isParent(n);
+const isDirective = (n) => "name" in n && typeof n.name === "string" && "attributes" in n && isRecord$1(n.attributes) && isParent(n);
 /**
 * remark-directive containers become mdxr components:
 *   :::note[Optional label]        → <Callout kind="note" title="Optional label">
@@ -1083,7 +1087,7 @@ const remarkMdxrDirectives = () => (tree, file) => {
 		}
 		const attrs = { ...directive.attributes };
 		const [first] = directive.children;
-		if (first !== void 0 && isRecord(first.data) && first.data.directiveLabel === true) {
+		if (first !== void 0 && isRecord$1(first.data) && first.data.directiveLabel === true) {
 			attrs.title ??= textContent$1(first).trim();
 			directive.children.shift();
 		}
@@ -1236,7 +1240,7 @@ const remarkNoJs = () => (tree, file) => {
 	});
 	visit(tree, JSX_ELEMENTS, (node) => {
 		if (!("attributes" in node) || !Array.isArray(node.attributes)) return;
-		for (const attr of node.attributes) if (isRecord(attr) && (attr.type !== "mdxJsxAttribute" || attr.value !== null && typeof attr.value !== "string")) file.fail(MESSAGE, node, "mdxr:no-js");
+		for (const attr of node.attributes) if (isRecord$1(attr) && (attr.type !== "mdxJsxAttribute" || attr.value !== null && typeof attr.value !== "string")) file.fail(MESSAGE, node, "mdxr:no-js");
 	});
 };
 //#endregion
@@ -1262,7 +1266,7 @@ const rebase = (node, origin, root) => {
 	const relative = (value) => REMOTE.test(value) ? value : path.relative(root, path.resolve(origin, value)).split(path.sep).join("/");
 	if ("url" in node && typeof node.url === "string") node.url = relative(node.url);
 	if (!("attributes" in node) || !Array.isArray(node.attributes)) return;
-	for (const attr of node.attributes) if (isRecord(attr) && [
+	for (const attr of node.attributes) if (isRecord$1(attr) && [
 		"path",
 		"src",
 		"poster",
@@ -1319,7 +1323,7 @@ const remarkInclude = () => (tree, file) => {
 //#region src/remark/references.ts
 const isElement$1 = (node) => node.type === "mdxJsxFlowElement" || node.type === "mdxJsxTextElement";
 const set = (node, name, value) => {
-	node.attributes = [...Array.isArray(node.attributes) ? node.attributes.filter((attr) => !(isRecord(attr) && attr.name === name)) : [], {
+	node.attributes = [...Array.isArray(node.attributes) ? node.attributes.filter((attr) => !(isRecord$1(attr) && attr.name === name)) : [], {
 		name,
 		type: "mdxJsxAttribute",
 		value
@@ -1511,7 +1515,7 @@ const attr = (node, name) => jsxAttr(node, name);
 */
 const flag = (node, name) => {
 	if (!Array.isArray(node.attributes)) return false;
-	for (const a of node.attributes) if (isRecord(a) && a.name === name) return a.value === null || a.value === true || attrTrue(a.value);
+	for (const a of node.attributes) if (isRecord$1(a) && a.name === name) return a.value === null || a.value === true || attrTrue(a.value);
 	return false;
 };
 /** Attribute explicitly set to the string `"false"` (open="false" opt-outs). */
@@ -1794,7 +1798,7 @@ const transformAscii = (root, registry, serialize, warn) => {
 		return [n];
 	};
 	const transformNodes = (nodes, ctx) => nodes.flatMap((node) => {
-		const id = isRecord(node.data) ? node.data.mdxrReferenceId : void 0;
+		const id = isRecord$1(node.data) ? node.data.mdxrReferenceId : void 0;
 		const output = transformElement(node, ctx);
 		if (typeof id !== "string") return output;
 		return [{
@@ -5220,8 +5224,8 @@ const mdxToAscii = async (source, filePath = "document.mdx") => {
 		value: source
 	});
 	matter(file);
-	const fmRaw = isRecord(file.data) ? file.data.matter : void 0;
-	const fm = isRecord(fmRaw) ? fmRaw : {};
+	const fmRaw = isRecord$1(file.data) ? file.data.matter : void 0;
+	const fm = isRecord$1(fmRaw) ? fmRaw : {};
 	const tree = processor.parse(file);
 	await processor.run(tree, file);
 	const hasPlan = contains(tree.children, "Plan");
@@ -5258,11 +5262,11 @@ const describeLiteral = (value) => {
 };
 const pipeConstraint = (schema) => {
 	if (!Array.isArray(schema.pipe)) return;
-	return schema.pipe.find((s) => isRecord(s) && (s.type === "picklist" || s.type === "union" || s.type === "literal"));
+	return schema.pipe.find((s) => isRecord$1(s) && (s.type === "picklist" || s.type === "union" || s.type === "literal"));
 };
 /** Structural view of a valibot schema — enough for catalog introspection. */
 const describeSchema = (schema) => {
-	if (!isRecord(schema)) return "unknown";
+	if (!isRecord$1(schema)) return "unknown";
 	switch (schema.type) {
 		case "nullable":
 		case "nullish": return `${describeSchema(schema.wrapped)} | null`;
@@ -5284,10 +5288,10 @@ const describeSchema = (schema) => {
 	return typeof schema.type === "string" ? schema.type : "unknown";
 };
 const propsOf = (schema) => {
-	if (!isRecord(schema) || !isRecord(schema.entries)) return {};
+	if (!isRecord$1(schema) || !isRecord$1(schema.entries)) return {};
 	const out = {};
 	for (const [key, raw] of Object.entries(schema.entries)) {
-		const optional = isRecord(raw) && typeof raw.type === "string" && OPTIONAL_TYPES.has(raw.type);
+		const optional = isRecord$1(raw) && typeof raw.type === "string" && OPTIONAL_TYPES.has(raw.type);
 		const def = optional ? raw.default : void 0;
 		Object.defineProperty(out, key, {
 			configurable: true,
@@ -5663,7 +5667,7 @@ const put = (into, k, v) => {
 };
 /** A default-exported object is treated as a `{ Name: Component }` map. */
 const mergeDefaultMap = (val, into) => {
-	if (!isRecord(val)) return;
+	if (!isRecord$1(val)) return;
 	for (const [k, v] of Object.entries(val)) if (isComponent(v)) put(into, k, v);
 };
 /**
@@ -5718,9 +5722,16 @@ const annotationHtml = (icon) => `
       </form>
       <p class="mdxr-annotation-empty" data-annotation-empty>No comments</p>
       <ol class="mdxr-annotation-list" data-annotation-list></ol>
+      <details class="mdxr-annotation-history" data-annotation-history hidden>
+        <summary>History <span data-annotation-history-count>0</span></summary>
+        <div class="mdxr-annotation-history-list" data-annotation-history-list></div>
+      </details>
     </div>
     <footer class="mdxr-annotation-footer">
-      <button type="button" data-annotation-copy aria-label="Copy Markdown" title="Copy Markdown" disabled><span class="mdxr-annotation-copy-idle">${icon("copy")}</span><span class="mdxr-annotation-copy-done">${icon("check")}</span><span data-annotation-copy-label>Markdown</span></button>
+      <div class="mdxr-annotation-footer-actions">
+        <button type="button" data-annotation-copy aria-label="Copy Markdown" title="Copy Markdown" disabled><span class="mdxr-annotation-copy-idle">${icon("copy")}</span><span class="mdxr-annotation-copy-done">${icon("check")}</span><span data-annotation-copy-label>Markdown</span></button>
+        <button type="button" data-annotation-send aria-label="Send to chat" title="Send to chat" disabled hidden>${icon("send")}<span>Send to chat</span></button>
+      </div>
       <div class="mdxr-annotation-save-status" data-annotation-status-row data-state="saved"><p role="status" aria-live="polite" data-annotation-status></p></div>
       <div data-annotation-export hidden>
         <label class="mdxr-annotation-sr-only" for="mdxr-annotation-markdown">Markdown feedback</label>
@@ -5859,14 +5870,14 @@ const inlineScript = (js) => js.replaceAll(/<\/script/giu, "\\u003C/script").rep
 * reads identically inside CSS strings/comments, so it's safe to emit.
 */
 const inlineStyle = (css) => css.replaceAll(/<\/style/giu, "<\\/style");
-const ESCAPES = {
+const ESCAPES$1 = {
 	"\"": "&quot;",
 	"&": "&amp;",
 	"'": "&#39;",
 	"<": "&lt;",
 	">": "&gt;"
 };
-const escapeHtml = (s) => s.replaceAll(/[&<>"']/gu, (c) => ESCAPES[c] ?? c);
+const escapeHtml = (s) => s.replaceAll(/[&<>"']/gu, (c) => ESCAPES$1[c] ?? c);
 /** Inline SVG from the bundled lucide set (bodies carry stroke attrs). */
 const iconSvg = (name) => {
 	const icon = icons.icons[name];
@@ -6476,6 +6487,47 @@ const editorUrl = (editor, absPath, line) => {
 	return scheme !== void 0 && SCRIPTABLE.has(scheme) ? void 0 : url;
 };
 //#endregion
+//#region src/workspace-syntax.ts
+const ALLOWED_STYLE_PROPERTIES = [
+	"--shiki-light",
+	"--shiki-dark",
+	"--shiki-light-font-style",
+	"--shiki-dark-font-style",
+	"--shiki-light-font-weight",
+	"--shiki-dark-font-weight",
+	"--shiki-light-text-decoration",
+	"--shiki-dark-text-decoration"
+];
+const parseToken = (value) => {
+	if (!isRecord$1(value) || typeof value.text !== "string" || !isRecord$1(value.style) || Array.isArray(value.style)) return;
+	const style = {};
+	for (const property of ALLOWED_STYLE_PROPERTIES) {
+		if (!Object.hasOwn(value.style, property)) continue;
+		const propertyValue = value.style[property];
+		if (typeof propertyValue === "string") style[property] = propertyValue;
+	}
+	return {
+		style,
+		text: value.text
+	};
+};
+/** Validate and narrow syntax tokens received through a workspace API. */
+const parseSyntaxLines = (value) => {
+	if (!Array.isArray(value)) return;
+	const lines = [];
+	for (const lineValue of value) {
+		if (!Array.isArray(lineValue)) return;
+		const line = [];
+		for (const tokenValue of lineValue) {
+			const token = parseToken(tokenValue);
+			if (token === void 0) return;
+			line.push(token);
+		}
+		lines.push(line);
+	}
+	return lines;
+};
+//#endregion
 //#region src/rehype/shiki.ts
 /**
 * Fenced code blocks are syntax-highlighted with shiki at render time.
@@ -6512,6 +6564,7 @@ const PRELOADED_LANGS = [
 	"jsx",
 	"kotlin",
 	"lua",
+	"mdx",
 	"markdown",
 	"php",
 	"python",
@@ -6569,7 +6622,7 @@ const getHighlighter = async () => {
 	}
 };
 const DIFF_FENCE_LANGS = /* @__PURE__ */ new Set(["diff", "patch"]);
-const isElement = (node) => isRecord(node) && node.type === "element" && typeof node.tagName === "string";
+const isElement = (node) => isRecord$1(node) && node.type === "element" && typeof node.tagName === "string";
 /** mdast-sourced nodes use `className`; shiki's hast uses `class`. Read both. */
 const classNames = (el) => {
 	const c = el?.properties?.className ?? el?.properties?.class;
@@ -6615,6 +6668,30 @@ const readyHighlighter = async (lang) => {
 		return;
 	}
 };
+const plainSyntaxLines = (source) => source.split("\n").map((text) => [{
+	style: {},
+	text
+}]);
+/** Tokenize a complete MDX document for the workspace source and diff views. */
+const highlightMdxSource = async (source) => {
+	const normalizedSource = source.replaceAll("\r\n", "\n");
+	if (normalizedSource.includes("\r")) return plainSyntaxLines(normalizedSource);
+	const highlighter = await readyHighlighter("mdx");
+	if (highlighter === void 0) return plainSyntaxLines(normalizedSource);
+	try {
+		const result = highlighter.codeToTokens(normalizedSource, {
+			defaultColor: false,
+			lang: "mdx",
+			themes: THEMES
+		});
+		return parseSyntaxLines(result.tokens.map((line) => line.map((token) => ({
+			style: token.htmlStyle ?? {},
+			text: token.content
+		})))) ?? plainSyntaxLines(normalizedSource);
+	} catch {
+		return plainSyntaxLines(normalizedSource);
+	}
+};
 /**
 * One side of a hunk, highlighted as the file's own language: `ctx`/`add`
 * rows read from the new side, `ctx`/`del` rows from the old side. Shiki's
@@ -6814,7 +6891,7 @@ const remarkAnnotationSources = () => (tree, file) => {
 			"mdxJsxFlowElement",
 			"mdxJsxTextElement"
 		].includes(node.type)) return;
-		const origin = isRecord(node.data) ? node.data.mdxrSourceFile : void 0;
+		const origin = isRecord$1(node.data) ? node.data.mdxrSourceFile : void 0;
 		const label = jsxAttr(node, "caption") ?? jsxAttr(node, "title") ?? jsxAttr(node, "aria-label") ?? jsxAttr(node, "alt") ?? "";
 		const image = "url" in node && typeof node.url === "string" ? node.url : jsxAttr(node, "src") ?? "";
 		const text = typeof node.value === "string" ? node.value : textContent$1(node);
@@ -6928,8 +7005,8 @@ const remarkSectionReviews = () => (tree) => {
 		if (!isFlowElement(node) || jsxAttr(node, "data-mdxr-page") === void 0) return;
 		const [heading] = node.children ?? [];
 		const data = heading?.data;
-		const properties = isRecord(data) ? data.hProperties : void 0;
-		if (heading?.type !== "heading" || !("depth" in heading) || heading.depth !== 2 || !isRecord(properties) || typeof properties.id !== "string" || node.children === void 0) return;
+		const properties = isRecord$1(data) ? data.hProperties : void 0;
+		if (heading?.type !== "heading" || !("depth" in heading) || heading.depth !== 2 || !isRecord$1(properties) || typeof properties.id !== "string" || node.children === void 0) return;
 		const control = {
 			attributes: jsxAttrs({
 				"data-section-id": properties.id,
@@ -6979,8 +7056,8 @@ const mdxToHtml = async (source, components, filePath = "document.mdx", opts = {
 		value: source
 	});
 	matter(file);
-	const fmRaw = isRecord(file.data) ? file.data.matter : void 0;
-	const frontmatter = isRecord(fmRaw) ? fmRaw : {};
+	const fmRaw = isRecord$1(file.data) ? file.data.matter : void 0;
+	const frontmatter = isRecord$1(fmRaw) ? fmRaw : {};
 	const editor = typeof frontmatter.editor === "string" && frontmatter.editor !== "" ? frontmatter.editor : opts.editor;
 	const dir = file.dirname ?? ".";
 	const fileLinks = /* @__PURE__ */ new Map();
@@ -7740,6 +7817,1384 @@ const renderFile = async (mdxPath, opts = {}) => {
 	});
 };
 //#endregion
+//#region src/agent-markdown.ts
+const ESCAPES = {
+	"\"": "&quot;",
+	"&": "&amp;",
+	"'": "&#39;",
+	"<": "&lt;",
+	">": "&gt;"
+};
+const WRAPPERS = {
+	blockquote: ["<blockquote>", "</blockquote>"],
+	delete: ["<del>", "</del>"],
+	emphasis: ["<em>", "</em>"],
+	listItem: ["<li>", "</li>"],
+	paragraph: ["<p>", "</p>"],
+	strong: ["<strong>", "</strong>"],
+	table: ["<table>", "</table>"],
+	tableCell: ["<td>", "</td>"],
+	tableRow: ["<tr>", "</tr>"]
+};
+const escape = (value) => value.replaceAll(/[&<>"']/gu, (char) => ESCAPES[char] ?? char);
+const safeUrl = (value) => {
+	const trimmed = value.trim();
+	return /^(?:https?:|mailto:|\/|#)/iu.test(trimmed) ? trimmed : void 0;
+};
+const renderLiteral = (node) => {
+	if (node.type === "code") return `<pre><code>${escape(node.value ?? "")}</code></pre>`;
+	if (node.type === "inlineCode") return `<code>${escape(node.value ?? "")}</code>`;
+	if (node.type === "break") return "<br>";
+	if (node.type === "thematicBreak") return "<hr>";
+};
+const renderNode = (node) => {
+	const literal = renderLiteral(node);
+	if (literal !== void 0) return literal;
+	const children = (node.children ?? []).map(renderNode).join("");
+	const wrapper = WRAPPERS[node.type];
+	if (wrapper !== void 0) return `${wrapper[0]}${children}${wrapper[1]}`;
+	if (node.type === "heading") {
+		const depth = Math.min(Math.max(node.depth ?? 1, 1), 6);
+		return `<h${depth}>${children}</h${depth}>`;
+	}
+	if (node.type === "list") return node.ordered === true ? `<ol>${children}</ol>` : `<ul>${children}</ul>`;
+	if (node.type === "link") {
+		const url = safeUrl(node.url ?? "");
+		return url === void 0 ? children : `<a href="${escape(url)}" rel="noopener noreferrer" target="_blank">${children}</a>`;
+	}
+	return children || escape(node.value ?? "");
+};
+/** Render agent text as inert Markdown; MDX JSX and raw HTML never execute. */
+const renderAgentMarkdown = (source) => {
+	const tree = unified().use(remarkParse).use(remarkGfm).parse(source);
+	return renderNode(tree);
+};
+//#endregion
+//#region src/agent-http.ts
+const view = (conversation) => ({
+	...conversation,
+	messages: conversation.messages.map((message) => ({
+		...message,
+		html: renderAgentMarkdown(message.content)
+	})),
+	sessionId: conversation.sessionId ?? null
+});
+const reply = (res, status, body) => {
+	res.writeHead(status, {
+		"cache-control": "no-store",
+		"content-type": "application/json; charset=utf-8",
+		"x-content-type-options": "nosniff"
+	});
+	res.end(JSON.stringify(body));
+};
+const sameOrigin$1 = (req) => {
+	const port = req.socket.localPort;
+	const host = req.headers.host ?? "";
+	return (host === `localhost:${port}` || host === `127.0.0.1:${port}`) && (req.headers.origin === void 0 || req.headers.origin === `http://${host}`);
+};
+const readMessage = async (req) => {
+	if (req.headers["content-type"]?.startsWith("application/json") !== true) throw new Error("Expected application/json");
+	let source = "";
+	for await (const chunk of req) {
+		source += Buffer.isBuffer(chunk) ? chunk.toString("utf-8") : String(chunk);
+		if (source.length > 65536) throw new Error("Message is too large");
+	}
+	let value;
+	try {
+		value = JSON.parse(source);
+	} catch {
+		throw new Error("Invalid JSON");
+	}
+	const message = typeof value === "object" && value !== null && "message" in value ? value.message : void 0;
+	if (typeof message !== "string" || message.trim() === "" || message.length > 65536) throw new Error("Expected a non-empty message");
+	return message.trim();
+};
+const errorStatus = (detail) => {
+	if (detail === "Agent is already responding") return 409;
+	if (detail === "Message is too large") return 413;
+	if (detail === "Expected application/json" || detail === "Invalid JSON" || detail === "Expected a non-empty message") return 400;
+	return 500;
+};
+/** Local-only JSON endpoint for one served document's agent conversation. */
+const handleAgentRequest = async (req, res, agent, notify, beforeSend) => {
+	let started = false;
+	try {
+		if (agent === void 0) {
+			reply(res, 404, { error: "Agent chat is disabled" });
+			return;
+		}
+		if (!sameOrigin$1(req)) {
+			reply(res, 403, { error: "Request origin is not allowed" });
+			return;
+		}
+		if (req.method === "GET") {
+			reply(res, 200, view(await agent.current()));
+			return;
+		}
+		if (req.method !== "POST") {
+			reply(res, 405, { error: "Method not allowed" });
+			return;
+		}
+		const message = await readMessage(req);
+		await beforeSend?.();
+		started = true;
+		reply(res, 200, view(await agent.send(message)));
+		notify();
+	} catch (error) {
+		if (started) notify();
+		if (res.headersSent) return;
+		const detail = formatError(error);
+		reply(res, errorStatus(detail), { error: detail });
+	}
+};
+//#endregion
+//#region src/agent-preview.ts
+const css = readFileSync(path.join(srcDir, "assets", "workspace.css"), "utf-8");
+/** Add the preview workspace without modifying the rendered MDX tree. */
+const injectAgentPreview = (html, provider) => {
+	const agentAttributes = provider === void 0 ? "" : ` data-mdxr-agent data-agent-provider="${provider}"`;
+	const workspace = `<style>${inlineStyle(css)}</style><div id="mdxr-workspace-root"${agentAttributes}></div><script src="/__mdxr_workspace.js" defer><\/script>`;
+	return html.includes("</body>") ? html.replace("</body>", `${workspace}</body>`) : `${html}${workspace}`;
+};
+//#endregion
+//#region src/claude-stream-session.ts
+var UserMessageQueue = class {
+	messages = [];
+	readers = [];
+	closed = false;
+	[Symbol.asyncIterator]() {
+		return this;
+	}
+	close() {
+		this.closed = true;
+		for (const reader of this.readers.splice(0)) reader({
+			done: true,
+			value: void 0
+		});
+	}
+	async next() {
+		const message = this.messages.shift();
+		if (message !== void 0) return {
+			done: false,
+			value: message
+		};
+		if (this.closed) return {
+			done: true,
+			value: void 0
+		};
+		return await new Promise((resolve) => {
+			this.readers.push(resolve);
+		});
+	}
+	push(message) {
+		if (this.closed) throw new Error("Claude Agent SDK input is closed");
+		const reader = this.readers.shift();
+		if (reader === void 0) {
+			this.messages.push(message);
+			return;
+		}
+		reader({
+			done: false,
+			value: message
+		});
+	}
+};
+const asError = (error) => error instanceof Error ? error : new Error(String(error));
+const noApprovalError = (tools) => /* @__PURE__ */ new Error(`Claude Code denied ${tools.join(", ")} because the MDX preview has no tool approval UI.`);
+/**
+* Create an MDX-owned, long-lived Claude Agent SDK session for `cwd`.
+* This starts a new session; it cannot attach to an already-running Claude CLI.
+*/
+const createClaudeStreamSession = (cwd) => {
+	const absoluteCwd = path.resolve(cwd);
+	const input = new UserMessageQueue();
+	let activeTurn;
+	let failure;
+	let closed = false;
+	let sessionId;
+	let abortController;
+	let runner;
+	const finishTurn = (turn, result) => {
+		if (activeTurn === turn) activeTurn = void 0;
+		turn.resolve(result);
+	};
+	const failTurn = (turn, error) => {
+		if (activeTurn === turn) activeTurn = void 0;
+		turn.reject(error);
+	};
+	const failSession = (error) => {
+		if (failure !== void 0 || closed) return;
+		failure = asError(error);
+		input.close();
+		abortController?.abort();
+		if (activeTurn !== void 0) failTurn(activeTurn, failure);
+	};
+	const handleMessage = (message) => {
+		if (message.type === "system" && message.subtype === "init") {
+			sessionId = message.session_id;
+			return;
+		}
+		if (message.type !== "result") return;
+		sessionId = message.session_id;
+		const turn = activeTurn;
+		if (turn === void 0) return;
+		const resultUserIds = message.user_message_uuids ?? [];
+		if (!(message.user_message_uuid === void 0 || message.user_message_uuid === turn.uuid || resultUserIds.includes(turn.uuid))) return;
+		if (message.permission_denials.length > 0) {
+			const deniedTools = [...new Set(message.permission_denials.map((denial) => denial.tool_name))];
+			failTurn(turn, noApprovalError(deniedTools));
+			return;
+		}
+		if (message.subtype !== "success") {
+			failTurn(turn, /* @__PURE__ */ new Error(`Claude Agent SDK turn failed (${message.subtype}): ${message.errors.join("; ")}`));
+			return;
+		}
+		if (message.is_error) {
+			failTurn(turn, /* @__PURE__ */ new Error(`Claude Code returned an error: ${message.result}`));
+			return;
+		}
+		if (sessionId === void 0 || sessionId === "") {
+			failTurn(turn, /* @__PURE__ */ new Error("Claude Agent SDK did not provide a session ID"));
+			return;
+		}
+		finishTurn(turn, {
+			answer: message.result,
+			sessionId
+		});
+	};
+	const start = () => {
+		if (runner !== void 0 || failure !== void 0 || closed) return;
+		abortController = new AbortController();
+		try {
+			const stream = query({
+				options: {
+					abortController,
+					cwd: absoluteCwd,
+					permissionMode: "dontAsk"
+				},
+				prompt: input
+			});
+			runner = (async () => {
+				try {
+					for await (const message of stream) handleMessage(message);
+					if (!closed) throw new Error("Claude Agent SDK session ended unexpectedly");
+				} catch (error) {
+					failSession(error);
+				}
+			})();
+		} catch (error) {
+			failSession(error);
+		}
+	};
+	const sendOne = async (message) => {
+		if (closed) throw new Error("Claude Agent SDK session is closed");
+		if (failure !== void 0) throw failure;
+		if (activeTurn !== void 0) throw new Error("Claude Agent SDK is already responding");
+		if (message.trim() === "") throw new Error("Message must not be empty");
+		const uuid = randomUUID();
+		return await new Promise((resolve, reject) => {
+			const turn = {
+				reject,
+				resolve,
+				uuid
+			};
+			activeTurn = turn;
+			start();
+			if (failure === void 0) try {
+				input.push({
+					message: {
+						content: message,
+						role: "user"
+					},
+					parent_tool_use_id: null,
+					type: "user",
+					uuid
+				});
+			} catch (error) {
+				failTurn(turn, asError(error));
+			}
+		});
+	};
+	const close = async () => {
+		if (!closed) {
+			closed = true;
+			input.close();
+			abortController?.abort();
+			if (activeTurn !== void 0) failTurn(activeTurn, /* @__PURE__ */ new Error("Claude Agent SDK session was closed"));
+		}
+		await runner;
+	};
+	return {
+		close,
+		send: sendOne
+	};
+};
+//#endregion
+//#region src/codex-app-server.ts
+const DEFAULT_ENDPOINT = "ws://127.0.0.1:4500";
+const DEFAULT_DAEMON_WS_ENDPOINT = "ws://localhost/";
+const RPC_TIMEOUT_MS = 3e4;
+const MAX_BUFFERED_TURNS = 8;
+var CodexAppServerError = class extends Error {
+	kind;
+	constructor(message, kind = "general", options) {
+		super(message, options);
+		this.kind = kind;
+		this.name = "CodexAppServerError";
+	}
+};
+const isRecord = (value) => typeof value === "object" && value !== null;
+const isRpcId = (value) => typeof value === "number" || typeof value === "string";
+const decodeFrame = (data) => {
+	if (Array.isArray(data)) return Buffer.concat(data).toString("utf-8");
+	if (data instanceof ArrayBuffer) return Buffer.from(data).toString("utf-8");
+	return data.toString("utf-8");
+};
+const defaultDaemonSocketPath = () => {
+	const configuredCodexHome = process.env.CODEX_HOME;
+	const codexHome = configuredCodexHome === void 0 || configuredCodexHome.length === 0 ? path.join(homedir(), ".codex") : configuredCodexHome;
+	return path.join(codexHome, "app-server-control", "app-server-control.sock");
+};
+const resolveEndpoint = (endpoint, useDefaultDaemon) => {
+	const resolved = endpoint ?? process.env.CODEX_APP_SERVER_URL ?? (useDefaultDaemon ? `unix://${defaultDaemonSocketPath()}` : DEFAULT_ENDPOINT);
+	let parsed;
+	try {
+		parsed = new URL(resolved);
+	} catch (error) {
+		throw new CodexAppServerError("Invalid Codex App Server endpoint.", "general", { cause: error });
+	}
+	if (parsed.protocol === "unix:") {
+		let socketPath;
+		try {
+			socketPath = decodeURIComponent(parsed.pathname);
+		} catch (error) {
+			throw new CodexAppServerError("Invalid Codex App Server Unix socket path.", "general", { cause: error });
+		}
+		if (parsed.host !== "" || !path.isAbsolute(socketPath) || parsed.search !== "" || parsed.hash !== "") throw new CodexAppServerError("Codex App Server Unix endpoint must be unix:///absolute/path without query or fragment.");
+		return {
+			socketPath,
+			url: DEFAULT_DAEMON_WS_ENDPOINT
+		};
+	}
+	if (parsed.protocol !== "ws:" && parsed.protocol !== "wss:") throw new CodexAppServerError("Codex App Server endpoint must use ws://, wss://, or unix:///absolute/path.");
+	if (parsed.username !== "" || parsed.password !== "") throw new CodexAppServerError("Codex App Server endpoint must not contain credentials; configure authentication separately.");
+	return { url: resolved };
+};
+const isActiveWriterConflict = (message) => {
+	const normalized = message.toLowerCase();
+	return normalized.includes("thread-store conflict") || normalized.includes("already has an active writer") || normalized.includes("active writer conflict");
+};
+const makeTurnState = () => ({
+	messageOrder: [],
+	messages: /* @__PURE__ */ new Map()
+});
+const getAgentMessage = (state, itemId) => {
+	let item = state.messages.get(itemId);
+	if (item === void 0) {
+		item = { text: "" };
+		state.messages.set(itemId, item);
+		state.messageOrder.push(itemId);
+	}
+	return item;
+};
+const getNotificationTurnId = (params) => {
+	const { turnId, turn } = params;
+	if (typeof turnId === "string") return turnId;
+	if (!isRecord(turn)) return;
+	return typeof turn.id === "string" ? turn.id : void 0;
+};
+const createDeferred = () => {
+	let handlers;
+	const promise = new Promise((resolve, reject) => {
+		handlers = {
+			reject,
+			resolve
+		};
+	});
+	if (handlers === void 0) throw new Error("Could not create a Codex turn completion promise.");
+	return {
+		promise,
+		reject: handlers.reject,
+		resolve: handlers.resolve
+	};
+};
+const settleQueuedMessage = (queuedMessage, outcome) => {
+	if (!queuedMessage.acknowledged) {
+		queuedMessage.outcome = outcome;
+		return;
+	}
+	if (outcome.type === "resolve") queuedMessage.completion.resolve(outcome.answer);
+	else queuedMessage.completion.reject(outcome.error);
+};
+const acknowledgeQueuedMessage = (queuedMessage) => {
+	queuedMessage.acknowledged = true;
+	if (queuedMessage.outcome !== void 0) settleQueuedMessage(queuedMessage, queuedMessage.outcome);
+};
+/**
+* Create a long-lived JSON-RPC client for the same Codex App Server used by
+* `codex --remote`. Calls reuse one socket and one thread until `close()`.
+*/
+const createCodexAppServerSession = (options = {}) => {
+	const endpoint = resolveEndpoint(options.endpoint, options.initialSessionId !== void 0);
+	let socket;
+	let connectionPromise;
+	let nextRequestId = 1;
+	let threadId;
+	let activeTurn;
+	let isClosed = false;
+	let isClosing = false;
+	let closePromise;
+	let busy = false;
+	let attachedToExistingThread = options.initialSessionId !== void 0;
+	const pendingRequests = /* @__PURE__ */ new Map();
+	const turns = /* @__PURE__ */ new Map();
+	const queuedMessagesByClientId = /* @__PURE__ */ new Map();
+	const queuedMessagesByTurnId = /* @__PURE__ */ new Map();
+	const makeTransportError = (reason, cause) => new CodexAppServerError(`Codex App Server connection ${reason}${cause instanceof Error ? `: ${cause.message}` : ""}`, "general", cause instanceof Error ? { cause } : void 0);
+	const rejectPendingRequests = (error) => {
+		for (const [id, pending] of pendingRequests) {
+			clearTimeout(pending.timeout);
+			pendingRequests.delete(id);
+			pending.reject(error);
+		}
+	};
+	const rejectQueuedMessages = (error) => {
+		for (const queuedMessage of queuedMessagesByClientId.values()) settleQueuedMessage(queuedMessage, {
+			error,
+			type: "reject"
+		});
+		queuedMessagesByClientId.clear();
+		queuedMessagesByTurnId.clear();
+	};
+	const sendFrame = (value) => {
+		if (socket?.readyState !== WebSocket.OPEN) throw makeTransportError("is not open.");
+		socket.send(JSON.stringify(value), (error) => {
+			if (error instanceof Error) {
+				const wrapped = makeTransportError("failed while sending a message.", error);
+				rejectPendingRequests(wrapped);
+				activeTurn?.reject(wrapped);
+				rejectQueuedMessages(wrapped);
+			}
+		});
+	};
+	const replyToServerRequest = (id, method) => {
+		if (attachedToExistingThread) return;
+		if (method === "item/commandExecution/requestApproval" || method === "item/fileChange/requestApproval") {
+			sendFrame({
+				id,
+				result: { decision: "decline" }
+			});
+			return;
+		}
+		if (method === "item/tool/requestUserInput" || method === "mcpServer/elicitation/request") {
+			sendFrame({
+				id,
+				result: {
+					action: "decline",
+					content: null
+				}
+			});
+			return;
+		}
+		sendFrame({
+			error: {
+				code: -32601,
+				message: `mdxr does not support the server request ${method}`
+			},
+			id
+		});
+	};
+	const finishActiveTurnIfReady = () => {
+		const currentTurn = activeTurn;
+		if (currentTurn === void 0 || currentTurn.turnId === void 0) return;
+		const activeTurnId = currentTurn.turnId;
+		const turn = turns.get(activeTurnId);
+		const completedTurn = turn?.completedTurn;
+		if (turn === void 0 || completedTurn === void 0) return;
+		const { status } = completedTurn;
+		if (status !== "completed") {
+			const { error } = completedTurn;
+			const detail = isRecord(error) ? error.message : void 0;
+			const message = typeof detail === "string" ? `Codex turn ${String(status)}: ${detail}` : `Codex turn finished with status ${String(status)}.`;
+			currentTurn.reject(new CodexAppServerError(message));
+			return;
+		}
+		const messages = turn.messageOrder.flatMap((itemId) => {
+			const item = turn.messages.get(itemId);
+			return item === void 0 ? [] : [item];
+		});
+		if (Array.isArray(completedTurn.items)) {
+			for (const item of completedTurn.items) if (isRecord(item) && item.type === "agentMessage" && typeof item.id === "string" && typeof item.text === "string") {
+				const message = getAgentMessage(turn, item.id);
+				message.text = item.text;
+				if (typeof item.phase === "string") message.phase = item.phase;
+			}
+		}
+		const completedMessages = turn.messageOrder.flatMap((itemId) => {
+			const item = turn.messages.get(itemId);
+			return item === void 0 ? [] : [item];
+		});
+		const answer = completedMessages.toReversed().find((item) => item.phase === "final_answer") ?? completedMessages.at(-1) ?? messages.at(-1);
+		if (threadId === void 0 || answer === void 0 || answer.text.trim() === "") {
+			currentTurn.reject(new CodexAppServerError("Codex returned no answer."));
+			return;
+		}
+		currentTurn.resolve({
+			answer: answer.text,
+			sessionId: threadId
+		});
+	};
+	const finishQueuedMessageIfReady = (turnId, turn) => {
+		const queuedMessage = queuedMessagesByTurnId.get(turnId);
+		const { completedTurn } = turn;
+		if (queuedMessage === void 0 || completedTurn === void 0) return;
+		queuedMessagesByTurnId.delete(turnId);
+		queuedMessagesByClientId.delete(queuedMessage.clientUserMessageId);
+		const { status, error } = completedTurn;
+		if (status !== "completed") {
+			const detail = isRecord(error) ? error.message : void 0;
+			settleQueuedMessage(queuedMessage, {
+				error: new CodexAppServerError(typeof detail === "string" ? `Codex turn ${String(status)}: ${detail}` : `Codex turn finished with status ${String(status)}.`),
+				type: "reject"
+			});
+			return;
+		}
+		const messages = turn.messageOrder.flatMap((itemId) => {
+			const item = turn.messages.get(itemId);
+			return item === void 0 ? [] : [item];
+		});
+		if (Array.isArray(completedTurn.items)) {
+			for (const item of completedTurn.items) if (isRecord(item) && item.type === "agentMessage" && typeof item.id === "string" && typeof item.text === "string") {
+				const message = getAgentMessage(turn, item.id);
+				message.text = item.text;
+				if (typeof item.phase === "string") message.phase = item.phase;
+			}
+		}
+		const completedMessages = turn.messageOrder.flatMap((itemId) => {
+			const item = turn.messages.get(itemId);
+			return item === void 0 ? [] : [item];
+		});
+		const answer = completedMessages.toReversed().find((item) => item.phase === "final_answer") ?? completedMessages.at(-1) ?? messages.at(-1);
+		if (answer === void 0 || answer.text.trim() === "") {
+			settleQueuedMessage(queuedMessage, {
+				error: new CodexAppServerError("Codex returned no answer for the queued message."),
+				type: "reject"
+			});
+			return;
+		}
+		settleQueuedMessage(queuedMessage, {
+			answer: answer.text,
+			type: "resolve"
+		});
+	};
+	const getTurnState = (turnId) => {
+		const existing = turns.get(turnId);
+		if (existing !== void 0) return existing;
+		const created = makeTurnState();
+		turns.set(turnId, created);
+		return created;
+	};
+	const handleAgentMessageDelta = (turn, params) => {
+		const { itemId, delta } = params;
+		if (typeof itemId !== "string" || typeof delta !== "string") return;
+		getAgentMessage(turn, itemId).text += delta;
+	};
+	const handleCompletedItem = (turn, params) => {
+		const { item } = params;
+		if (!isRecord(item) || item.type !== "agentMessage" || typeof item.id !== "string" || typeof item.text !== "string") return;
+		const agentMessage = getAgentMessage(turn, item.id);
+		agentMessage.text = item.text;
+		if (typeof item.phase === "string") agentMessage.phase = item.phase;
+	};
+	const handleStartedItem = (turnId, params) => {
+		const { item } = params;
+		if (!isRecord(item) || item.type !== "userMessage") return;
+		const { clientId } = item;
+		if (typeof clientId !== "string") return;
+		const queuedMessage = queuedMessagesByClientId.get(clientId);
+		if (queuedMessage === void 0) return;
+		queuedMessage.turnId = turnId;
+		queuedMessagesByTurnId.set(turnId, queuedMessage);
+	};
+	const pruneTurnBuffer = (activeTurnId) => {
+		if (turns.size <= MAX_BUFFERED_TURNS) return;
+		const oldestTurnId = turns.keys().next().value;
+		if (oldestTurnId !== void 0 && oldestTurnId !== activeTurnId) turns.delete(oldestTurnId);
+	};
+	const handleNotification = (message) => {
+		const { method, params } = message;
+		if (typeof method !== "string" || !isRecord(params) || params.threadId !== threadId) return;
+		const turnId = getNotificationTurnId(params);
+		if (turnId === void 0) return;
+		const turn = getTurnState(turnId);
+		switch (method) {
+			case "item/started":
+				handleStartedItem(turnId, params);
+				break;
+			case "item/agentMessage/delta":
+				handleAgentMessageDelta(turn, params);
+				break;
+			case "item/completed":
+				handleCompletedItem(turn, params);
+				break;
+			case "turn/completed": if (isRecord(params.turn)) {
+				turn.completedTurn = params.turn;
+				finishActiveTurnIfReady();
+				finishQueuedMessageIfReady(turnId, turn);
+			}
+		}
+		pruneTurnBuffer(activeTurn?.turnId ?? "");
+	};
+	const handleResponse = (message) => {
+		const { id } = message;
+		if (!isRpcId(id)) return;
+		const pending = pendingRequests.get(id);
+		if (pending === void 0) return;
+		pendingRequests.delete(id);
+		clearTimeout(pending.timeout);
+		const { error } = message;
+		if (isRecord(error)) {
+			const messageText = typeof error.message === "string" ? error.message : "Unknown JSON-RPC error";
+			if (pending.method === "thread/resume" && options.initialSessionId !== void 0 && isActiveWriterConflict(messageText) && options.initialSessionId !== void 0) {
+				pending.reject(new CodexAppServerError(`Cannot resume Codex session ${options.initialSessionId}: another active Codex App Server owns this session. Connect mdxr and the Codex TUI to the same --remote endpoint. The session ID was not changed.`, "session-conflict"));
+				return;
+			}
+			pending.reject(new CodexAppServerError(`${pending.method} failed: ${messageText}`));
+			return;
+		}
+		pending.resolve(message.result);
+	};
+	const handleMessage = (data) => {
+		let parsed;
+		try {
+			parsed = JSON.parse(decodeFrame(data));
+		} catch {
+			return;
+		}
+		if (!isRecord(parsed)) return;
+		const { id, method } = parsed;
+		if (isRpcId(id) && typeof method === "string") replyToServerRequest(id, method);
+		else if (isRpcId(id)) handleResponse(parsed);
+		else handleNotification(parsed);
+	};
+	const failConnection = (error) => {
+		rejectPendingRequests(error);
+		activeTurn?.reject(error);
+		rejectQueuedMessages(error);
+	};
+	const request = async (method, params) => {
+		const id = nextRequestId;
+		nextRequestId += 1;
+		const response = createDeferred();
+		const timeout = setTimeout(() => {
+			pendingRequests.delete(id);
+			response.reject(new CodexAppServerError(`${method} timed out after ${RPC_TIMEOUT_MS / 1e3} seconds.`));
+		}, RPC_TIMEOUT_MS);
+		timeout.unref?.();
+		pendingRequests.set(id, {
+			method,
+			reject: response.reject,
+			resolve: response.resolve,
+			timeout
+		});
+		try {
+			sendFrame({
+				id,
+				method,
+				params
+			});
+		} catch (error) {
+			pendingRequests.delete(id);
+			clearTimeout(timeout);
+			response.reject(error instanceof Error ? error : new Error(String(error)));
+		}
+		return await response.promise;
+	};
+	const notify = (method, params) => {
+		sendFrame({
+			method,
+			params
+		});
+	};
+	const connect$1 = async () => {
+		if (isClosed) throw makeTransportError("was closed by mdxr.");
+		if (connectionPromise !== void 0) {
+			await connectionPromise;
+			return;
+		}
+		const { socketPath } = endpoint;
+		const nextSocket = new WebSocket(endpoint.url, {
+			...socketPath === void 0 ? {} : { createConnection: () => connect(socketPath) },
+			perMessageDeflate: false
+		});
+		socket = nextSocket;
+		nextSocket.on("message", handleMessage);
+		nextSocket.on("error", (error) => {
+			failConnection(makeTransportError("failed.", error));
+		});
+		nextSocket.on("close", (code, reason) => {
+			if (!isClosing) {
+				const detail = reason.toString("utf-8");
+				const suffix = detail === "" ? "" : `: ${detail}`;
+				failConnection(makeTransportError(`closed unexpectedly (${code}${suffix}).`));
+			}
+		});
+		connectionPromise = (async () => {
+			await once(nextSocket, "open");
+			await request("initialize", {
+				capabilities: { experimentalApi: true },
+				clientInfo: {
+					name: "mdxr",
+					title: "mdxr",
+					version: "0.7.0"
+				}
+			});
+			notify("initialized", {});
+		})();
+		await connectionPromise;
+	};
+	const ensureThread = async () => {
+		if (threadId !== void 0) return threadId;
+		if (options.initialSessionId !== void 0) {
+			const result = await request("thread/resume", {
+				excludeTurns: true,
+				threadId: options.initialSessionId
+			});
+			const thread = isRecord(result) ? result.thread : void 0;
+			const resumedId = isRecord(thread) ? thread.id : void 0;
+			if (typeof resumedId !== "string") throw new CodexAppServerError(`Codex App Server did not resume session ${options.initialSessionId}.`);
+			if (resumedId !== options.initialSessionId) throw new CodexAppServerError(`Codex App Server returned thread ${resumedId} while resuming ${options.initialSessionId}; refusing to switch sessions.`);
+			threadId = resumedId;
+			attachedToExistingThread = true;
+			return threadId;
+		}
+		const params = {};
+		if (options.cwd !== void 0) params.cwd = options.cwd;
+		const result = await request("thread/start", params);
+		const thread = isRecord(result) ? result.thread : void 0;
+		const startedId = isRecord(thread) ? thread.id : void 0;
+		if (typeof startedId !== "string") throw new CodexAppServerError("Codex App Server did not start a thread.");
+		threadId = startedId;
+		return threadId;
+	};
+	const send = async (message) => {
+		if (message.trim() === "") throw new CodexAppServerError("Codex message must not be empty.");
+		if (busy) throw new CodexAppServerError("Codex is already responding in this session.");
+		busy = true;
+		try {
+			await connect$1();
+			const currentThreadId = await ensureThread();
+			const result = await request("turn/start", {
+				input: [{
+					text: message,
+					type: "text"
+				}],
+				threadId: currentThreadId
+			});
+			const turn = isRecord(result) ? result.turn : void 0;
+			const startedTurnId = isRecord(turn) ? turn.id : void 0;
+			if (typeof startedTurnId !== "string") throw new CodexAppServerError("Codex App Server did not return a turn ID.");
+			const completed = createDeferred();
+			const waiter = {
+				reject: completed.reject,
+				resolve: completed.resolve,
+				turnId: startedTurnId
+			};
+			activeTurn = waiter;
+			try {
+				if (isRecord(turn) && turn.status !== "inProgress") {
+					const turnState = turns.get(startedTurnId) ?? makeTurnState();
+					turnState.completedTurn = turn;
+					turns.set(startedTurnId, turnState);
+				}
+				finishActiveTurnIfReady();
+				return await completed.promise;
+			} catch (error) {
+				if (activeTurn === waiter) activeTurn = void 0;
+				throw error instanceof Error ? error : new Error(String(error));
+			} finally {
+				if (activeTurn === waiter) activeTurn = void 0;
+				if (waiter.turnId !== void 0) turns.delete(waiter.turnId);
+			}
+		} finally {
+			busy = false;
+		}
+	};
+	const enqueue = async (message) => {
+		if (message.trim() === "") throw new CodexAppServerError("Codex message must not be empty.");
+		await connect$1();
+		const currentThreadId = await ensureThread();
+		const clientUserMessageId = randomUUID();
+		const completion = createDeferred();
+		const queuedMessage = {
+			acknowledged: false,
+			clientUserMessageId,
+			completion
+		};
+		queuedMessagesByClientId.set(clientUserMessageId, queuedMessage);
+		try {
+			const result = await request("thread/queue/add", {
+				clientUserMessageId,
+				input: [{
+					text: message,
+					type: "text"
+				}],
+				threadId: currentThreadId
+			});
+			const queuedSubmission = isRecord(result) ? result.queuedSubmission : void 0;
+			if (!isRecord(queuedSubmission) || typeof queuedSubmission.id !== "string" || queuedSubmission.clientUserMessageId !== clientUserMessageId) throw new CodexAppServerError("Codex App Server did not acknowledge the queued message with its client ID.");
+			acknowledgeQueuedMessage(queuedMessage);
+			return {
+				completion: completion.promise,
+				sessionId: currentThreadId
+			};
+		} catch (error) {
+			queuedMessagesByClientId.delete(clientUserMessageId);
+			if (queuedMessage.turnId !== void 0) queuedMessagesByTurnId.delete(queuedMessage.turnId);
+			throw error instanceof Error ? error : new Error(String(error));
+		}
+	};
+	const close = async () => {
+		if (closePromise !== void 0) {
+			await closePromise;
+			return;
+		}
+		isClosed = true;
+		isClosing = true;
+		closePromise = (async () => {
+			const currentSocket = socket;
+			if (currentSocket === void 0 || currentSocket.readyState === WebSocket.CLOSED) {
+				failConnection(makeTransportError("was closed by mdxr."));
+				return;
+			}
+			const closed = once(currentSocket, "close");
+			if (currentSocket.readyState === WebSocket.OPEN) currentSocket.close(1e3, "mdxr session closed");
+			else currentSocket.terminate();
+			await closed;
+			failConnection(makeTransportError("was closed by mdxr."));
+		})();
+		await closePromise;
+	};
+	return {
+		close,
+		enqueue,
+		send
+	};
+};
+//#endregion
+//#region src/agent-session.ts
+const emptyStore = () => ({
+	documents: {},
+	version: 1
+});
+const isConversation = (value) => {
+	if (typeof value !== "object" || value === null) return false;
+	const item = value;
+	return (item.provider === "codex" || item.provider === "claude") && (item.sessionId === void 0 || typeof item.sessionId === "string") && Array.isArray(item.messages) && item.messages.every((message) => (message.role === "user" || message.role === "assistant") && typeof message.content === "string");
+};
+const isSessionStore = (value) => {
+	if (typeof value !== "object" || value === null) return false;
+	const store = value;
+	return store.version === 1 && typeof store.documents === "object" && store.documents !== null && Object.values(store.documents).every(isConversation);
+};
+const readStore = async (file) => {
+	let raw;
+	try {
+		raw = await readFile(file, "utf-8");
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return emptyStore();
+		throw error;
+	}
+	const parsed = JSON.parse(raw);
+	if (!isSessionStore(parsed)) throw new Error("Invalid mdxr session store");
+	return parsed;
+};
+const writeStore = async (file, store) => {
+	await mkdir(path.dirname(file), { recursive: true });
+	const temp = path.join(path.dirname(file), `.sessions-${randomUUID()}.tmp`);
+	try {
+		await writeFile(temp, `${JSON.stringify(store, null, 2)}\n`, { mode: 384 });
+		await rename(temp, file);
+	} catch (error) {
+		const { rm } = await import("node:fs/promises");
+		await rm(temp, { force: true });
+		throw error;
+	}
+};
+/** Keep one live provider connection for the lifetime of the MDX preview. */
+const createAgentSession = (filePath, provider, initialSessionId, serverEndpoint) => {
+	const document = path.resolve(filePath);
+	const cwd = process.cwd();
+	const storePath = path.join(cwd, ".mdxr", "sessions.json");
+	let busy = false;
+	let lastError;
+	let onUpdate;
+	let connection;
+	let claudeConversation = {
+		messages: [],
+		provider
+	};
+	const savedConversation = async () => {
+		if (provider === "claude") return claudeConversation;
+		const saved = (await readStore(storePath)).documents[document];
+		if (saved?.provider === provider && (initialSessionId === void 0 || saved.sessionId === initialSessionId)) return saved;
+		return {
+			messages: [],
+			provider,
+			sessionId: initialSessionId
+		};
+	};
+	const current = async () => ({
+		...await savedConversation(),
+		busy,
+		error: lastError
+	});
+	const saveConversation = async (conversation) => {
+		if (provider === "claude") {
+			claudeConversation = conversation;
+			return;
+		}
+		const store = await readStore(storePath);
+		store.documents[document] = conversation;
+		await writeStore(storePath, store);
+	};
+	const send = async (message) => {
+		if (busy) throw new Error("Agent is already responding");
+		busy = true;
+		lastError = void 0;
+		let awaitingQueuedAnswer = false;
+		try {
+			const conversation = await savedConversation();
+			connection ??= provider === "codex" ? createCodexAppServerSession({
+				cwd,
+				endpoint: serverEndpoint,
+				initialSessionId: conversation.sessionId
+			}) : createClaudeStreamSession(cwd);
+			const prompt = conversation.sessionId === void 0 ? `This message was sent from the preview of ${document}.\n\n${message}` : message;
+			if (provider === "codex" && conversation.sessionId !== void 0 && connection.enqueue !== void 0) {
+				const queued = await connection.enqueue(prompt);
+				const updated = {
+					messages: [...conversation.messages, {
+						content: message,
+						role: "user"
+					}],
+					provider,
+					sessionId: queued.sessionId
+				};
+				await saveConversation(updated);
+				(async () => {
+					try {
+						const answer = await queued.completion;
+						await saveConversation({
+							...updated,
+							messages: [...updated.messages, {
+								content: answer,
+								role: "assistant"
+							}]
+						});
+					} catch (error) {
+						lastError = error instanceof Error ? error.message : String(error);
+					} finally {
+						busy = false;
+						onUpdate?.();
+					}
+				})();
+				awaitingQueuedAnswer = true;
+				return {
+					...updated,
+					busy: true
+				};
+			}
+			const response = await connection.send(prompt);
+			const updated = {
+				messages: [
+					...conversation.messages,
+					{
+						content: message,
+						role: "user"
+					},
+					{
+						content: response.answer,
+						role: "assistant"
+					}
+				],
+				provider,
+				sessionId: response.sessionId
+			};
+			await saveConversation(updated);
+			return {
+				...updated,
+				busy: false
+			};
+		} finally {
+			if (!awaitingQueuedAnswer) busy = false;
+		}
+	};
+	const close = async () => {
+		await connection?.close();
+	};
+	const setOnUpdate = (callback) => {
+		onUpdate = callback;
+	};
+	return {
+		close,
+		current,
+		send,
+		setOnUpdate
+	};
+};
+//#endregion
+//#region src/document-history.ts
+var DocumentHistoryError = class extends Error {
+	kind;
+	constructor(kind, message) {
+		super(message);
+		this.name = "DocumentHistoryError";
+		this.kind = kind;
+	}
+};
+const HASH_PATTERN = /^[\da-f]{64}$/u;
+const EVENT_PATTERN = /^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu;
+const LOCK_STALE_AFTER_MS = 6e5;
+const LOCK_RETRY_MS = 20;
+const MAX_LOCK_WAIT_MS = 3e4;
+const MAX_STABLE_READS = 6;
+const sha256 = (value) => createHash("sha256").update(value).digest("hex");
+const isNodeError = (error) => error instanceof Error && "code" in error;
+const sameFileState = (left, right) => left.dev === right.dev && left.ino === right.ino && left.size === right.size && left.mtimeNs === right.mtimeNs && left.ctimeNs === right.ctimeNs;
+const readStableFile = async (filePath) => {
+	for (let attempt = 0; attempt < MAX_STABLE_READS; attempt += 1) {
+		try {
+			const before = await fsp.stat(filePath, { bigint: true });
+			const content = await fsp.readFile(filePath);
+			const after = await fsp.stat(filePath, { bigint: true });
+			if (sameFileState(before, after) && BigInt(content.byteLength) === after.size) return content;
+		} catch (error) {
+			if (!isNodeError(error) || error.code !== "ENOENT" && error.code !== "EBUSY" || attempt === 5) throw error;
+		}
+		await setTimeout$1(12 * (attempt + 1));
+	}
+	throw new Error(`Could not read a stable MDX version: ${filePath}`);
+};
+/** Write a file through a temporary name, then link it without replacing an
+* existing immutable file. This is safe when two preview processes race. */
+const writeImmutable = async (filePath, content) => {
+	const temporary = `${filePath}.${randomUUID()}.tmp`;
+	try {
+		await fsp.writeFile(temporary, content, { flag: "wx" });
+		try {
+			await fsp.link(temporary, filePath);
+		} catch (error) {
+			if (!isNodeError(error) || error.code !== "EEXIST") throw error;
+		}
+	} finally {
+		await fsp.rm(temporary, { force: true });
+	}
+};
+const parseVersionKind = (value) => value === "initial" || value === "before-instruction" || value === "change";
+const readVersionEvent = async (eventPath, expectedId) => {
+	let raw;
+	try {
+		raw = JSON.parse(await fsp.readFile(eventPath, "utf-8"));
+	} catch (error) {
+		if (isNodeError(error) && error.code === "ENOENT") throw error;
+		throw new DocumentHistoryError("corrupt-version", `Could not read document history event: ${expectedId}: ${String(error)}`);
+	}
+	if (typeof raw !== "object" || raw === null || !("id" in raw) || raw.id !== expectedId || !("contentHash" in raw) || typeof raw.contentHash !== "string" || !HASH_PATTERN.test(raw.contentHash) || !("kind" in raw) || !parseVersionKind(raw.kind) || !("createdAt" in raw) || typeof raw.createdAt !== "string" || Number.isNaN(Date.parse(raw.createdAt)) || !("size" in raw) || typeof raw.size !== "number" || !Number.isSafeInteger(raw.size) || raw.size < 0 || !("sequence" in raw) || typeof raw.sequence !== "number" || !Number.isSafeInteger(raw.sequence) || raw.sequence < 1) throw new DocumentHistoryError("corrupt-version", `Invalid document history event: ${expectedId}`);
+	return {
+		contentHash: raw.contentHash,
+		createdAt: raw.createdAt,
+		id: raw.id,
+		kind: raw.kind,
+		sequence: raw.sequence,
+		size: raw.size
+	};
+};
+const acquireLock = async (lockPath) => {
+	const startedAt = Date.now();
+	while (Date.now() - startedAt < MAX_LOCK_WAIT_MS) try {
+		const handle = await fsp.open(lockPath, "wx", 384);
+		await handle.writeFile(`${process.pid}\n${Date.now()}\n`);
+		return async () => {
+			await handle.close();
+			await fsp.rm(lockPath, { force: true });
+		};
+	} catch (error) {
+		if (!isNodeError(error) || error.code !== "EEXIST") throw error;
+		try {
+			const stat = await fsp.stat(lockPath);
+			if (Date.now() - stat.mtimeMs > LOCK_STALE_AFTER_MS) {
+				await fsp.rm(lockPath, { force: true });
+				continue;
+			}
+		} catch (statError) {
+			if (!isNodeError(statError) || statError.code !== "ENOENT") throw statError;
+		}
+		await setTimeout$1(LOCK_RETRY_MS);
+	}
+	throw new Error("Timed out waiting for the MDX history lock");
+};
+const lines = (source) => source.replaceAll("\r\n", "\n").split("\n");
+/** Myers shortest edit script with O((N + M)D) time and trace backtracking. */
+const diffLines = (before, after) => {
+	const left = lines(before);
+	const right = lines(after);
+	const max = left.length + right.length;
+	const trace = [];
+	const frontier = /* @__PURE__ */ new Map([[1, 0]]);
+	let found = false;
+	for (let distance = 0; distance <= max; distance += 1) {
+		trace.push(new Map(frontier));
+		for (let diagonal = -distance; diagonal <= distance; diagonal += 2) {
+			let x = diagonal === -distance || diagonal !== distance && (frontier.get(diagonal - 1) ?? Number.NEGATIVE_INFINITY) < (frontier.get(diagonal + 1) ?? Number.NEGATIVE_INFINITY) ? frontier.get(diagonal + 1) ?? 0 : (frontier.get(diagonal - 1) ?? 0) + 1;
+			let y = x - diagonal;
+			while (x < left.length && y < right.length && left[x] === right[y]) {
+				x += 1;
+				y += 1;
+			}
+			frontier.set(diagonal, x);
+			if (x >= left.length && y >= right.length) {
+				found = true;
+				break;
+			}
+		}
+		if (found) break;
+	}
+	let x = left.length;
+	let y = right.length;
+	const reversed = [];
+	for (let distance = trace.length - 1; distance >= 0; distance -= 1) {
+		const previous = trace[distance];
+		if (previous === void 0) continue;
+		const diagonal = x - y;
+		const previousDiagonal = diagonal === -distance || diagonal !== distance && (previous.get(diagonal - 1) ?? Number.NEGATIVE_INFINITY) < (previous.get(diagonal + 1) ?? Number.NEGATIVE_INFINITY) ? diagonal + 1 : diagonal - 1;
+		const previousX = previous.get(previousDiagonal) ?? 0;
+		const previousY = previousX - previousDiagonal;
+		while (x > previousX && y > previousY) {
+			reversed.push({
+				text: left[x - 1] ?? "",
+				type: "context"
+			});
+			x -= 1;
+			y -= 1;
+		}
+		if (distance === 0) break;
+		if (x === previousX) {
+			reversed.push({
+				text: right[y - 1] ?? "",
+				type: "add"
+			});
+			y -= 1;
+		} else {
+			reversed.push({
+				text: left[x - 1] ?? "",
+				type: "remove"
+			});
+			x -= 1;
+		}
+	}
+	return reversed.toReversed();
+};
+const eventCompare = (left, right) => left.sequence - right.sequence;
+/** Local, token-free snapshots and line diffs for one MDX source file. */
+const createDocumentHistory = (filePath, rootDir = process.cwd()) => {
+	const absoluteFilePath = path.resolve(filePath);
+	const historyPath = path.join(path.resolve(rootDir), ".mdxr", "history", sha256(absoluteFilePath));
+	const versionsPath = path.join(historyPath, "versions");
+	const eventsPath = path.join(historyPath, "events");
+	const lockPath = path.join(historyPath, ".capture.lock");
+	const listUnlocked = async () => {
+		await fsp.mkdir(eventsPath, { recursive: true });
+		const eventEntries = (await fsp.readdir(eventsPath, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".json") && EVENT_PATTERN.test(entry.name.replace(/\.json$/u, "")));
+		const versions = await Promise.all(eventEntries.map(async (entry) => {
+			const eventId = entry.name.slice(0, -5);
+			const version = await readVersionEvent(path.join(eventsPath, entry.name), eventId);
+			return {
+				contentHash: version.contentHash,
+				createdAt: version.createdAt,
+				id: version.id,
+				kind: version.kind,
+				sequence: version.sequence,
+				size: version.size
+			};
+		}));
+		versions.sort(eventCompare);
+		return {
+			latestId: versions.at(-1)?.id ?? "",
+			versions
+		};
+	};
+	const findVersion = async (id) => {
+		if (!EVENT_PATTERN.test(id)) throw new DocumentHistoryError("invalid-version", `Invalid document history version ID: ${id}`);
+		const eventPath = path.join(eventsPath, `${id}.json`);
+		try {
+			return await readVersionEvent(eventPath, id);
+		} catch (error) {
+			if (isNodeError(error) && error.code === "ENOENT") throw new DocumentHistoryError("unknown-version", `Unknown document history version: ${id}`);
+			throw error;
+		}
+	};
+	return {
+		capture: async (kind) => {
+			await fsp.mkdir(versionsPath, { recursive: true });
+			const release = await acquireLock(lockPath);
+			try {
+				const content = await readStableFile(absoluteFilePath);
+				const contentHash = sha256(content);
+				const latest = (await listUnlocked()).versions.at(-1);
+				if (kind !== "before-instruction" && latest?.contentHash === contentHash) return latest;
+				const blobPath = path.join(versionsPath, `${contentHash}.mdx`);
+				await writeImmutable(blobPath, content);
+				const version = {
+					contentHash,
+					createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+					id: randomUUID(),
+					kind,
+					sequence: (latest?.sequence ?? 0) + 1,
+					size: content.byteLength
+				};
+				const eventPath = path.join(eventsPath, `${version.id}.json`);
+				await writeImmutable(eventPath, JSON.stringify(version));
+				return version;
+			} finally {
+				await release();
+			}
+		},
+		diff: async (fromId, toId) => {
+			const [from, to] = await Promise.all([findVersion(fromId), findVersion(toId)]);
+			const [before, after] = await Promise.all([fsp.readFile(path.join(versionsPath, `${from.contentHash}.mdx`)), fsp.readFile(path.join(versionsPath, `${to.contentHash}.mdx`))]);
+			if (sha256(before) !== from.contentHash) throw new DocumentHistoryError("corrupt-version", `Corrupt document history version: ${fromId}`);
+			if (sha256(after) !== to.contentHash) throw new DocumentHistoryError("corrupt-version", `Corrupt document history version: ${toId}`);
+			return { lines: diffLines(before.toString("utf-8"), after.toString("utf-8")) };
+		},
+		list: async () => await listUnlocked(),
+		read: async (id) => {
+			const version = await findVersion(id);
+			const content = await fsp.readFile(path.join(versionsPath, `${version.contentHash}.mdx`));
+			if (sha256(content) !== version.contentHash) throw new DocumentHistoryError("corrupt-version", `Corrupt document history version: ${id}`);
+			return content.toString("utf-8");
+		}
+	};
+};
+//#endregion
+//#region src/document-history-http.ts
+const replyJson = (response, status, body) => {
+	response.writeHead(status, {
+		"cache-control": "no-store",
+		"content-type": "application/json; charset=utf-8",
+		"x-content-type-options": "nosniff"
+	});
+	response.end(JSON.stringify(body));
+};
+const sameOrigin = (request) => {
+	const port = request.socket.localPort;
+	const host = request.headers.host ?? "";
+	return (host === `localhost:${port}` || host === `127.0.0.1:${port}`) && (request.headers.origin === void 0 || request.headers.origin === `http://${host}`);
+};
+/** Read-only endpoints for the local, token-free MDX version store. */
+const handleDocumentHistoryRequest = async (request, response, history, filePath) => {
+	if (history === void 0 || filePath === void 0) {
+		replyJson(response, 404, { error: "Document history is unavailable" });
+		return;
+	}
+	if (!sameOrigin(request)) {
+		replyJson(response, 403, { error: "Request origin is not allowed" });
+		return;
+	}
+	if (request.method !== "GET") {
+		replyJson(response, 405, { error: "Method not allowed" });
+		return;
+	}
+	const url = new URL(request.url ?? "", "http://localhost");
+	try {
+		const view = url.searchParams.get("view");
+		if (view === null) {
+			replyJson(response, 200, await history.list());
+			return;
+		}
+		const id = url.searchParams.get("id");
+		if (view === "source" && id !== null) {
+			const source = await history.read(id);
+			const syntax = await highlightMdxSource(source);
+			replyJson(response, 200, {
+				id,
+				source,
+				syntax
+			});
+			return;
+		}
+		if (view === "diff") {
+			const from = url.searchParams.get("from");
+			const to = url.searchParams.get("to");
+			if (from !== null && to !== null) {
+				const { lines } = await history.diff(from, to);
+				const beforeSource = lines.filter((line) => line.type !== "add").map((line) => line.text).join("\n");
+				const afterSource = lines.filter((line) => line.type !== "remove").map((line) => line.text).join("\n");
+				const [before, after] = await Promise.all([highlightMdxSource(beforeSource), highlightMdxSource(afterSource)]);
+				replyJson(response, 200, {
+					from,
+					lines,
+					syntax: {
+						after,
+						before
+					},
+					to
+				});
+				return;
+			}
+		}
+		if (view === "preview" && id !== null) {
+			const source = await history.read(id);
+			const html = await render(source, {
+				dir: path.dirname(filePath),
+				filePath,
+				liveReload: false
+			});
+			response.writeHead(200, {
+				"cache-control": "no-store",
+				"content-type": "text/html; charset=utf-8",
+				"x-content-type-options": "nosniff"
+			});
+			response.end(html);
+			return;
+		}
+		replyJson(response, 400, { error: "Invalid history view or version" });
+	} catch (error) {
+		const detail = formatError(error);
+		const missingVersion = error instanceof DocumentHistoryError && (error.kind === "invalid-version" || error.kind === "unknown-version");
+		replyJson(response, missingVersion ? 404 : 500, { error: detail });
+	}
+};
+//#endregion
+//#region src/workspace-js.ts
+let cached;
+const buildWorkspaceJs = async () => {
+	return (await build({
+		absWorkingDir: pkgRoot,
+		bundle: true,
+		define: { "process.env.NODE_ENV": "\"production\"" },
+		entryPoints: [path.join(srcDir, "workspace-app.tsx")],
+		format: "iife",
+		jsx: "automatic",
+		jsxImportSource: "react",
+		logLevel: "silent",
+		minify: true,
+		platform: "browser",
+		target: "es2022",
+		write: false
+	})).outputFiles[0]?.text ?? "";
+};
+/** Browser-only React workspace used while serving a file. */
+const workspaceJs = async () => {
+	cached ??= buildWorkspaceJs();
+	try {
+		return await cached;
+	} catch (error) {
+		cached = void 0;
+		throw error;
+	}
+};
+//#endregion
 //#region src/serve.ts
 const errorPage = (err) => `<!doctype html><meta charset="utf-8"><body style="font-family:monospace;background:#1c1917;color:#fca5a5;padding:2rem"><h1>mdxr render error</h1><pre>${formatError(err).replaceAll("&", "&amp;").replaceAll("<", "&lt;")}</pre></body>`;
 /** Dependency/build output dirs — never worth a watch fd. */
@@ -7785,7 +9240,7 @@ const createWatchSet = () => {
 	* picked up on the next rebuild (armDeps re-arms the tree for this).
 	*/
 	const arm = (dir, onEvent) => {
-		if (SKIP_DIRS.has(path.basename(dir))) return;
+		if (SKIP_DIRS.has(path.basename(dir)) || path.basename(dir) === "history" && path.basename(path.dirname(dir)) === ".mdxr") return;
 		if (!armed.has(dir)) try {
 			track(fs.watch(dir, onEvent), dir);
 		} catch {}
@@ -7812,8 +9267,49 @@ const createWatchSet = () => {
 const servePreview = async (target, port) => {
 	let html = "";
 	let closed = false;
+	let capturedInitialVersion = false;
 	const clients = /* @__PURE__ */ new Set();
+	const notifyAgent = () => {
+		for (const client of clients) try {
+			client.write("event: agent\ndata: {}\n\n");
+		} catch {
+			clients.delete(client);
+		}
+	};
+	target.agent?.setOnUpdate(notifyAgent);
 	const server = http.createServer((req, res) => {
+		if (req.url === "/__mdxr_workspace.js") {
+			if (target.history === void 0) {
+				res.writeHead(404);
+				res.end();
+				return;
+			}
+			(async () => {
+				try {
+					const script = await workspaceJs();
+					res.writeHead(200, {
+						"cache-control": "no-store",
+						"content-type": "text/javascript; charset=utf-8",
+						"x-content-type-options": "nosniff"
+					});
+					res.end(script);
+				} catch (error) {
+					res.writeHead(500, { "content-type": "text/plain; charset=utf-8" });
+					res.end(formatError(error));
+				}
+			})();
+			return;
+		}
+		if (req.url === "/__mdxr_agent") {
+			handleAgentRequest(req, res, target.agent, notifyAgent, async () => {
+				await target.history?.capture("before-instruction");
+			});
+			return;
+		}
+		if (req.url?.startsWith("/__mdxr_history") === true) {
+			handleDocumentHistoryRequest(req, res, target.history, target.historyFile);
+			return;
+		}
 		if (req.url === "/__mdxr_events") {
 			res.writeHead(200, {
 				"cache-control": "no-cache",
@@ -7853,7 +9349,12 @@ const servePreview = async (target, port) => {
 	};
 	const rebuild = async (onEvent) => {
 		try {
-			html = await target.renderDoc();
+			if (target.history !== void 0) {
+				await target.history.capture(capturedInitialVersion ? "change" : "initial");
+				capturedInitialVersion = true;
+			}
+			const rendered = await target.renderDoc();
+			html = target.history === void 0 ? rendered : injectAgentPreview(rendered, target.agentProvider);
 		} catch (error) {
 			html = errorPage(error);
 		}
@@ -7876,7 +9377,10 @@ const servePreview = async (target, port) => {
 		})();
 	};
 	const notify = (_event, filename) => {
-		if (closed || filename?.split(path.sep).some((part) => SKIP_DIRS.has(part)) === true) return;
+		const parts = filename?.split(path.sep) ?? [];
+		const isHistoryWrite = parts.includes("history") && (parts.includes(".mdxr") || path.basename(target.watchDir) === ".mdxr");
+		const isInternalMdxrWrite = path.basename(target.watchDir) !== ".mdxr" && parts.includes(".mdxr");
+		if (closed || parts.some((part) => SKIP_DIRS.has(part)) || isHistoryWrite || isInternalMdxrWrite || parts.some((part) => part === "sessions.json" || /^\.sessions-.*\.tmp$/u.test(part))) return;
 		clearTimeout(timer);
 		timer = setTimeout(() => {
 			reload(notify);
@@ -7891,10 +9395,16 @@ const servePreview = async (target, port) => {
 	if (watch.size === 0 && target.watchFile !== void 0) try {
 		watch.track(fs.watch(target.watchFile, notify));
 	} catch {}
+	const closeAgent = async () => {
+		try {
+			await target.agent?.close();
+		} catch {}
+	};
 	server.on("close", () => {
 		closed = true;
 		clearTimeout(timer);
 		watch.close();
+		closeAgent();
 	});
 	reloading = rebuild(notify);
 	await reloading;
@@ -7938,8 +9448,16 @@ const trackDeps = (renderDoc) => {
 };
 /** Serve an .mdx file, rebuilding + live-reloading on changes in its directory. */
 const serve = async (mdxPath, port, opts = {}) => {
+	if (opts.session !== void 0 && opts.agent === void 0) throw new Error("--session requires --agent");
+	if (opts.session !== void 0 && opts.agent !== "codex") throw new Error("--session is only supported for codex");
+	if (opts.server !== void 0 && opts.agent !== "codex") throw new Error("--server requires --agent codex");
 	const abs = path.resolve(mdxPath);
+	const history = createDocumentHistory(abs);
 	const server = await servePreview({
+		agent: opts.agent === void 0 ? void 0 : createAgentSession(abs, opts.agent, opts.session, opts.server),
+		agentProvider: opts.agent,
+		history,
+		historyFile: abs,
 		label: mdxPath,
 		...trackDeps(async (onDeps) => await renderFile(abs, {
 			liveReload: true,
@@ -7953,6 +9471,7 @@ const serve = async (mdxPath, port, opts = {}) => {
 };
 /** Serve MDX source passed directly (e.g. piped via stdin). */
 const serveSource = async (source, port, opts = {}) => {
+	if (opts.agent !== void 0 || opts.session !== void 0 || opts.server !== void 0) throw new Error("Agent chat requires an MDX file");
 	const dir = path.resolve(opts.dir ?? process.cwd());
 	const server = await servePreview({
 		label: opts.filePath ?? "stdin",
@@ -7998,6 +9517,14 @@ const fail = (err, json) => {
 	else console.error(`mdxr: error: ${formatError(err)}`);
 	process.exit(1);
 };
+const validateAgentOptions = (agent, session, server) => {
+	if (agent !== void 0 && agent !== "codex" && agent !== "claude") throw new Error(`invalid --agent: ${agent} (expected codex or claude)`);
+	if (session !== void 0 && agent === void 0) throw new Error("--session requires --agent");
+	if (session !== void 0 && agent !== "codex") throw new Error("--session is only supported for codex");
+	if (server !== void 0 && agent !== "codex") throw new Error("--server requires --agent codex");
+	if (session !== void 0 && session.trim() === "") throw new Error("--session requires a non-empty ID");
+	return agent;
+};
 const cli = cac("mdxr");
 cli.command("render [file]", "Render an .mdx document to a standalone HTML file").option("-o, --out <path>", "Output path (default: <file>.html; stdout for stdin input or '-')").option("--format <format>", "Error output: text | json").option("--no-hydrate", "Emit static HTML without the client hydration bundle").option("--open", "Open the rendered file in the default browser").action(async (file, opts) => {
 	const json = opts.format === "json";
@@ -8027,12 +9554,14 @@ cli.command("render [file]", "Render an .mdx document to a standalone HTML file"
 		fail(error, json);
 	}
 });
-cli.command("serve [file]", "Preview a document in the browser with live reload").option("-p, --port <port>", "Port", { default: 3737 }).option("--open", "Open the preview in the default browser once serving").action(async (file, opts) => {
+cli.command("serve [file]", "Preview a document in the browser with live reload").option("-p, --port <port>", "Port", { default: 3737 }).option("--open", "Open the preview in the default browser once serving").option("--agent <agent>", "Chat with codex or claude in the preview").option("--session <id>", "Send to an existing Codex thread").option("--server <url>", "Codex App Server ws:// or unix:// endpoint").action(async (file, opts) => {
 	try {
 		const port = Number(opts.port);
 		if (!Number.isInteger(port) || port < 0 || port > 65535) throw new Error(`invalid --port: ${opts.port}`);
 		const open = opts.open === true;
+		const agent = validateAgentOptions(opts.agent, opts.session, opts.server);
 		if (file === void 0 || file === "-") {
+			if (agent !== void 0) throw new Error("--agent requires an MDX file");
 			requireStdinSource();
 			await serveSource(await readStdin(), port, {
 				dir: process.cwd(),
@@ -8041,7 +9570,12 @@ cli.command("serve [file]", "Preview a document in the browser with live reload"
 			});
 			return;
 		}
-		await serve(file, port, { open });
+		await serve(file, port, {
+			agent,
+			open,
+			server: opts.server,
+			session: opts.session
+		});
 	} catch (error) {
 		fail(error, false);
 	}