@samva/vite 0.8.0 → 0.9.0

package/dist/project-Cp8qb3s0.js

@@ -0,0 +1,774 @@
+import { watch } from "node:fs";
+import { mkdir, readFile, readdir, rename, stat, writeFile } from "node:fs/promises";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { execFile } from "node:child_process";
+import { parseBrandSpecifier, projectBrandSpecifier } from "@samva/markup/compiler";
+import { assetUrl, isAssetPath } from "@samva/markup/email/assets";
+import { renderIr, renderIrSms, renderIrWhatsApp } from "@samva/markup/render-ir";
+import { checkTemplateCompatibility, compileTemplate } from "@samva/markup/static";
+import { TEMPLATE_NAME_PATTERN } from "@samva/markup/template";
+//#region src/internal/guards.ts
+/** A non-null, non-array object, narrowed for property access. */
+const isObject = (input) => typeof input === "object" && input !== null && !Array.isArray(input);
+//#endregion
+//#region src/layout.ts
+/** Directories scanned for templates when no `dir` is configured, in scan order. */
+const DEFAULT_TEMPLATE_DIRS = ["templates", "emails"];
+/** The folder for files this package generates, relative to the project root. Gitignore it. */
+const SAMVA_DIR = ".samva";
+const toPosix = (value) => sep === "/" ? value : value.split(sep).join("/");
+const SCRIPT = /\.[cm]?[jt]sx?$/;
+const isProjectText = (name) => SCRIPT.test(name) || name.endsWith(".css") || name.endsWith(".json");
+/** True for a file a compile can read: scripts, stylesheets, JSON and importable assets. */
+const isProjectFile = (path) => isProjectText(path) || isAssetPath(path);
+const skipped = (name) => name.startsWith(".") || name === "node_modules";
+/** True when `path` is `parent` or lies beneath it. */
+const isWithin = (path, parent) => {
+	const inside = relative(parent, path);
+	return inside === "" || !inside.startsWith("..") && !isAbsolute(inside);
+};
+const isDirectory = async (path) => (await stat(path).catch(() => void 0))?.isDirectory() === true;
+/**
+* The absolute directories a project's templates live in. A configured `dir`
+* is the only one scanned; otherwise every default directory that exists. A
+* directory outside the root cannot be compiled, because a project's files are
+* addressed relative to its root, so it is refused rather than half-read.
+*/
+const templateDirectories = async (root, dir) => {
+	if (dir !== void 0) {
+		const configured = resolve(root, dir);
+		if (!isWithin(configured, root)) throw new Error(`The templates directory ${configured} is outside the project root ${root}. Set the project root to a folder that contains both.`);
+		return await isDirectory(configured) ? [configured] : [];
+	}
+	return (await Promise.all(DEFAULT_TEMPLATE_DIRS.map(async (name) => {
+		const path = join(root, name);
+		return await isDirectory(path) ? path : void 0;
+	}))).filter((path) => path !== void 0);
+};
+/** Root-relative POSIX path of an absolute one. */
+const projectPath = (root, path) => toPosix(relative(root, path));
+/** Every `.tsx` file beneath the given directories, as root-relative paths, sorted. */
+const discoverEntries = async (root, dirs) => {
+	const found = [];
+	const walk = async (current) => {
+		const entries = await readdir(current, { withFileTypes: true }).catch(() => []);
+		await Promise.all(entries.filter((entry) => !skipped(entry.name)).map(async (entry) => {
+			const full = join(current, entry.name);
+			if (entry.isDirectory()) return walk(full);
+			if (entry.isFile() && entry.name.endsWith(".tsx")) found.push(projectPath(root, full));
+		}));
+	};
+	await Promise.all(dirs.map(walk));
+	return [...new Set(found)].sort();
+};
+/**
+* Read the project into the map the compiler consumes: scripts, stylesheets
+* and JSON as text, imported assets as bytes. Hidden folders (`.samva`, `.git`)
+* and `node_modules` are not part of a project.
+*/
+const readProjectFiles = async (root) => {
+	const files = {};
+	const walk = async (current) => {
+		const entries = await readdir(current, { withFileTypes: true }).catch(() => []);
+		await Promise.all(entries.filter((entry) => !skipped(entry.name)).map(async (entry) => {
+			const full = join(current, entry.name);
+			if (entry.isDirectory()) return walk(full);
+			if (!entry.isFile()) return;
+			const path = projectPath(root, full);
+			if (isAssetPath(path)) files[path] = new Uint8Array(await readFile(full));
+			else if (isProjectText(entry.name)) files[path] = await readFile(full, "utf8");
+		}));
+	};
+	await walk(root);
+	return files;
+};
+//#endregion
+//#region src/brand.ts
+/** Where brand records are cached, relative to the project root. */
+const BRAND_SNAPSHOT_DIR = `${SAMVA_DIR}/brands`;
+const SNAPSHOT_VERSION = 1;
+const DEFAULT_API_URL = "https://api.samva.dev";
+const LIVE_TIMEOUT_MS = 15e3;
+/** How long a resolution is reused, so a watch loop does not ask the API on every save. */
+const RESOLUTION_TTL_MS = 3e4;
+/** Accept only the fields a build needs, from an API body or a snapshot file. */
+const asBrand = (value) => {
+	if (!isObject(value)) return void 0;
+	const { slug, name, isDefault, css, assets, footer, digest } = value;
+	if (typeof slug !== "string" || typeof name !== "string" || typeof isDefault !== "boolean" || typeof css !== "string" || typeof digest !== "string" || assets !== void 0 && !isObject(assets) || footer !== void 0 && !isObject(footer)) return void 0;
+	return {
+		slug,
+		name,
+		isDefault,
+		css,
+		digest,
+		...assets === void 0 ? {} : { assets },
+		...footer === void 0 ? {} : { footer }
+	};
+};
+const liveFromBody = (body, when) => {
+	const brand = asBrand(body);
+	return brand === void 0 ? {
+		ok: false,
+		reason: `${when} answered with something that is not a brand`
+	} : {
+		ok: true,
+		brand: {
+			...brand,
+			version: SNAPSHOT_VERSION,
+			pulledAt: ""
+		}
+	};
+};
+const fetchJson = async (url, apiKey) => {
+	const response = await fetch(url, {
+		headers: {
+			"x-api-key": apiKey,
+			accept: "application/json"
+		},
+		signal: AbortSignal.timeout(LIVE_TIMEOUT_MS)
+	});
+	if (!response.ok) throw new Error(`${url} answered ${response.status}`);
+	return response.json();
+};
+const liveWithApiKey = async (slug, env, apiKey) => {
+	const base = (env["SAMVA_API_URL"] || DEFAULT_API_URL).replace(/\/+$/, "");
+	try {
+		if (slug !== void 0) return liveFromBody(await fetchJson(`${base}/v1/brands/${slug}`, apiKey), "The Samva API");
+		const body = await fetchJson(`${base}/v1/brands`, apiKey);
+		const found = (isObject(body) && Array.isArray(body["items"]) ? body["items"] : []).find((item) => isObject(item) && item["isDefault"] === true);
+		return found === void 0 ? {
+			ok: false,
+			reason: "the organization has no default brand"
+		} : liveFromBody(found, "The Samva API");
+	} catch (cause) {
+		return {
+			ok: false,
+			reason: `the Samva API did not answer (${cause instanceof Error ? cause.message : String(cause)})`
+		};
+	}
+};
+/** The CLI's error envelope message, or its raw stderr. */
+const cliFailure = (stderr) => {
+	const parsed = (() => {
+		try {
+			return JSON.parse(stderr);
+		} catch {
+			return;
+		}
+	})();
+	return isObject(parsed) && typeof parsed["message"] === "string" ? parsed["message"] : stderr.trim() || "it exited without a message";
+};
+const liveWithCli = (slug, env) => new Promise((resolve) => {
+	execFile("samva", [
+		"brands",
+		"get",
+		...slug === void 0 ? [] : [slug],
+		"--json"
+	], {
+		env: { ...env },
+		timeout: LIVE_TIMEOUT_MS,
+		maxBuffer: 1048576
+	}, (error, stdout, stderr) => {
+		if (error !== null) {
+			const code = error.code;
+			resolve({
+				ok: false,
+				reason: code === "ENOENT" ? "there is no SAMVA_API_KEY and no `samva` CLI on PATH" : `\`samva brands get\` failed: ${cliFailure(stderr)}`
+			});
+			return;
+		}
+		const envelope = (() => {
+			try {
+				return JSON.parse(stdout);
+			} catch {
+				return;
+			}
+		})();
+		resolve(liveFromBody(isObject(envelope) ? envelope["data"] : void 0, "`samva brands get`"));
+	});
+});
+const fetchLiveBrand = (slug, env) => {
+	const apiKey = env["SAMVA_API_KEY"];
+	return apiKey !== void 0 && apiKey.length > 0 ? liveWithApiKey(slug, env, apiKey) : liveWithCli(slug, env);
+};
+const readSnapshotFile = async (path) => {
+	const raw = await readFile(path, "utf8").catch((cause) => {
+		if (cause.code === "ENOENT") return void 0;
+		throw cause;
+	});
+	if (raw === void 0) return {
+		ok: true,
+		snapshot: void 0,
+		path
+	};
+	const parsed = (() => {
+		try {
+			return JSON.parse(raw);
+		} catch {
+			return;
+		}
+	})();
+	const brand = asBrand(parsed);
+	if (brand === void 0 || !isObject(parsed) || parsed["version"] !== SNAPSHOT_VERSION || typeof parsed["pulledAt"] !== "string") return {
+		ok: false,
+		message: `${path} is not a brand snapshot this version of @samva/vite reads. Run \`samva brands pull\` to rewrite it.`
+	};
+	return {
+		ok: true,
+		snapshot: {
+			...brand,
+			version: SNAPSHOT_VERSION,
+			pulledAt: parsed["pulledAt"]
+		},
+		path
+	};
+};
+/**
+* The snapshot for a named brand, or for the default brand the most recently
+* pulled snapshot that was the default when it was pulled.
+*/
+const readSnapshot = async (root, slug) => {
+	const directory = join(root, BRAND_SNAPSHOT_DIR);
+	if (slug !== void 0) return readSnapshotFile(join(directory, `${slug}.json`));
+	const names = await readdir(directory).catch((cause) => {
+		if (cause.code === "ENOENT") return [];
+		throw cause;
+	});
+	const reads = await Promise.all(names.filter((name) => name.endsWith(".json")).sort().map((name) => readSnapshotFile(join(directory, name))));
+	const failed = reads.find((read) => !read.ok);
+	if (failed !== void 0) return failed;
+	const defaults = reads.flatMap((read) => read.ok && read.snapshot?.isDefault === true ? [{
+		...read,
+		snapshot: read.snapshot
+	}] : []);
+	defaults.sort((a, b) => b.snapshot.pulledAt.localeCompare(a.snapshot.pulledAt));
+	return defaults[0] ?? {
+		ok: true,
+		snapshot: void 0,
+		path: directory
+	};
+};
+const SAFE_SLUG = /^[a-z0-9][a-z0-9._-]*$/i;
+/**
+* Refresh the cached copy after a live answer. Best effort: a read-only checkout
+* or a full disk must not fail a build that already has the brand it needs.
+*/
+const cacheBrand = async (root, brand, cached) => {
+	if (!SAFE_SLUG.test(brand.slug) || cached?.digest === brand.digest) return;
+	const directory = join(root, BRAND_SNAPSHOT_DIR);
+	const target = join(directory, `${brand.slug}.json`);
+	const snapshot = {
+		...brand,
+		pulledAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	const temporary = `${target}.${process.pid}.tmp`;
+	await mkdir(directory, { recursive: true }).then(() => writeFile(temporary, `${JSON.stringify(snapshot, null, 2)}\n`, "utf8")).then(() => rename(temporary, target)).catch(() => void 0);
+};
+const toResolved = (brand) => ({
+	slug: brand.slug,
+	css: brand.css,
+	digest: brand.digest,
+	...brand.assets === void 0 ? {} : { assets: brand.assets },
+	...brand.footer === void 0 ? {} : { footer: brand.footer }
+});
+const relativeSnapshot = (root, path) => relative(root, path).split(sep).join("/");
+/**
+* Resolve the brand a project's `samva:brand` import names: live when the
+* environment's credentials reach the API, else the pulled snapshot with a
+* warning, else a failure naming both fixes.
+*/
+const resolveProjectBrand = async (input) => {
+	const specifier = projectBrandSpecifier(input.files, input.themePath ?? "");
+	if (specifier === void 0) return {
+		ok: true,
+		brand: void 0,
+		source: "none",
+		warnings: []
+	};
+	const slug = parseBrandSpecifier(specifier)?.slug;
+	const pullCommand = `samva brands pull${slug === void 0 ? "" : ` ${slug}`}`;
+	const [live, local] = await Promise.all([input.offline === true ? Promise.resolve({
+		ok: false,
+		reason: "offline mode skips the live brand"
+	}) : fetchLiveBrand(slug, input.env), readSnapshot(input.root, slug)]);
+	if (live.ok) {
+		const cached = local.ok ? local.snapshot : void 0;
+		const stale = cached !== void 0 && cached.digest !== live.brand.digest;
+		await cacheBrand(input.root, live.brand, cached);
+		return {
+			ok: true,
+			brand: toResolved(live.brand),
+			source: "live",
+			warnings: stale ? [{
+				code: "brand-snapshot-stale",
+				message: `${relativeSnapshot(input.root, local.ok ? local.path : input.root)} was older than the live brand ${live.brand.slug}; the cached copy is refreshed.`
+			}] : []
+		};
+	}
+	if (!local.ok) return {
+		ok: false,
+		message: local.message
+	};
+	if (local.snapshot === void 0) return {
+		ok: false,
+		message: `The project imports ${specifier}, but ${live.reason}, and there is no snapshot in ${BRAND_SNAPSHOT_DIR}. Run \`samva login\` or set SAMVA_API_KEY, or run \`${pullCommand}\` while online.`
+	};
+	return {
+		ok: true,
+		brand: toResolved(local.snapshot),
+		source: "snapshot",
+		warnings: [{
+			code: "brand-offline",
+			message: `Using ${relativeSnapshot(input.root, local.path)} (pulled ${local.snapshot.pulledAt}) for ${specifier}: ${live.reason}.`
+		}]
+	};
+};
+/**
+* The environment a local build resolves the brand with: the process
+* environment plus the project's `.env` files, as the editor's dev server
+* reads them, so `SAMVA_API_KEY` in `.env` reaches `check` and `export` too.
+*/
+const loadBrandEnv = async (root) => {
+	const vite = await import("vite").catch(() => void 0);
+	if (vite === void 0) throw new Error("`vite` is required to resolve samva:brand locally.");
+	return vite.loadEnv("development", root, "");
+};
+/** The resolution as build findings: warnings stay warnings, a failure is an error. */
+const brandDiagnostics = (resolution) => resolution.ok ? resolution.warnings.map((warning) => ({
+	code: warning.code,
+	severity: "warning",
+	message: warning.message,
+	origins: []
+})) : [{
+	code: "brand-unavailable",
+	severity: "error",
+	message: resolution.message,
+	origins: []
+}];
+/**
+* One resolver per watch session. A resolution is reused for a short while per
+* specifier, so saving a file does not ask the API each time while a brand
+* edited elsewhere still arrives within the window.
+*/
+const createBrandResolver = (options) => {
+	const cache = /* @__PURE__ */ new Map();
+	return { resolve: async (files, themePath) => {
+		const key = projectBrandSpecifier(files, themePath ?? "") ?? "";
+		const cached = cache.get(key);
+		if (cached !== void 0 && Date.now() - cached.at < RESOLUTION_TTL_MS) return cached.resolution;
+		const resolution = await resolveProjectBrand({
+			root: options.root,
+			files,
+			themePath,
+			env: options.env,
+			offline: options.offline
+		});
+		cache.set(key, {
+			at: Date.now(),
+			resolution
+		});
+		return resolution;
+	} };
+};
+//#endregion
+//#region src/compile.ts
+const CHANNELS = [
+	"email",
+	"sms",
+	"whatsapp"
+];
+/** The channels a compiled template declares, in a fixed order. */
+const channelsOf = (ir) => CHANNELS.filter((channel) => ir[channel] !== void 0);
+const finding = (code, severity, message, extra = {}) => ({
+	code,
+	severity,
+	message,
+	origins: [],
+	...extra
+});
+const isHelper = (diagnostics) => diagnostics.length > 0 && diagnostics.every((item) => item.code === "no-template");
+const failure = (cause) => finding("compile-failed", "error", cause instanceof Error ? cause.message : String(cause));
+const compileEntry = async (input, entryPath) => {
+	const attempt = await compileTemplate({
+		files: input.files,
+		entry: entryPath,
+		assetBase: input.assetBase,
+		...input.brand === void 0 ? {} : { brand: input.brand },
+		tailwind: input.theme === void 0 ? {} : {
+			css: input.theme.css,
+			cssPath: input.theme.path
+		}
+	}).then((compiled) => ({
+		ok: true,
+		compiled
+	}), (cause) => ({
+		ok: false,
+		cause
+	}));
+	if (!attempt.ok) return {
+		kind: "failed",
+		entry: {
+			entryPath,
+			diagnostics: [failure(attempt.cause)]
+		}
+	};
+	const { compiled } = attempt;
+	const { ir } = compiled;
+	if (ir === void 0) return isHelper(compiled.diagnostics) ? {
+		kind: "helper",
+		entryPath
+	} : {
+		kind: "failed",
+		entry: {
+			entryPath,
+			diagnostics: compiled.diagnostics
+		}
+	};
+	return {
+		kind: "template",
+		entry: {
+			id: ir.template,
+			entryPath,
+			ir,
+			fixtures: compiled.fixtures,
+			assets: compiled.assets,
+			diagnostics: compiled.diagnostics,
+			channels: channelsOf(ir)
+		}
+	};
+};
+/**
+* Compile every candidate entry. An entry the compiler reports `no-template`
+* for is a helper module, not a template; that is how a partial is told apart
+* from a template without evaluating either. One failure stays with its entry.
+*/
+const compileProject = async (input) => {
+	const entries = [...input.entries].sort();
+	const results = await Promise.all(entries.map((entryPath) => compileEntry(input, entryPath)));
+	const templates = [];
+	const failures = [];
+	const helpers = [];
+	const diagnostics = [];
+	const assets = /* @__PURE__ */ new Map();
+	const declaredBy = /* @__PURE__ */ new Map();
+	for (const result of results) {
+		if (result.kind === "helper") {
+			helpers.push(result.entryPath);
+			continue;
+		}
+		if (result.kind === "failed") {
+			failures.push(result.entry);
+			continue;
+		}
+		const { entry } = result;
+		const previous = declaredBy.get(entry.id);
+		if (previous !== void 0) {
+			diagnostics.push(finding("duplicate-template-id", "error", `Template id ${JSON.stringify(entry.id)} is declared by both ${previous} and ${entry.entryPath}. An id is a publication's identity, so it must name exactly one template.`));
+			continue;
+		}
+		declaredBy.set(entry.id, entry.entryPath);
+		for (const asset of entry.assets) assets.set(asset.digest, asset);
+		templates.push(entry);
+	}
+	return {
+		templates: templates.sort((left, right) => left.id < right.id ? -1 : 1),
+		failures,
+		helpers,
+		diagnostics,
+		assets: [...assets.values()].sort((left, right) => left.fileName < right.fileName ? -1 : 1)
+	};
+};
+/** A renderer refusal as findings about one fixture. */
+const renderFindings = (cause, templateId, fixture) => {
+	const carried = cause.diagnostics;
+	if (Array.isArray(carried) && carried.length > 0) return carried.map((item) => finding(item.code, "error", item.message, { fixtures: [fixture] }));
+	return [finding("render-failed", "error", `${templateId} could not render fixture ${JSON.stringify(fixture)}: ${cause instanceof Error ? cause.message : String(cause)}`, { fixtures: [fixture] })];
+};
+/**
+* Render every fixture a template declares through its email channel. A fixture
+* the renderer refuses is a finding on that fixture, never a thrown error, so
+* one bad input does not take the rest of the catalog with it.
+*/
+const renderEmailFixtures = (entry, options = {}) => Object.entries(entry.fixtures).map(([fixture, input]) => {
+	try {
+		return {
+			templateId: entry.id,
+			fixture,
+			rendered: renderIr(entry.ir, input, options),
+			diagnostics: []
+		};
+	} catch (cause) {
+		return {
+			templateId: entry.id,
+			fixture,
+			rendered: void 0,
+			diagnostics: renderFindings(cause, entry.id, fixture)
+		};
+	}
+});
+/** Client-matrix findings across the fixtures that rendered. */
+const emailCompatibility = (entry, rendered) => {
+	const renderable = Object.fromEntries(rendered.filter((result) => result.rendered !== void 0).map((result) => [result.fixture, entry.fixtures[result.fixture]]));
+	try {
+		return checkTemplateCompatibility(entry.ir, renderable);
+	} catch (cause) {
+		return [finding("compatibility-failed", "error", cause instanceof Error ? cause.message : String(cause))];
+	}
+};
+/** Render the SMS or WhatsApp channel of one fixture. */
+const renderChannelFixture = (entry, channel, fixture, options = {}) => {
+	if (!Object.hasOwn(entry.fixtures, fixture)) return {
+		ok: false,
+		diagnostics: [finding("unknown-fixture", "error", `Template ${entry.id} declares no fixture named ${JSON.stringify(fixture)}.`)]
+	};
+	try {
+		const input = entry.fixtures[fixture];
+		return channel === "sms" ? {
+			ok: true,
+			channel,
+			text: renderIrSms(entry.ir, input, options)
+		} : {
+			ok: true,
+			channel,
+			message: renderIrWhatsApp(entry.ir, input, options)
+		};
+	} catch (cause) {
+		return {
+			ok: false,
+			diagnostics: renderFindings(cause, entry.id, fixture)
+		};
+	}
+};
+const hasErrors = (diagnostics) => diagnostics.some((item) => item.severity === "error");
+//#endregion
+//#region src/local-assets.ts
+const HTTPS = /^https:\/\//i;
+/** True when the renderer accepts `base` as it is: a delivered message can resolve it. */
+const isDeliverableBase = (base) => HTTPS.test(base);
+/** An https origin exactly as long as `base`, unique enough not to occur in authored content. */
+const placeholderBase = (base) => `https://${"~".repeat(Math.max(1, base.length - 8))}`;
+/** The placeholder to compile with for `base`, or `base` itself when it can be delivered. */
+const compileBase = (base) => base === void 0 || isDeliverableBase(base) ? base : placeholderBase(base);
+/** Swap the placeholder for `base` in rendered output. */
+const restoreBase = (output, base) => base === void 0 || isDeliverableBase(base) ? output : output.replaceAll(placeholderBase(base), base);
+/**
+* Resolves the `theme` plugin option to an absolute path, or `undefined` when
+* theming is explicitly disabled (`theme: false`). A string is taken relative to
+* `root` (absolute strings pass through); the default is `<root>/theme.css`.
+*/
+const resolveThemePath = (root, option) => {
+	if (option === false) return void 0;
+	const file = option ?? "theme.css";
+	return isAbsolute(file) ? file : resolve(root, file);
+};
+/** Read authored Tailwind CSS verbatim; the email compiler validates its syntax. */
+const readProjectThemeCss = async (path) => path === void 0 ? void 0 : readFile(path, "utf8").catch((cause) => {
+	if (cause.code === "ENOENT") return void 0;
+	throw cause;
+});
+/** The theme's project-relative path, from which its relative `@import`s resolve. */
+const projectThemePath = (root, themePath) => relative(root, themePath).split(sep).join("/");
+//#endregion
+//#region src/project.ts
+/** Resolve the root a set of options names. */
+const projectRoot = (options) => resolve(options.root ?? process.cwd());
+/**
+* Read, resolve the brand of, and compile every template in a project. `brands`
+* lets a long-lived caller reuse a brand resolution between loads, and `only`
+* limits compilation to the named project-relative entries.
+*/
+const loadProject = async (options = {}, brands, only) => {
+	const root = projectRoot(options);
+	const dirs = await templateDirectories(root, options.dir);
+	const [discovered, files] = await Promise.all([discoverEntries(root, dirs), readProjectFiles(root)]);
+	const entries = only === void 0 ? discovered : discovered.filter((path) => only.includes(path));
+	const themeFile = resolveThemePath(root, options.theme);
+	const themeCss = await readProjectThemeCss(themeFile);
+	const themePath = themeFile === void 0 || themeCss === void 0 ? void 0 : projectThemePath(root, themeFile);
+	const brand = await (brands ?? createBrandResolver({
+		root,
+		env: await loadBrandEnv(root),
+		offline: options.offline === true
+	})).resolve(files, themePath);
+	const catalog = await compileProject({
+		files,
+		entries,
+		assetBase: options.assetBase ?? "",
+		...themeCss === void 0 || themePath === void 0 ? {} : { theme: {
+			css: themeCss,
+			path: themePath
+		} },
+		...brand.ok && brand.brand !== void 0 ? { brand: brand.brand } : {}
+	});
+	return {
+		root,
+		files,
+		catalog,
+		themePath,
+		brand,
+		diagnostics: [...brandDiagnostics(brand), ...catalog.diagnostics]
+	};
+};
+/** Paths under these are the tool's own output, not project source. */
+const IGNORED_WATCH = [
+	SAMVA_DIR,
+	".git",
+	"node_modules"
+];
+/**
+* The authoring loop: one watcher, one brand resolver, a catalog reloaded on
+* demand. Each `load` re-reads the project and recompiles every template, so a
+* partial that changed reaches every template that imports it.
+*/
+const createProjectSession = (options = {}) => {
+	const root = projectRoot(options);
+	let latest;
+	let brands;
+	const listeners = /* @__PURE__ */ new Set();
+	const observer = watch(root, { recursive: true }, (_event, name) => {
+		const changed = name === null ? "" : toPosix(name.toString());
+		if (IGNORED_WATCH.some((ignored) => changed === ignored || changed.startsWith(`${ignored}/`))) return;
+		if (changed.split("/").includes("node_modules")) return;
+		for (const listener of listeners) listener(changed);
+	});
+	return {
+		load: async () => {
+			brands ??= createBrandResolver({
+				root,
+				env: await loadBrandEnv(root),
+				offline: options.offline === true
+			});
+			latest = await loadProject(options, brands);
+			return latest;
+		},
+		current: () => latest,
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => void listeners.delete(listener);
+		},
+		close: async () => {
+			observer.close();
+			listeners.clear();
+		}
+	};
+};
+/**
+* Where an export serves its assets from when the caller names no origin.
+*
+* An export writes one page at `templates/<id>/<fixture>.html` and every asset
+* once at `assets/<content address>`, so the base a page resolves against is
+* the path from its own directory back to that one. A template id is one path
+* segment, so every page sits at the same depth and one base serves them all.
+*/
+const DEFAULT_EXPORT_ASSET_BASE = "../../assets";
+/**
+* The path an export writes, or `undefined` when a name would leave the root.
+* The compiler already refuses an id or a fixture key that is not one path
+* segment, so this is the guard rather than the contract: the same pattern,
+* plus a containment check, so a name that reaches `join` can never address a
+* file the export does not own.
+*/
+const exportPath = (out, ...segments) => {
+	if (!segments.every((segment) => TEMPLATE_NAME_PATTERN.test(segment))) return void 0;
+	const path = join(out, ...segments);
+	const inside = relative(out, path);
+	return inside === "" || inside === ".." || inside.startsWith(`..${sep}`) || isAbsolute(inside) ? void 0 : path;
+};
+const unsafeExportName = (kind, value) => finding("unsafe-export-name", "error", `${kind} ${JSON.stringify(value)} is not one path segment, so an export cannot write a file for it. Use letters, digits, ".", "_" and "-", starting with a letter, digit or "_".`);
+/**
+* Render every template's fixtures to files beside the bytes of every asset they
+* reference, with the manifest that maps each address to its file. Email
+* fixtures write `<fixture>.html` and `<fixture>.txt`; a template's SMS and
+* WhatsApp channels write `<fixture>.sms.txt` and `<fixture>.whatsapp.json`.
+*
+* A relative `assetBase` is accepted, and the written page resolves its images
+* from the directory it sits in. Delivery keeps refusing relative references,
+* because an inbox has no directory to resolve one against, so an export
+* destined for sending names the https origin it will be served from instead.
+*/
+const exportProject = async (input) => {
+	const out = resolve(input.out);
+	const base = input.assetBase ?? "../../assets";
+	const project = await loadProject({
+		...input,
+		assetBase: compileBase(base)
+	});
+	const { catalog } = project;
+	const diagnostics = [
+		...project.diagnostics,
+		...catalog.failures.flatMap((failure) => failure.diagnostics),
+		...catalog.templates.flatMap((entry) => entry.diagnostics)
+	];
+	const templates = [];
+	for (const entry of catalog.templates) {
+		const directory = exportPath(out, "templates", entry.id);
+		if (directory === void 0) {
+			diagnostics.push(unsafeExportName("Template id", entry.id));
+			continue;
+		}
+		await mkdir(directory, { recursive: true });
+		const rendered = entry.channels.includes("email") ? renderEmailFixtures(entry) : [];
+		const exported = [];
+		for (const fixture of Object.keys(entry.fixtures)) {
+			const write = async (name, content) => {
+				const path = exportPath(out, "templates", entry.id, name);
+				if (path === void 0) {
+					diagnostics.push(unsafeExportName("Fixture name", fixture));
+					return;
+				}
+				await writeFile(path, content, "utf8");
+				return toPosix(relative(out, path));
+			};
+			const email = rendered.find((result) => result.fixture === fixture);
+			diagnostics.push(...email?.diagnostics ?? []);
+			const sms = entry.channels.includes("sms") ? renderChannelFixture(entry, "sms", fixture) : void 0;
+			const whatsapp = entry.channels.includes("whatsapp") ? renderChannelFixture(entry, "whatsapp", fixture) : void 0;
+			for (const result of [sms, whatsapp]) if (result?.ok === false) diagnostics.push(...result.diagnostics);
+			exported.push({
+				fixture,
+				...email?.rendered === void 0 ? {} : {
+					html: await write(`${fixture}.html`, restoreBase(email.rendered.html, base)),
+					text: await write(`${fixture}.txt`, email.rendered.text)
+				},
+				...sms?.ok === true && sms.channel === "sms" ? { sms: await write(`${fixture}.sms.txt`, sms.text) } : {},
+				...whatsapp?.ok === true && whatsapp.channel === "whatsapp" ? { whatsapp: await write(`${fixture}.whatsapp.json`, restoreBase(JSON.stringify(whatsapp.message, null, 2), base)) } : {}
+			});
+		}
+		templates.push({
+			id: entry.id,
+			entryPath: entry.entryPath,
+			fixtures: exported
+		});
+	}
+	const assetDirectory = join(out, "assets");
+	if (catalog.assets.length > 0) await mkdir(assetDirectory, { recursive: true });
+	await Promise.all(catalog.assets.map((asset) => {
+		const bytes = project.files[asset.path];
+		return bytes === void 0 || typeof bytes === "string" ? Promise.resolve() : writeFile(join(assetDirectory, asset.fileName), bytes);
+	}));
+	const receipt = {
+		templates,
+		assets: {
+			base,
+			assets: catalog.assets
+		},
+		diagnostics
+	};
+	await mkdir(out, { recursive: true });
+	await writeFile(join(out, "catalog.json"), `${JSON.stringify({
+		...receipt,
+		assets: {
+			base,
+			assets: catalog.assets.map((asset) => ({
+				...asset,
+				url: assetUrl(asset, base)
+			}))
+		}
+	}, null, 2)}\n`, "utf8");
+	return receipt;
+};
+//#endregion
+export { discoverEntries as C, readProjectFiles as D, projectPath as E, templateDirectories as O, SAMVA_DIR as S, isWithin as T, brandDiagnostics as _, projectRoot as a, resolveProjectBrand as b, restoreBase as c, emailCompatibility as d, finding as f, BRAND_SNAPSHOT_DIR as g, renderEmailFixtures as h, loadProject as i, isObject as k, channelsOf as l, renderChannelFixture as m, createProjectSession as n, compileBase as o, hasErrors as p, exportProject as r, isDeliverableBase as s, DEFAULT_EXPORT_ASSET_BASE as t, compileProject as u, createBrandResolver as v, isProjectFile as w, DEFAULT_TEMPLATE_DIRS as x, loadBrandEnv as y };
+
+//# sourceMappingURL=project-Cp8qb3s0.js.map