Scaffold flows — verified generator reference

Last verified: 2026-07-10. Every adapter change must re-verify its section against upstream and update this date, the facts, and the sources. This document is the ground truth groot's adapters are written against.

Drift is watched automatically: e2e.yml re-runs the real generators weekly (behavior), and drift.yml re-checks every pinned series and this document's age (pins & docs) — see the maintainer runbook.

Version snapshot at verification: create-turbo 2.10.4 · Next.js 16.2.10 · sv 0.16.2 (SvelteKit 2.63 / Svelte 5.56 / Vite 8) · create-expo-app 4.0.0 (Expo SDK 57) · elysia 1.4.29 · create-hono 0.19.4 (hono 4.12.28) · convex 1.42.1.

Summary matrix

1. Turborepo trunk — create-turbo

bunx create-turbo@2 my-repo -m bun --skip-install --no-git

• Flags (from CLI source): -m/--package-manager <npm|yarn|pnpm|bun>, --skip-install, --no-git, --skip-transforms, --turbo-version <v>, -e/--example <name|github-url>, -p/--example-path.
• ⚠️ --skip-transforms conflicts with -m (transforms are what convert the pnpm-flavored example to bun). Never combine.
• Generates (basic example): apps/web + apps/docs (Next.js), packages/ui, packages/eslint-config, packages/typescript-config, root turbo.json (v2 "tasks" key), root package.json. The bun transform replaces pnpm-workspace.yaml with a root workspaces array + packageManager: "bun@…".
• Git init runs last (after transforms/install) so suppression is clean.
• groot post-patch: remove the example apps/web, apps/docs, packages/ui, packages/eslint-config (groot's selected scaffolds replace them; packages/typescript-config is kept and extended), reset root README, write groot.json.
• Sources: https://github.com/vercel/turborepo/blob/main/packages/create-turbo/src/cli.ts, https://github.com/vercel/turborepo/tree/main/examples/basic, https://turborepo.com/docs/reference/configuration.

2. Web: Next.js — create-next-app

bunx create-next-app@16 apps/web \
  --ts --tailwind --eslint --app --src-dir --turbopack \
  --import-alias "@/*" --use-bun --skip-install --disable-git --yes

• Current flag set (v16.2): --ts/--js, --tailwind (negate --no-tailwind), linter trio --eslint | --biome | --no-linter (the old --no-eslint world is gone), --react-compiler, --app, --api (route-handlers-only), --src-dir/--no-src-dir, --turbopack (default on), --import-alias <alias>, --empty, --use-bun (et al.), -e/--example, --skip-install, --disable-git, --yes, --reset-preferences, --agents-md/--no-agents-md (AGENTS.md + CLAUDE.md, default on).
• ⚠️ --yes reuses saved user preferences — CI/agents must pass every flag explicitly (groot does).
• Refuses non-empty target dirs; skips git init when already inside a git repo (groot passes --disable-git anyway).
• Generates app/ router + Tailwind v4 (postcss.config.mjs), next.config.ts, tsconfig.json, own .gitignore, AGENTS.md/CLAUDE.md.
• groot post-patch: rewire tsconfig.json to extend @repo/typescript-config/nextjs.json, keep port 3000, remove per-app lockfile if any, fold .gitignore.
• Sources: https://nextjs.org/docs/app/api-reference/cli/create-next-app, https://github.com/vercel/next.js/blob/canary/packages/create-next-app/index.ts, https://github.com/vercel/next.js/blob/canary/packages/create-next-app/helpers/git.ts.

3. Web: SvelteKit — sv create

create-svelte is deprecated; sv is the official CLI (merged create-svelte + svelte-add).

bunx sv@0.16 create apps/web --template minimal --types ts --no-add-ons --no-install --no-dir-check

• Flags: --template <minimal|demo|library>, --types <ts|jsdoc> (or --no-types, not recommended), --add <add-ons…> / --no-add-ons, --install <npm|pnpm|yarn|bun|deno> / --no-install, --no-dir-check, --from-playground <url>.
• Never git-inits. Writes its own .gitignore and .npmrc.
• ⚠️ The generated prepare script (svelte-kit sync || echo '') fires during root bun install — harmless, but expect it in install output.
• Generates: src/{app.html,app.d.ts,lib/,routes/}, vite.config.ts, tsconfig.json. Deps: @sveltejs/kit ^2.63, svelte ^5.56, vite ^8, @sveltejs/adapter-auto ^7.
• ⚠️ No svelte.config.js (verified 2026-07-10 against sv 0.16.2 output): SvelteKit config now lives inside vite.config.ts as sveltekit({ adapter, compilerOptions }) plugin options — adapters and doctor checks must look there.
• groot post-patch: add check / check-types scripts (mirroring Turborepo's with-svelte example), keep Vite port 5173, fold .gitignore/.npmrc.
• Sources: https://svelte.dev/docs/cli/sv-create, https://www.npmjs.com/package/sv, https://www.npmjs.com/package/create-svelte (deprecation notice), https://github.com/vercel/turborepo/tree/main/examples/with-svelte.

4. Mobile: Expo — create-expo-app

bunx create-expo-app@4 apps/mobile --template default@sdk-57 --no-install --yes

• Flags: --yes, --no-install, --template <name>[@<tag>], --example <name>, --no-agents-md, --version. Templates: default (Expo Router + TS — groot's choice), blank, blank-typescript, tabs, bare-minimum.
• ⚠️ SDK transition gotcha: during the SDK 57 transition, omitting --template yields an SDK 54 project. groot always pins the template tag explicitly (default@sdk-57).
• ⚠️ No git-suppression flag exists. create-expo-app git-inits its output whenever it doesn't detect an enclosing repo — and during groot init the root repo doesn't exist yet (root git init runs in the verify stage, after generation), so a nested apps/mobile/.git appeared every time (fixed in v1.0.1). The engine now scrubs any generator-created .git immediately after each scaffold grows (architecture.md#3-generate); the doctor check remains as a tripwire for workspaces grown earlier.
• Monorepos: Expo has first-class bun-workspaces support; since SDK 52 Metro auto-configures for monorepos — do not write legacy metro.config.js workspace hacks (watchFolders, nodeModulesPath…). Shared packages consumed as "<pkg>": "*".
• Metro dev server port: 8081 (kept).
• Sources: https://docs.expo.dev/more/create-expo/, https://docs.expo.dev/guides/monorepos/, https://www.npmjs.com/package/expo.

5. API: Elysia — files written directly (no generator)

bun create elysia resolves to the npm package create-elysia, which is community-owned (not an elysiajs org package), interactive-prompt-based, and diverges from Elysia's own docs (its template lacks the documented dev script). groot therefore writes the four files from Elysia's official manual setup:

apps/api/
├── src/index.ts       # new Elysia().get("/", …).listen(3001)  ← port patched from default 3000
├── package.json       # dev: bun --watch src/index.ts · build: bun build … · start · test: bun test
├── tsconfig.json      # strict: true
└── README.md

Deps: elysia@^1.4 + @types/bun. Scripts per Elysia's docs: dev: bun --watch src/index.ts, build: bun build src/index.ts --target bun --outdir ./dist, start: NODE_ENV=production bun dist/index.js, test: bun test.

• Sources: https://elysiajs.com/quick-start.html, https://www.npmjs.com/package/create-elysia (ownership), https://bun.com/docs/runtime/templating/create (bun create x ≡ bunx create-x).

6. API: Hono — create-hono

bunx create-hono@0.19 apps/api --template bun --pm bun

• Flags: -t/--template <bun|nodejs|cloudflare-workers|…>, -i/--install (install is opt-in), -p/--pm <bun|…>, -o/--offline (giget cache).
• ⚠️ The install confirmation has no negative flag (verified 2026-07-10 on 0.19.4): without -i, create-hono still prompts "Do you want to install project dependencies?", and an unanswered prompt (closed stdin) aborts the entire scaffold with "User force closed the prompt" — no files written. groot pre-answers n via stdin.
• Templates are fetched from honojs/starter pinned to a tag matching create-hono's own major.minor — deterministic per CLI version. Sets package.json#name to the directory basename.
• Never git-inits. ⚠️ Non-empty target → interactive confirm with no bypass flag — groot must always target a freshly created directory.
• Generates: src/index.ts (export default app), package.json (dev: bun run --hot src/index.ts, hono ^4.12), tsconfig.json.
• groot post-patch: Bun serves default-export apps on port 3000 → rewrite to export default { port: 3001, fetch: app.fetch }; add build/start scripts mirroring the Elysia layout.
• Sources: https://github.com/honojs/create-hono, https://github.com/honojs/starter/tree/main/templates/bun.

7. Backend: Convex — files written directly, _generated stubs vendored

No fully-offline official generator exists (create-convex is a degit template copier oriented at full-stack presets). groot writes packages/backend directly, modeled on Convex's own reference monorepo (get-convex/turbo-expo-nextjs-clerk-convex-monorepo):

packages/backend/
├── convex/
│   ├── schema.ts          # starter schema (messages table)
│   ├── messages.ts        # starter query + mutation matching the schema
│   ├── tsconfig.json      # vendored from get-convex/templates
│   └── _generated/        # vendored standard stubs — COMMITTED (official recommendation)
├── package.json           # @repo/backend · dev: convex dev · setup: convex dev --until-success · typecheck
└── .env.example           # CONVEX_DEPLOYMENT / CONVEX_URL placeholders

• ⚠️ convex codegen is NOT offline-usable in current releases (verified 2026-07-10 on convex 1.42.1): bunx convex codegen --init in a fresh package fails with "No CONVEX_DEPLOYMENT set, run npx convex dev to configure a Convex project". The older maintainer statements about credential-free codegen (get-convex/convex-js#81) no longer hold for new projects.
• groot copies the official templates' strategy instead: get-convex/templates ships the standard convex/_generated stubs (api.d.ts, api.js, dataModel.d.ts, server.d.ts, server.js) checked in, so the package typechecks before any login. groot vendors those stubs (src/adapters/convex-generated-stubs.ts, api.d.ts adapted to the starter messages.ts module); the first convex dev run regenerates them against the live deployment.
• ⚠️ The vendored convex/tsconfig.json declares "types": ["node"] — the generated package.json must therefore carry @types/node (pin tracks the upstream template), or convex dev's built-in typecheck fails with TS2688. Caught in a live v0.2.0 run; the E2E now typechecks scaffolded packages, not just installs them.
• ⚠️ Known upstream quirk (verified 2026-07-10, cosmetic): convex dev's optional "Set up Convex AI files?" step installs agent skills via npx, which trips npm's devEngines guard inside the bun-declared workspace (EBADDEVENGINES: required { name: 'bun' }). The guard is working as intended; Convex prints a manual retry command and continues — deployment provisioning and .env.local are unaffected.
• The one unavoidable interactive step — bunx convex dev --until-success (login, deployment provisioning, .env.local) — is never run by groot; it's printed as the first "next step".
• Consumption pattern: apps depend on "@repo/backend": "workspace:*" and deep-import @repo/backend/convex/_generated/api (no exports map — deliberate, matching the reference repo). Frontends receive the Convex URL via .env plumbing, named per framework: NEXT_PUBLIC_CONVEX_URL (Next), PUBLIC_CONVEX_URL (SvelteKit, Astro), VITE_CONVEX_URL (TanStack Start, React Router, Vite), NUXT_PUBLIC_CONVEX_URL (Nuxt), EXPO_PUBLIC_CONVEX_URL (Expo), CONVEX_URL (bare React Native — no public-env mechanism, left to the user's env lib).
• Sources: https://docs.convex.dev/cli/reference/codegen, https://docs.convex.dev/cli, https://github.com/get-convex/templates (stub strategy), https://github.com/get-convex/turbo-expo-nextjs-clerk-convex-monorepo, https://docs.convex.dev/production/project-configuration.

8. Desktop: Tauri — create-tauri-app

bunx create-tauri-app@4 desktop --template react-ts --manager bun --identifier com.<workspace>.desktop --yes

• Flags: -t/--template (react-ts pinned — TS + React frontend), -m/--manager (bun is a first-class option), --identifier (reverse-domain bundle id; the CLI warns on its com.tauri.dev default, so groot derives one from the workspace name), -y/--yes (skip remaining prompts), -f/--force, --tauri-version. Never installs, never git-inits.
• ⚠️ The positional is a NAME, not a path — the generator derives the app and crate names from it. groot therefore spawns from the scaffold's parent directory (apps/) with the bare directory name, instead of passing apps/desktop from the workspace root.
• Port 1420 is the template's own contract: the generated vite.config pins server.port: 1420 with strictPort: true, and src-tauri/tauri.conf.json points build.devUrl at the same port. Unique in groot's matrix → kept, no rewrite.
• Rust is a dev-time dependency, not a scaffold-time one: generation is pure npm; bun install works without cargo. tauri dev/tauri build need Rust (plus webkit2gtk on Linux) — groot prints a rustup next-step and doctor warns (never fails) when cargo is absent.
• Wrap-the-existing-web-app mode (bunx @tauri-apps/cli init --ci pointed at apps/web) is a distinct, officially supported shape — deferred to the add-on engine (expansion.md, roadmap v1.4).
• Sources: https://v2.tauri.app/start/create-project/, https://v2.tauri.app/reference/cli/, https://github.com/tauri-apps/create-tauri-app.

9. Desktop: Electron — @quick-start/create-electron (electron-vite)

bunx @quick-start/create-electron@1 desktop --template react-ts --skip

• Why this generator: electron-vite's scaffolder is the de-facto standard for Electron + Vite + TS. Electron Forge's own create-electron-app force-installs dependencies (npm/yarn only, no skip flag) and marks its Vite template experimental — unsuitable for groot's scaffold-dry model (expansion.md).
• Flags: -t/--template (react-ts pinned; the -ts suffix nulls the TypeScript prompt) and --skip (nulls the remaining prompts: overwrite, auto-update, mirror). Never installs, never git-inits — prints next steps only.
• ⚠️ The positional is a NAME, not a path — same contract as create-tauri-app: groot spawns from the scaffold's parent directory (apps/) with the bare directory name.
• No declared dev port: the renderer dev server is plain Vite (non-strict) and electron-vite launches Electron with whatever URL it resolved — self-wiring, so groot neither promises nor manages a port (unlike Tauri's contractual strictPort 1420).
• ⚠️ Bun lifecycle nuance (verified 2026-07-12, bun 1.3.14): the electron package downloads its runtime binary in a postinstall script, and bun only runs dependency lifecycle scripts for trusted packages — electron is NOT on bun's default-trusted list (the flagship E2E's real bun install proved it: runtime missing without a grant). The stitch stage writes trustedDependencies: ["electron"] into the workspace root package.json before verify's install — empirically honored for workspace-member dependencies — and verify keeps a bun pm trust electron fallback for degraded workspaces. Note bun treats an explicit trustedDependencies as replacing its default allowlist; packages a user later adds that need postinstalls belong in the same array.
• ⚠️ Bun 1.3 isolated-layout nuance: packages live in the node_modules/.bun store with symlinks in the declaring workspace member — there is no top-level node_modules/electron. Anything checking electron's install state must resolve from the app directory (groot's doctor/verify use node resolution from apps/desktop), not from a hardcoded root path.
• Build output: out/ (main/preload/renderer) — added to turbo's build.outputs; electron-builder's installers land in dist/ (not cached).
• Sources: https://electron-vite.org/guide/, https://www.npmjs.com/package/@quick-start/create-electron, https://bun.com/docs/pm/lifecycle.

10. Web: TanStack Start — @tanstack/cli (tanstack create)

bunx @tanstack/cli@0.69 create web --framework React --package-manager bun --no-git --no-install --no-examples --no-toolchain --no-intent --yes

• Flags (verified 2026-07-12 against the published 0.69.5 source): --framework <React|Solid> (display names from the framework definitions), --package-manager bun (first-class value), --no-git, --no-install, --no-examples (skip demo pages), --no-toolchain (skip the eslint/biome overlay — the workspace root owns linting), --no-intent (skip TanStack Intent agent files; groot's own agent artifacts arrive with roadmap v1.3), -y/--yes (accept remaining defaults), plus --target-dir, -f/--force, --json, --add-ons. The deprecated --tailwind/--no-tailwind are compatibility no-ops — Tailwind is always enabled.
• ⚠️ The positional is a NAME, not a path — same contract as create-tauri-app/create-electron: groot spawns from the scaffold's parent with the bare directory name.
• Port 3000 lives in the dev script ("dev": "vite dev --port 3000" in the template's package.json), not in vite.config — same default as Next.js. Single-web workspaces are clean; groot add tanstack-start --path apps/<name> next to a Next app trips the standard port-collision warning, and doctor tracks the dev-script/manifest agreement.
• Build is plain vite build → dist/ — the 1.x template has no Nitro/Vinxi (verified: no such deps in the template package.json); dist/** is already in turbo's outputs.
• Template ships TS-first (typescript ^6, vite ^8, react 19), Tailwind, file-based routing with the Start plugin; the scaffolded package.json name field is empty — stitch names it from the directory.
• The CLI is 0.x and fast-moving — pinned to the minor (@tanstack/cli@0.69), the sv@0.16 precedent; the drift watch tracks the series automatically.
• Sources: https://tanstack.com/start/latest/docs/framework/react/quick-start, https://www.npmjs.com/package/@tanstack/cli (dist/cli.js option table), https://www.npmjs.com/package/@tanstack/create (react framework template).

11. Web: Astro — create-astro

bunx create-astro@5 web --template minimal --no-install --no-git --no-ai --skip-houston --yes

• Flags (verified 2026-07-12 against the published 5.2.2 source): --template <name|gh-repo>, --ref, --install/--no-install, --git/--no-git, --no-ai (skip AI agent config files — groot's own agent artifacts arrive with roadmap v1.3), --skip-houston (skip the mascot animation), -y/--yes, -n/--no, --dry-run, --add, --fancy. Node >= 22.12 required by the package.
• ⚠️ Non-empty-target gotcha (verified in source): with --yes, a non-empty target directory is silently ignored — create-astro scaffolds into a randomly generated project name instead (generateProjectName()). groot's generate stage guarantees a fresh destination, which makes this unreachable — but never invoke this generator outside that guarantee. (A dir containing only .git/.gitignore-class entries counts as empty per its safe list.)
• The positional doubles as the project-name source — bare names pass toValidName untouched; a path like apps/web would become the package name apps-web. groot spawns from the scaffold's parent with the bare basename.
• Templates are fetched via giget from the withastro/astro examples at scaffold time (network to GitHub, not npm); minimal is pinned. TS-strict by default in 5.x — the old --typescript flag no longer exists.
• Port 4321 is astro dev's built-in default (no config entry, no dev-script flag) — the only unique web port in the matrix; nothing to rewrite or drift-check.
• Build: astro build → dist/ (already in turbo's outputs).
• Sources: https://docs.astro.build/en/install-and-setup/, https://www.npmjs.com/package/create-astro (dist/index.js flag table + project-name action), https://docs.astro.build/en/guides/environment-variables/ (PUBLIC_ prefix).

12. Web: React Router (framework mode) — create-react-router

bunx create-react-router@8 web --package-manager bun --no-git-init --no-install --no-agent-skills --yes

• Flags (verified 2026-07-12 against the published 8.2.0 source): --yes, --git-init/--no-git-init, --install/--no-install, --package-manager <npm|pnpm|yarn|bun|deno>, --agent-skills/--no-agent-skills, --template <gh-url-or-shorthand>, --overwrite, --react-router-version/-v, --no-color, --no-motion, --show-install-output, --token, --debug.
• ⚠️ v8.2 added an agent-skills step: the CLI ships React Router's own SKILL.md + reference docs and offers to copy them into the project. groot passes --no-agent-skills — the same policy as TanStack's --no-intent and Astro's --no-ai: groot's own agent-era artifacts arrive with roadmap v1.3 and per-scaffold agent files would collide.
• The default template is fetched from GitHub at scaffold time (remix-run/react-router-templates/tree/main/default): TS + Tailwind + SSR, plus a Dockerfile (kept as-is). In non-TTY runs the CLI auto-forces --yes; pre-existing file collisions hard-fail without --overwrite — groot's fresh-destination guarantee makes that unreachable.
• The positional doubles as the project-name source (toValidProjectName, same shape as create-astro) — groot spawns from the scaffold's parent with the bare basename.
• Port 5173 is the Vite default (no dev-script flag, no config entry) — shared with SvelteKit; same-slot alternatives share ports (the elysia/hono precedent), and add --path coexistence rides the collision warning.
• Build: react-router build → build/ (client + server; the template's serve script points at build/server/index.js) — added to turbo's outputs. Typecheck: react-router typegen && tsc.
• Sources: https://reactrouter.com/start/framework/installation, https://www.npmjs.com/package/create-react-router (dist/cli.js option table), https://github.com/remix-run/react-router-templates/tree/main/default.

13. Web: Nuxt — create-nuxt

bunx create-nuxt@3 web --template minimal --packageManager bun --no-gitInit --no-install --no-modules

• Flags (verified 2026-07-12 against the published 3.36.1 source — citty args): positional dir, -t/--template, --packageManager <npm|pnpm|yarn|bun|deno|aube>, --gitInit (boolean → --no-gitInit via citty negation), --install (default true → --no-install), -M/--modules (string, --no-modules skips the prompt), -f/--force, --offline, --preferOffline, --shell, --nightly, --logLevel.
• ⚠️ Non-interactive completeness is ENFORCED (verified in source): nonInteractiveRequiredArgs = [dir, template, packageManager, gitInit] — in a non-TTY shell, any of the four missing exits 2 with a usage report. groot passes all four explicitly; there is no --yes.
• The CLI's default template is minimal, fetched via giget from the nuxt/starter templates registry (raw.githubusercontent.com — network to GitHub at scaffold time). Package is create-nuxt 3.x even though Nuxt itself is v4.
• The template ships postinstall: nuxt prepare — it runs during the root bun install (workspace-member scripts always run under bun; this is not a blocked dependency lifecycle script).
• Port 3000 is nuxt dev's built-in default — shared with Next/TanStack per the same-slot rule.
• Build: nuxt build → .output/ (Nitro) — added to turbo's outputs. Convex env: NUXT_PUBLIC_CONVEX_URL (runtimeConfig.public via NUXT_PUBLIC_*).
• Sources: https://nuxt.com/docs/api/commands/init, https://www.npmjs.com/package/create-nuxt (dist/index.mjs citty args + nonInteractiveRequiredArgs), https://github.com/nuxt/starter.

14. Web: Vite — create-vite

bunx create-vite@9 web --template react-ts --no-interactive --no-immediate

• Flags (verified 2026-07-12 against the published 9.1.1 bundle): -t/--template, --interactive/--no-interactive (force mode), -i/--immediate/--no-immediate (⚠️ 9.x's --immediate installs dependencies AND starts the dev server — groot passes --no-immediate explicitly), --eslint/--no-eslint (React templates default to Oxlint in 9.x; groot keeps the default — the workspace root owns linting), --overwrite, -h/--help.
• Templates: vanilla-ts, vue-ts, react-ts (groot's pin), react-compiler-ts, solid-ts, svelte-ts, preact-ts, qwik-ts, lit-ts (+ JS variants). Watch renames across create-vite majors.
• The cleanest generator in the matrix: never installs, never git-inits, writes no lockfile; ships its gitignore as _gitignore, renamed on copy (verified in bundle).
• Port 5173 is the Vite default — shared with SvelteKit/React Router per the same-slot rule.
• Build: vite build → dist/ (already in turbo's outputs). Convex env: VITE_CONVEX_URL.
• Sources: https://vite.dev/guide/, https://www.npmjs.com/package/create-vite (dist/index.js option table + templates).

15. API: Fastify — fastify-cli generate

bunx fastify-cli@8 generate api --lang=ts --esm

• Fully non-interactive (verified 2026-07-13 in the published 8.0.0 bundle — generate.js, cli.js): no prompts, no install, no git init, no lockfile. The package ships a single bin named fastify (≠ package name) — bunx's single-bin fallback covers it, the same case @tanstack/cli → tanstack already proves in this matrix.
• Refuses existing directories (directory <dir> already exists, exit 1) and creates its own leaf dir — groot spawns from the scaffold's parent with the bare basename, the name-not-path pattern.
• ⚠️ Shells out to npm init -y inside the target (upstream behavior — the only generator in the matrix with a hard npm dependency at generate time; GitHub runners and dev machines with Node have it). That's also where the package name comes from: the directory basename. The template's scripts/deps are then merged into the resulting package.json.
• ⚠️ That npm call cannot run inside a groot workspace (caught live in e2e scenario 4, 2026-07-13): npm resolves its project root by walking up from cwd, finds the bun-declared workspace root (create-turbo's -m bun transform writes devEngines), and hard-fails with EBADDEVENGINES — the same guard scaffold-flows §7 documents for Convex's npx step, but fatal here. groot therefore runs this generator staged: generated in a disposable directory under the OS tempdir (neutral ancestry), then moved into apps/api — the trunk's temp-sibling pattern, generalized as ScaffoldAdapter.stagedGeneration. The same guard is why the stitched scripts must be bun-invoking: the template's own npm run … chains would trip it at runtime too.
• --lang=ts --esm pins the ESM TypeScript template (templates/app-ts-esm): an @fastify/autoload app plugin (src/app.ts, forceESM: true) with src/plugins/ + src/routes/ and a node:test suite. Ships __gitignore, renamed to .gitignore on copy (generify's __ → . convention, verified in generify 4.2.0). Its tsconfig sets outDir: dist, allowImportingTsExtensions + rewriteRelativeImportExtensions — so groot's server entry can import ./app.ts directly while tsc still emits clean JS.
• The template serves through the Node-centric fastify start wrapper — groot instead overlays src/server.ts (modeled on fastify-cli's own eject template: register the app plugin, listen on :3001) and the stitch stage swaps the scripts wholesale for the bun set: dev: bun --watch src/server.ts, start, build: tsc (→ dist/, turbo-cached), test: bun test, typecheck. The rewrite is marker-gated on the template's own dev script; hand-rolled scripts are never clobbered. Template devDependencies stay as-is (ts-node/c8/concurrently go unused under bun — harmless, and removing them would couple groot to template internals).
• @fastify/autoload ≥ 6 detects bun natively ('Bun' in globalThis, lib/runtime.js) and loads the .ts plugins/routes with no compile step or env var. Bun's node:test shim runs the template's test suite (test/t.after/node:assert verified locally on bun 1.3.14).
• Port 3001, shared with elysia/hono per the same-slot rule; the port lives in groot's src/server.ts (doctor watches the port: 3001 } marker there).
• Sources: https://github.com/fastify/fastify-cli (generate.js, args.js, templates/), https://www.npmjs.com/package/fastify-cli (published 8.0.0 bundle), https://github.com/fastify/fastify-autoload (lib/runtime.js bun detection).

16. Mobile: React Native (bare) — @react-native-community/cli init

bunx @react-native-community/cli@20 init mobile --pm bun --skip-install --install-pods false --skip-git-init --replace-directory false

• Fully non-interactive with these flags on a fresh target (verified 2026-07-13 in the published 20.2.0 bundle — commands/init/*.js): the positional is validated (/^[$A-Z_][0-9A-Z_$]*$/i, no java keywords, no "helloworld" — mobile passes), the react-native version and matching @react-native-community/template resolve via plain registry fetches, and with --pm bun the template installs via bun (bun init -y + bun add --exact) into the CLI's own tempdir before being copied into the target. Single bin rnc-cli (≠ package name) — bunx's single-bin fallback, same as @tanstack/cli and fastify-cli.
• ⚠️ The registry-URL lookup shells npm (npm config get registry --workspaces=false --include-workspace-root, tools/npm.js): inside a groot workspace that call hard-fails with EBADDEVENGINES (create-turbo's -m bun writes devEngines; reproduced 2026-07-13 — exit 1). The CLI's try/catch swallows it and falls back to the hardcoded default registry, so in-tree init survives by courtesy — groot runs it staged (ScaffoldAdapter.stagedGeneration) instead, which both dodges the guard and lets the user's real registry config apply.
• Placeholder pipeline (editTemplate.js): HelloWorld → project name (case-preserving + lowercase pass) across file contents and names; _gitignore/_watchmanconfig/_bundle/… → dotfiles (UNDERSCORED_DOTFILES). The android applicationId / iOS target become com.mobile / mobile — override with --package-name is available but groot keeps the default. package.json name lands as mobile, so the app-rename stitch is a no-op.
• Pods / SDKs stay out of generate: CocoaPods runs only on darwin AND only inside the (skipped) install step — --install-pods false is belt-and-braces; Xcode/CocoaPods/Android SDK are the user's build-time next steps, never groot's.
• Git: --skip-git-init; init also auto-skips when it detects an enclosing repo (git rev-parse on the project folder).
• Metro is not monorepo-aware in the bare template (unlike Expo ≥ SDK 52): the shipped metro.config.js is mergeConfig(getDefaultConfig(__dirname), {}) with a literal const config = {}; — groot's stitch rewrites that marker into watchFolders: [workspaceRoot] + resolver.nodeModulesPaths for the app and the workspace root, and the doctor watches the wiring persistently. Scripts stay untouched — they're package-manager-neutral (react-native start, jest).
• ⚠️ add --path basenames must satisfy the CLI's name rules (the veto runs at resolve time, before anything generates): JS-identifier shape — apps/rn-app has a dash and would crash init — plus no java keywords, react/react-native, or anything containing helloworld.
• Port 8081 is the Metro default, shared with Expo per the same-slot rule; add --path coexistence rides the port-collision warning (the issue's original "port shift" idea predates the same-slot precedent set by the web wave).
• Sources: https://github.com/react-native-community/cli (build/commands/init/*.js, build/tools/npm.js, build/tools/packageManager.js in the published 20.2.0 bundle), https://www.npmjs.com/package/@react-native-community/template (template.config.js, template/metro.config.js, 0.86.0), https://reactnative.dev/docs/metro.

17. Backend: Supabase — package shell + supabase init

bunx supabase@2 init   # postCommand, cwd = packages/backend (after groot's writeFiles)

• Non-interactive by default in 2.x (verified 2026-07-13 in the cli monorepo's Go sources AND by running the published 2.109.1 linux-x64 binary non-TTY): the old IDE prompts moved behind an opt-in --interactive flag that additionally requires a TTY (cmd/init.go), and init pins WORKDIR to . specifically to avoid walking up to a parent project. No install, no git init, no lockfile — it's a Go binary that shells nothing, so the EBADDEVENGINES staging class does not apply.
• Writes exactly supabase/config.toml into its cwd (no directory argument exists — hence the postCommand-inside-the-shell layout), plus supabase/.gitignore when an enclosing git repo exists (contained inside the scaffold either way — empirically: fresh dir → config only; git repo → both). Re-running errors with exit 1 (--force to overwrite); groot's fresh-dir planning never hits it.
• The npm wrapper is a 3-file shim that exec's a platform binary shipped as optionalDependencies (@supabase/cli-<platform>, 8 targets): no postinstall, so bun's lifecycle-script trust list (the electron lesson) is never involved. Single bin name matches the package name.
• project_id defaults to the cwd basename — "backend" for every groot workspace, but the field exists to "distinguish different Supabase projects on the same host" (Docker containers are named after it). The stitch renames it to the workspace name, anchored on the exact default line, triple-state like every template patch.
• groot's package shell (writeFiles, before init runs): package.json (@repo/backend, dev: supabase start · stop · typegen · typecheck; the CLI pinned as a devDependency), a database.types.ts placeholder matching gen types output for an empty schema (the Convex vendored-stubs pattern — apps deep-importing @repo/backend/database.types typecheck before Docker ever runs), tsconfig, README, .env.example (values left empty — supabase start prints them; no keys are ever vendored).
• Docker, login, and real codegen stay out of generate: supabase start (local stack), supabase login / link (cloud), and bun run typegen are next-steps output — the Convex login pattern.
• Env plumbing: two lines per frontend, <prefix>SUPABASE_URL= + <prefix>SUPABASE_ANON_KEY=, prefixed per framework exactly like the Convex names (§7); bare React Native gets the unprefixed pair.
• Sources: https://github.com/supabase/cli (apps/cli-go/cmd/init.go, apps/cli-go/internal/init/init.go), https://www.npmjs.com/package/supabase (published 2.109.1 shim + optionalDependencies), plus a live run of the 2.109.1 binary (fresh dir / git repo / re-run / --force).

Stitching reference

The canonical "what does stitched output look like" spec is the diff between raw generator output and the same app inside Turborepo's official examples (basic, with-svelte, kitchen-sink): package renames, @repo/* deps with workspace:*, shared typescript-config extends, per-app ports in dev scripts, no nested lockfiles. See architecture.md for the full operation list.

Prior-art notes (why groot works this way)

• create-better-t-stack: vendored Handlebars templates + near-daily releases to fight drift. groot copies its automation contract (--yes, --dry-run, explicit dir-conflict policy, JSON plan output) but not its template strategy.
• create-t3-turbo: a template repo consumed via create-turbo -e — already trailing upstream majors at verification time; demonstrates template rot.
• Both confirm: generators' monorepo-hostile side effects (git init, auto-install, nested lockfiles, port collisions) are the real problem groot's stitch stage solves.