plannar 0.0.3 → 0.0.5

package/dist/cli.mjs

@@ -10,10 +10,10 @@ const main = defineCommand({
 		description: "MDX plan editor CLI — init, preview, and export plans"
 	},
 	subCommands: {
-		init: () => import("./init-CK5HMoQf.mjs").then((m) => m.default),
-		editor: () => import("./editor-Bv5RTgcT.mjs").then((m) => m.default),
-		export: () => import("./export-BPZixWW4.mjs").then((m) => m.default),
-		status: () => import("./status-gCBxoymh.mjs").then((m) => m.default)
+		init: () => import("./init-OGg6OjUh.mjs").then((m) => m.default),
+		editor: () => import("./editor-Cc5XAM2j.mjs").then((m) => m.default),
+		export: () => import("./export-BSvaL5R2.mjs").then((m) => m.default),
+		status: () => import("./status-B4laDYjc.mjs").then((m) => m.default)
 	}
 });
 const junkCss = join(process.cwd(), ".plannar", "node_modules", ".plannar-junk.css");

package/dist/{editor-Bv5RTgcT.mjs → editor-Cc5XAM2j.mjs}

@@ -1,18 +1,19 @@
-import { n as resolveConfig, t as merge } from "./config-FJViU9hJ.mjs";
+import { n as resolveConfig, t as merge } from "./config-C_Uf66xX.mjs";
 import { defineCommand } from "citty";
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
 import { createServer } from "vite";
-import { fileURLToPath } from "node:url";
 //#region src/commands/editor.ts
