@replayablejs/export 0.1.0-alpha.0

package/dist/index.mjs

@@ -0,0 +1,1174 @@
+import { createRequire } from "node:module";
+import { mkdir, mkdtemp, readFile, readdir, realpath, rename, rm, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
+import { load } from "cheerio";
+import { build, transform } from "esbuild";
+import { deflate } from "pako";
+import { parse } from "acorn";
+import { minify } from "terser";
+import { Zip, ZipDeflate } from "fflate";
+import { simple } from "acorn-walk";
+import { createVariants, defineConfig } from "@replayablejs/config";
+//#region src/shared/filesystem-error.ts
+/** Reports whether a filesystem operation failed because its target path is absent. */
+function isMissingPathError(error) {
+	return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+//#endregion
+//#region src/shared/canonical-path.ts
+/**
+* Resolves symlinks in the existing portion of a path.
+*
+* Generated directories commonly do not exist yet. In that case, the nearest
+* existing ancestor is canonicalized and the missing path segments are appended
+* unchanged. For example, if "generated" is a symlink, resolving
+* "generated/exports" exposes its real destination before cleanup can use it.
+*/
+async function resolveCanonicalPath(path) {
+	const missingSegments = [];
+	let existingPath = path;
+	while (true) {
+		try {
+			const canonicalPath = await realpath(existingPath);
+			return resolve(canonicalPath, ...missingSegments);
+		} catch (error) {
+			if (!isMissingPathError(error)) throw error;
+		}
+		const parent = dirname(existingPath);
+		if (parent === existingPath) throw new Error(`Unable to resolve an existing ancestor for generated path: ${path}.`);
+		missingSegments.unshift(basename(existingPath));
+		existingPath = parent;
+	}
+}
+//#endregion
+//#region src/emission/write-export-artifacts.ts
+/**
+* Writes every prepared artifact before replacing the last successful export directory.
+*
+* The caller has already prepared the HTML/ZIP bytes and resolved unique, flat
+* output filenames. This function only handles filesystem delivery; it does not
+* build, compress, validate, or rename individual network artifacts.
+*
+* Delivery has three stages:
+* 1. Write all new files into a temporary sibling directory. Existing exports stay
+*    untouched while those writes run, including when a write fails.
+* 2. Move the existing export directory into a backup, then move the completed
+*    replacement into its final location. Old files are replaced as a set, not merged.
+* 3. Remove the temporary directory and the now-obsolete backup after success.
+*
+* If installing the replacement fails, restore the backup before rejecting. If
+* restoration also fails, keep the backup and report its path in an AggregateError
+* containing both failures. Cleanup must never delete that remaining recovery copy.
+*
+* This is recovery for awaited filesystem failures, not a crash-safe transaction
+* or a lock against concurrent exporters. The destination is briefly absent between
+* the two renames; process termination during that interval cannot run rollback.
+*
+* @param outputDirectory - Canonical absolute destination resolved by the export pipeline.
+* @param artifacts - Complete replacement set, with unique filenames assigned by resolution.
+* An empty set intentionally produces an empty export directory.
+*
+* @example Temporary paths when replacing a project's `exports` directory:
+* ```text
+* basic-playable/
+*   exports/                         Previous delivery files, until replacement starts
+*   .exports-staging-<unique>/        Temporary sibling owned by this operation
+*     prepared/                      New applovin_default_en.html, google_default_en.zip, ...
+*     previous/                      Old exports, moved here immediately before replacement
+* ```
+* On success, `prepared` becomes `exports`, and the temporary sibling is removed.
+*/
+async function writeExportArtifacts(outputDirectory, artifacts) {
+	const parent = dirname(outputDirectory);
+	await assertOutputDirectoryUnchanged(outputDirectory);
+	await mkdir(parent, { recursive: true });
+	const stagingDirectory = await mkdtemp(join(parent, `.${basename(outputDirectory)}-staging-`));
+	const preparedDirectory = join(stagingDirectory, "prepared");
+	const backupDirectory = join(stagingDirectory, "previous");
+	let preserveBackup = false;
+	try {
+		await mkdir(preparedDirectory);
+		for (const artifact of artifacts) await writeFile(join(preparedDirectory, basename(artifact.outputFile)), artifact.content);
+		await assertOutputDirectoryUnchanged(outputDirectory);
+		const hasPreviousExport = await movePreviousExport(outputDirectory, backupDirectory);
+		try {
+			await rename(preparedDirectory, outputDirectory);
+		} catch (error) {
+			if (hasPreviousExport) try {
+				await rename(backupDirectory, outputDirectory);
+			} catch (restoreError) {
+				preserveBackup = true;
+				throw new AggregateError([error, restoreError], `Export replacement failed. Previous exports remain at ${backupDirectory}.`, { cause: restoreError });
+			}
+			throw error;
+		}
+	} finally {
+		if (!preserveBackup) await rm(stagingDirectory, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+/**
+* Moves an existing destination into the operation's backup directory.
+*
+* Returns true only after the move succeeds, allowing the caller to attempt rollback.
+* A missing path returns false (normally the first export). Permission, device, and
+* other filesystem errors propagate; they must not be treated as an absent export.
+*/
+async function movePreviousExport(outputDirectory, backupDirectory) {
+	try {
+		await rename(outputDirectory, backupDirectory);
+		return true;
+	} catch (error) {
+		if (isMissingPathError(error)) return false;
+		throw error;
+	}
+}
+/**
+* Detects a symlink introduced after resolution and before directory replacement.
+*
+* Resolution stores the canonical destination. Resolving it again immediately
+* before staging and replacement detects an intermediate path redirected since then.
+* Reject rather than move a directory belonging to that new target. This check
+* does not lock the path or prevent another process changing it after the check.
+*/
+async function assertOutputDirectoryUnchanged(outputDirectory) {
+	if (await resolveCanonicalPath(outputDirectory) !== outputDirectory) throw new Error(`Refusing to clean a redirected export directory: ${outputDirectory}.`);
+}
+//#endregion
+//#region src/emission/emit-export-project.ts
+/** Writes prepared artifacts safely, then reports their committed destinations. */
+async function emitExportProject(project, artifacts) {
+	await writeExportArtifacts(project.outputDirectory, artifacts);
+	return {
+		outputDirectory: project.outputDirectory,
+		variants: artifacts.map(describeExportArtifact)
+	};
+}
+/** Reports the committed artifact's final path and byte size. */
+function describeExportArtifact(artifact) {
+	const { content, outputFile, variantId } = artifact;
+	return {
+		file: outputFile,
+		size: measureArtifact(content),
+		variantId
+	};
+}
+/** Measures text and binary artifacts in the bytes reported by the filesystem. */
+function measureArtifact(content) {
+	return typeof content === "string" ? Buffer.byteLength(content) : content.byteLength;
+}
+//#endregion
+//#region src/shared/export-limits.ts
+/** Maximum delivery size in bytes; Liftoff applies this to entry HTML. */
+const MAX_EXPORT_SIZE_BYTES = 5e6;
+/** Moloco requires a strictly smaller delivery; other networks include the limit. */
+function isWithinExportSizeLimit(bytes, network) {
+	return network === "moloco" ? bytes < MAX_EXPORT_SIZE_BYTES : bytes <= MAX_EXPORT_SIZE_BYTES;
+}
+//#endregion
+//#region src/shared/export-file-reference.ts
+/** Converts a relative document URL into its normalized export-file path. */
+function resolveExportFileReference(reference) {
+	if (reference === "" || reference.startsWith("//") || reference.startsWith("/") || /^[a-z][a-z\d+.-]*:/iu.test(reference)) return;
+	const encodedPath = reference.split(/[?#]/u, 1)[0];
+	if (encodedPath === void 0 || encodedPath === "") return;
+	let decodedPath;
+	try {
+		decodedPath = decodeURIComponent(encodedPath);
+	} catch {
+		return;
+	}
+	const exportFilePath = posix.normalize(decodedPath);
+	if (exportFilePath === ".." || exportFilePath.startsWith("../") || posix.isAbsolute(exportFilePath)) return;
+	return exportFilePath;
+}
+//#endregion
+//#region src/validation/resource-references.ts
+const RESOURCE_SELECTOR = "[src], link[href], object[data], video[poster]";
+const RESOURCE_ATTRIBUTES = [
+	"src",
+	"href",
+	"data",
+	"poster"
+];
+/**
+* Describes every document resource rejected by the caller's availability policy.
+*
+* For example, an unresolved image becomes 'img[src]="assets/logo.png"', making
+* the exact element, attribute, and reference immediately visible in diagnostics.
+*/
+function collectUnavailableResourceReferences(document, isAvailable) {
+	const unavailableResources = [];
+	for (const element of document(RESOURCE_SELECTOR).toArray()) for (const attribute of RESOURCE_ATTRIBUTES) {
+		const reference = document(element).attr(attribute);
+		if (reference === void 0 || isAvailable(reference)) continue;
+		unavailableResources.push(`${element.tagName}[${attribute}]=${JSON.stringify(reference)}`);
+	}
+	return unavailableResources;
+}
+/** Reports whether a reference's bytes already live inside the HTML document. */
+function isEmbeddedResourceReference(reference) {
+	return reference.startsWith("data:") || reference.startsWith("#");
+}
+/**
+* Reports whether a resource is embedded or resolves to a file inside an archive.
+*
+* The caller builds the path set once, then reuses it for every document
+* reference instead of repeatedly searching the archive file array.
+*/
+function isAvailableArchiveResourceReference(reference, archivePaths) {
+	if (isEmbeddedResourceReference(reference)) return true;
+	const exportFilePath = resolveExportFileReference(reference);
+	return exportFilePath !== void 0 && archivePaths.has(exportFilePath);
+}
+//#endregion
+//#region src/shared/playable-html.ts
+/** Canonical entry document produced by every Replayable build. */
+const PLAYABLE_HTML_FILE = "index.html";
+/** Returns the required playable entry document from a collected build. */
+function requirePlayableHtml(files, variantId) {
+	const html = files.find(({ path }) => path === PLAYABLE_HTML_FILE);
+	if (html === void 0) throw new Error(`Build ${variantId} does not contain a root ${PLAYABLE_HTML_FILE}.`);
+	return html;
+}
+//#endregion
+//#region src/validation/stylesheet-resources.ts
+/** Checks inline CSS in its final HTML location, including style attributes. */
+async function validateDocumentStylesheets(document, files = [], htmlPath = PLAYABLE_HTML_FILE) {
+	for (const element of document("style, [style]").toArray()) {
+		const node = document(element);
+		if (element.tagName === "style") await validateStylesheetResources(node.text(), htmlPath, files);
+		const declarations = node.attr("style");
+		if (declarations !== void 0) await validateStylesheetResources(`.inline { ${declarations} }`, htmlPath, files);
+	}
+}
+/** Checks each archived stylesheet relative to its own file, not the root HTML. */
+async function validateArchiveStylesheets(files) {
+	const decoder = new TextDecoder();
+	for (const file of files) if (file.path.endsWith(".css")) await validateStylesheetResources(decoder.decode(file.data), file.path, files);
+	else if (file.path.endsWith(".html")) await validateDocumentStylesheets(load(decoder.decode(file.data)), files, file.path);
+}
+/**
+* Lets esbuild parse CSS escapes, url() and @import rather than guessing with regex.
+* All references are marked external during this inspection: nothing is fetched,
+* emitted, or bundled. The existing export files are the only allowed resources.
+*/
+async function validateStylesheetResources(source, owner, files) {
+	const paths = new Set(files.map((file) => file.path));
+	const unavailable = /* @__PURE__ */ new Set();
+	await build({
+		stdin: {
+			contents: source,
+			loader: "css",
+			sourcefile: owner
+		},
+		bundle: true,
+		write: false,
+		logLevel: "silent",
+		plugins: [{
+			name: "validate-export-css-resources",
+			setup(builder) {
+				builder.onResolve({ filter: /.*/ }, ({ path }) => {
+					if (!isEmbeddedResourceReference(path) && !isArchivedStylesheetResource(path, owner, paths)) unavailable.add(path);
+					return {
+						path,
+						external: true
+					};
+				});
+			}
+		}]
+	});
+	if (unavailable.size > 0) throw new Error(`Stylesheet in ${owner} contains unavailable resources: ${[...unavailable].join(", ")}.`);
+}
+/** Resolves nested CSS URLs while rejecting remote and root-relative resources. */
+function isArchivedStylesheetResource(reference, owner, paths) {
+	if (reference.startsWith("/") || /^[a-z][a-z\d+.-]*:/iu.test(reference)) return false;
+	const path = resolveExportFileReference(posix.join(posix.dirname(owner), reference));
+	return path !== void 0 && paths.has(path);
+}
+//#endregion
+//#region src/validation/single-html.ts
+/** Enforces the destination policy that can be proven from one standalone document. */
+async function validateSingleHtmlExport(document, source, options) {
+	validateFileSize(source, options);
+	await validateDocumentStylesheets(document);
+	const preservedReferences = new Set(options.preservedResourceReferences);
+	const unavailableResources = collectUnavailableResourceReferences(document, (reference) => isEmbeddedResourceReference(reference) || preservedReferences.has(reference));
+	if (unavailableResources.length > 0) throw new Error(`${options.networkName} export contains non-embedded resources: ${unavailableResources.join(", ")}.`);
+}
+/** Rejects a serialized document larger than the destination network permits. */
+function validateFileSize(source, options) {
+	const size = Buffer.byteLength(source);
+	if (size <= options.maxFileSizeBytes) return;
+	const formattedSize = size.toLocaleString("en-US");
+	const formattedLimit = options.maxFileSizeBytes.toLocaleString("en-US");
+	throw new Error(`${options.networkName} export exceeds its ${formattedLimit}-byte limit: ${formattedSize} bytes.`);
+}
+//#endregion
+//#region src/preparation/shared/collect-build-files.ts
+/**
+* Collects one build directory as files ready for network-specific preparation.
+*
+* Given `dist/default/google/en` as the build directory:
+*
+* - `dist/default/google/en/index.html` becomes `{ path: 'index.html', data }`
+* - `dist/default/google/en/assets/main.js` becomes `{ path: 'assets/main.js', data }`
+*
+* Paths always use forward slashes and are sorted before their bytes are read,
+* producing the same ordered result on macOS, Linux, and Windows.
+*/
+async function collectBuildFiles(buildDirectory) {
+	const files = (await readdir(buildDirectory, {
+		recursive: true,
+		withFileTypes: true
+	})).filter((entry) => entry.isFile()).map((entry) => {
+		const file = resolve(entry.parentPath, entry.name);
+		return {
+			path: relative(buildDirectory, file).split(sep).join(posix.sep),
+			file
+		};
+	}).sort(compareExportFiles);
+	return Promise.all(files.map(async ({ path, file }) => ({
+		path,
+		data: await readFile(file)
+	})));
+}
+/** Orders export files by code point, independently of host locale. */
+function compareExportFiles(left, right) {
+	if (left.path < right.path) return -1;
+	if (left.path > right.path) return 1;
+	return 0;
+}
+//#endregion
+//#region src/preparation/shared/compress-javascript.ts
+const MAX_DEFLATE_LEVEL = 9;
+const MIN_COMPRESSION_SAVINGS_RATIO = .05;
+/**
+* Compresses prepared JavaScript only when its embedded Base64 is meaningfully smaller.
+*
+* Deflate produces binary data, but the standalone HTML must carry that data as
+* Base64 text. Comparing the finished Base64 payload accounts for its roughly
+* one-third expansion. Requiring a five-percent final reduction avoids spending
+* runtime CPU to inflate a large module for a negligible delivery-size saving.
+* Returning `undefined` tells the caller to preserve the original module source.
+*/
+function createCompressedJavaScriptPayload(source) {
+	if (source.length === 0) return;
+	const compressedSource = deflate(source, { level: MAX_DEFLATE_LEVEL });
+	const compressedPayload = Buffer.from(compressedSource).toString("base64");
+	const sourceSize = Buffer.byteLength(source);
+	if ((sourceSize - Buffer.byteLength(compressedPayload)) / sourceSize < MIN_COMPRESSION_SAVINGS_RATIO) return;
+	return compressedPayload;
+}
+/** Creates both delivery representations without discarding the prepared source. */
+function createJavaScriptCompressionCandidate(source) {
+	return {
+		compressedPayload: createCompressedJavaScriptPayload(source),
+		source
+	};
+}
+//#endregion
+//#region src/validation/build-entries.ts
+const ENTRY_ATTRIBUTE$1 = "data-replayable-entry";
+const entryRoles = [
+	"host",
+	"config",
+	"assets",
+	"application"
+];
+/**
+* Requires the four generated runtime entries to appear once in execution order.
+*
+* Module scripts execute in document order after fetching, so accepting missing,
+* duplicated, or reordered markers would make an otherwise valid archive fail only
+* at runtime with a misleading registration error.
+*/
+function validateBuildEntryOrder(document, variantId) {
+	const actualRoles = document(`script[${ENTRY_ATTRIBUTE$1}]`).toArray().map((element) => document(element).attr(ENTRY_ATTRIBUTE$1));
+	if (actualRoles.length === entryRoles.length && actualRoles.every((role, index) => role === entryRoles[index])) return;
+	throw new Error(`Build ${variantId} must execute Replayable entries as ${entryRoles.join(" → ")}; received ${actualRoles.join(" → ") || "none"}.`);
+}
+//#endregion
+//#region src/preparation/shared/prepare-javascript.ts
+/**
+* Prepares generated JavaScript for network delivery and safe HTML embedding.
+*
+* The narrow evaluation pass converts constant template literals produced by
+* the build minifier into ordinary quoted strings without enabling Terser's
+* broader compression transforms. This keeps static network analyzers reliable,
+* while `ascii_only` escapes Unicode for conservative delivery environments and
+* `inline_script` prevents source from closing its containing script element.
+*/
+async function prepareExportJavaScript(source, sourceType) {
+	const result = await minify(source, {
+		compress: {
+			defaults: false,
+			evaluate: true
+		},
+		mangle: false,
+		module: sourceType === "module",
+		format: {
+			ascii_only: true,
+			inline_script: true,
+			quote_style: 1
+		}
+	});
+	if (result.code === void 0) throw new Error("Terser did not produce JavaScript for export.");
+	return result.code;
+}
+//#endregion
+//#region src/preparation/shared/prepare-classic-javascript.ts
+/**
+* Converts a self-contained module into Mintegral's external classic script.
+* Vite's dynamic-import helpers can retain import.meta even without splitting.
+* Resolve their URL against the executing script, not the containing HTML page.
+*/
+async function prepareClassicJavaScript(source) {
+	const result = await prepareExportJavaScript(`(async function (entryUrl) {
+'use strict';
+${(await transform(source, {
+		loader: "js",
+		define: {
+			"import.meta.url": "entryUrl",
+			"import.meta.resolve": "undefined"
+		}
+	})).code}
+})(document.currentScript.src);`, "script");
+	parse(result, {
+		ecmaVersion: "latest",
+		sourceType: "script"
+	});
+	return result;
+}
+//#endregion
+//#region src/preparation/shared/prepare-stylesheet.ts
+/**
+* Prepares generated CSS for compact and safe embedding inside a style element.
+*
+* Esbuild's "inline-style" support escapes source that could otherwise terminate
+* the containing style element when the final HTML is parsed.
+*/
+async function prepareExportStylesheet(source) {
+	return (await transform(source, {
+		loader: "css",
+		minify: true,
+		supported: { "inline-style": true }
+	})).code;
+}
+//#endregion
+//#region src/preparation/shared/html-document.ts
+const ENTRY_ATTRIBUTE = "data-replayable-entry";
+/** Loads the required root HTML document from collected build files. */
+function loadHtmlBuildDocument(files, variantId) {
+	const html = requirePlayableHtml(files, variantId);
+	return load(new TextDecoder().decode(html.data));
+}
+/**
+* Resolves the local host, config, assets, application, and stylesheet files
+* referenced by a production build document.
+*
+* Host-provided and external resources are ignored. Every marked entry and local
+* stylesheet must exist in `files`. Internal entry markers are removed after
+* resolution so they never appear in network delivery HTML.
+*/
+function resolveHtmlBuildResources(document, files, variantId) {
+	validateBuildEntryOrder(document, variantId);
+	return {
+		entries: {
+			host: resolveEntry(document, files, variantId, "host"),
+			config: resolveEntry(document, files, variantId, "config"),
+			assets: resolveEntry(document, files, variantId, "assets"),
+			application: resolveEntry(document, files, variantId, "application")
+		},
+		stylesheets: resolveStylesheets(document, files, variantId)
+	};
+}
+/** Replaces every generated stylesheet link with minified inline CSS. */
+async function inlineStylesheets(document, stylesheets) {
+	for (const stylesheet of stylesheets) {
+		const inlineSource = await prepareExportStylesheet(new TextDecoder().decode(stylesheet.file.data));
+		const style = document("<style></style>").text(inlineSource);
+		stylesheet.element.replaceWith(style);
+	}
+}
+/** Reads and normalizes a generated module before its delivery form is selected. */
+function prepareModuleEntrySource(entry) {
+	return prepareExportJavaScript(new TextDecoder().decode(entry.file.data), "module");
+}
+/** Replaces a module reference with an already prepared inline source. */
+function inlinePreparedModuleEntry(entry, source) {
+	entry.element.removeAttr("src");
+	entry.element.text(source);
+}
+/**
+* Converts one external module entry into an external classic script.
+*
+* The HTML element keeps its `src` but loses `type="module"`. The returned file
+* contains an async IIFE so authored top-level `await` retains its behavior.
+*/
+async function prepareClassicScriptEntry(entry) {
+	const javaScript = await prepareClassicJavaScript(new TextDecoder().decode(entry.file.data));
+	entry.element.removeAttr("type");
+	return {
+		path: entry.file.path,
+		data: new TextEncoder().encode(javaScript)
+	};
+}
+/** Serializes a transformed document with one deterministic trailing newline. */
+function serializeHtmlDocument(document) {
+	return `${document.html()}\n`;
+}
+/** Resolves exactly one local script carrying the requested Replayable entry role. */
+function resolveEntry(document, files, variantId, role) {
+	const entries = [];
+	for (const element of document(`script[${ENTRY_ATTRIBUTE}="${role}"][src]`).toArray()) {
+		const script = document(element);
+		const reference = script.attr("src");
+		if (reference === void 0) continue;
+		const resource = resolveLocalResource(script, reference, files, variantId);
+		if (resource !== void 0) {
+			script.removeAttr(ENTRY_ATTRIBUTE);
+			entries.push(resource);
+		}
+	}
+	const entry = entries[0];
+	if (entry === void 0 || entries.length !== 1) throw new Error(`Build ${variantId} requires exactly one local ${role} entry; received ${entries.length}.`);
+	return entry;
+}
+/** Resolves local stylesheet links while preserving their document positions. */
+function resolveStylesheets(document, files, variantId) {
+	const stylesheets = [];
+	for (const element of document("link[rel][href]").toArray()) {
+		const stylesheet = document(element);
+		const relation = stylesheet.attr("rel");
+		const reference = stylesheet.attr("href");
+		if (!(relation?.split(/\s+/u).some((value) => value.toLowerCase() === "stylesheet") ?? false) || reference === void 0) continue;
+		const resource = resolveLocalResource(stylesheet, reference, files, variantId);
+		if (resource !== void 0) stylesheets.push(resource);
+	}
+	return stylesheets;
+}
+/** Resolves one local document reference while leaving host and remote URLs untouched. */
+function resolveLocalResource(element, reference, files, variantId) {
+	const path = resolveExportFileReference(reference);
+	if (path === void 0) return;
+	const file = files.find((candidate) => candidate.path === path);
+	if (file === void 0) throw new Error(`Build ${variantId} contains an unavailable local resource: ${reference}.`);
+	return {
+		element,
+		file
+	};
+}
+//#endregion
+//#region src/shared/compression-protocol.ts
+/** Identifies the inert script element that stores one Replayable module. */
+const COMPRESSED_ENTRY_ATTRIBUTE = "data-replayable-compressed-entry";
+/** Describes whether an inert Replayable module contains source or Deflate data. */
+const ENTRY_ENCODING_ATTRIBUTE = "data-replayable-entry-encoding";
+//#endregion
+//#region src/preparation/shared/load-compressed-module-loader.ts
+const COMPRESSED_MODULE_LOADER_PATH = new URL("./browser/compressed-module-loader.js", import.meta.url);
+let compressedModuleLoaderSource;
+/**
+* Loads and prepares Replayable's compiled browser-side module loader.
+*
+* The promise caches both the file read and export preparation so concurrently
+* generated variants share the same immutable minified source.
+*/
+function loadCompressedModuleLoader() {
+	compressedModuleLoaderSource ??= readFile(COMPRESSED_MODULE_LOADER_PATH, "utf8").then((source) => prepareExportJavaScript(source, "module"));
+	return compressedModuleLoaderSource;
+}
+//#endregion
+//#region src/preparation/shared/inline-compressed-modules.ts
+/**
+* Stores assets and application as inert payloads and appends their shared loader.
+*
+* Compressed entries use Base64 because Deflate produces binary data. An entry
+* that did not become smaller remains readable JavaScript under `identity`
+* encoding, avoiding Base64's one-third expansion while preserving deterministic
+* assets-before-application execution.
+*/
+async function inlineCompressedModules(entries) {
+	const loaderSource = await loadCompressedModuleLoader();
+	const loader = entries.application.resource.element.clone();
+	storeModulePayload(entries.assets, "assets");
+	storeModulePayload(entries.application, "application");
+	loader.removeAttr("src");
+	loader.removeAttr(COMPRESSED_ENTRY_ATTRIBUTE);
+	loader.removeAttr(ENTRY_ENCODING_ATTRIBUTE);
+	loader.attr("type", "module");
+	loader.text(loaderSource);
+	entries.application.resource.element.after(loader);
+}
+/** Replaces one module reference with its selected inert delivery representation. */
+function storeModulePayload(entry, role) {
+	const compressedPayload = entry.candidate.compressedPayload;
+	entry.resource.element.removeAttr("src");
+	entry.resource.element.attr("type", "application/octet-stream");
+	entry.resource.element.attr(COMPRESSED_ENTRY_ATTRIBUTE, role);
+	entry.resource.element.attr(ENTRY_ENCODING_ATTRIBUTE, compressedPayload === void 0 ? "identity" : "deflate");
+	entry.resource.element.text(compressedPayload ?? entry.candidate.source);
+}
+//#endregion
+//#region src/preparation/shared/load-pako-inflater.ts
+const PAKO_INFLATER_PATH = createRequire(import.meta.url).resolve("pako/dist/pako_inflate.min.js");
+let pakoInflaterSource;
+/**
+* Loads Pako's official inflate-only browser distribution.
+*
+* The source is cached because every single-HTML variant uses the same immutable
+* dependency file. Keeping the promise also shares an in-progress read when
+* several variants are prepared concurrently.
+*/
+function loadPakoInflater() {
+	pakoInflaterSource ??= readFile(PAKO_INFLATER_PATH, "utf8");
+	return pakoInflaterSource;
+}
+//#endregion
+//#region src/preparation/shared/inline-pako-inflater.ts
+/**
+* Embeds Pako's official inflate-only distribution before the first compressed entry.
+*
+* The original minified source is preserved, including its license banner. The
+* caller owns the one-time decision so multiple module candidates share one inflater.
+*/
+async function inlinePakoInflater(beforeEntry) {
+	const source = await loadPakoInflater();
+	const script = beforeEntry.element.clone();
+	script.removeAttr("src");
+	script.removeAttr("type");
+	script.text(source);
+	beforeEntry.element.before(script);
+}
+//#endregion
+//#region src/preparation/shared/single-html.ts
+/**
+* Produces one standalone HTML document from an existing runnable build.
+*
+* Local stylesheets and the validator-visible host and config entries are embedded
+* directly. Assets and application become ordered payloads when compression is
+* useful: qualifying Deflate results use Base64, while the other entry remains plain
+* source. If neither qualifies, both remain ordinary inline modules. The final
+* document is validated against the network's size and external-resource policy.
+*/
+async function prepareSingleHtmlExport(context, options) {
+	const files = await collectBuildFiles(context.buildDirectory);
+	const document = loadHtmlBuildDocument(files, context.variant.id);
+	const resources = resolveHtmlBuildResources(document, files, context.variant.id);
+	await inlineStylesheets(document, resources.stylesheets);
+	const [host, config, assets, application] = await Promise.all([
+		prepareModuleEntrySource(resources.entries.host),
+		prepareModuleEntrySource(resources.entries.config),
+		prepareModuleEntrySource(resources.entries.assets),
+		prepareModuleEntrySource(resources.entries.application)
+	]);
+	options.validateJavaScript?.([
+		host,
+		config,
+		assets,
+		application
+	]);
+	inlinePreparedModuleEntry(resources.entries.host, host);
+	inlinePreparedModuleEntry(resources.entries.config, config);
+	const assetsModule = createJavaScriptCompressionCandidate(assets);
+	const applicationModule = createJavaScriptCompressionCandidate(application);
+	if (assetsModule.compressedPayload !== void 0 || applicationModule.compressedPayload !== void 0) {
+		await inlinePakoInflater(resources.entries.assets);
+		await inlineCompressedModules({
+			application: {
+				candidate: applicationModule,
+				resource: resources.entries.application
+			},
+			assets: {
+				candidate: assetsModule,
+				resource: resources.entries.assets
+			}
+		});
+	} else {
+		inlinePreparedModuleEntry(resources.entries.assets, assetsModule.source);
+		inlinePreparedModuleEntry(resources.entries.application, applicationModule.source);
+	}
+	const source = serializeHtmlDocument(document);
+	await validateSingleHtmlExport(document, source, options);
+	return source;
+}
+//#endregion
+//#region src/preparation/networks/applovin.ts
+/** Produces one upload-ready AppLovin document from an existing variant build. */
+function prepareAppLovinExport(context) {
+	return prepareSingleHtmlExport(context, {
+		maxFileSizeBytes: MAX_EXPORT_SIZE_BYTES,
+		networkName: "AppLovin"
+	});
+}
+//#endregion
+//#region src/validation/networks/google.ts
+const EXIT_API_URL = "https://tpc.googlesyndication.com/pagead/gadgets/html5/api/exitapi.js";
+const ORIENTATIONS = /* @__PURE__ */ new Set([
+	"landscape",
+	"portrait",
+	"portrait,landscape"
+]);
+const SUPPORTED_ARCHIVE_PATH = /^[A-Za-z\d._/-]+$/u;
+/** Enforces every Google rule that can be proven from prepared archive files. */
+function validateGoogleFiles(files, variantId) {
+	const html = requirePlayableHtml(files, variantId);
+	validateFileCount(files);
+	validateArchivePaths$1(files);
+	validateDocument$1(new TextDecoder().decode(html.data), files, variantId);
+	validateExitCall(files);
+}
+/** Enforces Google's documented maximum compressed archive size. */
+function validateGoogleArchive(archive) {
+	if (isWithinExportSizeLimit(archive.byteLength, "google")) return;
+	const formattedSize = archive.byteLength.toLocaleString("en-US");
+	throw new Error(`Google archive exceeds its 5 MB limit: ${formattedSize} bytes.`);
+}
+/** Enforces Google's documented maximum number of files inside the ZIP. */
+function validateFileCount(files) {
+	if (files.length > 512) throw new Error(`Google archive contains ${files.length} files; the maximum is 512.`);
+}
+/** Rejects archive paths containing characters unsupported by Google Ads. */
+function validateArchivePaths$1(files) {
+	const invalidPaths = files.map(({ path }) => path).filter((archivePath) => !SUPPORTED_ARCHIVE_PATH.test(archivePath));
+	if (invalidPaths.length > 0) throw new Error(`Google archive contains unsupported paths: ${invalidPaths.join(", ")}.`);
+}
+/** Validates Google's required document structure, metadata, and resource policy. */
+function validateDocument$1(source, files, variantId) {
+	const document = load(source);
+	validateBuildEntryOrder(document, variantId);
+	if (!source.trimStart().toLowerCase().startsWith("<!doctype html>")) throw new Error("Google entry document must begin with <!DOCTYPE html>.");
+	if (document("html").length !== 1 || document("head").length !== 1 || document("body").length !== 1) throw new Error("Google entry document must contain one html, head, and body element.");
+	if (document("head > meta[charset]").attr("charset")?.toLowerCase() !== "utf-8") throw new Error("Google entry document must declare UTF-8 encoding.");
+	const orientation = document("head > meta[name=\"ad.orientation\"]").attr("content");
+	if (orientation === void 0 || !ORIENTATIONS.has(orientation)) throw new Error("Google entry document has no valid ad.orientation metadata.");
+	if (document(`head > script[src="${EXIT_API_URL}"]`).length !== 1) throw new Error("Google entry document must load the official Exit API exactly once.");
+	validateResourceReferences(document, files);
+}
+/** Allows the official Exit API and requires every other resource to live in the ZIP. */
+function validateResourceReferences(document, files) {
+	const archivePaths = new Set(files.map(({ path }) => path));
+	const unavailableResources = collectUnavailableResourceReferences(document, (reference) => reference === EXIT_API_URL || isAvailableArchiveResourceReference(reference, archivePaths));
+	if (unavailableResources.length > 0) throw new Error(`Google archive contains unavailable resources: ${unavailableResources.join(", ")}.`);
+}
+/** Ensures the bundled CTA path invokes Google's network-owned destination API. */
+function validateExitCall(files) {
+	const decoder = new TextDecoder();
+	if (!files.filter(({ path }) => path.endsWith(".js")).some(({ data }) => decoder.decode(data).includes("ExitApi.exit()"))) throw new Error("Google archive does not invoke ExitApi.exit().");
+}
+//#endregion
+//#region src/preparation/shared/create-zip-archive.ts
+/** Compresses prepared export files at the highest supported compression level. */
+function createZipArchive(files) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		const archive = new Zip((error, chunk, final) => {
+			if (error !== null) {
+				reject(error);
+				return;
+			}
+			chunks.push(chunk);
+			if (final) resolve(Buffer.concat(chunks));
+		});
+		for (const file of files) {
+			const archiveFile = new ZipDeflate(file.path, { level: 9 });
+			archive.add(archiveFile);
+			archiveFile.push(file.data, true);
+		}
+		archive.end();
+	});
+}
+//#endregion
+//#region src/preparation/networks/google.ts
+/** Packages one existing Google build as an upload-ready HTML5 ZIP. */
+async function prepareGoogleExport(context) {
+	const files = await collectBuildFiles(context.buildDirectory);
+	validateGoogleFiles(files, context.variant.id);
+	await validateArchiveStylesheets(files);
+	const archive = await createZipArchive(files);
+	validateGoogleArchive(archive);
+	return archive;
+}
+//#endregion
+//#region src/validation/networks/liftoff.ts
+const ASCII_ARCHIVE_PATH = /^[\x20-\x7e]+$/u;
+/** Enforces Liftoff's HTML size, archive path, and local-resource requirements. */
+function validateLiftoffFiles(files, variantId) {
+	const html = requirePlayableHtml(files, variantId);
+	validateHtmlSize(html);
+	validateArchivePaths(files);
+	validateDocument(new TextDecoder().decode(html.data), files, variantId);
+}
+/** Enforces Liftoff's documented maximum entry-document size. */
+function validateHtmlSize(html) {
+	if (!isWithinExportSizeLimit(html.data.byteLength, "liftoff")) {
+		const formattedSize = html.data.byteLength.toLocaleString("en-US");
+		throw new Error(`Liftoff HTML exceeds its 5 MB limit: ${formattedSize} bytes.`);
+	}
+}
+/** Rejects filenames that Liftoff's case-sensitive CDN cannot address reliably. */
+function validateArchivePaths(files) {
+	const invalidPaths = files.map(({ path }) => path).filter((archivePath) => !ASCII_ARCHIVE_PATH.test(archivePath));
+	if (invalidPaths.length > 0) throw new Error(`Liftoff export contains non-ASCII filenames: ${invalidPaths.join(", ")}.`);
+}
+/** Enforces Liftoff's supported document shape and local-only resource policy. */
+function validateDocument(source, files, variantId) {
+	const document = load(source);
+	validateBuildEntryOrder(document, variantId);
+	if (document("iframe").length > 0) throw new Error("Liftoff export must not contain iframe elements.");
+	const archivePaths = new Set(files.map(({ path }) => path));
+	const unavailableResources = collectUnavailableResourceReferences(document, (reference) => isAvailableArchiveResourceReference(reference, archivePaths));
+	if (unavailableResources.length > 0) throw new Error(`Liftoff export contains unavailable resources: ${unavailableResources.join(", ")}.`);
+}
+//#endregion
+//#region src/preparation/networks/liftoff.ts
+/** Packages one existing Liftoff build as an upload-ready progressive-loading ZIP. */
+async function prepareLiftoffExport(context) {
+	const files = await collectBuildFiles(context.buildDirectory);
+	validateLiftoffFiles(files, context.variant.id);
+	await validateArchiveStylesheets(files);
+	return createZipArchive(files);
+}
+//#endregion
+//#region src/preparation/networks/meta.ts
+/** Produces one self-contained HTML document accepted by Meta playable ads. */
+function prepareMetaExport(context) {
+	return prepareSingleHtmlExport(context, {
+		maxFileSizeBytes: MAX_EXPORT_SIZE_BYTES,
+		networkName: "Meta"
+	});
+}
+//#endregion
+//#region src/validation/networks/mintegral.ts
+/** Ensures every resource requested by the prepared HTML is contained in the ZIP. */
+function validateMintegralFiles(source, files) {
+	const document = load(source);
+	const archivePaths = new Set(files.map(({ path }) => path));
+	const unavailableResources = collectUnavailableResourceReferences(document, (reference) => isAvailableArchiveResourceReference(reference, archivePaths));
+	if (unavailableResources.length > 0) throw new Error(`Mintegral export contains resources outside its ZIP: ${unavailableResources.join(", ")}.`);
+}
+/** Enforces Mintegral's maximum compressed delivery size. */
+function validateMintegralArchive(archive) {
+	if (isWithinExportSizeLimit(archive.byteLength, "mintegral")) return;
+	const formattedSize = archive.byteLength.toLocaleString("en-US");
+	throw new Error(`Mintegral export exceeds the 5 MB limit: ${formattedSize} bytes.`);
+}
+//#endregion
+//#region src/preparation/networks/mintegral.ts
+/** Packages one existing Mintegral build as an upload-ready ZIP archive. */
+async function prepareMintegralExport(context) {
+	const files = await convertMintegralBuild(context, await collectBuildFiles(context.buildDirectory));
+	const html = requirePlayableHtml(files, context.variant.id);
+	validateMintegralFiles(new TextDecoder().decode(html.data), files);
+	await validateArchiveStylesheets(files);
+	const archive = await createZipArchive(files);
+	validateMintegralArchive(archive);
+	return archive;
+}
+/**
+* Converts Replayable's four ESM entries into Mintegral's local classic-script form.
+*
+* The async wrapper preserves authored top-level `await`, while Terser verifies that
+* no imports or exports remain and safely escapes text embedded in a script context.
+*/
+async function convertMintegralBuild(context, files) {
+	const document = loadHtmlBuildDocument(files, context.variant.id);
+	const resources = resolveHtmlBuildResources(document, files, context.variant.id);
+	await inlineStylesheets(document, resources.stylesheets);
+	const classicEntries = [
+		await prepareClassicScriptEntry(resources.entries.host),
+		await prepareClassicScriptEntry(resources.entries.config),
+		await prepareClassicScriptEntry(resources.entries.assets),
+		await prepareClassicScriptEntry(resources.entries.application)
+	];
+	const htmlData = new TextEncoder().encode(serializeHtmlDocument(document));
+	const filesByPath = new Map(files.map((file) => [file.path, file]));
+	for (const stylesheet of resources.stylesheets) filesByPath.delete(stylesheet.file.path);
+	filesByPath.set(PLAYABLE_HTML_FILE, {
+		path: PLAYABLE_HTML_FILE,
+		data: htmlData
+	});
+	for (const classicEntry of classicEntries) filesByPath.set(classicEntry.path, classicEntry);
+	return [...filesByPath.values()];
+}
+//#endregion
+//#region src/validation/browser-redirects.ts
+const BROWSER_OBJECTS = /* @__PURE__ */ new Set([
+	"window",
+	"self",
+	"globalThis",
+	"document"
+]);
+/**
+* Checks direct browser navigation without mistaking shader .location properties,
+* comments, or strings for executable redirects. Each module is parsed separately:
+* independent build entries may legitimately reuse the same top-level bindings.
+* This is a static direct-API check, not analysis of aliases or dynamically built code.
+*/
+function containsBrowserRedirect(source) {
+	const program = parse(source, {
+		ecmaVersion: "latest",
+		sourceType: "module"
+	});
+	let redirects = false;
+	simple(program, {
+		AssignmentExpression(node) {
+			const path = browserPath(node.left);
+			redirects ||= path === "location" || path === "location.href";
+		},
+		CallExpression(node) {
+			const path = browserPath(node.callee);
+			redirects ||= path === "location.assign" || path === "location.replace" || path === "open";
+		}
+	});
+	return redirects;
+}
+/** Removes only recognized browser roots; arbitrary object properties do not match. */
+function browserPath(node) {
+	const path = memberPath(node);
+	if (path === void 0) return;
+	const [root, ...properties] = path;
+	if (root === "document" && properties[0] !== "location") return;
+	if (root !== void 0 && BROWSER_OBJECTS.has(root)) return properties.join(".");
+	return root === "location" ? path.join(".") : void 0;
+}
+/** Resolves literal member access, including window['location'] and optional chains. */
+function memberPath(node) {
+	if (node.type === "Identifier") return [node.name];
+	if (node.type === "ChainExpression") return memberPath(node.expression);
+	if (node.type !== "MemberExpression") return;
+	const object = memberPath(node.object);
+	const property = node.property;
+	const name = !node.computed && property.type === "Identifier" ? property.name : property.type === "Literal" && typeof property.value === "string" ? property.value : void 0;
+	return object !== void 0 && name !== void 0 ? [...object, name] : void 0;
+}
+//#endregion
+//#region src/validation/networks/moloco.ts
+const CTA_CALL = "FbPlayableAd.onCTAClick()";
+/** Requires the responsive portrait-and-landscape layout documented by Moloco. */
+function validateMolocoVariant(context) {
+	const { landscape, portrait } = context.variant.screen.orientations;
+	if (!landscape.enabled || !portrait.enabled) throw new Error("Moloco playables must support both portrait and landscape orientations.");
+}
+/** Rejects APIs and redirect behavior explicitly prohibited by Moloco. */
+function validateMolocoSource(source) {
+	if (!isWithinExportSizeLimit(Buffer.byteLength(source), "moloco")) throw new Error("Moloco export must be smaller than 5 MB.");
+	if (source.toLowerCase().includes("mraid.js")) throw new Error("Moloco export must not contain mraid.js.");
+	if (!source.includes(CTA_CALL)) throw new Error(`Moloco export must invoke ${CTA_CALL}.`);
+}
+/** Checks readable code independently of the final compressed document size. */
+function validateMolocoJavaScript(sources) {
+	const source = sources.join("\n");
+	if (source.includes("XMLHttpRequest")) throw new Error("Moloco export contains XMLHttpRequest. Disable audio or remove the dependency that provides it.");
+	if (source.toLowerCase().includes("mraid.js")) throw new Error("Moloco export must not contain mraid.js.");
+	if (!source.includes(CTA_CALL)) throw new Error(`Moloco export must invoke ${CTA_CALL}.`);
+	if (sources.some(containsBrowserRedirect)) throw new Error("Moloco export contains a direct JavaScript redirect.");
+}
+//#endregion
+//#region src/preparation/networks/moloco.ts
+/** Produces one self-contained HTML document accepted by Moloco playable ads. */
+async function prepareMolocoExport(context) {
+	validateMolocoVariant(context);
+	const source = await prepareSingleHtmlExport(context, {
+		maxFileSizeBytes: MAX_EXPORT_SIZE_BYTES,
+		networkName: "Moloco",
+		validateJavaScript: validateMolocoJavaScript
+	});
+	validateMolocoSource(source);
+	return source;
+}
+//#endregion
+//#region src/preparation/networks/preview.ts
+/** Produces a portable self-contained document for local review and sharing. */
+function preparePreviewExport(context) {
+	return prepareSingleHtmlExport(context, {
+		maxFileSizeBytes: MAX_EXPORT_SIZE_BYTES,
+		networkName: "Preview"
+	});
+}
+//#endregion
+//#region src/preparation/networks/unity.ts
+const UNITY_MRAID_REFERENCE = "mraid.js";
+/** Produces one upload-ready Unity document while preserving its host-injected MRAID bootstrap. */
+function prepareUnityExport(context) {
+	return prepareSingleHtmlExport(context, {
+		maxFileSizeBytes: MAX_EXPORT_SIZE_BYTES,
+		networkName: "Unity",
+		preservedResourceReferences: [UNITY_MRAID_REFERENCE]
+	});
+}
+//#endregion
+//#region src/preparation/prepare-export-project.ts
+/** Prepares every network artifact in memory without changing existing exports. */
+function prepareExportProject(project) {
+	return Promise.all(project.variants.map(prepareExportVariant));
+}
+/** Prepares one resolved variant and keeps its destination beside the content. */
+async function prepareExportVariant(context) {
+	return {
+		content: await prepareExportContent(context),
+		outputFile: context.outputFile,
+		variantId: context.variant.id
+	};
+}
+/** Applies the delivery rules owned by the resolved variant's network. */
+function prepareExportContent(context) {
+	switch (context.variant.network) {
+		case "applovin": return prepareAppLovinExport(context);
+		case "google": return prepareGoogleExport(context);
+		case "liftoff": return prepareLiftoffExport(context);
+		case "meta": return prepareMetaExport(context);
+		case "mintegral": return prepareMintegralExport(context);
+		case "moloco": return prepareMolocoExport(context);
+		case "preview": return preparePreviewExport(context);
+		case "unity": return prepareUnityExport(context);
+		default: throw new Error(`Unsupported export network: ${String(context.variant.network)}.`);
+	}
+}
+//#endregion
+//#region src/resolution/resolve-export-directories.ts
+const DEFAULT_OUTPUT_DIRECTORY = "exports";
+/**
+* Resolves and validates the two generated roots used by export.
+*
+* Both directories must remain inside the project, and neither may contain the
+* other. This prevents the emission cleanup from deleting source builds. For
+* example, "dist" and "exports" are valid siblings, while "dist/exports" is not.
+*/
+async function resolveExportDirectories(projectRoot, buildOutputPath, exportOutputPath = DEFAULT_OUTPUT_DIRECTORY) {
+	const canonicalProjectRoot = await realpath(projectRoot);
+	const directories = {
+		buildOutput: await resolveGeneratedDirectory(canonicalProjectRoot, buildOutputPath),
+		exportOutput: await resolveGeneratedDirectory(canonicalProjectRoot, exportOutputPath)
+	};
+	assertDirectoriesDoNotOverlap(directories);
+	return directories;
+}
+/** Resolves one generated root and rejects the project root or paths outside it. */
+async function resolveGeneratedDirectory(projectRoot, configuredPath) {
+	const directory = await resolveCanonicalPath(resolve(projectRoot, configuredPath));
+	const projectRelativePath = relative(projectRoot, directory);
+	const escapesProject = projectRelativePath === ".." || projectRelativePath.startsWith(`..${sep}`) || isAbsolute(projectRelativePath);
+	if (projectRelativePath === "" || escapesProject) throw new Error(`Generated directory must be inside the project root: ${configuredPath}.`);
+	return directory;
+}
+/** Prevents export cleanup from removing builds or writing artifacts inside them. */
+function assertDirectoriesDoNotOverlap(directories) {
+	if (containsDirectory(directories.buildOutput, directories.exportOutput) || containsDirectory(directories.exportOutput, directories.buildOutput)) throw new Error("The build and export directories must not overlap.");
+}
+/**
+* Reports whether "parent" contains "child", including equality.
+*
+* For example, "/project/dist" contains "/project/dist/google", but it does not
+* contain the sibling "/project/exports".
+*/
+function containsDirectory(parent, child) {
+	const childPath = relative(parent, child);
+	return childPath === "" || childPath !== ".." && !childPath.startsWith(`..${sep}`) && !isAbsolute(childPath);
+}
+//#endregion
+//#region src/resolution/resolve-export-variant.ts
+/**
+* Resolves the existing build and future artifact paths for one variant.
+*
+* For example, the build "dist/default/google/en/index.html" becomes the
+* delivery artifact "exports/google_default_en.zip".
+* This function verifies the build but does not create the export directory.
+*/
+async function resolveExportVariant(directories, variant) {
+	const buildDirectory = join(directories.buildOutput, variant.id);
+	const htmlFile = join(buildDirectory, PLAYABLE_HTML_FILE);
+	await assertBuiltHtmlExists(variant.id, htmlFile);
+	return {
+		buildDirectory,
+		outputFile: join(directories.exportOutput, resolveExportFileName(variant)),
+		variant
+	};
+}
+/**
+* Selects the upload artifact name required by the destination network.
+*
+* Every name identifies its network, version, and language, such as
+* "applovin_default_en.html" or "google_default_en.zip".
+*/
+function resolveExportFileName(variant) {
+	const artifactName = [
+		variant.network,
+		variant.version,
+		variant.localization.language
+	].map(normalizeArtifactNameSegment).join("_");
+	switch (variant.network) {
+		case "applovin":
+		case "meta":
+		case "moloco":
+		case "preview":
+		case "unity": return `${artifactName}.html`;
+		case "google":
+		case "liftoff":
+		case "mintegral": return `${artifactName}.zip`;
+		default: throw new Error(`Unsupported export network: ${String(variant.network)}.`);
+	}
+}
+/** Produces a portable artifact-name segment containing letters, digits, and underscores. */
+function normalizeArtifactNameSegment(value) {
+	const segment = value.toLowerCase().replace(/[^a-z\d]+/gu, "_").replace(/^_+|_+$/gu, "");
+	return segment === "" ? "playable" : segment;
+}
+/** Verifies that export consumes a completed build rather than rebuilding implicitly. */
+async function assertBuiltHtmlExists(variantId, htmlFile) {
+	try {
+		if ((await stat(htmlFile)).isFile()) return;
+	} catch (error) {
+		if (isMissingPathError(error)) throw new Error(`Missing build for ${variantId}. Run replayable build before replayable export.`, { cause: error });
+		throw new Error(`Unable to inspect build for ${variantId}: ${htmlFile}.`, { cause: error });
+	}
+	throw new Error(`Build output for ${variantId} is not an HTML file: ${htmlFile}.`);
+}
+//#endregion
+//#region src/resolution/resolve-export-project.ts
+/**
+* Resolves every existing variant build and its future export destination.
+*
+* This read-only stage parses the project configuration, validates the build and
+* export roots, verifies every expected build, and returns paths for preparation
+* and emission. It neither rebuilds variants nor changes existing exports.
+*/
+async function resolveExportProject(input, options) {
+	const config = defineConfig(input);
+	const directories = await resolveExportDirectories(resolve(options.projectRoot), config.build.outDir, options.outputDirectory);
+	const variants = await Promise.all(createVariants(config).map((variant) => resolveExportVariant(directories, variant)));
+	assertUniqueOutputFiles(variants);
+	return {
+		outputDirectory: directories.exportOutput,
+		variants
+	};
+}
+/** Rejects variants whose normalized names would overwrite the same delivery artifact. */
+function assertUniqueOutputFiles(variants) {
+	const variantByOutputFile = /* @__PURE__ */ new Map();
+	for (const variant of variants) {
+		const existingVariantId = variantByOutputFile.get(variant.outputFile);
+		if (existingVariantId !== void 0) throw new Error(`Export variants ${existingVariantId} and ${variant.variant.id} resolve to the same output file: ${variant.outputFile}.`);
+		variantByOutputFile.set(variant.outputFile, variant.variant.id);
+	}
+}
+//#endregion
+//#region src/pipeline/export-project.ts
+/**
+* Produces every upload-ready artifact from an existing Replayable project build.
+*
+* Resolution verifies the builds and assigns destinations. Preparation creates
+* every artifact in memory. Emission replaces the previous export directory only
+* after all preparation succeeds, preserving the last successful export on error.
+*/
+async function exportProject(config, options) {
+	const project = await resolveExportProject(config, options);
+	return emitExportProject(project, await prepareExportProject(project));
+}
+//#endregion
+export { exportProject };
+
+//# sourceMappingURL=index.mjs.map