@rshono/create 1.0.0-rc.0

package/dist/api.mjs

@@ -0,0 +1,749 @@
+// Bundled by rspack — edit src/ and rebuild. Includes @clack/prompts (MIT).
+import {fileURLToPath as __rspack_fileURLToPath} from "node:url";
+import {dirname as __rspack_dirname} from "node:path";
+var __rspack_import_meta_dirname__ = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { dirname, join, posix, sep } from "node:path";
+import "node:child_process";
+// The require scope
+var __webpack_require__ = {};
+
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, getters, values) => {
+	var define = (defs, kind) => {
+		for(var key in defs) {
+			if(__webpack_require__.o(defs, key) && !__webpack_require__.o(exports, key)) {
+				Object.defineProperty(exports, key, { enumerable: true, [kind]: defs[key] });
+			}
+		}
+	};
+	define(getters, "get");
+	define(values, "value");
+};
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+var __webpack_exports__ = {};
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  bp: () => (/* reexport */ DEPLOY_TARGET_NAMES),
+  e7: () => (/* reexport */ FRAMEWORK_DEPS),
+  Ab: () => (/* reexport */ PACKAGE_MANAGERS),
+  pm: () => (/* reexport */ QUALITY_PRESETS),
+  s_: () => (/* reexport */ RSHONO_RANGE),
+  RM: () => (/* reexport */ TOOL_VERSIONS),
+  Jh: () => (/* reexport */ buildPackageJson),
+  P8: () => (/* reexport */ deployHint),
+  Lv: () => (/* reexport */ detectPackageManager),
+  WL: () => (/* reexport */ inspectTarget),
+  p1: () => (/* reexport */ isDeployTarget),
+  eW: () => (/* reexport */ isValidPackageName),
+  ml: () => (/* reexport */ packageManager),
+  et: () => (/* reexport */ plan_plan),
+  N7: () => (/* reexport */ selectFeatures),
+  PQ: () => (/* reexport */ toPackageName),
+  pD: () => (/* reexport */ writePlan)
+});
+
+;// CONCATENATED MODULE: ./src/features/combinations.ts
+/**
+ * Biome's CSS parser rejects Tailwind's syntax — `@apply` and a `@layer` block are parse errors, not
+ * unknown-at-rule warnings — so a project with both needs Biome pointed away from stylesheets. The
+ * overlay is a second `biome.json` listed after the first, which is all "later overlay wins" means.
+ *
+ * Narrow on purpose: the alternative was excluding CSS for everybody, which would quietly give up
+ * formatting the plain-CSS template that Biome handles perfectly well.
+ */ const BIOME_TAILWIND = {
+    id: 'biome-tailwind',
+    overlays: [
+        'biome-tailwind'
+    ]
+};
+/**
+ * Features that exist because of how two answers *combine*, rather than because of either one alone.
+ * Applied after the per-axis features, so an overlay here has the last word on a file.
+ *
+ * Keep this list short. A combination that needs more than a file swap is usually a sign that the two
+ * options should not both be offered.
+ */ function combinationFeatures(answers) {
+    const usesBiome = answers.formatter === 'biome' || answers.linter === 'biome';
+    return usesBiome && answers.styling === 'tailwind' ? [
+        BIOME_TAILWIND
+    ] : [];
+}
+
+;// CONCATENATED MODULE: ./src/generated/framework.ts
+// GENERATED by scripts/codegen.mjs from packages/core — do not edit. Run `pnpm --filter @rshono/create codegen`.
+/** The framework release a scaffolded app is pinned to: this package and rshono ship together. */ const RSHONO_VERSION = '1.0.0-rc.0';
+/**
+ * The dependency versions rshono is tested against, copied from its own manifest. Exact where it is
+ * exact — React's RSC internals are coupled across builds, and a generated app has no workspace
+ * overrides to fall back on.
+ */ const FRAMEWORK_DEPS = {
+    hono: '^4.12.31',
+    react: '19.2.8',
+    'react-dom': '19.2.8',
+    typescript: '^7.0.2',
+    '@types/node': '^26.1.1',
+    '@types/react': '^19.2.17'
+};
+/** Every `deploy` target the installed framework knows, with the command that ships what it built. */ const DEPLOY_TARGETS = [
+    {
+        name: 'node',
+        hint: 'run `rshono start`'
+    },
+    {
+        name: 'cloudflare',
+        hint: 'deploy with `wrangler deploy`'
+    },
+    {
+        name: 'bun',
+        hint: 'run `bun dist/server/main.mjs`'
+    },
+    {
+        name: 'deno',
+        hint: 'run `deno serve -A dist/server/main.mjs`'
+    },
+    {
+        name: 'vercel',
+        hint: 'deploy with `vercel deploy --prebuilt`'
+    },
+    {
+        name: 'netlify',
+        hint: 'deploy with `netlify deploy --build=false --dir=.netlify/publish`'
+    },
+    {
+        name: 'aws-lambda',
+        hint: 'zip dist/ with the handler at dist/server/main.mjs'
+    }
+];
+
+;// CONCATENATED MODULE: ./src/versions.ts
+
+
+/** The framework range a scaffolded app gets. The two packages are released together, so this is ours. */ const RSHONO_RANGE = `^${RSHONO_VERSION}`;
+/**
+ * Versions for the optional tooling the features can add — the one place in this package where a
+ * dependency range is typed out by hand, because none of these are things the framework itself
+ * declares. Everything a *scaffolded app* needs to run rshono comes from {@link FRAMEWORK_DEPS},
+ * which is generated from rshono's own manifest and must not be edited here.
+ *
+ * Ranges are caret, not exact: these are the app's own dev tools, and a scaffold made six months from
+ * now should pick up their patch releases rather than pinning whatever was current the day this file
+ * was last touched.
+ */ const TOOL_VERSIONS = {
+    tailwindcss: '^4.3.3',
+    '@tailwindcss/postcss': '^4.3.3',
+    // The pass Tailwind runs in, installed with it rather than with the framework.
+    postcss: '^8.5.23',
+    'postcss-loader': '^8.2.1',
+    prettier: '^3.9.6',
+    '@biomejs/biome': '^2.5.6',
+    oxlint: '^1.76.0',
+    oxfmt: '^0.61.0',
+    wrangler: '^4.115.0'
+};
+
+;// CONCATENATED MODULE: ./src/features/deploy.ts
+
+/**
+ * What a deploy target adds beyond the `deploy` line in `rshono.config.ts` — which is the build's job
+ * to read, and the template's to carry.
+ *
+ * Deliberately thin. The framework already knows how to arrange its own output for every platform, and
+ * `rshono build` writes the one platform config that has to exist (`wrangler.jsonc`, with the
+ * `compatibility_date` of the day it ran) if the project has none. Generating a second copy here would
+ * be a copy that goes stale. So a target contributes a `deploy` script, the CLI it needs locally, and
+ * the build artefacts its platform leaves in the project.
+ */ const DEPLOY_FEATURES = {
+    // Where a Node build goes from here is a Dockerfile or a process manager, neither of which this can
+    // guess — so the target contributes only the command that runs what was built.
+    node: {
+        id: 'deploy-node',
+        scripts: {
+            start: 'rshono start'
+        }
+    },
+    // `rshono start` is the Node target's launcher and refuses a build made for another platform, so
+    // these two get the command their own runtime uses under the same script name.
+    bun: {
+        id: 'deploy-bun',
+        scripts: {
+            start: 'bun dist/server/main.mjs'
+        }
+    },
+    deno: {
+        id: 'deploy-deno',
+        scripts: {
+            start: 'deno serve -A dist/server/main.mjs'
+        }
+    },
+    cloudflare: {
+        id: 'deploy-cloudflare',
+        devDependencies: {
+            wrangler: TOOL_VERSIONS.wrangler
+        },
+        scripts: {
+            deploy: 'rshono build && wrangler deploy'
+        },
+        gitignore: [
+            '.wrangler/'
+        ],
+        notes: [
+            'The first build writes wrangler.jsonc — yours to edit after that.'
+        ]
+    },
+    vercel: {
+        id: 'deploy-vercel',
+        scripts: {
+            deploy: 'rshono build && vercel deploy --prebuilt'
+        },
+        gitignore: [
+            '.vercel/'
+        ],
+        notes: [
+            '--prebuilt uploads what rshono build assembled; the platform must not rebuild it.'
+        ]
+    },
+    netlify: {
+        id: 'deploy-netlify',
+        scripts: {
+            deploy: 'rshono build && netlify deploy --build=false --dir=.netlify/publish'
+        },
+        gitignore: [
+            '.netlify/'
+        ]
+    },
+    'aws-lambda': {
+        id: 'deploy-aws-lambda',
+        notes: [
+            'Use a Function URL in RESPONSE_STREAM mode — a buffered invoke mode drops the streaming.'
+        ]
+    }
+};
+function deployFeature(target) {
+    return DEPLOY_FEATURES[target];
+}
+
+;// CONCATENATED MODULE: ./src/features/quality.ts
+
+/**
+ * The formatter and linter features. Biome answers to both slots and appears once — `selectFeatures`
+ * deduplicates by `id`, so `formatter: 'biome', linter: 'biome'` contributes one set of files, one
+ * dependency and one pair of scripts.
+ *
+ * Each tool brings its own `check` script alongside `format`/`lint`, because the writing half and the
+ * CI half want different exit-code behaviour: `format` rewrites files, `check` fails instead.
+ */ const PRETTIER = {
+    id: 'prettier',
+    overlays: [
+        'prettier'
+    ],
+    devDependencies: {
+        prettier: TOOL_VERSIONS.prettier
+    },
+    scripts: {
+        format: 'prettier --write .',
+        'format:check': 'prettier --check .'
+    }
+};
+const OXFMT = {
+    id: 'oxfmt',
+    overlays: [
+        'oxfmt'
+    ],
+    devDependencies: {
+        oxfmt: TOOL_VERSIONS.oxfmt
+    },
+    scripts: {
+        format: 'oxfmt .',
+        'format:check': 'oxfmt --check .'
+    }
+};
+const OXLINT = {
+    id: 'oxlint',
+    overlays: [
+        'oxlint'
+    ],
+    devDependencies: {
+        oxlint: TOOL_VERSIONS.oxlint
+    },
+    scripts: {
+        lint: 'oxlint',
+        'lint:fix': 'oxlint --fix'
+    }
+};
+const BIOME = {
+    id: 'biome',
+    overlays: [
+        'biome'
+    ],
+    devDependencies: {
+        '@biomejs/biome': TOOL_VERSIONS["@biomejs/biome"]
+    },
+    scripts: {
+        format: 'biome format --write .',
+        'format:check': 'biome format .',
+        lint: 'biome lint .',
+        'lint:fix': 'biome lint --write .',
+        check: 'biome check .'
+    }
+};
+const FORMATTERS = {
+    prettier: PRETTIER,
+    oxfmt: OXFMT,
+    biome: BIOME,
+    none: null
+};
+const LINTERS = {
+    oxlint: OXLINT,
+    biome: BIOME,
+    none: null
+};
+function formatterFeature(formatter) {
+    return FORMATTERS[formatter];
+}
+function linterFeature(linter) {
+    return LINTERS[linter];
+}
+
+;// CONCATENATED MODULE: ./src/features/styling.ts
+
+/**
+ * Tailwind is a PostCSS plugin and nothing more, which is the whole of this feature: four packages, and
+ * an overlay carrying the `postcss.config.mjs` naming the plugin, an `rshono.config.ts` whose `rspack`
+ * hook puts postcss-loader in front of the CSS parser, a Tailwind entry stylesheet, and the two views
+ * written in utilities instead of classes of their own.
+ *
+ * `postcss` and `postcss-loader` are the app's dependencies rather than the framework's — rshono
+ * compiles CSS natively and has no PostCSS in it, so an app that does not want a plugin chain does not
+ * install one.
+ */ const TAILWIND = {
+    id: 'tailwind',
+    overlays: [
+        'tailwind'
+    ],
+    devDependencies: {
+        tailwindcss: TOOL_VERSIONS.tailwindcss,
+        '@tailwindcss/postcss': TOOL_VERSIONS["@tailwindcss/postcss"],
+        postcss: TOOL_VERSIONS.postcss,
+        'postcss-loader': TOOL_VERSIONS["postcss-loader"]
+    }
+};
+function stylingFeature(styling) {
+    return styling === 'tailwind' ? TAILWIND : null;
+}
+
+;// CONCATENATED MODULE: ./src/features/index.ts
+
+
+
+
+/**
+ * The features a set of answers selects, in application order — so an overlay listed later wins a file
+ * both of them ship. Deduplicated by `id`, which is what lets one feature answer two questions (Biome
+ * is both the formatter and the linter) without contributing twice.
+ */ function selectFeatures(answers) {
+    const selected = [
+        deployFeature(answers.deploy),
+        stylingFeature(answers.styling),
+        formatterFeature(answers.formatter),
+        linterFeature(answers.linter),
+        ...combinationFeatures(answers)
+    ];
+    const features = [];
+    const seen = new Set();
+    for (const feature of selected){
+        if (!feature || seen.has(feature.id)) continue;
+        seen.add(feature.id);
+        features.push(feature);
+    }
+    return features;
+}
+
+;// CONCATENATED MODULE: ./src/options.ts
+
+const PACKAGE_MANAGERS = [
+    'npm',
+    'pnpm',
+    'yarn',
+    'bun'
+];
+const DEPLOY_TARGET_NAMES = DEPLOY_TARGETS.map((target)=>target.name);
+function deployHint(name) {
+    return DEPLOY_TARGETS.find((target)=>target.name === name)?.hint ?? '';
+}
+function isDeployTarget(value) {
+    return DEPLOY_TARGET_NAMES.includes(value);
+}
+const QUALITY_PRESETS = [
+    {
+        id: 'prettier-oxlint',
+        label: 'Prettier + oxlint',
+        hint: 'the conventional formatter, with a fast linter',
+        formatter: 'prettier',
+        linter: 'oxlint'
+    },
+    {
+        id: 'biome',
+        label: 'Biome',
+        hint: 'formatter and linter in one tool',
+        formatter: 'biome',
+        linter: 'biome'
+    },
+    {
+        id: 'oxc',
+        label: 'oxfmt + oxlint',
+        hint: 'the oxc toolchain — fastest, newest',
+        formatter: 'oxfmt',
+        linter: 'oxlint'
+    },
+    {
+        id: 'none',
+        label: 'None',
+        hint: 'add your own later',
+        formatter: 'none',
+        linter: 'none'
+    }
+];
+/**
+ * Turns whatever the user typed into a name npm will accept, or returns `null` when nothing usable is
+ * left. Lowercasing and replacing runs of invalid characters covers the ordinary cases (`My App`,
+ * `my_app`); a scoped name is kept intact, since `@scope/name` is legal.
+ */ function toPackageName(input) {
+    const trimmed = input.trim().replace(/^\.\/+/, '').replace(/\/+$/, '');
+    if (!trimmed || trimmed === '.') return null;
+    // A scoped name is a name, not a path: `@scope/pkg` stays whole rather than becoming `pkg`. Anything
+    // else is a path, and the last segment is the one that names the project.
+    const scoped = /^@[^\\/]+[\\/][^\\/]+$/.test(trimmed);
+    const base = scoped ? trimmed : trimmed.split(/[\\/]/).filter(Boolean).pop() ?? '';
+    if (!base) return null;
+    const name = base.toLowerCase().replace(/[\\/]/g, '/').replace(/[^a-z\d\-._~/@]+/g, '-').replace(/^-+/, '').replace(/-+$/, '');
+    if (!name || name === '@' || !scoped && name.startsWith('.')) return null;
+    return name.slice(0, 214);
+}
+/** npm's own rule, narrowed to what we ever generate: no uppercase, no leading dot or underscore. */ function isValidPackageName(name) {
+    return /^(?:@[a-z\d\-*~][a-z\d\-*._~]*\/)?[a-z\d\-~][a-z\d\-._~]*$/.test(name) && name.length <= 214;
+}
+
+;// CONCATENATED MODULE: ./src/pkg.ts
+
+/**
+ * The scripts every app gets. `start` is not among them: it is the *Node* launcher, and the deploy
+ * features each contribute the command their own platform runs what was built with.
+ */ const BASE_SCRIPTS = {
+    dev: 'rshono dev',
+    build: 'rshono build',
+    typecheck: 'tsc --noEmit'
+};
+/** Field order in the emitted file — the conventional reading order, and stable so snapshots are too. */ const FIELD_ORDER = [
+    'name',
+    'version',
+    'private',
+    'type',
+    'engines',
+    'packageManager',
+    'scripts',
+    'dependencies',
+    'devDependencies'
+];
+function sorted(record) {
+    return Object.fromEntries(Object.entries(record).sort(([a], [b])=>a < b ? -1 : 1));
+}
+/**
+ * Assembles `package.json` from the answers and whatever the selected features contribute.
+ *
+ * Dependencies are sorted by name and scripts are left in contribution order (the base ones, then each
+ * feature's, in the order features were selected) — so two runs with the same answers produce byte-
+ * identical output, which is what makes the generated manifest snapshot-testable.
+ */ function buildPackageJson(answers, features, pm) {
+    const scripts = {
+        ...BASE_SCRIPTS
+    };
+    const dependencies = {
+        '@rshono/core': RSHONO_RANGE,
+        hono: FRAMEWORK_DEPS.hono,
+        react: FRAMEWORK_DEPS.react,
+        'react-dom': FRAMEWORK_DEPS["react-dom"]
+    };
+    const devDependencies = {
+        '@types/node': FRAMEWORK_DEPS["@types/node"],
+        '@types/react': FRAMEWORK_DEPS["@types/react"],
+        typescript: FRAMEWORK_DEPS.typescript
+    };
+    for (const feature of features){
+        Object.assign(scripts, feature.scripts);
+        Object.assign(dependencies, feature.dependencies);
+        Object.assign(devDependencies, feature.devDependencies);
+    }
+    const manifest = {
+        name: answers.packageName,
+        version: '0.1.0',
+        private: true,
+        type: 'module',
+        // The floor the framework declares. Stated here too so a CI image or a contributor on an older
+        // Node finds out from their package manager rather than from a stack trace.
+        engines: {
+            node: '>=22.1.0'
+        },
+        scripts,
+        dependencies: sorted(dependencies),
+        devDependencies: sorted(devDependencies)
+    };
+    // Only when the environment told us the exact version: `packageManager` pins the tool for Corepack,
+    // and a guess at the version is worse than leaving the field out.
+    if (pm.version) manifest.packageManager = `${pm.name}@${pm.version}`;
+    const ordered = Object.fromEntries(FIELD_ORDER.filter((field)=>field in manifest).map((field)=>[
+            field,
+            manifest[field]
+        ]));
+    return `${JSON.stringify(ordered, null, 2)}\n`;
+}
+
+;// CONCATENATED MODULE: external "node:fs"
+
+;// CONCATENATED MODULE: external "node:path"
+
+;// CONCATENATED MODULE: ./src/render.ts
+
+const TOKEN_PATTERN = /__[A-Z][A-Z\d_]*__/g;
+function tokensFor(answers, pm) {
+    return {
+        __PROJECT_NAME__: answers.packageName,
+        __DEPLOY_TARGET__: answers.deploy,
+        __DEPLOY_HINT__: deployHint(answers.deploy),
+        __PM__: pm.name,
+        __PM_RUN__: pm.run
+    };
+}
+/**
+ * Substitutes tokens, and throws on one it doesn't know — a typo in a template would otherwise ship a
+ * literal `__PORJECT_NAME__` into somebody's new app, which no test of the generator's logic would
+ * catch.
+ */ function render(contents, tokens, source) {
+    return contents.replace(TOKEN_PATTERN, (token)=>{
+        const value = tokens[token];
+        if (value === undefined) throw new Error(`[create-rshono] ${source} uses unknown template token ${token}`);
+        return value;
+    });
+}
+
+;// CONCATENATED MODULE: ./src/plan.ts
+
+
+
+
+
+/** `dist/cli.mjs` and `templates/` are siblings in the published package, as they are in the repo. */ const TEMPLATES_DIR = join(__rspack_import_meta_dirname__, '..', 'templates');
+function readTemplateDir(dir) {
+    const files = new Map();
+    for (const entry of readdirSync(dir, {
+        recursive: true,
+        withFileTypes: true
+    })){
+        if (!entry.isFile()) continue;
+        const absolute = join(entry.parentPath, entry.name);
+        const relative = absolute.slice(dir.length + 1).split(sep).join(posix.sep);
+        files.set(relative, readFileSync(absolute, 'utf8'));
+    }
+    return files;
+}
+/**
+ * `_gitignore` → `.gitignore`, and so on for every dotfile.
+ *
+ * npm strips a literal `.gitignore` out of a published tarball, so a template cannot simply contain
+ * one — the file would exist in the repo, pass every local test, and be missing from the package
+ * everybody actually installs. Naming them with an underscore and renaming here is the long-standing
+ * fix. It applies to the basename only, so `src/lib/_x.ts` is a dotfile but `templates/_x/y.ts` is not.
+ */ function undotted(path) {
+    const segments = path.split(posix.sep);
+    const name = segments.pop();
+    return [
+        ...segments,
+        name.startsWith('_') ? `.${name.slice(1)}` : name
+    ].join(posix.sep);
+}
+/**
+ * A feature's `.gitignore` lines, appended under a heading naming it — so somebody reading the file six
+ * months later can tell why `.wrangler/` is in there.
+ */ function appendGitignore(existing, features) {
+    const additions = features.filter((feature)=>feature.gitignore?.length);
+    if (additions.length === 0) return existing;
+    const blocks = additions.map((feature)=>`\n# ${feature.id}\n${feature.gitignore.join('\n')}\n`);
+    return existing + blocks.join('');
+}
+/**
+ * Turns answers into the exact set of files to write, without touching the target directory — the
+ * decisions and the I/O are separated so the whole matrix of answers can be asserted on in a test, and
+ * so `--dry-run` is the same code path minus the last step.
+ */ function plan_plan(answers, pm) {
+    const features = selectFeatures(answers);
+    const tokens = tokensFor(answers, pm);
+    const raw = readTemplateDir(join(TEMPLATES_DIR, 'base'));
+    for (const feature of features){
+        for (const overlay of feature.overlays ?? []){
+            for (const [path, contents] of readTemplateDir(join(TEMPLATES_DIR, overlay))){
+                raw.set(path, contents);
+            }
+        }
+    }
+    const files = new Map();
+    for (const [path, contents] of raw){
+        files.set(undotted(path), render(contents, tokens, path));
+    }
+    const gitignore = files.get('.gitignore');
+    if (gitignore) files.set('.gitignore', appendGitignore(gitignore, features));
+    files.set('package.json', buildPackageJson(answers, features, pm));
+    return {
+        // Sorted, so both the write order and a test's snapshot are stable.
+        files: new Map([
+            ...files
+        ].sort(([a], [b])=>a < b ? -1 : 1)),
+        features,
+        notes: features.flatMap((feature)=>feature.notes ?? [])
+    };
+}
+
+;// CONCATENATED MODULE: external "node:child_process"
+
+;// CONCATENATED MODULE: ./src/pm.ts
+
+const INSTALL = {
+    npm: [
+        'install'
+    ],
+    pnpm: [
+        'install'
+    ],
+    yarn: [],
+    bun: [
+        'install'
+    ]
+};
+const RUN = {
+    npm: 'npm run',
+    pnpm: 'pnpm',
+    yarn: 'yarn',
+    bun: 'bun'
+};
+function isKnown(name) {
+    return name === 'npm' || name === 'pnpm' || name === 'yarn' || name === 'bun';
+}
+function packageManager(name, version) {
+    return {
+        name,
+        version,
+        install: INSTALL[name],
+        run: RUN[name]
+    };
+}
+/**
+ * Which package manager invoked us. Every one of them sets `npm_config_user_agent` for the process it
+ * spawns — `pnpm/11.9.0 npm/? node/v22.14.0 darwin arm64` — so `pnpm create @rshono` scaffolds a pnpm
+ * project without asking, and the exact version comes along for the `packageManager` field.
+ *
+ * Falls back to npm, which is also what a bare `node bin/create-rshono.mjs` gets.
+ */ function detectPackageManager(userAgent = process.env.npm_config_user_agent) {
+    const [spec] = (userAgent ?? '').split(' ');
+    const [name, version] = (spec ?? '').split('/');
+    if (name && isKnown(name)) return packageManager(name, version && /^\d+\.\d+\.\d+/.test(version) ? version : undefined);
+    return packageManager('npm');
+}
+/**
+ * Runs the install, streaming its output. `shell: true` on Windows because npm, pnpm and yarn are all
+ * `.cmd` shims there, which `spawn` cannot execute directly — and with a shell involved the arguments
+ * are all fixed strings from the tables above, never anything the user typed.
+ */ function runInstall(pm, cwd) {
+    return run(pm, pm.install, cwd);
+}
+/** `<pm> run <script>` — the one form every package manager accepts, Yarn v1 included. */ function runScript(pm, script, cwd) {
+    return run(pm, [
+        'run',
+        script
+    ], cwd);
+}
+function run(pm, args, cwd) {
+    const result = spawnSync(pm.name, args, {
+        cwd,
+        stdio: 'inherit',
+        shell: process.platform === 'win32'
+    });
+    return result.status === 0;
+}
+
+;// CONCATENATED MODULE: ./src/write.ts
+
+
+/**
+ * Files that do not make a directory "occupied". A user who ran `git init` or opened the folder in an
+ * editor before scaffolding has not put anything in it that we would overwrite.
+ */ const IGNORED_ENTRIES = new Set([
+    '.git',
+    '.DS_Store',
+    '.idea',
+    '.vscode',
+    'Thumbs.db'
+]);
+function inspectTarget(dir) {
+    if (!existsSync(dir)) return {
+        exists: false,
+        conflicts: []
+    };
+    return {
+        exists: true,
+        conflicts: readdirSync(dir).filter((entry)=>!IGNORED_ENTRIES.has(entry))
+    };
+}
+/**
+ * Writes the plan. Directories are created as needed, and files are written with the plan's own
+ * ordering so a failure part-way through leaves something a person can make sense of.
+ */ function writePlan(plan, targetDir) {
+    mkdirSync(targetDir, {
+        recursive: true
+    });
+    for (const [path, contents] of plan.files){
+        const absolute = join(targetDir, path);
+        mkdirSync(dirname(absolute), {
+            recursive: true
+        });
+        writeFileSync(absolute, contents);
+    }
+}
+
+;// CONCATENATED MODULE: ./src/api.ts
+/**
+ * The generator without the CLI around it: answers in, the exact set of files out. This is what the
+ * test suite asserts on — the whole matrix of options, in memory, with no directory to clean up — and
+ * what another tool would call to scaffold an app itself.
+ *
+ * @packageDocumentation
+ */ 
+
+
+
+
+
+
+
+var __webpack_exports__DEPLOY_TARGET_NAMES = __webpack_exports__.bp;
+var __webpack_exports__FRAMEWORK_DEPS = __webpack_exports__.e7;
+var __webpack_exports__PACKAGE_MANAGERS = __webpack_exports__.Ab;
+var __webpack_exports__QUALITY_PRESETS = __webpack_exports__.pm;
+var __webpack_exports__RSHONO_RANGE = __webpack_exports__.s_;
+var __webpack_exports__TOOL_VERSIONS = __webpack_exports__.RM;
+var __webpack_exports__buildPackageJson = __webpack_exports__.Jh;
+var __webpack_exports__deployHint = __webpack_exports__.P8;
+var __webpack_exports__detectPackageManager = __webpack_exports__.Lv;
+var __webpack_exports__inspectTarget = __webpack_exports__.WL;
+var __webpack_exports__isDeployTarget = __webpack_exports__.p1;
+var __webpack_exports__isValidPackageName = __webpack_exports__.eW;
+var __webpack_exports__packageManager = __webpack_exports__.ml;
+var __webpack_exports__plan = __webpack_exports__.et;
+var __webpack_exports__selectFeatures = __webpack_exports__.N7;
+var __webpack_exports__toPackageName = __webpack_exports__.PQ;
+var __webpack_exports__writePlan = __webpack_exports__.pD;
+export { __webpack_exports__DEPLOY_TARGET_NAMES as DEPLOY_TARGET_NAMES, __webpack_exports__FRAMEWORK_DEPS as FRAMEWORK_DEPS, __webpack_exports__PACKAGE_MANAGERS as PACKAGE_MANAGERS, __webpack_exports__QUALITY_PRESETS as QUALITY_PRESETS, __webpack_exports__RSHONO_RANGE as RSHONO_RANGE, __webpack_exports__TOOL_VERSIONS as TOOL_VERSIONS, __webpack_exports__buildPackageJson as buildPackageJson, __webpack_exports__deployHint as deployHint, __webpack_exports__detectPackageManager as detectPackageManager, __webpack_exports__inspectTarget as inspectTarget, __webpack_exports__isDeployTarget as isDeployTarget, __webpack_exports__isValidPackageName as isValidPackageName, __webpack_exports__packageManager as packageManager, __webpack_exports__plan as plan, __webpack_exports__selectFeatures as selectFeatures, __webpack_exports__toPackageName as toPackageName, __webpack_exports__writePlan as writePlan };