@bleedingdev/modern-js-create 3.2.0-ultramodern.99 → 3.4.0-ultramodern.1

package/README.md

@@ -8,102 +8,263 @@
   A Progressive React Framework for modern web development.
 </p>
 
-## Getting Started
+## UltraModern.js Create
 
-Please follow [Quick Start](https://modernjs.dev/en/guides/get-started/quick-start) to get started with Modern.js.
-
-For UltraModern.js, use the BleedingDev create package. It defaults to a
-production-ready single app with `presetUltramodern(...)`, TanStack Router,
-Tailwind CSS v4, i18n, Effect BFF, generated quality gates, and published
-BleedingDev package aliases:
+The BleedingDev create package has one supported generated product: an
+UltraModern SuperApp workspace.
 
 ```bash
-pnpm dlx @bleedingdev/modern-js-create my-app
+pnpm dlx @bleedingdev/modern-js-create my-workspace
 ```
 
+The supported pnpm command contract is the scoped package specifier above:
+`pnpm dlx @bleedingdev/modern-js-create <target>`. Do not shorten it to
+`pnpm dlx modern-js-create`; there is no unscoped `modern-js-create` npm
+package. Release proof runs this scoped form from a temporary pnpm store/cache
+so it cannot pass because of a local link cache.
+
 To initialize the empty directory you are already in, pass `.` explicitly:
 
 ```bash
 pnpm dlx @bleedingdev/modern-js-create .
 ```
 
-The default is the full UltraModern single-app setup. Create a SuperApp
-workspace explicitly when you need independently owned verticals:
-
-```bash
-pnpm dlx @bleedingdev/modern-js-create my-super-app --ultramodern-workspace
-```
-
 The workspace starts shell-only so the first commit has no fake business
 domains to delete. It generates:
 
 - `apps/shell-super-app` as the Module Federation host and topology owner.
-- `verticals/*` empty until you add a real domain with `--vertical`.
-- `packages/shared-*` placeholders for shared contracts, tokens, and API
-  support.
-- `.modernjs/ultramodern-generated-contract.json` with MF, Effect, i18n,
-  federated CSS, Cloudflare, and Zephyr dependency metadata.
+- `verticals/*` empty until a real domain is added with `--vertical`.
+- `packages/shared-*` placeholders for shared contracts, tokens, and Effect
+  API support.
+- `.modernjs/ultramodern-generated-contract.json` with Module Federation,
+  Effect, i18n, federated CSS, Cloudflare, route publicness, generated
+  public-surface, and Zephyr dependency metadata.
 
 Validate the generated workspace before making application changes:
 
 ```bash
-cd my-super-app
+cd my-workspace
 mise install
 pnpm install
 pnpm check
 pnpm build
 ```
 
-### Router Template
+The generated toolchain baseline is Node `>=26` with pnpm `11+`.
+`packageManager`, `.mise.toml`, generated validation, and CI should all agree
+on that baseline; do not reintroduce Corepack or older pnpm aliases.
+
+## TS-Go Compatibility Boundary
 
-TanStack Router is generated by default. Choose React Router only as an explicit
-compatibility lane:
+The supported generator runtime surfaces are:
+
+- `@modern-js/create/ultramodern-workspace`
+- `@modern-js/create/ultramodern-workspace/codesmith`
+- The `@bleedingdev/modern-js-create` CLI that delegates to those APIs.
+
+These surfaces are plain Node generator code. They must not import
+`typescript`, `@typescript/native-preview`, or TypeScript compiler internals at
+runtime. The package build is the local validation command for this boundary:
 
 ```bash
-pnpm dlx @bleedingdev/modern-js-create my-app --router react-router
+pnpm --filter @modern-js/create build
 ```
 
-### Tailwind Template
+That command runs the Rslib runtime build and then emits declarations through
+the repo `tsgo:dts` flow. Run `pnpm --filter @modern-js/create test` when
+changing generator behavior; it includes a boundary test that scans generator
+sources, templates, and generated workspace output for compiler API imports.
+
+Generated app packages keep stable `typescript` for classic compiler consumers
+such as Module Federation DTS generation, and use `@effect/tsgo` plus
+`@typescript/native-preview` as tooling for `pnpm typecheck`. Generated
+app/package source must not depend on compiler API internals. Existing compiler
+API tests in this package use the stable TypeScript 6 package. If a future AST
+utility is needed, keep it behind a dedicated compatibility module and test it
+against stable `typescript`, not native-preview internals.
 
-Tailwind CSS v4 setup is generated by default. Disable it explicitly when you
-need a plain CSS starter:
+Generated CI does not call the local aggregate. It runs format, lint,
+typecheck, skills, i18n boundary validation, contract validation, and build as
+separate matrix jobs so failures are isolated and parallelizable. Generated
+lefthook config runs separate format and lint-fix commands on pre-commit, then
+runs the read-only primitive gates in parallel on pre-push.
+
+For local monorepo dependency testing, add `--workspace`:
 
 ```bash
-pnpm dlx @bleedingdev/modern-js-create my-app --no-tailwind
+pnpm dlx @bleedingdev/modern-js-create my-workspace --workspace
+```
+
+For package-source validation outside the monorepo, pass explicit
+`--ultramodern-package-*` options.
+
+## Automation And Public API
+
+The supported runtime import is the public generator subpath. It exposes only
+generator operations and stable result types; CLI argument parsing, prompts,
+registry lookup, and process-exit flows stay private.
+
+```ts
+import {
+  addUltramodernVertical,
+  generateUltramodernWorkspace,
+  planUltramodernVertical,
+} from '@modern-js/create/ultramodern-workspace';
+
+const workspace = generateUltramodernWorkspace({
+  targetDir: '/tmp/my-workspace',
+  packageName: 'my-workspace',
+  modernVersion: '3.4.0',
+  packageSource: {
+    strategy: 'install',
+    modernPackageVersion: '3.4.0',
+  },
+});
+
+const plan = planUltramodernVertical({
+  workspaceRoot: workspace.workspaceRoot,
+  name: 'new-vertical',
+  modernVersion: '3.4.0',
+});
+
+const vertical = addUltramodernVertical({
+  workspaceRoot: workspace.workspaceRoot,
+  name: 'new-vertical',
+  modernVersion: '3.4.0',
+});
 ```
 
-TanStack Router and Tailwind CSS work together without extra flags:
+Workspace generation returns `operation`, `workspaceRoot`, `packageScope`,
+`packageSource`, `createdApps`, `createdPaths`, `rewrittenPaths`,
+`assignedPorts`, `moduleFederationNames`, `effectApiPrefixes`,
+`generatedContractPath`, and `warnings`. MicroVertical addition returns the
+same shape for the new vertical and all rewritten integration surfaces.
+
+Dry-run is available for MicroVertical addition only. The CLI prints the plan as
+JSON and writes no files:
 
 ```bash
-pnpm dlx @bleedingdev/modern-js-create my-app
+pnpm dlx @bleedingdev/modern-js-create new-vertical --vertical --dry-run
+pnpm dlx @bleedingdev/modern-js-create --vertical=new-vertical --dry-run
+pnpm dlx @bleedingdev/modern-js-create --vertical-name new-vertical --dry-run
 ```
 
-### BFF Runtime Template
+The dry-run object adds `dryRun: true`, `selectedPort`,
+`moduleFederationRemote`, `effectApiPrefix`, `jsonMutations`,
+`shellDependencyChanges`, and `generatedContractChanges`. It still validates
+the workspace before returning a plan.
+
+Validation runs before the first filesystem write. Failures name the owning
+contract so automation can stop safely:
+
+| Failure area | Typical cause | Fix |
+| --- | --- | --- |
+| Fresh input | Invalid or missing vertical name | Use `<name> --vertical`, `--vertical=<name>`, or `--vertical-name <name>` |
+| Existing topology | Duplicate app ID, package suffix, path, Module Federation name, port, API prefix, or manifest key | Choose a new vertical name or repair the existing topology/local overlay first |
+| Workspace files | Missing or non-object topology, ownership, package-source, local overlay, or generated contract JSON | Restore the generated contract file from source control or rerun from a valid workspace |
+| Tailwind prefix | Existing app already owns the generated CSS prefix | Rename the vertical before generation |
+| Output path | A generated path already exists | Treat it as an existing vertical and do not overwrite it |
+
+Package source is explicit and recorded in `.modernjs/ultramodern-package-source.json`.
+
+| Strategy | Use when | CLI |
+| --- | --- | --- |
+| `install` | Published BleedingDev package cohort or release proof | Default for the BleedingDev create package; optional `--ultramodern-package-version`, `--ultramodern-package-registry`, `--ultramodern-package-scope`, and `--ultramodern-package-name-prefix` |
+| `workspace` | Local monorepo testing against unreleased packages | `--workspace` or `--ultramodern-package-source=workspace` |
+
+## Migrating Older Workspaces
 
-UltraModern app scaffolds include Effect HttpApi BFF by default:
+Older generated repos should move by adopting one published BleedingDev cohort
+at a time. Start with a dry-run vertical addition so validation reports
+topology, ownership, package-source, overlay, Tailwind prefix, Module Federation,
+and generated-contract conflicts before files are written:
 
 ```bash
-pnpm dlx @bleedingdev/modern-js-create my-app
+pnpm dlx @bleedingdev/modern-js-create@latest catalog --vertical --dry-run
+pnpm dlx @bleedingdev/modern-js-create@latest catalog --vertical
+mise install
+mise exec -- pnpm install
+mise exec -- pnpm check
+mise exec -- pnpm build
 ```
 
-To scaffold Hono runtime explicitly:
+Use `--ultramodern-package-source=install` for published cohort proof and pin a
+specific release with `--ultramodern-package-version` when CI must prove an
+exact framework version. Keep `--workspace` only for local monorepo testing
+against unpublished packages. After install, run the generated
+`scripts/validate-ultramodern-workspace.mjs` contract check and fix ownership
+conflicts in the owning JSON/config files instead of editing generated package
+metadata by hand.
 
-```bash
-pnpm dlx @bleedingdev/modern-js-create my-app --bff-runtime hono
+## CodeSmith Adapter And Overlays
+
+The CodeSmith adapter is exported from:
+
+```ts
+import ultramodernCodeSmith from '@modern-js/create/ultramodern-workspace/codesmith';
 ```
 
-Generated starters expose `presetUltramodern(...)` as the public opinionated
-config wrapper when you want the full Ultramodern setup surface in
-`modern.config.ts`.
+Non-interactive usage passes config directly:
+
+```ts
+await ultramodernCodeSmith({
+  config: {
+    mode: 'workspace',
+    name: 'my-workspace',
+    targetDir: '/tmp/my-workspace',
+    modernVersion: '3.4.0',
+    packageSourceStrategy: 'install',
+    modernPackageVersion: '3.4.0',
+  },
+});
+
+await ultramodernCodeSmith({
+  config: {
+    mode: 'vertical',
+    name: 'new-vertical',
+    workspaceRoot: '/tmp/my-workspace',
+    dryRun: true,
+    logResult: true,
+  },
+});
+```
+
+The adapter prompts only when a required name is missing and a CodeSmith prompt
+function is available. It returns the same public generation result or dry-run
+plan as the direct API.
 
-TanStack Router, default Tailwind, and Effect BFF are included without extra
-flags. For local monorepo dependency testing, add `--workspace`:
+Overlays are explicit CodeSmith generators that run after base workspace or
+MicroVertical generation:
 
 ```bash
-pnpm dlx @bleedingdev/modern-js-create my-app --workspace
+pnpm dlx @bleedingdev/modern-js-create new-vertical --vertical \
+  --codesmith-overlay ./generators/vertical-overlay
+```
+
+```ts
+addUltramodernVertical({
+  workspaceRoot: '/tmp/my-workspace',
+  name: 'new-vertical',
+  modernVersion: '3.4.0',
+  overlays: [
+    {
+      generator: './generators/vertical-overlay',
+      config: { owner: 'workspace' },
+    },
+  ],
+});
 ```
 
-### Vertical Workspace Recipes
+Overlay config receives `workspaceRoot`, `packageScope`, `operation`,
+`generatedApp`, `generatedApps`, `assignedPort`, `assignedPorts`,
+`moduleFederationName`, `moduleFederationNames`, `effectApiPrefix`,
+`effectApiPrefixes`, `packageSource`, and `generationResult`. Overlays extend
+the generated output after base generation; they do not replace, inherit, or
+shadow the base templates. Overlay failures stop the command with an
+`UltraModern CodeSmith overlay failed` error and do not report base generation
+as fully successful.
+
+## Vertical Workspace Recipes
 
 Use the workspace add flow from the UltraModern workspace root. It derives the
 package path, package name, port, Module Federation name, topology entry, local
@@ -112,6 +273,8 @@ requested vertical name.
 
 ```bash
 pnpm dlx @bleedingdev/modern-js-create catalog --vertical
+pnpm dlx @bleedingdev/modern-js-create --vertical=catalog
+pnpm dlx @bleedingdev/modern-js-create --vertical-name catalog
 ```
 
 Use this decision table before adding a vertical:
@@ -124,33 +287,44 @@ Use this decision table before adding a vertical:
 | Design tokens, primitives, generated clients, or domain-neutral utilities | Yes | Use an ordinary workspace package, not a vertical |
 | Feature composites or workflow state shared across verticals | No | Revisit ownership; do not hide it in shared code |
 
-The lower-level `--router react-router`, `--workspace`, and `--sub` flags remain
-available for compatibility and local package scaffolding, but UltraModern
-vertical additions should use `--vertical` so paths, topology, Effect BFF
-contracts, and local overlays stay consistent.
-
-See
-`docs/super-app-rfc-adr/WORKSPACE-0001-micro-vertical-workspace-scaffolding.md`
-for the canonical workspace topology and local orchestration model.
-
-The published `@bleedingdev/modern-js-create` package is the preferred
-UltraModern.js entrypoint. The lower-level `--ultramodern-*` flags remain
-available for release engineering and local package-source testing, but users
-should not need them for normal app creation.
-
-### SuperApp Architecture Contracts
+## SuperApp Architecture Contracts
 
 The generated shell owns route assembly and policy. Each vertical added with
-`--vertical` owns its route subtree, MF exposes, Effect BFF contract, generated
-client, `localisedUrls`, locale JSON, CSS layer, and Cloudflare Worker output.
-The shell consumes vertical UI through MF manifests and vertical APIs through
-generated Effect clients exported by the vertical packages.
-
-Route localization is route-owned. Each app writes
-`src/routes/ultramodern-route-metadata` and passes
-`ultramodernLocalisedUrls` into `@modern-js/plugin-i18n`. Locale JSON is served
-from `/locales/{{lng}}/{{ns}}.json`; Czech and English routes are generated from
-the route owner, not from shell rewrites.
+`--vertical` owns its route subtree, Module Federation exposes, Effect BFF
+contract, generated client, `localisedUrls`, locale JSON, CSS layer, and
+Cloudflare Worker output. The shell consumes vertical UI through Module
+Federation manifests and vertical APIs through generated Effect clients
+exported by the vertical packages.
+
+Route metadata is route-owned and colocated in
+`src/routes/**/route.meta.ts`. The scaffold regenerates
+`src/routes/ultramodern-route-metadata.ts` as a compatibility manifest for
+Modern.js config, i18n, public head, and public surface contracts; authors
+should not hand-maintain it. Locale JSON is served from
+`/locales/{{lng}}/{{ns}}.json`; Czech and English routes are generated from the
+route owner, not from shell rewrites.
+
+Routes default to `privateByDefault: true` and
+`publicnessDefault: private-app-screen`. Public web artifacts are build/deploy
+outputs generated by `scripts/generate-public-surface-assets.mjs` into
+`dist/public` and `.output/public`, not source files under `config/public`.
+Generated public files use only explicit `public && indexable` route metadata,
+so private app screens publish only a disallowing `robots.txt` by default.
+JSON-LD is not inferred from route titles, descriptions, localized paths, app
+names, BFF APIs, or Module Federation metadata. To publish structured data,
+author `jsonLd` explicitly in route metadata for a `public && indexable` route;
+generated apps provide `src/routes/ultramodern-jsonld.ts` helpers for
+`WebPage`, `WebApplication`, `SoftwareApplication`, `BreadcrumbList`,
+`FAQPage`, and `Organization`, while raw JSON-LD remains possible for other
+schema types.
+
+Dynamic public routes can expand sitemap entries through route-owned,
+Node-safe ESM providers, normally `route.sitemap.mjs` beside the route
+metadata. The public-surface generator discovers those providers for dynamic
+public routes and still honors explicit `routes.publicSurface.contentSources`
+entries in the generated compatibility manifest. Providers may export
+`entries`, `entries()`, or a default entries/loader returning sitemap entries;
+draft entries and `indexable: false` entries are omitted.
 
 CSS federation is explicit:
 
@@ -162,15 +336,36 @@ CSS federation is explicit:
 - Tailwind CSS v4 is configured per app through `@tailwindcss/postcss`.
 - Duplicate base styles are forbidden; SSR first paint depends on shared token
   CSS plus Modern/Rspack-emitted app CSS.
-- Apps should not inject remote `async-index.css` paths, hardcode remote
-  stylesheet links, or disable filename hashing to make CSS URLs predictable.
-  UltraModern SSR resolves federated CSS from build output and MF manifests so
-  generated shells and demos can keep normal hashed assets.
 
-Version switching evidence must keep UI, Effect API, CSS, i18n JSON, and MF
-manifest markers in lockstep for the same vertical version.
+## Public URL Environment Variables
 
-### Cloudflare And Zephyr Proof
+Generated apps must not bake absolute `http://localhost:<port>` URLs into asset
+configuration. Public URL and asset prefix environment variables have distinct
+roles, and stale aliases should not be carried forward when regenerating or
+updating workspaces.
+
+| Variable | Role | Feeds |
+| --- | --- | --- |
+| `MODERN_PUBLIC_SITE_URL` | Canonical site origin for public SEO output only | Canonical, hreflang, sitemap `<loc>`, robots `Sitemap:` |
+| `MODERN_ASSET_PREFIX` | Preferred JS/CSS/static asset prefix | Modern/Rspack-emitted asset URLs |
+| `ULTRAMODERN_ASSET_PREFIX` | UltraModern compatibility asset prefix | Modern/Rspack-emitted asset URLs when `MODERN_ASSET_PREFIX` is unset |
+| `ULTRAMODERN_PUBLIC_URL_<APP_ID>` | Per-app deployment/proof URL | Cloudflare proof inputs and Module Federation remote URLs |
+
+Asset URLs use this precedence: `MODERN_ASSET_PREFIX` →
+`ULTRAMODERN_ASSET_PREFIX` → origin-relative `/`. `MODERN_PUBLIC_SITE_URL` is
+canonical/SEO-only and must not be used as an asset-prefix fallback.
+SEO output uses `MODERN_PUBLIC_SITE_URL`; if it is unset, generated local and
+preview outputs remain non-public until deployment proof provides explicit
+public URLs.
+
+Without public URLs configured, asset paths are origin-relative (`/`), and the
+dev server uses `dev.assetPrefix: '/'` — so apps work through tunnels and
+reverse proxies (ngrok, cloudflared) without triggering Chrome's Local Network
+Access prompt or mixed-content errors. Shell-only workspaces can set
+`MODERN_PUBLIC_SITE_URL` for SEO output without changing where assets load
+from.
+
+## Cloudflare And Zephyr Proof
 
 Each generated workspace app has:
 
@@ -181,9 +376,12 @@ Each generated workspace app has:
 - `zephyr-rspack-plugin` wired through the generated Modern.js Rspack bridge.
 
 Deploy first, then pass each deployed app's generated public URL env key into
-the proof step. Shell-only workspaces only need the shell URL; added verticals
-use the same `ULTRAMODERN_PUBLIC_URL_<APP_ID>` pattern with hyphens converted
-to underscores and uppercased:
+the proof step. The proof script reads the generated contract and checks the
+Cloudflare Worker surface, including public-route sitemap/robots consistency,
+preview noindex behavior, unknown-route status, asset headers, byte budgets,
+and public sourcemap exposure. Shell-only workspaces only need the shell URL;
+added verticals use the same `ULTRAMODERN_PUBLIC_URL_<APP_ID>` pattern with
+hyphens converted to underscores and uppercased:
 
 ```bash
 pnpm cloudflare:deploy
@@ -192,50 +390,27 @@ ULTRAMODERN_PUBLIC_URL_TRANSPORTATION=https://transportation.example.workers.dev
 pnpm cloudflare:proof -- --require-public-urls
 ```
 
-Without public URLs and credentials, use local `pnpm check` and `pnpm build`
+Without public URLs and credentials, use local primitive gates and `pnpm build`
 evidence only; do not claim live Cloudflare or Zephyr selection has been
 proven.
 
-### Troubleshooting
+## Troubleshooting
 
 | Symptom | Current check | Owner |
 | --- | --- | --- |
 | Package cohort mismatch | Regenerate with one package source strategy, run `mise install`, then rerun `pnpm install` from the activated shell. | Generated workspace package source metadata |
 | Install failure | Check the active Node/pnpm from `mise install`; rerun `pnpm install` after the shell sees the pinned versions. | Toolchain setup |
-| Build failure | Run `pnpm check` before `pnpm build`; fix reported format, lint, type, skill, i18n, or generated-contract failures first. | Owning package or generated contract |
+| Build failure | Run the matching primitive gate (`pnpm lint`, `pnpm typecheck`, `pnpm i18n:boundaries`, `pnpm contract:check`) before `pnpm build`; fix the owning failure first. | Owning package or generated contract |
 | Missing public URL | Set the env key from `.modernjs/ultramodern-generated-contract.json`, for example `ULTRAMODERN_PUBLIC_URL_SHELL_SUPER_APP`. | Deployment operator |
 | Cloudflare credentials | Confirm Wrangler credentials before `pnpm cloudflare:deploy`; local checks do not prove live Worker access. | Deployment operator |
 | Asset or CSS 404 | Rebuild with `pnpm build` or `pnpm cloudflare:deploy` and inspect emitted Modern/Rspack asset paths instead of hardcoding CSS URLs. | Framework/runtime asset pipeline |
 | Federation manifest failure | Run the shell and vertical build scripts, then check each deployed `/mf-manifest.json` URL used by the shell. | Module Federation owner |
 
-### Local Monorepo Testing
-
-When testing unreleased Modern.js packages from a local monorepo checkout, use
-workspace protocol dependencies:
-
-```bash
-pnpm dlx @bleedingdev/modern-js-create my-app --workspace
-```
-
-For package-source validation of the full SuperApp workspace, generate with the
-workspace package source, then run the generated contract gate:
-
-```bash
-pnpm dlx @bleedingdev/modern-js-create my-super-app --ultramodern-workspace --ultramodern-package-source workspace
-cd my-super-app
-pnpm install
-pnpm check
-```
-
-## Documentation
+## Modern.js Documentation
 
 - [English Documentation](https://modernjs.dev/en/)
 - [中文文档](https://modernjs.dev)
 
-## Contributing
-
-Please read the [Contributing Guide](https://github.com/web-infra-dev/modern.js/blob/main/CONTRIBUTING.md).
-
 ## License
 
 Modern.js is [MIT licensed](https://github.com/web-infra-dev/modern.js/blob/main/LICENSE).

package/bin/run.js

@@ -69,5 +69,6 @@ if (env === 'development') {
 } else {
   import(pathToFileURL(entry).href).catch(e => {
     console.error(e);
+    process.exit(1);
   });
 }

package/dist/cjs/create-package-root.cjs

@@ -0,0 +1,63 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    resolveCreatePackageRoot: ()=>resolveCreatePackageRoot
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const MAX_WALK_UP_LEVELS = 5;
+function resolveCreatePackageRoot(fromDir) {
+    let candidate = fromDir;
+    for(let level = 0; level <= MAX_WALK_UP_LEVELS; level++){
+        if (external_node_fs_default().existsSync(external_node_path_default().join(candidate, 'package.json')) && external_node_fs_default().existsSync(external_node_path_default().join(candidate, 'template-workspace'))) return candidate;
+        const parent = external_node_path_default().dirname(candidate);
+        if (parent === candidate) break;
+        candidate = parent;
+    }
+    throw new Error(`Unable to resolve the @modern-js/create package root (a directory containing both package.json and template-workspace/) within ${MAX_WALK_UP_LEVELS} levels above ${fromDir}`);
+}
+exports.resolveCreatePackageRoot = __webpack_exports__.resolveCreatePackageRoot;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "resolveCreatePackageRoot"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});