create-eigen-game 0.12.1 → 0.13.1

package/dist/src-q9BxESYC.js

@@ -0,0 +1,833 @@
+import { execFileSync } from "node:child_process";
+import { appendFileSync, cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, rmdirSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/engine-range.ts
+/**
+* Where the engine range emitted into a scaffolded project comes from.
+*
+* Its own module because the two branches below execute in different worlds,
+* one only inside this repository and the other only inside a published tarball,
+* and a function whose published-only path never runs in CI is a function that
+* is not tested. `src/index.ts` uses it; the package `exports` map does not
+* expose it, so it is internal despite being importable by the tests.
+*/
+/** The dependency whose version the scaffolder emits into the generated server. */
+const ENGINE_PACKAGE = "@eigeninteractive/server";
+/**
+* The engine range for a scaffolded project, from this package's own
+* `@eigeninteractive/server` devDependency.
+*
+* That number is not maintained by anyone: it is the version CI compiled the
+* templates against, because `pnpm -r typecheck` runs
+* `tsc -p templates/worker/tsconfig.json` inside this workspace. Emitting
+* anything else would mean shipping templates paired with an engine no build
+* ever saw.
+*
+* It replaced a derivation from this package's OWN version, which was correct
+* only while `create-eigen-game` sat in the `fixed` changesets group, and that
+* membership is what forced an engine-wide release for every scaffolder-only
+* change. Reading the dependency keeps the guarantee and drops the coupling.
+*
+* Two branches, because the same manifest reads differently in the two places
+* this runs:
+*
+* - **Published tarball**: pnpm rewrites `workspace:*` to the exact version
+*   while packing, so the manifest already states it (`"0.2.0"`), and no
+*   sibling package exists on disk to consult.
+* - **This workspace**: the manifest still says `workspace:*`, which names no
+*   version, so the sibling package is read directly.
+*
+* @param declared the raw `@eigeninteractive/server` devDependency value
+* @param readSiblingVersion consulted only for the `workspace:` protocol
+*/
+function engineRange(declared, readSiblingVersion) {
+	if (!declared) throw new Error(`create-eigen-game has no ${ENGINE_PACKAGE} devDependency, which is where the engine range it emits comes from`);
+	const version = declared.startsWith("workspace:") ? readSiblingVersion() : declared;
+	if (!version) throw new Error(`create-eigen-game declares ${ENGINE_PACKAGE} as "${declared}" but the workspace package could not be read, so there is no engine version to emit`);
+	if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(version)) throw new Error(`expected an exact ${ENGINE_PACKAGE} version to build a range from, got "${version}"`);
+	return `^${version}`;
+}
+//#endregion
+//#region src/link-firebase.ts
+/**
+* Reads the two deployment values that exist only once a Firebase project
+* does, so the closing summary can name what is still missing.
+*
+* Reading only. `configure_firebase` writes them, into `wrangler.jsonc` and
+* `app-config.json`, because it is also what a project runs later when
+* reconfiguring, and one implementation is what keeps the scaffold-time path
+* and the re-run path identical. This module exists so the summary can tell
+* the difference between "filled in" and "still owed", not to do it again.
+*
+* Its own module for the same reason `summary.ts` is: `index.ts` runs a
+* scaffold, and this is worth asserting without one. The package `exports` map
+* does not expose it.
+*/
+function readJson(path) {
+	if (!existsSync(path)) return void 0;
+	try {
+		return JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		return;
+	}
+}
+/**
+* The project FlutterFire recorded for the Dart output this app uses.
+*
+* `firebase.json` is FlutterFire's own record rather than something this
+* scaffold writes, so it is read defensively: a shape that does not match is
+* treated as "not configured", which is the same answer as a run that never
+* happened.
+*/
+function configuredProject(appRoot) {
+	const projectId = readJson(resolve(appRoot, "firebase.json"))?.flutter?.platforms?.dart?.["lib/firebase_options.dart"]?.projectId;
+	return typeof projectId === "string" && projectId !== "" ? projectId : null;
+}
+/**
+* The OAuth web client id that `configure_firebase` copied into
+* `app-config.json`, when there was one to copy.
+*
+* Empty is an ordinary outcome rather than a failure. Firebase creates that
+* client when the Google sign-in provider is enabled, which is a console
+* action no CLI can perform, so a project that has never had it enabled has
+* nothing to offer here.
+*/
+function configuredWebClientId(appRoot) {
+	const value = readJson(resolve(appRoot, "app-config.json"))?.GOOGLE_WEB_CLIENT_ID;
+	return typeof value === "string" && value !== "" ? value : null;
+}
+/** What the Firebase step settled, for the summary to report. */
+function readFirebaseLink(root) {
+	const appRoot = resolve(root, "app");
+	return {
+		projectId: configuredProject(appRoot),
+		googleWebClientId: configuredWebClientId(appRoot)
+	};
+}
+//#endregion
+//#region src/index.ts
+/**
+* Gives a terminal that reports no width the width clack would have assumed.
+*
+* A pty can report itself as a TTY and set `columns` to 0. `script` does, and
+* so do some container terminals. clack falls back to 80 for a stream with no
+* `columns` at all, but `0` is a number and satisfies that check, so the width
+* it draws its rules from goes negative and a scaffold dies partway through
+* with `RangeError: Invalid string length`. Supplying the default its check
+* misses is better than giving up the drawing.
+*/
+function normaliseTerminalWidth(stream) {
+	if (stream.isTTY === true && (stream.columns ?? 0) < 1) stream.columns = 80;
+}
+/** Runs every step plainly, which is what a library caller gets by default. */
+const plainReporter = {
+	step: (_label, body) => body(),
+	handOver: (_label, body) => body(),
+	emit: (output) => process.stdout.write(output),
+	warn: (message) => console.warn(`create-eigen-game: ${message}`),
+	interactive: true
+};
+/**
+* The runner a scaffold uses when the caller has not supplied one: it asks the
+* reporter whether the terminal is spoken for.
+*
+* `interactive` inherits, which is the only way FlutterFire can put a question
+* on screen and read the answer. Otherwise both streams are captured and
+* handed to the reporter: on success so it can discard them, and on failure
+* so the reason survives.
+*/
+function capturingRunner(reporter) {
+	return (command, args, cwd) => {
+		if (reporter.interactive) {
+			execFileSync(command, args, {
+				cwd,
+				stdio: "inherit"
+			});
+			return;
+		}
+		try {
+			reporter.emit(execFileSync(command, args, {
+				cwd,
+				encoding: "utf8",
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				]
+			}));
+		} catch (error) {
+			const { stdout, stderr } = error;
+			reporter.emit(`${stdout ?? ""}${stderr ?? ""}`);
+			throw error;
+		}
+	};
+}
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const templatesRoot = resolve(packageRoot, "templates");
+/**
+* The engine range emitted into a scaffolded project's package.json.
+*
+* Read from this package's `@eigeninteractive/server` devDependency rather than
+* from its own version. See `engine-range.ts` for why that is the version the
+* templates are known to compile against, and what it replaced.
+*/
+const engineVersion = engineRange(JSON.parse(readFileSync(resolve(packageRoot, "package.json"), "utf8")).devDependencies?.[ENGINE_PACKAGE], () => {
+	const sibling = resolve(packageRoot, "../server/package.json");
+	return existsSync(sibling) ? JSON.parse(readFileSync(sibling, "utf8")).version : void 0;
+});
+/**
+* The Flutter client range installed into the app half.
+*
+* A stated version, not a derived or resolved one. The Dart templates import
+* `package:eigen_flutter/eigen_flutter.dart` and
+* `package:eigen_flutter/testing/twin_fixtures.dart` and are written against a
+* specific Dart API. `eigen_flutter` is published and versioned separately from
+* this package even though both now live in the platform monorepo, so a source
+* location cannot compute which released version the template should request.
+* Only compiling a scaffolded app establishes it, which the platform gate does
+* on every change.
+*
+* This briefly resolved from pub.dev instead: "the newest `eigen_flutter` whose
+* own `eigen_api` constraint targets the engine line being scaffolded". That
+* predicate is wrong. The `eigen_api` constraint describes the WIRE the shell
+* speaks, not the Dart API these templates call, and the two move
+* independently: a future `eigen_flutter` may legitimately keep `eigen_api:
+* ^0.2.0` while renaming everything the templates touch. It would have been
+* selected, and the generated app would not compile.
+*
+* A caret RANGE rather than an exact version, so it still improves without a
+* republish: `flutter pub add eigen_flutter@^0.4.0` already picks the newest
+* 0.4.x at scaffold time, which is the part the pub.dev lookup was duplicating.
+* What it deliberately cannot do is cross to 0.5.x, the one move that needs a
+* human to confirm the templates still compile.
+*
+* Staleness is therefore a failing check rather than a broken scaffold: this is
+* only ever a release behind, never wrong.
+*
+* Raised to 0.4.0 with the engine's session-snapshot wire. This is the one kind
+* of bump that is not merely an improvement: a scaffold writes both halves, and
+* the worker half is this repository's own line, so the shell it installs has to
+* speak that line's socket. `eigen_flutter` 0.4.0 is the first that does, and
+* every 0.3.x pins `eigen_api: ^0.2.0`, which cannot read a 0.3.x engine at all.
+* A scaffold pinning 0.3.x would therefore resolve, compile, and then fail to
+* render a game, which is the worst of the three.
+*
+* Raised to 0.4.1 for `EngineConfig.authDomain`, which the generated
+* `main.dart` passes. Additive, so pre-1.0 it is a patch and `^0.4.0` would
+* still resolve it, but `^0.4.0` also still resolves 0.4.0, where the parameter
+* does not exist and the scaffold would not compile. The floor is what makes
+* the generated code and the installed shell agree.
+*
+* Raised to 0.6.0 with the engine's opaque pagination cursors, and this is the
+* same *required* kind of bump the 0.4.0 note describes rather than an
+* improvement. The 0.4.x engine line takes `cursor` as an opaque string and
+* returns `nextCursor` on every paged response; `eigen_flutter` 0.6.0 is the
+* first shell that pins `eigen_api: ^0.4.0` and can read it. Everything below
+* that pins `eigen_api: ^0.3.0` or older, so a scaffold left on `^0.4.1` would
+* install the engine's current line beside a shell that cannot read a single
+* paged list from it: it resolves, it compiles, and then the lobby and history
+* are empty. 0.5.0 is skipped for the same reason, being a web-design release
+* that still speaks the 0.3.x wire.
+*
+* Raised to 0.7.0 for the 0.5.x engine line and the `PlayerLimits` client API.
+* vNext later simplified the wire again: versions are a contiguous prefix and
+* generic mutation identities are gone. The next Flutter release must raise
+* this floor before the corresponding scaffolder is published.
+*
+* Note that this floor and the engine range are raised in one commit on
+* purpose. The scaffolder writes both halves, and `updateInternalDependencies`
+* republishes this package whenever the engine version moves, so between an
+* engine line crossing and this line moving there is a published scaffolder
+* that pairs a new worker with an old shell. That window is real and this is
+* what closes it.
+*
+* The 0.7.0 raise is the exception that shows where that promise cannot hold. A
+* floor names a *published* `eigen_flutter`, and `eigen_flutter` publishes at the
+* end of the release chain, after the npm packages this scaffolder ships with --
+* so at the moment the engine crossed to 0.5.x there was no 0.7.0 to point at,
+* and `create-eigen-game@0.12.0` went out pairing a `^0.5.0` worker with a 0.6.0
+* shell. A Flutter line move therefore costs a follow-up scaffolder patch, and
+* `scripts/scaffold-e2e.mjs` is what refuses to let it be forgotten: it resolves
+* both halves for real and compares the wire lines they land on.
+*/
+const flutterClientVersion = "^0.8.0";
+/** Optional Firebase adapter installed by the standard app scaffold. */
+const firebaseAdapterVersion = "^0.1.0";
+/** Development-only contract compiler installed into the generated app. */
+const dartCodegenVersion = "^0.1.0";
+const gameSlug = (value) => {
+	if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value)) throw new Error("destination directory name must be a lowercase kebab-case slug, for example my-game");
+	return value;
+};
+const dartName = (value) => value.replaceAll("-", "_");
+/**
+* The Android `applicationId`, and iOS bundle id, a scaffold at `directory`
+* will produce, so the CLI can show it rather than describe it.
+*
+* `flutter create --org X --project-name Y` derives `X.Y`. The organization is
+* the *prefix*, not the whole identifier, which is the part worth seeing
+* before answering: Google Play makes it permanent at first upload.
+*/
+function applicationId(directory, org) {
+	return `${org?.trim() || "com.example"}.${dartName(gameSlug(basename(resolve(directory))))}`;
+}
+const title = (value) => value.split("-").map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`).join(" ");
+const identifier = (value) => {
+	const pascal = value.split("-").map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`).join("");
+	return /^[0-9]/.test(pascal) ? `Game${pascal}` : pascal;
+};
+function detectPackageManager(userAgent = process.env.npm_config_user_agent) {
+	if (userAgent?.startsWith("pnpm/")) return "pnpm";
+	if (userAgent?.startsWith("npm/")) return "npm";
+}
+/**
+* Substitutes the scaffold's tokens, of which there are two deliberate kinds.
+*
+* `{{BRACED}}` for values that have no valid example: a package manager,
+* an engine version, an Android package id. They appear only in manifests,
+* READMEs, workflows and the `Appfile`: files nothing compiles.
+*
+* Bare words (`ExampleGame`, `example-game`, …) for names a real example game
+* genuinely has. This is what keeps `templates/worker` and the Dart templates
+* VALID, COMPILING SOURCE rather than text with holes in it, which the rest of
+* this package leans on hard: `typecheck` runs `tsc` over `templates/worker`,
+* the tests `import` its game module directly and build a real contract from
+* it, and the `scaffold` job compiles the Dart templates. Bracing these would
+* trade all of that for a marker.
+*
+* The cost, and the one rule for template authors: a template file cannot
+* contain the literal string `example-game`, `Example Game`, `ExampleGame` or
+* `example_game` and keep it; every occurrence is rewritten, in prose and in
+* code alike. Write around it, or brace a new token instead.
+*
+* Note this means the set of files carrying a token changes whenever someone
+* writes one into an existing file. Nothing needs to track that: `renderTree`
+* decides what to rewrite from the bytes, not from a list of paths.
+*/
+function render(contents, name, manager, packageId) {
+	return [
+		["@game/example-game-server", `@game/${name}-server`],
+		["{{PACKAGE_MANAGER}}", manager],
+		["{{PACKAGE_ID}}", packageId],
+		["{{ENGINE_VERSION}}", engineVersion],
+		["ExampleGame", identifier(name)],
+		["Example Game", title(name)],
+		["example_game", dartName(name)],
+		["example-game", name]
+	].reduce((result, [from, to]) => result.replaceAll(from, to), contents);
+}
+/**
+* True when the bytes are valid UTF-8.
+*
+* This is not a guess at whether a file is "binary"; it is the precondition
+* of the operation. Token substitution is `String.replaceAll`, so a file that
+* cannot be decoded cannot take part, and one that can is safe to rewrite.
+*
+* Deliberately not an extension list. A DENY list (`.png`, `.jar`, …) fails
+* silently in the dangerous direction: the day someone adds a `.webp`, it is
+* corrupted with no error. An ALLOW list fails the safe way but fits this tree
+* badly: `Gemfile`, `Fastfile`, `.nvmrc`, `.fvmrc` and `.ruby-version` all
+* need rendering and none carry a usable extension, so it would have to be a
+* list of extensions *and* a list of bare filenames, both drifting.
+*
+* `.template` is not the signal either, despite the name: it marks files a
+* language server must not claim before they have an enclosing package. Five
+* of them contain no token at all, and nine token-bearing files are not
+* marked, so the two concepts are orthogonal here.
+*
+* `renderTree`'s test pins the resulting classification for the whole tree, so
+* this stays a reviewed decision rather than an invisible one.
+*/
+const utf8 = new TextDecoder("utf-8", { fatal: true });
+function decodeUtf8(bytes) {
+	try {
+		return utf8.decode(bytes);
+	} catch {
+		return;
+	}
+}
+function renderTree(source, destination, name, manager, packageId) {
+	cpSync(source, destination, { recursive: true });
+	const visit = (directory) => {
+		for (const entry of readdirSync(directory, { withFileTypes: true })) {
+			const templatePath = resolve(directory, entry.name);
+			if (entry.isDirectory()) {
+				visit(templatePath);
+				continue;
+			}
+			if (!entry.isFile()) continue;
+			const rendered = resolve(destination, relative(source, templatePath));
+			const text = decodeUtf8(readFileSync(templatePath));
+			if (text !== void 0) writeFileSync(rendered, render(text, name, manager, packageId));
+			if (entry.name.endsWith(".template")) renameSync(rendered, rendered.slice(0, -9));
+		}
+	};
+	visit(source);
+	const packagedGitignore = resolve(templatesRoot, "scaffold", `${basename(source)}.gitignore`);
+	if (existsSync(packagedGitignore)) writeFileSync(resolve(destination, ".gitignore"), render(readFileSync(packagedGitignore, "utf8"), name, manager, packageId));
+}
+function packageCommand(manager, operation) {
+	if (operation === "install") return [manager, ["install"]];
+	return [manager, ["run", operation]];
+}
+/**
+* Appends `block` to a file this scaffolder does not own, as its own paragraph.
+*
+* **Append, never insert.** That is the rule the three callers below follow, and
+* it is what keeps them from competing with `flutter create` and `flutterfire
+* configure` for position in the same files. A pure append cannot collide with
+* whatever those tools write above it; the one edit here that ever needed a
+* position, prepending a Kotlin `import`, was broken by an AGP upgrade and has
+* since been rewritten away. See MAINTAINERS.md for the whole doctrine, including
+* why FlutterFire's `// START:`/`// END:` marker comments are deliberately not
+* copied.
+*
+* `contents` is passed in rather than read here because every caller has already
+* read the file to decide whether its block is present, and two of them assert
+* on the shape of what they found. This owns the whitespace and nothing else.
+*
+* That is worth one function because it was previously written three times with
+* two different answers, so the desugaring block got a blank line before it and
+* the other two did not, and the two Gradle blocks ended up flush against each
+* other in every generated project. Separation belongs to the append, so the
+* block constants carry no leading or trailing newline of their own.
+*/
+function appendBlock(path, contents, block) {
+	appendFileSync(path, `${contents.endsWith("\n") ? "" : "\n"}\n${block}\n`);
+}
+const androidDesugaring = `// flutter_local_notifications requires desugaring in the application module.
+// A library plugin cannot enable this compiler setting transitively.
+android {
+    compileOptions {
+        isCoreLibraryDesugaringEnabled = true
+    }
+}
+
+dependencies {
+    coreLibraryDesugaring("com.android.tools:desugar_jdk_libs:2.1.4")
+}`;
+function enableAndroidCoreLibraryDesugaring(appRoot) {
+	const gradlePath = resolve(appRoot, "android/app/build.gradle.kts");
+	const gradle = readFileSync(gradlePath, "utf8");
+	if (!gradle.includes("id(\"com.android.application\")")) throw new Error(`Flutter created an unexpected Android application build file: ${gradlePath}`);
+	const settingExists = gradle.includes("isCoreLibraryDesugaringEnabled");
+	const dependencyExists = gradle.includes("coreLibraryDesugaring(");
+	if (settingExists && dependencyExists) return;
+	if (settingExists || dependencyExists) throw new Error(`Flutter created an incomplete Android core library desugaring configuration: ${gradlePath}`);
+	appendBlock(gradlePath, gradle, androidDesugaring);
+}
+const androidReleaseSigning = `val releaseKeyProperties: Map<String, String> =
+    rootProject.file("key.properties")
+        .takeIf { it.exists() }
+        ?.readLines()
+        ?.map { it.trim() }
+        ?.filter { it.isNotEmpty() && !it.startsWith("#") && it.contains("=") }
+        ?.associate { it.substringBefore("=").trim() to it.substringAfter("=").trim() }
+        .orEmpty()
+
+android {
+    signingConfigs {
+        create("release") {
+            storeFile = releaseKeyProperties["storeFile"]?.let { file(it) }
+            storePassword = releaseKeyProperties["storePassword"]
+            keyAlias = releaseKeyProperties["keyAlias"]
+            keyPassword = releaseKeyProperties["keyPassword"]
+        }
+    }
+    buildTypes {
+        release {
+            signingConfig = if (releaseKeyProperties["storeFile"] != null)
+                signingConfigs.getByName("release")
+            else
+                signingConfigs.getByName("debug")
+            isMinifyEnabled = true
+            isShrinkResources = true
+            proguardFiles(
+                getDefaultProguardFile("proguard-android-optimize.txt"),
+                "proguard-rules.pro",
+            )
+        }
+    }
+}`;
+function enableAndroidReleaseSigning(appRoot) {
+	const gradlePath = resolve(appRoot, "android/app/build.gradle.kts");
+	const gradle = readFileSync(gradlePath, "utf8");
+	if (gradle.includes("releaseKeyProperties")) return;
+	appendBlock(gradlePath, gradle, androidReleaseSigning);
+}
+const launcherIconsAndSplashConfig = `flutter_launcher_icons:
+  android: true
+  web:
+    generate: true
+    image_path: "assets/icon/icon.png"
+  image_path: "assets/icon/icon.png"
+  adaptive_icon_background: "#1B1E24"
+  adaptive_icon_foreground: "assets/icon/icon_foreground.png"
+  min_sdk_android: 21
+
+flutter_native_splash:
+  color: "#F4F1EA"
+  color_dark: "#1B1E24"
+  image: assets/icon/splash.png
+  image_dark: assets/icon/splash_dark.png
+  fullscreen: true
+  android_12:
+    color: "#F4F1EA"
+    color_dark: "#1B1E24"
+    image: assets/icon/splash.png
+    image_dark: assets/icon/splash_dark.png
+    icon_background_color: "#F4F1EA"
+    icon_background_color_dark: "#1B1E24"
+  web: true`;
+function configureLauncherIconsAndSplash(appRoot) {
+	const pubspecPath = resolve(appRoot, "pubspec.yaml");
+	const pubspec = readFileSync(pubspecPath, "utf8");
+	if (pubspec.includes("flutter_launcher_icons:")) return;
+	appendBlock(pubspecPath, pubspec, launcherIconsAndSplashConfig);
+}
+/**
+* Adds the GitHub Actions workflows to an existing generated project.
+*
+* The companion to `ci: false`: a game can be built and played locally for as
+* long as its author likes, then gain the same PR gate and signed release
+* pipeline a `--ci` scaffold would have produced.
+*/
+function addContinuousIntegration(options) {
+	const root = resolve(options.directory);
+	const manifestPath = resolve(root, "package.json");
+	if (!existsSync(manifestPath) || !existsSync(resolve(root, "server")) || !existsSync(resolve(root, "app"))) throw new Error(`not an EigenInteractive game project (expected package.json, server/ and app/): ${root}`);
+	const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+	const name = gameSlug(manifest.name ?? basename(root));
+	const recorded = manifest.scripts?.contract?.includes("pnpm ") ? "pnpm" : manifest.scripts?.contract?.includes("npm ") ? "npm" : void 0;
+	const manager = options.packageManager ?? recorded ?? detectPackageManager() ?? "pnpm";
+	const appfile = resolve(root, "app/fastlane/Appfile");
+	const packageId = existsSync(appfile) ? /package_name\("([^"]+)"\)/.exec(readFileSync(appfile, "utf8"))?.[1] ?? `com.example.${dartName(name)}` : `com.example.${dartName(name)}`;
+	const workflows = resolve(root, ".github/workflows");
+	const existing = existsSync(workflows) ? readdirSync(workflows).filter((f) => f === "checks.yml" || f === "release.yml") : [];
+	if (existing.length > 0) throw new Error(`refusing to overwrite existing workflows: ${existing.join(", ")}`);
+	renderTree(resolve(templatesRoot, "ci"), root, name, manager, packageId);
+	return {
+		root,
+		files: [".github/workflows/checks.yml", ".github/workflows/release.yml"]
+	};
+}
+const probeCommand = (command, args) => {
+	try {
+		return {
+			ok: true,
+			stdout: execFileSync(command, args, {
+				encoding: "utf8",
+				stdio: [
+					"ignore",
+					"pipe",
+					"ignore"
+				]
+			})
+		};
+	} catch {
+		return {
+			ok: false,
+			stdout: ""
+		};
+	}
+};
+/**
+* Whether this machine can configure Firebase, asked *before* the scaffold
+* rather than after it.
+*
+* `configure_firebase` runs the same three checks and is the authority on
+* them; this one exists only to move the answer earlier. Learning that
+* `flutterfire` is missing costs nothing here and costs two minutes of Flutter
+* and pub at the far end, which is where the step actually runs.
+*
+* Every problem, not the first one. The checks are independent (two CLIs from
+* two ecosystems, plus a sign-in) so short-circuiting turns one setup into a
+* sequence of runs that each reveal the next missing piece. Reported in the
+* order they have to be fixed in: the CLI, then the sign-in it stores, then
+* the bridge that consumes both.
+*
+* The sign-in check fails open, for the same reason it does there: only an
+* answer that positively reports no accounts counts as "no", so a `firebase`
+* that errors or grows a different output shape is left to the command that
+* actually needs the credentials.
+*/
+function firebaseReadiness(probe = probeCommand) {
+	const problems = [];
+	if (probe("firebase", ["--version"]).ok) {
+		if (signedOut(probe)) problems.push({
+			reason: "no Google account is signed in to the Firebase CLI",
+			fix: "firebase login"
+		});
+	} else problems.push({
+		reason: "the `firebase` CLI is not installed",
+		fix: "curl -sL https://firebase.tools | bash"
+	});
+	if (!probe("flutterfire", ["--version"]).ok) problems.push({
+		reason: "the `flutterfire` CLI is not installed",
+		fix: "dart pub global activate flutterfire_cli"
+	});
+	return problems.length === 0 ? { ready: true } : {
+		ready: false,
+		problems
+	};
+}
+/**
+* Whether the Firebase CLI holds no credentials.
+*
+* `login:list --json` prints the stored refresh and access tokens along with
+* the account list. Read the shape, count the entries, and never surface the
+* output: not in a warning, not in a captured stream, not on the failure
+* path. That is why this returns a boolean rather than the response.
+*/
+function signedOut(probe) {
+	const accounts = probe("firebase", ["login:list", "--json"]);
+	if (!accounts.ok) return false;
+	try {
+		const { result } = JSON.parse(accounts.stdout);
+		return Array.isArray(result) && result.length === 0;
+	} catch {
+		return false;
+	}
+}
+/**
+* Whether the scaffold would land inside a repository that already exists.
+*
+* Asked of the nearest ancestor that exists, because the destination does not
+* yet. The point is not to change what {@link scaffoldGame} does, which already
+* declines to nest a repository, but to stop the CLI asking a question whose
+* answer cannot matter.
+*/
+/**
+* Why this destination cannot be scaffolded into, said as a whole message, or
+* `undefined` when there is nothing in the way.
+*
+* A directory that exists and is *empty* is not in the way, since people make
+* one out of habit, so it is removed and rewritten rather than refused over
+* nothing. Anything with contents in it is refused, and a cloned repository is
+* not an exception: `.git` is in the way like any other entry, and the message
+* names it. Publishing into one would mean parking `.git`, renaming staging
+* over the top and putting it back, with a failure in the middle able to
+* orphan a remote, which is a lot of care to spend on a flow that has a
+* one-line alternative.
+*
+* Refused, and deliberately not offered as a "remove it and continue?"
+* question, which is where several scaffolders in this family go. This one
+* writes ninety-odd files and runs `flutter create`; the cost of getting that
+* answer wrong against a mistyped path has no upper bound, and `rm -rf` is one
+* command that belongs to the person who can see what is in there. Every other
+* question this CLI asks is reversible. This one would not be.
+*
+* Exported so the CLI can ask it before the first question rather than after
+* the last one. {@link scaffoldGame} asks it again, for callers that are not
+* the CLI.
+*/
+function destinationProblem(directory) {
+	const root = resolve(directory);
+	if (!existsSync(root)) return void 0;
+	if (!statSync(root).isDirectory()) return `${root} already exists, and is a file.`;
+	const entries = readdirSync(root);
+	if (entries.length === 0) return void 0;
+	return `${root} already exists, and is not empty: it holds ${entries.slice(0, 3).sort().join(", ")}${entries.length > 3 ? `, and ${entries.length - 3} more` : ""}.\n\nScaffold somewhere else, or clear it out yourself. This will not delete a directory you already had.`;
+}
+function insideWorkTree(directory, probe = probeCommand) {
+	let candidate = resolve(directory);
+	while (!existsSync(candidate)) {
+		const parent = dirname(candidate);
+		if (parent === candidate) return false;
+		candidate = parent;
+	}
+	return probe("git", [
+		"-C",
+		candidate,
+		"rev-parse",
+		"--is-inside-work-tree"
+	]).ok;
+}
+/**
+* Runs the Flutter client's `configure_firebase` against the generated app.
+*
+* The command owns everything about how Firebase is configured: which
+* platforms, which CLIs must exist, whether anyone is signed in, and what to
+* do when no project has been chosen yet. This only decides *when*: before the
+* scaffold commit, so a configured project is committed configured.
+*
+* Not fatal. Every failure here (a missing `flutterfire`, no Google login, a
+* cancelled picker) leaves a complete and usable project that is exactly what
+* a scaffold without `--firebase` produces, so it warns with the command to
+* re-run and lets the commit happen.
+*/
+function configureFirebase(appRoot, project, run, reporter) {
+	const placeholder = resolve(appRoot, "lib/firebase_options.dart");
+	const parked = `${placeholder}.placeholder`;
+	const parking = existsSync(placeholder);
+	if (parking) renameSync(placeholder, parked);
+	try {
+		reporter.step("Preparing the Firebase configurator", () => run("dart", [
+			"run",
+			"eigen_firebase:configure_firebase",
+			"--help"
+		], appRoot));
+		reporter.handOver("Configuring Firebase", () => run("dart", [
+			"run",
+			"eigen_firebase:configure_firebase",
+			"--worker",
+			"../server",
+			...typeof project === "string" ? ["--project", project] : []
+		], appRoot));
+		if (parking) rmSync(parked, { force: true });
+		return "configured";
+	} catch {
+		if (parking) {
+			if (existsSync(placeholder)) rmSync(parked, { force: true });
+			else renameSync(parked, placeholder);
+		}
+		reporter.warn("Could not configure Firebase. The project is complete. Run `firebase:configure` yourself, then commit what it writes.");
+		return "failed";
+	}
+}
+/**
+* Commits the scaffold, so the first `git diff` is the first game change.
+*
+* This matters more here than in a scaffolder that only writes source. The
+* bootstrap runs `flutter_launcher_icons` and `flutter_native_splash`, which
+* write generated-but-committed files across `android/`, `web/` and
+* `assets/`; without a baseline the first branding change is indistinguishable
+* from the ninety files the scaffolder happened to produce.
+*
+* Nothing here is fatal. The project is complete and valid before this runs,
+* so a missing `git`, or the unconfigured `user.email` that a fresh CI image
+* has, warns and leaves the tree alone rather than discarding a scaffold that
+* took two minutes of Flutter and pub to produce.
+*/
+function initialiseRepository(root, name, run, reporter) {
+	try {
+		execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
+			cwd: root,
+			stdio: "ignore"
+		});
+		return "existing";
+	} catch {}
+	try {
+		run("git", ["init", "--quiet"], root);
+		run("git", ["add", "--all"], root);
+	} catch {
+		reporter.warn("Could not initialise a git repository. The project is complete. Run `git init` yourself when ready.");
+		return "failed";
+	}
+	try {
+		run("git", [
+			"commit",
+			"--quiet",
+			"--message",
+			`Scaffold ${name}`
+		], root);
+	} catch {
+		reporter.warn(`Initialised a repository and staged the scaffold, but could not commit it. Set \`user.name\` and \`user.email\`, then \`git commit -m "Scaffold ${name}"\`.`);
+		return "failed";
+	}
+	return "committed";
+}
+function scaffoldGame(options) {
+	const root = resolve(options.directory);
+	const name = gameSlug(basename(root));
+	const manager = options.packageManager ?? detectPackageManager() ?? "pnpm";
+	const org = options.org?.trim() || "com.example";
+	const packageId = applicationId(root, org);
+	const bootstrap = options.bootstrap ?? true;
+	const reporter = options.reporter ?? plainReporter;
+	const run = options.run ?? capturingRunner(reporter);
+	const occupied = destinationProblem(root);
+	if (occupied !== void 0) throw new Error(occupied);
+	if (existsSync(root)) rmdirSync(root);
+	mkdirSync(dirname(root), { recursive: true });
+	const stagingRoot = mkdtempSync(resolve(dirname(root), `.${basename(root)}-`));
+	try {
+		const serverRoot = resolve(stagingRoot, "server");
+		const appRoot = resolve(stagingRoot, "app");
+		renderTree(resolve(templatesRoot, "worker"), serverRoot, name, manager, packageId);
+		renderTree(resolve(templatesRoot, "project"), stagingRoot, name, manager, packageId);
+		if (options.ci) renderTree(resolve(templatesRoot, "ci"), stagingRoot, name, manager, packageId);
+		if (bootstrap) reporter.step("Creating the Flutter app", () => {
+			run("flutter", [
+				"create",
+				"--empty",
+				"--platforms",
+				"android,web",
+				"--project-name",
+				dartName(name),
+				"--org",
+				org,
+				appRoot
+			], stagingRoot);
+			enableAndroidCoreLibraryDesugaring(appRoot);
+			enableAndroidReleaseSigning(appRoot);
+		});
+		else mkdirSync(appRoot, { recursive: true });
+		renderTree(resolve(templatesRoot, "app-overlay"), appRoot, name, manager, packageId);
+		if (bootstrap) {
+			reporter.step("Adding the Flutter packages", () => {
+				configureLauncherIconsAndSplash(appRoot);
+				run("flutter", [
+					"pub",
+					"add",
+					`eigen_flutter@${flutterClientVersion}`,
+					`eigen_firebase@${firebaseAdapterVersion}`,
+					"firebase_core@^4.9.0"
+				], appRoot);
+				run("flutter", [
+					"pub",
+					"add",
+					`dev:eigen_codegen@${dartCodegenVersion}`,
+					"dev:flutter_launcher_icons",
+					"dev:flutter_native_splash"
+				], appRoot);
+			});
+			reporter.step("Generating the icons and splash", () => {
+				run("dart", ["run", "flutter_launcher_icons"], appRoot);
+				run("dart", ["run", "flutter_native_splash:create"], appRoot);
+			});
+			const [install, installArgs] = packageCommand(manager, "install");
+			const [typegen, typegenArgs] = packageCommand(manager, "cf-typegen");
+			reporter.step("Installing the Worker packages", () => {
+				run(install, installArgs, serverRoot);
+				run(typegen, typegenArgs, serverRoot);
+				run(install, installArgs, stagingRoot);
+			});
+			const [contract, contractArgs] = packageCommand(manager, "contract");
+			reporter.step("Generating the contract and payloads", () => {
+				run(contract, contractArgs, serverRoot);
+				run("dart", [
+					"run",
+					"eigen_codegen:generate_payloads",
+					"--contract",
+					"../server/game-contract.json",
+					"--output",
+					"lib/game/generated/payloads.dart",
+					"--fixtures-output",
+					"test/fixtures"
+				], appRoot);
+			});
+		}
+		renameSync(stagingRoot, root);
+	} catch (error) {
+		rmSync(stagingRoot, {
+			recursive: true,
+			force: true
+		});
+		throw error;
+	}
+	const firebase = options.firebase ? configureFirebase(resolve(root, "app"), options.firebase, run, reporter) : "skipped";
+	const link = firebase === "configured" ? readFirebaseLink(root) : void 0;
+	return {
+		root,
+		name,
+		git: options.git ?? bootstrap ? initialiseRepository(root, name, run, reporter) : "skipped",
+		firebase,
+		link
+	};
+}
+//#endregion
+export { destinationProblem as a, insideWorkTree as c, scaffoldGame as d, decodeUtf8 as i, normaliseTerminalWidth as l, applicationId as n, detectPackageManager as o, capturingRunner as r, firebaseReadiness as s, addContinuousIntegration as t, plainReporter as u };
+
+//# sourceMappingURL=src-q9BxESYC.js.map