@ox-content/code-play 3.0.0-alpha.8 → 3.0.0-beta.0

package/dist/plugin2.mjs

@@ -1,28 +1,553 @@
-import { c as DEV_TYPECHECK_PATH, i as escapeAttribute, n as encodePayload, o as DEFAULT_ENDPOINTS, p as resolveLanguage, r as decodeHtml, s as DEFAULT_VIEWERS, t as decodePayload, u as resolveCodePlayOptions } from "./payload.mjs";
-import { readFile, writeFile } from "node:fs/promises";
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { f as resolveCodePlayOptions, h as resolveLanguage, i as escapeAttribute, n as encodePayload, o as DEFAULT_ENDPOINTS, r as decodeHtml, s as DEFAULT_VIEWERS, t as decodePayload, u as DEV_TYPECHECK_PATH } from "./payload.mjs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+//#region src/authoring.ts
+function parsePlayMeta(meta) {
+	const options = emptyPlayOptions();
+	for (const token of splitPlayInfo(meta)) {
+		if (token === "typecheck") {
+			options.typecheck = true;
+			continue;
+		}
+		if (token === "play-compact") {
+			options.ui = "compact";
+			continue;
+		}
+		if (token === "play-headless") {
+			options.ui = "headless";
+			continue;
+		}
+		const pair = readTokenPair(token);
+		if (!pair) continue;
+		applyPlayOption(options, pair.name, pair.value);
+	}
+	return options;
+}
+function parseCodePlayAttributes(attrs) {
+	const options = emptyPlayOptions();
+	for (const [name, value] of readAttributes(attrs)) {
+		if (name === "typecheck") {
+			options.typecheck = value !== "false";
+			continue;
+		}
+		if (name === "title") {
+			options.title = value;
+			continue;
+		}
+		if (name === "ui") {
+			options.ui = parseUi(value);
+			continue;
+		}
+		if (name === "timeout" || name === "timeout-ms" || name === "timeoutms") {
+			options.timeoutMs = parsePositiveInt(value);
+			continue;
+		}
+		if (name === "viewers") {
+			options.viewers = parseViewers(value);
+			continue;
+		}
+		if (applyProjectAttribute(options, name, value)) continue;
+		if (name.startsWith("config-")) options.config[configKeyFromAttribute(name.slice(7))] = coerceOptionValue(value);
+	}
+	return options;
+}
+function readCodePlayAttribute(attrs, name) {
+	return readAttributes(attrs).get(name.toLowerCase());
+}
+function splitPlayInfo(info) {
+	const tokens = [];
+	let current = "";
+	let quote;
+	let escaped = false;
+	for (const char of info.trim()) {
+		if (escaped) {
+			current += `\\${char}`;
+			escaped = false;
+			continue;
+		}
+		if (char === "\\") {
+			escaped = true;
+			continue;
+		}
+		if (quote) {
+			if (char === quote) {
+				current += char;
+				quote = void 0;
+			} else current += char;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			current += char;
+			quote = char;
+			continue;
+		}
+		if (/\s/.test(char)) {
+			if (current) {
+				tokens.push(current);
+				current = "";
+			}
+			continue;
+		}
+		current += char;
+	}
+	if (current) tokens.push(current);
+	return tokens;
+}
+function emptyPlayOptions() {
+	return {
+		typecheck: false,
+		config: {}
+	};
+}
+function applyPlayOption(options, rawName, value) {
+	const name = rawName.toLowerCase();
+	if (name === "play-title") {
+		options.title = value;
+		return;
+	}
+	if (name === "play-ui") {
+		options.ui = parseUi(value);
+		return;
+	}
+	if (name === "play-timeout" || name === "play-timeout-ms" || name === "play-timeoutms") {
+		options.timeoutMs = parsePositiveInt(value);
+		return;
+	}
+	if (name === "play-viewers") {
+		options.viewers = parseViewers(value);
+		return;
+	}
+	if (applyProjectMeta(options, rawName, value)) return;
+	const configKey = name.startsWith("play-config:") || name.startsWith("play-config.") ? rawName.slice(12) : name.startsWith("play-") ? rawName.slice(5) : "";
+	if (configKey) options.config[configKey] = coerceOptionValue(value);
+}
+function applyProjectMeta(options, rawName, value) {
+	switch (rawName.toLowerCase()) {
+		case "play-project":
+		case "play-sandbox":
+		case "play-provider":
+			ensureProject(options, value);
+			return true;
+		case "play-entry":
+			ensureProject(options).entry = value;
+			return true;
+		case "play-file":
+			ensureProject(options).file = value;
+			return true;
+		case "play-files":
+			ensureProject(options).files.push(...splitList(value));
+			return true;
+		case "play-project-url":
+		case "play-open-url":
+			ensureProject(options).openUrl = value;
+			return true;
+		case "play-fallback-url":
+			ensureProject(options).fallbackUrl = value;
+			return true;
+		default: return false;
+	}
+}
+function applyProjectAttribute(options, name, value) {
+	switch (name) {
+		case "project":
+		case "sandbox":
+		case "provider":
+			ensureProject(options, value);
+			return true;
+		case "entry":
+			ensureProject(options).entry = value;
+			return true;
+		case "file":
+			ensureProject(options).file = value;
+			return true;
+		case "files":
+			ensureProject(options).files.push(...splitList(value));
+			return true;
+		case "project-url":
+		case "open-url":
+			ensureProject(options).openUrl = value;
+			return true;
+		case "fallback-url":
+			ensureProject(options).fallbackUrl = value;
+			return true;
+		default: return false;
+	}
+}
+function ensureProject(options, provider = "external") {
+	options.project ??= {
+		provider,
+		files: []
+	};
+	if (provider && options.project.provider === "external") options.project.provider = provider;
+	return options.project;
+}
+function readTokenPair(token) {
+	const index = token.indexOf("=");
+	if (index === -1) return;
+	return {
+		name: token.slice(0, index),
+		value: unquote(token.slice(index + 1))
+	};
+}
+function readAttributes(attrs) {
+	const values = /* @__PURE__ */ new Map();
+	for (const match of attrs.matchAll(/([:\w-]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+)))?/g)) {
+		const name = match[1]?.toLowerCase();
+		if (!name) continue;
+		values.set(name, match[2] ?? match[3] ?? match[4] ?? "true");
+	}
+	return values;
+}
+function parseUi(value) {
+	return value === "default" || value === "compact" || value === "headless" ? value : void 0;
+}
+function parsePositiveInt(value) {
+	const parsed = Number.parseInt(value, 10);
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+}
+function parseViewers(value) {
+	const viewers = {};
+	for (const token of value.split(",")) {
+		const trimmed = token.trim();
+		const enabled = !trimmed.startsWith("-");
+		const key = enabled ? trimmed : trimmed.slice(1);
+		if (key === "config" || key === "stdio" || key === "stderr" || key === "provenance" || key === "timing") viewers[key] = enabled;
+	}
+	return Object.keys(viewers).length > 0 ? viewers : void 0;
+}
+function splitList(value) {
+	return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function coerceOptionValue(value) {
+	if (value === "true") return true;
+	if (value === "false") return false;
+	const numeric = Number(value);
+	return value.trim() !== "" && Number.isFinite(numeric) ? numeric : value;
+}
+function configKeyFromAttribute(value) {
+	return value.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+}
+function unquote(value) {
+	if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1);
+	return value;
+}
+//#endregion
+//#region src/markdown.ts
+const FENCE_OPEN = /^( {0,3})(`{3,}|~{3,})([^\n]*)$/;
+function parseTopLevelFences(source) {
+	const lines = source.split("\n");
+	const fences = [];
+	let index = 0;
+	let offset = 0;
+	while (index < lines.length) {
+		const line = lines[index] ?? "";
+		const open = FENCE_OPEN.exec(line);
+		if (!open) {
+			offset += line.length + 1;
+			index += 1;
+			continue;
+		}
+		const indent = open[1] ?? "";
+		const marker = open[2] ?? "```";
+		const { language, meta } = readFenceInfo((open[3] ?? "").trim());
+		const start = offset;
+		index += 1;
+		offset += line.length + 1;
+		const body = [];
+		while (index < lines.length) {
+			const candidate = lines[index] ?? "";
+			if (new RegExp(`^ {0,3}${escapeRegExp(marker)}[ \t]*$`).exec(candidate)) {
+				const raw = `${line}\n${body.join("\n")}${body.length > 0 ? "\n" : ""}${candidate}`;
+				fences.push({
+					language,
+					meta,
+					code: body.join("\n"),
+					raw,
+					start,
+					end: start + raw.length,
+					indent,
+					marker
+				});
+				offset += candidate.length + 1;
+				index += 1;
+				break;
+			}
+			body.push(candidate);
+			offset += candidate.length + 1;
+			index += 1;
+		}
+	}
+	return fences;
+}
+function parsePlayFences(source) {
+	return parseTopLevelFences(source).filter((fence) => hasToken(fence.meta, "play")).map((fence) => {
+		const options = parsePlayMeta(fence.meta);
+		return {
+			language: fence.language,
+			meta: fence.meta,
+			code: fence.code,
+			raw: fence.raw,
+			start: fence.start,
+			end: fence.end,
+			typecheck: options.typecheck,
+			title: options.title,
+			config: options.config,
+			ui: options.ui,
+			viewers: options.viewers,
+			timeoutMs: options.timeoutMs,
+			project: options.project
+		};
+	});
+}
+function stripPlayMeta(meta) {
+	return splitPlayInfo(meta).filter((token) => token && token !== "play" && token !== "typecheck" && !token.startsWith("play-") && !token.startsWith("play:")).join(" ");
+}
+function rewritePlayFences(source, encode) {
+	const fences = parsePlayFences(source);
+	if (fences.length === 0) return source;
+	let cursor = 0;
+	let output = "";
+	for (const fence of fences) {
+		output += source.slice(cursor, fence.start);
+		const encoded = encode(fence);
+		if (encoded === null) output += source.slice(fence.start, fence.end);
+		else {
+			const cleanedMeta = stripPlayMeta(fence.meta);
+			const info = [fence.language, cleanedMeta].filter(Boolean).join(" ");
+			output += `<!--ox-code-play:${encoded}-->\n\`\`\`${info}\n${fence.code}\n\`\`\``;
+		}
+		cursor = fence.end;
+	}
+	output += source.slice(cursor);
+	return output;
+}
+function parseCodePlayTags(source) {
+	const tags = [];
+	for (const match of source.matchAll(/<CodePlay\b([^>]*)>([\s\S]*?)<\/CodePlay>/gi)) {
+		const attrs = match[1] ?? "";
+		const language = readCodePlayAttribute(attrs, "lang") ?? readCodePlayAttribute(attrs, "language") ?? "text";
+		const options = parseCodePlayAttributes(attrs);
+		tags.push({
+			language,
+			meta: "play",
+			code: stripIndent((match[2] ?? "").replace(/^\n/, "").replace(/\n$/, "")),
+			raw: match[0] ?? "",
+			start: match.index ?? 0,
+			end: (match.index ?? 0) + (match[0]?.length ?? 0),
+			typecheck: options.typecheck,
+			title: options.title,
+			config: options.config,
+			ui: options.ui,
+			viewers: options.viewers,
+			timeoutMs: options.timeoutMs,
+			project: options.project
+		});
+	}
+	return tags;
+}
+function readFenceInfo(info) {
+	const match = /^(\S+)(?:\s+([\s\S]*))?$/.exec(info);
+	return {
+		language: match?.[1] ?? "",
+		meta: match?.[2]?.trim() ?? ""
+	};
+}
+function hasToken(meta, token) {
+	return splitPlayInfo(meta).includes(token);
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function stripIndent(value) {
+	const lines = value.split("\n");
+	const indents = lines.filter((line) => line.trim()).map((line) => line.match(/^ */)?.[0].length ?? 0);
+	const indent = indents.length > 0 ? Math.min(...indents) : 0;
+	return lines.map((line) => line.slice(indent)).join("\n");
+}
+//#endregion
+//#region src/project-sandbox.ts
+const PROJECT_SANDBOX_ADAPTERS = {
+	stackblitz: adapter("stackblitz", "StackBlitz", "browser"),
+	codesandbox: adapter("codesandbox", "CodeSandbox", "browser"),
+	webcontainer: adapter("webcontainer", "WebContainer", "node"),
+	external: adapter("external", "External sandbox", "external")
+};
+function projectSandboxFromPayloadInput(input) {
+	if (!input.project) return;
+	const warnings = [...input.warnings ?? []];
+	const adapter = resolveProjectSandboxAdapter(input.project.provider, warnings);
+	const sourceFile = normalizeProjectPath(input.project.file, warnings, "source file");
+	const entry = normalizeProjectPath(input.project.entry, warnings, "entry path");
+	const primary = {
+		path: sourceFile ?? entry ?? defaultProjectFile(input.language, input.definition),
+		code: input.code
+	};
+	const files = mergeProjectFiles([primary, ...input.files ?? []]);
+	const openUrl = safeProjectUrl(input.project.openUrl, adapter.provider, warnings);
+	const fallbackUrl = safeProjectUrl(input.project.fallbackUrl, adapter.provider, warnings);
+	return adapter.resolve({
+		provider: input.project.provider,
+		entry: entry ?? primary.path,
+		files,
+		openUrl,
+		fallbackUrl,
+		warnings
+	});
+}
+function normalizeProjectPath(value, warnings = [], label = "file path") {
+	const trimmed = value?.trim();
+	if (!trimmed) return;
+	const normalized = trimmed.replace(/^\.\//, "");
+	if (normalized.startsWith("/") || normalized.includes("\\") || normalized.includes("\0") || normalized.split("/").some((part) => part === "" || part === "." || part === "..") || /^[a-z]+:/i.test(normalized)) {
+		warnings.push(`Skipped unsafe project ${label}: ${trimmed}`);
+		return;
+	}
+	if (normalized.length > 256) {
+		warnings.push(`Skipped long project ${label}: ${trimmed}`);
+		return;
+	}
+	return normalized;
+}
+function projectSandboxProviderLabel(provider) {
+	return PROJECT_SANDBOX_ADAPTERS[provider].label;
+}
+function adapter(provider, label, target) {
+	return {
+		provider,
+		label,
+		target,
+		resolve(input) {
+			return compactProjectSandbox({
+				provider,
+				label,
+				target,
+				entry: input.entry,
+				files: input.files,
+				openUrl: input.openUrl,
+				fallbackUrl: input.fallbackUrl,
+				warnings: input.warnings
+			});
+		}
+	};
+}
+function defaultProjectFile(language, definition) {
+	if (definition?.framework === "vue") return "src/App.vue";
+	if (definition?.framework === "react" || definition?.framework === "solid") return "src/App.tsx";
+	if (definition?.framework === "svelte") return "src/App.svelte";
+	switch (language) {
+		case "javascript": return "index.js";
+		case "typescript": return "index.ts";
+		case "go": return "main.go";
+		case "rust": return "src/main.rs";
+		default: return "snippet.txt";
+	}
+}
+function resolveProjectSandboxAdapter(rawProvider, warnings) {
+	switch (rawProvider.trim().toLowerCase()) {
+		case "stackblitz":
+		case "stack-blitz":
+		case "sb": return PROJECT_SANDBOX_ADAPTERS.stackblitz;
+		case "codesandbox":
+		case "code-sandbox":
+		case "csb": return PROJECT_SANDBOX_ADAPTERS.codesandbox;
+		case "webcontainer":
+		case "web-container": return PROJECT_SANDBOX_ADAPTERS.webcontainer;
+		case "external":
+		case "": return PROJECT_SANDBOX_ADAPTERS.external;
+		default:
+			warnings.push(`Unknown project sandbox provider: ${rawProvider}`);
+			return PROJECT_SANDBOX_ADAPTERS.external;
+	}
+}
+function mergeProjectFiles(files) {
+	const merged = /* @__PURE__ */ new Map();
+	for (const file of files) merged.set(file.path, file);
+	return [...merged.values()];
+}
+function safeProjectUrl(value, provider, warnings) {
+	if (!value) return;
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		warnings.push(`Skipped invalid project URL: ${value}`);
+		return;
+	}
+	if (url.protocol !== "https:" && url.protocol !== "http:") {
+		warnings.push(`Skipped non-http project URL: ${value}`);
+		return;
+	}
+	if (url.username || url.password) {
+		warnings.push(`Skipped project URL with credentials: ${url.origin}`);
+		return;
+	}
+	if (!providerAllowsHost(provider, url.hostname)) {
+		warnings.push(`Skipped ${provider} project URL on unexpected host: ${url.hostname}`);
+		return;
+	}
+	return url.href;
+}
+function providerAllowsHost(provider, host) {
+	if (provider === "external") return true;
+	const normalized = host.toLowerCase();
+	return {
+		stackblitz: ["stackblitz.com"],
+		codesandbox: ["codesandbox.io", "csb.app"],
+		webcontainer: ["webcontainers.io", "webcontainer.io"]
+	}[provider].some((suffix) => normalized === suffix || normalized.endsWith(`.${suffix}`));
+}
+function compactProjectSandbox(project) {
+	const next = {
+		provider: project.provider,
+		label: project.label,
+		target: project.target,
+		files: project.files
+	};
+	if (project.entry) next.entry = project.entry;
+	if (project.openUrl) next.openUrl = project.openUrl;
+	if (project.fallbackUrl) next.fallbackUrl = project.fallbackUrl;
+	if (project.warnings?.length) next.warnings = project.warnings;
+	return next;
+}
+//#endregion
 //#region src/payload-factory.ts
-function payloadFromFence(fence, options) {
+function payloadFromFence(fence, options, context = {}) {
 	const definition = resolveLanguage(fence.language);
 	const enabled = definition ? options.languages.get(definition.id) : void 0;
-	return {
+	const payload = {
 		language: definition?.id ?? fence.language,
 		code: fence.code,
+		title: fence.title,
 		capabilities: {
 			execute: enabled?.execute ?? Boolean(definition?.capabilities.execute),
 			typecheck: payloadTypecheckEnabled(fence.typecheck, enabled?.typecheck, definition, options.endpoints)
 		},
 		config: {
 			...definition?.defaultConfig,
-			...enabled?.config
+			...enabled?.config,
+			...fence.config
+		},
+		viewers: {
+			...options.viewers,
+			...fence.viewers
 		},
-		viewers: options.viewers,
-		ui: options.ui,
-		timeoutMs: options.timeoutMs,
+		ui: fence.ui ?? options.ui,
+		timeoutMs: fence.timeoutMs ?? options.timeoutMs,
 		endpoints: options.endpoints
 	};
+	if (enabled?.endpoint) payload.endpoint = enabled.endpoint;
+	const project = projectSandboxFromPayloadInput({
+		language: payload.language,
+		code: payload.code,
+		definition,
+		project: fence.project,
+		files: context.files,
+		warnings: context.warnings
+	});
+	if (project) payload.project = project;
+	return payload;
 }
 /** TypeScript typecheck in the browser needs a reachable endpoint; hide the dead button otherwise. */
 function payloadTypecheckEnabled(fenceTypecheck, enabledTypecheck, definition, endpoints) {
@@ -60,23 +585,39 @@ function wrapCommentedBlocks(html, _options) {
 function upgradeCodePlayTags(html, options) {
 	return html.replace(CODEPLAY_TAG_PATTERN, (all, attrs, body) => {
 		if (/\bdata-ox-code-play=/.test(all)) return all;
-		const language = readAttr$1(attrs, "lang") ?? readAttr$1(attrs, "language") ?? "text";
+		const language = readAttr(attrs, "lang") ?? readAttr(attrs, "language") ?? "text";
 		const code = decodeHtml(body).replace(/^\n/, "").replace(/\n$/, "");
 		const definition = resolveLanguage(language);
 		const endpoints = options.endpoints ?? DEFAULT_ENDPOINTS;
-		return wrapWidget(options.encodePayload({
+		const playOptions = parseCodePlayAttributes(attrs);
+		const payloadValue = {
 			language: definition?.id ?? language,
 			code,
+			title: playOptions.title,
 			capabilities: {
 				execute: true,
-				typecheck: payloadTypecheckEnabled(/\btypecheck\b/i.test(attrs), void 0, definition, endpoints)
+				typecheck: payloadTypecheckEnabled(playOptions.typecheck, void 0, definition, endpoints)
+			},
+			config: {
+				...definition?.defaultConfig,
+				...playOptions.config
+			},
+			viewers: {
+				...DEFAULT_VIEWERS,
+				...playOptions.viewers
 			},
-			config: {},
-			viewers: { ...DEFAULT_VIEWERS },
-			ui: "default",
-			timeoutMs: 1e4,
+			ui: playOptions.ui ?? "default",
+			timeoutMs: playOptions.timeoutMs ?? 1e4,
 			endpoints
-		}), `<pre><code class="language-${escapeAttribute(language)}">${body}</code></pre>`);
+		};
+		const project = projectSandboxFromPayloadInput({
+			language: payloadValue.language,
+			code,
+			definition,
+			project: playOptions.project
+		});
+		if (project) payloadValue.project = project;
+		return wrapWidget(options.encodePayload(payloadValue), `<pre><code class="language-${escapeAttribute(language)}">${body}</code></pre>`);
 	});
 }
 function wrapMatchingFences(html, matches) {
@@ -85,7 +626,7 @@ function wrapMatchingFences(html, matches) {
 		used: false
 	}));
 	return html.replace(PRE_PATTERN, (all, attrs, body) => {
-		const language = (readAttr$1(attrs, "class") ?? "").split(/\s+/).find((token) => token.startsWith("language-"))?.slice(9);
+		const language = (readAttr(attrs, "class") ?? "").split(/\s+/).find((token) => token.startsWith("language-"))?.slice(9);
 		const code = normalizeCode(decodeHtml(stripTags(body)));
 		const match = unused.find((item) => !item.used && aliasesEqual(item.language, language) && normalizeCode(item.code) === code);
 		if (!match) return all;
@@ -94,7 +635,7 @@ function wrapMatchingFences(html, matches) {
 	});
 }
 function wrapWidget(payload, inner) {
-	return `<ox-code-play data-ox-code-play="${escapeAttribute(payload)}">${inner}</ox-code-play>`;
+	return `<ox-code-play data-ox-code-play="${escapeAttribute(payload)}" inert>${inner}</ox-code-play>`;
 }
 function readJsonString(source, start) {
 	try {
@@ -119,7 +660,7 @@ function sliceJsonString(source, start) {
 	}
 	throw new Error("Unterminated HTML JSON string.");
 }
-function readAttr$1(attrs, name) {
+function readAttr(attrs, name) {
 	return new RegExp(`(?:^|\\s)${name}\\s*=\\s*"([^"]+)"`, "i").exec(attrs)?.[1];
 }
 function stripTags(value) {
@@ -133,120 +674,109 @@ function aliasesEqual(left, right) {
 	return left.toLowerCase() === right.toLowerCase();
 }
 //#endregion
-//#region src/markdown.ts
-const FENCE_OPEN = /^( {0,3})(`{3,}|~{3,})([^\n]*)$/;
-function parseTopLevelFences(source) {
-	const lines = source.split("\n");
-	const fences = [];
-	let index = 0;
-	let offset = 0;
-	while (index < lines.length) {
-		const line = lines[index] ?? "";
-		const open = FENCE_OPEN.exec(line);
-		if (!open) {
-			offset += line.length + 1;
-			index += 1;
+//#region src/project-files.ts
+const DEFAULT_MAX_FILES = 32;
+const DEFAULT_MAX_BYTES = 262144;
+function collectProjectFiles(project, context = {}) {
+	const warnings = [];
+	if (!project?.files.length) return {
+		files: [],
+		warnings
+	};
+	if (!context.documentPath) {
+		warnings.push("Skipped project files because the Markdown source path is unavailable.");
+		return {
+			files: [],
+			warnings
+		};
+	}
+	const documentDir = path.dirname(context.documentPath);
+	const sourceRoot = path.resolve(context.sourceRoot ?? documentDir);
+	const realSourceRoot = realpathIfExists(sourceRoot) ?? sourceRoot;
+	const files = [];
+	for (const requested of project.files) {
+		if (files.length >= (context.maxFiles ?? DEFAULT_MAX_FILES)) {
+			warnings.push(`Skipped project file after ${files.length} files: ${requested}`);
 			continue;
 		}
-		const indent = open[1] ?? "";
-		const marker = open[2] ?? "```";
-		const [language = "", ...metaParts] = splitInfo((open[3] ?? "").trim());
-		const start = offset;
-		index += 1;
-		offset += line.length + 1;
-		const body = [];
-		while (index < lines.length) {
-			const candidate = lines[index] ?? "";
-			if (new RegExp(`^ {0,3}${escapeRegExp(marker)}[ \t]*$`).exec(candidate)) {
-				const raw = `${line}\n${body.join("\n")}${body.length > 0 ? "\n" : ""}${candidate}`;
-				fences.push({
-					language,
-					meta: metaParts.join(" "),
-					code: body.join("\n"),
-					raw,
-					start,
-					end: start + raw.length,
-					indent,
-					marker
-				});
-				offset += candidate.length + 1;
-				index += 1;
-				break;
-			}
-			body.push(candidate);
-			offset += candidate.length + 1;
-			index += 1;
+		const safePath = normalizeProjectPath(requested, warnings);
+		if (!safePath) continue;
+		const absolute = path.resolve(documentDir, safePath);
+		if (!pathInside(absolute, sourceRoot)) {
+			warnings.push(`Skipped project file outside source root: ${safePath}`);
+			continue;
+		}
+		const realAbsolute = realpathIfExists(absolute);
+		if (!realAbsolute) {
+			warnings.push(`Skipped missing project file: ${safePath}`);
+			continue;
+		}
+		if (!pathInside(realAbsolute, realSourceRoot)) {
+			warnings.push(`Skipped project file outside real source root: ${safePath}`);
+			continue;
+		}
+		const stat = statSync(realAbsolute);
+		if (!stat.isFile()) {
+			warnings.push(`Skipped non-file project path: ${safePath}`);
+			continue;
+		}
+		if (stat.size > (context.maxBytes ?? DEFAULT_MAX_BYTES)) {
+			warnings.push(`Skipped large project file: ${safePath}`);
+			continue;
 		}
+		files.push({
+			path: safePath,
+			code: readFileSync(realAbsolute, "utf8")
+		});
 	}
-	return fences;
+	return {
+		files,
+		warnings
+	};
 }
-function parsePlayFences(source) {
-	return parseTopLevelFences(source).filter((fence) => hasToken(fence.meta, "play")).map((fence) => ({
-		language: fence.language,
-		meta: fence.meta,
-		code: fence.code,
-		raw: fence.raw,
-		start: fence.start,
-		end: fence.end,
-		typecheck: hasToken(fence.meta, "typecheck")
-	}));
+function realpathIfExists(file) {
+	if (!existsSync(file)) return;
+	return realpathSync(file);
 }
-function stripPlayMeta(meta) {
-	return meta.split(/\s+/).filter((token) => token && token !== "play" && token !== "typecheck" && !token.startsWith("play-")).join(" ");
+function pathInside(file, root) {
+	const relative = path.relative(root, file);
+	return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
 }
-function rewritePlayFences(source, encode) {
-	const fences = parsePlayFences(source);
-	if (fences.length === 0) return source;
-	let cursor = 0;
-	let output = "";
-	for (const fence of fences) {
-		output += source.slice(cursor, fence.start);
-		const encoded = encode(fence);
-		if (encoded === null) output += source.slice(fence.start, fence.end);
-		else {
-			const cleanedMeta = stripPlayMeta(fence.meta);
-			const info = [fence.language, cleanedMeta].filter(Boolean).join(" ");
-			output += `<!--ox-code-play:${encoded}-->\n\`\`\`${info}\n${fence.code}\n\`\`\``;
-		}
-		cursor = fence.end;
-	}
-	output += source.slice(cursor);
-	return output;
-}
-function parseCodePlayTags(source) {
-	const tags = [];
-	for (const match of source.matchAll(/<CodePlay\b([^>]*)>([\s\S]*?)<\/CodePlay>/gi)) {
-		const attrs = match[1] ?? "";
-		const language = readAttr(attrs, "lang") ?? readAttr(attrs, "language") ?? "text";
-		tags.push({
-			language,
-			meta: "play",
-			code: stripIndent((match[2] ?? "").replace(/^\n/, "").replace(/\n$/, "")),
-			raw: match[0] ?? "",
-			start: match.index ?? 0,
-			end: (match.index ?? 0) + (match[0]?.length ?? 0),
-			typecheck: /\btypecheck\b/i.test(attrs)
-		});
-	}
-	return tags;
+//#endregion
+//#region src/plugin-paths.ts
+const MARKDOWN_RE = /\.(?:md|markdown|mdx)(?:$|\?)/i;
+function cleanMarkdownPath(id, root) {
+	const file = id.split("?")[0];
+	if (!file || file.startsWith("\0")) return;
+	return path.isAbsolute(file) ? file : path.resolve(root, file);
 }
-function splitInfo(info) {
-	return info.trim().split(/\s+/).filter(Boolean);
+function guessHtmlPath(file, srcDir, outDir) {
+	const relative = path.relative(srcDir, file).replace(/\.(?:md|markdown|mdx)$/i, "");
+	return [path.join(outDir, `${relative}.html`), path.join(outDir, relative, "index.html")].find((candidate) => existsSync(candidate));
 }
-function hasToken(meta, token) {
-	return meta.split(/\s+/).includes(token);
+function normalizeBase(base) {
+	if (!base || base === "/") return "/";
+	return base.endsWith("/") ? base : `${base}/`;
 }
-function escapeRegExp(value) {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function sourceRoot(root, resolved) {
+	return path.resolve(root, resolved.srcDir ?? "docs");
 }
-function readAttr(attrs, name) {
-	return new RegExp(`(?:^|\\s)${name}\\s*=\\s*"([^"]+)"`, "i").exec(attrs)?.[1];
+function urlToMarkdown(urlPath, root, srcDir, base) {
+	let relative = urlPath;
+	if (base !== "/" && relative.startsWith(base)) relative = relative.slice(base.length);
+	relative = relative.replace(/^\//, "").replace(/\.html$/, "");
+	if (!relative || relative.includes("..")) return;
+	return [path.resolve(root, srcDir, `${relative}.md`), path.resolve(root, srcDir, relative, "index.md")].find((candidate) => existsSync(candidate));
 }
-function stripIndent(value) {
-	const lines = value.split("\n");
-	const indents = lines.filter((line) => line.trim()).map((line) => line.match(/^ */)?.[0].length ?? 0);
-	const indent = indents.length > 0 ? Math.min(...indents) : 0;
-	return lines.map((line) => line.slice(indent)).join("\n");
+function walkFiles(dir) {
+	const entries = readdirSync(dir);
+	const files = [];
+	for (const entry of entries) {
+		const full = path.join(dir, entry);
+		if (statSync(full).isDirectory()) files.push(...walkFiles(full));
+		else files.push(full);
+	}
+	return files;
 }
 //#endregion
 //#region src/plugin-client.ts
@@ -273,6 +803,13 @@ function assertBrowserClientSource(source) {
 	return source;
 }
 //#endregion
+//#region src/plugin-assets.ts
+async function writeClientAsset(outDir, source) {
+	if (!source) return;
+	await mkdir(outDir, { recursive: true });
+	await writeFile(path.join(outDir, "ox-code-play.js"), source);
+}
+//#endregion
 //#region src/plugin-proxy.ts
 const PROXY_MAX_BODY_BYTES = 262144;
 var ProxyRequestError = class extends Error {
@@ -352,14 +889,20 @@ function writeJson(res, status, body) {
 //#region src/plugin.ts
 const VIRTUAL_ID = "virtual:ox-content/code-play";
 const RESOLVED_VIRTUAL = `\0${VIRTUAL_ID}`;
-const MARKDOWN_RE = /\.(?:md|markdown|mdx)(?:$|\?)/i;
 function codePlay(options = {}) {
 	const resolved = resolveCodePlayOptions(options);
 	const explicitTypecheck = options.endpoints?.typecheck;
+	const proxyTargets = {
+		rust: resolved.endpoints.rust,
+		go: resolved.endpoints.go
+	};
 	let base = resolved.base;
 	let command = "serve";
 	let outDir = resolved.outDir;
 	let root = process.cwd();
+	let needsClientAsset = false;
+	let emittedClientAsset = false;
+	let clientSource;
 	const enhanceOptions = (matchFences) => ({
 		scriptSrc: `${base}ox-code-play.js`,
 		decodePayload,
@@ -374,10 +917,12 @@ function codePlay(options = {}) {
 			root = config.root;
 			base = resolved.base === "/" ? normalizeBase(config.base) : resolved.base;
 			outDir = resolved.outDir ?? config.build.outDir;
-			if (explicitTypecheck === void 0) {
-				if (command === "serve" && resolved.proxy) resolved.endpoints.typecheck = DEV_TYPECHECK_PATH;
-				else delete resolved.endpoints.typecheck;
+			if (command === "serve" && resolved.proxy) {
+				resolved.endpoints.rust = options.endpoints?.rust ?? "/__ox-code-play/rust";
+				resolved.endpoints.go = options.endpoints?.go ?? "/__ox-code-play/go";
 			}
+			if (explicitTypecheck === void 0 && command === "serve" && resolved.proxy) resolved.endpoints.typecheck = DEV_TYPECHECK_PATH;
+			else if (explicitTypecheck === void 0) delete resolved.endpoints.typecheck;
 		},
 		resolveId(id) {
 			return id === VIRTUAL_ID ? RESOLVED_VIRTUAL : null;
@@ -388,18 +933,24 @@ function codePlay(options = {}) {
 		},
 		transform(code, id) {
 			if (!MARKDOWN_RE.test(id)) {
-				if (code.includes("export const html = ") && code.includes("ox-code-play:")) return enhanceGeneratedModule(code, enhanceOptions());
+				if (code.includes("export const html = ") && code.includes("ox-code-play:")) {
+					const enhanced = enhanceGeneratedModule(code, enhanceOptions());
+					if (enhanced !== code) needsClientAsset = true;
+					return enhanced;
+				}
 				return null;
 			}
 			const rewritten = rewritePlayFences(code, (fence) => {
 				const definition = resolveLanguage(fence.language);
 				if (!definition || !resolved.languages.has(definition.id)) return null;
-				return encodePayload(payloadFromFence(fence, resolved));
+				return encodePayload(payloadFromFence(fence, resolved, projectContextForFence(fence, cleanMarkdownPath(id, root), sourceRoot(root, resolved))));
 			});
-			return rewritten === code ? null : rewritten;
+			if (rewritten === code) return null;
+			needsClientAsset = true;
+			return rewritten;
 		},
 		configureServer(server) {
-			if (resolved.proxy) mountProxies(server, resolved.endpoints.rust, resolved.endpoints.go);
+			if (resolved.proxy) mountProxies(server, proxyTargets.rust, proxyTargets.go);
 			server.middlewares.use(async (req, res, next) => {
 				const urlPath = req.url?.split("?")[0] ?? "";
 				if (urlPath === `${base}ox-code-play.js`.replace(/\/{2,}/g, "/")) {
@@ -414,22 +965,33 @@ function codePlay(options = {}) {
 			});
 		},
 		async generateBundle() {
-			const file = resolveClientFile();
-			if (!file || command !== "build") return;
+			if (command !== "build" || !needsClientAsset) return;
+			const source = await loadClientSource();
+			if (!source) return;
 			this.emitFile({
 				type: "asset",
 				fileName: "ox-code-play.js",
-				source: assertBrowserClientSource(await readFile(file, "utf8"))
+				source
 			});
+			emittedClientAsset = true;
 		},
 		async closeBundle() {
 			if (command !== "build") return;
 			const srcDir = path.resolve(root, resolved.srcDir ?? "docs");
 			const destination = path.resolve(root, outDir ?? "dist");
 			if (!existsSync(srcDir) || !existsSync(destination)) return;
-			await enhanceWrittenPages(srcDir, destination, resolved, enhanceOptions);
+			if (!await enhanceWrittenPages(srcDir, destination, resolved, enhanceOptions)) return;
+			needsClientAsset = true;
+			if (!emittedClientAsset) await writeClientAsset(destination, await loadClientSource());
 		}
 	};
+	async function loadClientSource() {
+		if (clientSource) return clientSource;
+		const file = resolveClientFile();
+		if (!file) return;
+		clientSource = assertBrowserClientSource(await readFile(file, "utf8"));
+		return clientSource;
+	}
 }
 function interceptHtml(res, enhance) {
 	const originalEnd = res.end.bind(res);
@@ -451,6 +1013,7 @@ function enhanceHtmlForUrl(urlPath, html, root, resolved, enhance) {
 	const markdownPath = urlToMarkdown(urlPath, root, resolved.srcDir ?? "docs", resolved.base);
 	if (!markdownPath || !existsSync(markdownPath)) return;
 	const source = readFileSync(markdownPath, "utf8");
+	const srcRoot = sourceRoot(root, resolved);
 	const fences = [...parsePlayFences(source), ...parseCodePlayTags(source)].filter((fence) => {
 		const definition = resolveLanguage(fence.language);
 		return Boolean(definition && resolved.languages.has(definition.id));
@@ -459,16 +1022,9 @@ function enhanceHtmlForUrl(urlPath, html, root, resolved, enhance) {
 	return enhancePlayHtml(html, enhance(fences.map((fence) => ({
 		language: fence.language,
 		code: fence.code,
-		payload: encodePayload(payloadFromFence(fence, resolved))
+		payload: encodePayload(payloadFromFence(fence, resolved, projectContextForFence(fence, markdownPath, srcRoot)))
 	}))));
 }
-function urlToMarkdown(urlPath, root, srcDir, base) {
-	let relative = urlPath;
-	if (base !== "/" && relative.startsWith(base)) relative = relative.slice(base.length);
-	relative = relative.replace(/^\//, "").replace(/\.html$/, "");
-	if (!relative || relative.includes("..")) return;
-	return [path.resolve(root, srcDir, `${relative}.md`), path.resolve(root, srcDir, relative, "index.md")].find((candidate) => existsSync(candidate));
-}
 function mountProxies(server, rustUrl, goUrl) {
 	server.middlewares.use("/__ox-code-play/rust", (req, res) => {
 		proxy(req, res, rustUrl, "application/json");
@@ -481,6 +1037,7 @@ function mountProxies(server, rustUrl, goUrl) {
 	});
 }
 async function enhanceWrittenPages(srcDir, outDir, resolved, enhance) {
+	let enhancedAny = false;
 	for (const file of walkFiles(srcDir)) {
 		if (!MARKDOWN_RE.test(file)) continue;
 		const source = await readFile(file, "utf8");
@@ -495,30 +1052,23 @@ async function enhanceWrittenPages(srcDir, outDir, resolved, enhance) {
 		const enhanced = enhancePlayHtml(html, enhance(fences.map((fence) => ({
 			language: fence.language,
 			code: fence.code,
-			payload: encodePayload(payloadFromFence(fence, resolved))
+			payload: encodePayload(payloadFromFence(fence, resolved, projectContextForFence(fence, file, srcDir)))
 		}))));
-		if (enhanced !== html) await writeFile(htmlPath, enhanced);
-	}
-}
-function guessHtmlPath(file, srcDir, outDir) {
-	const relative = path.relative(srcDir, file).replace(/\.(?:md|markdown|mdx)$/i, "");
-	return [path.join(outDir, `${relative}.html`), path.join(outDir, relative, "index.html")].find((candidate) => existsSync(candidate));
-}
-function walkFiles(dir) {
-	const entries = readdirSync(dir);
-	const files = [];
-	for (const entry of entries) {
-		const full = path.join(dir, entry);
-		if (statSync(full).isDirectory()) files.push(...walkFiles(full));
-		else files.push(full);
+		if (enhanced !== html) {
+			await writeFile(htmlPath, enhanced);
+			enhancedAny = true;
+		}
 	}
-	return files;
+	return enhancedAny;
 }
-function normalizeBase(base) {
-	if (!base || base === "/") return "/";
-	return base.endsWith("/") ? base : `${base}/`;
+function projectContextForFence(fence, documentPath, srcRoot) {
+	if (!fence.project) return {};
+	return collectProjectFiles(fence.project, {
+		documentPath,
+		sourceRoot: srcRoot
+	});
 }
 //#endregion
-export { stripPlayMeta as a, rewritePlayFences as i, parseCodePlayTags as n, enhanceGeneratedModule as o, parsePlayFences as r, enhancePlayHtml as s, codePlay as t };
+export { normalizeProjectPath as a, parseCodePlayTags as c, stripPlayMeta as d, PROJECT_SANDBOX_ADAPTERS as i, parsePlayFences as l, enhanceGeneratedModule as n, projectSandboxFromPayloadInput as o, enhancePlayHtml as r, projectSandboxProviderLabel as s, codePlay as t, rewritePlayFences as u };
 
 //# sourceMappingURL=plugin2.mjs.map