tessera-learn 0.0.1

package/dist/plugin/index.js

@@ -0,0 +1,1239 @@
+import { svelte } from "@sveltejs/vite-plugin-svelte";
+import { fileURLToPath } from "node:url";
+import { basename, dirname, extname, relative, resolve } from "node:path";
+import { cpSync, createWriteStream, existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import JSON5 from "json5";
+import { createHash } from "node:crypto";
+import { ZipArchive } from "archiver";
+//#region src/plugin/manifest.ts
+/**
+* Module-level cache of source file contents keyed by absolute path with
+* mtime invalidation. Both `validateProject` and `generateManifest` read the
+* same .svelte / _meta.js / course.config.js files during a single build;
+* sharing the read avoids the second disk hit (and matters most on cold-cache
+* CI runs and large courses).
+*/
+const fileContentCache = /* @__PURE__ */ new Map();
+function readSourceFileCached(filePath) {
+	const stat = statSync(filePath);
+	const cached = fileContentCache.get(filePath);
+	if (cached && cached.mtimeMs === stat.mtimeMs) return cached.content;
+	const content = readFileSync(filePath, "utf-8");
+	fileContentCache.set(filePath, {
+		mtimeMs: stat.mtimeMs,
+		content
+	});
+	return content;
+}
+/** Strip numeric prefix and hyphen: "01-introduction" → "introduction" */
+function stripPrefix(name) {
+	return name.replace(/^\d+-/, "");
+}
+/** Title-case a slug: "getting-started" → "Getting Started" */
+function titleCase(slug) {
+	return slug.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+/** Derive slug from folder/file name */
+function deriveSlug(name, isFile = false) {
+	if (isFile) return basename(name, extname(name));
+	return stripPrefix(name);
+}
+/** Matches both Svelte 5 `<script module>` and legacy `<script context="module">`. */
+const MODULE_SCRIPT_RE = /<script\s+(?:context\s*=\s*["']module["']|module)[^>]*>([\s\S]*?)<\/script>/;
+/** Matches `export const pageConfig =` (RHS is read separately). */
+const PAGE_CONFIG_EXPORT_RE = /export\s+const\s+pageConfig\s*=\s*/;
+/** Matches `export default ` (RHS is read separately). */
+const DEFAULT_EXPORT_RE = /export\s+default\s*/;
+/**
+* Locate `export default { ... }` and return the object literal substring,
+* or null if no balanced object literal follows the `export default` keyword.
+* Used by both manifest extraction and project validation.
+*/
+function extractDefaultExportObjectLiteral(source) {
+	const match = source.match(DEFAULT_EXPORT_RE);
+	if (!match || match.index === void 0) return null;
+	const startIndex = source.indexOf("{", match.index);
+	if (startIndex < 0) return null;
+	return extractObjectLiteral(source, startIndex);
+}
+/**
+* Read a _meta.js file and extract its default export object.
+* Uses the same JSON5 approach as pageConfig extraction — find the object literal
+* after `export default` and parse it.
+*/
+function readMetaFile(metaPath) {
+	if (!existsSync(metaPath)) return {};
+	const objectStr = extractDefaultExportObjectLiteral(readSourceFileCached(metaPath));
+	if (!objectStr) return {};
+	try {
+		return JSON5.parse(objectStr);
+	} catch {
+		return {};
+	}
+}
+/**
+* Extract pageConfig from a .svelte file's module script block.
+*/
+function extractPageConfig(filePath) {
+	const moduleScriptMatch = readSourceFileCached(filePath).match(MODULE_SCRIPT_RE);
+	if (!moduleScriptMatch) return {};
+	const scriptContent = moduleScriptMatch[1];
+	const configMatch = scriptContent.match(PAGE_CONFIG_EXPORT_RE);
+	if (!configMatch || configMatch.index === void 0) return {};
+	const startIndex = scriptContent.indexOf("{", configMatch.index + configMatch[0].length);
+	if (startIndex < 0) return {};
+	const objectStr = extractObjectLiteral(scriptContent, startIndex);
+	if (!objectStr) return {};
+	try {
+		return JSON5.parse(objectStr);
+	} catch {
+		throw new Error(`${filePath}: pageConfig must be a static object literal (no variables, function calls, or computed values)`);
+	}
+}
+/**
+* Extract an object literal from source starting at the opening brace.
+* Tracks brace depth to find the matching closing brace.
+*/
+function extractObjectLiteral(source, startIndex) {
+	if (source[startIndex] !== "{") return null;
+	let depth = 0;
+	let inString = null;
+	let escaped = false;
+	for (let i = startIndex; i < source.length; i++) {
+		const char = source[i];
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+		if (char === "\\" && inString) {
+			escaped = true;
+			continue;
+		}
+		if (inString) {
+			if (char === inString) inString = null;
+			continue;
+		}
+		if (char === "\"" || char === "'" || char === "`") {
+			inString = char;
+			continue;
+		}
+		if (char === "/" && i + 1 < source.length && source[i + 1] === "/") {
+			const newline = source.indexOf("\n", i);
+			i = newline === -1 ? source.length : newline;
+			continue;
+		}
+		if (char === "/" && i + 1 < source.length && source[i + 1] === "*") {
+			const end = source.indexOf("*/", i + 2);
+			i = end === -1 ? source.length : end + 1;
+			continue;
+		}
+		if (char === "{") depth++;
+		if (char === "}") {
+			depth--;
+			if (depth === 0) return source.slice(startIndex, i + 1);
+		}
+	}
+	return null;
+}
+/**
+* Get sorted subdirectories of a given path.
+*/
+function getSortedDirs(dirPath) {
+	if (!existsSync(dirPath)) return [];
+	return readdirSync(dirPath).filter((name) => {
+		return statSync(resolve(dirPath, name)).isDirectory() && !name.startsWith(".");
+	}).sort();
+}
+/**
+* Get .svelte files in a directory.
+*/
+function getSvelteFiles(dirPath) {
+	if (!existsSync(dirPath)) return [];
+	return readdirSync(dirPath).filter((name) => name.endsWith(".svelte")).sort();
+}
+/**
+* Generate a course manifest by scanning the pages/ directory.
+*/
+function generateManifest(pagesDir) {
+	const sections = [];
+	const flatPages = [];
+	let pageIndex = 0;
+	const sectionDirs = getSortedDirs(pagesDir);
+	for (const sectionName of sectionDirs) {
+		const sectionPath = resolve(pagesDir, sectionName);
+		const sectionMeta = readMetaFile(resolve(sectionPath, "_meta.js"));
+		const sectionSlug = deriveSlug(sectionName);
+		const section = {
+			title: sectionMeta.title || titleCase(sectionSlug),
+			slug: sectionSlug,
+			lessons: []
+		};
+		const lessonDirs = getSortedDirs(sectionPath);
+		for (const lessonName of lessonDirs) {
+			const lessonPath = resolve(sectionPath, lessonName);
+			const lessonMeta = readMetaFile(resolve(lessonPath, "_meta.js"));
+			const lessonSlug = deriveSlug(lessonName);
+			const lesson = {
+				title: lessonMeta.title || titleCase(lessonSlug),
+				slug: lessonSlug,
+				pages: []
+			};
+			const orderedFiles = orderPageFiles(getSvelteFiles(lessonPath), lessonMeta.pages);
+			for (const fileName of orderedFiles) {
+				const filePath = resolve(lessonPath, fileName);
+				const pageSlug = deriveSlug(fileName, true);
+				let pageConfig = {};
+				try {
+					pageConfig = extractPageConfig(filePath);
+				} catch (e) {
+					console.warn(`[tessera warning] ${e.message}`);
+				}
+				const relativePath = `/pages/${sectionName}/${lessonName}/${fileName}`;
+				const page = {
+					index: pageIndex,
+					title: pageConfig.title || titleCase(pageSlug),
+					slug: pageSlug,
+					importPath: relativePath,
+					quiz: pageConfig.quiz || null
+				};
+				lesson.pages.push(page);
+				flatPages.push(page);
+				pageIndex++;
+			}
+			section.lessons.push(lesson);
+		}
+		sections.push(section);
+	}
+	return {
+		sections,
+		pages: flatPages,
+		totalPages: flatPages.length
+	};
+}
+/**
+* Order .svelte files: listed in `pages` array first (in order), then unlisted appended alphabetically.
+*/
+function orderPageFiles(allFiles, pagesArray) {
+	if (!pagesArray || pagesArray.length === 0) return allFiles;
+	const listed = pagesArray.map((name) => name.endsWith(".svelte") ? name : `${name}.svelte`);
+	const listedSet = new Set(listed);
+	const unlisted = allFiles.filter((f) => !listedSet.has(f)).sort();
+	return [...listed.filter((f) => allFiles.includes(f)), ...unlisted];
+}
+//#endregion
+//#region src/runtime/xapi/agent-rules.ts
+/**
+* xAPI Identified Agent and Basic-auth credential validation rules.
+*
+* Pure logic — no Svelte/runtime imports. Imported by both `publisher.ts`
+* (runtime validation of resolved actor / auth) and `plugin/validation.ts`
+* (build-time validation of static `course.config.js` actor / auth).
+* Keeping the rules in one place prevents the two callsites from drifting.
+*/
+/**
+* Validate that a candidate is an Identified Agent per xAPI 1.0.3.
+* Returns null on success or a human-readable error suffix on failure.
+*
+* Suffixes are prefix-friendly: callers concatenate their own label
+* (`xapi.actor`, `xapi[0].actor`, etc.) with a single space — no "actor"
+* appears in the suffix to avoid doubling.
+*/
+function validateAgent(actor) {
+	if (!actor || typeof actor !== "object") return "must be an object";
+	const a = actor;
+	if (Array.isArray(a.member) && a.member.length > 0) return "is a Group (has `member`); v1 supports Identified Agents only";
+	let count = 0;
+	if (a.mbox !== void 0) count++;
+	if (a.mbox_sha1sum !== void 0) count++;
+	if (a.openid !== void 0) count++;
+	if (a.account !== void 0) count++;
+	if (count === 0) return "must have one of mbox, mbox_sha1sum, openid, or account (Identified Agent rule)";
+	if (count > 1) return "must have exactly one IFI (mbox / mbox_sha1sum / openid / account), not multiple";
+	if (a.mbox !== void 0) {
+		if (typeof a.mbox !== "string" || !a.mbox.startsWith("mailto:")) return ".mbox must be a string starting with \"mailto:\"";
+	}
+	if (a.mbox_sha1sum !== void 0) {
+		if (typeof a.mbox_sha1sum !== "string" || !/^[0-9a-f]{40}$/i.test(a.mbox_sha1sum)) return ".mbox_sha1sum must be a 40-character hex string";
+	}
+	if (a.openid !== void 0) {
+		if (typeof a.openid !== "string" || !a.openid) return ".openid must be a non-empty string";
+		try {
+			new URL(a.openid);
+		} catch {
+			return ".openid must be an absolute URI";
+		}
+	}
+	if (a.account !== void 0) {
+		const acc = a.account;
+		if (!acc || typeof acc !== "object") return ".account must be an object with homePage and name";
+		if (typeof acc.homePage !== "string" || !acc.homePage) return ".account.homePage must be a non-empty string";
+		try {
+			new URL(acc.homePage);
+		} catch {
+			return ".account.homePage must be an absolute URL";
+		}
+		if (typeof acc.name !== "string" || !acc.name) return ".account.name must be a non-empty string";
+	}
+	return null;
+}
+//#endregion
+//#region src/plugin/validation.ts
+const KNOWN_CONFIG_FIELDS = new Set([
+	"title",
+	"description",
+	"author",
+	"version",
+	"branding",
+	"navigation",
+	"completion",
+	"scoring",
+	"export",
+	"chrome",
+	"xapi"
+]);
+const VALID_NAV_MODES = ["free", "sequential"];
+const VALID_COMPLETION_MODES = ["quiz", "percentage"];
+const VALID_EXPORT_STANDARDS = [
+	"web",
+	"scorm12",
+	"scorm2004",
+	"cmi5"
+];
+/**
+* Validate a Tessera project at the given root.
+* Returns errors (block build) and warnings (informational).
+*/
+function validateProject(projectRoot) {
+	const errors = [];
+	const warnings = [];
+	const configPath = resolve(projectRoot, "course.config.js");
+	if (!existsSync(configPath)) {
+		errors.push("course.config.js not found in project root");
+		return {
+			errors,
+			warnings
+		};
+	}
+	const config = parseConfig(configPath, errors, warnings);
+	const pageResults = validatePages(resolve(projectRoot, "pages"), resolve(projectRoot, "assets"), projectRoot);
+	errors.push(...pageResults.errors);
+	warnings.push(...pageResults.warnings);
+	if (config) crossValidate(config, pageResults, errors, warnings);
+	return {
+		errors,
+		warnings
+	};
+}
+function parseConfig(configPath, errors, warnings) {
+	const objectStr = extractDefaultExportObjectLiteral(readSourceFileCached(configPath));
+	if (!objectStr) {
+		errors.push("course.config.js: could not parse — must use `export default { ... }` syntax");
+		return null;
+	}
+	let config;
+	try {
+		config = JSON5.parse(objectStr);
+	} catch {
+		errors.push("course.config.js: syntax error — must export a static object literal");
+		return null;
+	}
+	for (const key of Object.keys(config)) if (!KNOWN_CONFIG_FIELDS.has(key)) warnings.push(`course.config.js: unknown field "${key}" — will be ignored`);
+	if (config.navigation?.mode !== void 0) {
+		if (!VALID_NAV_MODES.includes(config.navigation.mode)) errors.push(`course.config.js: "navigation.mode" must be "free" or "sequential", got "${config.navigation.mode}"`);
+	}
+	if (config.completion?.mode !== void 0) {
+		if (!VALID_COMPLETION_MODES.includes(config.completion.mode)) errors.push(`course.config.js: "completion.mode" must be "quiz" or "percentage", got "${config.completion.mode}"`);
+	}
+	if (config.export?.standard !== void 0) {
+		if (!VALID_EXPORT_STANDARDS.includes(config.export.standard)) errors.push(`course.config.js: "export.standard" must be "web", "scorm12", "scorm2004", or "cmi5", got "${config.export.standard}"`);
+	}
+	if (config.scoring?.passingScore !== void 0) {
+		const score = config.scoring.passingScore;
+		if (typeof score !== "number" || score < 0 || score > 100) errors.push(`course.config.js: "scoring.passingScore" must be 0–100, got ${score}`);
+	}
+	if (config.completion?.percentageThreshold !== void 0) {
+		const threshold = config.completion.percentageThreshold;
+		if (typeof threshold !== "number" || threshold < 0 || threshold > 100) errors.push(`course.config.js: "completion.percentageThreshold" must be 0–100, got ${threshold}`);
+	}
+	if (config.xapi !== void 0) validateXAPIConfig(config.xapi, config.export?.standard ?? "web", errors, warnings);
+	return config;
+}
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function validateXAPIConfig(raw, standard, errors, warnings) {
+	if (raw === void 0 || raw === null) return;
+	const entries = Array.isArray(raw) ? raw : [raw];
+	if (Array.isArray(raw)) {
+		if (entries.length === 0) {
+			errors.push("course.config.js: xapi must contain at least one destination, or be omitted");
+			return;
+		}
+		if (entries.filter((e) => e && typeof e === "object" && e.endpoint === "lms").length > 1) errors.push("course.config.js: xapi has multiple entries with endpoint: 'lms' — only one cmi5 launch-inherited destination is allowed");
+		const seen = /* @__PURE__ */ new Map();
+		for (const e of entries) if (e && typeof e === "object") {
+			const ep = e.endpoint;
+			if (typeof ep === "string" && ep !== "lms") seen.set(ep, (seen.get(ep) ?? 0) + 1);
+		}
+		for (const [ep, count] of seen) if (count > 1) warnings.push(`course.config.js: xapi has ${count} entries with endpoint "${ep}" — usually a copy-paste mistake; fan-out to the same LRS with different actors/activityIds is supported but uncommon.`);
+	} else if (typeof raw !== "object") {
+		errors.push("course.config.js: xapi must be an object or an array of objects");
+		return;
+	}
+	for (let i = 0; i < entries.length; i++) {
+		const entry = entries[i];
+		const label = Array.isArray(raw) ? `xapi[${i}]` : "xapi";
+		if (!entry || typeof entry !== "object") {
+			errors.push(`course.config.js: ${label} must be an object`);
+			continue;
+		}
+		validateSingleXAPIEntry(entry, label, standard, errors, warnings);
+	}
+}
+function validateSingleXAPIEntry(entry, label, standard, errors, warnings) {
+	const endpoint = entry.endpoint;
+	if (endpoint === void 0) {
+		errors.push(`course.config.js: ${label}.endpoint is required`);
+		return;
+	}
+	if (typeof endpoint !== "string") {
+		errors.push(`course.config.js: ${label}.endpoint must be a string`);
+		return;
+	}
+	if (endpoint === "lms") {
+		if (standard !== "cmi5") errors.push(`course.config.js: ${label}.endpoint: 'lms' requires export.standard: 'cmi5' (you have "${standard}"). Either change the export standard or specify an explicit LRS endpoint.`);
+		for (const f of [
+			"auth",
+			"actor",
+			"activityId",
+			"registration",
+			"actorAccountHomePage"
+		]) if (entry[f] !== void 0) errors.push(`course.config.js: ${label}.${f} must be omitted when ${label}.endpoint is 'lms' — it is inherited from the cmi5 launch.`);
+		return;
+	}
+	let url;
+	try {
+		url = new URL(endpoint);
+	} catch {
+		errors.push(`course.config.js: ${label}.endpoint must be an absolute http(s) URL, got "${endpoint}"`);
+		return;
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") {
+		errors.push(`course.config.js: ${label}.endpoint must use http: or https:, got "${url.protocol}"`);
+		return;
+	}
+	if (url.protocol === "http:" && process.env.NODE_ENV === "production") warnings.push(`course.config.js: ${label}.endpoint uses http:; LRS credentials will travel in cleartext. Use https in production.`);
+	if (!endpoint.endsWith("/")) warnings.push(`course.config.js: ${label}.endpoint should end with a slash to avoid concatenation surprises (e.g. 'https://lrs.example.com/xapi/' not 'https://lrs.example.com/xapi'). Runtime normalizes regardless.`);
+	const auth = entry.auth;
+	if (auth === void 0) errors.push(`course.config.js: ${label}.auth is required`);
+	else if (typeof auth === "string") if (!auth) errors.push(`course.config.js: ${label}.auth must be a non-empty string`);
+	else if (/^basic\s/i.test(auth)) errors.push(`course.config.js: ${label}.auth must be the Basic credential value only, not the full header. Drop the 'Basic ' prefix.`);
+	else if (/^bearer\s/i.test(auth)) errors.push(`course.config.js: ${label}.auth: Bearer/OAuth credentials are not supported in v1. Use Basic auth, or wrap your token-exchange in an auth function that returns a Basic credential.`);
+	else warnings.push(`course.config.js: ${label}.auth is a static string and will be embedded in the bundle. For production, pass a function that fetches a short-lived token from a server endpoint.`);
+	else if (typeof auth !== "function") errors.push(`course.config.js: ${label}.auth must be a string or a function, got ${typeof auth}`);
+	const activityId = entry.activityId;
+	if (activityId === void 0 || activityId === "") errors.push(`course.config.js: ${label}.activityId is required`);
+	else if (typeof activityId !== "string") errors.push(`course.config.js: ${label}.activityId must be a string`);
+	else try {
+		new URL(activityId);
+	} catch {
+		errors.push(`course.config.js: ${label}.activityId must be an absolute IRI, got "${activityId}"`);
+	}
+	const actor = entry.actor;
+	if (actor === void 0) {
+		if (standard === "web") errors.push(`course.config.js: ${label}.actor is required for web export — there is no LMS to derive a learner identity from. Provide either a static actor object or a function that resolves one (e.g. from your auth system).`);
+	} else if (typeof actor === "object" && actor !== null) {
+		const err = validateStaticAgent(actor);
+		if (err) {
+			const joined = err.startsWith(".") ? `${label}.actor${err}` : `${label}.actor ${err}`;
+			errors.push(`course.config.js: ${joined}`);
+		}
+	} else if (typeof actor !== "function") errors.push(`course.config.js: ${label}.actor must be an object or function, got ${typeof actor}`);
+	const aahp = entry.actorAccountHomePage;
+	if (aahp !== void 0) {
+		if (typeof aahp !== "string") errors.push(`course.config.js: ${label}.actorAccountHomePage must be a string`);
+		else try {
+			new URL(aahp);
+		} catch {
+			errors.push(`course.config.js: ${label}.actorAccountHomePage must be an absolute URL`);
+		}
+		if (actor !== void 0) warnings.push(`course.config.js: ${label}.actorAccountHomePage is ignored when ${label}.actor is supplied explicitly.`);
+		if (standard === "cmi5" || standard === "web") warnings.push(`course.config.js: ${label}.actorAccountHomePage is only used under scorm12/scorm2004 actor synthesis; ignored under "${standard}".`);
+	}
+	if (actor === void 0 && (standard === "scorm12" || standard === "scorm2004") && typeof activityId === "string") {
+		let isHttp = false;
+		try {
+			const u = new URL(activityId);
+			isHttp = u.protocol === "http:" || u.protocol === "https:";
+		} catch {
+			isHttp = false;
+		}
+		if (!isHttp && aahp === void 0) errors.push(`course.config.js: ${label}.activityId is not an http(s) URL, so its origin can't be used as the SCORM actor's account.homePage. Provide ${label}.actorAccountHomePage explicitly.`);
+	}
+	const registration = entry.registration;
+	if (registration !== void 0) {
+		if (typeof registration !== "string" || !UUID_RE.test(registration)) errors.push(`course.config.js: ${label}.registration must be a UUID v4, got "${String(registration)}"`);
+		if (standard !== "cmi5") warnings.push(`course.config.js: ${label}.registration is a cmi5 concept; the LRS will accept it under "${standard}" but most analytics tools won't know what to do with it.`);
+	}
+}
+/**
+* Build-time alias for the shared `validateAgent` rules. Suffixes are already
+* prefix-friendly (no leading "actor"), so this is a straight pass-through —
+* kept named so the call sites in this file stay readable.
+*/
+const validateStaticAgent = validateAgent;
+function validatePages(pagesDir, assetsDir, projectRoot) {
+	const errors = [];
+	const warnings = [];
+	let totalPages = 0;
+	let totalQuizzes = 0;
+	let hasGradedQuiz = false;
+	if (!existsSync(pagesDir)) {
+		errors.push("No pages found. Create at least one section with a lesson and page in pages/");
+		return {
+			errors,
+			warnings,
+			totalPages: 0,
+			totalQuizzes: 0,
+			hasGradedQuiz: false
+		};
+	}
+	const topLevelEntries = readdirSync(pagesDir);
+	for (const entry of topLevelEntries) {
+		const fullPath = resolve(pagesDir, entry);
+		if (entry.endsWith(".svelte") && statSync(fullPath).isFile()) {
+			const relPath = relative(projectRoot, fullPath);
+			warnings.push(`${relPath}: this file is outside the section/lesson structure and will be ignored`);
+		}
+	}
+	const sectionDirs = topLevelEntries.filter((name) => {
+		return statSync(resolve(pagesDir, name)).isDirectory() && !name.startsWith(".");
+	}).sort();
+	if (sectionDirs.length === 0) {
+		errors.push("No pages found. Create at least one section with a lesson and page in pages/");
+		return {
+			errors,
+			warnings,
+			totalPages: 0,
+			totalQuizzes: 0,
+			hasGradedQuiz: false
+		};
+	}
+	for (const sectionName of sectionDirs) {
+		const sectionPath = resolve(pagesDir, sectionName);
+		const sectionRel = relative(projectRoot, sectionPath);
+		const sectionMeta = validateMetaFile(resolve(sectionPath, "_meta.js"), sectionRel, errors);
+		const sectionEntries = readdirSync(sectionPath);
+		const sectionSvelteFiles = sectionEntries.filter((name) => {
+			const full = resolve(sectionPath, name);
+			return name.endsWith(".svelte") && statSync(full).isFile();
+		}).sort();
+		if (sectionMeta?.pages) for (const pageName of sectionMeta.pages) {
+			const fileName = pageName.endsWith(".svelte") ? pageName : `${pageName}.svelte`;
+			if (!sectionSvelteFiles.includes(fileName)) {
+				const metaRel = relative(projectRoot, resolve(sectionPath, "_meta.js"));
+				errors.push(`${metaRel}: pages array lists "${pageName}" but ${fileName} not found in this directory`);
+			}
+		}
+		for (const fileName of sectionSvelteFiles) {
+			const filePath = resolve(sectionPath, fileName);
+			const fileRel = relative(projectRoot, filePath);
+			const content = readSourceFileCached(filePath);
+			const pageConfig = validatePageConfig(content, fileRel, errors);
+			totalPages++;
+			if (pageConfig?.quiz) {
+				totalQuizzes++;
+				validateQuizConfig(pageConfig.quiz, fileRel, errors);
+				if (pageConfig.quiz.graded === true) hasGradedQuiz = true;
+			}
+			validateAssetRefs(content, fileRel, assetsDir, warnings);
+		}
+		const lessonDirs = sectionEntries.filter((name) => {
+			return statSync(resolve(sectionPath, name)).isDirectory() && !name.startsWith(".");
+		}).sort();
+		for (const lessonName of lessonDirs) {
+			const lessonPath = resolve(sectionPath, lessonName);
+			const lessonRel = relative(projectRoot, lessonPath);
+			const meta = validateMetaFile(resolve(lessonPath, "_meta.js"), lessonRel, errors);
+			const svelteFiles = readdirSync(lessonPath).filter((name) => name.endsWith(".svelte")).sort();
+			if (meta?.pages) for (const pageName of meta.pages) {
+				const fileName = pageName.endsWith(".svelte") ? pageName : `${pageName}.svelte`;
+				if (!svelteFiles.includes(fileName)) {
+					const metaRel = relative(projectRoot, resolve(lessonPath, "_meta.js"));
+					errors.push(`${metaRel}: pages array lists "${pageName}" but ${fileName} not found in this directory`);
+				}
+			}
+			if (meta?.pages && meta.pages.length > 0) {
+				const listedSet = new Set(meta.pages.map((p) => p.endsWith(".svelte") ? p : `${p}.svelte`));
+				for (const file of svelteFiles) if (!listedSet.has(file)) {
+					const relPath = relative(projectRoot, resolve(lessonPath, file));
+					warnings.push(`${relPath}: not listed in _meta.js pages array — will be appended at end`);
+				}
+			}
+			for (const fileName of svelteFiles) {
+				const filePath = resolve(lessonPath, fileName);
+				const fileRel = relative(projectRoot, filePath);
+				const content = readSourceFileCached(filePath);
+				const pageConfig = validatePageConfig(content, fileRel, errors);
+				totalPages++;
+				if (pageConfig?.quiz) {
+					totalQuizzes++;
+					validateQuizConfig(pageConfig.quiz, fileRel, errors);
+					if (pageConfig.quiz.graded === true) hasGradedQuiz = true;
+				}
+				validateAssetRefs(content, fileRel, assetsDir, warnings);
+			}
+		}
+	}
+	if (totalPages === 0) errors.push("No pages found. Create at least one section with a lesson and page in pages/");
+	return {
+		errors,
+		warnings,
+		totalPages,
+		totalQuizzes,
+		hasGradedQuiz
+	};
+}
+function validateMetaFile(metaPath, parentRel, errors) {
+	if (!existsSync(metaPath)) return null;
+	const metaRel = `${parentRel}/_meta.js`;
+	const objectStr = extractDefaultExportObjectLiteral(readSourceFileCached(metaPath));
+	if (!objectStr) {
+		errors.push(`${metaRel}: syntax error — must export default { title: "..." }`);
+		return null;
+	}
+	let meta;
+	try {
+		meta = JSON5.parse(objectStr);
+	} catch {
+		errors.push(`${metaRel}: syntax error — must export default { title: "..." }`);
+		return null;
+	}
+	if (!meta.title) errors.push(`${metaRel}: missing required "title" field`);
+	return meta;
+}
+function validatePageConfig(content, fileRel, errors) {
+	const moduleScriptMatch = content.match(MODULE_SCRIPT_RE);
+	if (!moduleScriptMatch) return null;
+	const scriptContent = moduleScriptMatch[1];
+	const exportMatch = scriptContent.match(PAGE_CONFIG_EXPORT_RE);
+	if (!exportMatch || exportMatch.index === void 0) return null;
+	if (!scriptContent.slice(exportMatch.index + exportMatch[0].length).trimStart().startsWith("{")) {
+		errors.push(`${fileRel}: pageConfig must be a static object literal (no variables, function calls, or computed values)`);
+		return null;
+	}
+	const objectStr = extractObjectLiteral(scriptContent, scriptContent.indexOf("{", exportMatch.index + exportMatch[0].length));
+	if (!objectStr) {
+		errors.push(`${fileRel}: pageConfig must be a static object literal (no variables, function calls, or computed values)`);
+		return null;
+	}
+	try {
+		return JSON5.parse(objectStr);
+	} catch {
+		errors.push(`${fileRel}: pageConfig must be a static object literal (no variables, function calls, or computed values)`);
+		return null;
+	}
+}
+function validateQuizConfig(quiz, fileRel, errors) {
+	if (!quiz || typeof quiz !== "object") return;
+	const cfg = quiz;
+	if (cfg.maxAttempts !== void 0) {
+		const val = cfg.maxAttempts;
+		if (val !== Infinity && (typeof val !== "number" || val <= 0 || !Number.isFinite(val))) errors.push(`${fileRel}: quiz.maxAttempts must be a positive number or Infinity, got ${String(val)}`);
+	}
+	if (cfg.graded !== void 0 && typeof cfg.graded !== "boolean") errors.push(`${fileRel}: quiz.graded must be a boolean, got ${typeof cfg.graded}`);
+}
+function validateAssetRefs(content, fileRel, assetsDir, warnings) {
+	const assetRefPattern = /\$assets\/([^\s"'`)]+)/g;
+	let match;
+	while ((match = assetRefPattern.exec(content)) !== null) {
+		const assetPath = match[1];
+		if (!existsSync(resolve(assetsDir, assetPath))) warnings.push(`${fileRel}: "$assets/${assetPath}" not found in assets/ directory`);
+	}
+}
+function crossValidate(config, pageResults, errors, warnings) {
+	if (config.completion?.mode === "quiz" && !pageResults.hasGradedQuiz) errors.push("completion.mode is \"quiz\" but no pages have quiz config with graded: true");
+	if (config.export?.standard === "scorm12") {
+		let visitedChars = 0;
+		for (let i = 0; i < pageResults.totalPages; i++) visitedChars += String(i).length + 1;
+		const overhead = 60;
+		const quizBytes = pageResults.totalQuizzes * 15;
+		const chunkBytes = pageResults.totalPages * 12;
+		const standaloneBytes = pageResults.totalPages * 30;
+		const estimatedSize = overhead + visitedChars + quizBytes + chunkBytes + standaloneBytes + 256;
+		if (estimatedSize > 3200) warnings.push(`Course has ${pageResults.totalPages} pages with ${pageResults.totalQuizzes} quizzes — estimated SCORM 1.2 suspend_data ~${estimatedSize} bytes may exceed the 4096-byte limit when fully populated (visited + chunks + standalone scores + usePersistence). Consider using "scorm2004" or "cmi5".`);
+	}
+}
+//#endregion
+//#region src/runtime/slugify.ts
+/**
+* Slugify a string for use as a URL-safe / filename-safe identifier.
+* "My Course Title" → "my-course-title"
+*
+* Shared by the runtime (`WebAdapter` localStorage key) and the build-time
+* exporter (`runExport` zip filename). Both want identical, deterministic
+* output so a course's storage key matches its package name.
+*/
+function slugify(text) {
+	return text.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+//#endregion
+//#region src/plugin/export.ts
+function escapeXml(str) {
+	return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+/**
+* Recursively collect all file paths relative to a directory.
+*/
+function collectFiles(dir, base = "") {
+	const files = [];
+	if (!existsSync(dir)) return files;
+	for (const entry of readdirSync(dir)) {
+		const fullPath = resolve(dir, entry);
+		const relPath = base ? `${base}/${entry}` : entry;
+		if (statSync(fullPath).isDirectory()) files.push(...collectFiles(fullPath, relPath));
+		else files.push(relPath);
+	}
+	return files;
+}
+/**
+* Derive a stable URN IRI from a seed string. cmi5 §13.1 / xs:anyURI
+* require course / AU ids to be IRIs — bare hex or UUID-shaped strings
+* (without correct version/variant bits) aren't conformant URNs and may
+* be rejected by strict LMS importers.
+*
+* Hash the seed so the id survives rebuilds, then format as
+* `urn:tessera:<kind>:<hex>`. The same seed always produces the same
+* IRI, so existing LRS records are not orphaned by re-export.
+*/
+function stableUrn(kind, seed) {
+	return `urn:tessera:${kind}:${createHash("sha256").update(seed).digest("hex").slice(0, 32)}`;
+}
+function formatSize(bytes) {
+	if (bytes < 1024) return `${bytes} B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+	return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function generateSCORM12Manifest(config, distDir) {
+	const title = escapeXml(config.title || "Tessera Course");
+	return `<?xml version="1.0" encoding="UTF-8"?>
+<manifest identifier="tessera-course" version="1.0"
+  xmlns="http://www.imsproject.org/xsd/imscp_rootv1p1p2"
+  xmlns:adlcp="http://www.adlnet.org/xsd/adlcp_rootv1p2">
+  <metadata>
+    <schema>ADL SCORM</schema>
+    <schemaversion>1.2</schemaversion>
+  </metadata>
+  <organizations default="org-1">
+    <organization identifier="org-1">
+      <title>${title}</title>
+      <item identifier="item-1" identifierref="res-1">
+        <title>${title}</title>
+      </item>
+    </organization>
+  </organizations>
+  <resources>
+    <resource identifier="res-1" type="webcontent" adlcp:scormtype="sco" href="index.html">
+${collectFiles(distDir).map((f) => `      <file href="${escapeXml(f)}" />`).join("\n")}
+    </resource>
+  </resources>
+</manifest>`;
+}
+function generateSCORM2004Manifest(config, distDir) {
+	const title = escapeXml(config.title || "Tessera Course");
+	return `<?xml version="1.0" encoding="UTF-8"?>
+<manifest identifier="tessera-course" version="1.0"
+  xmlns="http://www.imsglobal.org/xsd/imscp_v1p1"
+  xmlns:adlcp="http://www.adlnet.org/xsd/adlcp_v1p3">
+  <metadata>
+    <schema>ADL SCORM</schema>
+    <schemaversion>2004 4th Edition</schemaversion>
+  </metadata>
+  <organizations default="org-1">
+    <organization identifier="org-1">
+      <title>${title}</title>
+      <item identifier="item-1" identifierref="res-1">
+        <title>${title}</title>
+      </item>
+    </organization>
+  </organizations>
+  <resources>
+    <resource identifier="res-1" type="webcontent" adlcp:scormType="sco" href="index.html">
+${collectFiles(distDir).map((f) => `      <file href="${escapeXml(f)}" />`).join("\n")}
+    </resource>
+  </resources>
+</manifest>`;
+}
+function generateCMI5Xml(config) {
+	const title = escapeXml(config.title || "Tessera Course");
+	const description = escapeXml(config.description || "");
+	const courseId = stableUrn("course", `tessera-course:${config.title || ""}`);
+	const auId = stableUrn("au", `tessera-au:${config.title || ""}`);
+	const masteryScore = (config.scoring?.passingScore ?? 70) / 100;
+	return `<?xml version="1.0" encoding="UTF-8"?>
+<courseStructure xmlns="https://w3id.org/xapi/profiles/cmi5/v1/CourseStructure.xsd">
+  <course id="${courseId}">
+    <title><langstring lang="en-US">${title}</langstring></title>
+    <description><langstring lang="en-US">${description}</langstring></description>
+  </course>
+  <au id="${auId}" url="index.html" moveOn="${config.completion?.mode === "quiz" ? "CompletedAndPassed" : "Completed"}" masteryScore="${masteryScore}">
+    <title><langstring lang="en-US">${title}</langstring></title>
+    <description><langstring lang="en-US">${description}</langstring></description>
+  </au>
+</courseStructure>`;
+}
+async function createZip(distDir, outputPath) {
+	return new Promise((res, reject) => {
+		const output = createWriteStream(outputPath);
+		const archive = new ZipArchive({ zlib: { level: 9 } });
+		output.on("close", () => {
+			res(archive.pointer());
+		});
+		output.on("error", reject);
+		archive.on("error", reject);
+		archive.pipe(output);
+		archive.directory(distDir, false);
+		archive.finalize();
+	});
+}
+/**
+* Run the export process after Vite build completes.
+* Writes manifest XML into dist/, then packages into ZIP if needed.
+*/
+/** Remove any previously built zips for this package to prevent accumulation. */
+function cleanOldZips(projectRoot, slug) {
+	try {
+		for (const f of readdirSync(projectRoot)) if (f.startsWith(`${slug}-`) && f.endsWith(".zip")) try {
+			unlinkSync(resolve(projectRoot, f));
+		} catch {}
+	} catch {}
+}
+async function runExport(projectRoot, config) {
+	const distDir = resolve(projectRoot, "dist");
+	const standard = config.export?.standard || "web";
+	const slug = slugify(config.title || "tessera-course") || "tessera-course";
+	const zipName = `${slug}-${config.version || "1.0.0"}.zip`;
+	const zipPath = resolve(projectRoot, zipName);
+	switch (standard) {
+		case "web": {
+			const files = collectFiles(distDir);
+			let totalSize = 0;
+			for (const f of files) totalSize += statSync(resolve(distDir, f)).size;
+			console.log(`✓ Web export: dist/ (${formatSize(totalSize)})`);
+			break;
+		}
+		case "scorm12": {
+			const manifest = generateSCORM12Manifest(config, distDir);
+			writeFileSync(resolve(distDir, "imsmanifest.xml"), manifest, "utf-8");
+			cleanOldZips(projectRoot, slug);
+			const zipSize = await createZip(distDir, zipPath);
+			console.log(`✓ SCORM 1.2 export: ${zipName} (${formatSize(zipSize)})`);
+			break;
+		}
+		case "scorm2004": {
+			const manifest = generateSCORM2004Manifest(config, distDir);
+			writeFileSync(resolve(distDir, "imsmanifest.xml"), manifest, "utf-8");
+			cleanOldZips(projectRoot, slug);
+			const zipSize = await createZip(distDir, zipPath);
+			console.log(`✓ SCORM 2004 export: ${zipName} (${formatSize(zipSize)})`);
+			break;
+		}
+		case "cmi5": {
+			const xml = generateCMI5Xml(config);
+			writeFileSync(resolve(distDir, "cmi5.xml"), xml, "utf-8");
+			cleanOldZips(projectRoot, slug);
+			const zipSize = await createZip(distDir, zipPath);
+			console.log(`✓ CMI5 export: ${zipName} (${formatSize(zipSize)})`);
+			break;
+		}
+	}
+}
+//#endregion
+//#region src/plugin/layout.ts
+const VIRTUAL_LAYOUT_ID = "virtual:tessera-layout";
+const RESOLVED_LAYOUT_ID = "\0" + VIRTUAL_LAYOUT_ID;
+function tesseraLayoutPlugin() {
+	let projectRoot;
+	return {
+		name: "tessera:layout",
+		enforce: "pre",
+		configResolved(config) {
+			projectRoot = config.root;
+		},
+		resolveId(id) {
+			if (id === VIRTUAL_LAYOUT_ID) return RESOLVED_LAYOUT_ID;
+			return null;
+		},
+		load(id) {
+			if (id !== RESOLVED_LAYOUT_ID) return null;
+			const layoutPath = resolve(projectRoot, "layout.svelte");
+			if (existsSync(layoutPath)) {
+				this.addWatchFile(layoutPath);
+				return `export { default } from '${layoutPath.replace(/\\/g, "/")}';`;
+			}
+			return `export default null;`;
+		},
+		configureServer(server) {
+			const layoutPath = resolve(projectRoot, "layout.svelte");
+			server.watcher.on("all", (event, filePath) => {
+				if (filePath !== layoutPath) return;
+				if (event !== "add" && event !== "unlink") return;
+				const mod = server.moduleGraph.getModuleById(RESOLVED_LAYOUT_ID);
+				if (mod) server.moduleGraph.invalidateModule(mod);
+				server.ws.send({ type: "full-reload" });
+			});
+		}
+	};
+}
+//#endregion
+//#region src/plugin/quiz.ts
+const VIRTUAL_QUIZ_ID = "virtual:tessera-quiz";
+const RESOLVED_QUIZ_ID = "\0" + VIRTUAL_QUIZ_ID;
+const __dirname$1 = dirname(fileURLToPath(import.meta.url));
+/**
+* Resolve the project's quiz shell.
+* `projectRoot/quiz.svelte` overrides the built-in `<Quiz>` if it exists,
+* otherwise the built-in is used. Mirrors `tesseraLayoutPlugin` (Phase 3A).
+*/
+function tesseraQuizPlugin() {
+	let projectRoot;
+	const builtinQuiz = resolve(resolve(__dirname$1, "..", ".."), "src", "components", "Quiz.svelte");
+	return {
+		name: "tessera:quiz",
+		enforce: "pre",
+		configResolved(config) {
+			projectRoot = config.root;
+		},
+		resolveId(id) {
+			if (id === VIRTUAL_QUIZ_ID) return RESOLVED_QUIZ_ID;
+			return null;
+		},
+		load(id) {
+			if (id !== RESOLVED_QUIZ_ID) return null;
+			const userQuizPath = resolve(projectRoot, "quiz.svelte");
+			if (existsSync(userQuizPath)) {
+				this.addWatchFile(userQuizPath);
+				return `export { default } from '${userQuizPath.replace(/\\/g, "/")}';`;
+			}
+			return `export { default } from '${builtinQuiz.replace(/\\/g, "/")}';`;
+		},
+		configureServer(server) {
+			const userQuizPath = resolve(projectRoot, "quiz.svelte");
+			server.watcher.on("all", (event, filePath) => {
+				if (filePath !== userQuizPath) return;
+				if (event !== "add" && event !== "unlink") return;
+				const mod = server.moduleGraph.getModuleById(RESOLVED_QUIZ_ID);
+				if (mod) server.moduleGraph.invalidateModule(mod);
+				server.ws.send({ type: "full-reload" });
+			});
+		}
+	};
+}
+//#endregion
+//#region src/plugin/index.ts
+const __dirname = dirname(fileURLToPath(import.meta.url));
+function resolveRuntimeDir() {
+	return resolve(resolve(__dirname, "..", ".."), "src", "runtime");
+}
+function resolveStylesDir() {
+	return resolve(resolve(__dirname, "..", ".."), "styles");
+}
+function tesseraPlugin() {
+	return [
+		svelte({ compilerOptions: { css: "injected" } }),
+		tesseraValidationPlugin(),
+		tesseraEntryPlugin(),
+		tesseraConfigPlugin(),
+		tesseraPagesPlugin(),
+		tesseraManifestPlugin(),
+		tesseraLayoutPlugin(),
+		tesseraQuizPlugin(),
+		tesseraExportPlugin()
+	];
+}
+const VIRTUAL_ENTRY_ID = "virtual:tessera-entry";
+const RESOLVED_ENTRY_ID = "\0" + VIRTUAL_ENTRY_ID;
+const VIRTUAL_MAIN_ID = "/virtual:tessera-main";
+const RESOLVED_MAIN_ID = "\0virtual:tessera-main";
+function tesseraEntryPlugin() {
+	const runtimeDir = resolveRuntimeDir();
+	const stylesDir = resolveStylesDir();
+	const appSveltePath = resolve(runtimeDir, "App.svelte");
+	let projectRoot;
+	let isBuild = false;
+	return {
+		name: "tessera:entry",
+		enforce: "pre",
+		configResolved(config) {
+			projectRoot = config.root;
+			isBuild = config.command === "build";
+		},
+		buildStart() {
+			if (isBuild) writeFileSync(resolve(projectRoot, "index.html"), generateIndexHtml(), "utf-8");
+		},
+		closeBundle() {
+			if (isBuild) {
+				const htmlPath = resolve(projectRoot, "index.html");
+				if (existsSync(htmlPath)) try {
+					unlinkSync(htmlPath);
+				} catch {}
+				const assetsDir = resolve(projectRoot, "assets");
+				const distAssetsDir = resolve(projectRoot, "dist", "assets");
+				if (existsSync(assetsDir)) {
+					mkdirSync(distAssetsDir, { recursive: true });
+					cpSync(assetsDir, distAssetsDir, { recursive: true });
+				}
+			}
+		},
+		configureServer(server) {
+			return () => {
+				server.middlewares.use(async (req, res, next) => {
+					if (req.url === "/" || req.url === "/index.html") {
+						const html = generateIndexHtml();
+						const transformed = await server.transformIndexHtml(req.url, html);
+						res.setHeader("Content-Type", "text/html");
+						res.statusCode = 200;
+						res.end(transformed);
+						return;
+					}
+					next();
+				});
+			};
+		},
+		resolveId(id) {
+			if (id === VIRTUAL_ENTRY_ID) return RESOLVED_ENTRY_ID;
+			if (id === VIRTUAL_MAIN_ID || id === "virtual:tessera-main") return RESOLVED_MAIN_ID;
+			return null;
+		},
+		load(id) {
+			if (id === RESOLVED_ENTRY_ID || id === RESOLVED_MAIN_ID) return generateEntryScript(appSveltePath, stylesDir, projectRoot);
+			return null;
+		}
+	};
+}
+function generateIndexHtml() {
+	return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Tessera Course</title>
+</head>
+<body>
+  <div id="tessera-root"></div>
+  <script type="module" src="/virtual:tessera-main"><\/script>
+</body>
+</html>`;
+}
+function generateEntryScript(appSveltePath, frameworkStylesDir, projectRoot) {
+	const normalizedPath = appSveltePath.replace(/\\/g, "/");
+	const frameworkImports = [
+		"theme.css",
+		"base.css",
+		"layout.css"
+	].map((file) => resolve(frameworkStylesDir, file).replace(/\\/g, "/")).filter((path) => existsSync(path)).map((path) => `import '${path}';`).join("\n");
+	const userStylesDir = resolve(projectRoot, "styles");
+	let userImports = "";
+	if (existsSync(userStylesDir)) userImports = readdirSync(userStylesDir).filter((f) => f.endsWith(".css")).sort().map((f) => resolve(userStylesDir, f).replace(/\\/g, "/")).map((path) => `import '${path}';`).join("\n");
+	return `// Framework styles
+${frameworkImports}
+// User styles
+${userImports}
+
+import { mount } from 'svelte';
+import App from '${normalizedPath}';
+
+mount(App, {
+  target: document.getElementById('tessera-root'),
+});
+`;
+}
+const VIRTUAL_CONFIG_ID = "virtual:tessera-config";
+const RESOLVED_CONFIG_ID = "\0" + VIRTUAL_CONFIG_ID;
+function tesseraConfigPlugin() {
+	let projectRoot;
+	return {
+		name: "tessera:config",
+		enforce: "pre",
+		config(config) {
+			return {
+				base: "./",
+				resolve: { alias: { "$assets": resolve(config.root || process.cwd(), "assets") } }
+			};
+		},
+		configResolved(config) {
+			projectRoot = config.root;
+		},
+		resolveId(id) {
+			if (id === VIRTUAL_CONFIG_ID) return RESOLVED_CONFIG_ID;
+			return null;
+		},
+		load(id) {
+			if (id === RESOLVED_CONFIG_ID) {
+				const configPath = resolve(projectRoot, "course.config.js");
+				let userConfig = {};
+				if (existsSync(configPath)) {
+					this.addWatchFile(configPath);
+					const objectStr = extractDefaultExportObjectLiteral(readFileSync(configPath, "utf-8"));
+					if (objectStr) try {
+						userConfig = JSON5.parse(objectStr);
+					} catch {}
+				}
+				const merged = {
+					title: userConfig.title || "Untitled Course",
+					...userConfig,
+					navigation: {
+						mode: "free",
+						...userConfig.navigation
+					},
+					completion: {
+						mode: "percentage",
+						percentageThreshold: 100,
+						...userConfig.completion
+					},
+					scoring: {
+						passingScore: 70,
+						...userConfig.scoring
+					},
+					export: {
+						standard: "web",
+						...userConfig.export
+					}
+				};
+				return `export default ${JSON.stringify(merged)};`;
+			}
+			return null;
+		}
+	};
+}
+/** Register all _meta.js and .svelte files under pagesDir as watch files for build mode. */
+function addWatchFiles(ctx, dir) {
+	if (!existsSync(dir)) return;
+	for (const entry of readdirSync(dir)) {
+		const full = resolve(dir, entry);
+		if (statSync(full).isDirectory()) addWatchFiles(ctx, full);
+		else if (entry.endsWith(".svelte") || entry === "_meta.js") ctx.addWatchFile(full);
+	}
+}
+const VIRTUAL_PAGES_ID = "virtual:tessera-pages";
+const RESOLVED_PAGES_ID = "\0" + VIRTUAL_PAGES_ID;
+/**
+* Provides a virtual module that exports an import.meta.glob map for all .svelte
+* pages. This runs in the user's project context so the glob resolves against their
+* pages/ directory, and Vite can statically analyze it for code splitting.
+*/
+function tesseraPagesPlugin() {
+	return {
+		name: "tessera:pages",
+		enforce: "pre",
+		resolveId(id) {
+			if (id === VIRTUAL_PAGES_ID) return RESOLVED_PAGES_ID;
+			return null;
+		},
+		load(id) {
+			if (id === RESOLVED_PAGES_ID) return `export default import.meta.glob('/pages/**/*.svelte');`;
+			return null;
+		}
+	};
+}
+function tesseraValidationPlugin() {
+	let projectRoot;
+	let isBuild = false;
+	return {
+		name: "tessera:validation",
+		enforce: "pre",
+		configResolved(config) {
+			projectRoot = config.root;
+			isBuild = config.command === "build";
+			if (!isBuild) runValidation(projectRoot);
+		},
+		buildStart() {
+			if (isBuild) runValidation(projectRoot);
+		}
+	};
+}
+function runValidation(projectRoot) {
+	const { errors, warnings } = validateProject(projectRoot);
+	for (const warning of warnings) console.warn(`\x1b[33m[tessera warning]\x1b[0m ${warning}`);
+	if (errors.length > 0) {
+		for (const error of errors) console.error(`\x1b[31m[tessera error]\x1b[0m ${error}`);
+		throw new Error(`Tessera validation failed with ${errors.length} error(s). Fix the errors above to continue.`);
+	}
+}
+function tesseraExportPlugin() {
+	let projectRoot;
+	let isBuild = false;
+	return {
+		name: "tessera:export",
+		enforce: "post",
+		configResolved(config) {
+			projectRoot = config.root;
+			isBuild = config.command === "build";
+		},
+		async closeBundle() {
+			if (!isBuild) return;
+			const configPath = resolve(projectRoot, "course.config.js");
+			if (!existsSync(configPath)) throw new Error("[tessera:export] course.config.js not found at closeBundle. The file must exist for the export step to run.");
+			const objectStr = extractDefaultExportObjectLiteral(readFileSync(configPath, "utf-8"));
+			if (!objectStr) throw new Error("[tessera:export] course.config.js: could not locate `export default { ... }`. Cannot determine export.standard.");
+			let config;
+			try {
+				config = JSON5.parse(objectStr);
+			} catch (err) {
+				throw new Error(`[tessera:export] course.config.js: failed to parse export-default object literal — ${err.message}`);
+			}
+			await runExport(projectRoot, config);
+		}
+	};
+}
+const VIRTUAL_MANIFEST_ID = "virtual:tessera-manifest";
+const RESOLVED_MANIFEST_ID = "\0" + VIRTUAL_MANIFEST_ID;
+function tesseraManifestPlugin() {
+	let projectRoot;
+	let pagesDir;
+	let currentManifest = null;
+	function buildManifest() {
+		currentManifest = generateManifest(pagesDir);
+		return currentManifest;
+	}
+	return {
+		name: "tessera:manifest",
+		enforce: "pre",
+		configResolved(config) {
+			projectRoot = config.root;
+			pagesDir = resolve(projectRoot, "pages");
+		},
+		configureServer(devServer) {
+			devServer.watcher.on("all", (event, filePath) => {
+				if (!filePath.startsWith(pagesDir)) return;
+				if (filePath.endsWith(".svelte") || filePath.endsWith("_meta.js") || event === "addDir" || event === "unlinkDir") {
+					currentManifest = null;
+					const mod = devServer.moduleGraph.getModuleById(RESOLVED_MANIFEST_ID);
+					if (mod) {
+						devServer.moduleGraph.invalidateModule(mod);
+						devServer.ws.send({ type: "full-reload" });
+					}
+					console.log(`[tessera] Manifest rebuilt (${event}: ${filePath.replace(projectRoot, "")})`);
+				}
+			});
+		},
+		buildStart() {
+			buildManifest();
+		},
+		resolveId(id) {
+			if (id === VIRTUAL_MANIFEST_ID) return RESOLVED_MANIFEST_ID;
+			return null;
+		},
+		load(id) {
+			if (id === RESOLVED_MANIFEST_ID) {
+				if (!currentManifest) buildManifest();
+				addWatchFiles(this, pagesDir);
+				const json = JSON.stringify(currentManifest, (_key, value) => value === Infinity ? 1e9 : value);
+				return `export default JSON.parse(atob("${Buffer.from(json).toString("base64")}"));`;
+			}
+			return null;
+		}
+	};
+}
+//#endregion
+export { tesseraPlugin };
+
+//# sourceMappingURL=index.js.map