@farming-labs/docs 0.2.60 → 0.2.62

package/dist/code-blocks-qe0T8-xe.mjs

@@ -1,871 +0,0 @@
-import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
-import path from "node:path";
-import { execFile } from "node:child_process";
-import { tmpdir } from "node:os";
-import { promisify } from "node:util";
-
-//#region src/code-blocks.ts
-const execFileAsync = promisify(execFile);
-const DEFAULT_ENV_FILES = [
-	".env.local",
-	".env.test",
-	".env"
-];
-const DEFAULT_COMMAND_TIMEOUT_MS = 6e4;
-function resolveDocsCodeBlocksValidateConfig(input) {
-	if (input === false || input === void 0) return {
-		enabled: false,
-		planner: { provider: "metadata" },
-		runner: {
-			provider: "local",
-			tokenEnv: "VERCEL_TOKEN",
-			projectIdEnv: "VERCEL_PROJECT_ID",
-			teamIdEnv: "VERCEL_TEAM_ID",
-			projectJson: ".vercel/project.json",
-			runtime: "node24",
-			apiUrlEnv: "DAYTONA_API_URL",
-			targetEnv: "DAYTONA_TARGET",
-			timeoutMs: DEFAULT_COMMAND_TIMEOUT_MS
-		},
-		envFile: DEFAULT_ENV_FILES,
-		env: {},
-		missingEnv: "skip",
-		unsupportedLanguage: "skip",
-		mode: "report"
-	};
-	const config = input === true ? {} : input;
-	const planner = normalizePlannerConfig(config.planner);
-	const runner = normalizeRunnerConfig(config.runner);
-	const envFile = Array.isArray(config.envFile) ? config.envFile : typeof config.envFile === "string" ? [config.envFile] : DEFAULT_ENV_FILES;
-	return {
-		enabled: config.enabled ?? true,
-		planner,
-		runner,
-		envFile,
-		env: config.env ?? {},
-		missingEnv: config.missingEnv ?? "skip",
-		unsupportedLanguage: config.unsupportedLanguage ?? "skip",
-		mode: config.mode ?? "report"
-	};
-}
-function parseCodeFenceInfo(info) {
-	const trimmed = info.trim();
-	if (!trimmed) return { meta: {} };
-	const firstToken = trimmed.match(/^(\S+)/)?.[1] ?? "";
-	const language = firstToken && !firstToken.includes("=") ? firstToken : void 0;
-	const attributeSource = language ? trimmed.slice(firstToken.length).trim() : trimmed;
-	const meta = {};
-	const attributePattern = /([A-Za-z_:][\w:.-]*)(?:=(?:"([^"]*)"|'([^']*)'|([^\s"']+)))?/g;
-	let match;
-	while (match = attributePattern.exec(attributeSource)) {
-		const key = match[1];
-		meta[key] = match[2] ?? match[3] ?? match[4] ?? true;
-	}
-	return {
-		language,
-		meta
-	};
-}
-function extractCodeBlocksFromMarkdown(input) {
-	const blocks = [];
-	const lines = input.source.split("\n");
-	let openFence;
-	for (let index = 0; index < lines.length; index += 1) {
-		const line = lines[index] ?? "";
-		const trimmed = line.trim();
-		if (!openFence) {
-			const openMatch = trimmed.match(/^(`{3,}|~{3,})(.*)$/);
-			if (!openMatch) continue;
-			openFence = {
-				marker: openMatch[1],
-				info: openMatch[2]?.trim() ?? "",
-				code: [],
-				lineStart: index + 1
-			};
-			continue;
-		}
-		if (isClosingFence(trimmed, openFence.marker)) {
-			const parsed = parseCodeFenceInfo(openFence.info);
-			const meta = parsed.meta;
-			const blockIndex = blocks.length + 1;
-			const relativePath = input.relativePath ?? input.filePath;
-			blocks.push({
-				id: `${relativePath}#code-${blockIndex}`,
-				filePath: input.filePath,
-				relativePath,
-				lineStart: openFence.lineStart,
-				lineEnd: index + 1,
-				language: parsed.language,
-				title: readStringMeta(meta, "title"),
-				framework: readStringMeta(meta, "framework"),
-				packageManager: readStringMeta(meta, "packageManager"),
-				runnable: readBooleanMeta(meta, "runnable") ?? false,
-				env: readEnvMeta(meta),
-				meta,
-				code: openFence.code.join("\n")
-			});
-			openFence = void 0;
-			continue;
-		}
-		openFence.code.push(line);
-	}
-	return blocks;
-}
-function collectCodeBlockTargets(options) {
-	const root = path.resolve(options.rootDir);
-	const contentRoot = path.resolve(root, options.contentDir);
-	if (!existsSync(contentRoot)) return [];
-	return walkMarkdownFiles(contentRoot).flatMap((filePath) => {
-		return extractCodeBlocksFromMarkdown({
-			source: readFileSync(filePath, "utf-8"),
-			filePath,
-			relativePath: path.relative(root, filePath).replace(/\\/g, "/")
-		});
-	});
-}
-async function planCodeBlockTargets(targets, config) {
-	if (config.planner.provider === "metadata") return targets.map((target) => buildMetadataExecutionPlan(target, config));
-	if (config.planner.provider === "cloud") throw new Error("Hosted cloud code block planning is not available in this package yet.");
-	return planWithOpenAICompatibleProvider(targets, config);
-}
-async function validateCodeBlockPlans(input) {
-	const validationEnv = loadValidationEnv(input.rootDir, input.config);
-	const preflight = input.plans.map((plan) => preflightPlan(plan, input.config, validationEnv));
-	const runnable = preflight.filter((result) => result.status !== "SKIP" && !result.reason);
-	const skippedOrFailed = preflight.filter((result) => result.status === "SKIP" || result.reason);
-	const plansToRun = runnable.map((result) => result.plan);
-	if (plansToRun.length === 0) return skippedOrFailed;
-	const runResults = await runPlansWithConfiguredRunner(plansToRun, input.rootDir, input.config, validationEnv.env);
-	return [...skippedOrFailed, ...runResults].sort((a, b) => a.id.localeCompare(b.id));
-}
-async function validateCodeBlocks(input) {
-	const targets = collectCodeBlockTargets({
-		rootDir: input.rootDir,
-		contentDir: input.contentDir
-	});
-	const plans = await planCodeBlockTargets(targets, input.config);
-	const results = input.planOnly || input.config.mode === "plan" ? plans.map((plan) => ({
-		id: plan.id,
-		target: plan.target,
-		plan,
-		status: plan.action === "skip" ? "SKIP" : "PLAN",
-		reason: plan.reason ?? (plan.action === "skip" ? "planned skip" : "planned")
-	})) : await validateCodeBlockPlans({
-		plans,
-		rootDir: input.rootDir,
-		config: input.config
-	});
-	return {
-		summary: results.reduce((acc, result) => {
-			acc.total += 1;
-			if (result.status === "PLAN") acc.planned += 1;
-			if (result.status === "PASS") acc.pass += 1;
-			if (result.status === "SKIP") acc.skip += 1;
-			if (result.status === "FAIL") acc.fail += 1;
-			return acc;
-		}, {
-			total: 0,
-			planned: 0,
-			pass: 0,
-			skip: 0,
-			fail: 0
-		}),
-		config: input.config,
-		targets,
-		plans,
-		results
-	};
-}
-function normalizePlannerConfig(input) {
-	if (!input) return { provider: "metadata" };
-	if (typeof input === "string") return { provider: input };
-	return {
-		provider: input.provider ?? "metadata",
-		...input
-	};
-}
-function normalizeRunnerConfig(input) {
-	const config = typeof input === "string" ? { provider: input } : input ?? {};
-	const provider = config.provider ?? "local";
-	return {
-		provider,
-		tokenEnv: config.tokenEnv ?? defaultRunnerTokenEnv(provider),
-		projectIdEnv: config.projectIdEnv ?? "VERCEL_PROJECT_ID",
-		teamIdEnv: config.teamIdEnv ?? "VERCEL_TEAM_ID",
-		projectJson: config.projectJson === void 0 ? ".vercel/project.json" : config.projectJson,
-		runtime: config.runtime ?? "node24",
-		apiUrlEnv: config.apiUrlEnv ?? "DAYTONA_API_URL",
-		targetEnv: config.targetEnv ?? "DAYTONA_TARGET",
-		timeoutMs: config.timeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS
-	};
-}
-function defaultRunnerTokenEnv(provider) {
-	if (provider === "e2b") return "E2B_API_KEY";
-	if (provider === "daytona") return "DAYTONA_API_KEY";
-	return "VERCEL_TOKEN";
-}
-function buildMetadataExecutionPlan(target, config) {
-	const language = normalizeLanguage(target.language);
-	const template = target.framework ?? templateFromLanguage(language);
-	const requiredEnv = target.env;
-	if (readBooleanMeta(target.meta, "partial") || looksPartial(target.code)) return skipPlan(target, template, requiredEnv, "partial fragment", config.planner.provider);
-	if (!language) {
-		if (!target.runnable) return skipPlan(target, "unknown", requiredEnv, "code block is not marked runnable", config.planner.provider);
-		if (looksLikeShellCommand(target.code)) return shellPlan(target, "shell", requiredEnv, config.planner.provider);
-		return skipPlan(target, "unknown", requiredEnv, "missing language and not obviously runnable", config.planner.provider);
-	}
-	if (!target.runnable) return skipPlan(target, template, requiredEnv, "code block is not marked runnable", config.planner.provider);
-	if (isShellLanguage(language)) return shellPlan(target, template, requiredEnv, config.planner.provider);
-	if (language === "json") return syntaxPlan(target, "json", "node", requiredEnv, config.planner.provider);
-	if (language === "javascript" || language === "js" || language === "jsx") return executePlan(target, template, "node", "js", {
-		cmd: "node",
-		args: []
-	}, requiredEnv, config.planner.provider);
-	if (language === "typescript" || language === "ts" || language === "tsx") return executePlan(target, template, "tsx", "ts", {
-		cmd: "npx",
-		args: ["--yes", "tsx"]
-	}, requiredEnv, config.planner.provider);
-	if (language === "python" || language === "py") return executePlan(target, template, "python3", "py", {
-		cmd: "python3",
-		args: []
-	}, requiredEnv, config.planner.provider);
-	if (language === "ruby" || language === "rb") return executePlan(target, template, "ruby", "rb", {
-		cmd: "ruby",
-		args: []
-	}, requiredEnv, config.planner.provider);
-	if (language === "elixir" || language === "ex" || language === "exs") return executePlan(target, template, "elixir", "exs", {
-		cmd: "elixir",
-		args: []
-	}, requiredEnv, config.planner.provider);
-	if (language === "yaml" || language === "yml") return skipPlan(target, "yaml", requiredEnv, "YAML syntax validation requires a YAML parser", config.planner.provider);
-	if (!target.runnable) return skipPlan(target, template, requiredEnv, "code block is not marked runnable", config.planner.provider);
-	return skipPlan(target, template, requiredEnv, `unsupported language: ${target.language}`, config.planner.provider);
-}
-function executePlan(target, template, runtime, extension, command, requiredEnv, planner) {
-	const filePath = `snippet-${slugify(target.id)}.${extension}`;
-	return {
-		id: target.id,
-		target,
-		action: "execute",
-		template,
-		runtime,
-		filePath,
-		command: {
-			cmd: command.cmd,
-			args: [...command.args, filePath]
-		},
-		requiredEnv,
-		planner
-	};
-}
-function shellPlan(target, template, requiredEnv, planner) {
-	const filePath = `snippet-${slugify(target.id)}.sh`;
-	return {
-		id: target.id,
-		target,
-		action: "execute",
-		template,
-		runtime: "bash",
-		filePath,
-		command: {
-			cmd: "bash",
-			args: [filePath]
-		},
-		requiredEnv,
-		planner
-	};
-}
-function syntaxPlan(target, template, runtime, requiredEnv, planner) {
-	const filePath = `snippet-${slugify(target.id)}.json`;
-	return {
-		id: target.id,
-		target,
-		action: "validate-syntax",
-		template,
-		runtime,
-		filePath,
-		command: {
-			cmd: "node",
-			args: [
-				"-e",
-				`JSON.parse(require("node:fs").readFileSync(process.argv[1], "utf8"))`,
-				filePath
-			]
-		},
-		requiredEnv,
-		planner
-	};
-}
-function skipPlan(target, template, requiredEnv, reason, planner) {
-	return {
-		id: target.id,
-		target,
-		action: "skip",
-		template,
-		requiredEnv,
-		reason,
-		planner
-	};
-}
-async function planWithOpenAICompatibleProvider(targets, config) {
-	const baseUrl = config.planner.baseUrl ?? (config.planner.baseUrlEnv ? process.env[config.planner.baseUrlEnv] : void 0) ?? (config.planner.provider === "openai" ? "https://api.openai.com/v1" : void 0);
-	const apiKey = config.planner.apiKey ?? (config.planner.apiKeyEnv ? process.env[config.planner.apiKeyEnv] : void 0);
-	if (!baseUrl) throw new Error("codeBlocks.validate planner requires baseUrl or baseUrlEnv.");
-	if (!apiKey) throw new Error(`codeBlocks.validate planner requires an API key. Set ${config.planner.apiKeyEnv ?? "apiKeyEnv"} in your environment.`);
-	const metadataPlans = targets.map((target) => buildMetadataExecutionPlan(target, config));
-	const response = await fetch(`${baseUrl.replace(/\/+$/, "")}/chat/completions`, {
-		method: "POST",
-		headers: {
-			Authorization: `Bearer ${apiKey}`,
-			"Content-Type": "application/json"
-		},
-		body: JSON.stringify({
-			model: config.planner.model ?? "gpt-4.1-mini",
-			temperature: 0,
-			response_format: { type: "json_object" },
-			messages: [{
-				role: "system",
-				content: "You produce JSON execution plans for documentation code blocks. Do not rewrite snippets. If the snippet is partial, missing setup, or unsafe, choose action skip. Return only JSON."
-			}, {
-				role: "user",
-				content: JSON.stringify({
-					contract: { plans: "array of {id, action: execute|validate-syntax|skip, template, runtime?, reason?, requiredEnv?: string[]}" },
-					codeBlocks: targets.map((target) => ({
-						id: target.id,
-						language: target.language,
-						title: target.title,
-						framework: target.framework,
-						packageManager: target.packageManager,
-						runnable: target.runnable,
-						env: target.env,
-						meta: target.meta,
-						code: target.code.slice(0, 8e3)
-					}))
-				})
-			}]
-		})
-	});
-	if (!response.ok) throw new Error(`Planner request failed with ${response.status} ${response.statusText}.`);
-	const content = (await response.json()).choices?.[0]?.message?.content ?? "";
-	let parsed;
-	try {
-		parsed = JSON.parse(content);
-	} catch {
-		throw new Error("Planner returned non-JSON content.");
-	}
-	const byId = new Map(metadataPlans.map((plan) => [plan.id, plan]));
-	for (const plan of parsed.plans ?? []) {
-		if (!plan.id || !byId.has(plan.id)) continue;
-		const fallback = byId.get(plan.id);
-		byId.set(plan.id, {
-			...fallback,
-			action: isPlanAction(plan.action) ? plan.action : fallback.action,
-			template: typeof plan.template === "string" && plan.template ? plan.template : fallback.template,
-			runtime: typeof plan.runtime === "string" && plan.runtime ? plan.runtime : fallback.runtime,
-			requiredEnv: Array.isArray(plan.requiredEnv) ? plan.requiredEnv.filter((value) => typeof value === "string") : fallback.requiredEnv,
-			reason: typeof plan.reason === "string" ? plan.reason : fallback.reason,
-			planner: config.planner.provider
-		});
-	}
-	return metadataPlans.map((plan) => byId.get(plan.id));
-}
-function preflightPlan(plan, config, validationEnv) {
-	if (plan.action === "skip") return {
-		id: plan.id,
-		target: plan.target,
-		plan,
-		status: "SKIP",
-		reason: plan.reason
-	};
-	const missingEnv = plan.requiredEnv.filter((key) => !validationEnv.env[key]);
-	if (missingEnv.length > 0) {
-		const reason = `missing env: ${missingEnv.join(", ")}`;
-		return {
-			id: plan.id,
-			target: plan.target,
-			plan,
-			status: config.missingEnv === "error" ? "FAIL" : "SKIP",
-			reason
-		};
-	}
-	if (!plan.command || !plan.filePath) return {
-		id: plan.id,
-		target: plan.target,
-		plan,
-		status: config.unsupportedLanguage === "error" ? "FAIL" : "SKIP",
-		reason: "no executable command in plan"
-	};
-	return {
-		id: plan.id,
-		target: plan.target,
-		plan,
-		status: "PASS"
-	};
-}
-async function runPlansLocally(plans, config, env) {
-	const tempDir = mkdtempSync(path.join(tmpdir(), "docs-codeblocks-"));
-	try {
-		return await Promise.all(plans.map(async (plan) => {
-			if (!plan.command || !plan.filePath) return skippedResult(plan, "no executable command in plan");
-			writeFileSync(path.join(tempDir, plan.filePath), plan.target.code, "utf-8");
-			try {
-				const result = await execFileAsync(plan.command.cmd, plan.command.args, {
-					cwd: tempDir,
-					env: {
-						...process.env,
-						...env
-					},
-					timeout: config.runner.timeoutMs,
-					maxBuffer: 1024 * 1024
-				});
-				return {
-					id: plan.id,
-					target: plan.target,
-					plan,
-					status: "PASS",
-					stdout: result.stdout,
-					stderr: result.stderr,
-					exitCode: 0
-				};
-			} catch (error) {
-				const err = error;
-				return {
-					id: plan.id,
-					target: plan.target,
-					plan,
-					status: "FAIL",
-					stdout: err.stdout,
-					stderr: err.stderr,
-					exitCode: typeof err.code === "number" ? err.code : null,
-					reason: err.signal ? `terminated by ${err.signal}` : err.message
-				};
-			}
-		}));
-	} finally {
-		rmSync(tempDir, {
-			force: true,
-			recursive: true
-		});
-	}
-}
-async function runPlansWithConfiguredRunner(plans, rootDir, config, env) {
-	switch (config.runner.provider) {
-		case "local": return runPlansLocally(plans, config, env);
-		case "vercel-sandbox": return runPlansInVercelSandbox(plans, rootDir, config, env);
-		case "e2b": return runPlansInE2B(plans, config, env);
-		case "daytona": return runPlansInDaytona(plans, config, env);
-		case "cloud": return plans.map((plan) => skippedResult(plan, "cloud runner is not available in this package yet"));
-	}
-}
-async function runPlansInVercelSandbox(plans, rootDir, config, env) {
-	const credentials = await resolveVercelSandboxCredentials(rootDir, config);
-	if (credentials.missing.length > 0) return plans.map((plan) => skippedResult(plan, `missing ${credentials.missing.join(", ")}`));
-	try {
-		const { Sandbox } = await import("@vercel/sandbox");
-		const sandbox = await Sandbox.create({
-			runtime: config.runner.runtime,
-			timeout: Math.max(config.runner.timeoutMs * Math.max(1, plans.length), config.runner.timeoutMs),
-			env,
-			token: credentials.token,
-			projectId: credentials.projectId,
-			teamId: credentials.teamId
-		});
-		try {
-			return await Promise.all(plans.map(async (plan) => {
-				if (!plan.command || !plan.filePath) return skippedResult(plan, "no executable command in plan");
-				await sandbox.writeFiles([{
-					path: plan.filePath,
-					content: Buffer.from(plan.target.code)
-				}]);
-				const command = await sandbox.runCommand({
-					cmd: plan.command.cmd,
-					args: plan.command.args,
-					cwd: "/vercel/sandbox",
-					env
-				});
-				const [stdout, stderr] = await Promise.all([command.stdout(), command.stderr()]);
-				return {
-					id: plan.id,
-					target: plan.target,
-					plan,
-					status: command.exitCode === 0 ? "PASS" : "FAIL",
-					stdout,
-					stderr,
-					exitCode: command.exitCode,
-					reason: command.exitCode === 0 ? void 0 : `exit code ${command.exitCode}`
-				};
-			}));
-		} finally {
-			await sandbox.stop().catch(() => {});
-		}
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		return plans.map((plan) => skippedResult(plan, `vercel-sandbox unavailable: ${message}`));
-	}
-}
-async function runPlansInE2B(plans, config, env) {
-	const token = process.env[config.runner.tokenEnv];
-	if (!token) return plans.map((plan) => skippedResult(plan, `missing ${config.runner.tokenEnv}`));
-	const module = await importOptionalModule("e2b");
-	if (!module) return plans.map((plan) => skippedResult(plan, "e2b unavailable: install the \"e2b\" package"));
-	try {
-		const E2BSandbox = readProviderExport(module, "default") ?? readProviderExport(module, "Sandbox");
-		if (!hasCreateMethod(E2BSandbox)) return plans.map((plan) => skippedResult(plan, "e2b unavailable: missing Sandbox.create"));
-		const sandbox = await withTemporaryEnv("E2B_API_KEY", token, () => E2BSandbox.create());
-		try {
-			return await Promise.all(plans.map(async (plan) => {
-				if (!plan.command || !plan.filePath) return skippedResult(plan, "no executable command in plan");
-				const command = buildSandboxShellCommand(plan);
-				const runner = readObject(sandbox).commands;
-				if (!hasRunMethod(runner)) return skippedResult(plan, "e2b unavailable: missing commands.run");
-				try {
-					return sandboxCommandResult(plan, await runner.run(command, {
-						envs: env,
-						timeoutMs: config.runner.timeoutMs
-					}));
-				} catch (error) {
-					return failedSandboxResult(plan, error);
-				}
-			}));
-		} finally {
-			await cleanupProviderSandbox(sandbox);
-		}
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		return plans.map((plan) => skippedResult(plan, `e2b unavailable: ${message}`));
-	}
-}
-async function runPlansInDaytona(plans, config, env) {
-	const token = process.env[config.runner.tokenEnv];
-	if (!token) return plans.map((plan) => skippedResult(plan, `missing ${config.runner.tokenEnv}`));
-	const module = await importOptionalModule("@daytona/sdk");
-	if (!module) return plans.map((plan) => skippedResult(plan, "daytona unavailable: install the \"@daytona/sdk\" package"));
-	try {
-		const Daytona = readProviderExport(module, "Daytona");
-		if (!hasConstructor(Daytona)) return plans.map((plan) => skippedResult(plan, "daytona unavailable: missing Daytona SDK"));
-		const apiUrl = process.env[config.runner.apiUrlEnv];
-		const target = process.env[config.runner.targetEnv];
-		const daytona = new Daytona({
-			apiKey: token,
-			...apiUrl ? { apiUrl } : {},
-			...target ? { target } : {}
-		});
-		if (!hasCreateMethod(daytona)) return plans.map((plan) => skippedResult(plan, "daytona unavailable: missing create"));
-		const sandbox = await daytona.create({
-			ephemeral: true,
-			language: "typescript",
-			...Object.keys(env).length > 0 ? { envVars: env } : {}
-		});
-		try {
-			return await Promise.all(plans.map(async (plan) => {
-				if (!plan.command || !plan.filePath) return skippedResult(plan, "no executable command in plan");
-				const processApi = readObject(sandbox).process;
-				if (!hasExecuteCommandMethod(processApi)) return skippedResult(plan, "daytona unavailable: missing process.executeCommand");
-				try {
-					return sandboxCommandResult(plan, await processApi.executeCommand(buildSandboxShellCommand(plan)));
-				} catch (error) {
-					return failedSandboxResult(plan, error);
-				}
-			}));
-		} finally {
-			await cleanupProviderSandbox(sandbox);
-			await cleanupProviderSandbox(daytona);
-		}
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		return plans.map((plan) => skippedResult(plan, `daytona unavailable: ${message}`));
-	}
-}
-async function resolveVercelSandboxCredentials(rootDir, config) {
-	const projectJson = readVercelProjectJson(rootDir, config.runner.projectJson);
-	const token = process.env[config.runner.tokenEnv];
-	if (!token && process.env.VERCEL_OIDC_TOKEN) return { missing: [] };
-	if (!token) return { missing: [config.runner.tokenEnv] };
-	const envProjectId = process.env[config.runner.projectIdEnv];
-	const envTeamId = process.env[config.runner.teamIdEnv];
-	const discoveredProject = !(envProjectId && envTeamId) && !(projectJson?.projectId && projectJson?.orgId) ? await discoverVercelSandboxProject(token) : void 0;
-	const projectId = envProjectId ?? projectJson?.projectId ?? discoveredProject?.projectId;
-	const teamId = envTeamId ?? projectJson?.orgId ?? discoveredProject?.teamId;
-	return {
-		token,
-		projectId,
-		teamId,
-		missing: [projectId ? void 0 : "Vercel project id", teamId ? void 0 : "Vercel team id"].filter((value) => Boolean(value))
-	};
-}
-async function discoverVercelSandboxProject(token) {
-	try {
-		const response = await fetch("https://api.vercel.com/v9/projects?limit=1", { headers: { Authorization: `Bearer ${token}` } });
-		if (!response.ok) return void 0;
-		const project = (await response.json()).projects?.[0];
-		if (!project) return void 0;
-		return {
-			projectId: typeof project.id === "string" ? project.id : void 0,
-			teamId: typeof project.accountId === "string" ? project.accountId : void 0
-		};
-	} catch {
-		return;
-	}
-}
-function readVercelProjectJson(rootDir, projectJson) {
-	if (projectJson === false) return void 0;
-	const fullPath = path.resolve(rootDir, projectJson);
-	if (!existsSync(fullPath)) return void 0;
-	try {
-		const parsed = JSON.parse(readFileSync(fullPath, "utf-8"));
-		return {
-			projectId: typeof parsed.projectId === "string" ? parsed.projectId : void 0,
-			orgId: typeof parsed.orgId === "string" ? parsed.orgId : void 0
-		};
-	} catch {
-		return;
-	}
-}
-async function importOptionalModule(specifier) {
-	const importer = globalThis.__DOCS_CODE_BLOCKS_MODULE_IMPORTER__ ?? ((id) => import(id));
-	try {
-		return await importer(specifier);
-	} catch {
-		return;
-	}
-}
-function buildSandboxShellCommand(plan) {
-	const command = plan.command;
-	const filePath = plan.filePath;
-	if (!command || !filePath) return "";
-	const sandboxDir = "/tmp/docs-codeblocks";
-	const writeFileCommand = [
-		"printf",
-		"%s",
-		Buffer.from(plan.target.code, "utf-8").toString("base64"),
-		"|",
-		"base64",
-		"-d",
-		">",
-		filePath
-	].map((part) => part === "|" || part === ">" ? part : shellEscape(part)).join(" ");
-	return [
-		`mkdir -p ${shellEscape(sandboxDir)}`,
-		`cd ${shellEscape(sandboxDir)}`,
-		writeFileCommand,
-		shellJoin([command.cmd, ...command.args])
-	].join(" && ");
-}
-function shellJoin(parts) {
-	return parts.map(shellEscape).join(" ");
-}
-function shellEscape(value) {
-	return `'${value.replace(/'/g, "'\\''")}'`;
-}
-async function withTemporaryEnv(key, value, callback) {
-	const previous = process.env[key];
-	process.env[key] = value;
-	try {
-		return await callback();
-	} finally {
-		if (previous === void 0) delete process.env[key];
-		else process.env[key] = previous;
-	}
-}
-function sandboxCommandResult(plan, result) {
-	const record = readObject(result);
-	const error = readStringValue(record.error);
-	const exitCode = readNumberValue(record.exitCode) ?? readNumberValue(record.code) ?? readNumberValue(record.exit_code) ?? (error ? 1 : 0);
-	const stdout = readStringValue(record.stdout) ?? readStringValue(record.result) ?? readStringValue(record.text) ?? "";
-	const stderr = readStringValue(record.stderr) ?? error ?? "";
-	return {
-		id: plan.id,
-		target: plan.target,
-		plan,
-		status: exitCode === 0 ? "PASS" : "FAIL",
-		stdout,
-		stderr,
-		exitCode,
-		reason: exitCode === 0 ? void 0 : `exit code ${exitCode}`
-	};
-}
-function failedSandboxResult(plan, error) {
-	const record = readObject(error);
-	return {
-		id: plan.id,
-		target: plan.target,
-		plan,
-		status: "FAIL",
-		stdout: readStringValue(record.stdout),
-		stderr: readStringValue(record.stderr),
-		exitCode: readNumberValue(record.exitCode) ?? readNumberValue(record.code) ?? null,
-		reason: error instanceof Error ? error.message : String(error)
-	};
-}
-async function cleanupProviderSandbox(value) {
-	const record = readObject(value);
-	for (const methodName of [
-		"kill",
-		"close",
-		"stop",
-		"delete",
-		"remove",
-		"destroy"
-	]) {
-		const method = record[methodName];
-		if (typeof method !== "function") continue;
-		await Promise.resolve(method.call(value)).catch(() => {});
-		return;
-	}
-}
-function readProviderExport(module, name) {
-	return readObject(module)[name];
-}
-function readObject(value) {
-	return value !== null && (typeof value === "object" || typeof value === "function") ? value : {};
-}
-function readStringValue(value) {
-	return typeof value === "string" ? value : void 0;
-}
-function readNumberValue(value) {
-	return typeof value === "number" ? value : void 0;
-}
-function hasCreateMethod(value) {
-	return typeof readObject(value).create === "function";
-}
-function hasRunMethod(value) {
-	return typeof readObject(value).run === "function";
-}
-function hasExecuteCommandMethod(value) {
-	return typeof readObject(value).executeCommand === "function";
-}
-function hasConstructor(value) {
-	return typeof value === "function";
-}
-function loadValidationEnv(rootDir, config) {
-	const fileEnv = {};
-	for (const file of config.envFile) {
-		const fullPath = path.resolve(rootDir, file);
-		if (!existsSync(fullPath)) continue;
-		Object.assign(fileEnv, parseEnvFile(readFileSync(fullPath, "utf-8")));
-	}
-	const resolved = {};
-	const missing = [];
-	for (const [runtimeKey, sourceKey] of Object.entries(config.env)) {
-		const value = process.env[sourceKey] ?? fileEnv[sourceKey];
-		if (value === void 0) {
-			missing.push(runtimeKey);
-			continue;
-		}
-		resolved[runtimeKey] = value;
-	}
-	return {
-		env: resolved,
-		missing
-	};
-}
-function parseEnvFile(source) {
-	const env = {};
-	for (const line of source.split(/\r?\n/)) {
-		const trimmed = line.trim();
-		if (!trimmed || trimmed.startsWith("#")) continue;
-		const equals = trimmed.indexOf("=");
-		if (equals <= 0) continue;
-		const key = trimmed.slice(0, equals).trim();
-		env[key] = trimmed.slice(equals + 1).trim().replace(/^['"]|['"]$/g, "");
-	}
-	return env;
-}
-function readStringMeta(meta, key) {
-	const value = meta[key];
-	return typeof value === "string" && value.trim().length > 0 ? value : void 0;
-}
-function readBooleanMeta(meta, key) {
-	const value = meta[key];
-	if (typeof value === "boolean") return value;
-	if (typeof value !== "string") return void 0;
-	const normalized = value.trim().toLowerCase();
-	if (!normalized || normalized === "true" || normalized === "1" || normalized === "yes") return true;
-	if (normalized === "false" || normalized === "0" || normalized === "no") return false;
-	return true;
-}
-function readEnvMeta(meta) {
-	const direct = meta.env;
-	const values = /* @__PURE__ */ new Set();
-	if (typeof direct === "string") for (const item of direct.split(/[,\s]+/)) {
-		const trimmed = item.trim();
-		if (trimmed) values.add(trimmed);
-	}
-	for (const [key, value] of Object.entries(meta)) {
-		if (!key.startsWith("env:") && !key.startsWith("env.")) continue;
-		const envName = key.slice(4).trim();
-		if (envName && value !== false) values.add(envName);
-	}
-	return [...values];
-}
-function walkMarkdownFiles(root) {
-	const files = [];
-	const ignored = new Set([
-		".git",
-		".next",
-		".nuxt",
-		".svelte-kit",
-		"dist",
-		"node_modules",
-		"out"
-	]);
-	function visit(dir) {
-		for (const entry of readdirSync(dir)) {
-			if (ignored.has(entry)) continue;
-			const fullPath = path.join(dir, entry);
-			if (statSync(fullPath).isDirectory()) visit(fullPath);
-			else if (/\.(?:md|mdx)$/i.test(entry)) files.push(fullPath);
-		}
-	}
-	visit(root);
-	return files.sort();
-}
-function normalizeLanguage(language) {
-	return language?.trim().toLowerCase();
-}
-function isClosingFence(trimmedLine, marker) {
-	return new RegExp(`^${marker[0]}{${marker.length},}[ \\t]*$`).test(trimmedLine);
-}
-function isShellLanguage(language) {
-	return [
-		"bash",
-		"sh",
-		"shell",
-		"zsh",
-		"curl"
-	].includes(language);
-}
-function templateFromLanguage(language) {
-	if (!language) return "unknown";
-	if (isShellLanguage(language)) return "shell";
-	if (language === "js" || language === "javascript" || language === "jsx") return "node";
-	if (language === "ts" || language === "typescript" || language === "tsx") return "typescript";
-	if (language === "py" || language === "python") return "python";
-	return language;
-}
-function looksLikeShellCommand(code) {
-	return /^(?:\s*(?:npm|pnpm|yarn|bun|npx|curl|git|node|python3?|deno|uv|pip)\b)/m.test(code);
-}
-function looksPartial(code) {
-	const trimmed = code.trim();
-	if (!trimmed) return true;
-	return /^\.\.\.$/m.test(trimmed) || /\/\/\s*\.\.\.|#\s*\.\.\./.test(trimmed);
-}
-function slugify(value) {
-	return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "snippet";
-}
-function isPlanAction(value) {
-	return value === "execute" || value === "validate-syntax" || value === "skip";
-}
-function skippedResult(plan, reason) {
-	return {
-		id: plan.id,
-		target: plan.target,
-		plan,
-		status: "SKIP",
-		reason
-	};
-}
-
-//#endregion
-export { validateCodeBlocks as a, validateCodeBlockPlans as i, planCodeBlockTargets as n, resolveDocsCodeBlocksValidateConfig as r, extractCodeBlocksFromMarkdown as t };