@replayablejs/build 0.1.0-alpha.0

package/dist/index.mjs

@@ -0,0 +1,1063 @@
+import { buildAssets } from "@replayablejs/assets";
+import { createVariants, defineConfig } from "@replayablejs/config";
+import { dirname, extname, isAbsolute, join, parse, relative, resolve, sep } from "node:path";
+import { build, createServer, mergeConfig, normalizePath } from "vite";
+import { fileURLToPath } from "node:url";
+import { styleText } from "node:util";
+import { toHtml } from "hast-util-to-html";
+import { h } from "hastscript";
+import { REPLAYABLE_CONTAINER_ID, REPLAYABLE_LOADING_INDICATOR_ID, REPLAYABLE_ROOT_ID } from "@replayablejs/runtime/shell";
+import { rm, writeFile } from "node:fs/promises";
+import { existsSync, lstatSync, readFileSync, realpathSync, statSync } from "node:fs";
+//#region src/networks/google.ts
+const EXIT_API_URL = "https://tpc.googlesyndication.com/pagead/gadgets/html5/api/exitapi.js";
+/** Resolves the production document elements required by Google App Campaigns. */
+function resolveGoogleHtmlHead(variant) {
+	return {
+		metaTags: [{
+			name: "ad.orientation",
+			content: resolveOrientation(variant.screen.orientations)
+		}],
+		scripts: [{ src: EXIT_API_URL }]
+	};
+}
+/** Converts Replayable's enabled layouts into Google's orientation-tag value. */
+function resolveOrientation(orientations) {
+	const { landscape, portrait } = orientations;
+	if (landscape.enabled && portrait.enabled) return "portrait,landscape";
+	return portrait.enabled ? "portrait" : "landscape";
+}
+//#endregion
+//#region src/networks/unity.ts
+const unityHtmlHead = {
+	metaTags: [],
+	scripts: [{ src: "mraid.js" }]
+};
+/** Adds Unity's required MRAID SDK bootstrap before authored runtime code. */
+function resolveUnityHtmlHead() {
+	return unityHtmlHead;
+}
+//#endregion
+//#region src/networks/network-profiles.ts
+const fullScreenEndCard = {
+	animation: "continuous",
+	interaction: "full-screen"
+};
+const ctaOnlyEndCard = {
+	animation: "finite",
+	interaction: "cta-only"
+};
+const previewControls = { persistentCta: true };
+const hiddenControls = { persistentCta: false };
+const liftoffControls = { persistentCta: true };
+const noCompileTimeDefinitions = {};
+const emptyHtmlHead = {
+	metaTags: [],
+	scripts: []
+};
+const networkProfiles = {
+	preview: {
+		assetMode: "inline",
+		applicationMode: "single-module",
+		compileTimeDefinitions: noCompileTimeDefinitions,
+		completionDurationStart: "ready",
+		controls: previewControls,
+		endCard: fullScreenEndCard,
+		loadingIndicator: "replayable",
+		resolveHtmlHead: resolveEmptyHtmlHead,
+		runtime: "browser"
+	},
+	applovin: {
+		assetMode: "inline",
+		applicationMode: "single-module",
+		compileTimeDefinitions: noCompileTimeDefinitions,
+		completionDurationStart: "interaction",
+		controls: hiddenControls,
+		endCard: fullScreenEndCard,
+		loadingIndicator: "replayable",
+		resolveHtmlHead: resolveEmptyHtmlHead,
+		runtime: "applovin"
+	},
+	meta: {
+		assetMode: "inline",
+		applicationMode: "single-module",
+		compileTimeDefinitions: noCompileTimeDefinitions,
+		completionDurationStart: "ready",
+		controls: hiddenControls,
+		endCard: fullScreenEndCard,
+		loadingIndicator: "replayable",
+		resolveHtmlHead: resolveEmptyHtmlHead,
+		runtime: "meta"
+	},
+	google: {
+		assetMode: "resource",
+		applicationMode: "module-graph",
+		compileTimeDefinitions: noCompileTimeDefinitions,
+		completionDurationStart: "ready",
+		controls: hiddenControls,
+		endCard: ctaOnlyEndCard,
+		loadingIndicator: "replayable",
+		resolveHtmlHead: resolveGoogleHtmlHead,
+		runtime: "google"
+	},
+	liftoff: {
+		assetMode: "resource",
+		applicationMode: "module-graph",
+		compileTimeDefinitions: noCompileTimeDefinitions,
+		completionDurationStart: "ready",
+		controls: liftoffControls,
+		endCard: fullScreenEndCard,
+		loadingIndicator: "replayable",
+		resolveHtmlHead: resolveEmptyHtmlHead,
+		runtime: "liftoff"
+	},
+	mintegral: {
+		assetMode: "inline",
+		applicationMode: "single-module",
+		compileTimeDefinitions: noCompileTimeDefinitions,
+		completionDurationStart: "ready",
+		controls: hiddenControls,
+		endCard: fullScreenEndCard,
+		loadingIndicator: "host",
+		resolveHtmlHead: resolveEmptyHtmlHead,
+		runtime: "mintegral"
+	},
+	moloco: {
+		assetMode: "inline",
+		applicationMode: "single-module",
+		compileTimeDefinitions: { XMLHttpRequest: "undefined" },
+		completionDurationStart: "ready",
+		controls: hiddenControls,
+		endCard: fullScreenEndCard,
+		loadingIndicator: "replayable",
+		resolveHtmlHead: resolveEmptyHtmlHead,
+		runtime: "moloco"
+	},
+	unity: {
+		assetMode: "inline",
+		applicationMode: "single-module",
+		compileTimeDefinitions: noCompileTimeDefinitions,
+		completionDurationStart: "ready",
+		controls: hiddenControls,
+		endCard: fullScreenEndCard,
+		loadingIndicator: "replayable",
+		resolveHtmlHead: resolveUnityHtmlHead,
+		runtime: "unity"
+	}
+};
+/** Resolves the asset, document, and runtime policy owned by one variant's network. */
+function resolvePlayableProfile(variant) {
+	const profile = networkProfiles[variant.network];
+	return {
+		assetMode: profile.assetMode,
+		applicationMode: profile.applicationMode,
+		compileTimeDefinitions: profile.compileTimeDefinitions,
+		completionDurationStart: profile.completionDurationStart,
+		controls: variant.network === "preview" ? variant.controls : profile.controls,
+		endCard: profile.endCard,
+		htmlHead: profile.resolveHtmlHead(variant),
+		loadingIndicator: profile.loadingIndicator,
+		runtime: profile.runtime
+	};
+}
+/** Returns no document additions for networks without production head requirements. */
+function resolveEmptyHtmlHead(_variant) {
+	return emptyHtmlHead;
+}
+//#endregion
+//#region src/runtime/resolve-assets-module.ts
+/** Resolves the generated assets module selected for one playable variant. */
+function resolveAssetsModule(projectRoot, variant) {
+	return normalizePath(resolve(projectRoot, variant.assets.emit.assets));
+}
+//#endregion
+//#region src/vite/create-playable-vite-context.ts
+/** Resolves every shared input needed before configuring Vite. */
+function createPlayableViteContext(options) {
+	return {
+		entryFile: resolve(options.projectRoot, options.variant.entry),
+		assetsModule: resolveAssetsModule(options.projectRoot, options.variant),
+		profile: resolvePlayableProfile(options.variant),
+		projectRoot: options.projectRoot,
+		variant: options.variant
+	};
+}
+//#endregion
+//#region src/pipeline/create-development-context.ts
+const DEFAULT_HOST = "0.0.0.0";
+const DEFAULT_PORT = 5173;
+/** Resolves every path, profile, and server option needed by local development. */
+function createDevelopmentContext(variant, options) {
+	const viteContext = createPlayableViteContext({
+		projectRoot: resolve(options.projectRoot),
+		variant
+	});
+	return {
+		...viteContext,
+		profile: {
+			...viteContext.profile,
+			assetMode: "resource"
+		},
+		host: options.host ?? DEFAULT_HOST,
+		open: options.open ?? false,
+		port: options.port ?? DEFAULT_PORT
+	};
+}
+//#endregion
+//#region src/vite/create-base-vite-config.ts
+/** Creates environment-independent Vite configuration for one Replayable project. */
+function createBaseViteConfig(projectRoot) {
+	return {
+		configFile: false,
+		envDir: false,
+		logLevel: "warn",
+		publicDir: false,
+		root: projectRoot
+	};
+}
+//#endregion
+//#region src/vite/create-development-vite-config.ts
+/** Combines the four production entry configurations into one HMR module graph. */
+function createDevelopmentViteConfig(options) {
+	const { application, assets, config, host } = options.entries;
+	const entryConfig = [
+		host,
+		config,
+		assets,
+		application
+	].reduce((current, entry) => mergeConfig(current, entry.viteConfig), {});
+	return mergeConfig(createBaseViteConfig(options.projectRoot), mergeConfig(entryConfig, { plugins: [...options.plugins ?? []] }));
+}
+//#endregion
+//#region src/runtime/resolve-build-runtime-module.ts
+const buildDirectory = dirname(fileURLToPath(import.meta.resolve("@replayablejs/build")));
+/** Resolves one private browser module emitted beside the build package entry. */
+function resolveBuildRuntimeModule(modulePath) {
+	return resolve(buildDirectory, "runtime", modulePath);
+}
+//#endregion
+//#region src/runtime/resolve-build-runtime-entry.ts
+/** Resolves one private browser entry emitted with the build package. */
+function resolveBuildRuntimeEntry(entry) {
+	return resolveBuildRuntimeModule(`entries/${entry}.mjs`);
+}
+//#endregion
+//#region src/runtime/resolve-devtools.ts
+const devtoolsDirectory = dirname(fileURLToPath(import.meta.resolve("@replayablejs/devtools")));
+/** Audio-disabled variants and production never load the sound control or its icons. */
+function resolveSoundControl(command, enabled) {
+	return resolve(devtoolsDirectory, "sound-control", command === "serve" && enabled ? "enabled.js" : "disabled.js");
+}
+/** Production selects a dependency-free stub, regardless of the project's preference. */
+function resolveEndCardTrigger(command, enabled) {
+	return resolve(devtoolsDirectory, "endcard-trigger", command === "serve" && enabled ? "enabled.js" : "disabled.js");
+}
+/** Selects stats before module loading; production never visits the enabled graph. */
+function resolveDevtoolsStats(command, stats) {
+	const enabled = command === "serve" && stats !== false && Object.values(stats).some((value) => value === true);
+	return resolve(devtoolsDirectory, "stats", enabled ? "enabled.js" : "disabled.js");
+}
+/** Context registration is unnecessary unless a WebGL metric is requested in development. */
+function resolveWebglStats(command, stats) {
+	const enabled = command === "serve" && stats !== false && (stats.drawCalls || stats.textureBinds || stats.programUses);
+	return resolve(devtoolsDirectory, "stats", "webgl", enabled ? "enabled.js" : "disabled.js");
+}
+//#endregion
+//#region src/runtime/resolve-runtime-audio.ts
+const runtimeDirectory$1 = dirname(fileURLToPath(import.meta.resolve("@replayablejs/runtime")));
+/** Returns the enabled or no-op audio module selected for one concrete variant. */
+function resolveRuntimeAudio(enabled) {
+	return resolve(runtimeDirectory$1, "audio", enabled ? "enabled.js" : "disabled.js");
+}
+//#endregion
+//#region src/vite/resolve-physical-id.ts
+/** Removes Vite query metadata and normalizes a module ID for comparison. */
+function resolvePhysicalId(id) {
+	return normalizePath(id).split("?")[0] ?? id;
+}
+//#endregion
+//#region src/vite/plugins/generated-assets-boundary.ts
+/** Prevents application code from importing the physical generated asset registry. */
+function createGeneratedAssetsBoundaryPlugin(options) {
+	const allowedImporter = options.allowedImporter === void 0 ? void 0 : resolvePhysicalId(options.allowedImporter);
+	const generatedAssetsModule = resolvePhysicalId(options.assetsModule);
+	return {
+		name: "replayable:generated-assets-boundary",
+		enforce: "pre",
+		async resolveId(source, importer) {
+			if (importer === void 0) return;
+			const resolved = await this.resolve(source, importer, { skipSelf: true });
+			if (resolved === null || resolvePhysicalId(resolved.id) !== generatedAssetsModule) return resolved;
+			if (allowedImporter !== void 0 && resolvePhysicalId(importer) === allowedImporter) return resolved;
+			throw new Error(["The generated assets module is internal to the Replayable build.", "Consume assets through playable.loader instead of importing the generated module directly."].join(" "));
+		}
+	};
+}
+//#endregion
+//#region src/vite/create-application-vite-config.ts
+/** Creates Vite configuration for authored application and runtime code only. */
+function createApplicationViteConfig(options, assetsEntry, command) {
+	return {
+		define: options.profile.compileTimeDefinitions,
+		plugins: [createGeneratedAssetsBoundaryPlugin({
+			allowedImporter: assetsEntry,
+			assetsModule: options.assetsModule
+		})],
+		resolve: { alias: {
+			"#adapter": resolveBuildRuntimeModule("bindings/adapter.mjs"),
+			"#assets": resolveBuildRuntimeModule("bindings/assets.mjs"),
+			"#audio": resolveRuntimeAudio(options.variant.audio),
+			"#definition": resolveBuildRuntimeModule("bindings/definition.mjs"),
+			"#stats": resolveDevtoolsStats(command, options.variant.devtools.stats),
+			"#endcard-trigger": resolveEndCardTrigger(command, options.variant.devtools.endCardTrigger),
+			"#sound-control": resolveSoundControl(command, options.variant.audio && options.variant.devtools.soundControl),
+			"#webgl-stats": resolveWebglStats(command, options.variant.devtools.stats)
+		} }
+	};
+}
+//#endregion
+//#region src/vite/plugins/generated-assets.ts
+const BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+	".avif",
+	".glb",
+	".gltf",
+	".jpeg",
+	".jpg",
+	".m4a",
+	".mp3",
+	".ogg",
+	".png",
+	".skel",
+	".wav",
+	".webp",
+	".woff",
+	".woff2"
+]);
+const JSON_EXTENSION = ".json";
+const TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+	".atlas",
+	".frag",
+	".glsl",
+	".vert"
+]);
+const INLINE_QUERY_BY_KIND = {
+	binary: "?url&inline",
+	json: void 0,
+	text: "?raw"
+};
+/**
+* Applies a profile's asset policy through Vite's native import queries.
+*
+* The generated assets module stays independent of Vite and contains ordinary
+* imports such as:
+*
+* ```ts
+* import image from './resources/logo.webp';
+* import shader from './resources/frag.glsl';
+* import locale from './resources/translations.json';
+* ```
+*
+* Before Vite resolves those imports, this plugin privately attaches the query
+* that describes the required runtime representation:
+*
+* | Imported file       | Inline mode   | Resource mode    |
+* | ------------------- | ------------- | ---------------- |
+* | Image/audio/font    | `?url&inline` | `?url&no-inline` |
+* | Binary SKEL         | `?url&inline` | `?url&no-inline` |
+* | GLSL/Spine atlas    | `?raw`        | `?url&no-inline` |
+* | JSON                | ordinary JSON | `?url&no-inline` |
+*
+* Only direct imports made by the generated assets module are rewritten.
+* Authored application imports and unrelated JSON or text files retain Vite's
+* normal behavior.
+*/
+function createGeneratedAssetsPlugin(options) {
+	const assetsModule = resolvePhysicalId(options.assetsModule);
+	return {
+		name: "replayable:generated-assets",
+		enforce: "pre",
+		async resolveId(source, importer) {
+			if (importer === void 0 || resolvePhysicalId(importer) !== assetsModule) return;
+			const importKind = classifyGeneratedImport(source);
+			if (importKind === void 0) return;
+			const query = resolveViteQuery(importKind, options.mode);
+			if (query === void 0) return;
+			return this.resolve(`${source}${query}`, importer, { skipSelf: true });
+		}
+	};
+}
+/** Classifies one physical import emitted by the generated assets module. */
+function classifyGeneratedImport(source) {
+	const extension = extname(resolvePhysicalId(source)).toLowerCase();
+	if (BINARY_EXTENSIONS.has(extension)) return "binary";
+	if (TEXT_EXTENSIONS.has(extension)) return "text";
+	return extension === JSON_EXTENSION ? "json" : void 0;
+}
+/** Selects the documented Vite query for one asset kind and delivery mode. */
+function resolveViteQuery(kind, mode) {
+	return mode === "resource" ? "?url&no-inline" : INLINE_QUERY_BY_KIND[kind];
+}
+//#endregion
+//#region src/vite/create-assets-vite-config.ts
+/** Creates Vite configuration for the generated assets registration only. */
+function createAssetsViteConfig(options) {
+	return {
+		resolve: { alias: { "#generated-assets": options.assetsModule } },
+		plugins: [createGeneratedAssetsPlugin({
+			assetsModule: options.assetsModule,
+			mode: options.profile.assetMode
+		})]
+	};
+}
+//#endregion
+//#region src/runtime/create-runtime-define.ts
+const RUNTIME_DEFINITION = "REPLAYABLE_RUNTIME_DEFINITION";
+/** Creates the platform-neutral value completed by the browser config entry. */
+function createRuntimeDefine(variant, profile) {
+	const definition = {
+		assetMode: profile.assetMode,
+		config: {
+			audio: variant.audio,
+			backgroundColor: variant.backgroundColor,
+			completion: createRuntimeCompletionConfig(variant, profile),
+			controls: { persistentCta: profile.controls.persistentCta },
+			devtools: variant.devtools,
+			endCard: profile.endCard,
+			id: variant.id,
+			localization: variant.localization,
+			network: variant.network,
+			params: variant.params,
+			screen: variant.screen,
+			store: variant.store,
+			version: variant.version
+		}
+	};
+	return { [RUNTIME_DEFINITION]: JSON.stringify(definition) };
+}
+/** Removes disabled timers while adding the network-owned duration start policy. */
+function createRuntimeCompletionConfig(variant, profile) {
+	const { duration, inactivity } = variant.completion;
+	return {
+		durationStart: profile.completionDurationStart,
+		...duration === void 0 ? {} : { duration },
+		...inactivity === void 0 ? {} : { inactivity }
+	};
+}
+//#endregion
+//#region src/vite/create-config-vite-config.ts
+/** Creates Vite configuration for the resolved runtime definition only. */
+function createConfigViteConfig(options) {
+	return { define: createRuntimeDefine(options.variant, options.profile) };
+}
+//#endregion
+//#region src/runtime/resolve-runtime-adapter.ts
+const runtimeDirectory = dirname(fileURLToPath(import.meta.resolve("@replayablejs/runtime")));
+/** Returns the private runtime adapter module selected by Replayable. */
+function resolveRuntimeAdapter(host) {
+	return resolve(runtimeDirectory, "adapters", `${host}.js`);
+}
+//#endregion
+//#region src/vite/create-host-vite-config.ts
+/** Creates Vite configuration for the profile-selected network host only. */
+function createHostViteConfig(options) {
+	return { resolve: { alias: { "#selected-adapter": resolveRuntimeAdapter(options.profile.runtime) } } };
+}
+//#endregion
+//#region src/vite/create-playable-entries.ts
+/**
+* Describes the four private module entries shared by development and production.
+*
+* Production builds each descriptor independently. Development merges their Vite
+* configuration into one live graph and serves the same inputs in execution order.
+*/
+function createPlayableEntries(context, command) {
+	const assetsEntry = resolveBuildRuntimeEntry("assets");
+	return {
+		host: {
+			input: resolveBuildRuntimeEntry("host"),
+			viteConfig: createHostViteConfig(context)
+		},
+		config: {
+			input: resolveBuildRuntimeEntry("config"),
+			viteConfig: createConfigViteConfig(context)
+		},
+		assets: {
+			input: assetsEntry,
+			viteConfig: createAssetsViteConfig(context)
+		},
+		application: {
+			input: context.entryFile,
+			viteConfig: createApplicationViteConfig(context, assetsEntry, command)
+		}
+	};
+}
+//#endregion
+//#region src/development/plugins/development-reporter.ts
+const UPDATE_LABELS = {
+	create: "Created",
+	delete: "Deleted",
+	update: "Updated"
+};
+const DUPLICATE_UPDATE_WINDOW = 100;
+/** Reports Vite file updates without exposing Vite as the public development interface. */
+function createDevelopmentReporterPlugin(projectRoot) {
+	const recentUpdates = /* @__PURE__ */ new Map();
+	return {
+		name: "replayable:development-reporter",
+		hotUpdate(options) {
+			if (this.environment.name !== "client") return;
+			const file = normalizePath(relative(projectRoot, options.file));
+			const startedAt = performance.now();
+			const previousUpdate = recentUpdates.get(file);
+			if (previousUpdate !== void 0 && startedAt - previousUpdate < DUPLICATE_UPDATE_WINDOW) return;
+			recentUpdates.set(file, startedAt);
+			setImmediate(() => {
+				const duration = Math.round(performance.now() - startedAt);
+				const label = styleText("green", UPDATE_LABELS[options.type].padEnd(9));
+				const formattedDuration = duration === 0 ? "<1ms" : `${duration}ms`;
+				const details = styleText("dim", `${file} in ${formattedDuration}`);
+				console.log(`${label} ${details}`);
+			});
+		}
+	};
+}
+//#endregion
+//#region src/html/playable-html.ts
+/** Canonical entry document produced by every Replayable build. */
+const PLAYABLE_HTML_FILE = "index.html";
+//#endregion
+//#region src/html/loading-indicator.scss?inline
+var loading_indicator_default = "#replayable-loading-indicator{z-index:1;pointer-events:none;place-items:center;display:grid;position:absolute;inset:0}#replayable-loading-indicator:after{content:\"\";border:.125rem solid #7f7f7f73;border-top-color:#fff;border-radius:50%;width:1.5rem;height:1.5rem;animation:.8s linear infinite replayable-loading-spin}@keyframes replayable-loading-spin{to{transform:rotate(1turn)}}@media (prefers-reduced-motion:reduce){#replayable-loading-indicator:after{animation:none}}\n";
+//#endregion
+//#region src/html/playable-shell.scss?inline
+var playable_shell_default = "html,body{overscroll-behavior:none;width:100%;height:100%;margin:0;overflow:hidden}body{background-color:inherit;position:fixed;inset:0}#replayable-root{background-color:inherit;-webkit-user-select:none;user-select:none;-webkit-touch-callout:none;-webkit-tap-highlight-color:transparent;touch-action:none;position:fixed;inset:0;overflow:hidden}#replayable-container{background-color:inherit;position:absolute;overflow:hidden}#replayable-root:before{content:\"\";visibility:hidden;pointer-events:none;padding:max(env(safe-area-inset-top,0px), clamp(36px, 5svh, 44px)) max(env(safe-area-inset-right,0px), 12px) max(env(safe-area-inset-bottom,0px), clamp(24px, 4svh, 36px)) max(env(safe-area-inset-left,0px), 12px);position:absolute}#replayable-root[data-orientation=landscape]:before{padding:max(env(safe-area-inset-top,0px), 12px) max(env(safe-area-inset-right,0px), clamp(48px, 7svw, 64px)) max(env(safe-area-inset-bottom,0px), clamp(20px, 4svh, 32px)) max(env(safe-area-inset-left,0px), clamp(48px, 7svw, 64px))}\n";
+//#endregion
+//#region src/html/playable-shell.ts
+/** Returns only the framework styles required by the active loading owner. */
+function resolvePlayableShellStyles(loadingIndicator) {
+	if (loadingIndicator === "host") return playable_shell_default;
+	return `${playable_shell_default}${loading_indicator_default}`;
+}
+/** Renders the framework mount points shared by DOM and canvas playables. */
+function renderPlayableShell(loadingIndicator) {
+	const children = [h("div", { id: REPLAYABLE_CONTAINER_ID })];
+	if (loadingIndicator === "replayable") children.unshift(h("div", {
+		id: REPLAYABLE_LOADING_INDICATOR_ID,
+		role: "status",
+		ariaLabel: "Loading"
+	}));
+	return h("div", { id: REPLAYABLE_ROOT_ID }, children);
+}
+//#endregion
+//#region src/html/render-playable-html.ts
+/** Renders the shared playable document used by development and production. */
+function renderPlayableHtml(variant, resources) {
+	const networkMetaTags = resources.head.metaTags.map(({ name, content }) => h("meta", {
+		name,
+		content
+	}));
+	const stylesheets = resources.stylesheets.map((stylesheet) => h("link", {
+		href: stylesheet,
+		rel: "stylesheet"
+	}));
+	const networkScripts = resources.head.scripts.map(({ src }) => h("script", { src }));
+	const initializationScripts = renderInitializationScripts(resources.initializers);
+	const shellStyles = resolvePlayableShellStyles(resources.loadingIndicator);
+	const document = h(null, [{ type: "doctype" }, h("html", {
+		lang: variant.localization.language,
+		style: { "background-color": variant.backgroundColor }
+	}, [h("head", [
+		h("meta", { charSet: "UTF-8" }),
+		h("meta", {
+			name: "viewport",
+			content: "width=device-width, initial-scale=1, minimum-scale=1, maximum-scale=1, user-scalable=no, viewport-fit=cover"
+		}),
+		...networkMetaTags,
+		h("title", variant.projectName),
+		h("style", shellStyles),
+		...stylesheets,
+		...networkScripts
+	]), h("body", [
+		renderPlayableShell(resources.loadingIndicator),
+		...initializationScripts,
+		h("script", {
+			"data-replayable-entry": "application",
+			src: resources.entry,
+			type: "module"
+		})
+	])])]);
+	return `${toHtml(document)}\n`;
+}
+/** Renders scope initialization in its required execution order. */
+function renderInitializationScripts(initializers) {
+	if (initializers === void 0) return [];
+	return [
+		h("script", {
+			"data-replayable-entry": "host",
+			src: initializers.host,
+			type: "module"
+		}),
+		h("script", {
+			"data-replayable-entry": "config",
+			src: initializers.config,
+			type: "module"
+		}),
+		h("script", {
+			"data-replayable-entry": "assets",
+			src: initializers.assets,
+			type: "module"
+		})
+	];
+}
+//#endregion
+//#region src/development/plugins/playable-html.ts
+/** Serves framework-owned HTML while leaving modules and HMR to Vite. */
+function createPlayableHtmlPlugin(variant, resources) {
+	return {
+		name: "replayable:html",
+		configureServer(server) {
+			server.middlewares.use(async (request, response, next) => {
+				if (!isHtmlRequest(request.url)) {
+					next();
+					return;
+				}
+				try {
+					const source = renderPlayableHtml(variant, resources);
+					const html = await server.transformIndexHtml(request.url ?? "/", source);
+					response.statusCode = 200;
+					response.setHeader("Content-Type", "text/html; charset=utf-8");
+					response.end(html);
+				} catch (error) {
+					next(error);
+				}
+			});
+		}
+	};
+}
+/** Matches only the development document, never module or asset requests. */
+function isHtmlRequest(requestUrl) {
+	if (requestUrl === void 0) return false;
+	const pathname = new URL(requestUrl, "http://replayable.local").pathname;
+	return pathname === "/" || pathname === `/index.html`;
+}
+//#endregion
+//#region src/development/create-development-server.ts
+/** Starts Vite for one resolved playable variant and its authored browser entry. */
+async function createDevelopmentServer(context) {
+	const entries = createPlayableEntries(context, "serve");
+	const viteConfig = createDevelopmentViteConfig({
+		entries,
+		projectRoot: context.projectRoot,
+		plugins: [createPlayableHtmlPlugin(context.variant, {
+			entry: toDevelopmentModuleUrl(entries.application.input),
+			initializers: {
+				assets: toDevelopmentModuleUrl(entries.assets.input),
+				config: toDevelopmentModuleUrl(entries.config.input),
+				host: toDevelopmentModuleUrl(entries.host.input)
+			},
+			head: context.profile.htmlHead,
+			loadingIndicator: context.profile.loadingIndicator,
+			stylesheets: []
+		}), createDevelopmentReporterPlugin(context.projectRoot)]
+	});
+	const server = await createServer({
+		...viteConfig,
+		appType: "custom",
+		server: {
+			host: context.host,
+			open: context.open,
+			port: context.port
+		}
+	});
+	await server.listen();
+	return server;
+}
+/** Converts an absolute private entry path into Vite's browser-facing filesystem URL. */
+function toDevelopmentModuleUrl(file) {
+	return `/@fs/${normalizePath(file)}`;
+}
+//#endregion
+//#region src/development/select-development-variant.ts
+/** Selects the preview variant that satisfies every explicit development choice. */
+function selectDevelopmentVariant(variants, selection) {
+	const variant = variants.find((candidate) => candidate.network === "preview" && (selection.version === void 0 || candidate.version === selection.version) && (selection.language === void 0 || candidate.localization.language === selection.language));
+	if (variant === void 0) throw new Error(`No configured playable variant matches ${describeSelection(selection)}.`);
+	return variant;
+}
+/** Produces a concise, actionable description for an invalid selection. */
+function describeSelection(selection) {
+	return [
+		`version=${selection.version ?? "*"}`,
+		"network=preview",
+		`language=${selection.language ?? "*"}`
+	].join(", ");
+}
+//#endregion
+//#region src/development/serve-preview.ts
+/** Builds one preview variant's assets and starts its local Vite server. */
+async function servePreview(config, options) {
+	const validatedConfig = defineConfig(config);
+	const context = createDevelopmentContext(selectDevelopmentVariant(createVariants(validatedConfig), options), options);
+	await buildAssets(context.variant.assets, context.projectRoot);
+	const server = await createDevelopmentServer(context);
+	const resolvedUrls = server.resolvedUrls;
+	return {
+		close: () => server.close(),
+		localUrls: resolvedUrls?.local ?? [],
+		networkUrls: resolvedUrls?.network ?? [],
+		variantId: context.variant.id
+	};
+}
+//#endregion
+//#region src/pipeline/resolve-output-directory.ts
+/** Resolves an output path while preventing project-wide recursive deletion. */
+function resolveOutputDirectory(projectRoot, configuredPath) {
+	const outputDirectory = resolve(projectRoot, configuredPath);
+	const projectRelativePath = relative(projectRoot, outputDirectory);
+	if (projectRelativePath === "" || isOutsideProject(projectRelativePath)) throw new Error("The build output must resolve to a directory inside the project root.");
+	const physicalRoot = realpathSync.native(projectRoot);
+	const physicalOutput = resolvePhysicalPath(outputDirectory);
+	const physicalRelativePath = relative(physicalRoot, physicalOutput);
+	if (physicalRelativePath === "" || isOutsideProject(physicalRelativePath)) throw new Error("The build output must resolve to a directory inside the project root.");
+	return outputDirectory;
+}
+/** Resolves symlinks in the nearest existing ancestor of a future output path. */
+function resolvePhysicalPath(path) {
+	if (lstatSync(path, { throwIfNoEntry: false }) !== void 0) {
+		const physicalPath = realpathSync.native(path);
+		if (!statSync(physicalPath).isDirectory()) throw new Error(`ENOTDIR: build output ancestor is not a directory: ${path}`);
+		return physicalPath;
+	}
+	const parent = dirname(path);
+	return resolve(resolvePhysicalPath(parent), relative(parent, path));
+}
+/** Identifies relative paths that resolve beyond their intended parent directory. */
+function isOutsideProject(relativePath) {
+	return relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath);
+}
+//#endregion
+//#region src/html/emit-playable-html.ts
+/** Writes the runnable HTML document into its prepared variant output. */
+async function emitPlayableHtml(context, bundle) {
+	const source = renderPlayableHtml(context.variant, {
+		entry: `./${bundle.entries.application}`,
+		head: context.profile.htmlHead,
+		initializers: {
+			assets: `./${bundle.entries.assets}`,
+			config: `./${bundle.entries.config}`,
+			host: `./${bundle.entries.host}`
+		},
+		loadingIndicator: context.profile.loadingIndicator,
+		stylesheets: bundle.stylesheets.map((stylesheet) => `./${stylesheet}`)
+	});
+	await writeFile(context.htmlFile, source, "utf8");
+}
+//#endregion
+//#region src/pipeline/create-build-context.ts
+/** Resolves every authored and generated path needed to build one variant. */
+function createBuildContext(variant, options) {
+	const projectRoot = resolve(options.projectRoot);
+	const outputDirectory = resolveOutputDirectory(projectRoot, options.outputDirectory);
+	return {
+		...createPlayableViteContext({
+			projectRoot,
+			variant
+		}),
+		outputDirectory,
+		htmlFile: join(outputDirectory, PLAYABLE_HTML_FILE)
+	};
+}
+//#endregion
+//#region src/browser-targets.ts
+/** Minimum browser engines supported by compiled playable output. */
+const PLAYABLE_BROWSER_TARGETS = ["ios16.1", "chrome105"];
+//#endregion
+//#region src/production/create-bundle-output.ts
+const STYLESHEET_EXTENSION = ".css";
+const standaloneEntryRoles = [
+	"host",
+	"config",
+	"assets"
+];
+const entryRoles = [...standaloneEntryRoles, "application"];
+/** Combines four role-specific Rolldown results into one HTML-facing description. */
+function createBundleOutput(outputs, applicationMode) {
+	const entries = {
+		host: requireEntryFile(outputs.host, "host"),
+		config: requireEntryFile(outputs.config, "config"),
+		assets: requireEntryFile(outputs.assets, "assets"),
+		application: requireEntryFile(outputs.application, "application")
+	};
+	validateBundleContract(outputs, entries, applicationMode);
+	const emittedAssets = Object.values(outputs).flat().filter((chunkOrAsset) => chunkOrAsset.type === "asset");
+	return {
+		entries,
+		chunks: outputs.application.filter((chunkOrAsset) => chunkOrAsset.type === "chunk" && !chunkOrAsset.isEntry).map(({ fileName }) => fileName).sort(),
+		stylesheets: collectAssetFiles(emittedAssets, true),
+		resources: collectAssetFiles(emittedAssets, false)
+	};
+}
+/** Enforces the entry isolation required by the runtime registration protocol. */
+function validateBundleContract(outputs, entries, applicationMode) {
+	const entryFiles = Object.values(entries);
+	if (new Set(entryFiles).size !== entryFiles.length) throw new Error(`Playable entry filenames must be unique; received ${entryFiles.join(", ")}.`);
+	for (const role of standaloneEntryRoles) assertStandaloneEntry(outputs[role], role);
+	if (applicationMode === "single-module") assertStandaloneEntry(outputs.application, "application");
+	for (const role of entryRoles) assertNoCrossEntryImports(outputs[role], role, entries);
+}
+/** Requires a role configured without code splitting to emit exactly one chunk. */
+function assertStandaloneEntry(output, role) {
+	const chunks = output.filter((chunkOrAsset) => chunkOrAsset.type === "chunk");
+	if (chunks.length !== 1) throw new Error(`Expected standalone ${role} entry to emit one chunk, received ${chunks.length}.`);
+}
+/** Rejects dependencies on another private entry while permitting application chunks. */
+function assertNoCrossEntryImports(output, role, entries) {
+	const forbiddenEntryFiles = new Set(Object.entries(entries).filter(([entryRole]) => entryRole !== role).map(([, entryFile]) => entryFile));
+	for (const chunk of output) {
+		if (chunk.type !== "chunk") continue;
+		const forbiddenImport = [...chunk.imports, ...chunk.dynamicImports].find((file) => forbiddenEntryFiles.has(file));
+		if (forbiddenImport !== void 0) throw new Error(`Playable ${role} entry imports private entry ${forbiddenImport}.`);
+	}
+}
+/** Returns the one entry emitted by a role-specific build. */
+function requireEntryFile(output, role) {
+	const entryFiles = output.filter((chunkOrAsset) => chunkOrAsset.type === "chunk" && chunkOrAsset.isEntry).map(({ fileName }) => fileName);
+	const entryFile = entryFiles[0];
+	if (entryFile === void 0 || entryFiles.length !== 1) throw new Error(`Expected one ${role} entry, received ${entryFiles.length}.`);
+	return entryFile;
+}
+/** Collects unique stylesheet or non-stylesheet asset paths in stable order. */
+function collectAssetFiles(assets, stylesheets) {
+	return [...new Set(assets.filter(({ fileName }) => fileName.endsWith(STYLESHEET_EXTENSION) === stylesheets).map(({ fileName }) => fileName))].sort();
+}
+//#endregion
+//#region src/production/validate-application-module-graph.ts
+/**
+* Browser packages whose state or object identity cannot safely be duplicated.
+*
+* This list is intentionally local to `@replayablejs/build`: unlike the repository
+* dependency check, this validator ships to consumers and must work independently.
+*/
+const SINGLETON_PACKAGES = [
+	"@esotericsoftware/spine-core",
+	"@esotericsoftware/spine-pixi-v8",
+	"@replayablejs/runtime",
+	"motion",
+	"motion-dom",
+	"pixi.js"
+];
+/**
+* Rejects singleton packages bundled from more than one physical installation.
+*
+* Rolldown may include the same package in several chunks; those modules are
+* valid when their nearest package.json resolves to the same real directory.
+* Distinct directories indicate separate caches, class identities, or frame
+* schedulers that cannot safely coexist inside one playable application.
+*
+* Only the application build belongs here. Replayable deliberately builds host,
+* config, and assets as separate executable entries; combining all four module
+* graphs would confuse that isolation with duplicate browser package instances.
+*
+* A protected package may be absent—for example, a DOM-only playable contains
+* no PixiJS. Presence is enforced by authored imports; this function only rejects
+* multiple installations of a package that actually entered the application.
+*/
+function validateApplicationModuleGraph(output) {
+	const packageInstances = /* @__PURE__ */ new Map();
+	const packageCache = /* @__PURE__ */ new Map();
+	for (const chunkOrAsset of output) {
+		if (chunkOrAsset.type !== "chunk") continue;
+		for (const moduleId of Object.keys(chunkOrAsset.modules)) {
+			const packageInstance = resolvePackageInstance(moduleId, packageCache);
+			if (!isSingletonPackage(packageInstance?.name)) continue;
+			const instances = packageInstances.get(packageInstance.name) ?? /* @__PURE__ */ new Set();
+			instances.add(packageInstance.directory);
+			packageInstances.set(packageInstance.name, instances);
+		}
+	}
+	for (const packageName of SINGLETON_PACKAGES) {
+		const instances = packageInstances.get(packageName);
+		if (instances !== void 0 && instances.size > 1) throw new Error(`Playable application contains multiple ${packageName} instances: ${[...instances].join(", ")}.`);
+	}
+}
+/** Resolves the nearest package.json that owns one filesystem-backed module. */
+function resolvePackageInstance(moduleId, cache) {
+	const filePath = moduleId.replace(/[?#].*$/, "");
+	if (!isAbsolute(filePath)) return null;
+	let directory = dirname(filePath);
+	const visitedDirectories = [];
+	while (directory !== parse(directory).root) {
+		const cachedInstance = cache.get(directory);
+		if (cachedInstance !== void 0 || cache.has(directory)) {
+			cacheDirectories(visitedDirectories, cachedInstance ?? null, cache);
+			return cachedInstance ?? null;
+		}
+		visitedDirectories.push(directory);
+		const manifestPath = join(directory, "package.json");
+		if (existsSync(manifestPath)) {
+			const packageInstance = readPackageInstance(JSON.parse(readFileSync(manifestPath, "utf8")), directory);
+			cacheDirectories(visitedDirectories, packageInstance, cache);
+			return packageInstance;
+		}
+		directory = dirname(directory);
+	}
+	cacheDirectories(visitedDirectories, null, cache);
+	return null;
+}
+/**
+* Retains one package lookup for every traversed directory.
+*
+* Many modules share nested directories. Caching the whole walk prevents repeated
+* filesystem traversal for every file in a large dependency such as PixiJS.
+*/
+function cacheDirectories(directories, packageInstance, cache) {
+	for (const directory of directories) cache.set(directory, packageInstance);
+}
+/** Reads only the package identity required by singleton validation. */
+function readPackageInstance(manifest, directory) {
+	if (typeof manifest !== "object" || manifest === null || !("name" in manifest) || typeof manifest.name !== "string") return null;
+	return {
+		directory: realpathSync.native(directory),
+		name: manifest.name
+	};
+}
+/** Narrows an arbitrary package name to the protected singleton set. */
+function isSingletonPackage(name) {
+	return name !== void 0 && SINGLETON_PACKAGES.some((packageName) => packageName === name);
+}
+//#endregion
+//#region src/production/bundle-variant.ts
+/** Builds independently executable host, config, assets, and application entries. */
+async function bundleVariant(context) {
+	const entries = createPlayableEntries(context, "build");
+	const hostOutput = await buildEntry(context, entries.host, {
+		emptyOutputDirectory: true,
+		output: {
+			codeSplitting: false,
+			format: "es"
+		}
+	});
+	const configOutput = await buildEntry(context, entries.config, {
+		emptyOutputDirectory: false,
+		output: {
+			codeSplitting: false,
+			format: "es"
+		}
+	});
+	const assetsOutput = await buildEntry(context, entries.assets, {
+		emptyOutputDirectory: false,
+		output: {
+			codeSplitting: false,
+			format: "es"
+		}
+	});
+	const applicationOutput = await buildEntry(context, entries.application, {
+		emptyOutputDirectory: false,
+		output: {
+			codeSplitting: context.profile.applicationMode === "module-graph",
+			format: "es"
+		}
+	});
+	validateApplicationModuleGraph(applicationOutput);
+	return createBundleOutput({
+		host: hostOutput,
+		config: configOutput,
+		assets: assetsOutput,
+		application: applicationOutput
+	}, context.profile.applicationMode);
+}
+/** Runs one role-specific Vite build into the shared variant directory. */
+async function buildEntry(context, entry, options) {
+	const buildResult = await build({
+		...createBaseViteConfig(context.projectRoot),
+		...entry.viteConfig,
+		base: "./",
+		build: {
+			assetsInlineLimit: context.profile.assetMode === "inline" ? Infinity : 0,
+			chunkSizeWarningLimit: Infinity,
+			cssTarget: [...PLAYABLE_BROWSER_TARGETS],
+			emptyOutDir: options.emptyOutputDirectory,
+			outDir: context.outputDirectory,
+			rolldownOptions: {
+				input: entry.input,
+				onLog(level, log, defaultHandler) {
+					defaultHandler(level === "warn" ? "error" : level, log);
+				},
+				output: options.output
+			},
+			target: [...PLAYABLE_BROWSER_TARGETS]
+		}
+	});
+	if (!("output" in buildResult)) throw new Error("Vite did not return a single playable build output.");
+	return buildResult.output;
+}
+//#endregion
+//#region src/production/build-variant.ts
+/**
+* Produces one runnable playable from a concrete configuration variant.
+*
+* @param variant - Fully resolved version, network, and language combination.
+* @param options - Explicit project root and variant output directory.
+*/
+async function buildVariant(variant, options) {
+	const context = createBuildContext(variant, options);
+	const assets = await buildAssets(context.variant.assets, context.projectRoot);
+	await emitPlayableHtml(context, await bundleVariant(context));
+	return {
+		assets,
+		htmlFile: context.htmlFile,
+		outputDirectory: context.outputDirectory,
+		variantId: context.variant.id
+	};
+}
+//#endregion
+//#region src/production/build-project.ts
+/**
+* Builds every concrete variant configured by one Replayable project.
+*
+* Variants are built sequentially because their asset builds share generated
+* source paths. The project output is reset once so variants removed from the
+* configuration cannot leave stale playable directories behind.
+* The first variant is restored afterward as a deterministic baseline. This
+* does not isolate an active preview: build and development share asset paths.
+*
+* @param config - Human-authored or already validated Replayable configuration.
+* @param workingDirectory - Project directory used to resolve authored paths.
+*/
+async function buildProject(config, workingDirectory = process.cwd()) {
+	const validatedConfig = defineConfig(config);
+	const projectRoot = resolve(workingDirectory);
+	const outputDirectory = resolveOutputDirectory(projectRoot, validatedConfig.build.outDir);
+	const configuredVariants = createVariants(validatedConfig);
+	const canonicalVariant = configuredVariants[0];
+	const variants = [];
+	const errors = [];
+	if (canonicalVariant === void 0) throw new Error("A Replayable project must resolve at least one playable variant.");
+	await rm(outputDirectory, {
+		force: true,
+		recursive: true
+	});
+	try {
+		for (const variant of configuredVariants) variants.push(await buildVariant(variant, {
+			outputDirectory: join(outputDirectory, variant.id),
+			projectRoot
+		}));
+	} catch (error) {
+		errors.push(error);
+	}
+	try {
+		await buildAssets(canonicalVariant.assets, projectRoot);
+	} catch (error) {
+		errors.push(error);
+	}
+	if (errors.length === 1) throw errors[0];
+	if (errors.length > 1) throw new AggregateError(errors, "Playable build and generated asset restoration both failed.");
+	return {
+		outputDirectory,
+		variants
+	};
+}
+//#endregion
+export { buildProject, buildVariant, servePreview };
+
+//# sourceMappingURL=index.mjs.map