@open-aippt/core 1.13.2

package/dist/config-CjzqjrEA.js

@@ -0,0 +1,4280 @@
+import { defaultDesign } from "./design-cpzS8aud.js";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { randomUUID } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import tailwindcss from "@tailwindcss/vite";
+import react from "@vitejs/plugin-react";
+import * as t$4 from "@babel/types";
+import * as t$3 from "@babel/types";
+import * as t$2 from "@babel/types";
+import * as t$1 from "@babel/types";
+import * as t from "@babel/types";
+import { isJSXElement, isJSXFragment } from "@babel/types";
+import { parse } from "@babel/parser";
+import { spawn } from "node:child_process";
+import fg from "fast-glob";
+import { loadConfigFromFile, normalizePath } from "vite";
+
+//#region src/editing/babel-walk.ts
+const SKIP_KEYS = new Set([
+	"loc",
+	"start",
+	"end",
+	"type",
+	"extra",
+	"leadingComments",
+	"trailingComments",
+	"innerComments"
+]);
+function walk(ast, visit, accept) {
+	let stopped = false;
+	const recurse = (node) => {
+		if (stopped || !node || typeof node !== "object") return;
+		if (Array.isArray(node)) {
+			for (const c of node) recurse(c);
+			return;
+		}
+		const n = node;
+		if (typeof n.type !== "string") return;
+		if (accept(n) && visit(n) === "stop") {
+			stopped = true;
+			return;
+		}
+		for (const key of Object.keys(n)) {
+			if (SKIP_KEYS.has(key)) continue;
+			recurse(n[key]);
+		}
+	};
+	recurse(ast);
+}
+const isJsx = (n) => isJSXElement(n) || isJSXFragment(n);
+const acceptAll = () => true;
+function walkJsx(ast, visit) {
+	walk(ast, visit, isJsx);
+}
+function walkAll(ast, visit) {
+	walk(ast, visit, acceptAll);
+}
+function parseSource$2(source) {
+	try {
+		const ast = parse(source, {
+			sourceType: "module",
+			plugins: ["typescript", "jsx"],
+			errorRecovery: true
+		});
+		return ast.errors && ast.errors.length > 0 ? null : ast;
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+//#region src/editing/edit-ops.ts
+function jsString$1(s) {
+	return `'${s.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n")}'`;
+}
+function spliceRange(node, text) {
+	return {
+		from: node.start ?? 0,
+		to: node.end ?? 0,
+		text
+	};
+}
+function formatJsxAttrValue(value) {
+	if (/^[^"\\<>&{}\n\r]*$/.test(value)) return `"${value}"`;
+	return `{${jsString$1(value)}}`;
+}
+function jsxAttrName(attr) {
+	return t$4.isJSXIdentifier(attr.name) ? attr.name.name : null;
+}
+function findJsxAttr(opening, name) {
+	for (const attr of opening.attributes) if (t$4.isJSXAttribute(attr) && jsxAttrName(attr) === name) return attr;
+	return null;
+}
+function readJsxStringAttr(opening, name) {
+	const attr = findJsxAttr(opening, name);
+	const v = attr?.value;
+	if (!v) return null;
+	if (t$4.isStringLiteral(v)) return v.value;
+	if (t$4.isJSXExpressionContainer(v) && t$4.isStringLiteral(v.expression)) return v.expression.value;
+	return null;
+}
+function readJsxNumberAttr(opening, name) {
+	const attr = findJsxAttr(opening, name);
+	const v = attr?.value;
+	if (!v || !t$4.isJSXExpressionContainer(v)) return null;
+	if (!t$4.isNumericLiteral(v.expression)) return null;
+	const n = v.expression.value;
+	return Number.isFinite(n) ? n : null;
+}
+function findImports$1(ast) {
+	const out = [];
+	for (const node of ast.program.body) {
+		if (!t$4.isImportDeclaration(node)) continue;
+		let def = null;
+		for (const spec of node.specifiers) if (t$4.isImportDefaultSpecifier(spec)) {
+			def = spec.local.name;
+			break;
+		}
+		out.push({
+			node,
+			source: node.source.value,
+			defaultIdent: def
+		});
+	}
+	return out;
+}
+function collectTopLevelIdentifiers(ast) {
+	const names = new Set();
+	for (const imp of findImports$1(ast)) {
+		if (imp.defaultIdent) names.add(imp.defaultIdent);
+		for (const spec of imp.node.specifiers) if (!t$4.isImportDefaultSpecifier(spec)) names.add(spec.local.name);
+	}
+	return names;
+}
+function safeAssetIdentifier(filename, taken) {
+	const stem = filename.replace(/\.[^.]+$/, "");
+	let camel = "";
+	let upper = false;
+	for (const ch of stem) if (/[A-Za-z0-9]/.test(ch)) {
+		camel += upper ? ch.toUpperCase() : ch;
+		upper = false;
+	} else upper = camel.length > 0;
+	let base = camel;
+	if (!base || !/^[A-Za-z_$]/.test(base)) base = `asset${base.charAt(0).toUpperCase()}${base.slice(1)}` || "asset";
+	base = base.charAt(0).toLowerCase() + base.slice(1);
+	let candidate = base;
+	let i = 2;
+	while (taken.has(candidate)) {
+		candidate = `${base}${i}`;
+		i += 1;
+	}
+	return candidate;
+}
+function findJsxAncestors$1(ast, line, column) {
+	const hits = [];
+	walkJsx(ast, (n) => {
+		if (!n.loc || !t$4.isJSXElement(n) && !t$4.isJSXFragment(n)) return;
+		const s = n.loc.start;
+		const e = n.loc.end;
+		const afterStart = line > s.line || line === s.line && column >= s.column;
+		const beforeEnd = line < e.line || line === e.line && column < e.column;
+		if (afterStart && beforeEnd) hits.push({
+			node: n,
+			size: (n.end ?? 0) - (n.start ?? 0)
+		});
+	});
+	hits.sort((a, b) => a.size - b.size);
+	return hits.map((h) => h.node);
+}
+function findJsxByStart(ast, line, column) {
+	let hit = null;
+	walkJsx(ast, (n) => {
+		if (!t$4.isJSXElement(n) || !n.loc) return;
+		const s = n.loc.start;
+		if (s.line === line && s.column === column) {
+			hit = n;
+			return "stop";
+		}
+	});
+	return hit;
+}
+function findInnermostJsxElement(ast, line, column) {
+	const exact = findJsxByStart(ast, line, column);
+	if (exact) return exact;
+	for (const n of findJsxAncestors$1(ast, line, column)) if (t$4.isJSXElement(n)) return n;
+	return null;
+}
+function findUniqueElementByText(ast, prevText) {
+	const hits = [];
+	walkJsx(ast, (n) => {
+		if (!t$4.isJSXElement(n)) return;
+		const parts = [];
+		collectTextRangeParts(n, parts);
+		if (textRangeContent(parts) !== prevText) return;
+		hits.push({
+			node: n,
+			size: (n.end ?? 0) - (n.start ?? 0)
+		});
+	});
+	if (hits.length === 0) return null;
+	hits.sort((a, b) => a.size - b.size);
+	const best = hits[0];
+	const bestStart = best.node.start ?? 0;
+	const bestEnd = best.node.end ?? 0;
+	const hasSiblingMatch = hits.slice(1).some(({ node }) => (node.start ?? 0) > bestStart || (node.end ?? 0) < bestEnd);
+	return hasSiblingMatch ? null : best.node;
+}
+function fallbackTextForOps(ops) {
+	for (const op of ops) if ((op.kind === "set-style" || op.kind === "set-text" || op.kind === "set-text-range-style") && op.prevText !== void 0) return op.prevText;
+	return null;
+}
+function hasOnlyTextOps(ops) {
+	return ops.length > 0 && ops.every((op) => op.kind === "set-text");
+}
+function elementTextMatches(element, prevText) {
+	const parts = [];
+	collectTextRangeParts(element, parts);
+	return textRangeContent(parts) === prevText;
+}
+function elementHasTextCandidate(ast, element, prevText) {
+	const norm = prevText.trim();
+	return collectElementTextCandidates(ast, element).some((candidate) => candidate.current === norm);
+}
+function findElementForEdit(ast, line, column, ops) {
+	const element = findInnermostJsxElement(ast, line, column);
+	const prevText = fallbackTextForOps(ops);
+	if (prevText === null) return element;
+	if (hasOnlyTextOps(ops) && element && (elementTextMatches(element, prevText) || elementHasTextCandidate(ast, element, prevText))) return element;
+	const textMatch = findUniqueElementByText(ast, prevText);
+	if (element && elementTextMatches(element, prevText)) return textMatch ?? element;
+	return textMatch ?? element;
+}
+function buildStyleSplice(source, element, ops) {
+	const opening = element.openingElement;
+	const existing = findJsxAttr(opening, "style");
+	const entries = [];
+	let hasRawEntry = false;
+	if (existing) {
+		const value = existing.value;
+		if (!value || !t$4.isJSXExpressionContainer(value)) return { error: "style attribute has unsupported form" };
+		const expr = value.expression;
+		if (!t$4.isObjectExpression(expr)) {
+			if (typeof expr.start !== "number" || typeof expr.end !== "number") return { error: "style value missing source range" };
+			entries.push({
+				kind: "raw",
+				text: `...(${source.slice(expr.start, expr.end)})`
+			});
+			hasRawEntry = true;
+		} else for (const prop of expr.properties) if (t$4.isObjectProperty(prop) && !prop.computed) {
+			let keyName = null;
+			if (t$4.isIdentifier(prop.key)) keyName = prop.key.name;
+			else if (t$4.isStringLiteral(prop.key)) keyName = prop.key.value;
+			if (!keyName) return { error: "style has unsupported key" };
+			const v = prop.value;
+			if (typeof prop.key.start !== "number" || typeof prop.key.end !== "number" || typeof v.start !== "number" || typeof v.end !== "number") return { error: "style value missing source range" };
+			entries.push({
+				kind: "prop",
+				key: keyName,
+				keyText: source.slice(prop.key.start, prop.key.end),
+				valueText: source.slice(v.start, v.end)
+			});
+		} else {
+			if (typeof prop.start !== "number" || typeof prop.end !== "number") return { error: "style value missing source range" };
+			entries.push({
+				kind: "raw",
+				text: source.slice(prop.start, prop.end)
+			});
+			hasRawEntry = true;
+		}
+	}
+	for (const op of ops) {
+		const matching = entries.filter((entry) => entry.kind === "prop" && entry.key === op.key);
+		if (op.value === null) {
+			for (const entry of matching) entries.splice(entries.indexOf(entry), 1);
+			if (hasRawEntry) entries.push({
+				kind: "prop",
+				key: op.key,
+				keyText: op.key,
+				valueText: "undefined"
+			});
+		} else if (matching.length > 0) matching[matching.length - 1].valueText = jsString$1(op.value);
+		else entries.push({
+			kind: "prop",
+			key: op.key,
+			keyText: op.key,
+			valueText: jsString$1(op.value)
+		});
+	}
+	if (entries.length === 0) {
+		if (!existing) return null;
+		let from = existing.start ?? 0;
+		if (from > 0 && source[from - 1] === " ") from -= 1;
+		return {
+			from,
+			to: existing.end ?? 0,
+			text: ""
+		};
+	}
+	const propsText = entries.map((entry) => entry.kind === "prop" ? `${entry.keyText}: ${entry.valueText}` : entry.text).join(", ");
+	const newAttr = `style={{ ${propsText} }}`;
+	if (existing) {
+		const lastAttr$1 = opening.attributes[opening.attributes.length - 1];
+		if (lastAttr$1 && lastAttr$1 !== existing && typeof lastAttr$1.end === "number") {
+			const attrsAfterStyle = source.slice(existing.end ?? 0, lastAttr$1.end).replace(/^[ \t]+/, "");
+			return {
+				from: existing.start ?? 0,
+				to: lastAttr$1.end,
+				text: `${attrsAfterStyle} ${newAttr}`
+			};
+		}
+		return {
+			from: existing.start ?? 0,
+			to: existing.end ?? 0,
+			text: newAttr
+		};
+	}
+	const lastAttr = opening.attributes[opening.attributes.length - 1];
+	const at = lastAttr?.end ?? opening.name.end ?? 0;
+	return {
+		from: at,
+		to: at,
+		text: ` ${newAttr}`
+	};
+}
+function formatJsxText(value) {
+	if (/[{}<>]/.test(value) || /^\s|\s$/.test(value) || value === "") return `{${jsString$1(value)}}`;
+	return value;
+}
+function meaningfulChildren(parent) {
+	return parent.children.filter((c) => {
+		if (t$4.isJSXText(c)) return c.value.trim() !== "";
+		return true;
+	});
+}
+function isOnlyMeaningfulChild(parent, child) {
+	const meaningful = meaningfulChildren(parent);
+	return meaningful.length === 1 && meaningful[0] === child;
+}
+function wrapSplice(parent, text) {
+	const first = parent.children[0];
+	const last = parent.children[parent.children.length - 1];
+	return {
+		from: first.start ?? 0,
+		to: last.end ?? 0,
+		text
+	};
+}
+function splitLinesWithOffsets(value) {
+	const lines = [];
+	let start = 0;
+	for (let i = 0; i < value.length; i++) {
+		const ch = value[i];
+		if (ch !== "\n" && ch !== "\r") continue;
+		lines.push({
+			text: value.slice(start, i),
+			start
+		});
+		if (ch === "\r" && value[i + 1] === "\n") i += 1;
+		start = i + 1;
+	}
+	lines.push({
+		text: value.slice(start),
+		start
+	});
+	return lines;
+}
+function cleanJsxTextWithOffsets(value) {
+	const lines = splitLinesWithOffsets(value);
+	let lastNonEmptyLine = 0;
+	for (let i = 0; i < lines.length; i++) if (lines[i].text.trim()) lastNonEmptyLine = i;
+	let text = "";
+	const offsets = [];
+	for (let i = 0; i < lines.length; i++) {
+		const chars = Array.from(lines[i].text, (ch, j) => ({
+			ch: ch === "	" ? " " : ch,
+			offset: lines[i].start + j
+		}));
+		let from = 0;
+		let to = chars.length;
+		if (i !== 0) while (from < to && chars[from].ch === " ") from += 1;
+		if (i !== lines.length - 1) while (to > from && chars[to - 1].ch === " ") to -= 1;
+		if (from >= to) continue;
+		for (const item of chars.slice(from, to)) {
+			text += item.ch;
+			offsets.push(item.offset);
+		}
+		if (i !== lastNonEmptyLine) {
+			text += " ";
+			offsets.push(null);
+		}
+	}
+	return {
+		text,
+		offsets
+	};
+}
+function isJsxBrElement(node) {
+	if (!t$4.isJSXElement(node)) return false;
+	const name = node.openingElement.name;
+	return t$4.isJSXIdentifier(name) && name.name.toLowerCase() === "br";
+}
+function collectTextCandidates(element, out) {
+	const meaningful = meaningfulChildren(element);
+	const isSole = meaningful.length === 1;
+	for (const child of meaningful) if (t$4.isJSXText(child)) {
+		const current = child.value.trim();
+		if (!current) continue;
+		out.push({
+			current,
+			splice: (v) => isSole ? wrapSplice(element, formatJsxText(v)) : {
+				from: child.start ?? 0,
+				to: child.end ?? 0,
+				text: formatJsxText(v)
+			}
+		});
+	} else if (t$4.isJSXExpressionContainer(child)) {
+		const expr = child.expression;
+		if (t$4.isStringLiteral(expr) || t$4.isNumericLiteral(expr)) {
+			const current = String(expr.value);
+			out.push({
+				current,
+				splice: (v) => isSole ? wrapSplice(element, `{${jsString$1(v)}}`) : {
+					from: child.start ?? 0,
+					to: child.end ?? 0,
+					text: `{${jsString$1(v)}}`
+				}
+			});
+		}
+	} else if (t$4.isJSXElement(child) || t$4.isJSXFragment(child)) collectTextCandidates(child, out);
+}
+function collectTextRangeParts(element, out) {
+	const parts = [];
+	collectTextRangePartsRaw(element, parts);
+	out.push(...normalizeTextRangeParts(parts));
+}
+function collectTextRangePartsRaw(element, out) {
+	for (const child of element.children) if (t$4.isJSXText(child)) {
+		const { text: current, offsets } = cleanJsxTextWithOffsets(child.value);
+		if (current) out.push({
+			node: child,
+			parent: element,
+			current,
+			raw: child.value,
+			text: formatJsxText,
+			offsets
+		});
+	} else if (t$4.isJSXExpressionContainer(child)) {
+		const expression = child.expression;
+		if (t$4.isStringLiteral(expression) || t$4.isNumericLiteral(expression)) {
+			const raw = String(expression.value);
+			const current = raw;
+			if (current) out.push({
+				node: child,
+				parent: element,
+				current,
+				raw,
+				text: (value) => `{${jsString$1(value)}}`,
+				offsets: Array.from({ length: current.length }, (_, i) => i)
+			});
+		}
+	} else if (isJsxBrElement(child)) out.push({
+		node: child,
+		current: "\n"
+	});
+	else if (t$4.isJSXElement(child) || t$4.isJSXFragment(child)) collectTextRangePartsRaw(child, out);
+}
+function normalizeTextRangeParts(parts) {
+	return parts.flatMap((part, index) => {
+		if (!("raw" in part)) return [part];
+		let start = 0;
+		let end = part.current.length;
+		if (parts[index - 1]?.current === "\n") while (start < end && /\s/.test(part.current[start] ?? "")) start++;
+		if (parts[index + 1]?.current === "\n") while (end > start && /\s/.test(part.current[end - 1] ?? "")) end--;
+		if (start === 0 && end === part.current.length) return [part];
+		if (start >= end) return [];
+		return [{
+			...part,
+			current: part.current.slice(start, end),
+			offsets: part.offsets.slice(start, end)
+		}];
+	});
+}
+function resetValueForRangeStyle(key) {
+	if (key === "fontWeight") return "400";
+	if (key === "fontStyle") return "normal";
+	return null;
+}
+function styleSpanForText(text, key, value) {
+	const styleValue = value ?? resetValueForRangeStyle(key);
+	if (styleValue === null) return formatJsxText(text);
+	return `<span style={{ ${key}: ${jsString$1(styleValue)} }}>${formatJsxText(text)}</span>`;
+}
+function textRangeContent(parts) {
+	return parts.map((part) => part.current).join("");
+}
+function compactText(value) {
+	return value.replace(/\s+/g, "");
+}
+function textMatchesExpected(current, expected) {
+	return current === expected || compactText(current) === compactText(expected);
+}
+function formatRichText(value, formatText = formatJsxText) {
+	return value.split("\n").map((part) => formatText(part)).join("<br />");
+}
+function formatOptionalText(value, formatText = formatJsxText) {
+	return value ? formatText(value) : "";
+}
+function textDiff(prevText, nextText) {
+	let start = 0;
+	while (start < prevText.length && start < nextText.length && prevText[start] === nextText[start]) start += 1;
+	let prevEnd = prevText.length;
+	let nextEnd = nextText.length;
+	while (prevEnd > start && nextEnd > start && prevText[prevEnd - 1] === nextText[nextEnd - 1]) {
+		prevEnd -= 1;
+		nextEnd -= 1;
+	}
+	return {
+		start,
+		end: prevEnd,
+		value: nextText.slice(start, nextEnd)
+	};
+}
+function textLeafSplice(part, value) {
+	const rawRange = textLeafRawRange(part, 0, part.current.length);
+	if (!rawRange) return spliceRange(part.node, part.text(value));
+	const { rawStart, rawEnd } = rawRange;
+	return {
+		from: part.node.start ?? 0,
+		to: part.node.end ?? 0,
+		text: `${part.raw.slice(0, rawStart)}${formatRichText(value, part.text)}${part.raw.slice(rawEnd)}`
+	};
+}
+function textLeafRawRange(part, start, end) {
+	if (start >= end) return null;
+	let first = null;
+	let last = null;
+	for (let i = start; i < end; i++) {
+		const offset = part.offsets[i];
+		if (offset === void 0) return null;
+		if (offset === null) continue;
+		first ??= offset;
+		last = offset;
+	}
+	if (first === null || last === null) return null;
+	return {
+		rawStart: first,
+		rawEnd: last + 1
+	};
+}
+function buildTextRangeReplaceSplices(parts, start, end, value) {
+	const splices = [];
+	let offset = 0;
+	let inserted = false;
+	for (const part of parts) {
+		const partStart = offset;
+		const partEnd = partStart + part.current.length;
+		offset = partEnd;
+		const overlaps = start < partEnd && end > partStart;
+		const insertsHere = start === end && !inserted && start >= partStart && start <= partEnd;
+		if (!overlaps && !insertsHere) continue;
+		if ("raw" in part) {
+			const localStart = Math.max(start, partStart) - partStart;
+			const localEnd = overlaps ? Math.min(end, partEnd) - partStart : localStart;
+			const nextText = `${part.current.slice(0, localStart)}${inserted ? "" : value}${part.current.slice(localEnd)}`;
+			splices.push(textLeafSplice(part, nextText));
+		} else if (overlaps) splices.push(spliceRange(part.node, inserted ? "" : formatRichText(value)));
+		else if (insertsHere) {
+			const at = start === partStart ? part.node.start ?? 0 : part.node.end ?? 0;
+			splices.push({
+				from: at,
+				to: at,
+				text: formatRichText(value)
+			});
+		}
+		inserted = true;
+	}
+	if (!inserted && start === end && start === offset) {
+		const last = parts[parts.length - 1];
+		if (!last) return { error: "element has no editable text" };
+		if ("raw" in last) splices.push(textLeafSplice(last, `${last.current}${value}`));
+		else splices.push({
+			from: last.node.end ?? 0,
+			to: last.node.end ?? 0,
+			text: formatRichText(value)
+		});
+	}
+	return splices;
+}
+function buildTextContentSplices(element, value, prevText) {
+	const parts = [];
+	collectTextRangeParts(element, parts);
+	const current = textRangeContent(parts);
+	if (!textMatchesExpected(current, prevText)) return { error: "no text candidate matches the current value" };
+	const diff = textDiff(current, value);
+	if (diff.start === diff.end && diff.value === "") return [];
+	return buildTextRangeReplaceSplices(parts, diff.start, diff.end, diff.value);
+}
+function buildTextRangeStyleSplices(ast, source, element, start, end, op, prevText) {
+	if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end <= start) return { error: "invalid text range" };
+	const parts = [];
+	collectTextRangeParts(element, parts);
+	const current = prevText ?? textRangeContent(parts);
+	if (!current) return { error: "element has no editable text" };
+	if (end > current.length) return { error: "text range is out of bounds" };
+	const renderedText = textRangeContent(parts);
+	if (prevText !== void 0 && renderedText !== prevText) {
+		if (elementTextCandidateMatches(ast, element, prevText)) {
+			const result = buildStyleSplice(source, element, [op]);
+			if (result && "error" in result) return result;
+			return result ? [result] : [];
+		}
+		return { error: "no text candidate matches the current value" };
+	}
+	const splices = [];
+	let leafStart = 0;
+	for (const leaf of parts) {
+		const leafEnd = leafStart + leaf.current.length;
+		if (!("raw" in leaf)) {
+			leafStart = leafEnd;
+			continue;
+		}
+		const selectedStart = Math.max(start, leafStart);
+		const selectedEnd = Math.min(end, leafEnd);
+		if (selectedStart >= selectedEnd) {
+			leafStart = leafEnd;
+			continue;
+		}
+		if (selectedStart === leafStart && selectedEnd === leafEnd && t$4.isJSXElement(leaf.parent) && leaf.parent !== element && isOnlyMeaningfulChild(leaf.parent, leaf.node)) {
+			const result = buildStyleSplice(source, leaf.parent, [op]);
+			if (result && "error" in result) return result;
+			if (result) splices.push(result);
+			leafStart = leafEnd;
+			continue;
+		}
+		const localStart = selectedStart - leafStart;
+		const localEnd = selectedEnd - leafStart;
+		const rawRange = textLeafRawRange(leaf, localStart, localEnd);
+		if (!rawRange) return { error: "text range source mismatch" };
+		const raw = leaf.raw;
+		const { rawStart, rawEnd } = rawRange;
+		const before = raw.slice(0, rawStart);
+		const selected = leaf.current.slice(localStart, localEnd);
+		const after = raw.slice(rawEnd);
+		const beforeText = t$4.isJSXText(leaf.node) ? before : formatOptionalText(before, leaf.text);
+		const afterText = t$4.isJSXText(leaf.node) ? after : formatOptionalText(after, leaf.text);
+		splices.push(spliceRange(leaf.node, `${beforeText}${styleSpanForText(selected, op.key, op.value)}${afterText}`));
+		leafStart = leafEnd;
+	}
+	return splices.length > 0 ? splices : null;
+}
+function propPassthroughName(element) {
+	const meaningful = meaningfulChildren(element);
+	if (meaningful.length !== 1) return null;
+	const child = meaningful[0];
+	if (!t$4.isJSXExpressionContainer(child)) return null;
+	return t$4.isIdentifier(child.expression) ? child.expression.name : null;
+}
+function findEnclosingComponent(ast, target) {
+	let best = null;
+	let bestSize = Number.POSITIVE_INFINITY;
+	const targetStart = target.start ?? 0;
+	const targetEnd = target.end ?? 0;
+	const consider = (name, fn) => {
+		if (!/^[A-Z]/.test(name)) return;
+		const fnStart = fn.start ?? 0;
+		const fnEnd = fn.end ?? 0;
+		if (fnStart > targetStart || fnEnd < targetEnd) return;
+		const size = fnEnd - fnStart;
+		if (size < bestSize) {
+			best = {
+				name,
+				fn
+			};
+			bestSize = size;
+		}
+	};
+	const visitDecl = (decl) => {
+		if (t$4.isFunctionDeclaration(decl) && decl.id) consider(decl.id.name, decl);
+		else if (t$4.isVariableDeclaration(decl)) for (const d of decl.declarations) {
+			if (!t$4.isVariableDeclarator(d) || !t$4.isIdentifier(d.id) || !d.init) continue;
+			if (t$4.isArrowFunctionExpression(d.init) || t$4.isFunctionExpression(d.init)) consider(d.id.name, d.init);
+		}
+	};
+	for (const decl of ast.program.body) {
+		visitDecl(decl);
+		if (t$4.isExportNamedDeclaration(decl) || t$4.isExportDefaultDeclaration(decl)) {
+			const inner = decl.declaration;
+			if (inner && (t$4.isStatement(inner) || t$4.isFunctionDeclaration(inner))) visitDecl(inner);
+		}
+	}
+	return best;
+}
+function componentDestructuresProp(fn, propName) {
+	if (fn.params.length === 0) return false;
+	let first = fn.params[0];
+	if (t$4.isAssignmentPattern(first)) first = first.left;
+	if (!t$4.isObjectPattern(first)) return false;
+	for (const prop of first.properties) {
+		if (!t$4.isObjectProperty(prop)) continue;
+		if (t$4.isIdentifier(prop.key) && prop.key.name === propName) return true;
+		if (t$4.isStringLiteral(prop.key) && prop.key.value === propName) return true;
+	}
+	return false;
+}
+function collectCallSiteCandidates(ast, componentName) {
+	const out = [];
+	walkJsx(ast, (n) => {
+		if (!t$4.isJSXElement(n)) return;
+		const elName = n.openingElement.name;
+		if (t$4.isJSXIdentifier(elName) && elName.name === componentName) collectTextCandidates(n, out);
+	});
+	return out;
+}
+function collectPropCallSiteCandidates(ast, componentName, propName) {
+	const out = [];
+	walkJsx(ast, (n) => {
+		if (!t$4.isJSXElement(n)) return;
+		const elName = n.openingElement.name;
+		if (!t$4.isJSXIdentifier(elName) || elName.name !== componentName) return;
+		const attr = findJsxAttr(n.openingElement, propName);
+		if (!attr?.value) return;
+		const v = attr.value;
+		if (t$4.isStringLiteral(v)) out.push({
+			current: v.value,
+			splice: (s) => spliceRange(v, formatJsxAttrValue(s))
+		});
+		else if (t$4.isJSXExpressionContainer(v)) {
+			const expr = v.expression;
+			if (t$4.isStringLiteral(expr) || t$4.isNumericLiteral(expr)) out.push({
+				current: String(expr.value),
+				splice: (s) => spliceRange(v, formatJsxAttrValue(s))
+			});
+		}
+	});
+	return out;
+}
+function findEnclosingMapCallback(ast, target) {
+	let best = null;
+	const targetStart = target.start ?? 0;
+	const targetEnd = target.end ?? 0;
+	walkAll(ast, (node) => {
+		if (!t$4.isCallExpression(node)) return;
+		const callee = node.callee;
+		if (!t$4.isMemberExpression(callee) || callee.computed) return;
+		if (!t$4.isIdentifier(callee.property)) return;
+		if (callee.property.name !== "map" && callee.property.name !== "flatMap") return;
+		const fn = node.arguments[0];
+		if (!fn || !t$4.isArrowFunctionExpression(fn) && !t$4.isFunctionExpression(fn)) return;
+		const fnStart = fn.start ?? 0;
+		const fnEnd = fn.end ?? 0;
+		if (fnStart > targetStart || fnEnd < targetEnd) return;
+		if (!t$4.isExpression(callee.object)) return;
+		const size = fnEnd - fnStart;
+		if (!best || size < best.size) best = {
+			fn,
+			arrayArg: callee.object,
+			size
+		};
+	});
+	if (!best) return null;
+	const found = best;
+	return {
+		fn: found.fn,
+		arrayArg: found.arrayArg
+	};
+}
+function resolveArrayLiteralElements(ast, expr) {
+	const dropHoles = (arr) => arr.elements.filter((e) => e != null);
+	if (t$4.isArrayExpression(expr)) return dropHoles(expr);
+	if (!t$4.isIdentifier(expr)) return null;
+	const name = expr.name;
+	const useStart = expr.start ?? 0;
+	let init = null;
+	walkAll(ast, (node) => {
+		if (!t$4.isVariableDeclarator(node)) return;
+		if (!t$4.isIdentifier(node.id) || node.id.name !== name) return;
+		if (!node.init || !t$4.isArrayExpression(node.init)) return;
+		if ((node.init.start ?? 0) > useStart) return;
+		init = node.init;
+	});
+	return init ? dropHoles(init) : null;
+}
+function findObjectProperty(obj, name) {
+	if (!t$4.isObjectExpression(obj)) return null;
+	for (const prop of obj.properties) {
+		if (!t$4.isObjectProperty(prop) || prop.computed) continue;
+		if (t$4.isIdentifier(prop.key) && prop.key.name === name) return prop;
+		if (t$4.isStringLiteral(prop.key) && prop.key.value === name) return prop;
+	}
+	return null;
+}
+function decodeMapPassthrough(element, callbackParam) {
+	const meaningful = meaningfulChildren(element);
+	if (meaningful.length !== 1) return null;
+	const child = meaningful[0];
+	if (!t$4.isJSXExpressionContainer(child)) return null;
+	const expr = child.expression;
+	if (t$4.isMemberExpression(expr)) {
+		if (expr.computed) return null;
+		if (!t$4.isIdentifier(expr.object) || !t$4.isIdentifier(expr.property)) return null;
+		if (!callbackParam || !t$4.isIdentifier(callbackParam)) return null;
+		if (callbackParam.name !== expr.object.name) return null;
+		return expr.property.name;
+	}
+	if (t$4.isIdentifier(expr)) {
+		const fieldName = expr.name;
+		if (!callbackParam || !t$4.isObjectPattern(callbackParam)) return null;
+		for (const prop of callbackParam.properties) {
+			if (!t$4.isObjectProperty(prop) || prop.computed) continue;
+			if (!t$4.isIdentifier(prop.key) || prop.key.name !== fieldName) continue;
+			return t$4.isIdentifier(prop.value) && prop.value.name === fieldName ? fieldName : null;
+		}
+	}
+	return null;
+}
+function collectArrayMapCandidates(ast, element) {
+	const ctx = findEnclosingMapCallback(ast, element);
+	if (!ctx) return [];
+	const fieldName = decodeMapPassthrough(element, ctx.fn.params[0]);
+	if (!fieldName) return [];
+	const elements = resolveArrayLiteralElements(ast, ctx.arrayArg);
+	if (!elements) return [];
+	const out = [];
+	for (const obj of elements) {
+		const prop = findObjectProperty(obj, fieldName);
+		if (!prop) continue;
+		const v = prop.value;
+		if (t$4.isStringLiteral(v)) out.push({
+			current: v.value,
+			splice: (s) => spliceRange(v, jsString$1(s))
+		});
+		else if (t$4.isNumericLiteral(v)) out.push({
+			current: String(v.value),
+			splice: (s) => spliceRange(v, jsString$1(s))
+		});
+	}
+	return out;
+}
+function collectElementTextCandidates(ast, element) {
+	const candidates = [];
+	collectTextCandidates(element, candidates);
+	if (candidates.length === 0) {
+		const passthrough = propPassthroughName(element);
+		const enclosing = passthrough ? findEnclosingComponent(ast, element) : null;
+		if (passthrough === "children" && enclosing) candidates.push(...collectCallSiteCandidates(ast, enclosing.name));
+		else if (passthrough && enclosing && componentDestructuresProp(enclosing.fn, passthrough)) candidates.push(...collectPropCallSiteCandidates(ast, enclosing.name, passthrough));
+	}
+	if (candidates.length === 0) candidates.push(...collectArrayMapCandidates(ast, element));
+	return candidates;
+}
+function elementTextCandidateMatches(ast, element, prevText) {
+	const norm = prevText.trim();
+	return collectElementTextCandidates(ast, element).some((candidate) => candidate.current === norm);
+}
+function buildTextSplice(ast, element, value, prevText) {
+	const candidates = collectElementTextCandidates(ast, element);
+	if (candidates.length === 0) return { error: "element has no editable text" };
+	if (candidates.length === 1) return candidates[0].splice(value);
+	if (prevText === void 0) return { error: "element has multiple text candidates; missing prevText" };
+	const norm = prevText.trim();
+	const matches = candidates.filter((c) => c.current === norm);
+	if (matches.length === 0) return { error: "no text candidate matches the current value" };
+	if (matches.length > 1) return { error: "multiple text candidates share the same value; cannot disambiguate" };
+	return matches[0].splice(value);
+}
+function planAssetImport(ast, assetPath) {
+	const imports = findImports$1(ast);
+	for (const imp of imports) if (imp.source === assetPath && imp.defaultIdent) return {
+		identifier: imp.defaultIdent,
+		importSplice: null
+	};
+	const filename = assetPath.slice(assetPath.lastIndexOf("/") + 1);
+	const identifier = safeAssetIdentifier(filename, collectTopLevelIdentifiers(ast));
+	const importStmt = `import ${identifier} from '${assetPath.replace(/'/g, "\\'")}';\n`;
+	const last = imports[imports.length - 1];
+	const insertAt = last ? last.node.end ?? 0 : 0;
+	const prefix = last ? "\n" : "";
+	return {
+		identifier,
+		importSplice: {
+			from: insertAt,
+			to: insertAt,
+			text: prefix + importStmt
+		}
+	};
+}
+function planAssetAttr(ast, element, attr, assetPath) {
+	if (!attr || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(attr)) return { error: "invalid attribute name" };
+	if (!assetPath.startsWith("./assets/") && !assetPath.startsWith("@assets/")) return { error: "asset path must start with ./assets/ or @assets/" };
+	const { identifier, importSplice } = planAssetImport(ast, assetPath);
+	const opening = element.openingElement;
+	const newAttr = `${attr}={${identifier}}`;
+	const existing = findJsxAttr(opening, attr);
+	const attrSplice = existing ? {
+		from: existing.start ?? 0,
+		to: existing.end ?? 0,
+		text: newAttr
+	} : {
+		from: opening.name.end ?? 0,
+		to: opening.name.end ?? 0,
+		text: ` ${newAttr}`
+	};
+	return {
+		importSplice,
+		attrSplice
+	};
+}
+function planReplacePlaceholder(ast, element, assetPath) {
+	const opening = element.openingElement;
+	if (!t$4.isJSXIdentifier(opening.name) || opening.name.name !== "ImagePlaceholder") return { error: "not a placeholder" };
+	if (!assetPath.startsWith("./assets/") && !assetPath.startsWith("@assets/")) return { error: "asset path must start with ./assets/ or @assets/" };
+	const hint = readJsxStringAttr(opening, "hint") ?? "";
+	const width = readJsxNumberAttr(opening, "width");
+	const height = readJsxNumberAttr(opening, "height");
+	const { identifier, importSplice } = planAssetImport(ast, assetPath);
+	const styleParts = [];
+	if (width != null) styleParts.push(`width: ${width}`);
+	else if (height != null) styleParts.push(`width: '100%'`);
+	if (height != null) styleParts.push(`height: ${height}`);
+	else if (width != null) styleParts.push(`height: '100%'`);
+	styleParts.push(`objectFit: 'cover'`);
+	styleParts.push(`objectPosition: '50% 50%'`);
+	const replacement = `<img src={${identifier}} alt=${jsString$1(hint)} style={{ ${styleParts.join(", ")} }} />`;
+	return {
+		importSplice,
+		elementSplice: spliceRange(element, replacement)
+	};
+}
+function applyEdit(source, line, column, ops) {
+	if (ops.length === 0) return {
+		ok: true,
+		source
+	};
+	const ast = parseSource$2(source);
+	if (!ast) return {
+		ok: false,
+		status: 422,
+		error: "could not parse source"
+	};
+	const element = findElementForEdit(ast, line, column, ops);
+	if (!element) return {
+		ok: false,
+		status: 422,
+		error: "no JSX element at location"
+	};
+	const splices = [];
+	const styleOps = ops.flatMap((op) => op.kind === "set-style" ? [{
+		key: op.key,
+		value: op.value
+	}] : []);
+	if (styleOps.length > 0) {
+		const result = buildStyleSplice(source, element, styleOps);
+		if (result && "error" in result) return {
+			ok: false,
+			status: 422,
+			error: result.error
+		};
+		if (result) splices.push(result);
+	}
+	for (const op of ops) {
+		if (op.kind !== "set-text-range-style") continue;
+		const result = buildTextRangeStyleSplices(ast, source, element, op.start, op.end, {
+			key: op.key,
+			value: op.value
+		}, op.prevText);
+		if (result && "error" in result) return {
+			ok: false,
+			status: 422,
+			error: result.error
+		};
+		if (result) splices.push(...result);
+	}
+	for (const op of ops) {
+		if (op.kind !== "set-text") continue;
+		if (op.prevText !== void 0 && (op.value.includes("\n") || op.prevText.includes("\n"))) {
+			const richResult = buildTextContentSplices(element, op.value, op.prevText);
+			if (!("error" in richResult)) {
+				splices.push(...richResult);
+				continue;
+			}
+		}
+		const result = buildTextSplice(ast, element, op.value, op.prevText);
+		if ("error" in result) {
+			if (op.prevText === void 0) return {
+				ok: false,
+				status: 422,
+				error: result.error
+			};
+			const richResult = buildTextContentSplices(element, op.value, op.prevText);
+			if ("error" in richResult) return {
+				ok: false,
+				status: 422,
+				error: result.error
+			};
+			splices.push(...richResult);
+		} else splices.push(result);
+	}
+	const assetOps = ops.flatMap((op) => op.kind === "set-attr-asset" ? [op] : []);
+	const placeholderOps = ops.flatMap((op) => op.kind === "replace-placeholder-with-image" ? [op] : []);
+	if (assetOps.length > 0 || placeholderOps.length > 0) {
+		const importSplices = [];
+		for (const op of assetOps) {
+			const plan = planAssetAttr(ast, element, op.attr, op.assetPath);
+			if ("error" in plan) return {
+				ok: false,
+				status: 422,
+				error: plan.error
+			};
+			splices.push(plan.attrSplice);
+			if (plan.importSplice) importSplices.push(plan.importSplice);
+		}
+		for (const op of placeholderOps) {
+			const plan = planReplacePlaceholder(ast, element, op.assetPath);
+			if ("error" in plan) return {
+				ok: false,
+				status: 422,
+				error: plan.error
+			};
+			splices.push(plan.elementSplice);
+			if (plan.importSplice) importSplices.push(plan.importSplice);
+		}
+		if (importSplices.length > 0) {
+			const from = importSplices[0].from;
+			const to = importSplices[0].to;
+			const text = importSplices.map((s) => s.text).join("");
+			splices.push({
+				from,
+				to,
+				text
+			});
+		}
+	}
+	if (splices.length === 0) return {
+		ok: true,
+		source
+	};
+	splices.sort((a, b) => b.from - a.from);
+	let next = source;
+	for (const sp of splices) next = next.slice(0, sp.from) + sp.text + next.slice(sp.to);
+	if (!parseSource$2(next)) return {
+		ok: false,
+		status: 422,
+		error: "edit would produce invalid source"
+	};
+	return {
+		ok: true,
+		source: next
+	};
+}
+
+//#endregion
+//#region src/editing/revert-asset.ts
+function collectImgSrcUses(ast, identifier) {
+	const uses = [];
+	walkJsx(ast, (n) => {
+		if (!t$3.isJSXElement(n)) return;
+		const opening = n.openingElement;
+		if (!t$3.isJSXIdentifier(opening.name) || opening.name.name !== "img") return;
+		const src = findJsxAttr(opening, "src");
+		if (!src?.value) return;
+		if (!t$3.isJSXExpressionContainer(src.value)) return;
+		const expr = src.value.expression;
+		if (!t$3.isIdentifier(expr) || expr.name !== identifier) return;
+		uses.push({
+			element: n,
+			identNode: expr
+		});
+	});
+	return uses;
+}
+function readStyleNumericDim(opening, key) {
+	const style = findJsxAttr(opening, "style");
+	if (!style?.value) return null;
+	if (!t$3.isJSXExpressionContainer(style.value)) return null;
+	const obj = style.value.expression;
+	if (!t$3.isObjectExpression(obj)) return null;
+	for (const prop of obj.properties) {
+		if (!t$3.isObjectProperty(prop)) continue;
+		if (prop.computed) continue;
+		const k = prop.key;
+		const keyName = t$3.isIdentifier(k) ? k.name : t$3.isStringLiteral(k) ? k.value : null;
+		if (keyName !== key) continue;
+		const v = prop.value;
+		if (t$3.isNumericLiteral(v) && Number.isFinite(v.value)) return v.value;
+		return null;
+	}
+	return null;
+}
+function buildPlaceholderReplacement(hint, width, height) {
+	const parts = [`hint=${formatJsxAttrValue(hint)}`];
+	if (width != null) parts.push(`width={${width}}`);
+	if (height != null) parts.push(`height={${height}}`);
+	return `<ImagePlaceholder ${parts.join(" ")} />`;
+}
+function planEnsureImagePlaceholderImport(ast) {
+	const readKind = (n) => n.importKind === "type";
+	const imports = findImports$1(ast);
+	let valueImport = null;
+	for (const imp of imports) {
+		if (imp.source !== "@open-aippt/core") continue;
+		const declIsTypeOnly = readKind(imp.node);
+		for (const spec of imp.node.specifiers) {
+			if (!t$3.isImportSpecifier(spec)) continue;
+			const imported = spec.imported;
+			const name = t$3.isIdentifier(imported) ? imported.name : imported.value;
+			if (name !== "ImagePlaceholder") continue;
+			const specIsTypeOnly = readKind(spec) || declIsTypeOnly;
+			if (!specIsTypeOnly) return null;
+		}
+		if (!declIsTypeOnly && !valueImport) valueImport = imp;
+	}
+	if (valueImport) {
+		const node = valueImport.node;
+		const lastSpec = node.specifiers[node.specifiers.length - 1];
+		if (lastSpec && t$3.isImportSpecifier(lastSpec)) {
+			const insertAt$1 = lastSpec.end ?? 0;
+			return {
+				from: insertAt$1,
+				to: insertAt$1,
+				text: ", ImagePlaceholder"
+			};
+		}
+		if (lastSpec && t$3.isImportDefaultSpecifier(lastSpec)) {
+			const insertAt$1 = lastSpec.end ?? 0;
+			return {
+				from: insertAt$1,
+				to: insertAt$1,
+				text: ", { ImagePlaceholder }"
+			};
+		}
+		const insertAt = (node.source.start ?? 0) - 5;
+		return {
+			from: insertAt,
+			to: insertAt,
+			text: "{ ImagePlaceholder } "
+		};
+	}
+	return {
+		from: 0,
+		to: 0,
+		text: "import { ImagePlaceholder } from '@open-aippt/core';\n"
+	};
+}
+function findAssetUsages(source, assetPath) {
+	const ast = parseSource$2(source);
+	if (!ast) return 0;
+	const imports = findImports$1(ast);
+	const target = imports.find((imp) => imp.source === assetPath && imp.defaultIdent);
+	if (!target?.defaultIdent) return 0;
+	return collectImgSrcUses(ast, target.defaultIdent).length;
+}
+function findReferencedAssets(source, assetPaths) {
+	const referenced = new Set();
+	if (assetPaths.length === 0) return referenced;
+	const ast = parseSource$2(source);
+	if (!ast) return referenced;
+	const wanted = new Set(assetPaths);
+	const identToPath = new Map();
+	const importLocals = new Set();
+	for (const imp of findImports$1(ast)) {
+		if (!imp.defaultIdent) continue;
+		if (!wanted.has(imp.source)) continue;
+		identToPath.set(imp.defaultIdent, imp.source);
+		for (const spec of imp.node.specifiers) if (t$3.isImportDefaultSpecifier(spec) && spec.local.name === imp.defaultIdent) importLocals.add(spec.local);
+	}
+	if (identToPath.size === 0) return referenced;
+	walkAll(ast, (n) => {
+		if (!t$3.isIdentifier(n)) return;
+		const p = identToPath.get(n.name);
+		if (!p) return;
+		if (importLocals.has(n)) return;
+		referenced.add(p);
+	});
+	return referenced;
+}
+function applyRevertAsset(source, assetPath) {
+	const ast = parseSource$2(source);
+	if (!ast) return {
+		ok: false,
+		status: 422,
+		error: "could not parse source"
+	};
+	const imports = findImports$1(ast);
+	const target = imports.find((imp) => imp.source === assetPath && imp.defaultIdent);
+	if (!target?.defaultIdent) return {
+		ok: true,
+		source
+	};
+	const identifier = target.defaultIdent;
+	const importLocal = (() => {
+		for (const spec of target.node.specifiers) if (t$3.isImportDefaultSpecifier(spec) && spec.local.name === identifier) return spec.local;
+		return null;
+	})();
+	const imgUses = collectImgSrcUses(ast, identifier);
+	const allowed = new Set(imgUses.map((u) => u.identNode));
+	if (importLocal) allowed.add(importLocal);
+	let foreign = false;
+	walkAll(ast, (n) => {
+		if (!t$3.isIdentifier(n) || n.name !== identifier) return;
+		if (!allowed.has(n)) foreign = true;
+	});
+	if (foreign) return {
+		ok: false,
+		status: 422,
+		error: `cannot revert: '${identifier}' is referenced outside <img src={${identifier}}>`
+	};
+	const splices = [];
+	for (const use of imgUses) {
+		const opening = use.element.openingElement;
+		const hint = readJsxStringAttr(opening, "alt") ?? "";
+		const width = readStyleNumericDim(opening, "width");
+		const height = readStyleNumericDim(opening, "height");
+		splices.push(spliceRange(use.element, buildPlaceholderReplacement(hint, width, height)));
+	}
+	const importNode = target.node;
+	const importFrom = importNode.start ?? 0;
+	let importTo = importNode.end ?? 0;
+	if (source[importTo] === "\n") importTo += 1;
+	splices.push({
+		from: importFrom,
+		to: importTo,
+		text: ""
+	});
+	const ensureSplice = planEnsureImagePlaceholderImport(ast);
+	if (ensureSplice) splices.push(ensureSplice);
+	if (splices.length === 0) return {
+		ok: true,
+		source
+	};
+	splices.sort((a, b) => b.from - a.from);
+	let next = source;
+	for (const sp of splices) next = next.slice(0, sp.from) + sp.text + next.slice(sp.to);
+	if (!parseSource$2(next)) return {
+		ok: false,
+		status: 422,
+		error: "edit would produce invalid source"
+	};
+	return {
+		ok: true,
+		source: next
+	};
+}
+
+//#endregion
+//#region src/editing/slide-ops.ts
+const SLIDE_ID_RE = /^[a-z0-9_-]+$/i;
+function validateSlideName(v) {
+	if (typeof v !== "string") return null;
+	const trimmed = v.trim();
+	if (trimmed.length < 1 || trimmed.length > 80) return null;
+	return trimmed;
+}
+function unwrapExpression(node) {
+	let current = node;
+	while (current && (current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression")) current = current.expression;
+	return current;
+}
+function readMetaTitleInSource(source) {
+	let ast;
+	try {
+		ast = parse(source, {
+			sourceType: "module",
+			plugins: ["typescript", "jsx"],
+			errorRecovery: true
+		});
+	} catch {
+		return { kind: "unsupported" };
+	}
+	const body = ast.program?.body ?? [];
+	for (const stmt of body) {
+		if (stmt.type !== "ExportNamedDeclaration") continue;
+		const decl = stmt.declaration;
+		if (!decl || decl.type !== "VariableDeclaration") continue;
+		const declarations = decl.declarations ?? [];
+		for (const d of declarations) {
+			const id = d.id;
+			if (!id || id.type !== "Identifier" || id.name !== "meta") continue;
+			const init = unwrapExpression(d.init);
+			if (!init || init.type !== "ObjectExpression") return { kind: "unsupported" };
+			const properties = init.properties ?? [];
+			for (const property of properties) {
+				if (property.type !== "ObjectProperty" || property.computed) continue;
+				const key = property.key;
+				const keyName = key?.type === "Identifier" ? key.name : key?.type === "StringLiteral" ? key.value : void 0;
+				if (keyName !== "title") continue;
+				const value = property.value;
+				if (value?.type === "StringLiteral" && typeof value.value === "string") return {
+					kind: "found",
+					title: value.value
+				};
+				if (value?.type === "TemplateLiteral") {
+					const expressions = value.expressions ?? [];
+					const quasis = value.quasis ?? [];
+					const firstValue = quasis[0]?.value;
+					const cooked = firstValue?.cooked;
+					const raw = firstValue?.raw;
+					if (expressions.length === 0 && typeof (cooked ?? raw) === "string") return {
+						kind: "found",
+						title: cooked ?? raw
+					};
+				}
+				return { kind: "unsupported" };
+			}
+			return { kind: "missing" };
+		}
+	}
+	return { kind: "missing" };
+}
+async function rmSlideDir(slidesRoot, slideId) {
+	if (!SLIDE_ID_RE.test(slideId)) return false;
+	const dir = path.resolve(slidesRoot, slideId);
+	if (!dir.startsWith(slidesRoot + path.sep)) return false;
+	try {
+		await fs.rm(dir, {
+			recursive: true,
+			force: true
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function duplicateSlideDir(slidesRoot, slideId, desiredId) {
+	if (!SLIDE_ID_RE.test(slideId)) return {
+		ok: false,
+		status: 400,
+		error: "invalid slideId"
+	};
+	const root = path.resolve(slidesRoot);
+	const srcDir = path.resolve(root, slideId);
+	if (!srcDir.startsWith(root + path.sep)) return {
+		ok: false,
+		status: 400,
+		error: "invalid slideId"
+	};
+	try {
+		await fs.access(path.join(srcDir, "index.tsx"));
+	} catch {
+		return {
+			ok: false,
+			status: 404,
+			error: "slide not found"
+		};
+	}
+	let newId;
+	if (desiredId !== void 0) {
+		if (!SLIDE_ID_RE.test(desiredId)) return {
+			ok: false,
+			status: 400,
+			error: "invalid newId"
+		};
+		newId = desiredId;
+		const dstDir$1 = path.resolve(root, newId);
+		if (!dstDir$1.startsWith(root + path.sep)) return {
+			ok: false,
+			status: 400,
+			error: "invalid newId"
+		};
+		try {
+			await fs.access(dstDir$1);
+			return {
+				ok: false,
+				status: 409,
+				error: "slide already exists"
+			};
+		} catch {}
+	} else {
+		let suffix = 1;
+		while (true) {
+			newId = suffix === 1 ? `${slideId}-copy` : `${slideId}-copy-${suffix}`;
+			try {
+				await fs.access(path.resolve(root, newId));
+				suffix++;
+			} catch {
+				break;
+			}
+		}
+	}
+	const dstDir = path.resolve(root, newId);
+	if (!dstDir.startsWith(root + path.sep)) return {
+		ok: false,
+		status: 400,
+		error: "invalid newId"
+	};
+	const srcEntry = path.join(srcDir, "index.tsx");
+	let copiedEntrySource;
+	try {
+		const source = await fs.readFile(srcEntry, "utf8");
+		const metaTitle = readMetaTitleInSource(source);
+		if (metaTitle.kind === "unsupported") return {
+			ok: false,
+			status: 422,
+			error: "could not update copied slide title"
+		};
+		const title = metaTitle.kind === "found" ? metaTitle.title : slideId;
+		const updated = updateMetaTitleInSource(source, `${title} (copy)`);
+		if (updated === null) return {
+			ok: false,
+			status: 422,
+			error: "could not update copied slide title"
+		};
+		copiedEntrySource = updated;
+	} catch {
+		return {
+			ok: false,
+			status: 404,
+			error: "slide not found"
+		};
+	}
+	try {
+		await fs.cp(srcDir, dstDir, {
+			recursive: true,
+			errorOnExist: true,
+			force: false
+		});
+		await fs.writeFile(path.join(dstDir, "index.tsx"), copiedEntrySource, "utf8");
+		return {
+			ok: true,
+			slideId: newId
+		};
+	} catch (err) {
+		if (err.code === "EEXIST") return {
+			ok: false,
+			status: 409,
+			error: "slide already exists"
+		};
+		return {
+			ok: false,
+			status: 500,
+			error: String(err.message ?? err)
+		};
+	}
+}
+function resolveSlideEntry(slidesRoot, slideId) {
+	if (!SLIDE_ID_RE.test(slideId)) return null;
+	const dir = path.resolve(slidesRoot, slideId);
+	if (!dir.startsWith(slidesRoot + path.sep)) return null;
+	return path.join(dir, "index.tsx");
+}
+function escapeSingleQuoted(s) {
+	return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+/**
+* Rewrite (or insert) the `title` field in the slide module's `export const meta`.
+*
+* Strategy:
+*   1. Find `export const meta` and brace-match its object literal.
+*   2. If the object already has a `title: '...'` entry, replace the literal.
+*   3. If the object exists but has no title, inject a new `title: '...'` line
+*      as the first property (preserving the author's surrounding indentation).
+*   4. If there is no `meta` export at all, insert a fresh one right before
+*      `export default`.
+*
+* Returns the rewritten source, or `null` if the file shape was too surprising
+* to touch safely (e.g. `export default` missing when we'd need to inject meta).
+*/
+function updateMetaTitleInSource(source, title) {
+	const newLiteral = `'${escapeSingleQuoted(title)}'`;
+	const metaStart = source.search(/export\s+const\s+meta\b/);
+	if (metaStart !== -1) {
+		const eqIdx = source.indexOf("=", metaStart);
+		if (eqIdx === -1) return null;
+		const openBrace = source.indexOf("{", eqIdx);
+		if (openBrace === -1) return null;
+		let depth = 0;
+		let closeBrace = -1;
+		for (let i = openBrace; i < source.length; i++) {
+			const ch = source[i];
+			if (ch === "{") depth++;
+			else if (ch === "}") {
+				depth--;
+				if (depth === 0) {
+					closeBrace = i;
+					break;
+				}
+			}
+		}
+		if (closeBrace === -1) return null;
+		const body = source.slice(openBrace + 1, closeBrace);
+		const titleRe = /(^|[\s,{])(title\s*:\s*)(['"`])((?:\\.|(?!\3).)*)\3/;
+		const match = body.match(titleRe);
+		if (match) {
+			const newBody = body.replace(titleRe, `${match[1]}${match[2]}${newLiteral}`);
+			return source.slice(0, openBrace + 1) + newBody + source.slice(closeBrace);
+		}
+		const firstIndentMatch = body.match(/\n([ \t]+)\S/);
+		const indent$1 = firstIndentMatch ? firstIndentMatch[1] : "  ";
+		const trimmedBody = body.replace(/^\s*\n?/, "");
+		const needsSeparator = trimmedBody.trim().length > 0;
+		const insertion$1 = `\n${indent$1}title: ${newLiteral}${needsSeparator ? "," : ""}`;
+		return source.slice(0, openBrace + 1) + insertion$1 + body + source.slice(closeBrace);
+	}
+	const exportDefaultIdx = source.search(/export\s+default\b/);
+	if (exportDefaultIdx === -1) return null;
+	const insertion = `export const meta: SlideMeta = { title: ${newLiteral} };\n\n`;
+	return source.slice(0, exportDefaultIdx) + insertion + source.slice(exportDefaultIdx);
+}
+function findDefaultExportArray(source) {
+	let ast;
+	try {
+		ast = parse(source, {
+			sourceType: "module",
+			plugins: ["typescript", "jsx"],
+			errorRecovery: true
+		});
+	} catch {
+		return null;
+	}
+	const body = ast.program?.body ?? [];
+	for (const node of body) {
+		if (node.type !== "ExportDefaultDeclaration") continue;
+		let inner = node.declaration;
+		while (inner && (inner.type === "TSAsExpression" || inner.type === "TSSatisfiesExpression")) inner = inner.expression;
+		if (!inner || inner.type !== "ArrayExpression") return null;
+		const arrayStart = inner.start;
+		const arrayEnd = inner.end;
+		const rawElements = inner.elements ?? [];
+		const elements = [];
+		for (const el of rawElements) {
+			if (!el || typeof el.start !== "number" || typeof el.end !== "number") return null;
+			elements.push({
+				start: el.start,
+				end: el.end
+			});
+		}
+		return {
+			elements,
+			arrayStart,
+			arrayEnd
+		};
+	}
+	return null;
+}
+/**
+* Rewrite `export default [...]` so its elements appear in the requested order.
+*
+* `order[i]` is the original index that should land at new position `i`. The
+* function preserves each element's exact source slice (including any inline
+* comments that hug an identifier) and keeps the inter-element separator slots
+* in their original positions, so a 3-page array `[A, B, C]` reordered to
+* `[2, 0, 1]` becomes `[C, A, B]` with the same indentation and trailing
+* commas the author wrote.
+*
+* Returns `null` when the file's default export isn't an array literal, or the
+* order is not a valid permutation of `[0, n-1]`.
+*/
+function reorderDefaultExportPagesInSource(source, order) {
+	const found = findDefaultExportArray(source);
+	if (!found) return null;
+	const { elements, arrayStart, arrayEnd } = found;
+	const n = elements.length;
+	if (order.length !== n) return null;
+	const seen = new Set();
+	for (const idx of order) {
+		if (!Number.isInteger(idx) || idx < 0 || idx >= n) return null;
+		if (seen.has(idx)) return null;
+		seen.add(idx);
+	}
+	if (n === 0) return source;
+	let identity = true;
+	for (let i = 0; i < n; i++) if (order[i] !== i) {
+		identity = false;
+		break;
+	}
+	if (identity) return source;
+	const prefix = source.slice(arrayStart, elements[0].start);
+	const suffix = source.slice(elements[n - 1].end, arrayEnd);
+	const separators = [];
+	for (let i = 0; i < n - 1; i++) separators.push(source.slice(elements[i].end, elements[i + 1].start));
+	const elementText = elements.map((el) => source.slice(el.start, el.end));
+	let rebuilt = prefix + elementText[order[0]];
+	for (let i = 1; i < n; i++) rebuilt += separators[i - 1] + elementText[order[i]];
+	rebuilt += suffix;
+	return source.slice(0, arrayStart) + rebuilt + source.slice(arrayEnd);
+}
+function findNotesArray(source) {
+	let ast;
+	try {
+		ast = parse(source, {
+			sourceType: "module",
+			plugins: ["typescript", "jsx"],
+			errorRecovery: true
+		});
+	} catch {
+		return "invalid";
+	}
+	const body = ast.program?.body ?? [];
+	for (const stmt of body) {
+		if (stmt.type !== "ExportNamedDeclaration") continue;
+		const decl = stmt.declaration;
+		if (!decl || decl.type !== "VariableDeclaration") continue;
+		const declarations = decl.declarations ?? [];
+		for (const d of declarations) {
+			const id = d.id;
+			if (!id || id.type !== "Identifier" || id.name !== "notes") continue;
+			const init = d.init;
+			if (!init || init.type !== "ArrayExpression") return "invalid";
+			const arrayStart = init.start;
+			const arrayEnd = init.end;
+			if (typeof arrayStart !== "number" || typeof arrayEnd !== "number") return "invalid";
+			const rawElements = init.elements ?? [];
+			const elementTexts = [];
+			for (const el of rawElements) {
+				if (el === null) {
+					elementTexts.push("undefined");
+					continue;
+				}
+				if (el.type === "SpreadElement") return "invalid";
+				const start = el.start;
+				const end = el.end;
+				if (typeof start !== "number" || typeof end !== "number") return "invalid";
+				elementTexts.push(source.slice(start, end));
+			}
+			return {
+				arrayStart,
+				arrayEnd,
+				elementTexts
+			};
+		}
+	}
+	return null;
+}
+/**
+* Reorder `export const notes = [...]` to follow the page-array reorder.
+*
+* `order[i]` is the original page index that should land at new position `i`.
+* The notes array is index-aligned with the pages array but may be shorter
+* (trailing `undefined` slots are routinely trimmed). Missing elements are
+* treated as `undefined`, and trailing `undefined` is trimmed again after
+* reordering to keep the file tidy.
+*
+* Returns the rewritten source, the original source if no `notes` export
+* exists or the reorder is a no-op, or `null` if the `notes` export's shape
+* is too surprising to touch safely.
+*/
+function reorderNotesArrayInSource(source, order) {
+	for (const idx of order) if (!Number.isInteger(idx) || idx < 0) return null;
+	const found = findNotesArray(source);
+	if (found === "invalid") return null;
+	if (found === null) return source;
+	const { arrayStart, arrayEnd, elementTexts } = found;
+	const pick = (i) => i >= 0 && i < elementTexts.length ? elementTexts[i] : "undefined";
+	return rebuildNotesArray(source, arrayStart, arrayEnd, order.map(pick));
+}
+/**
+* Remove the note aligned with the page at `index` so the `notes` export stays
+* index-aligned with `export default [...]` after a page deletion. Mirrors
+* {@link removePageFromDefaultExportInSource}.
+*
+* Returns the rewritten source, the original source if no `notes` export exists
+* or the index falls past the recorded notes, or `null` if the `notes` export's
+* shape is too surprising to touch safely.
+*/
+function removeNotesElementInSource(source, index) {
+	if (!Number.isInteger(index) || index < 0) return null;
+	const found = findNotesArray(source);
+	if (found === "invalid") return null;
+	if (found === null) return source;
+	const { arrayStart, arrayEnd, elementTexts } = found;
+	if (index >= elementTexts.length) return source;
+	const next = elementTexts.slice();
+	next.splice(index, 1);
+	return rebuildNotesArray(source, arrayStart, arrayEnd, next);
+}
+/**
+* Duplicate the note aligned with the page at `index`, inserting the copy right
+* after it so the `notes` export stays index-aligned with `export default [...]`
+* after a page duplication. Mirrors {@link duplicatePageInDefaultExportInSource}.
+*
+* Returns the rewritten source, the original source if no `notes` export exists
+* or the index falls past the recorded notes (the new slot and everything after
+* it are absent, so nothing shifts), or `null` if the shape is too surprising.
+*/
+function duplicateNotesElementInSource(source, index) {
+	if (!Number.isInteger(index) || index < 0) return null;
+	const found = findNotesArray(source);
+	if (found === "invalid") return null;
+	if (found === null) return source;
+	const { arrayStart, arrayEnd, elementTexts } = found;
+	if (index >= elementTexts.length) return source;
+	const next = elementTexts.slice();
+	next.splice(index + 1, 0, next[index]);
+	return rebuildNotesArray(source, arrayStart, arrayEnd, next);
+}
+function rebuildNotesArray(source, arrayStart, arrayEnd, elements) {
+	const trimmed = elements.slice();
+	while (trimmed.length > 0 && trimmed[trimmed.length - 1] === "undefined") trimmed.pop();
+	const replacement = trimmed.length === 0 ? "[]" : `[\n${trimmed.map((s) => `  ${s},`).join("\n")}\n]`;
+	if (replacement === source.slice(arrayStart, arrayEnd)) return source;
+	return source.slice(0, arrayStart) + replacement + source.slice(arrayEnd);
+}
+/**
+* Remove the element at `index` from `export default [...]`.
+*
+* Preserves the source slice of every other element, dropping the separator
+* immediately following the removed element (or the preceding one when the
+* removed element is the last). Returns `null` when the default export isn't
+* an array literal or `index` is out of range.
+*/
+function removePageFromDefaultExportInSource(source, index) {
+	const found = findDefaultExportArray(source);
+	if (!found) return null;
+	const { elements, arrayStart, arrayEnd } = found;
+	const n = elements.length;
+	if (!Number.isInteger(index) || index < 0 || index >= n) return null;
+	if (n === 1) return `${source.slice(0, arrayStart)}[]${source.slice(arrayEnd)}`;
+	const prefix = source.slice(arrayStart, elements[0].start);
+	const suffix = source.slice(elements[n - 1].end, arrayEnd);
+	const separators = [];
+	for (let i = 0; i < n - 1; i++) separators.push(source.slice(elements[i].end, elements[i + 1].start));
+	const elementText = elements.map((el) => source.slice(el.start, el.end));
+	const keptElements = [];
+	const keptSeparators = [];
+	for (let i = 0; i < n; i++) {
+		if (i === index) continue;
+		keptElements.push(elementText[i]);
+	}
+	for (let i = 0; i < n - 1; i++) {
+		if (index === n - 1 ? i === n - 2 : i === index) continue;
+		keptSeparators.push(separators[i]);
+	}
+	let rebuilt = prefix + keptElements[0];
+	for (let i = 1; i < keptElements.length; i++) rebuilt += keptSeparators[i - 1] + keptElements[i];
+	rebuilt += suffix;
+	return source.slice(0, arrayStart) + rebuilt + source.slice(arrayEnd);
+}
+function chooseInsertSeparator(prefix, existingSeparators) {
+	const sample = existingSeparators.find((s) => s.includes(","));
+	if (sample) return sample;
+	if (prefix.includes("\n")) {
+		const m = prefix.match(/\n([ \t]*)$/);
+		const indent$1 = m ? m[1] : "  ";
+		return `,\n${indent$1}`;
+	}
+	return ", ";
+}
+/**
+* Duplicate the element at `index` in `export default [...]`, inserting the
+* copy immediately after the original. Reuses an existing inter-element
+* separator when one is available so the cloned entry matches the surrounding
+* indentation. Returns `null` when the default export isn't an array literal
+* or `index` is out of range.
+*/
+function duplicatePageInDefaultExportInSource(source, index) {
+	const found = findDefaultExportArray(source);
+	if (!found) return null;
+	const { elements, arrayStart, arrayEnd } = found;
+	const n = elements.length;
+	if (!Number.isInteger(index) || index < 0 || index >= n) return null;
+	const prefix = source.slice(arrayStart, elements[0].start);
+	const suffix = source.slice(elements[n - 1].end, arrayEnd);
+	const separators = [];
+	for (let i = 0; i < n - 1; i++) separators.push(source.slice(elements[i].end, elements[i + 1].start));
+	const elementText = elements.map((el) => source.slice(el.start, el.end));
+	const insertSep = chooseInsertSeparator(prefix, separators);
+	const newElements = [];
+	const newSeparators = [];
+	for (let i = 0; i < n; i++) {
+		newElements.push(elementText[i]);
+		if (i === index) {
+			newElements.push(elementText[i]);
+			newSeparators.push(insertSep);
+		}
+		if (i < n - 1) newSeparators.push(separators[i]);
+	}
+	let rebuilt = prefix + newElements[0];
+	for (let i = 1; i < newElements.length; i++) rebuilt += newSeparators[i - 1] + newElements[i];
+	rebuilt += suffix;
+	return source.slice(0, arrayStart) + rebuilt + source.slice(arrayEnd);
+}
+
+//#endregion
+//#region src/files/assets.ts
+const GLOBAL_SCOPE = "@global";
+const ASSET_MAX_BYTES = 25 * 1024 * 1024;
+const ASSET_FORBIDDEN_RE = /[\x00-\x1F\x7F/\\:*?"<>|]/;
+const MIME_BY_EXT = {
+	png: "image/png",
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	gif: "image/gif",
+	svg: "image/svg+xml",
+	webp: "image/webp",
+	avif: "image/avif",
+	ico: "image/x-icon",
+	mp4: "video/mp4",
+	webm: "video/webm",
+	mov: "video/quicktime",
+	woff: "font/woff",
+	woff2: "font/woff2",
+	ttf: "font/ttf",
+	otf: "font/otf",
+	json: "application/json",
+	txt: "text/plain; charset=utf-8",
+	md: "text/markdown; charset=utf-8"
+};
+function mimeForFilename(name) {
+	const dot = name.lastIndexOf(".");
+	if (dot < 0) return "application/octet-stream";
+	const ext = name.slice(dot + 1).toLowerCase();
+	return MIME_BY_EXT[ext] ?? "application/octet-stream";
+}
+function validateAssetName(v) {
+	if (typeof v !== "string") return null;
+	const trimmed = v.trim();
+	if (trimmed.length < 1 || trimmed.length > 120) return null;
+	if (ASSET_FORBIDDEN_RE.test(trimmed)) return null;
+	if (trimmed.startsWith(".") || trimmed.startsWith("~")) return null;
+	if (trimmed === ".." || trimmed.split(/[/\\]/).includes("..")) return null;
+	const dot = trimmed.lastIndexOf(".");
+	if (dot <= 0 || dot === trimmed.length - 1) return null;
+	return trimmed;
+}
+function resolveAssetsDir(slidesRoot, slideId) {
+	if (!SLIDE_ID_RE.test(slideId)) return null;
+	const slideDir = path.resolve(slidesRoot, slideId);
+	if (!slideDir.startsWith(slidesRoot + path.sep)) return null;
+	const assetsDir = path.resolve(slideDir, "assets");
+	if (assetsDir !== path.join(slideDir, "assets")) return null;
+	return assetsDir;
+}
+function resolveAssetFile(slidesRoot, slideId, filename) {
+	const assetsDir = resolveAssetsDir(slidesRoot, slideId);
+	if (!assetsDir) return null;
+	if (!validateAssetName(filename)) return null;
+	const file = path.resolve(assetsDir, filename);
+	if (!file.startsWith(assetsDir + path.sep)) return null;
+	return file;
+}
+function resolveScopedAssetsDir(slidesRoot, globalAssetsRoot, scope) {
+	if (scope === GLOBAL_SCOPE) return globalAssetsRoot;
+	return resolveAssetsDir(slidesRoot, scope);
+}
+function resolveScopedAssetFile(slidesRoot, globalAssetsRoot, scope, filename) {
+	if (scope === GLOBAL_SCOPE) {
+		if (!validateAssetName(filename)) return null;
+		const file = path.resolve(globalAssetsRoot, filename);
+		if (!file.startsWith(globalAssetsRoot + path.sep)) return null;
+		return file;
+	}
+	return resolveAssetFile(slidesRoot, scope, filename);
+}
+
+//#endregion
+//#region src/http/request-guard.ts
+function firstHeaderValue(value) {
+	if (Array.isArray(value)) return value[0] ?? null;
+	return value ?? null;
+}
+function headerValue(req, name) {
+	return firstHeaderValue(req.headers[name.toLowerCase()])?.trim() ?? null;
+}
+function firstCommaToken(value) {
+	if (!value) return null;
+	const [first] = value.split(",", 1);
+	return first?.trim() || null;
+}
+function requestProto(req) {
+	const forwarded = firstCommaToken(headerValue(req, "x-forwarded-proto"))?.toLowerCase();
+	if (forwarded === "http" || forwarded === "https") return forwarded;
+	return "encrypted" in req.socket && req.socket.encrypted ? "https" : "http";
+}
+function normalizedOrigin(origin) {
+	try {
+		const url = new URL(origin);
+		return `${url.protocol}//${url.host}`.toLowerCase();
+	} catch {
+		return null;
+	}
+}
+function validateMutationRequest(req, opts = {}) {
+	if (opts.requireJsonBody) {
+		const contentType = headerValue(req, "content-type")?.toLowerCase();
+		if (!contentType || !contentType.startsWith("application/json")) return {
+			ok: false,
+			status: 415,
+			error: "content-type must be application/json"
+		};
+	}
+	const fetchSite = firstCommaToken(headerValue(req, "sec-fetch-site"))?.toLowerCase();
+	if (fetchSite === "cross-site") return {
+		ok: false,
+		status: 403,
+		error: "cross-site request blocked"
+	};
+	const originRaw = headerValue(req, "origin");
+	if (!originRaw) return { ok: true };
+	if (originRaw.toLowerCase() === "null") return {
+		ok: false,
+		status: 403,
+		error: "opaque origin is not allowed"
+	};
+	const actualOrigin = normalizedOrigin(originRaw);
+	if (!actualOrigin) return {
+		ok: false,
+		status: 403,
+		error: "invalid origin header"
+	};
+	const host = firstCommaToken(headerValue(req, "x-forwarded-host")) ?? headerValue(req, "host");
+	if (!host) return {
+		ok: false,
+		status: 400,
+		error: "missing host header"
+	};
+	const expectedOrigin = `${requestProto(req)}://${host}`.toLowerCase();
+	if (actualOrigin !== expectedOrigin) return {
+		ok: false,
+		status: 403,
+		error: "origin mismatch"
+	};
+	return { ok: true };
+}
+
+//#endregion
+//#region src/vite/routes/context.ts
+function makeContext(opts) {
+	const userCwd = opts.userCwd;
+	const slidesDir = opts.slidesDir ?? "slides";
+	const assetsDir = opts.assetsDir ?? "assets";
+	const slidesRoot = path.resolve(userCwd, slidesDir);
+	const globalAssetsRoot = path.resolve(userCwd, assetsDir);
+	const manifestPath = path.join(slidesRoot, ".folders.json");
+	return {
+		userCwd,
+		slidesDir,
+		slidesRoot,
+		globalAssetsRoot,
+		manifestPath,
+		coreVersion: opts.coreVersion
+	};
+}
+async function readBody(req) {
+	return await new Promise((resolve, reject) => {
+		const chunks = [];
+		req.on("data", (c) => chunks.push(c));
+		req.on("end", () => {
+			const raw = Buffer.concat(chunks).toString("utf8");
+			if (!raw) return resolve({});
+			try {
+				resolve(JSON.parse(raw));
+			} catch (e) {
+				reject(e);
+			}
+		});
+		req.on("error", reject);
+	});
+}
+function json(res, status, body) {
+	res.statusCode = status;
+	res.setHeader("content-type", "application/json");
+	res.end(JSON.stringify(body));
+}
+function resolveSlidePath(userCwd, slidesDir, slideId) {
+	if (!SLIDE_ID_RE.test(slideId)) return null;
+	const slidesRoot = path.resolve(userCwd, slidesDir);
+	const full = path.resolve(slidesRoot, slideId, "index.tsx");
+	if (!full.startsWith(slidesRoot + path.sep)) return null;
+	return full;
+}
+function resolveSlideEntryPath(ctx, slideId) {
+	return resolveSlidePath(ctx.userCwd, ctx.slidesDir, slideId);
+}
+
+//#endregion
+//#region src/vite/routes/assets.ts
+function registerAssetRoutes(server, ctx) {
+	server.middlewares.use("/__assets", async (req, res, next) => {
+		const url = new URL(req.url ?? "/", "http://local");
+		const method = req.method ?? "GET";
+		try {
+			const listMatch = url.pathname.match(/^\/([^/]+)\/?$/);
+			const fileMatch = url.pathname.match(/^\/([^/]+)\/([^/]+)$/);
+			const usagesMatch = url.pathname.match(/^\/([^/]+)\/([^/]+)\/usages$/);
+			if (usagesMatch && method === "GET") {
+				const scope = usagesMatch[1];
+				const filename = decodeURIComponent(usagesMatch[2]);
+				if (!validateAssetName(filename)) return json(res, 400, { error: "invalid path" });
+				const isGlobal = scope === GLOBAL_SCOPE;
+				const assetPath = isGlobal ? `@assets/${filename}` : `./assets/${filename}`;
+				let slideIds;
+				if (isGlobal) try {
+					const entries = await fs.readdir(ctx.slidesRoot, { withFileTypes: true });
+					slideIds = entries.filter((e) => e.isDirectory() && SLIDE_ID_RE.test(e.name)).map((e) => e.name);
+				} catch {
+					slideIds = [];
+				}
+				else {
+					if (!SLIDE_ID_RE.test(scope)) return json(res, 400, { error: "invalid slideId" });
+					slideIds = [scope];
+				}
+				const usages = [];
+				let totalCount = 0;
+				for (const sid of slideIds) {
+					const entry = resolveSlideEntry(ctx.slidesRoot, sid);
+					if (!entry) continue;
+					let source;
+					try {
+						source = await fs.readFile(entry, "utf8");
+					} catch {
+						continue;
+					}
+					const count = findAssetUsages(source, assetPath);
+					if (count > 0) {
+						usages.push({
+							slideId: sid,
+							count
+						});
+						totalCount += count;
+					}
+				}
+				return json(res, 200, {
+					usages,
+					totalCount
+				});
+			}
+			if (listMatch && method === "GET") {
+				const slideId = listMatch[1];
+				const scopedDir = resolveScopedAssetsDir(ctx.slidesRoot, ctx.globalAssetsRoot, slideId);
+				if (!scopedDir) return json(res, 400, { error: "invalid slideId" });
+				let entries;
+				try {
+					entries = await fs.readdir(scopedDir);
+				} catch (err) {
+					if (err.code === "ENOENT") return json(res, 200, { assets: [] });
+					throw err;
+				}
+				const assets = [];
+				for (const name of entries) {
+					if (!validateAssetName(name)) continue;
+					const stat = await fs.stat(path.join(scopedDir, name));
+					if (!stat.isFile()) continue;
+					assets.push({
+						name,
+						size: stat.size,
+						mtime: stat.mtimeMs,
+						mime: mimeForFilename(name),
+						url: `/__assets/${slideId}/${encodeURIComponent(name)}`,
+						unused: true
+					});
+				}
+				assets.sort((a, b) => a.name.localeCompare(b.name));
+				if (assets.length > 0) {
+					const isGlobal = slideId === GLOBAL_SCOPE;
+					let scanIds;
+					if (isGlobal) try {
+						const dirs = await fs.readdir(ctx.slidesRoot, { withFileTypes: true });
+						scanIds = dirs.filter((e) => e.isDirectory() && SLIDE_ID_RE.test(e.name)).map((e) => e.name);
+					} catch {
+						scanIds = [];
+					}
+					else scanIds = SLIDE_ID_RE.test(slideId) ? [slideId] : [];
+					const paths = assets.map((a) => isGlobal ? `@assets/${a.name}` : `./assets/${a.name}`);
+					const pathToAsset = new Map(paths.map((p, i) => [p, assets[i]]));
+					for (const sid of scanIds) {
+						const entry = resolveSlideEntry(ctx.slidesRoot, sid);
+						if (!entry) continue;
+						let source;
+						try {
+							source = await fs.readFile(entry, "utf8");
+						} catch {
+							continue;
+						}
+						for (const p of findReferencedAssets(source, paths)) {
+							const a = pathToAsset.get(p);
+							if (a) a.unused = false;
+						}
+					}
+				}
+				return json(res, 200, { assets });
+			}
+			if (fileMatch) {
+				const slideId = fileMatch[1];
+				const filename = decodeURIComponent(fileMatch[2]);
+				const file = resolveScopedAssetFile(ctx.slidesRoot, ctx.globalAssetsRoot, slideId, filename);
+				if (!file) return json(res, 400, { error: "invalid path" });
+				if (method === "GET") try {
+					const buf = await fs.readFile(file);
+					res.statusCode = 200;
+					res.setHeader("content-type", mimeForFilename(filename));
+					res.setHeader("cache-control", "no-store");
+					res.end(buf);
+					return;
+				} catch (err) {
+					if (err.code === "ENOENT") return json(res, 404, { error: "asset not found" });
+					throw err;
+				}
+				if (method === "POST") {
+					const requestCheck = validateMutationRequest(req);
+					if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+					const overwrite = url.searchParams.get("overwrite") === "1";
+					const lenHeader = req.headers["content-length"];
+					const len = typeof lenHeader === "string" ? Number(lenHeader) : NaN;
+					if (Number.isFinite(len) && len > ASSET_MAX_BYTES) return json(res, 413, { error: "file too large" });
+					if (!overwrite) try {
+						await fs.access(file);
+						return json(res, 409, { error: "asset exists" });
+					} catch {}
+					const scopedDir = resolveScopedAssetsDir(ctx.slidesRoot, ctx.globalAssetsRoot, slideId);
+					if (!scopedDir) return json(res, 400, { error: "invalid slideId" });
+					await fs.mkdir(scopedDir, { recursive: true });
+					const chunks = [];
+					let total = 0;
+					let oversized = false;
+					await new Promise((resolve, reject) => {
+						req.on("data", (c) => {
+							total += c.length;
+							if (total > ASSET_MAX_BYTES) {
+								oversized = true;
+								req.destroy();
+								return;
+							}
+							chunks.push(c);
+						});
+						req.on("end", () => resolve());
+						req.on("error", reject);
+					});
+					if (oversized) return json(res, 413, { error: "file too large" });
+					await fs.writeFile(file, Buffer.concat(chunks));
+					return json(res, 200, {
+						ok: true,
+						name: filename,
+						size: total,
+						mime: mimeForFilename(filename),
+						url: `/__assets/${slideId}/${encodeURIComponent(filename)}`
+					});
+				}
+				if (method === "PATCH") {
+					const requestCheck = validateMutationRequest(req, { requireJsonBody: true });
+					if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+					const body = await readBody(req);
+					const target = validateAssetName(body.name);
+					if (!target) return json(res, 400, { error: "invalid name" });
+					if (target === filename) return json(res, 200, {
+						ok: true,
+						name: filename
+					});
+					const dest = resolveScopedAssetFile(ctx.slidesRoot, ctx.globalAssetsRoot, slideId, target);
+					if (!dest) return json(res, 400, { error: "invalid name" });
+					try {
+						await fs.access(dest);
+						return json(res, 409, { error: "target exists" });
+					} catch {}
+					try {
+						await fs.rename(file, dest);
+					} catch (err) {
+						if (err.code === "ENOENT") return json(res, 404, { error: "asset not found" });
+						throw err;
+					}
+					return json(res, 200, {
+						ok: true,
+						name: target
+					});
+				}
+				if (method === "DELETE") {
+					const requestCheck = validateMutationRequest(req);
+					if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+					try {
+						await fs.unlink(file);
+					} catch (err) {
+						if (err.code === "ENOENT") return json(res, 404, { error: "asset not found" });
+						throw err;
+					}
+					return json(res, 200, { ok: true });
+				}
+			}
+			return next();
+		} catch (err) {
+			json(res, 500, { error: String(err.message ?? err) });
+		}
+	});
+}
+
+//#endregion
+//#region src/editing/comments.ts
+const MARKER_RE = /\{\/\*\s*@slide-comment\s+id="(c-[a-f0-9]+)"\s+ts="([^"]+)"\s+text="([A-Za-z0-9_-]+={0,2})"\s*\*\/\}/g;
+function b64urlEncode(s) {
+	return Buffer.from(s, "utf8").toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function b64urlDecode(s) {
+	const pad = s.length % 4 === 0 ? "" : "=".repeat(4 - s.length % 4);
+	return Buffer.from(s.replace(/-/g, "+").replace(/_/g, "/") + pad, "base64").toString("utf8");
+}
+function parseMarkers(source) {
+	const comments = [];
+	const lines = source.split("\n");
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		MARKER_RE.lastIndex = 0;
+		const m = MARKER_RE.exec(line);
+		if (!m) continue;
+		const [, id, ts, textB64] = m;
+		try {
+			const payload = JSON.parse(b64urlDecode(textB64));
+			comments.push({
+				id,
+				line: i + 1,
+				ts,
+				note: payload.note,
+				hint: payload.hint
+			});
+		} catch {}
+	}
+	return comments;
+}
+function newCommentId() {
+	return `c-${randomUUID().replace(/-/g, "").slice(0, 8)}`;
+}
+function markerDeleteRegex(id) {
+	return new RegExp(`\\{\\/\\*\\s*@slide-comment\\s+id="${id}"\\s+ts="[^"]+"\\s+text="[A-Za-z0-9_\\-]+={0,2}"\\s*\\*\\/\\}`);
+}
+function lineToOffset(source, line) {
+	let off = 0;
+	for (let l = 1; l < line; l++) {
+		const nl = source.indexOf("\n", off);
+		if (nl === -1) return source.length;
+		off = nl + 1;
+	}
+	return off;
+}
+function lineIndent(source, lineNumber) {
+	const start = lineToOffset(source, lineNumber);
+	const m = source.slice(start, start + 200).match(/^[ \t]*/);
+	return m?.[0] ?? "";
+}
+function findJsxAncestors(ast, line, column) {
+	const hits = [];
+	walkJsx(ast, (n) => {
+		if (!n.loc || !t$2.isJSXElement(n) && !t$2.isJSXFragment(n)) return;
+		const s = n.loc.start;
+		const e = n.loc.end;
+		const afterStart = line > s.line || line === s.line && column >= s.column;
+		const beforeEnd = line < e.line || line === e.line && column < e.column;
+		if (afterStart && beforeEnd) hits.push({
+			node: n,
+			size: (n.end ?? 0) - (n.start ?? 0)
+		});
+	});
+	hits.sort((a, b) => a.size - b.size);
+	return hits.map((h) => h.node);
+}
+function planInsertion(source, target) {
+	if (t$2.isJSXFragment(target)) {
+		const opening = target.openingFragment;
+		const startLine = target.loc?.start.line ?? 1;
+		return {
+			offset: opening.end ?? 0,
+			indent: `${lineIndent(source, startLine)}  `
+		};
+	}
+	if (t$2.isJSXElement(target)) {
+		const opening = target.openingElement;
+		if (opening.selfClosing) return null;
+		const startLine = target.loc?.start.line ?? 1;
+		return {
+			offset: opening.end ?? 0,
+			indent: `${lineIndent(source, startLine)}  `
+		};
+	}
+	return null;
+}
+function findInsertion(source, line, column) {
+	const ast = parseSource$2(source);
+	if (!ast) return null;
+	const col = column ?? 0;
+	const ancestors = findJsxAncestors(ast, line, col);
+	for (const node of ancestors) {
+		const plan = planInsertion(source, node);
+		if (plan) return plan;
+	}
+	return null;
+}
+function offsetToLine(source, offset) {
+	let line = 1;
+	for (let i = 0; i < offset && i < source.length; i++) if (source[i] === "\n") line++;
+	return line;
+}
+
+//#endregion
+//#region src/vite/routes/comments.ts
+function registerCommentRoutes(server, ctx) {
+	server.middlewares.use("/__comments", async (req, res, next) => {
+		const url = new URL(req.url ?? "/", "http://local");
+		const method = req.method ?? "GET";
+		try {
+			if (method === "GET" && url.pathname === "/") {
+				const slideId = url.searchParams.get("slideId") ?? "";
+				const file = resolveSlideEntryPath(ctx, slideId);
+				if (!file) return json(res, 400, { error: "invalid slideId" });
+				let source;
+				try {
+					source = await fs.readFile(file, "utf8");
+				} catch {
+					return json(res, 404, { error: "slide not found" });
+				}
+				return json(res, 200, { comments: parseMarkers(source) });
+			}
+			if (method === "POST" && url.pathname === "/add") {
+				const requestCheck = validateMutationRequest(req, { requireJsonBody: true });
+				if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+				const body = await readBody(req);
+				const slideId = body.slideId ?? "";
+				const file = resolveSlideEntryPath(ctx, slideId);
+				if (!file) return json(res, 400, { error: "invalid slideId" });
+				if (!body.line || body.line < 1) return json(res, 400, { error: "invalid line" });
+				if (!body.text || typeof body.text !== "string") return json(res, 400, { error: "missing text" });
+				let source;
+				try {
+					source = await fs.readFile(file, "utf8");
+				} catch {
+					return json(res, 404, { error: "slide not found" });
+				}
+				const plan = findInsertion(source, body.line, body.column);
+				if (!plan) return json(res, 422, { error: `could not find a JSX container around line ${body.line}. Try clicking a different element.` });
+				const id = newCommentId();
+				const ts = new Date().toISOString();
+				const payload = b64urlEncode(JSON.stringify({
+					note: body.text,
+					hint: body.hint
+				}));
+				const marker = `\n${plan.indent}{/* @slide-comment id="${id}" ts="${ts}" text="${payload}" */}`;
+				const next$1 = source.slice(0, plan.offset) + marker + source.slice(plan.offset);
+				await fs.writeFile(file, next$1, "utf8");
+				const markerLine = offsetToLine(next$1, plan.offset + 1);
+				return json(res, 200, {
+					id,
+					line: markerLine
+				});
+			}
+			if (method === "DELETE" && url.pathname.startsWith("/")) {
+				const requestCheck = validateMutationRequest(req);
+				if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+				const id = url.pathname.slice(1);
+				if (!/^c-[a-f0-9]+$/.test(id)) return json(res, 400, { error: "invalid id" });
+				const slideId = url.searchParams.get("slideId") ?? "";
+				const file = resolveSlideEntryPath(ctx, slideId);
+				if (!file) return json(res, 400, { error: "invalid slideId" });
+				let source;
+				try {
+					source = await fs.readFile(file, "utf8");
+				} catch {
+					return json(res, 404, { error: "slide not found" });
+				}
+				const lines = source.split("\n");
+				const idRe = markerDeleteRegex(id);
+				const hit = lines.findIndex((l) => idRe.test(l));
+				if (hit === -1) return json(res, 404, { error: "marker not found" });
+				lines.splice(hit, 1);
+				await fs.writeFile(file, lines.join("\n"), "utf8");
+				return json(res, 200, { ok: true });
+			}
+			next();
+		} catch (err) {
+			json(res, 500, { error: String(err.message ?? err) });
+		}
+	});
+}
+
+//#endregion
+//#region src/vite/routes/edit.ts
+function registerEditRoutes(server, ctx) {
+	server.middlewares.use("/__edit", async (req, res, next) => {
+		const url = new URL(req.url ?? "/", "http://local");
+		const method = req.method ?? "GET";
+		if (method !== "POST") return next();
+		const requestCheck = validateMutationRequest(req, { requireJsonBody: true });
+		if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+		try {
+			if (url.pathname === "/") {
+				const body = await readBody(req);
+				const slideId = body.slideId ?? "";
+				const file = resolveSlideEntryPath(ctx, slideId);
+				if (!file) return json(res, 400, { error: "invalid slideId" });
+				if (!body.line || body.line < 1) return json(res, 400, { error: "invalid line" });
+				if (!Array.isArray(body.ops)) return json(res, 400, { error: "missing ops" });
+				let source;
+				try {
+					source = await fs.readFile(file, "utf8");
+				} catch {
+					return json(res, 404, { error: "slide not found" });
+				}
+				const result = applyEdit(source, body.line, body.column ?? 0, body.ops);
+				if (!result.ok) return json(res, result.status, { error: result.error });
+				const changed = result.source !== source;
+				if (changed) await fs.writeFile(file, result.source, "utf8");
+				return json(res, 200, {
+					ok: true,
+					changed
+				});
+			}
+			if (url.pathname === "/revert-asset") {
+				const body = await readBody(req);
+				const slideId = body.slideId ?? "";
+				const assetPath = body.assetPath;
+				const file = resolveSlideEntryPath(ctx, slideId);
+				if (!file) return json(res, 400, { error: "invalid slideId" });
+				if (typeof assetPath !== "string" || !assetPath) return json(res, 400, { error: "missing assetPath" });
+				if (!assetPath.startsWith("./assets/") && !assetPath.startsWith("@assets/")) return json(res, 400, { error: "asset path must start with ./assets/ or @assets/" });
+				let source;
+				try {
+					source = await fs.readFile(file, "utf8");
+				} catch {
+					return json(res, 404, { error: "slide not found" });
+				}
+				const result = applyRevertAsset(source, assetPath);
+				if (!result.ok) return json(res, result.status, { error: result.error });
+				const changed = result.source !== source;
+				if (changed) await fs.writeFile(file, result.source, "utf8");
+				return json(res, 200, {
+					ok: true,
+					changed
+				});
+			}
+			if (url.pathname === "/batch") {
+				const body = await readBody(req);
+				const slideId = body.slideId ?? "";
+				const file = resolveSlideEntryPath(ctx, slideId);
+				if (!file) return json(res, 400, { error: "invalid slideId" });
+				if (!Array.isArray(body.edits)) return json(res, 400, { error: "missing edits" });
+				let source;
+				try {
+					source = await fs.readFile(file, "utf8");
+				} catch {
+					return json(res, 404, { error: "slide not found" });
+				}
+				const original = source;
+				const results = [];
+				for (const edit of body.edits) {
+					if (!edit.line || edit.line < 1 || !Array.isArray(edit.ops)) {
+						results.push({
+							ok: false,
+							error: "invalid edit"
+						});
+						continue;
+					}
+					const r = applyEdit(source, edit.line, edit.column ?? 0, edit.ops);
+					if (r.ok) {
+						source = r.source;
+						results.push({ ok: true });
+					} else results.push({
+						ok: false,
+						error: r.error
+					});
+				}
+				const changed = source !== original;
+				if (changed) await fs.writeFile(file, source, "utf8");
+				return json(res, 200, {
+					ok: true,
+					changed,
+					results
+				});
+			}
+			return next();
+		} catch (err) {
+			json(res, 500, { error: String(err.message ?? err) });
+		}
+	});
+}
+
+//#endregion
+//#region src/files/folders.ts
+const FOLDER_ID_RE = /^f-[a-f0-9]{8}$/;
+const COLOR_RE = /^#[0-9a-fA-F]{6}$/;
+function emptyManifest() {
+	return {
+		folders: [],
+		assignments: {}
+	};
+}
+async function readManifest(file) {
+	try {
+		const raw = await fs.readFile(file, "utf8");
+		const parsed = JSON.parse(raw);
+		return {
+			folders: Array.isArray(parsed.folders) ? parsed.folders : [],
+			assignments: parsed.assignments && typeof parsed.assignments === "object" ? parsed.assignments : {}
+		};
+	} catch (err) {
+		if (err.code === "ENOENT") return emptyManifest();
+		throw err;
+	}
+}
+async function writeManifest(file, manifest) {
+	await fs.mkdir(path.dirname(file), { recursive: true });
+	await fs.writeFile(file, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+}
+function newFolderId() {
+	return `f-${randomUUID().replace(/-/g, "").slice(0, 8)}`;
+}
+function validateName(v) {
+	if (typeof v !== "string") return null;
+	const trimmed = v.trim();
+	if (trimmed.length < 1 || trimmed.length > 40) return null;
+	return trimmed;
+}
+function validateReorder(v, current) {
+	if (!Array.isArray(v) || v.length !== current.length) return null;
+	const known = new Set(current.map((f) => f.id));
+	const seen = new Set();
+	const out = [];
+	for (const id of v) {
+		if (typeof id !== "string" || !FOLDER_ID_RE.test(id)) return null;
+		if (!known.has(id) || seen.has(id)) return null;
+		seen.add(id);
+		out.push(id);
+	}
+	return out;
+}
+function validateIcon(v) {
+	if (!v || typeof v !== "object") return null;
+	const icon = v;
+	if (icon.type === "emoji") {
+		if (typeof icon.value !== "string") return null;
+		if (icon.value.length < 1 || icon.value.length > 8) return null;
+		return {
+			type: "emoji",
+			value: icon.value
+		};
+	}
+	if (icon.type === "color") {
+		if (typeof icon.value !== "string" || !COLOR_RE.test(icon.value)) return null;
+		return {
+			type: "color",
+			value: icon.value
+		};
+	}
+	return null;
+}
+
+//#endregion
+//#region src/vite/routes/folders.ts
+function registerFolderRoutes(server, ctx) {
+	server.middlewares.use("/__folders", async (req, res, next) => {
+		const url = new URL(req.url ?? "/", "http://local");
+		const method = req.method ?? "GET";
+		try {
+			if (method === "GET" && url.pathname === "/") {
+				const manifest = await readManifest(ctx.manifestPath);
+				return json(res, 200, manifest);
+			}
+			if (method === "POST" && url.pathname === "/") {
+				const requestCheck = validateMutationRequest(req, { requireJsonBody: true });
+				if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+				const body = await readBody(req);
+				const name = validateName(body.name);
+				if (!name) return json(res, 400, { error: "invalid name" });
+				const icon = validateIcon(body.icon);
+				if (!icon) return json(res, 400, { error: "invalid icon" });
+				const manifest = await readManifest(ctx.manifestPath);
+				const folder = {
+					id: newFolderId(),
+					name,
+					icon
+				};
+				manifest.folders.push(folder);
+				await writeManifest(ctx.manifestPath, manifest);
+				return json(res, 200, folder);
+			}
+			if (method === "PUT" && url.pathname === "/assign") {
+				const requestCheck = validateMutationRequest(req, { requireJsonBody: true });
+				if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+				const body = await readBody(req);
+				if (typeof body.slideId !== "string" || !SLIDE_ID_RE.test(body.slideId)) return json(res, 400, { error: "invalid slideId" });
+				const slideId = body.slideId;
+				let folderId;
+				if (body.folderId === null) folderId = null;
+				else if (typeof body.folderId === "string" && FOLDER_ID_RE.test(body.folderId)) folderId = body.folderId;
+				else return json(res, 400, { error: "invalid folderId" });
+				const manifest = await readManifest(ctx.manifestPath);
+				if (folderId && !manifest.folders.some((f) => f.id === folderId)) return json(res, 404, { error: "folder not found" });
+				if (folderId === null) delete manifest.assignments[slideId];
+				else manifest.assignments[slideId] = folderId;
+				await writeManifest(ctx.manifestPath, manifest);
+				return json(res, 200, { ok: true });
+			}
+			if (method === "PUT" && url.pathname === "/reorder") {
+				const requestCheck = validateMutationRequest(req, { requireJsonBody: true });
+				if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+				const body = await readBody(req);
+				const manifest = await readManifest(ctx.manifestPath);
+				const ids = validateReorder(body.ids, manifest.folders);
+				if (!ids) return json(res, 400, { error: "invalid ids" });
+				const byId = new Map(manifest.folders.map((f) => [f.id, f]));
+				manifest.folders = ids.map((id) => byId.get(id));
+				await writeManifest(ctx.manifestPath, manifest);
+				return json(res, 200, { ok: true });
+			}
+			const idMatch = url.pathname.match(/^\/([^/]+)$/);
+			if (idMatch) {
+				const id = idMatch[1];
+				if (!FOLDER_ID_RE.test(id)) return json(res, 400, { error: "invalid id" });
+				if (method === "PATCH") {
+					const requestCheck = validateMutationRequest(req, { requireJsonBody: true });
+					if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+					const body = await readBody(req);
+					const manifest = await readManifest(ctx.manifestPath);
+					const folder = manifest.folders.find((f) => f.id === id);
+					if (!folder) return json(res, 404, { error: "folder not found" });
+					if (body.name !== void 0) {
+						const name = validateName(body.name);
+						if (!name) return json(res, 400, { error: "invalid name" });
+						folder.name = name;
+					}
+					if (body.icon !== void 0) {
+						const icon = validateIcon(body.icon);
+						if (!icon) return json(res, 400, { error: "invalid icon" });
+						folder.icon = icon;
+					}
+					await writeManifest(ctx.manifestPath, manifest);
+					return json(res, 200, folder);
+				}
+				if (method === "DELETE") {
+					const requestCheck = validateMutationRequest(req);
+					if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+					const manifest = await readManifest(ctx.manifestPath);
+					const before = manifest.folders.length;
+					manifest.folders = manifest.folders.filter((f) => f.id !== id);
+					if (manifest.folders.length === before) return json(res, 404, { error: "folder not found" });
+					for (const [slideId, folderId] of Object.entries(manifest.assignments)) if (folderId === id) delete manifest.assignments[slideId];
+					await writeManifest(ctx.manifestPath, manifest);
+					return json(res, 200, { ok: true });
+				}
+			}
+			next();
+		} catch (err) {
+			json(res, 500, { error: String(err.message ?? err) });
+		}
+	});
+}
+
+//#endregion
+//#region src/vite/routes/slides.ts
+function registerSlideRoutes(server, ctx) {
+	server.middlewares.use("/__slides", async (req, res, next) => {
+		const url = new URL(req.url ?? "/", "http://local");
+		const method = req.method ?? "GET";
+		try {
+			const reorderMatch = url.pathname.match(/^\/([^/]+)\/reorder$/);
+			if (reorderMatch && method === "PUT") {
+				const requestCheck = validateMutationRequest(req, { requireJsonBody: true });
+				if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+				const slideId$1 = reorderMatch[1];
+				if (!SLIDE_ID_RE.test(slideId$1)) return json(res, 400, { error: "invalid slideId" });
+				const body = await readBody(req);
+				if (!Array.isArray(body.order)) return json(res, 400, { error: "invalid order" });
+				const order = [];
+				for (const v of body.order) {
+					if (!Number.isInteger(v)) return json(res, 400, { error: "invalid order" });
+					order.push(v);
+				}
+				const entry = resolveSlideEntry(ctx.slidesRoot, slideId$1);
+				if (!entry) return json(res, 400, { error: "invalid slideId" });
+				let source;
+				try {
+					source = await fs.readFile(entry, "utf8");
+				} catch {
+					return json(res, 404, { error: "slide not found" });
+				}
+				const reordered = reorderDefaultExportPagesInSource(source, order);
+				if (reordered === null) return json(res, 422, { error: "could not reorder pages — order must be a permutation of the existing array" });
+				const withNotes = reorderNotesArrayInSource(reordered, order);
+				if (withNotes === null) return json(res, 422, { error: "could not reorder pages — `notes` export has an unexpected shape" });
+				if (withNotes !== source) await fs.writeFile(entry, withNotes, "utf8");
+				return json(res, 200, {
+					ok: true,
+					slideId: slideId$1,
+					order
+				});
+			}
+			const pageOpMatch = url.pathname.match(/^\/([^/]+)\/pages\/(\d+)(?:\/([a-z]+))?$/);
+			if (pageOpMatch) {
+				const slideId$1 = pageOpMatch[1];
+				const pageIndex = Number.parseInt(pageOpMatch[2], 10);
+				const op = pageOpMatch[3];
+				if (!SLIDE_ID_RE.test(slideId$1)) return json(res, 400, { error: "invalid slideId" });
+				if (!Number.isInteger(pageIndex) || pageIndex < 0) return json(res, 400, { error: "invalid page index" });
+				const isDelete = method === "DELETE" && !op;
+				const isDuplicate = method === "POST" && op === "duplicate";
+				if (!isDelete && !isDuplicate) return next();
+				const requestCheck = validateMutationRequest(req);
+				if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+				const entry = resolveSlideEntry(ctx.slidesRoot, slideId$1);
+				if (!entry) return json(res, 400, { error: "invalid slideId" });
+				let source;
+				try {
+					source = await fs.readFile(entry, "utf8");
+				} catch {
+					return json(res, 404, { error: "slide not found" });
+				}
+				const updated = isDelete ? removePageFromDefaultExportInSource(source, pageIndex) : duplicatePageInDefaultExportInSource(source, pageIndex);
+				if (updated === null) return json(res, 422, { error: isDelete ? "could not delete page — index out of range or default export is not an array" : "could not duplicate page — index out of range or default export is not an array" });
+				const withNotes = isDelete ? removeNotesElementInSource(updated, pageIndex) : duplicateNotesElementInSource(updated, pageIndex);
+				if (withNotes === null) return json(res, 422, { error: isDelete ? "could not delete page — `notes` export has an unexpected shape" : "could not duplicate page — `notes` export has an unexpected shape" });
+				if (withNotes !== source) await fs.writeFile(entry, withNotes, "utf8");
+				return json(res, 200, {
+					ok: true,
+					slideId: slideId$1,
+					index: pageIndex
+				});
+			}
+			const duplicateMatch = url.pathname.match(/^\/([^/]+)\/duplicate$/);
+			if (duplicateMatch && method === "POST") {
+				const requestCheck = validateMutationRequest(req);
+				if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+				const slideId$1 = duplicateMatch[1];
+				if (!SLIDE_ID_RE.test(slideId$1)) return json(res, 400, { error: "invalid slideId" });
+				const body = await readBody(req);
+				if (body.newId !== void 0 && typeof body.newId !== "string") return json(res, 400, { error: "invalid newId" });
+				const duplicated = await duplicateSlideDir(ctx.slidesRoot, slideId$1, body.newId);
+				if (!duplicated.ok) return json(res, duplicated.status, { error: duplicated.error });
+				const manifest = await readManifest(ctx.manifestPath);
+				const folderId = manifest.assignments[slideId$1];
+				if (folderId) {
+					manifest.assignments[duplicated.slideId] = folderId;
+					await writeManifest(ctx.manifestPath, manifest);
+				}
+				return json(res, 200, {
+					ok: true,
+					slideId: duplicated.slideId
+				});
+			}
+			const idMatch = url.pathname.match(/^\/([^/]+)$/);
+			if (!idMatch) return next();
+			const slideId = idMatch[1];
+			if (!SLIDE_ID_RE.test(slideId)) return json(res, 400, { error: "invalid slideId" });
+			if (method === "PATCH") {
+				const requestCheck = validateMutationRequest(req, { requireJsonBody: true });
+				if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+				const body = await readBody(req);
+				const name = validateSlideName(body.name);
+				if (!name) return json(res, 400, { error: "invalid name" });
+				const entry = resolveSlideEntry(ctx.slidesRoot, slideId);
+				if (!entry) return json(res, 400, { error: "invalid slideId" });
+				let source;
+				try {
+					source = await fs.readFile(entry, "utf8");
+				} catch {
+					return json(res, 404, { error: "slide not found" });
+				}
+				const updated = updateMetaTitleInSource(source, name);
+				if (updated === null) return json(res, 422, { error: "could not locate a safe place to write meta.title in index.tsx" });
+				if (updated !== source) await fs.writeFile(entry, updated, "utf8");
+				server.ws.send({ type: "full-reload" });
+				return json(res, 200, {
+					ok: true,
+					slideId,
+					name
+				});
+			}
+			if (method === "DELETE") {
+				const requestCheck = validateMutationRequest(req);
+				if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+				const removed = await rmSlideDir(ctx.slidesRoot, slideId);
+				if (!removed) return json(res, 404, { error: "slide not found" });
+				const manifest = await readManifest(ctx.manifestPath);
+				delete manifest.assignments[slideId];
+				await writeManifest(ctx.manifestPath, manifest);
+				return json(res, 200, { ok: true });
+			}
+			return next();
+		} catch (err) {
+			json(res, 500, { error: String(err.message ?? err) });
+		}
+	});
+}
+
+//#endregion
+//#region src/vite/routes/svgl.ts
+function registerSvglRoutes(server) {
+	server.middlewares.use("/__svgl", async (req, res, next) => {
+		const reqUrl = new URL(req.url ?? "/", "http://local");
+		const method = req.method ?? "GET";
+		if (method !== "GET") return next();
+		try {
+			let target = null;
+			if (reqUrl.pathname === "/search") {
+				const params = new URLSearchParams();
+				const q = reqUrl.searchParams.get("q");
+				const limit = reqUrl.searchParams.get("limit");
+				if (q) params.set("search", q);
+				if (limit) params.set("limit", limit);
+				const qs = params.toString();
+				target = `https://api.svgl.app/${qs ? `?${qs}` : ""}`;
+			} else if (reqUrl.pathname === "/svg") {
+				const u = reqUrl.searchParams.get("u");
+				if (!u) return json(res, 400, { error: "missing u" });
+				let parsed;
+				try {
+					parsed = new URL(u);
+				} catch {
+					return json(res, 400, { error: "invalid u" });
+				}
+				if (parsed.protocol !== "https:") return json(res, 400, { error: "https only" });
+				const host = parsed.hostname.toLowerCase();
+				if (host !== "svgl.app" && !host.endsWith(".svgl.app")) return json(res, 400, { error: "host not allowed" });
+				target = parsed.toString();
+			} else return next();
+			const upstream = await fetch(target);
+			const ct = upstream.headers.get("content-type") ?? "application/octet-stream";
+			res.statusCode = upstream.status;
+			res.setHeader("content-type", ct);
+			res.setHeader("cache-control", "no-store");
+			const buf = Buffer.from(await upstream.arrayBuffer());
+			res.end(buf);
+		} catch (err) {
+			json(res, 502, { error: String(err.message ?? err) });
+		}
+	});
+}
+
+//#endregion
+//#region src/vite/routes/update.ts
+const PKG = "@open-aippt/core";
+const CACHE_TTL_MS = 10 * 60 * 1e3;
+const COMMAND_TIMEOUT_MS = 3e5;
+let cache = null;
+let updateInFlight = null;
+function parseSemver(v) {
+	const m = /^v?(\d+)\.(\d+)\.(\d+)/.exec(v.trim());
+	if (!m) return null;
+	return [
+		Number(m[1]),
+		Number(m[2]),
+		Number(m[3])
+	];
+}
+function isOutdated(current, latest) {
+	const a = parseSemver(current);
+	const b = parseSemver(latest);
+	if (!a || !b) return false;
+	for (let i = 0; i < 3; i++) {
+		if (b[i] > a[i]) return true;
+		if (b[i] < a[i]) return false;
+	}
+	return false;
+}
+async function fetchLatest(now) {
+	if (cache && now - cache.at < CACHE_TTL_MS) return cache.latest;
+	try {
+		const res = await fetch(`https://registry.npmjs.org/${PKG}/latest`, {
+			signal: AbortSignal.timeout(3e3),
+			headers: { accept: "application/json" }
+		});
+		if (!res.ok) throw new Error(`registry ${res.status}`);
+		const body = await res.json();
+		const latest = typeof body.version === "string" ? body.version : null;
+		cache = {
+			at: now,
+			latest
+		};
+		return latest;
+	} catch {
+		return cache?.latest ?? null;
+	}
+}
+async function fileExists(file) {
+	try {
+		await fs.access(file);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function detectPackageManager(cwd) {
+	const ua = process.env.npm_config_user_agent ?? "";
+	if (ua.startsWith("pnpm")) return "pnpm";
+	if (ua.startsWith("yarn")) return "yarn";
+	if (ua.startsWith("bun")) return "bun";
+	if (ua.startsWith("npm")) return "npm";
+	if (await fileExists(path.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+	if (await fileExists(path.join(cwd, "yarn.lock"))) return "yarn";
+	if (await fileExists(path.join(cwd, "bun.lockb"))) return "bun";
+	if (await fileExists(path.join(cwd, "bun.lock"))) return "bun";
+	if (await fileExists(path.join(cwd, "package-lock.json"))) return "npm";
+	return "npm";
+}
+function updateCommandFor(packageManager) {
+	switch (packageManager) {
+		case "pnpm": return {
+			cmd: "pnpm",
+			args: ["add", `${PKG}@latest`]
+		};
+		case "yarn": return {
+			cmd: "yarn",
+			args: ["add", `${PKG}@latest`]
+		};
+		case "bun": return {
+			cmd: "bun",
+			args: ["add", `${PKG}@latest`]
+		};
+		case "npm": return {
+			cmd: "npm",
+			args: ["install", `${PKG}@latest`]
+		};
+	}
+}
+function localOpenAipptCommand(cwd) {
+	const bin = process.platform === "win32" ? "open-aippt.cmd" : "open-aippt";
+	return {
+		cmd: path.join(cwd, "node_modules", ".bin", bin),
+		args: ["sync:skills"]
+	};
+}
+function formatCommand(spec) {
+	return [spec.cmd, ...spec.args].join(" ");
+}
+async function runCommand(spec, cwd) {
+	await new Promise((resolve, reject) => {
+		const child = spawn(spec.cmd, spec.args, {
+			cwd,
+			env: process.env,
+			shell: process.platform === "win32",
+			stdio: [
+				"ignore",
+				"ignore",
+				"pipe"
+			]
+		});
+		let stderr = "";
+		const timer = setTimeout(() => {
+			child.kill();
+			reject(new Error(`${formatCommand(spec)} timed out`));
+		}, COMMAND_TIMEOUT_MS);
+		child.stderr.on("data", (chunk) => {
+			stderr += chunk.toString("utf8");
+			if (stderr.length > 2e3) stderr = stderr.slice(-2e3);
+		});
+		child.on("error", (err) => {
+			clearTimeout(timer);
+			reject(err);
+		});
+		child.on("close", (code) => {
+			clearTimeout(timer);
+			if (code === 0) {
+				resolve();
+				return;
+			}
+			const detail = stderr.trim();
+			reject(new Error(detail || `${formatCommand(spec)} exited with code ${code ?? "unknown"}`));
+		});
+	});
+}
+async function updatePackage(ctx) {
+	const packageManager = await detectPackageManager(ctx.userCwd);
+	const updateCommand = updateCommandFor(packageManager);
+	const syncCommand = localOpenAipptCommand(ctx.userCwd);
+	await runCommand(updateCommand, ctx.userCwd);
+	await runCommand(syncCommand, ctx.userCwd);
+	cache = null;
+	const latest = await fetchLatest(Date.now());
+	return {
+		packageManager,
+		command: `${formatCommand(updateCommand)} && open-aippt sync:skills`,
+		latest,
+		message: "Updated @open-aippt/core and synced skills."
+	};
+}
+function registerUpdateRoutes(server, ctx) {
+	server.middlewares.use("/__update-check", async (req, res, next) => {
+		if ((req.method ?? "GET") !== "GET") return next();
+		const latest = await fetchLatest(Date.now());
+		const result = {
+			current: ctx.coreVersion,
+			latest,
+			outdated: latest ? isOutdated(ctx.coreVersion, latest) : false
+		};
+		res.setHeader("cache-control", "no-store");
+		json(res, 200, result);
+	});
+	server.middlewares.use("/__update-package", async (req, res, next) => {
+		if ((req.method ?? "GET") !== "POST") return next();
+		const guard = validateMutationRequest(req);
+		if (!guard.ok) return json(res, guard.status, { error: guard.error });
+		try {
+			updateInFlight ??= updatePackage(ctx).finally(() => {
+				updateInFlight = null;
+			});
+			const result = await updateInFlight;
+			json(res, 200, result);
+		} catch (err) {
+			json(res, 500, { error: err instanceof Error ? err.message : "update failed" });
+		}
+	});
+}
+
+//#endregion
+//#region src/vite/routes/watchers.ts
+function registerWatchers(server, ctx) {
+	server.watcher.add(ctx.manifestPath);
+	server.watcher.on("change", (p) => {
+		if (p === ctx.manifestPath) server.ws.send({
+			type: "custom",
+			event: "open-aippt:files-changed"
+		});
+	});
+	server.watcher.add(ctx.globalAssetsRoot);
+	const onAssetChange = (p) => {
+		if (p.startsWith(ctx.globalAssetsRoot + path.sep) || p === ctx.globalAssetsRoot) {
+			server.ws.send({
+				type: "custom",
+				event: "open-aippt:assets-changed",
+				data: { slideId: GLOBAL_SCOPE }
+			});
+			return;
+		}
+		if (!p.startsWith(ctx.slidesRoot + path.sep)) return;
+		const rel = p.slice(ctx.slidesRoot.length + 1);
+		const parts = rel.split(path.sep);
+		if (parts.length < 3 || parts[1] !== "assets") return;
+		const slideId = parts[0];
+		if (!SLIDE_ID_RE.test(slideId)) return;
+		server.ws.send({
+			type: "custom",
+			event: "open-aippt:assets-changed",
+			data: { slideId }
+		});
+	};
+	server.watcher.on("add", onAssetChange);
+	server.watcher.on("change", onAssetChange);
+	server.watcher.on("unlink", onAssetChange);
+}
+
+//#endregion
+//#region src/vite/api-plugin.ts
+function apiPlugin(opts) {
+	return {
+		name: "open-aippt:api",
+		apply: "serve",
+		configureServer(server) {
+			const ctx = makeContext(opts);
+			registerWatchers(server, ctx);
+			registerEditRoutes(server, ctx);
+			registerCommentRoutes(server, ctx);
+			registerSlideRoutes(server, ctx);
+			registerAssetRoutes(server, ctx);
+			registerSvglRoutes(server);
+			registerFolderRoutes(server, ctx);
+			registerUpdateRoutes(server, ctx);
+		}
+	};
+}
+
+//#endregion
+//#region src/vite/current-plugin.ts
+const TEXT_SNIPPET_MAX = 120;
+function parseSelection(raw) {
+	if (raw == null || typeof raw !== "object") return null;
+	const sel = raw;
+	if (typeof sel.line !== "number" || !Number.isFinite(sel.line)) return null;
+	if (typeof sel.column !== "number" || !Number.isFinite(sel.column)) return null;
+	const tagName = typeof sel.tagName === "string" ? sel.tagName.toLowerCase().slice(0, 32) : "unknown";
+	const text = typeof sel.text === "string" ? sel.text.replace(/\s+/g, " ").trim().slice(0, TEXT_SNIPPET_MAX) : "";
+	return {
+		line: Math.max(1, Math.floor(sel.line)),
+		column: Math.max(0, Math.floor(sel.column)),
+		tagName,
+		text
+	};
+}
+function currentPlugin(opts) {
+	const userCwd = opts.userCwd;
+	const slidesDir = opts.slidesDir ?? "slides";
+	const outDir = path.join(userCwd, "node_modules", ".open-aippt");
+	const outFile = path.join(outDir, "current.json");
+	const tmpFile = `${outFile}.tmp`;
+	let cached = null;
+	return {
+		name: "open-aippt:current",
+		apply: "serve",
+		configureServer(server) {
+			server.ws.on("open-aippt:current", async (raw) => {
+				const next = cached ? { ...cached } : {
+					slideId: "",
+					pageIndex: 0,
+					pageNumber: 1,
+					totalPages: 1,
+					slideTitle: "",
+					view: "slides",
+					pagePath: "",
+					selection: null
+				};
+				if (typeof raw?.slideId === "string") {
+					if (!SLIDE_ID_RE.test(raw.slideId)) return;
+					const totalPages = typeof raw.totalPages === "number" && Number.isFinite(raw.totalPages) && raw.totalPages > 0 ? Math.floor(raw.totalPages) : 1;
+					const rawIndex = typeof raw.pageIndex === "number" && Number.isFinite(raw.pageIndex) ? Math.floor(raw.pageIndex) : 0;
+					const pageIndex = Math.max(0, Math.min(totalPages - 1, rawIndex));
+					const slideTitle = typeof raw.slideTitle === "string" ? raw.slideTitle : raw.slideId;
+					const view = raw.view === "assets" ? "assets" : "slides";
+					const pagePath = path.join(slidesDir, raw.slideId, "index.tsx").split(path.sep).join("/");
+					if (cached?.slideId !== raw.slideId || cached?.pageIndex !== pageIndex) next.selection = null;
+					next.slideId = raw.slideId;
+					next.pageIndex = pageIndex;
+					next.pageNumber = pageIndex + 1;
+					next.totalPages = totalPages;
+					next.slideTitle = slideTitle;
+					next.view = view;
+					next.pagePath = pagePath;
+				}
+				if ("selection" in raw) next.selection = parseSelection(raw.selection);
+				if (!next.slideId) return;
+				cached = next;
+				const body = {
+					...next,
+					updatedAt: new Date().toISOString()
+				};
+				try {
+					await fs.mkdir(outDir, { recursive: true });
+					await fs.writeFile(tmpFile, `${JSON.stringify(body, null, 2)}\n`, "utf8");
+					await fs.rename(tmpFile, outFile);
+				} catch {}
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/vite/design-plugin.ts
+function parseSource$1(source) {
+	try {
+		return parse(source, {
+			sourceType: "module",
+			plugins: ["typescript", "jsx"],
+			errorRecovery: true
+		});
+	} catch {
+		return null;
+	}
+}
+function findDesignDecl(ast) {
+	const body = ast.program?.body ?? [];
+	for (const node of body) {
+		let varDecl = null;
+		if (node.type === "VariableDeclaration") varDecl = node;
+		else if (node.type === "ExportNamedDeclaration") {
+			const decl = node.declaration;
+			if (decl?.type === "VariableDeclaration") varDecl = decl;
+		}
+		if (!varDecl) continue;
+		const declarations = varDecl.declarations ?? [];
+		for (const d of declarations) {
+			const id = d.id;
+			if (!id || id.type !== "Identifier" || id.name !== "design") continue;
+			const init = d.init;
+			if (!init) return null;
+			let inner = init;
+			if (inner.type === "TSSatisfiesExpression" || inner.type === "TSAsExpression") {
+				const expr = inner.expression;
+				if (expr) inner = expr;
+			}
+			if (inner.type !== "ObjectExpression") return null;
+			return {
+				declStart: node.start,
+				declEnd: node.end,
+				objectStart: inner.start,
+				objectEnd: inner.end
+			};
+		}
+	}
+	return null;
+}
+function literalToValue(node) {
+	switch (node.type) {
+		case "StringLiteral": return node.value;
+		case "NumericLiteral": return node.value;
+		case "BooleanLiteral": return node.value;
+		case "NullLiteral": return null;
+		case "UnaryExpression": {
+			const op = node.operator;
+			const arg = node.argument;
+			const v = literalToValue(arg);
+			if (op === "-" && typeof v === "number") return -v;
+			if (op === "+" && typeof v === "number") return v;
+			throw new Error(`unsupported unary operator ${op}`);
+		}
+		case "TemplateLiteral": {
+			const quasis = node.quasis;
+			const expressions = node.expressions;
+			if (expressions.length > 0) throw new Error("template literal has expressions");
+			return quasis[0].value.cooked ?? quasis[0].value.raw;
+		}
+		case "ArrayExpression": {
+			const elements = node.elements;
+			return elements.map((el) => {
+				if (!el) throw new Error("array has hole");
+				return literalToValue(el);
+			});
+		}
+		case "ObjectExpression": {
+			const properties = node.properties;
+			const out = {};
+			for (const prop of properties) {
+				if (prop.type !== "ObjectProperty") throw new Error("object has spread or method");
+				const p = prop;
+				if (p.computed) throw new Error("object has computed key");
+				let key;
+				if (p.key.type === "Identifier" && typeof p.key.name === "string") key = p.key.name;
+				else if (p.key.type === "StringLiteral" && typeof p.key.value === "string") key = p.key.value;
+				else throw new Error("unsupported object key");
+				out[key] = literalToValue(p.value);
+			}
+			return out;
+		}
+		default: throw new Error(`unsupported node type ${node.type}`);
+	}
+}
+function isPlainObject(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function mergeDesign(base, patch) {
+	const out = JSON.parse(JSON.stringify(base));
+	const apply = (target, src) => {
+		for (const [k, v] of Object.entries(src)) if (isPlainObject(v) && isPlainObject(target[k])) apply(target[k], v);
+		else target[k] = v;
+	};
+	if (isPlainObject(patch)) apply(out, patch);
+	return out;
+}
+function indent(level) {
+	return "  ".repeat(level);
+}
+function jsString(s) {
+	return `'${s.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n")}'`;
+}
+function isValidIdentifier(name) {
+	return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name);
+}
+function serializeValue(value, level) {
+	if (value === null) return "null";
+	if (typeof value === "string") return jsString(value);
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw new Error("non-finite number");
+		return String(value);
+	}
+	if (typeof value === "boolean") return value ? "true" : "false";
+	if (Array.isArray(value)) {
+		if (value.length === 0) return "[]";
+		const inner = value.map((el) => serializeValue(el, level + 1)).join(", ");
+		return `[${inner}]`;
+	}
+	if (isPlainObject(value)) {
+		const entries = Object.entries(value);
+		if (entries.length === 0) return "{}";
+		const childIndent = indent(level + 1);
+		const lines = entries.map(([k, v]) => {
+			const key = isValidIdentifier(k) ? k : jsString(k);
+			return `${childIndent}${key}: ${serializeValue(v, level + 1)},`;
+		});
+		return `{\n${lines.join("\n")}\n${indent(level)}}`;
+	}
+	throw new Error(`unsupported value type ${typeof value}`);
+}
+function serializeDesign(design) {
+	return serializeValue(design, 0);
+}
+function parseSlideDesign(source) {
+	const ast = parseSource$1(source);
+	if (!ast) return {
+		ok: false,
+		exists: true,
+		error: "could not parse slide source"
+	};
+	const loc = findDesignDecl(ast);
+	if (!loc) return {
+		ok: false,
+		exists: false
+	};
+	const objectNode = findDesignObjectNode(ast);
+	if (!objectNode) return {
+		ok: false,
+		exists: true,
+		error: "design has unsupported initializer"
+	};
+	let value;
+	try {
+		value = literalToValue(objectNode);
+	} catch (err) {
+		return {
+			ok: false,
+			exists: true,
+			error: err.message
+		};
+	}
+	const merged = mergeDesign(defaultDesign, value);
+	return {
+		ok: true,
+		design: merged,
+		loc
+	};
+}
+function findDesignObjectNode(ast) {
+	const body = ast.program?.body ?? [];
+	for (const node of body) {
+		let varDecl = null;
+		if (node.type === "VariableDeclaration") varDecl = node;
+		else if (node.type === "ExportNamedDeclaration") {
+			const decl = node.declaration;
+			if (decl?.type === "VariableDeclaration") varDecl = decl;
+		}
+		if (!varDecl) continue;
+		const declarations = varDecl.declarations ?? [];
+		for (const d of declarations) {
+			const id = d.id;
+			if (!id || id.type !== "Identifier" || id.name !== "design") continue;
+			const init = d.init;
+			if (!init) return null;
+			let inner = init;
+			if (inner.type === "TSSatisfiesExpression" || inner.type === "TSAsExpression") {
+				const expr = inner.expression;
+				if (expr) inner = expr;
+			}
+			if (inner.type !== "ObjectExpression") return null;
+			return inner;
+		}
+	}
+	return null;
+}
+function findImports(ast) {
+	const body = ast.program?.body ?? [];
+	const out = [];
+	for (const node of body) {
+		if (node.type !== "ImportDeclaration") continue;
+		const src = node.source?.value;
+		if (typeof src !== "string") continue;
+		const specs = node.specifiers ?? [];
+		out.push({
+			node,
+			source: src,
+			specifiers: specs
+		});
+	}
+	return out;
+}
+function ensureDesignSystemImport(source, ast) {
+	const imports = findImports(ast);
+	const coreImport = imports.find((imp) => imp.source === "@open-aippt/core");
+	if (coreImport) {
+		const hasDesignSystem = coreImport.specifiers.some((spec) => {
+			if (spec.type !== "ImportSpecifier") return false;
+			const imported = spec.imported;
+			return imported?.name === "DesignSystem";
+		});
+		if (hasDesignSystem) return {
+			source,
+			offsetShift: 0
+		};
+		const node = coreImport.node;
+		const importText = source.slice(node.start, node.end);
+		const braceClose = importText.lastIndexOf("}");
+		if (braceClose === -1) return {
+			source,
+			offsetShift: 0
+		};
+		const absoluteBrace = node.start + braceClose;
+		const insertText = coreImport.specifiers.length > 0 ? ", type DesignSystem" : "type DesignSystem";
+		const next$1 = `${source.slice(0, absoluteBrace)}${insertText}${source.slice(absoluteBrace)}`;
+		return {
+			source: next$1,
+			offsetShift: insertText.length
+		};
+	}
+	const stmt = `import type { DesignSystem } from '@open-aippt/core';\n`;
+	if (imports.length > 0) {
+		const last = imports[imports.length - 1];
+		const insertAt = last.node.end;
+		const trail = source[insertAt] === "\n" ? "" : "\n";
+		const next$1 = `${source.slice(0, insertAt)}\n${stmt.slice(0, -1)}${trail}${source.slice(insertAt)}`;
+		return {
+			source: next$1,
+			offsetShift: 1 + stmt.length - (trail ? 0 : 1)
+		};
+	}
+	const next = `${stmt}\n${source}`;
+	return {
+		source: next,
+		offsetShift: stmt.length + 1
+	};
+}
+function findInsertionPoint(source, ast) {
+	const imports = findImports(ast);
+	if (imports.length === 0) return 0;
+	const last = imports[imports.length - 1];
+	let off = last.node.end;
+	while (off < source.length && source[off] !== "\n") off++;
+	if (off < source.length) off++;
+	return off;
+}
+function applyDesignWrite(source, next) {
+	let body;
+	try {
+		body = serializeDesign(next);
+	} catch (err) {
+		return {
+			ok: false,
+			status: 422,
+			error: `serialize failed: ${err.message}`
+		};
+	}
+	const ast = parseSource$1(source);
+	if (!ast) return {
+		ok: false,
+		status: 422,
+		error: "could not parse slide source"
+	};
+	const loc = findDesignDecl(ast);
+	if (loc) {
+		const out$1 = source.slice(0, loc.objectStart) + body + source.slice(loc.objectEnd);
+		return {
+			ok: true,
+			source: out$1,
+			created: false
+		};
+	}
+	const withImport = ensureDesignSystemImport(source, ast);
+	const ast2 = parseSource$1(withImport.source);
+	if (!ast2) return {
+		ok: false,
+		status: 422,
+		error: "failed to re-parse after adding import"
+	};
+	const insertAt = findInsertionPoint(withImport.source, ast2);
+	const block = `\nconst design: DesignSystem = ${body};\n`;
+	const out = withImport.source.slice(0, insertAt) + block + withImport.source.slice(insertAt);
+	return {
+		ok: true,
+		source: out,
+		created: true
+	};
+}
+function designPlugin(opts) {
+	const userCwd = opts.userCwd;
+	const slidesDir = opts.slidesDir ?? "slides";
+	return {
+		name: "open-aippt:design",
+		apply: "serve",
+		configureServer(server) {
+			server.middlewares.use("/__design", async (req, res, next) => {
+				const url = new URL(req.url ?? "/", "http://local");
+				const method = req.method ?? "GET";
+				const slideId = url.searchParams.get("slideId") ?? "";
+				const file = resolveSlidePath(userCwd, slidesDir, slideId);
+				if (!file) return json(res, 400, { error: "invalid slideId" });
+				try {
+					if (method === "GET" && url.pathname === "/") {
+						let source;
+						try {
+							source = await fs.readFile(file, "utf8");
+						} catch {
+							return json(res, 404, { error: "slide not found" });
+						}
+						const parsed = parseSlideDesign(source);
+						if (parsed.ok) return json(res, 200, {
+							design: parsed.design,
+							exists: true,
+							warning: null
+						});
+						if (parsed.exists === false) return json(res, 200, {
+							design: defaultDesign,
+							exists: false,
+							warning: null
+						});
+						return json(res, 200, {
+							design: defaultDesign,
+							exists: true,
+							warning: parsed.error
+						});
+					}
+					if (method === "PUT" && url.pathname === "/") {
+						const requestCheck = validateMutationRequest(req, { requireJsonBody: true });
+						if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+						const body = await readBody(req);
+						const patch = body.patch;
+						if (!patch || typeof patch !== "object") return json(res, 400, { error: "missing patch object" });
+						let source;
+						try {
+							source = await fs.readFile(file, "utf8");
+						} catch {
+							return json(res, 404, { error: "slide not found" });
+						}
+						const parsed = parseSlideDesign(source);
+						const baseDesign = parsed.ok ? parsed.design : defaultDesign;
+						if (!parsed.ok && parsed.exists) return json(res, 422, { error: parsed.error });
+						const merged = mergeDesign(baseDesign, patch);
+						const written = applyDesignWrite(source, merged);
+						if (!written.ok) return json(res, written.status, { error: written.error });
+						if (written.source !== source) await fs.writeFile(file, written.source, "utf8");
+						return json(res, 200, {
+							ok: true,
+							design: merged,
+							created: written.created
+						});
+					}
+					if (method === "POST" && url.pathname === "/reset") {
+						const requestCheck = validateMutationRequest(req);
+						if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+						let source;
+						try {
+							source = await fs.readFile(file, "utf8");
+						} catch {
+							return json(res, 404, { error: "slide not found" });
+						}
+						const written = applyDesignWrite(source, defaultDesign);
+						if (!written.ok) return json(res, written.status, { error: written.error });
+						if (written.source !== source) await fs.writeFile(file, written.source, "utf8");
+						return json(res, 200, {
+							ok: true,
+							design: defaultDesign,
+							created: written.created
+						});
+					}
+					return next();
+				} catch (err) {
+					json(res, 500, { error: String(err.message ?? err) });
+				}
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/vite/loc-tags-plugin.ts
+const FORWARDING_COMPONENTS = new Set(["ImagePlaceholder"]);
+function isTaggableJsxName(name) {
+	if (!t$1.isJSXIdentifier(name)) return false;
+	return /^[a-z]/.test(name.name) || FORWARDING_COMPONENTS.has(name.name);
+}
+function alreadyTagged(opening) {
+	return opening.attributes.some((attr) => t$1.isJSXAttribute(attr) && t$1.isJSXIdentifier(attr.name) && attr.name.name === "data-slide-loc");
+}
+function injectLocTags(code) {
+	let ast;
+	try {
+		ast = parse(code, {
+			sourceType: "module",
+			plugins: ["typescript", "jsx"],
+			errorRecovery: true
+		});
+	} catch {
+		return null;
+	}
+	const insertions = [];
+	walkJsx(ast, (node) => {
+		if (!t$1.isJSXElement(node) || !node.loc) return;
+		const opening = node.openingElement;
+		const name = opening.name;
+		if (!isTaggableJsxName(name) || alreadyTagged(opening)) return;
+		insertions.push({
+			offset: name.end ?? 0,
+			text: ` data-slide-loc="${node.loc.start.line}:${node.loc.start.column}"`
+		});
+	});
+	if (insertions.length === 0) return null;
+	insertions.sort((a, b) => b.offset - a.offset);
+	let next = code;
+	for (const ins of insertions) next = next.slice(0, ins.offset) + ins.text + next.slice(ins.offset);
+	return next;
+}
+function isSlideSourceFile(id, slidesRootPosix) {
+	const filePath = id.split(/[?#]/)[0].replace(/\\/g, "/");
+	if (!filePath.startsWith(`${slidesRootPosix}/`)) return false;
+	if (!filePath.endsWith(".tsx")) return false;
+	if (filePath.endsWith(".d.ts") || filePath.endsWith(".test.tsx")) return false;
+	const rel = filePath.slice(slidesRootPosix.length + 1);
+	return rel.includes("/");
+}
+function locTagsPlugin(opts) {
+	const slidesRoot = path.resolve(opts.userCwd, opts.slidesDir ?? "slides").replace(/\\/g, "/");
+	return {
+		name: "open-aippt:loc-tags",
+		apply: "serve",
+		enforce: "pre",
+		transform(code, id) {
+			if (!isSlideSourceFile(id, slidesRoot)) return null;
+			const next = injectLocTags(code);
+			if (next === null) return null;
+			return {
+				code: next,
+				map: null
+			};
+		}
+	};
+}
+
+//#endregion
+//#region src/vite/notes-plugin.ts
+function parseSource(source) {
+	try {
+		return parse(source, {
+			sourceType: "module",
+			plugins: ["typescript", "jsx"],
+			errorRecovery: true
+		});
+	} catch {
+		return null;
+	}
+}
+function findNotesExport(ast) {
+	for (const stmt of ast.program.body) {
+		if (!t.isExportNamedDeclaration(stmt)) continue;
+		const decl = stmt.declaration;
+		if (!decl || !t.isVariableDeclaration(decl)) continue;
+		for (const d of decl.declarations) {
+			if (!t.isVariableDeclarator(d)) continue;
+			if (!t.isIdentifier(d.id) || d.id.name !== "notes") continue;
+			if (!d.init) return { error: "`notes` export has no initializer" };
+			if (!t.isArrayExpression(d.init)) return { error: "`notes` export is not an array literal" };
+			const arr = d.init;
+			if (typeof stmt.start !== "number" || typeof stmt.end !== "number") return { error: "`notes` export missing source range" };
+			if (typeof arr.start !== "number" || typeof arr.end !== "number") return { error: "`notes` array missing source range" };
+			return {
+				declStart: stmt.start,
+				declEnd: stmt.end,
+				arrayStart: arr.start,
+				arrayEnd: arr.end,
+				elements: arr.elements
+			};
+		}
+	}
+	return null;
+}
+function renderNoteLiteral(text) {
+	if (text === "") return "undefined";
+	const hasNewline = /\n/.test(text);
+	if (hasNewline) {
+		const escaped = text.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+		return `\`${escaped}\``;
+	}
+	return JSON.stringify(text);
+}
+function findInsertionOffset(ast, source) {
+	let lastImportEnd = -1;
+	for (const stmt of ast.program.body) if (t.isImportDeclaration(stmt) && typeof stmt.end === "number") lastImportEnd = Math.max(lastImportEnd, stmt.end);
+	if (lastImportEnd >= 0) return lastImportEnd;
+	return source.length;
+}
+function applyNotesEdit(source, index, text) {
+	if (!Number.isInteger(index) || index < 0) return {
+		ok: false,
+		status: 400,
+		error: "invalid index"
+	};
+	const ast = parseSource(source);
+	if (!ast) return {
+		ok: false,
+		status: 422,
+		error: "could not parse source"
+	};
+	const found = findNotesExport(ast);
+	if (found && "error" in found) return {
+		ok: false,
+		status: 422,
+		error: found.error
+	};
+	const literal = renderNoteLiteral(text);
+	if (!found) {
+		if (text === "") return {
+			ok: true,
+			source
+		};
+		const padding = Array.from({ length: index }, () => "undefined");
+		const items = [...padding, literal];
+		const block = [
+			"",
+			"",
+			"export const notes: (string | undefined)[] = [",
+			...items.map((s) => `  ${s},`),
+			"];",
+			""
+		].join("\n");
+		const offset = findInsertionOffset(ast, source);
+		const next$1 = source.slice(0, offset) + block + source.slice(offset);
+		return {
+			ok: true,
+			source: next$1
+		};
+	}
+	const elementTexts = [];
+	for (const el of found.elements) {
+		if (el === null) {
+			elementTexts.push("undefined");
+			continue;
+		}
+		if (typeof el.start !== "number" || typeof el.end !== "number") return {
+			ok: false,
+			status: 422,
+			error: "`notes` element missing source range"
+		};
+		elementTexts.push(source.slice(el.start, el.end));
+	}
+	while (elementTexts.length <= index) elementTexts.push("undefined");
+	elementTexts[index] = literal;
+	while (elementTexts.length > 0 && elementTexts[elementTexts.length - 1] === "undefined") elementTexts.pop();
+	const replacement = elementTexts.length === 0 ? "[]" : `[\n${elementTexts.map((s) => `  ${s},`).join("\n")}\n]`;
+	const next = source.slice(0, found.arrayStart) + replacement + source.slice(found.arrayEnd);
+	return {
+		ok: true,
+		source: next
+	};
+}
+function notesPlugin(opts) {
+	const userCwd = opts.userCwd;
+	const slidesDir = opts.slidesDir ?? "slides";
+	const recentWrites = new Map();
+	const RECENT_WRITE_WINDOW_MS = 1500;
+	return {
+		name: "open-aippt:notes",
+		apply: "serve",
+		handleHotUpdate(ctx) {
+			const ts = recentWrites.get(ctx.file);
+			if (ts != null && Date.now() - ts < RECENT_WRITE_WINDOW_MS) {
+				recentWrites.delete(ctx.file);
+				return [];
+			}
+			return void 0;
+		},
+		configureServer(server) {
+			server.middlewares.use("/__notes", async (req, res, next) => {
+				const url = new URL(req.url ?? "/", "http://local");
+				const method = req.method ?? "GET";
+				if (method !== "PUT" || url.pathname !== "/") return next();
+				const requestCheck = validateMutationRequest(req, { requireJsonBody: true });
+				if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+				try {
+					const body = await readBody(req);
+					const slideId = body.slideId ?? "";
+					const file = resolveSlidePath(userCwd, slidesDir, slideId);
+					if (!file) return json(res, 400, { error: "invalid slideId" });
+					if (typeof body.index !== "number") return json(res, 400, { error: "missing index" });
+					if (typeof body.text !== "string") return json(res, 400, { error: "missing text" });
+					let source;
+					try {
+						source = await fs.readFile(file, "utf8");
+					} catch {
+						return json(res, 404, { error: "slide not found" });
+					}
+					const result = applyNotesEdit(source, body.index, body.text);
+					if (!result.ok) return json(res, result.status, { error: result.error });
+					const changed = result.source !== source;
+					if (changed) {
+						recentWrites.set(file, Date.now());
+						await fs.writeFile(file, result.source, "utf8");
+					}
+					return json(res, 200, {
+						ok: true,
+						changed
+					});
+				} catch (err) {
+					json(res, 500, { error: String(err.message ?? err) });
+				}
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/vite/open-aippt-plugin.ts
+const CONFIG_FILE = "open-aippt.config.ts";
+const SLIDES_VMOD = "virtual:open-aippt/slides";
+const CONFIG_VMOD = "virtual:open-aippt/config";
+const FOLDERS_VMOD = "virtual:open-aippt/folders";
+async function readFoldersManifest(file) {
+	try {
+		const raw = await fs.readFile(file, "utf8");
+		const parsed = JSON.parse(raw);
+		return {
+			folders: Array.isArray(parsed.folders) ? parsed.folders : [],
+			assignments: parsed.assignments && typeof parsed.assignments === "object" ? parsed.assignments : {}
+		};
+	} catch (err) {
+		if (err.code === "ENOENT") return {
+			folders: [],
+			assignments: {}
+		};
+		throw err;
+	}
+}
+function resolved$1(id) {
+	return `\0${id}`;
+}
+async function findSlides(userCwd, slidesDir) {
+	const abs = path.resolve(userCwd, slidesDir);
+	if (!existsSync(abs)) return [];
+	const hits = await fg("*/index.{tsx,jsx,ts,js}", {
+		cwd: abs,
+		absolute: true,
+		onlyFiles: true
+	});
+	return hits.sort();
+}
+function toId(absFile, slidesRoot) {
+	const rel = path.relative(slidesRoot, absFile);
+	return rel.split(path.sep)[0];
+}
+const META_THEME_RE = /(?:^|[\s,{])theme\s*:\s*['"]([^'"]+)['"]/;
+const META_CREATED_AT_RE = /(?:^|[\s,{])createdAt\s*:\s*['"]([^'"]+)['"]/;
+function extractMeta(src) {
+	const empty = {
+		theme: null,
+		createdAt: null
+	};
+	const metaStart = src.search(/export\s+const\s+meta\b/);
+	if (metaStart === -1) return empty;
+	const eqIdx = src.indexOf("=", metaStart);
+	if (eqIdx === -1) return empty;
+	const openBrace = src.indexOf("{", eqIdx);
+	if (openBrace === -1) return empty;
+	let depth = 0;
+	let closeBrace = -1;
+	for (let i = openBrace; i < src.length; i++) {
+		const ch = src[i];
+		if (ch === "{") depth++;
+		else if (ch === "}") {
+			depth--;
+			if (depth === 0) {
+				closeBrace = i;
+				break;
+			}
+		}
+	}
+	if (closeBrace === -1) return empty;
+	const body = src.slice(openBrace + 1, closeBrace);
+	const themeMatch = body.match(META_THEME_RE);
+	const createdAtMatch = body.match(META_CREATED_AT_RE);
+	return {
+		theme: themeMatch ? themeMatch[1] : null,
+		createdAt: createdAtMatch ? createdAtMatch[1] : null
+	};
+}
+async function readSlideMeta(abs) {
+	try {
+		const src = await fs.readFile(abs, "utf8");
+		return extractMeta(src);
+	} catch {
+		return {
+			theme: null,
+			createdAt: null
+		};
+	}
+}
+function parseCreatedAtMs(iso) {
+	if (!iso) return null;
+	const ms = Date.parse(iso);
+	return Number.isFinite(ms) ? ms : null;
+}
+async function generateSlidesModule(files, slidesRoot, isDev) {
+	const entries = await Promise.all(files.map(async (abs) => {
+		const id = toId(abs, slidesRoot);
+		const importPath = isDev ? `@fs/${normalizePath(abs).replace(/^\/+/, "")}` : abs;
+		const meta = await readSlideMeta(abs);
+		return {
+			id,
+			importPath,
+			theme: meta.theme,
+			createdAt: parseCreatedAtMs(meta.createdAt)
+		};
+	}));
+	const ids = JSON.stringify(entries.map((e) => e.id).sort());
+	const themesMap = {};
+	const createdAtMap = {};
+	for (const e of entries) {
+		if (e.theme) themesMap[e.id] = e.theme;
+		if (e.createdAt !== null) createdAtMap[e.id] = e.createdAt;
+	}
+	const themesJson = JSON.stringify(themesMap);
+	const createdAtJson = JSON.stringify(createdAtMap);
+	const importTokens = JSON.stringify(Object.fromEntries(entries.map((e) => [e.id, 0])));
+	const devRuntime = isDev ? `
+const slideImportTokens = ${importTokens};
+if (import.meta.hot) {
+  import.meta.hot.on('open-aippt:slide-changed', (data) => {
+    const ids = Array.isArray(data?.slideIds) ? data.slideIds : data?.slideId ? [data.slideId] : [];
+    const token = Date.now();
+    for (const id of ids) {
+      if (Object.prototype.hasOwnProperty.call(slideImportTokens, id)) slideImportTokens[id] = token;
+    }
+  });
+}
+` : "";
+	const cases = entries.map((e) => {
+		const importExpr = isDev ? `import(/* @vite-ignore */ import.meta.env.BASE_URL + ${JSON.stringify(`${e.importPath}?t=`)} + slideImportTokens[${JSON.stringify(e.id)}])` : `import(${JSON.stringify(e.importPath)})`;
+		return `    case ${JSON.stringify(e.id)}: return ${importExpr};`;
+	}).join("\n");
+	return `// virtual:open-aippt/slides — generated
+export const slideIds = ${ids};
+export const slideThemes = ${themesJson};
+export const slideCreatedAt = ${createdAtJson};
+${devRuntime}
+
+export async function loadSlide(id) {
+  switch (id) {
+${cases}
+    default: throw new Error('Slide not found: ' + id);
+  }
+}
+`;
+}
+function openAipptPlugin(opts) {
+	const { userCwd, config, coreVersion } = opts;
+	const slidesDir = config.slidesDir ?? "slides";
+	const slidesRoot = path.resolve(userCwd, slidesDir);
+	const foldersManifestPath = path.join(slidesRoot, ".folders.json");
+	let isDev = false;
+	const slideIdForEntry = (p) => {
+		const rel = path.relative(slidesRoot, p);
+		if (rel.startsWith("..") || path.isAbsolute(rel)) return null;
+		const parts = rel.split(path.sep);
+		if (parts.length !== 2) return null;
+		if (!/^index\.(tsx|jsx|ts|js)$/.test(parts[1])) return null;
+		return parts[0];
+	};
+	let slideChangeTimer = null;
+	const pendingSlideChanges = new Set();
+	const queueSlideChanged = (server, id) => {
+		pendingSlideChanges.add(id);
+		if (slideChangeTimer) clearTimeout(slideChangeTimer);
+		slideChangeTimer = setTimeout(() => {
+			slideChangeTimer = null;
+			const mod = server.moduleGraph.getModuleById(resolved$1(SLIDES_VMOD));
+			if (mod) server.moduleGraph.invalidateModule(mod);
+			const slideIds = Array.from(pendingSlideChanges);
+			pendingSlideChanges.clear();
+			server.ws.send({
+				type: "custom",
+				event: "open-aippt:slide-changed",
+				data: { slideIds }
+			});
+		}, 100);
+	};
+	return {
+		name: "open-aippt",
+		config(_c, env) {
+			isDev = env.command === "serve";
+			return { server: { fs: { allow: [userCwd] } } };
+		},
+		resolveId(id) {
+			if (id === SLIDES_VMOD) return resolved$1(SLIDES_VMOD);
+			if (id === CONFIG_VMOD) return resolved$1(CONFIG_VMOD);
+			if (id === FOLDERS_VMOD) return resolved$1(FOLDERS_VMOD);
+			return null;
+		},
+		async load(id) {
+			if (id === resolved$1(SLIDES_VMOD)) {
+				const files = await findSlides(userCwd, slidesDir);
+				return await generateSlidesModule(files, slidesRoot, isDev);
+			}
+			if (id === resolved$1(CONFIG_VMOD)) {
+				const userBuild = config.build ?? {};
+				const buildResolved = isDev ? {
+					showSlideBrowser: true,
+					showSlideUi: true,
+					allowHtmlDownload: true
+				} : {
+					showSlideBrowser: userBuild.showSlideBrowser ?? true,
+					showSlideUi: userBuild.showSlideUi ?? true,
+					allowHtmlDownload: userBuild.allowHtmlDownload ?? true
+				};
+				const resolvedConfig = {
+					...config,
+					build: buildResolved,
+					version: coreVersion
+				};
+				return `export default ${JSON.stringify(resolvedConfig)};\n`;
+			}
+			if (id === resolved$1(FOLDERS_VMOD)) {
+				const manifest = await readFoldersManifest(foldersManifestPath);
+				return `export default ${JSON.stringify(manifest)};\n`;
+			}
+			return null;
+		},
+		handleHotUpdate(ctx) {
+			const slideId = slideIdForEntry(ctx.file);
+			if (!slideId) return;
+			queueSlideChanged(ctx.server, slideId);
+			return [];
+		},
+		configureServer(server) {
+			const isSlideEntry = (p) => slideIdForEntry(p) !== null;
+			let reloadTimer = null;
+			const reload = () => {
+				if (reloadTimer) clearTimeout(reloadTimer);
+				reloadTimer = setTimeout(() => {
+					reloadTimer = null;
+					const mod = server.moduleGraph.getModuleById(resolved$1(SLIDES_VMOD));
+					if (mod) server.moduleGraph.invalidateModule(mod);
+					server.ws.send({ type: "full-reload" });
+				}, 150);
+			};
+			if (existsSync(slidesRoot)) server.watcher.add(slidesRoot);
+			server.watcher.on("add", (p) => {
+				if (isSlideEntry(p)) reload();
+			});
+			server.watcher.on("unlink", (p) => {
+				if (isSlideEntry(p)) reload();
+			});
+			let foldersTimer = null;
+			const invalidateFolders = () => {
+				if (foldersTimer) clearTimeout(foldersTimer);
+				foldersTimer = setTimeout(() => {
+					foldersTimer = null;
+					const mod = server.moduleGraph.getModuleById(resolved$1(FOLDERS_VMOD));
+					if (mod) server.moduleGraph.invalidateModule(mod);
+				}, 100);
+			};
+			server.watcher.add(foldersManifestPath);
+			server.watcher.on("change", (p) => {
+				if (p === foldersManifestPath) invalidateFolders();
+			});
+			server.watcher.on("add", (p) => {
+				if (p === foldersManifestPath) invalidateFolders();
+			});
+			server.watcher.on("unlink", (p) => {
+				if (p === foldersManifestPath) invalidateFolders();
+			});
+		}
+	};
+}
+async function loadUserConfig(userCwd) {
+	const file = path.join(userCwd, CONFIG_FILE);
+	if (!existsSync(file)) return {};
+	const loaded = await loadConfigFromFile({
+		command: "serve",
+		mode: "development"
+	}, file, userCwd, "silent");
+	return loaded?.config ?? {};
+}
+
+//#endregion
+//#region src/vite/themes-plugin.ts
+const THEMES_VMOD = "virtual:open-aippt/themes";
+function resolved(id) {
+	return `\0${id}`;
+}
+const FM_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+function parseFrontmatter(raw, themeId) {
+	const match = raw.match(FM_RE);
+	const fmText = match ? match[1] : "";
+	const body = match ? match[2] : raw;
+	const data = {};
+	for (const line of fmText.split(/\r?\n/)) {
+		const m = line.match(/^([A-Za-z0-9_-]+)\s*:\s*(.*)$/);
+		if (!m) continue;
+		let value = m[2].trim();
+		if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+		data[m[1]] = value;
+	}
+	return {
+		fm: {
+			name: data.name || themeId,
+			description: data.description || ""
+		},
+		body: body.trim()
+	};
+}
+async function findThemes(userCwd, themesDir) {
+	const abs = path.resolve(userCwd, themesDir);
+	if (!existsSync(abs)) return [];
+	const hits = await fg("*.md", {
+		cwd: abs,
+		absolute: true,
+		onlyFiles: true
+	});
+	return hits.sort();
+}
+async function readTheme(mdAbs, themesRoot) {
+	const id = path.basename(mdAbs, ".md");
+	const raw = await fs.readFile(mdAbs, "utf8");
+	const { fm, body } = parseFrontmatter(raw, id);
+	const demoCandidates = [
+		`${id}.demo.tsx`,
+		`${id}.demo.jsx`,
+		`${id}.demo.ts`,
+		`${id}.demo.js`
+	];
+	let demoAbs = null;
+	for (const cand of demoCandidates) {
+		const p = path.join(themesRoot, cand);
+		if (existsSync(p)) {
+			demoAbs = p;
+			break;
+		}
+	}
+	return {
+		id,
+		frontmatter: fm,
+		body,
+		demoAbs
+	};
+}
+function generateThemesModule(themes, isDev) {
+	const meta = themes.map((t$5) => ({
+		id: t$5.id,
+		name: t$5.frontmatter.name,
+		description: t$5.frontmatter.description,
+		body: t$5.body,
+		hasDemo: t$5.demoAbs !== null
+	}));
+	const cases = themes.flatMap((t$5) => {
+		const abs = t$5.demoAbs;
+		if (!abs) return [];
+		const importPath = isDev ? `@fs/${normalizePath(abs).replace(/^\/+/, "")}` : abs;
+		const importExpr = isDev ? `import(/* @vite-ignore */ import.meta.env.BASE_URL + ${JSON.stringify(importPath)})` : `import(${JSON.stringify(importPath)})`;
+		return [`    case ${JSON.stringify(t$5.id)}: return ${importExpr};`];
+	}).join("\n");
+	return `// virtual:open-aippt/themes — generated
+export const themes = ${JSON.stringify(meta)};
+
+export async function loadThemeDemo(id) {
+  switch (id) {
+${cases}
+    default: throw new Error('Theme demo not found: ' + id);
+  }
+}
+`;
+}
+function themesPlugin(opts) {
+	const { userCwd, config } = opts;
+	const themesDir = config.themesDir ?? "themes";
+	const themesRoot = path.resolve(userCwd, themesDir);
+	let isDev = false;
+	return {
+		name: "open-aippt:themes",
+		config(_c, env) {
+			isDev = env.command === "serve";
+		},
+		resolveId(id) {
+			if (id === THEMES_VMOD) return resolved(THEMES_VMOD);
+			return null;
+		},
+		async load(id) {
+			if (id !== resolved(THEMES_VMOD)) return null;
+			const files = await findThemes(userCwd, themesDir);
+			const themes = await Promise.all(files.map((f) => readTheme(f, themesRoot)));
+			return generateThemesModule(themes, isDev);
+		},
+		configureServer(server) {
+			const isThemeFile = (p) => {
+				const rel = path.relative(themesRoot, p);
+				if (rel.startsWith("..") || path.isAbsolute(rel)) return false;
+				if (rel.includes(path.sep)) return false;
+				return /\.(md|demo\.(tsx|jsx|ts|js))$/.test(rel);
+			};
+			let reloadTimer = null;
+			const reload = () => {
+				if (reloadTimer) clearTimeout(reloadTimer);
+				reloadTimer = setTimeout(() => {
+					reloadTimer = null;
+					const mod = server.moduleGraph.getModuleById(resolved(THEMES_VMOD));
+					if (mod) server.moduleGraph.invalidateModule(mod);
+					server.ws.send({ type: "full-reload" });
+				}, 150);
+			};
+			if (existsSync(themesRoot)) server.watcher.add(themesRoot);
+			server.watcher.on("add", (p) => {
+				if (isThemeFile(p)) reload();
+			});
+			server.watcher.on("unlink", (p) => {
+				if (isThemeFile(p)) reload();
+			});
+			server.watcher.on("change", (p) => {
+				if (isThemeFile(p)) reload();
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/vite/config.ts
+function findPackageRoot(fromFile) {
+	let dir = path.dirname(fromFile);
+	while (dir !== path.dirname(dir)) {
+		if (existsSync(path.join(dir, "package.json"))) return dir;
+		dir = path.dirname(dir);
+	}
+	throw new Error(`Could not find package.json walking up from ${fromFile}`);
+}
+const PKG_ROOT = findPackageRoot(fileURLToPath(import.meta.url));
+const APP_ROOT = path.join(PKG_ROOT, "src", "app");
+function readCoreVersion() {
+	try {
+		const raw = readFileSync(path.join(PKG_ROOT, "package.json"), "utf8");
+		return JSON.parse(raw).version ?? "0.0.0";
+	} catch {
+		return "0.0.0";
+	}
+}
+const CORE_VERSION = readCoreVersion();
+async function createViteConfig(opts) {
+	const userCwd = path.resolve(opts.userCwd);
+	const config = opts.config ?? await loadUserConfig(userCwd);
+	const slidesDir = config.slidesDir ?? "slides";
+	const themesDir = config.themesDir ?? "themes";
+	const assetsDir = config.assetsDir ?? "assets";
+	const slidesAbs = path.resolve(userCwd, slidesDir);
+	const themesAbs = path.resolve(userCwd, themesDir);
+	const assetsAbs = path.resolve(userCwd, assetsDir);
+	return {
+		base: config.base ?? "/",
+		root: APP_ROOT,
+		configFile: false,
+		envDir: userCwd,
+		plugins: [
+			locTagsPlugin({
+				userCwd,
+				slidesDir
+			}),
+			react(),
+			tailwindcss(),
+			openAipptPlugin({
+				userCwd,
+				config,
+				coreVersion: CORE_VERSION
+			}),
+			themesPlugin({
+				userCwd,
+				config
+			}),
+			designPlugin({ userCwd }),
+			apiPlugin({
+				userCwd,
+				slidesDir,
+				assetsDir,
+				coreVersion: CORE_VERSION
+			}),
+			notesPlugin({
+				userCwd,
+				slidesDir
+			}),
+			currentPlugin({
+				userCwd,
+				slidesDir
+			})
+		],
+		resolve: { alias: {
+			"@": APP_ROOT,
+			"@assets": assetsAbs
+		} },
+		optimizeDeps: {
+			entries: [path.join(APP_ROOT, "main.tsx")],
+			include: [
+				"react",
+				"react-dom",
+				"react-dom/client",
+				"next-themes",
+				"react-router-dom",
+				"radix-ui",
+				"lucide-react",
+				"clsx",
+				"tailwind-merge",
+				"class-variance-authority",
+				"emoji-picker-react"
+			],
+			esbuildOptions: { plugins: [{
+				name: "open-aippt:virtual-externals",
+				setup(build$1) {
+					build$1.onResolve({ filter: /^virtual:open-aippt\// }, (args) => ({
+						path: args.path,
+						external: true
+					}));
+				}
+			}] }
+		},
+		server: {
+			port: config.port ?? 5173,
+			fs: { allow: [
+				APP_ROOT,
+				userCwd,
+				slidesAbs,
+				themesAbs,
+				assetsAbs
+			] }
+		},
+		build: {
+			outDir: path.resolve(userCwd, "dist"),
+			emptyOutDir: true
+		}
+	};
+}
+
+//#endregion
+export { createViteConfig };