-function findEditorRoot(startDir) {
-	if (existsSync(resolve(startDir, "editor", "index.html"))) return resolve(startDir, "editor");
-	let dir = startDir;
+function findEditorRoot(pkgDir) {
+	const bundled = resolve(pkgDir, "editor");
+	if (existsSync(resolve(bundled, "vite.config.ts"))) return bundled;
+	let dir = pkgDir;
 	for (let i = 0; i < 10; i++) {
-		if (existsSync(resolve(dir, "apps/editor/index.html"))) return resolve(dir, "apps/editor");
+		const candidate = resolve(dir, "apps", "editor");
+		if (existsSync(resolve(candidate, "vite.config.ts"))) return candidate;
 		dir = resolve(dir, "..");
 	}
-	throw new Error("Could not find apps/editor relative to CLI package");
+	throw new Error("Could not find editor relative to CLI package");
 }
 var editor_default = defineCommand({
 	meta: {
@@ -40,7 +41,7 @@ var editor_default = defineCommand({
 		if (config.globalCss) process.env.PLANNAR_GLOBAL_CSS = resolve(cwd, config.globalCss);
 		if (config.cssFilePath) process.env.PLANNAR_CSS_FILE_PATH = resolve(cwd, config.cssFilePath);
 		if (config.meta) process.env.PLANNAR_META = JSON.stringify(config.meta);
-		const editorRoot = findEditorRoot(fileURLToPath(new URL("..", import.meta.url)));
+		const editorRoot = findEditorRoot(import.meta.dirname);
 		const baseServerConfig = {
 			configFile: resolve(editorRoot, "vite.config.ts"),
 			root: editorRoot,

package/dist/export-BSvaL5R2.mjs

@@ -0,0 +1,653 @@
+import { n as resolveConfig } from "./config-C_Uf66xX.mjs";
+import { defineCommand } from "citty";
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { build } from "vite";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+import react from "@vitejs/plugin-react";
+import tailwindcss from "@tailwindcss/vite";
+import { readFile } from "node:fs/promises";
+import { compile } from "@mdx-js/mdx";
+import remarkGfm from "remark-gfm";
+import rehypePrettyCode from "rehype-pretty-code";
+import rehypeAutolinkHeadings from "rehype-autolink-headings";
+import { Parser } from "acorn";
+import acornJsx from "acorn-jsx";
+//#region ../core/dist/index.mjs
+/**
+* Built-in HTML element bindings.
+* Keys are element name, or `element:type` for inputs with a type attribute.
+*/
+const htmlBindings = {
+	input: {
+		valueProp: "value",
+		changeProp: "onChange",
+		extract: "e.target.value"
+	},
+	"input:checkbox": {
+		valueProp: "checked",
+		changeProp: "onChange",
+		extract: "e.target.checked"
+	},
+	"input:number": {
+		valueProp: "value",
+		changeProp: "onChange",
+		extract: "e.target.valueAsNumber"
+	},
+	textarea: {
+		valueProp: "value",
+		changeProp: "onChange",
+		extract: "e.target.value"
+	},
+	select: {
+		valueProp: "value",
+		changeProp: "onChange",
+		extract: "e.target.value"
+	}
+};
+const _parser = Parser.extend(acornJsx());
+function parseEsm(code) {
+	return _parser.parse(code, {
+		ecmaVersion: "latest",
+		sourceType: "module",
+		locations: true
+	});
+}
+const remarkStateBind = (options) => {
+	const bindings = {
+		...htmlBindings,
+		...options?.bindings
+	};
+	const state = {
+		counter: 0,
+		importAdded: false
+	};
+	return (tree) => {
+		state.counter = 0;
+		state.importAdded = false;
+		visitAndTransform(tree, tree, state, bindings);
+		if (state.importAdded) tree.children.unshift({
+			type: "mdxjsEsm",
+			value: `import { useState } from "react"`,
+			data: { estree: parseEsm(`import { useState } from "react"`) }
+		});
+	};
+};
+function visitAndTransform(node, root, state, bindings) {
+	if (!node.children) return;
+	for (let i = node.children.length - 1; i >= 0; i--) {
+		const child = node.children[i];
+		if (child.children) visitAndTransform(child, root, state, bindings);
+	}
+	for (let i = 0; i < node.children.length; i++) {
+		const child = node.children[i];
+		if (child.type === "mdxJsxFlowElement" && child.name === "Playground") {
+			const transformed = transformPlayground(child, node.children, i, root, state, bindings);
+			i += transformed.indexOffset;
+		}
+	}
+}
+function transformPlayground(playground, siblings, index, root, state, bindings) {
+	const binds = collectBinds(playground, playground);
+	const names = binds.map((b) => b.name);
+	const dupes = names.filter((n, i) => names.indexOf(n) !== i);
+	if (dupes.length > 0) throw new Error(`Duplicate bind names in <Playground>: ${[...new Set(dupes)].join(", ")}`);
+	applyBindings(playground, binds, bindings);
+	const componentName = `_PlannarPlayground_${state.counter++}`;
+	const childrenJsx = (playground.children || []).map(serializeNode).join("\n");
+	const stateDecls = binds.map((b) => `const [${b.name}, set${capitalize(b.name)}] = useState(${b.initialValue})`).join("\n  ");
+	const esmCode = `function ${componentName}() {\n  ${stateDecls ? stateDecls + "\n  " : ""}return (<>\n${indent(childrenJsx)}\n</>)\n}`;
+	if (stateDecls && !state.importAdded) state.importAdded = true;
+	const esmNode = {
+		type: "mdxjsEsm",
+		value: esmCode,
+		data: { estree: parseEsm(esmCode) }
+	};
+	siblings[index] = {
+		type: "mdxJsxFlowElement",
+		name: componentName,
+		attributes: [],
+		children: []
+	};
+	root.children.unshift(esmNode);
+	return { indexOffset: 0 };
+}
+function collectBinds(node, owningPlayground) {
+	const binds = [];
+	if (node !== owningPlayground && node.type === "mdxJsxFlowElement" && node.name === "Playground") return binds;
+	if (Array.isArray(node.attributes)) {
+		for (const attr of node.attributes) if (attr.type === "mdxJsxAttribute" && attr.name === "bind") {
+			const attrValue = attr.value;
+			if (typeof attrValue === "object" && attrValue !== null && attrValue.type === "mdxJsxAttributeValueExpression") {
+				const expr = String(attrValue.value ?? "");
+				const colonIdx = expr.indexOf(":");
+				if (colonIdx === -1) binds.push({
+					name: expr,
+					initialValue: "undefined"
+				});
+				else {
+					const name = expr.slice(0, colonIdx);
+					const initial = expr.slice(colonIdx + 1) || "undefined";
+					binds.push({
+						name,
+						initialValue: initial
+					});
+				}
+			} else {
+				const raw = String(attrValue ?? "");
+				const colonIdx = raw.indexOf(":");
+				if (colonIdx === -1) binds.push({
+					name: raw,
+					initialValue: "undefined"
+				});
+				else {
+					const name = raw.slice(0, colonIdx);
+					const initial = raw.slice(colonIdx + 1) || "undefined";
+					binds.push({
+						name,
+						initialValue: initial
+					});
+				}
+			}
+		}
+	}
+	if (Array.isArray(node.children)) for (const child of node.children) binds.push(...collectBinds(child, owningPlayground));
+	return binds;
+}
+function applyBindings(node, binds, bindings) {
+	const bindNameSet = new Set(binds.map((b) => b.name));
+	if (Array.isArray(node.attributes)) {
+		const attrs = node.attributes;
+		for (let i = attrs.length - 1; i >= 0; i--) {
+			const attr = attrs[i];
+			if (attr.type === "mdxJsxAttribute" && attr.name === "bind") {
+				const parsed = parseBindValue(attr);
+				if (parsed && bindNameSet.has(parsed.name)) {
+					const elName = String(node.name || "").toLowerCase();
+					const typeAttr = attrs.find((a) => a.type === "mdxJsxAttribute" && a.name === "type");
+					const replacement = bindingAttrs(elName, typeAttr ? String(typeAttr.value ?? "text") : "", parsed.name, bindings);
+					attrs.splice(i, 1, ...replacement);
+				} else attrs.splice(i, 1);
+			}
+		}
+	}
+	if (Array.isArray(node.children)) for (const child of node.children) applyBindings(child, binds, bindings);
+}
+function parseBindValue(attr) {
+	const raw = parseAttrValue(attr);
+	if (!raw) return null;
+	const colonIdx = raw.indexOf(":");
+	if (colonIdx === -1) return {
+		name: raw,
+		initialValue: "undefined"
+	};
+	return {
+		name: raw.slice(0, colonIdx),
+		initialValue: raw.slice(colonIdx + 1) || "undefined"
+	};
+}
+function parseAttrValue(attr) {
+	const v = attr.value;
+	if (typeof v === "object" && v !== null && v.type === "mdxJsxAttributeValueExpression") return String(v.value ?? "");
+	if (typeof v === "string") return v;
+	if (v == null) return "";
+	return null;
+}
+function bindingAttrs(elName, inputType, name, bindings) {
+	const meta = bindings[inputType ? `${elName}:${inputType}` : elName] ?? bindings[elName];
+	if (!meta) return [];
+	const setter = `set${capitalize(name)}`;
+	const valueExpr = meta.inject ? meta.inject.replace(/\bv\b/g, name) : name;
+	return [exprAttr(meta.valueProp, valueExpr), exprAttr(meta.changeProp, `(e) => ${setter}(${meta.extract})`)];
+}
+function exprAttr(name, expr) {
+	return {
+		type: "mdxJsxAttribute",
+		name,
+		value: {
+			type: "mdxJsxAttributeValueExpression",
+			value: expr,
+			data: { estree: _parser.parse(expr, {
+				ecmaVersion: "latest",
+				sourceType: "module",
+				locations: true
+			}) }
+		}
+	};
+}
+function serializeNode(node) {
+	switch (node.type) {
+		case "text": return escapeJsxText(String(node.value ?? ""));
+		case "inlineCode": return `<code>${escapeJsxText(String(node.value ?? ""))}</code>`;
+		case "strong": return `<strong>${(node.children || []).map(serializeNode).join("")}</strong>`;
+		case "emphasis": return `<em>${(node.children || []).map(serializeNode).join("")}</em>`;
+		case "delete": return `<del>${(node.children || []).map(serializeNode).join("")}</del>`;
+		case "link": return `<a href="${node.url}">${(node.children || []).map(serializeNode).join("")}</a>`;
+		case "image": return `<img src="${node.url}" alt="${node.alt || ""}" />`;
+		case "break": return "<br />";
+		case "thematicBreak": return "<hr />";
+		case "mdxTextExpression":
+		case "mdxFlowExpression": return `{${node.value}}`;
+		case "mdxJsxTextElement":
+		case "mdxJsxFlowElement": return serializeJsxElement(node);
+		case "paragraph": return `<p>${(node.children || []).map(serializeNode).join("")}</p>`;
+		case "heading": return `<h${node.depth}>${(node.children || []).map(serializeNode).join("")}</h${node.depth}>`;
+		case "blockquote": return `<blockquote>${(node.children || []).map(serializeNode).join("")}</blockquote>`;
+		case "list": {
+			const tag = node.ordered ? "ol" : "ul";
+			return `<${tag}>${(node.children || []).map(serializeNode).join("")}</${tag}>`;
+		}
+		case "listItem": return `<li>${(node.children || []).map(serializeNode).join("")}</li>`;
+		case "code": return `<pre><code>${escapeJsxText(String(node.value ?? ""))}</code></pre>`;
+		default:
+			if (Array.isArray(node.children)) return node.children.map(serializeNode).join("");
+			return "";
+	}
+}
+function serializeJsxElement(node) {
+	const attrs = (node.attributes || []).map(serializeAttribute).filter(Boolean).join(" ");
+	const openTag = `<${node.name}${attrs ? " " + attrs : ""}>`;
+	const body = (node.children || []).map(serializeNode).join("");
+	const closeTag = `</${node.name}>`;
+	return openTag + body + closeTag;
+}
+function serializeAttribute(attr) {
+	if (attr.type === "mdxJsxExpressionAttribute") return `{...${attr.value}}`;
+	if (attr.type === "mdxJsxAttribute") {
+		if (typeof attr.value === "object" && attr.value !== null && attr.value.type === "mdxJsxAttributeValueExpression") return `${attr.name}={${attr.value.value}}`;
+		const strVal = attr.value == null ? "" : String(attr.value);
+		return `${attr.name}=${JSON.stringify(strVal)}`;
+	}
+	return "";
+}
+function escapeJsxText(text) {
+	return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\{/g, "&#123;").replace(/\}/g, "&#125;");
+}
+function capitalize(s) {
+	return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function indent(text) {
+	return text.split("\n").map((line) => "  " + line).join("\n");
+}
+async function generateMdx(filepath, options = {}) {
+	const { content, bindings, ...mdxOptions } = options;
+	const absolutePath = resolve(filepath);
+	const result = await compile({
+		value: content ?? await readFile(absolutePath, "utf-8"),
+		path: absolutePath
+	}, {
+		development: false,
+		...mdxOptions,
+		remarkPlugins: [
+			[remarkStateBind, { bindings }],
+			remarkGfm,
+			...mdxOptions.remarkPlugins ?? []
+		],
+		rehypePlugins: [
+			rehypePrettyCode,
+			rehypeAutolinkHeadings,
+			...mdxOptions.rehypePlugins ?? []
+		]
+	});
+	return String(result.value);
+}
+//#endregion
+//#region ../registry-metadata/dist/index.mjs
+/**
+* shadcn/ui component bindings for stateful two-way binding.
+*
+* Each key is the shadcn registry component name (lowercase), matching the
+* name used in `npx shadcn add <name>`.
+*
+* Elements with a `type` attribute are looked up as `name:type` first,
+* falling back to `name`. This mirrors the HTML binding lookup.
+*/
+const shadcnBindings = {
+	input: {
+		valueProp: "value",
+		changeProp: "onChange",
+		extract: "e.target.value"
+	},
+	"input:checkbox": {
+		valueProp: "checked",
+		changeProp: "onChange",
+		extract: "e.target.checked"
+	},
+	"input:number": {
+		valueProp: "value",
+		changeProp: "onChange",
+		extract: "e.target.valueAsNumber"
+	},
+	textarea: {
+		valueProp: "value",
+		changeProp: "onChange",
+		extract: "e.target.value"
+	},
+	"native-select": {
+		valueProp: "value",
+		changeProp: "onChange",
+		extract: "e.target.value"
+	},
+	checkbox: {
+		valueProp: "checked",
+		changeProp: "onCheckedChange",
+		extract: "e"
+	},
+	switch: {
+		valueProp: "checked",
+		changeProp: "onCheckedChange",
+		extract: "e"
+	},
+	toggle: {
+		valueProp: "pressed",
+		changeProp: "onPressedChange",
+		extract: "e"
+	},
+	slider: {
+		valueProp: "value",
+		changeProp: "onValueChange",
+		extract: "e[0]",
+		inject: "[v]"
+	},
+	select: {
+		valueProp: "value",
+		changeProp: "onValueChange",
+		extract: "e"
+	},
+	"radio-group": {
+		valueProp: "value",
+		changeProp: "onValueChange",
+		extract: "e"
+	},
+	tabs: {
+		valueProp: "value",
+		changeProp: "onValueChange",
+		extract: "e"
+	},
+	accordion: {
+		valueProp: "value",
+		changeProp: "onValueChange",
+		extract: "e"
+	},
+	dialog: {
+		valueProp: "open",
+		changeProp: "onOpenChange",
+		extract: "e"
+	},
+	"alert-dialog": {
+		valueProp: "open",
+		changeProp: "onOpenChange",
+		extract: "e"
+	},
+	sheet: {
+		valueProp: "open",
+		changeProp: "onOpenChange",
+		extract: "e"
+	},
+	drawer: {
+		valueProp: "open",
+		changeProp: "onOpenChange",
+		extract: "e"
+	},
+	popover: {
+		valueProp: "open",
+		changeProp: "onOpenChange",
+		extract: "e"
+	},
+	"hover-card": {
+		valueProp: "open",
+		changeProp: "onOpenChange",
+		extract: "e"
+	},
+	tooltip: {
+		valueProp: "open",
+		changeProp: "onOpenChange",
+		extract: "e"
+	},
+	"dropdown-menu": {
+		valueProp: "open",
+		changeProp: "onOpenChange",
+		extract: "e"
+	},
+	"context-menu": {
+		valueProp: "open",
+		changeProp: "onOpenChange",
+		extract: "e"
+	},
+	collapsible: {
+		valueProp: "open",
+		changeProp: "onOpenChange",
+		extract: "e"
+	}
+};
+//#endregion
+//#region ../export/dist/index.mjs
+const pkgDir = dirname(fileURLToPath(import.meta.url));
+async function exportPlan(planName, options = {}) {
+	const cwd = options.cwd ?? process.cwd();
+	const plannarFolder = options.plannarFolder ?? ".plannar";
+	const exportsFolder = options.exportsFolder ?? `${plannarFolder}/exports`;
+	const compiled = await generateMdx(join(cwd, plannarFolder, "plans", `${planName}.mdx`), { bindings: {
+		...shadcnBindings,
+		...normalizeMeta(options.meta)
+	} });
+	const tmpDir = mkdtempSync(join(tmpdir(), "plannar-export-"));
+	try {
+		const html = await buildExportHtml(compiled, tmpDir, cwd, plannarFolder, options);
+		const outDir = resolve(cwd, exportsFolder);
+		mkdirSync(outDir, { recursive: true });
+		const outPath = join(outDir, `${planName}.html`);
+		writeFileSync(outPath, html, "utf-8");
+		return outPath;
+	} finally {
+		rmSync(tmpDir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+function normalizeMeta(meta) {
+	if (!meta || typeof meta !== "object" || Array.isArray(meta)) return {};
+	return meta;
+}
+function deepMerge(target, source) {
+	const result = { ...target };
+	for (const key of Object.keys(source)) {
+		const sv = source[key];
+		const tv = result[key];
+		if (sv && typeof sv === "object" && !Array.isArray(sv) && tv && typeof tv === "object" && !Array.isArray(tv)) result[key] = deepMerge(tv, sv);
+		else result[key] = sv;
+	}
+	return result;
+}
+function resolveExistingCssImport(cwd, tmpDir, cssPath) {
+	if (!cssPath) return null;
+	const cssAbs = resolve(cwd, cssPath);
+	if (!existsSync(cssAbs)) return null;
+	const destName = `plannar-${basename(cssAbs)}`;
+	copyFileSync(cssAbs, join(tmpDir, destName));
+	return `./${destName}`;
+}
+function injectBrowserProcessShim(html) {
+	if (!/(?<!window\.)process\.env\b/.test(html)) return html;
+	const shim = `<script>window.process ??= {}; window.process.env ??= {}; window.process.env.NODE_ENV ??= "production";<\/script>`;
+	return html.includes("</head>") ? html.replace("</head>", `${shim}</head>`) : `${shim}${html}`;
+}
+async function buildExportHtml(compiled, tmpDir, cwd, plannarFolder, options) {
+	const plannarDir = join(cwd, plannarFolder);
+	const sourcePath = relative(tmpDir, plannarDir).replaceAll("\\", "/");
+	const nodeModulesSource = findNearestNodeModules(pkgDir) ?? findNearestNodeModules(cwd) ?? findNearestNodeModules(plannarDir) ?? findNearestNodeModules(tmpDir);
+	if (nodeModulesSource) symlinkSync(nodeModulesSource, join(tmpDir, "node_modules"), "dir");
+	const planModule = compiled.replace(/export\s+default\s+function\s+MDXContent/g, "function Plan").replace(/export\s+{\s*MDXContent\s+as\s+default\s*}/g, "");
+	writeFileSync(join(tmpDir, "plan-content.tsx"), `${planModule}\nexport { Plan };\n`, "utf-8");
+	writeFileSync(join(tmpDir, "plan.tsx"), `import { Plan } from "./plan-content";
+import { createRoot } from "react-dom/client";
+import "./index.css";
+
+const root = document.getElementById("root");
+if (root) {
+  createRoot(root).render(
+    <div className="mdx-content">
+      <Plan />
+    </div>
+  );
+}`, "utf-8");
+	let cssImports = "";
+	const globalCssRel = resolveExistingCssImport(cwd, tmpDir, options.globalCss);
+	if (globalCssRel) cssImports += `@import "${globalCssRel}";\n`;
+	const cssFilePathRel = resolveExistingCssImport(cwd, tmpDir, options.cssFilePath);
+	if (cssFilePathRel) cssImports += `@import "${cssFilePathRel}";\n`;
+	const coreStylesDir = join(pkgDir, "core-styles");
+	const mdxCssPath = join(coreStylesDir, "mdx.css").replaceAll("\\", "/");
+	const themeCssPath = join(coreStylesDir, "theme.css").replaceAll("\\", "/");
+	writeFileSync(join(tmpDir, "index.css"), `@import "tailwindcss";
+@import "tw-animate-css";
+@import "${mdxCssPath}";
+@import "${themeCssPath}";
+${cssImports}@source "${sourcePath}";
+
+@custom-variant dark (&:is(.dark *));
+
+@theme inline {
+  --color-background: var(--background);
+  --color-foreground: var(--foreground);
+  --color-card: var(--card);
+  --color-card-foreground: var(--card-foreground);
+  --color-popover: var(--popover);
+  --color-popover-foreground: var(--popover-foreground);
+  --color-primary: var(--primary);
+  --color-primary-foreground: var(--primary-foreground);
+  --color-secondary: var(--secondary);
+  --color-secondary-foreground: var(--secondary-foreground);
+  --color-muted: var(--muted);
+  --color-muted-foreground: var(--muted-foreground);
+  --color-accent: var(--accent);
+  --color-accent-foreground: var(--accent-foreground);
+  --color-destructive: var(--destructive);
+  --color-destructive-foreground: var(--destructive-foreground);
+  --color-border: var(--border);
+  --color-input: var(--input);
+  --color-ring: var(--ring);
+  --color-chart-1: var(--chart-1);
+  --color-chart-2: var(--chart-2);
+  --color-chart-3: var(--chart-3);
+  --color-chart-4: var(--chart-4);
+  --color-chart-5: var(--chart-5);
+  --radius-sm: calc(var(--radius) - 4px);
+  --radius-md: calc(var(--radius) - 2px);
+  --radius-lg: var(--radius);
+  --radius-xl: calc(var(--radius) + 4px);
+}`, "utf-8");
+	const outDir = join(tmpDir, "dist");
+	const baseBuildConfig = {
+		root: tmpDir,
+		define: { "process.env.NODE_ENV": JSON.stringify("production") },
+		build: {
+			outDir,
+			minify: false,
+			cssCodeSplit: false,
+			lib: {
+				entry: join(tmpDir, "plan.tsx"),
+				name: "PlannarExport",
+				formats: ["es"],
+				fileName: () => "plan.js",
+				cssFileName: "plan"
+			}
+		},
+		plugins: [
+			tailwindcss(),
+			react(),
+			inlineAssetsPlugin(outDir)
+		],
+		resolve: { alias: { "@": plannarDir } },
+		logLevel: "warn"
+	};
+	await build(options.viteConfig ? deepMerge(baseBuildConfig, options.viteConfig) : baseBuildConfig);
+	return injectBrowserProcessShim(readFileSync(join(outDir, "index.html"), "utf-8"));
+}
+function findNearestNodeModules(startDir) {
+	let dir = resolve(startDir);
+	for (let i = 0; i < 10; i++) {
+		const candidate = join(dir, "node_modules");
+		if (existsSync(candidate)) return candidate;
+		const parent = resolve(dir, "..");
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return null;
+}
+function inlineAssetsPlugin(outDir) {
+	let css = "";
+	let js = "";
+	return {
+		name: "plannar-inline-assets",
+		enforce: "post",
+		apply: "build",
+		generateBundle(_opts, bundle) {
+			for (const [, chunk] of Object.entries(bundle)) {
+				const ch = chunk;
+				if (ch.type === "asset" && typeof ch.source === "string") {
+					if (ch.fileName.endsWith(".css")) css += ch.source;
+				}
+				if (ch.type === "chunk") js += chunk.code;
+			}
+		},
+		closeBundle() {
+			try {
+				const safeJs = js.replace(/<\//g, "<\\/");
+				const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<script>
+(function(){var e=localStorage.getItem("plannar-theme");if(e==="dark"||(!e&&window.matchMedia("(prefers-color-scheme: dark)").matches)){document.documentElement.classList.add("dark")}})();
+<\/script>
+<style>
+${css}
+</style>
+</head>
+<body>
+<div id="root"></div>
+<script>
+${safeJs}
+<\/script>
+</body>
+</html>`;
+				writeFileSync(join(outDir, "index.html"), html, "utf-8");
+				const entries = readdirSync(outDir);
+				for (const entry of entries) if (entry !== "index.html") rmSync(join(outDir, entry), { force: true });
+			} catch {}
+		}
+	};
+}
+//#endregion
+//#region src/commands/export.ts
+var export_default = defineCommand({
+	meta: {
+		name: "export",
+		description: "Export a plan to a self-contained HTML file"
+	},
+	args: { plan: {
+		type: "positional",
+		description: "Plan name (without .mdx extension)",
+		required: true
+	} },
+	async run({ args }) {
+		const cwd = process.cwd();
+		const config = await resolveConfig(cwd);
+		const outPath = await exportPlan(args.plan, {
+			cwd,
+			plannarFolder: config.plannarFolder,
+			exportsFolder: config.exportsFolder,
+			globalCss: config.globalCss,
+			cssFilePath: config.cssFilePath,
+			meta: config.meta,
+			viteConfig: config.viteConfig?.exports
+		});
+		console.log(`✓ Exported to ${outPath}`);
+	}
+});
+//#endregion
+export { export_default as default };