@warlock.js/core 4.11.0 → 4.13.0

package/CHANGELOG.md

@@ -4,6 +4,206 @@ All notable changes to `@warlock.js/core` are documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). `@warlock.js/*` packages are released in lockstep — every package shares the same version number, so a version below may list only the changes that affected this package.
 
+> ⚠ **Versioning: `@warlock.js/*` does not follow SemVer strictly — breaking changes may ship in a minor.** This is a deliberate decision, not an oversight: the framework is pre-adoption and the cost of a major per behaviour fix currently outweighs the benefit. **Pin an exact version or a tilde range (`~4.13.0`) if you need to opt into changes rather than receive them.** Every breaking change is marked **BREAKING** in its entry and summarised in an *Upgrading* section at the top of the release. **This policy will change once the framework has consumers beyond its author.**
+
+## 4.13.0
+
+### ⚠ Upgrading from 4.12.0 — read this first
+
+**Four breaking changes. Every one of them fails visibly, and every one is fixed by a single line or a single config key.** Three are security defaults that were wrong; the fourth is an import path.
+
+| What breaks | How you'll see it | The fix |
+|---|---|---|
+| **`http.cors` now actually applies** — it never had any effect in any release through 4.12.0 | requests from origins you never allow-listed start being rejected | check `http.cors` before upgrading; it now means what it says |
+| **`http.bodyLimit` defaults to Fastify's 1 MB**, not 200 GB | large uploads that used to be accepted answer `413` | set `http.bodyLimit` explicitly if you need more |
+| **`http.trustProxy` defaults to `false`** | `request.ip` becomes the socket address instead of `X-Forwarded-For` | set `http.trustProxy: true` **only if** you are genuinely behind a proxy that strips the header |
+| **The package entry no longer re-exports the CLI, dev server, test helpers or Vite integration** | build fails with `has no exported member` | test helpers move to `@warlock.js/core/tests`, `lowerStage3Decorators` to `@warlock.js/core/vite` — **one line per import.** The CLI and dev-server internals are **not** public and have no replacement specifier |
+
+**If your app configures none of the three HTTP keys, the first three changes make it strictly safer with no action from you.** The `trustProxy` default in particular meant per-IP rate limiting was bypassable by anyone sending their own `X-Forwarded-For`.
+
+Details for each are in the entries below.
+
+### Added
+
+- **`build.singleBundle` — one file you can run with `node dist/app.js`.** The default build keeps dependencies as real `import` specifiers resolved from `node_modules`, which is right when you deploy the folder. Producing a single self-contained file previously meant knowing to set `packages: "bundle"` **and** `splitting: false`, and it still did not work
+
+  It sets both as **defaults you can override** — an explicit `splitting: true` in your config still wins. Phase ordering is unaffected: it comes from the generated entry using dynamic `await import(...)`, which the bundler defers to the call site whether or not splitting is on. A comment in the builder claiming ordering "requires `splitting: true`" was wrong and has been corrected
+
+  ⚠ Native `.node` addons cannot be inlined by any bundler and are still emitted alongside the file, so "single bundle" means one JavaScript file plus any native addons — the flag does not promise otherwise
+
+  **Verified end to end on a real application**, not in isolation: the build emits exactly one file, the interop prelude is present, and the result boots and serves a request. This only became possible once dev-only tooling left the production module graph — see the entry below, which is what made `singleBundle` build a real application rather than only a synthetic one
+
+- **`@warlock.js/core/tests` and `@warlock.js/core/vite` are real subpaths**, with their own build entries and `exports` keys — the first version in which those helpers are addressable at all. `/tests` carries the 13 documented test helpers; `/vite` carries `lowerStage3Decorators`
+
+  **The test server's port channel — `publishTestServerPort`, `withdrawTestServerPort`, `TEST_SERVER_PORT_ENV_KEY` — is deliberately NOT part of that surface.** It is how `startHttpTestServer` hands the resolved port to the worker processes that later call `testGet`; it is plumbing, and nothing outside the framework needs it. **Decided before the subpath shipped rather than after, because removing an export once people depend on it is a breaking change**
+
+### Fixed
+
+- **`setupTest()` no longer crashes in a project that has no `src/config/tests.ts`.** `config.get("tests")` resolves an absent key to `null`, and the result was dereferenced — so the very path `warlock add test` generates threw `Cannot read properties of null (reading 'connectors')` before running a single test. **`setupTest()` with no arguments at all** threw one step earlier still, on a destructured parameter with no default
+
+  **`connectors: false` now starts no connectors, as its type and the skill have always said.** The selection read `testConfig.connectors || connectors`, so a configured `false` was discarded, and every non-array value then took the "start all but http" branch — **`false` started everything except http, from config and from the caller alike.** It is now `??` with an explicit `false` check
+
+  ⚠ **Config still beats the parameter:** if `tests.connectors` is set, `setupTest({ connectors })` cannot override it. That is the existing contract and this release does not change it — one line of `skills/test-service` claimed otherwise and has been corrected. **A per-call override is a contract decision for a later release**
+
+- **The request helpers send falsy JSON bodies.** `testPost`, `testPut` and `testPatch` used `body ? JSON.stringify(body) : undefined`, so **`false`, `0`, `""` and `null` — all legal JSON documents — were sent as no body at all.** Only an omitted argument now means "no body"
+
+  **Headers are accepted in every shape `RequestInit` allows.** They were merged by object spread, which is correct only for a plain record — a `Headers` instance or a `[name, value]` tuple list was silently turned into an object with numeric keys and the header was lost with no error. They are now normalised through `new Headers(...)`
+
+  **`Content-Type: application/json` is set only when the helper serialized the body**, and never over a content type the caller set. It was previously forced onto every request, including `FormData` — replacing the multipart boundary the runtime generates and producing a request no server can parse
+
+- **Shutdown survives a throwing log channel.** A connector whose `shutdown()` failed was reported through `log.error(...)` **from inside the catch block** — and `Logger.log()` hands each entry to `channel.log()` with no isolation, so a channel that throws synchronously (a misconfigured transport, an unserialisable payload) made that report reject. The rejection escaped `shutdown()` entirely, and the consequences went well past a missing log line: **`log.flush()` never ran, so every buffered entry from the whole run was lost; the remaining connectors were never torn down; and `process.exit(0)` — the line `gracefulShutdown` runs once `shutdown()` resolves — was never reached, leaving the process alive on the handles those connectors still held**
+
+  ⚠ **This hardens the shutdown path, not the logger.** `Logger.log()` still aborts its fan-out on the first throwing channel, so the other channels never receive that entry, and an *asynchronously* rejecting channel is not covered at all — `channel.log()` is never awaited. **Logger-wide isolation is a separate fix in a later release**
+
+- **A test server that fails to start no longer leaves half of itself running.** `startHttpTestServer()` publishes the resolved port before the late connector phase and sets `isServerRunning` only on its last line, so a failure in between left **live early-phase connectors and a published port pointing at a server that never came up** — while `stopHttpTestServer()` in `globalTeardown` reported *"No server to stop"* and walked away from them. Startup now unwinds what it started, always withdraws the port and resets its state. ⚠ **The error you get back is unchanged — it always was.** Startup had no `catch` at all, so the original failure already propagated correctly; what was missing was the cleanup, and the new `catch` exists only to run it. A failure *during* that cleanup is reported and never substituted for the cause, which is the one propagation guarantee the wrapper had to be careful not to break
+
+  **`stopHttpTestServer()` withdraws the port and resets state in a `finally`.** They previously ran after the `await`, so a shutdown that threw left the published port behind and the next run in the same process inherited it
+
+- **`startHttpTestServer({ port: 0 })` is refused with an instruction instead of half-working.** `0` is the OS's "pick a free one" idiom, and the test server cannot honour it: the preflight would bind some unrelated ephemeral port and pass without proving anything, and nothing publishable exists afterwards — `HttpConnector.start()` records the port it **asked for**, not the one Fastify bound. Accepting it silently meant `getTestServerUrl()` resolved `0` through its own config fallback and **every worker request went to `http://host:0`**, where nothing listens. The error names the fix: pass an explicit port, or set `http.port`
+
+- ⚠ **BREAKING — the package entry no longer re-exports the CLI, the dev server, the test helpers or the Vite integration.** Five `export *` lines are gone from `@warlock.js/core`'s root: `./cli`, `./dev-server/files-orchestrator`, `./dev-server/health-checker`, `./tests` and `./vite`
+
+  **Why it had to change:** those five put dev-only tooling into the **static module graph of every application that imports the framework** — 39 files, reaching ESLint and, through it, ESLint's optional `jiti` import. It cost nothing while the builder kept `packages: "external"`, because esbuild never walked into the framework. **Anything that bundles walks it, and the build fails.** That is why `singleBundle` could not build a single real application
+
+  ⚠ **Making those imports lazy does not help and should not be attempted.** esbuild resolves `import()` at build time; a dynamic import defers *evaluation*, not resolution. Measured: `await import("jiti")` in an otherwise empty file still fails with `Could not resolve "jiti"`. **Only unreachability from the entry removes a module from the graph**
+
+  **The two public halves are now reachable from a subpath — and in 4.12.0 and earlier they were reachable from nowhere at all.** `./tests` and `./vite` are **real build entries with their own emitted files and `exports` entries**, not reachable from the root barrel, which is the entire point:
+
+  ```ts
+  // before                                        // after
+  import { setupTest } from "@warlock.js/core";     import { setupTest } from "@warlock.js/core/tests";
+  import { startHttpTestServer } from "@warlock.js/core";
+                                                    import { startHttpTestServer } from "@warlock.js/core/tests";
+  import { lowerStage3Decorators } from "@warlock.js/core";
+                                                    import { lowerStage3Decorators } from "@warlock.js/core/vite";
+  ```
+
+  **The CLI and dev-server internals are different — they were never a public API and have no replacement specifier.** If you were importing from those, you were reaching into framework internals; open an issue describing what you needed.
+
+  ⚠ **If you were importing these symbols in 4.12.0, they were already not in the published package.** `esm/tests/` and `esm/vite/` did not exist in the 4.12.0 artifact, and none of those symbols appear in `esm/index.d.mts` — **the root barrel re-exported source the build never emitted.** So this is the release that makes them installable, not the one that removed them.
+
+  `Path` is unaffected — it moved to a genuine utility module and remains exported
+
+  **Removing the five lines was necessary but not sufficient.** Three production modules — `connectors/http-connector`, `connectors/connectors-manager` and `warlock-config/warlock-config.manager` — imported the dev server's console formatter directly. In `http-connector` the dev-console call was simply **deleted**: the same error was already routed through `log.fatal` on the following line. `connectors-manager` now logs a connector's shutdown failure through `@warlock.js/logger`, **awaited and then flushed** — `process.exit(0)` follows immediately, so an un-awaited log is a log that never happens. `warlock-config.manager`'s *"`warlock.config.ts` is missing"* warning writes **straight to the console instead**: it runs during CLI bootstrap, before the logger has a single channel configured, so routing it through the logger would drop it in every application
+
+  `tests/unit/meta/production-entry-graph.test.ts` enforces this from now on. It keys on **our own directory names** rather than a denylist of third-party packages, because a denylist rots the moment a dependency changes its imports and can only catch names someone thought of
+
+- ⚠ **BREAKING — the CORS allow-list in `http.cors` now actually applies.** The framework's defaults were spread **after** your configuration, so `{ origin: "*", methods: "*" }` overwrote whatever you set. **`http.cors` has never had any effect**, in any release up to 4.12.0 — an app that configured an allow-list still answered every origin. Your configuration now wins
+
+  **This is breaking in the direction you want, but it is breaking:** an app that has been relying on the accidental `origin: "*"` while believing it was restricted will now restrict. Check your `http.cors` before upgrading
+
+  Worth knowing why the old behaviour was also broken for the legitimate case: `Access-Control-Allow-Origin: *` together with `Access-Control-Allow-Credentials: true` is a pair **browsers reject**, so a cross-origin `fetch(…, { credentials: "include" })` failed outright. The default was simultaneously too open for unauthenticated reads and unusable for authenticated ones
+
+- ⚠ **BREAKING — `http.bodyLimit` no longer defaults to 200 GB.** An app that configures nothing now gets **Fastify's own 1 MB limit**. The previous default did not merely allow large bodies, it **replaced a protection Fastify provides**: an unauthenticated endpoint accepted a 5 MB body and ran application logic on it where bare Fastify would have answered `413`
+
+  **If you accept uploads, set `http.bodyLimit` before upgrading** — otherwise those requests start failing with `413`. The failure is immediate and one config key fixes it
+
+  The old comment recommended `middleware.maxBodySize()` for per-route caps. **That middleware cannot do this job** and its documentation has been corrected: framework middleware runs inside the route handler, after `@fastify/multipart` has already parsed the body, so it can report `Content-Length` but cannot refuse the read. For a real per-route cap use `serverOptions.bodyLimit`, which Fastify enforces while reading
+
+- ⚠ **BREAKING — `http.trustProxy` now defaults to `false`.** `request.ip` was derived from the client-supplied `X-Forwarded-For` header by default, and `@fastify/rate-limit` keys its buckets on `request.ip` — so **a client sending a different `X-Forwarded-For` on each request got a fresh rate-limit bucket every time.** Any deployment not behind a proxy that strips the header had bypassable rate limiting, and the same applied to per-IP lockouts and audit logs
+
+  **If your app is behind a proxy, set `http.trustProxy = true`.** Until you do, `request.ip` reports the proxy's address rather than the client's — a visible, diagnosable change, unlike the previous default, which could not be detected from inside the application
+
+- **Per-route `serverOptions` are no longer discarded by the dev server.** `scanDevServer` registers wildcard routes and dispatches per request, so it had no per-route registration slot and dropped `serverOptions` entirely. A route declaring `serverOptions.onRequest` — the documented way to run **before body parsing** — worked in production and **silently never ran in dev**, which is the only mode most teams run. `route.rateLimit` was dropped the same way, since it rides in the same options object
+
+  Matching now happens in Fastify's own `onRequest` phase and the matched route's hooks run there, so `onRequest`, `preValidation` and `preHandler` are forwarded with their pre-parse ordering intact
+
+  ⚠ **Two options still cannot be forwarded in dev, and `serverOptions`' documentation now says so rather than implying otherwise:** `bodyLimit`, because Fastify reads it at registration time and no hook can bound a body already being parsed; and `preParsing`, because it must return the payload stream. For a pre-parse guarantee that holds in both modes, register a server-level hook via `router.beforeScanning` — it must be idempotent per request, since a connector restart builds a new server and runs the callback again
+
+- **The dev server no longer rebuilds its entire route registry on every request.** A comment claimed the registry was initialised "once" and pointed at a `rebuildRouteRegistry` function that **does not exist**; the code sat inside the per-request handler, re-registering every route on every hit — and `router.any()` routes expand into seven registrations each. It is now built once and rebuilt when the route table changes
+
+- **The dev dispatcher logs through the framework logger instead of `console.log(error)`,** with the request method and url attached
+
+- **A bundled production build no longer succeeds and then dies at startup.** Setting `packages: "bundle"` produced a clean build whose process failed immediately with `Error: Dynamic require of "node:assert" is not supported`. Warlock's output is an ES module; bundled CommonJS dependencies call `require(...)` and read `__dirname` to locate their own assets, and neither exists in an ES module, so the bundler substituted a stub that throws. The only fix available to an application author was to hand-write an esbuild `banner` recreating `require` via `createRequire(import.meta.url)` — esbuild internals no app should need to know
+
+  The interop prelude is now injected automatically for **any** ESM build (`build.esmShim`, default `true`), not only under `singleBundle` — so a hand-written `packages: "bundle"` works too. It defines `__filename` and `__dirname` as well as `require`: a dependency resolving an asset path with a missing `__dirname` gets `undefined` and fails later, further from the cause
+
+  **An existing hand-written `banner` is preserved.** esbuild's `banner` is an object and every merge on the way to it replaces rather than merges, so previously whichever was applied second silently deleted the other. The shim is prepended to your banner instead
+
+## 4.12.0
+
+### Added
+
+- **`warlock migrate --pending` — what will run next, in the order it will run.** `migrate` could report what had already run (`--list`) and what files existed on disk (`--all`), but not the one thing an operator asks before a schema change against a live database. The pending set was already computed on every migrate run; it simply had no read-only exit
+
+  The gap forced a workaround that is **unsound in the dangerous direction**. `--all` globs `src/app` only, so it cannot see migrations a *package* registers through `database.migrations` — `@warlock.js/auth` alone contributes two. `--list` reads the migrations table, which does contain them. Differencing the two counts subtracts populations that do not overlap, and it under-counts pending by roughly the number of package migrations installed — reporting "nothing else is pending" when something is
+
+  **`migrate --list` now prints both sections**, executed and pending, so the question can be answered without knowing a second flag exists. The executed section prints **first and unconditionally**: it is a table read that cannot fail because of a broken file on disk, and `--list` is the command reached for while something is already wrong. `--list` always exits `0` — it is a report
+
+  **`--pending` is the gate**, and its exit code is its entire API: **`0`** computed and nothing pending, **`1`** computed and N pending, **`2`** could not be computed. Two codes would fold "three migrations are waiting" into "I could not work out what is waiting", and those demand opposite responses — the first is *run them*, the second is *stop*. `migrate --pending && deploy` behaves correctly under all three
+
+  **A failure to read the migrations never reports `0`.** Computing pending requires loading project code, and a single migration file missing its default export throws. That degrades to an explicit `Pending: unavailable — <reason>` line with the executed listing intact above it, and `--pending` exits `2`. An empty pending set means *nothing is pending*, and nothing else
+
+  `--all` deliberately does **not** gain a migration name beside each path. The only identifier available without loading is the one derived from the filename, and that derivation is a *fallback* used when a migration does not set `migrationName` — so any migration that names itself (`auth`'s do) would be listed under a name that does not exist. A wrong identifier in a listing whose purpose is cross-referencing is worse than no identifier, and `--list`'s two sections answer the comparison directly
+
+  Proven against a real Postgres: an executed package migration and a pending local one land in the correct sections, a fully-migrated database reports an empty pending list rather than an absent one, and the reporter's `files − executed` arithmetic is pinned as a test that fails if it is ever reintroduced
+
+### Changed
+
+- `migrate`'s preload block no longer declares `env: true`. The flag has done nothing since env began loading for every command that declares a preload block; it was decoration, and the test suite now asserts its **absence** so it is not re-added by someone reading the still-deprecated type
+
+- **The package now declares its own test runner and a `test` script.** `@warlock.js/core` shipped a maintained `vitest.config.ts` — aliasing eight sibling packages to their sources — with **no `devDependencies` key at all** and no way to invoke it. Its suite was reachable only by knowing to type `npx vitest`, which resolves whatever happens to exist in the tree rather than anything the manifest asked for. The runner is pinned to an **exact** version, not a range: it moved from 4.1.8 to 4.1.10 mid-development on an unrelated install, silently, and a suite whose runner can change underneath it proves less than it appears to
+
+### Fixed
+
+- **A build artifact that names an entry point it does not contain is now refused before it can be packed.** An interrupted build leaves a directory that looks finished — `package.json`, `README`, `CHANGELOG`, `bin/`, `skills/` — and holds no compiled code at all. Nineteen existed in this tree at once, and nothing in the release path noticed: the only related guard compares **modification times**, so a hollow directory with a freshly written manifest is *newer than source* and passes, and it runs solely on the artifact-reuse path, which is not how the hollow directories were produced
+
+  Each artifact is now verified immediately before `npm pack`, on the normal build path and the reuse path alike. **The manifest is the specification:** `main`, `module` and the typings field name the exact files the package promises to ship, so they are resolved against the artifact and must exist. Fields a manifest does not declare are skipped — `core` and `auth` point `main` at `esm/` while `cascade`, `ai` and `seal` point it at `cjs/`, and any check that assumed one build shape would have raised a false failure on packages that are entirely correct. A manifest declaring no entry point at all is also a failure: a published package nothing can import is not a package
+
+- **The production acceptance gate no longer inherits the environment it is supposed to be testing.** `run-pnpm-acceptance.mjs` spawned every child with `env: { ...process.env }` and set no `NODE_ENV`. It exercised the production path only because the shell it was written in happened to carry `NODE_ENV=production`; on a clean checkout, a new contributor's machine, or CI, the same gate boots the app in **development** — and does not fail, it passes while testing something other than the thing it is named after. That is the worst outcome available to a gate, and it sat underneath the proof for 4.11.0's headline fix
+
+  `NODE_ENV=production` is now set explicitly on every spawn, and — more importantly — **asserted from inside the running app**: `/acceptance` reports the environment it actually booted in, and the run fails if it is anything else. Setting a variable and never checking it arrived is how the original defect survived. The remaining `{ ...process.env }` is documented as a deliberate inheritance of `PATH` and the package-manager store paths, with everything the *verdict* depends on set after it
+
+  Consequence for the roadmap, recorded because the ordering matters: **CI wiring for this gate is now blocked on this fix, not parallel to it.** Wiring it up first would have produced a green from CI — which carries more weight than a local one — for a run that never touched the production path
+
+- **`warlock migrate --rollback=false` no longer drops every table.** CLI options were parsed as raw strings and nothing ever coerced them: `--rollback=false` reached the action as the string `"false"`, `if (rollback)` saw a truthy value, and the run rolled back *everything*. The declared `type: "boolean"` on the option was decorative — used only to render help. The same shape existed on every boolean option, including `warlock drop.tables --force=false`, where it turned a confirmation prompt into an unattended drop
+
+  Its twin was worse. A bare `--flag` swallowed the following token as its value, so `warlock migrate --rollback 2024_users.ts` produced `rollback: "2024_users.ts"` — the filename was never read as a path, and every table went down while the operator believed they had named one file. **A declared boolean now never consumes the next positional**: `--rollback 2024_users.ts` is `rollback: true` plus the positional `2024_users.ts`
+
+  Coercion is **type-aware, driven by the command's own declared options**, not a blanket rule in the parser: `--flag` → `true`, `--flag=true|1|yes` → `true`, `--flag=false|0|no` → `false` (case-insensitive), and short aliases (`-r=false`) behave identically. A string-typed option whose value is genuinely the word `false` — `--name=false` — still arrives as the string `"false"`. Options a command does not declare are untouched
+
+  **An unreadable value is an error, not a guess.** `--rollback=maybe` prints what was invalid and what is accepted, and exits 1. Guessing is what produced this defect; a flag that gates a destructive action must refuse input it cannot read rather than pick a side
+
+  `parseCliArgs` now takes an optional schema and runs twice: once bare to discover the command name (behaviour unchanged — there is no command to consult yet), then again against the resolved command's options. Re-reading argv is what makes the swallowed positional recoverable; by the time the first pass returns, a swallowed argument is indistinguishable from a value
+
+- **`warlock generate.module users --force=false` no longer overwrites your files.** The coercion above is opt-in by design — it applies only to options a command declares `type: "boolean"`, so a string option whose value is genuinely the word `false` survives. The generate family and `add` never carried that declaration, so the fix reached none of them and both faces of the defect stayed live on the commands most likely to be run against existing source
+
+  `--force=false` arrived at every generator as the truthy string `"false"` and the overwrite guard (`if (exists && !force)`) let it through — a flag written to *prevent* clobbering did the clobbering. Its twin ate the target: `warlock generate.module --force users` parsed `users` as the value of `--force`, so the module name was lost entirely and the generator ran with no name
+
+  Twenty-three option declarations are now typed: `--force, -f` and `--dry-run` on all eight `generate.*` commands, plus `--minimal, -m`, `--with-validation, -v`, `--with-resource, -rs`, and both `--timestamps [bool]` declarations, and `--list, -l` / `--no-install` on `add`. Options that carry real data are deliberately untouched and still take a value — `--table`, `--add`, `--drop`, `--rename` on the generators, `--package-manager` on `add`, and `seed --drop="Seed Name"`, whose value scopes which seeder is undone
+
+  `add --no-install` no longer has to be passed last. That instruction was in its help text only because the bare flag used to swallow the feature that followed it; `warlock add --no-install auth` now records `auth` as the feature and skips the install, and the wording is gone
+
+  The guard drives the real command objects through the manager's own resolution path (`tests/unit/cli/generate-flag-options.test.ts`) and asserts what the action is handed. Asserting the declaration object instead would pass against a fixture while the CLI stayed broken
+
+- **`new Image(...)` no longer fails depending on how soon you call it.** The `Image` module fired `import("sharp")` at load time without awaiting it, and the constructor only checked whether that import had *failed* — never whether it was still in flight. Constructing an image in the first tick after importing the package therefore ran with an undefined sharp function and died with `TypeError: sharpFn is not a function`; the exact same code passed if something had awaited a timer first. Anything that builds an image during boot — a startup thumbnail job, a module-level warm-up — hit it, and it presented as a mysterious "works locally, breaks in prod" timing bug rather than as a missing dependency
+
+  Sharp is now resolved **synchronously on the first construction that needs it**, via `createRequire`, and the outcome is cached for the process. There is no longer a window in which the constructor can proceed without a real sharp function: it either has the module or throws. A missing sharp still throws the same install-hint error, at the same point (construction), with the same wording
+
+  Resolution stays **lazy** — importing `@warlock.js/core` still does not load sharp's native binary, so apps that never touch images pay nothing — and constructing an `Image` from an existing sharp instance short-circuits before any module load
+
+  The guard for this is a spawned fresh Node process that imports and constructs with nothing in between (`tests/unit/image/image-sharp-resolution.test.ts`). A same-process test cannot catch it: importing at collection time and constructing later *is* the delay that hides the bug
+
+- **A sharp that is installed but will not load no longer reports itself as "not installed".** The resolution above swallowed every failure into a single outcome, so the most common real-world sharp problem — the package present but its native binary built for another platform — arrived as `sharp is not installed.` plus instructions to run `npm install sharp`, which cannot fix it. sharp throws its own long, actionable error naming the runtime, the failing `.node` file and the exact install flags to use; that text was discarded and replaced with a different, wrong cause
+
+  Only **genuine absence** now produces the install hint: a `MODULE_NOT_FOUND` whose message names the specifier `'sharp'` exactly. Matching on the code alone is not sufficient — a dependency missing *inside* sharp raises the very same code (`Cannot find module 'color'`), and would have been reported as sharp itself being absent. Any other failure surfaces sharp's own message, inlined as `Failed to load "sharp": …` **and** chained as `cause`, so a terminal that never prints `cause` still shows the text that helps. The absent-sharp path is unchanged, wording included
+
+  **The failure reason is cached, not just the fact of failure.** The resolution attempt runs once per process; a second `new Image(...)` skips the load entirely, so caching only "there is no sharp function" would have re-told the same lie one call later. The guard therefore constructs **twice** in each spawned process and asserts the second error matches the first (`tests/unit/image/image-sharp-load-failure.test.ts`) — a one-shot test passes even with that bug present
+
+  The `MODULE_NOT_FOUND` shapes the guard feeds in are produced by asking Node for a module that genuinely is not installed, rather than hand-written, so the matcher is tested against Node's real message text
+
+- **`renderReact()` no longer renders against modules that have not loaded yet.** The same defect as the two above, in a second module, found by looking for the pattern rather than by a bug report. `react/index.ts` fired `import("react")` and `import("react-dom/server")` at load time without awaiting either, and tracked them with a three-state flag that the guard only tested for one state: `if (moduleExists === false)`. While the imports were in flight the flag was `null`, which is not `false`, so the guard passed and the synchronous `renderReact` read `createElement` off `undefined`. With two sequential dynamic imports the window is wider than the image module's, and it is open during exactly the work a server does at boot — rendering a page or an email template from a module-level warm-up
+
+  The window swallowed the diagnostics as well as the render. A genuinely missing react did **not** produce the install hint during that window: it produced `TypeError: Cannot read properties of undefined (reading 'createElement')`, because the flag was still `null` rather than `false`. The install instructions only appeared for callers late enough to have missed the race — the callers who least needed telling
+
+  Both modules are now resolved **synchronously on the first `renderReact()` that needs them**, via `createRequire`, with the outcome cached for the process. Resolution stays **lazy**: importing `@warlock.js/core` still does not pull react into apps that never render. A genuinely absent react throws the same `react is not installed.` message with the same instructions, unchanged
+
+- **A broken `react-dom/server` no longer reports itself as `react is not installed`.** The two packages were loaded in one `try` and collapsed into one flag, so any failure of either was attributed to react. The specifiers are now resolved and reported **separately**, and the message names the one that actually failed — `Failed to load "react-dom/server": …` — because sending an operator to reinstall react when react is fine costs them the debugging session. Absence is distinguished from breakage the same way as for sharp: `MODULE_NOT_FOUND` **and** a message naming the specifier exactly, quoted, which is also what stops `'react-dom'` from satisfying a check for `'react'`. Everything else surfaces the original error, inlined and chained as `cause`. A `react-dom` whose `./server` subpath is missing from `exports` raises `ERR_PACKAGE_PATH_NOT_EXPORTED`, so it correctly reports as an incompatible install rather than an absent one
+
+  As with sharp, the failure **reason** is cached rather than only the fact of failure, so the second call cannot fall through to the "not installed" branch and re-tell a lie the first call got right
+
+  The guard is a spawned fresh Node process (`tests/unit/react/react-module-resolution.test.ts`); a same-process test cannot catch this, which is why the pre-existing suite was green against it. Against the live bug all five cases failed, and — the detail that shows how much the race hid — all five failed with the *same* `Cannot read properties of undefined` symptom, including the case that only asserts the install message. The present-but-broken states are staged by copying the module source next to a fixture `node_modules`, since resolution anchors to the importing file; the real workspace is not mutated
+
 ## 4.11.0
 
 ### Added

package/esm/cli/cli-commands.manager.mjs

@@ -13,7 +13,7 @@ import { manifestManager } from "../manifest/manifest-manager.mjs";
 import { displayBootError, displayCommandError, displayCommandHelp, displayCommandNotFound, displayCommandSuccess, displayExecutingCommand, displayHelp, displayMissingCommand, displayMissingOptions, displayWarlockVersionInTerminal, isMatchingCommandName } from "./cli-commands.utils.mjs";
 import { cliCommandsLoader } from "./commands-loader.mjs";
 import { frameworkCommands } from "./framework-cli-commands.mjs";
-import { parseCliArgs } from "./parse-cli-args.mjs";
+import { CliOptionValueError, parseCliArgs } from "./parse-cli-args.mjs";
 import { findSimilar } from "./string-similarity.mjs";
 import { colors } from "@mongez/copper";
 import { fileExistsAsync } from "@warlock.js/fs";
@@ -74,7 +74,7 @@ var CLICommandsManager = class {
 	* Start the cli manager
 	*/
 	async start() {
-		const { name, options, args } = parseCliArgs(process.argv);
+		const { name, options } = parseCliArgs(process.argv);
 		if (options.noCache) {
 			manifestManager.clearCommandsCache();
 			await manifestManager.removeCommandsFile();
@@ -116,12 +116,35 @@ var CLICommandsManager = class {
 			});
 			process.exit(0);
 		}
+		const resolved = this.resolveCommandArgs(command);
 		await this.execute(command, {
-			options,
-			args
+			options: resolved.options,
+			args: resolved.args
 		});
 	}
 	/**
+	* Re-parse argv against the resolved command's declared options.
+	*
+	* parseCliArgs runs twice on purpose. The first run produces the command
+	* name, and there is no schema to consult yet; the second one, here, can be
+	* type-aware. Re-reading argv (rather than post-processing the first result)
+	* is what makes `--rollback users.ts` recoverable: by the time the first pass
+	* returns, the swallowed positional is indistinguishable from a value.
+	*/
+	resolveCommandArgs(command, argv = process.argv) {
+		try {
+			return parseCliArgs(argv, command.commandOptions);
+		} catch (error) {
+			if (error instanceof CliOptionValueError) {
+				console.log();
+				console.log(`  ${colors.redBright("Error:")} ${error.message}`);
+				console.log();
+				process.exit(1);
+			}
+			throw error;
+		}
+	}
+	/**
 	* Show global help with all commands
 	* Uses manifest if available for fast display
 	*/
@@ -228,7 +251,7 @@ var CLICommandsManager = class {
 			if (opt.defaultValue !== void 0) {
 				if (!(result[opt.name] !== void 0 || opt.alias && result[opt.alias] !== void 0)) result[opt.name] = opt.defaultValue;
 			}
-			if (opt.alias !== void 0 && result[opt.alias] && result[opt.name] === void 0) result[opt.name] = result[opt.alias];
+			if (opt.alias !== void 0 && result[opt.alias] !== void 0 && result[opt.name] === void 0) result[opt.name] = result[opt.alias];
 		});
 		return result;
 	}

package/esm/cli/cli-commands.manager.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"cli-commands.manager.mjs","names":[],"sources":["../../../../../../../core/src/cli/cli-commands.manager.ts"],"sourcesContent":["import { colors } from \"@mongez/copper\";\r\nimport { fileExistsAsync } from \"@warlock.js/fs\";\r\nimport { Application } from \"../application\";\r\nimport { bootstrap } from \"../bootstrap\";\r\nimport { loadConfigFiles } from \"../config/load-config-files\";\r\nimport { connectorsManager } from \"../connectors/connectors-manager\";\r\nimport { ConnectorLifecyclePhase } from \"../connectors/types\";\r\nimport { filesOrchestrator } from \"../dev-server/files-orchestrator\";\r\nimport { manifestManager } from \"../manifest/manifest-manager\";\r\nimport { appPath } from \"../utils\";\r\nimport { loadEnvironmentFiles } from \"../utils/load-environment\";\r\nimport { warlockConfigManager } from \"../warlock-config/warlock-config.manager\";\r\nimport { CLICommand } from \"./cli-command\";\r\nimport {\r\n  displayBootError,\r\n  displayCommandError,\r\n  displayCommandHelp,\r\n  displayCommandNotFound,\r\n  displayCommandSuccess,\r\n  displayExecutingCommand,\r\n  displayHelp,\r\n  displayMissingCommand,\r\n  displayMissingOptions,\r\n  displayWarlockVersionInTerminal,\r\n  type HelpCommandInfo,\r\n  isMatchingCommandName,\r\n} from \"./cli-commands.utils\";\r\nimport { cliCommandsLoader } from \"./commands-loader\";\r\nimport { frameworkCommands } from \"./framework-cli-commands\";\r\nimport { parseCliArgs } from \"./parse-cli-args\";\r\nimport { findSimilar } from \"./string-similarity\";\r\nimport { CommandActionData, ResolvedCLICommandOption } from \"./types\";\r\n\r\nexport class CLICommandsManager {\r\n  /**\r\n   * List of commands\r\n   */\r\n  public commands: CLICommand[] = [];\r\n\r\n  /**\r\n   * Commands map (name -> command)\r\n   */\r\n  public commandsMap: Map<string, CLICommand> = new Map();\r\n\r\n  /**\r\n   * Alias map (alias -> command name)\r\n   */\r\n  public aliasMap: Map<string, string> = new Map();\r\n\r\n  /**\r\n   * Register the given commands\r\n   */\r\n  public register(...commands: CLICommand[]): this {\r\n    this.commands.push(...commands);\r\n\r\n    commands.forEach((command) => {\r\n      const commandKey = command.name.split(\" \")[0];\r\n\r\n      manifestManager.addCommandToList(command.name, {\r\n        relativePath: command.commandRelativePath,\r\n        source: command.commandSource || \"project\",\r\n        description: command.commandDescription,\r\n        alias: command.commandAlias,\r\n        options: command.commandOptions.length > 0 ? command.commandOptions : undefined,\r\n      });\r\n\r\n      this.commandsMap.set(commandKey, command);\r\n\r\n      // Register alias if exists\r\n      if (command.commandAlias) {\r\n        this.aliasMap.set(command.commandAlias, commandKey);\r\n      }\r\n    });\r\n\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Get command by name or alias\r\n   */\r\n  public getCommand(name: string): CLICommand | undefined {\r\n    // First try direct lookup\r\n    let command = this.commandsMap.get(name);\r\n    if (command) return command;\r\n\r\n    // Try alias lookup\r\n    const realName = this.aliasMap.get(name);\r\n    if (realName) {\r\n      return this.commandsMap.get(realName);\r\n    }\r\n\r\n    return;\r\n  }\r\n\r\n  /**\r\n   * Get all command names and aliases\r\n   * Used for fuzzy matching suggestions\r\n   */\r\n  public getAllCommandNames(): string[] {\r\n    const names: string[] = [];\r\n\r\n    // Add all command names\r\n    for (const name of this.commandsMap.keys()) {\r\n      names.push(name);\r\n    }\r\n\r\n    // Add all aliases\r\n    for (const alias of this.aliasMap.keys()) {\r\n      names.push(alias);\r\n    }\r\n\r\n    // Also include cached commands from manifest\r\n    const manifestCommands = manifestManager.commandsJson?.commands || {};\r\n    for (const name of Object.keys(manifestCommands)) {\r\n      const baseName = name.split(\" \")[0];\r\n      if (!names.includes(baseName)) {\r\n        names.push(baseName);\r\n      }\r\n      const alias = manifestCommands[name].alias;\r\n      if (alias && !names.includes(alias)) {\r\n        names.push(alias);\r\n      }\r\n    }\r\n\r\n    return names;\r\n  }\r\n\r\n  /**\r\n   * Start the cli manager\r\n   */\r\n  public async start() {\r\n    const { name, options, args } = parseCliArgs(process.argv);\r\n\r\n    if (options.noCache) {\r\n      manifestManager.clearCommandsCache();\r\n      // remove the commands.json file as wel\r\n      await manifestManager.removeCommandsFile();\r\n    }\r\n\r\n    if (options.version || options.v) {\r\n      await displayWarlockVersionInTerminal();\r\n      process.exit(0);\r\n    }\r\n\r\n    // Try to load from manifest first (fastest path)\r\n    await manifestManager.loadCommands();\r\n\r\n    // Register framework commands first (needed for help)\r\n    this.register(\r\n      ...frameworkCommands.map((command) => {\r\n        if (!command.commandSource) {\r\n          command.commandSource = \"framework\";\r\n        }\r\n        return command;\r\n      }),\r\n    );\r\n\r\n    const isHelpCommand = options.help || options.h;\r\n\r\n    // Handle global help (no command)\r\n    if (!name && isHelpCommand) {\r\n      await this.showGlobalHelp();\r\n      process.exit(0);\r\n    }\r\n\r\n    // Handle warm cache\r\n    if (options.warmCache) {\r\n      await this.warmCache();\r\n      process.exit(0);\r\n    }\r\n\r\n    if (!name) {\r\n      displayMissingCommand();\r\n      process.exit(1);\r\n    }\r\n\r\n    const command = await this.lazyGetCommand(name);\r\n\r\n    if (manifestManager.hasChanges) {\r\n      await manifestManager.saveCommands();\r\n    }\r\n\r\n    if (!command) {\r\n      // Find similar commands for suggestions\r\n      const allCommandNames = this.getAllCommandNames();\r\n      const suggestions = findSimilar(name, allCommandNames).map((s) => s.value);\r\n\r\n      displayCommandNotFound(name, suggestions);\r\n      process.exit(1);\r\n    }\r\n\r\n    // Handle command-specific help\r\n    if (isHelpCommand) {\r\n      displayCommandHelp({\r\n        name: command.name,\r\n        alias: command.commandAlias,\r\n        description: command.commandDescription,\r\n        options: command.commandOptions,\r\n      });\r\n      process.exit(0);\r\n    }\r\n\r\n    await this.execute(command, {\r\n      options,\r\n      args,\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Show global help with all commands\r\n   * Uses manifest if available for fast display\r\n   */\r\n  protected async showGlobalHelp() {\r\n    if (\r\n      manifestManager.isCommandLoaded &&\r\n      Object.keys(manifestManager.commandsJson?.commands || {}).length > 0\r\n    ) {\r\n      // Use manifest directly - no need to load command files\r\n      const helpCommands: HelpCommandInfo[] = Object.entries(\r\n        manifestManager.commandsJson?.commands || {},\r\n      ).map(([name, cmd]) => ({\r\n        name,\r\n        alias: cmd.alias,\r\n        description: cmd.description,\r\n        source: cmd.source,\r\n      }));\r\n\r\n      await displayHelp(helpCommands);\r\n      return;\r\n    }\r\n\r\n    // Fallback: No manifest, build from registered commands\r\n    // This happens on first run before warm-cache\r\n    await this.loadPluginsCommands();\r\n\r\n    const projectCommands = await cliCommandsLoader.scanAll();\r\n\r\n    this.register(...projectCommands);\r\n\r\n    await manifestManager.saveCommands();\r\n\r\n    // Build help info from registered commands\r\n    const helpCommands: HelpCommandInfo[] = this.commands.map((cmd) => ({\r\n      name: cmd.name,\r\n      alias: cmd.commandAlias,\r\n      description: cmd.commandDescription,\r\n      source: cmd.commandSource || \"project\",\r\n    }));\r\n\r\n    await displayHelp(helpCommands);\r\n  }\r\n\r\n  /**\r\n   * Warm cache - scan all project commands and save to manifest\r\n   */\r\n  protected async warmCache() {\r\n    console.log();\r\n    console.log(`  ${colors.cyan(\"›\")} Scanning project commands...`);\r\n\r\n    const projectCommands = await cliCommandsLoader.scanAll();\r\n\r\n    this.register(...projectCommands);\r\n\r\n    await manifestManager.saveCommands();\r\n\r\n    console.log(\r\n      `  ${colors.green(\"✔\")} Cached ${colors.bold(String(projectCommands.length))} project commands`,\r\n    );\r\n    console.log();\r\n  }\r\n\r\n  /**\r\n   * Load plugins commands\r\n   */\r\n  protected async loadPluginsCommands() {\r\n    await warlockConfigManager.load();\r\n\r\n    if (warlockConfigManager.isLoaded) {\r\n      this.register(\r\n        ...(warlockConfigManager.get(\"cli\")?.commands || []).map((command) => {\r\n          if (!command.commandSource) {\r\n            command.commandSource = \"plugin\";\r\n          }\r\n          return command;\r\n        }),\r\n      );\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Try to find the command based on the given command name or alias\r\n   */\r\n  protected async lazyGetCommand(name: string) {\r\n    // first step, try to find it directly through current commands\r\n    let command = this.getCommand(name);\r\n    if (command) {\r\n      return command;\r\n    }\r\n\r\n    // second step, try to find it through warlock config commands\r\n    await this.loadPluginsCommands();\r\n\r\n    command = this.getCommand(name);\r\n\r\n    if (command) {\r\n      return command;\r\n    }\r\n\r\n    // third step, try to find it through project commands\r\n    await this.loadProjectCommands(name);\r\n\r\n    command = this.getCommand(name);\r\n    if (command) {\r\n      return command;\r\n    }\r\n\r\n    return null;\r\n  }\r\n\r\n  /**\r\n   * Load project commands\r\n   */\r\n  protected async loadProjectCommands(name: string) {\r\n    // first get the commands.json contents as an object\r\n    const jsonCommandsFile = await manifestManager.loadCommands();\r\n\r\n    if (jsonCommandsFile) {\r\n      // Check by name or alias\r\n      for (const fullCommandName in jsonCommandsFile.commands) {\r\n        const cmdMeta = jsonCommandsFile.commands[fullCommandName];\r\n\r\n        // Match by name or alias\r\n        if (isMatchingCommandName(fullCommandName, name) || cmdMeta.alias === name) {\r\n          const commandPath = cmdMeta.relativePath;\r\n          if (commandPath) {\r\n            const executedCommand = await cliCommandsLoader.load(commandPath);\r\n\r\n            if (executedCommand) {\r\n              executedCommand.$relativePath(commandPath);\r\n              this.register(executedCommand);\r\n              return;\r\n            }\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    const command = await cliCommandsLoader.locate(name);\r\n\r\n    if (command) {\r\n      this.register(command);\r\n      return;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Validate required options\r\n   */\r\n  protected validateOptions(\r\n    command: CLICommand,\r\n    options: Record<string, string | boolean | number>,\r\n  ): ResolvedCLICommandOption[] {\r\n    const missing: ResolvedCLICommandOption[] = [];\r\n\r\n    command.commandOptions.forEach((opt) => {\r\n      if (opt.required) {\r\n        // Check if option is provided by name or alias\r\n        const hasOption =\r\n          options[opt.name] !== undefined || (opt.alias && options[opt.alias] !== undefined);\r\n        if (!hasOption) {\r\n          missing.push(opt);\r\n        }\r\n      }\r\n    });\r\n\r\n    return missing;\r\n  }\r\n\r\n  /**\r\n   * Apply default values to options\r\n   */\r\n  protected applyDefaultOptions(\r\n    command: CLICommand,\r\n    options: Record<string, string | boolean | number>,\r\n  ): Record<string, string | boolean | number> {\r\n    const result = { ...options };\r\n\r\n    command.commandOptions.forEach((opt) => {\r\n      if (opt.defaultValue !== undefined) {\r\n        const hasOption =\r\n          result[opt.name] !== undefined || (opt.alias && result[opt.alias] !== undefined);\r\n        if (!hasOption) {\r\n          result[opt.name] = opt.defaultValue;\r\n        }\r\n      }\r\n\r\n      if (opt.alias !== undefined && result[opt.alias] && result[opt.name] === undefined) {\r\n        result[opt.name] = result[opt.alias];\r\n      }\r\n    });\r\n\r\n    return result;\r\n  }\r\n\r\n  /**\r\n   * Execute the given command\r\n   */\r\n  public async execute(command: CLICommand, data: CommandActionData) {\r\n    const startTime = Date.now();\r\n\r\n    // Validate required options\r\n    const missingOptions = this.validateOptions(command, data.options);\r\n    if (missingOptions.length > 0) {\r\n      displayMissingOptions(missingOptions);\r\n      process.exit(1);\r\n    }\r\n\r\n    // Apply default values\r\n    data.options = this.applyDefaultOptions(command, data.options);\r\n\r\n    displayExecutingCommand(command.name);\r\n\r\n    if (command.commandPreAction) {\r\n      await command.commandPreAction(data);\r\n    }\r\n\r\n    // load preloaders\r\n    if (command.commandPreload) {\r\n      try {\r\n        await this.loadPreloaders(command);\r\n      } catch (error) {\r\n        // A preload failure (a bad import in a config file, a connector that\r\n        // throws on boot, a missing module export) happens BEFORE the command's\r\n        // action runs — there is no run loop to recover into, so it is ALWAYS\r\n        // fatal, persistent command (dev/start) or not. Surface the real cause\r\n        // and the offending file, then exit. This MUST stay outside the\r\n        // command-execute try/catch below: letting a preload rejection escape\r\n        // turned `warlock dev` into a silent hang — the unhandled rejection slid\r\n        // past while the already-started loader worker thread kept the process\r\n        // alive, freezing just after the banner with no error printed.\r\n        displayBootError(command.name, error as Error);\r\n        process.exit(1);\r\n      }\r\n    }\r\n\r\n    try {\r\n      await command.execute(data);\r\n\r\n      if (!command.isPersistent) {\r\n        displayCommandSuccess(command.name, Date.now() - startTime);\r\n\r\n        process.exit(0);\r\n      }\r\n    } catch (error) {\r\n      displayCommandError(command.name, error as Error);\r\n      // Persistent commands (dev/start) own their startup-failure exits;\r\n      // by the time an error reaches here they've already entered their\r\n      // run loop, so it's a runtime error we log but don't crash on —\r\n      // HMR or process supervisors can recover. Non-persistent\r\n      // one-shot commands always exit on failure.\r\n      if (!command.isPersistent) {\r\n        process.exit(1);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Load preloaders\r\n   */\r\n  protected async loadPreloaders(command: CLICommand) {\r\n    const preloaders = command.commandPreload || {};\r\n\r\n    if (preloaders.runtimeStrategy) {\r\n      Application.setRuntimeStrategy(preloaders.runtimeStrategy);\r\n    }\r\n\r\n    if (preloaders.environemnt) {\r\n      Application.setEnvironment(preloaders.environemnt);\r\n    }\r\n\r\n    // Env BEFORE config, unconditionally, for every command.\r\n    //\r\n    // `warlock.config.ts` is a module whose body runs on import, and projects\r\n    // legitimately call `env(\"BUILD_OUT\", \"dist\")` in it. Loading config first\r\n    // evaluated that body against an empty env store, so every such call\r\n    // silently returned its default — under `build` and `start`, which never\r\n    // loaded env at all, and under `dev` too, because config was loaded first\r\n    // regardless. The ordering is load-bearing in the other direction as well:\r\n    // `loadEnv()` reads `process.env.NODE_ENV` at call time to choose\r\n    // `.env.<NODE_ENV>` over `.env`, so it must follow `setEnvironment` above.\r\n    await loadEnvironmentFiles();\r\n\r\n    await warlockConfigManager.load();\r\n\r\n    if (preloaders.config || preloaders.bootstrap || preloaders.prestart) {\r\n      await filesOrchestrator.init();\r\n    }\r\n\r\n    // `preloaders.env` is gone: env is loaded above for every command, so the\r\n    // branch that used to serve it could only re-parse the same files and\r\n    // re-override `process.env` a second time.\r\n    if (preloaders.bootstrap) {\r\n      await bootstrap();\r\n\r\n      if (await fileExistsAsync(appPath(\"bootstrap.ts\"))) {\r\n        await filesOrchestrator.load(\"src/app/bootstrap.ts\");\r\n      }\r\n    }\r\n\r\n    // Load configuration files\r\n    if (preloaders.config) {\r\n      await loadConfigFiles(preloaders.config);\r\n    }\r\n\r\n    if (preloaders.prestart) {\r\n      if (await fileExistsAsync(appPath(\"prestart.ts\"))) {\r\n        await filesOrchestrator.load(\"src/app/prestart.ts\");\r\n      }\r\n    }\r\n\r\n    // Initialize connectors.\r\n    // `connectors: true` only starts the early phase here — late-phase\r\n    // connectors (http, socket) start after the command's action loads\r\n    // app code. Explicit lists bypass phase splitting (caller knows\r\n    // exactly which connectors they want).\r\n    if (preloaders.connectors) {\r\n      if (preloaders.connectors === true) {\r\n        await connectorsManager.startPhase(ConnectorLifecyclePhase.Early);\r\n      } else {\r\n        await connectorsManager.start(preloaders.connectors);\r\n      }\r\n    }\r\n  }\r\n}\r\n"],"mappings":"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"}
+{"version":3,"file":"cli-commands.manager.mjs","names":[],"sources":["../../../../../../../core/src/cli/cli-commands.manager.ts"],"sourcesContent":["import { colors } from \"@mongez/copper\";\r\nimport { fileExistsAsync } from \"@warlock.js/fs\";\r\nimport { Application } from \"../application\";\r\nimport { bootstrap } from \"../bootstrap\";\r\nimport { loadConfigFiles } from \"../config/load-config-files\";\r\nimport { connectorsManager } from \"../connectors/connectors-manager\";\r\nimport { ConnectorLifecyclePhase } from \"../connectors/types\";\r\nimport { filesOrchestrator } from \"../dev-server/files-orchestrator\";\r\nimport { manifestManager } from \"../manifest/manifest-manager\";\r\nimport { appPath } from \"../utils\";\r\nimport { loadEnvironmentFiles } from \"../utils/load-environment\";\r\nimport { warlockConfigManager } from \"../warlock-config/warlock-config.manager\";\r\nimport { CLICommand } from \"../commands/cli-command\";\r\nimport {\r\n  displayBootError,\r\n  displayCommandError,\r\n  displayCommandHelp,\r\n  displayCommandNotFound,\r\n  displayCommandSuccess,\r\n  displayExecutingCommand,\r\n  displayHelp,\r\n  displayMissingCommand,\r\n  displayMissingOptions,\r\n  displayWarlockVersionInTerminal,\r\n  type HelpCommandInfo,\r\n  isMatchingCommandName,\r\n} from \"./cli-commands.utils\";\r\nimport { cliCommandsLoader } from \"./commands-loader\";\r\nimport { frameworkCommands } from \"./framework-cli-commands\";\r\nimport { CliOptionValueError, ParsedCliArgs, parseCliArgs } from \"./parse-cli-args\";\r\nimport { findSimilar } from \"./string-similarity\";\r\nimport { CommandActionData, ResolvedCLICommandOption } from \"../commands/types\";\r\n\r\nexport class CLICommandsManager {\r\n  /**\r\n   * List of commands\r\n   */\r\n  public commands: CLICommand[] = [];\r\n\r\n  /**\r\n   * Commands map (name -> command)\r\n   */\r\n  public commandsMap: Map<string, CLICommand> = new Map();\r\n\r\n  /**\r\n   * Alias map (alias -> command name)\r\n   */\r\n  public aliasMap: Map<string, string> = new Map();\r\n\r\n  /**\r\n   * Register the given commands\r\n   */\r\n  public register(...commands: CLICommand[]): this {\r\n    this.commands.push(...commands);\r\n\r\n    commands.forEach((command) => {\r\n      const commandKey = command.name.split(\" \")[0];\r\n\r\n      manifestManager.addCommandToList(command.name, {\r\n        relativePath: command.commandRelativePath,\r\n        source: command.commandSource || \"project\",\r\n        description: command.commandDescription,\r\n        alias: command.commandAlias,\r\n        options: command.commandOptions.length > 0 ? command.commandOptions : undefined,\r\n      });\r\n\r\n      this.commandsMap.set(commandKey, command);\r\n\r\n      // Register alias if exists\r\n      if (command.commandAlias) {\r\n        this.aliasMap.set(command.commandAlias, commandKey);\r\n      }\r\n    });\r\n\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Get command by name or alias\r\n   */\r\n  public getCommand(name: string): CLICommand | undefined {\r\n    // First try direct lookup\r\n    let command = this.commandsMap.get(name);\r\n    if (command) return command;\r\n\r\n    // Try alias lookup\r\n    const realName = this.aliasMap.get(name);\r\n    if (realName) {\r\n      return this.commandsMap.get(realName);\r\n    }\r\n\r\n    return;\r\n  }\r\n\r\n  /**\r\n   * Get all command names and aliases\r\n   * Used for fuzzy matching suggestions\r\n   */\r\n  public getAllCommandNames(): string[] {\r\n    const names: string[] = [];\r\n\r\n    // Add all command names\r\n    for (const name of this.commandsMap.keys()) {\r\n      names.push(name);\r\n    }\r\n\r\n    // Add all aliases\r\n    for (const alias of this.aliasMap.keys()) {\r\n      names.push(alias);\r\n    }\r\n\r\n    // Also include cached commands from manifest\r\n    const manifestCommands = manifestManager.commandsJson?.commands || {};\r\n    for (const name of Object.keys(manifestCommands)) {\r\n      const baseName = name.split(\" \")[0];\r\n      if (!names.includes(baseName)) {\r\n        names.push(baseName);\r\n      }\r\n      const alias = manifestCommands[name].alias;\r\n      if (alias && !names.includes(alias)) {\r\n        names.push(alias);\r\n      }\r\n    }\r\n\r\n    return names;\r\n  }\r\n\r\n  /**\r\n   * Start the cli manager\r\n   */\r\n  public async start() {\r\n    // Schema-less first pass: it exists to discover the command name and the\r\n    // command-independent flags (--help, --version, --no-cache). Values here are\r\n    // raw strings; the typed pass below is the one whose options reach a command.\r\n    const { name, options } = parseCliArgs(process.argv);\r\n\r\n    if (options.noCache) {\r\n      manifestManager.clearCommandsCache();\r\n      // remove the commands.json file as wel\r\n      await manifestManager.removeCommandsFile();\r\n    }\r\n\r\n    if (options.version || options.v) {\r\n      await displayWarlockVersionInTerminal();\r\n      process.exit(0);\r\n    }\r\n\r\n    // Try to load from manifest first (fastest path)\r\n    await manifestManager.loadCommands();\r\n\r\n    // Register framework commands first (needed for help)\r\n    this.register(\r\n      ...frameworkCommands.map((command) => {\r\n        if (!command.commandSource) {\r\n          command.commandSource = \"framework\";\r\n        }\r\n        return command;\r\n      }),\r\n    );\r\n\r\n    const isHelpCommand = options.help || options.h;\r\n\r\n    // Handle global help (no command)\r\n    if (!name && isHelpCommand) {\r\n      await this.showGlobalHelp();\r\n      process.exit(0);\r\n    }\r\n\r\n    // Handle warm cache\r\n    if (options.warmCache) {\r\n      await this.warmCache();\r\n      process.exit(0);\r\n    }\r\n\r\n    if (!name) {\r\n      displayMissingCommand();\r\n      process.exit(1);\r\n    }\r\n\r\n    const command = await this.lazyGetCommand(name);\r\n\r\n    if (manifestManager.hasChanges) {\r\n      await manifestManager.saveCommands();\r\n    }\r\n\r\n    if (!command) {\r\n      // Find similar commands for suggestions\r\n      const allCommandNames = this.getAllCommandNames();\r\n      const suggestions = findSimilar(name, allCommandNames).map((s) => s.value);\r\n\r\n      displayCommandNotFound(name, suggestions);\r\n      process.exit(1);\r\n    }\r\n\r\n    // Handle command-specific help\r\n    if (isHelpCommand) {\r\n      displayCommandHelp({\r\n        name: command.name,\r\n        alias: command.commandAlias,\r\n        description: command.commandDescription,\r\n        options: command.commandOptions,\r\n      });\r\n      process.exit(0);\r\n    }\r\n\r\n    // The first parse above had no command to consult, so every value in it is\r\n    // a raw string. Now that the command is resolved, re-read argv against its\r\n    // declared options so a `type: \"boolean\"` option arrives as a boolean.\r\n    const resolved = this.resolveCommandArgs(command);\r\n\r\n    await this.execute(command, {\r\n      options: resolved.options,\r\n      args: resolved.args,\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Re-parse argv against the resolved command's declared options.\r\n   *\r\n   * parseCliArgs runs twice on purpose. The first run produces the command\r\n   * name, and there is no schema to consult yet; the second one, here, can be\r\n   * type-aware. Re-reading argv (rather than post-processing the first result)\r\n   * is what makes `--rollback users.ts` recoverable: by the time the first pass\r\n   * returns, the swallowed positional is indistinguishable from a value.\r\n   */\r\n  protected resolveCommandArgs(command: CLICommand, argv: string[] = process.argv): ParsedCliArgs {\r\n    try {\r\n      return parseCliArgs(argv, command.commandOptions);\r\n    } catch (error) {\r\n      if (error instanceof CliOptionValueError) {\r\n        console.log();\r\n        console.log(`  ${colors.redBright(\"Error:\")} ${error.message}`);\r\n        console.log();\r\n        process.exit(1);\r\n      }\r\n\r\n      throw error;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Show global help with all commands\r\n   * Uses manifest if available for fast display\r\n   */\r\n  protected async showGlobalHelp() {\r\n    if (\r\n      manifestManager.isCommandLoaded &&\r\n      Object.keys(manifestManager.commandsJson?.commands || {}).length > 0\r\n    ) {\r\n      // Use manifest directly - no need to load command files\r\n      const helpCommands: HelpCommandInfo[] = Object.entries(\r\n        manifestManager.commandsJson?.commands || {},\r\n      ).map(([name, cmd]) => ({\r\n        name,\r\n        alias: cmd.alias,\r\n        description: cmd.description,\r\n        source: cmd.source,\r\n      }));\r\n\r\n      await displayHelp(helpCommands);\r\n      return;\r\n    }\r\n\r\n    // Fallback: No manifest, build from registered commands\r\n    // This happens on first run before warm-cache\r\n    await this.loadPluginsCommands();\r\n\r\n    const projectCommands = await cliCommandsLoader.scanAll();\r\n\r\n    this.register(...projectCommands);\r\n\r\n    await manifestManager.saveCommands();\r\n\r\n    // Build help info from registered commands\r\n    const helpCommands: HelpCommandInfo[] = this.commands.map((cmd) => ({\r\n      name: cmd.name,\r\n      alias: cmd.commandAlias,\r\n      description: cmd.commandDescription,\r\n      source: cmd.commandSource || \"project\",\r\n    }));\r\n\r\n    await displayHelp(helpCommands);\r\n  }\r\n\r\n  /**\r\n   * Warm cache - scan all project commands and save to manifest\r\n   */\r\n  protected async warmCache() {\r\n    console.log();\r\n    console.log(`  ${colors.cyan(\"›\")} Scanning project commands...`);\r\n\r\n    const projectCommands = await cliCommandsLoader.scanAll();\r\n\r\n    this.register(...projectCommands);\r\n\r\n    await manifestManager.saveCommands();\r\n\r\n    console.log(\r\n      `  ${colors.green(\"✔\")} Cached ${colors.bold(String(projectCommands.length))} project commands`,\r\n    );\r\n    console.log();\r\n  }\r\n\r\n  /**\r\n   * Load plugins commands\r\n   */\r\n  protected async loadPluginsCommands() {\r\n    await warlockConfigManager.load();\r\n\r\n    if (warlockConfigManager.isLoaded) {\r\n      this.register(\r\n        ...(warlockConfigManager.get(\"cli\")?.commands || []).map((command) => {\r\n          if (!command.commandSource) {\r\n            command.commandSource = \"plugin\";\r\n          }\r\n          return command;\r\n        }),\r\n      );\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Try to find the command based on the given command name or alias\r\n   */\r\n  protected async lazyGetCommand(name: string) {\r\n    // first step, try to find it directly through current commands\r\n    let command = this.getCommand(name);\r\n    if (command) {\r\n      return command;\r\n    }\r\n\r\n    // second step, try to find it through warlock config commands\r\n    await this.loadPluginsCommands();\r\n\r\n    command = this.getCommand(name);\r\n\r\n    if (command) {\r\n      return command;\r\n    }\r\n\r\n    // third step, try to find it through project commands\r\n    await this.loadProjectCommands(name);\r\n\r\n    command = this.getCommand(name);\r\n    if (command) {\r\n      return command;\r\n    }\r\n\r\n    return null;\r\n  }\r\n\r\n  /**\r\n   * Load project commands\r\n   */\r\n  protected async loadProjectCommands(name: string) {\r\n    // first get the commands.json contents as an object\r\n    const jsonCommandsFile = await manifestManager.loadCommands();\r\n\r\n    if (jsonCommandsFile) {\r\n      // Check by name or alias\r\n      for (const fullCommandName in jsonCommandsFile.commands) {\r\n        const cmdMeta = jsonCommandsFile.commands[fullCommandName];\r\n\r\n        // Match by name or alias\r\n        if (isMatchingCommandName(fullCommandName, name) || cmdMeta.alias === name) {\r\n          const commandPath = cmdMeta.relativePath;\r\n          if (commandPath) {\r\n            const executedCommand = await cliCommandsLoader.load(commandPath);\r\n\r\n            if (executedCommand) {\r\n              executedCommand.$relativePath(commandPath);\r\n              this.register(executedCommand);\r\n              return;\r\n            }\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    const command = await cliCommandsLoader.locate(name);\r\n\r\n    if (command) {\r\n      this.register(command);\r\n      return;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Validate required options\r\n   */\r\n  protected validateOptions(\r\n    command: CLICommand,\r\n    options: Record<string, string | boolean | number>,\r\n  ): ResolvedCLICommandOption[] {\r\n    const missing: ResolvedCLICommandOption[] = [];\r\n\r\n    command.commandOptions.forEach((opt) => {\r\n      if (opt.required) {\r\n        // Check if option is provided by name or alias\r\n        const hasOption =\r\n          options[opt.name] !== undefined || (opt.alias && options[opt.alias] !== undefined);\r\n        if (!hasOption) {\r\n          missing.push(opt);\r\n        }\r\n      }\r\n    });\r\n\r\n    return missing;\r\n  }\r\n\r\n  /**\r\n   * Apply default values to options\r\n   */\r\n  protected applyDefaultOptions(\r\n    command: CLICommand,\r\n    options: Record<string, string | boolean | number>,\r\n  ): Record<string, string | boolean | number> {\r\n    const result = { ...options };\r\n\r\n    command.commandOptions.forEach((opt) => {\r\n      if (opt.defaultValue !== undefined) {\r\n        const hasOption =\r\n          result[opt.name] !== undefined || (opt.alias && result[opt.alias] !== undefined);\r\n        if (!hasOption) {\r\n          result[opt.name] = opt.defaultValue;\r\n        }\r\n      }\r\n\r\n      // `!== undefined`, not truthiness: `-r=false` now resolves to the boolean\r\n      // `false`, and a truthiness test would drop it before it ever reached the\r\n      // canonical name — leaving `rollback` undefined instead of explicitly off.\r\n      if (\r\n        opt.alias !== undefined &&\r\n        result[opt.alias] !== undefined &&\r\n        result[opt.name] === undefined\r\n      ) {\r\n        result[opt.name] = result[opt.alias];\r\n      }\r\n    });\r\n\r\n    return result;\r\n  }\r\n\r\n  /**\r\n   * Execute the given command\r\n   */\r\n  public async execute(command: CLICommand, data: CommandActionData) {\r\n    const startTime = Date.now();\r\n\r\n    // Validate required options\r\n    const missingOptions = this.validateOptions(command, data.options);\r\n    if (missingOptions.length > 0) {\r\n      displayMissingOptions(missingOptions);\r\n      process.exit(1);\r\n    }\r\n\r\n    // Apply default values\r\n    data.options = this.applyDefaultOptions(command, data.options);\r\n\r\n    displayExecutingCommand(command.name);\r\n\r\n    if (command.commandPreAction) {\r\n      await command.commandPreAction(data);\r\n    }\r\n\r\n    // load preloaders\r\n    if (command.commandPreload) {\r\n      try {\r\n        await this.loadPreloaders(command);\r\n      } catch (error) {\r\n        // A preload failure (a bad import in a config file, a connector that\r\n        // throws on boot, a missing module export) happens BEFORE the command's\r\n        // action runs — there is no run loop to recover into, so it is ALWAYS\r\n        // fatal, persistent command (dev/start) or not. Surface the real cause\r\n        // and the offending file, then exit. This MUST stay outside the\r\n        // command-execute try/catch below: letting a preload rejection escape\r\n        // turned `warlock dev` into a silent hang — the unhandled rejection slid\r\n        // past while the already-started loader worker thread kept the process\r\n        // alive, freezing just after the banner with no error printed.\r\n        displayBootError(command.name, error as Error);\r\n        process.exit(1);\r\n      }\r\n    }\r\n\r\n    try {\r\n      await command.execute(data);\r\n\r\n      if (!command.isPersistent) {\r\n        displayCommandSuccess(command.name, Date.now() - startTime);\r\n\r\n        process.exit(0);\r\n      }\r\n    } catch (error) {\r\n      displayCommandError(command.name, error as Error);\r\n      // Persistent commands (dev/start) own their startup-failure exits;\r\n      // by the time an error reaches here they've already entered their\r\n      // run loop, so it's a runtime error we log but don't crash on —\r\n      // HMR or process supervisors can recover. Non-persistent\r\n      // one-shot commands always exit on failure.\r\n      if (!command.isPersistent) {\r\n        process.exit(1);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Load preloaders\r\n   */\r\n  protected async loadPreloaders(command: CLICommand) {\r\n    const preloaders = command.commandPreload || {};\r\n\r\n    if (preloaders.runtimeStrategy) {\r\n      Application.setRuntimeStrategy(preloaders.runtimeStrategy);\r\n    }\r\n\r\n    if (preloaders.environemnt) {\r\n      Application.setEnvironment(preloaders.environemnt);\r\n    }\r\n\r\n    // Env BEFORE config, unconditionally, for every command.\r\n    //\r\n    // `warlock.config.ts` is a module whose body runs on import, and projects\r\n    // legitimately call `env(\"BUILD_OUT\", \"dist\")` in it. Loading config first\r\n    // evaluated that body against an empty env store, so every such call\r\n    // silently returned its default — under `build` and `start`, which never\r\n    // loaded env at all, and under `dev` too, because config was loaded first\r\n    // regardless. The ordering is load-bearing in the other direction as well:\r\n    // `loadEnv()` reads `process.env.NODE_ENV` at call time to choose\r\n    // `.env.<NODE_ENV>` over `.env`, so it must follow `setEnvironment` above.\r\n    await loadEnvironmentFiles();\r\n\r\n    await warlockConfigManager.load();\r\n\r\n    if (preloaders.config || preloaders.bootstrap || preloaders.prestart) {\r\n      await filesOrchestrator.init();\r\n    }\r\n\r\n    // `preloaders.env` is gone: env is loaded above for every command, so the\r\n    // branch that used to serve it could only re-parse the same files and\r\n    // re-override `process.env` a second time.\r\n    if (preloaders.bootstrap) {\r\n      await bootstrap();\r\n\r\n      if (await fileExistsAsync(appPath(\"bootstrap.ts\"))) {\r\n        await filesOrchestrator.load(\"src/app/bootstrap.ts\");\r\n      }\r\n    }\r\n\r\n    // Load configuration files\r\n    if (preloaders.config) {\r\n      await loadConfigFiles(preloaders.config);\r\n    }\r\n\r\n    if (preloaders.prestart) {\r\n      if (await fileExistsAsync(appPath(\"prestart.ts\"))) {\r\n        await filesOrchestrator.load(\"src/app/prestart.ts\");\r\n      }\r\n    }\r\n\r\n    // Initialize connectors.\r\n    // `connectors: true` only starts the early phase here — late-phase\r\n    // connectors (http, socket) start after the command's action loads\r\n    // app code. Explicit lists bypass phase splitting (caller knows\r\n    // exactly which connectors they want).\r\n    if (preloaders.connectors) {\r\n      if (preloaders.connectors === true) {\r\n        await connectorsManager.startPhase(ConnectorLifecyclePhase.Early);\r\n      } else {\r\n        await connectorsManager.start(preloaders.connectors);\r\n      }\r\n    }\r\n  }\r\n}\r\n"],"mappings":"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"}

package/esm/cli/commands/add.command.mjs

@@ -1,4 +1,4 @@
-import { command } from "../cli-command.mjs";
+import { command } from "../../commands/cli-command.mjs";
 import { addCommandAction } from "../../generations/add-command.action.mjs";
 
 //#region ../core/src/cli/commands/add.command.ts
@@ -13,11 +13,13 @@ const addCommand = command({
 		},
 		{
 			text: "--list, -l",
-			description: "List available features"
+			description: "List available features",
+			type: "boolean"
 		},
 		{
 			text: "--no-install",
-			description: "Record dependencies in package.json without installing them — still ejects configs, adds scripts, and runs setup hooks. Pass it last, after the feature list. Used by scaffolders that run a single install afterwards."
+			description: "Record dependencies in package.json without installing them — still ejects configs, adds scripts, and runs setup hooks. Used by scaffolders that run a single install afterwards.",
+			type: "boolean"
 		}
 	]
 });

package/esm/cli/commands/add.command.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"add.command.mjs","names":[],"sources":["../../../../../../../../core/src/cli/commands/add.command.ts"],"sourcesContent":["import { addCommandAction } from \"../../generations/add-command.action\";\r\nimport { command } from \"../cli-command\";\r\n\r\nexport const addCommand = command({\r\n  name: \"add <features...>\",\r\n  description: \"Add new feature(s) to the project\",\r\n  action: addCommandAction,\r\n  options: [\r\n    {\r\n      text: \"--package-manager -pm\",\r\n      description: \"Package manager to use, if not passed, it will be detected automatically\",\r\n    },\r\n    {\r\n      text: \"--list, -l\",\r\n      description: \"List available features\",\r\n    },\r\n    {\r\n      text: \"--no-install\",\r\n      description:\r\n        \"Record dependencies in package.json without installing them — still ejects configs, adds scripts, and runs setup hooks. Pass it last, after the feature list. Used by scaffolders that run a single install afterwards.\",\r\n    },\r\n  ],\r\n});\r\n"],"mappings":";;;;AAGA,MAAa,aAAa,QAAQ;CAChC,MAAM;CACN,aAAa;CACb,QAAQ;CACR,SAAS;EACP;GACE,MAAM;GACN,aAAa;EACf;EACA;GACE,MAAM;GACN,aAAa;EACf;EACA;GACE,MAAM;GACN,aACE;EACJ;CACF;AACF,CAAC"}
+{"version":3,"file":"add.command.mjs","names":[],"sources":["../../../../../../../../core/src/cli/commands/add.command.ts"],"sourcesContent":["import { addCommandAction } from \"../../generations/add-command.action\";\r\nimport { command } from \"../../commands/cli-command\";\r\n\r\nexport const addCommand = command({\r\n  name: \"add <features...>\",\r\n  description: \"Add new feature(s) to the project\",\r\n  action: addCommandAction,\r\n  options: [\r\n    {\r\n      text: \"--package-manager -pm\",\r\n      description: \"Package manager to use, if not passed, it will be detected automatically\",\r\n    },\r\n    {\r\n      text: \"--list, -l\",\r\n      description: \"List available features\",\r\n      type: \"boolean\",\r\n    },\r\n    {\r\n      text: \"--no-install\",\r\n      description:\r\n        \"Record dependencies in package.json without installing them — still ejects configs, adds scripts, and runs setup hooks. Used by scaffolders that run a single install afterwards.\",\r\n      type: \"boolean\",\r\n    },\r\n  ],\r\n});\r\n"],"mappings":";;;;AAGA,MAAa,aAAa,QAAQ;CAChC,MAAM;CACN,aAAa;CACb,QAAQ;CACR,SAAS;EACP;GACE,MAAM;GACN,aAAa;EACf;EACA;GACE,MAAM;GACN,aAAa;GACb,MAAM;EACR;EACA;GACE,MAAM;GACN,aACE;GACF,MAAM;EACR;CACF;AACF,CAAC"}

package/esm/cli/commands/build.command.mjs

@@ -1,4 +1,4 @@
-import { command } from "../cli-command.mjs";
+import { command } from "../../commands/cli-command.mjs";
 import { buildAppProduction } from "../../production/build-app-production.mjs";
 
 //#region ../core/src/cli/commands/build.command.ts

package/esm/cli/commands/build.command.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"build.command.mjs","names":[],"sources":["../../../../../../../../core/src/cli/commands/build.command.ts"],"sourcesContent":["import { buildAppProduction } from \"../../production/build-app-production\";\nimport { command } from \"../cli-command\";\n\nexport const buildCommand = command({\n  name: \"build\",\n  description: \"Build the project for production\",\n  action: buildAppProduction,\n  preload: {\n    warlockConfig: true,\n  },\n});\n"],"mappings":";;;;AAGA,MAAa,eAAe,QAAQ;CAClC,MAAM;CACN,aAAa;CACb,QAAQ;CACR,SAAS,EACP,eAAe,KACjB;AACF,CAAC"}
+{"version":3,"file":"build.command.mjs","names":[],"sources":["../../../../../../../../core/src/cli/commands/build.command.ts"],"sourcesContent":["import { buildAppProduction } from \"../../production/build-app-production\";\r\nimport { command } from \"../../commands/cli-command\";\r\n\r\nexport const buildCommand = command({\r\n  name: \"build\",\r\n  description: \"Build the project for production\",\r\n  action: buildAppProduction,\r\n  preload: {\r\n    warlockConfig: true,\r\n  },\r\n});\r\n"],"mappings":";;;;AAGA,MAAa,eAAe,QAAQ;CAClC,MAAM;CACN,aAAa;CACb,QAAQ;CACR,SAAS,EACP,eAAe,KACjB;AACF,CAAC"}

package/esm/cli/commands/create-database.command.mjs

@@ -1,4 +1,4 @@
-import { command } from "../cli-command.mjs";
+import { command } from "../../commands/cli-command.mjs";
 import { createDatabaseAction } from "../../database/create-database-action.mjs";
 
 //#region ../core/src/cli/commands/create-database.command.ts

package/esm/cli/commands/create-database.command.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"create-database.command.mjs","names":[],"sources":["../../../../../../../../core/src/cli/commands/create-database.command.ts"],"sourcesContent":["import { createDatabaseAction } from \"../../database/create-database-action\";\nimport { command } from \"../cli-command\";\n\nexport const createDatabaseCommand = command({\n  name: \"create-database <name>\",\n  alias: \"cdb\",\n  description: \"Create a new database\",\n  action: createDatabaseAction,\n  preload: {\n    config: [\"database\", \"log\"],\n    env: true,\n    connectors: [\"database\"],\n  },\n  options: [\n    {\n      text: \"--connection, -c\",\n      description: \"Database connection name\",\n      defaultValue: \"default\",\n    },\n  ],\n});\n"],"mappings":";;;;AAGA,MAAa,wBAAwB,QAAQ;CAC3C,MAAM;CACN,OAAO;CACP,aAAa;CACb,QAAQ;CACR,SAAS;EACP,QAAQ,CAAC,YAAY,KAAK;EAC1B,KAAK;EACL,YAAY,CAAC,UAAU;CACzB;CACA,SAAS,CACP;EACE,MAAM;EACN,aAAa;EACb,cAAc;CAChB,CACF;AACF,CAAC"}
+{"version":3,"file":"create-database.command.mjs","names":[],"sources":["../../../../../../../../core/src/cli/commands/create-database.command.ts"],"sourcesContent":["import { createDatabaseAction } from \"../../database/create-database-action\";\r\nimport { command } from \"../../commands/cli-command\";\r\n\r\nexport const createDatabaseCommand = command({\r\n  name: \"create-database <name>\",\r\n  alias: \"cdb\",\r\n  description: \"Create a new database\",\r\n  action: createDatabaseAction,\r\n  preload: {\r\n    config: [\"database\", \"log\"],\r\n    env: true,\r\n    connectors: [\"database\"],\r\n  },\r\n  options: [\r\n    {\r\n      text: \"--connection, -c\",\r\n      description: \"Database connection name\",\r\n      defaultValue: \"default\",\r\n    },\r\n  ],\r\n});\r\n"],"mappings":";;;;AAGA,MAAa,wBAAwB,QAAQ;CAC3C,MAAM;CACN,OAAO;CACP,aAAa;CACb,QAAQ;CACR,SAAS;EACP,QAAQ,CAAC,YAAY,KAAK;EAC1B,KAAK;EACL,YAAY,CAAC,UAAU;CACzB;CACA,SAAS,CACP;EACE,MAAM;EACN,aAAa;EACb,cAAc;CAChB,CACF;AACF,CAAC"}

package/esm/cli/commands/dev-server.command.mjs

@@ -1,4 +1,4 @@
-import { command } from "../cli-command.mjs";
+import { command } from "../../commands/cli-command.mjs";
 import { displayStartupBanner } from "../cli-commands.utils.mjs";
 import { isDevWorker, superviseDevServer } from "../../dev-server/supervisor.mjs";
 import { checkForFrameworkUpdate } from "../../dev-server/check-for-updates.mjs";

package/esm/cli/commands/dev-server.command.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"dev-server.command.mjs","names":[],"sources":["../../../../../../../../core/src/cli/commands/dev-server.command.ts"],"sourcesContent":["import { checkForFrameworkUpdate } from \"../../dev-server/check-for-updates\";\r\nimport { startDevelopmentServer } from \"../../dev-server/start-development-server\";\r\nimport { isDevWorker, superviseDevServer } from \"../../dev-server/supervisor\";\r\nimport { command } from \"../cli-command\";\r\nimport { displayStartupBanner } from \"../cli-commands.utils\";\r\n\r\nexport const devServerCommand = command({\r\n  name: \"dev\",\r\n  description: \"Start development server (HMR, type-gen, health checks)\",\r\n  persistent: true,\r\n  preload: {\r\n    runtimeStrategy: \"development\",\r\n    config: true, // load all config\r\n    bootstrap: true,\r\n    prestart: true, // load prestart file (if exists)\r\n    // Only the Early lifecycle phase starts here; the Late phase\r\n    // (http, socket) starts after app modules load — see\r\n    // development-server.ts STEP 8.5.\r\n    connectors: true,\r\n  },\r\n  preAction: async () => {\r\n    // Two roles share this command. The first `warlock dev` becomes a thin\r\n    // supervisor that owns the terminal and (re)spawns the real server; the\r\n    // process it spawns carries WARLOCK_DEV_WORKER and falls through to the\r\n    // server itself. See supervisor.ts for why the split exists.\r\n    //\r\n    // This branch has to sit in `preAction`, which runs BEFORE the command's\r\n    // preloaders: the supervisor must never load config or start connectors,\r\n    // or it would hold a second database connection open for the whole\r\n    // session. `superviseDevServer()` never resolves, so nothing below it —\r\n    // preload included — runs in the supervisor.\r\n    if (!isDevWorker()) {\r\n      return superviseDevServer();\r\n    }\r\n\r\n    await displayStartupBanner({ environment: \"development\" });\r\n  },\r\n  action: async (data) => {\r\n    const devServer = await startDevelopmentServer({\r\n      fresh: Boolean(data.options.fresh),\r\n      // Pass `false` only when the CLI flag is explicitly set; `undefined`\r\n      // lets `warlock.config.ts > devServer.*` defaults apply.\r\n      generateTypings: data.options.skipTypings ? false : undefined,\r\n      healthCheckers: data.options.skipHealth ? false : undefined,\r\n    });\r\n\r\n    // Fire-and-forget: once the server is ready, surface a one-line notice if\r\n    // a newer @warlock.js/core has been published, and arm the `u` shortcut\r\n    // that updates + restarts. Fully self-guarded — it never blocks startup\r\n    // nor breaks dev if the registry is unreachable.\r\n    void checkForFrameworkUpdate(devServer);\r\n  },\r\n  options: [\r\n    {\r\n      text: \"--fresh, -f\",\r\n      description: \"Delete .warlock/manifest.json before start (force full re-parse from disk)\",\r\n      type: \"boolean\",\r\n    },\r\n    {\r\n      text: \"--skip-typings, -st\",\r\n      description: \"Skip background type generation for this run\",\r\n      type: \"boolean\",\r\n    },\r\n    {\r\n      text: \"--skip-health, -sh\",\r\n      description: \"Skip file health checkers for this run\",\r\n      type: \"boolean\",\r\n    },\r\n  ],\r\n});\r\n"],"mappings":";;;;;;;AAMA,MAAa,mBAAmB,QAAQ;CACtC,MAAM;CACN,aAAa;CACb,YAAY;CACZ,SAAS;EACP,iBAAiB;EACjB,QAAQ;EACR,WAAW;EACX,UAAU;EAIV,YAAY;CACd;CACA,WAAW,YAAY;EAWrB,IAAI,CAAC,YAAY,GACf,OAAO,mBAAmB;EAG5B,MAAM,qBAAqB,EAAE,aAAa,cAAc,CAAC;CAC3D;CACA,QAAQ,OAAO,SAAS;EAatB,AAAK,wBAAwB,MAZL,uBAAuB;GAC7C,OAAO,QAAQ,KAAK,QAAQ,KAAK;GAGjC,iBAAiB,KAAK,QAAQ,cAAc,QAAQ;GACpD,gBAAgB,KAAK,QAAQ,aAAa,QAAQ;EACpD,CAAC,CAMqC;CACxC;CACA,SAAS;EACP;GACE,MAAM;GACN,aAAa;GACb,MAAM;EACR;EACA;GACE,MAAM;GACN,aAAa;GACb,MAAM;EACR;EACA;GACE,MAAM;GACN,aAAa;GACb,MAAM;EACR;CACF;AACF,CAAC"}
+{"version":3,"file":"dev-server.command.mjs","names":[],"sources":["../../../../../../../../core/src/cli/commands/dev-server.command.ts"],"sourcesContent":["import { checkForFrameworkUpdate } from \"../../dev-server/check-for-updates\";\r\nimport { startDevelopmentServer } from \"../../dev-server/start-development-server\";\r\nimport { isDevWorker, superviseDevServer } from \"../../dev-server/supervisor\";\r\nimport { command } from \"../../commands/cli-command\";\r\nimport { displayStartupBanner } from \"../cli-commands.utils\";\r\n\r\nexport const devServerCommand = command({\r\n  name: \"dev\",\r\n  description: \"Start development server (HMR, type-gen, health checks)\",\r\n  persistent: true,\r\n  preload: {\r\n    runtimeStrategy: \"development\",\r\n    config: true, // load all config\r\n    bootstrap: true,\r\n    prestart: true, // load prestart file (if exists)\r\n    // Only the Early lifecycle phase starts here; the Late phase\r\n    // (http, socket) starts after app modules load — see\r\n    // development-server.ts STEP 8.5.\r\n    connectors: true,\r\n  },\r\n  preAction: async () => {\r\n    // Two roles share this command. The first `warlock dev` becomes a thin\r\n    // supervisor that owns the terminal and (re)spawns the real server; the\r\n    // process it spawns carries WARLOCK_DEV_WORKER and falls through to the\r\n    // server itself. See supervisor.ts for why the split exists.\r\n    //\r\n    // This branch has to sit in `preAction`, which runs BEFORE the command's\r\n    // preloaders: the supervisor must never load config or start connectors,\r\n    // or it would hold a second database connection open for the whole\r\n    // session. `superviseDevServer()` never resolves, so nothing below it —\r\n    // preload included — runs in the supervisor.\r\n    if (!isDevWorker()) {\r\n      return superviseDevServer();\r\n    }\r\n\r\n    await displayStartupBanner({ environment: \"development\" });\r\n  },\r\n  action: async (data) => {\r\n    const devServer = await startDevelopmentServer({\r\n      fresh: Boolean(data.options.fresh),\r\n      // Pass `false` only when the CLI flag is explicitly set; `undefined`\r\n      // lets `warlock.config.ts > devServer.*` defaults apply.\r\n      generateTypings: data.options.skipTypings ? false : undefined,\r\n      healthCheckers: data.options.skipHealth ? false : undefined,\r\n    });\r\n\r\n    // Fire-and-forget: once the server is ready, surface a one-line notice if\r\n    // a newer @warlock.js/core has been published, and arm the `u` shortcut\r\n    // that updates + restarts. Fully self-guarded — it never blocks startup\r\n    // nor breaks dev if the registry is unreachable.\r\n    void checkForFrameworkUpdate(devServer);\r\n  },\r\n  options: [\r\n    {\r\n      text: \"--fresh, -f\",\r\n      description: \"Delete .warlock/manifest.json before start (force full re-parse from disk)\",\r\n      type: \"boolean\",\r\n    },\r\n    {\r\n      text: \"--skip-typings, -st\",\r\n      description: \"Skip background type generation for this run\",\r\n      type: \"boolean\",\r\n    },\r\n    {\r\n      text: \"--skip-health, -sh\",\r\n      description: \"Skip file health checkers for this run\",\r\n      type: \"boolean\",\r\n    },\r\n  ],\r\n});\r\n"],"mappings":";;;;;;;AAMA,MAAa,mBAAmB,QAAQ;CACtC,MAAM;CACN,aAAa;CACb,YAAY;CACZ,SAAS;EACP,iBAAiB;EACjB,QAAQ;EACR,WAAW;EACX,UAAU;EAIV,YAAY;CACd;CACA,WAAW,YAAY;EAWrB,IAAI,CAAC,YAAY,GACf,OAAO,mBAAmB;EAG5B,MAAM,qBAAqB,EAAE,aAAa,cAAc,CAAC;CAC3D;CACA,QAAQ,OAAO,SAAS;EAatB,AAAK,wBAAwB,MAZL,uBAAuB;GAC7C,OAAO,QAAQ,KAAK,QAAQ,KAAK;GAGjC,iBAAiB,KAAK,QAAQ,cAAc,QAAQ;GACpD,gBAAgB,KAAK,QAAQ,aAAa,QAAQ;EACpD,CAAC,CAMqC;CACxC;CACA,SAAS;EACP;GACE,MAAM;GACN,aAAa;GACb,MAAM;EACR;EACA;GACE,MAAM;GACN,aAAa;GACb,MAAM;EACR;EACA;GACE,MAAM;GACN,aAAa;GACb,MAAM;EACR;CACF;AACF,CAAC"}

package/esm/cli/commands/doctor/doctor-command.action.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"doctor-command.action.mjs","names":[],"sources":["../../../../../../../../../core/src/cli/commands/doctor/doctor-command.action.ts"],"sourcesContent":["import type { CommandActionData } from \"../../types\";\nimport { defaultDoctorChecks } from \"./checks\";\nimport { printReport } from \"./format-report\";\nimport { runChecks } from \"./run-checks\";\n\n/**\n * Action behind `warlock doctor`. Runs the default read-only diagnostic\n * checks, prints the grouped pass/warn/fail report, and — when any check\n * failed — exits the process with a non-zero code so the command signals\n * failure to scripts/CI.\n *\n * A failing check is REPORTED (a line in the report + a non-zero exit), never\n * thrown: the runner converts any thrown check into a `fail` result first.\n *\n * On success this simply returns; the CLI manager then prints its own success\n * banner and exits zero.\n *\n * @param _data Parsed CLI args (unused — doctor takes no positional args).\n */\nexport async function doctorCommandAction(_data: CommandActionData): Promise<void> {\n  const report = await runChecks(defaultDoctorChecks);\n\n  printReport(report);\n\n  if (report.hasFailures) {\n    process.exit(report.exitCode);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAmBA,eAAsB,oBAAoB,OAAyC;CACjF,MAAM,SAAS,MAAM,UAAU,mBAAmB;CAElD,YAAY,MAAM;CAElB,IAAI,OAAO,aACT,QAAQ,KAAK,OAAO,QAAQ;AAEhC"}
+{"version":3,"file":"doctor-command.action.mjs","names":[],"sources":["../../../../../../../../../core/src/cli/commands/doctor/doctor-command.action.ts"],"sourcesContent":["import type { CommandActionData } from \"../../../commands/types\";\r\nimport { defaultDoctorChecks } from \"./checks\";\r\nimport { printReport } from \"./format-report\";\r\nimport { runChecks } from \"./run-checks\";\r\n\r\n/**\r\n * Action behind `warlock doctor`. Runs the default read-only diagnostic\r\n * checks, prints the grouped pass/warn/fail report, and — when any check\r\n * failed — exits the process with a non-zero code so the command signals\r\n * failure to scripts/CI.\r\n *\r\n * A failing check is REPORTED (a line in the report + a non-zero exit), never\r\n * thrown: the runner converts any thrown check into a `fail` result first.\r\n *\r\n * On success this simply returns; the CLI manager then prints its own success\r\n * banner and exits zero.\r\n *\r\n * @param _data Parsed CLI args (unused — doctor takes no positional args).\r\n */\r\nexport async function doctorCommandAction(_data: CommandActionData): Promise<void> {\r\n  const report = await runChecks(defaultDoctorChecks);\r\n\r\n  printReport(report);\r\n\r\n  if (report.hasFailures) {\r\n    process.exit(report.exitCode);\r\n  }\r\n}\r\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAmBA,eAAsB,oBAAoB,OAAyC;CACjF,MAAM,SAAS,MAAM,UAAU,mBAAmB;CAElD,YAAY,MAAM;CAElB,IAAI,OAAO,aACT,QAAQ,KAAK,OAAO,QAAQ;AAEhC"}

package/esm/cli/commands/doctor.command.mjs

@@ -1,4 +1,4 @@
-import { command } from "../cli-command.mjs";
+import { command } from "../../commands/cli-command.mjs";
 import { doctorCommandAction } from "./doctor/doctor-command.action.mjs";
 
 //#region ../core/src/cli/commands/doctor.command.ts

package/esm/cli/commands/doctor.command.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"doctor.command.mjs","names":[],"sources":["../../../../../../../../core/src/cli/commands/doctor.command.ts"],"sourcesContent":["import { command } from \"../cli-command\";\nimport { doctorCommandAction } from \"./doctor/doctor-command.action\";\n\n/**\n * `warlock doctor` — run a set of READ-ONLY diagnostic checks (routes, config,\n * connectors, optional peers, health endpoints, release hygiene) and print a\n * grouped pass/warn/fail report. Exits non-zero if any check fails.\n *\n * Preload plan: load every config file and bootstrap app code so routes and\n * connectors are registered for introspection, but DELIBERATELY start no\n * connectors — doctor must not open database/cache/socket connections. The\n * connectors check therefore reports the registered set and which (if any) are\n * already active without forcing them up.\n */\nexport const doctorCommand = command({\n  name: \"doctor\",\n  description:\n    \"Run read-only health checks (routes, config, connectors, optional peers, health endpoints, release hygiene) and print a pass/warn/fail report\",\n  action: doctorCommandAction,\n  preload: {\n    config: true,\n    env: true,\n    bootstrap: true,\n  },\n});\n"],"mappings":";;;;;;;;;;;;;;;AAcA,MAAa,gBAAgB,QAAQ;CACnC,MAAM;CACN,aACE;CACF,QAAQ;CACR,SAAS;EACP,QAAQ;EACR,KAAK;EACL,WAAW;CACb;AACF,CAAC"}
+{"version":3,"file":"doctor.command.mjs","names":[],"sources":["../../../../../../../../core/src/cli/commands/doctor.command.ts"],"sourcesContent":["import { command } from \"../../commands/cli-command\";\r\nimport { doctorCommandAction } from \"./doctor/doctor-command.action\";\r\n\r\n/**\r\n * `warlock doctor` — run a set of READ-ONLY diagnostic checks (routes, config,\r\n * connectors, optional peers, health endpoints, release hygiene) and print a\r\n * grouped pass/warn/fail report. Exits non-zero if any check fails.\r\n *\r\n * Preload plan: load every config file and bootstrap app code so routes and\r\n * connectors are registered for introspection, but DELIBERATELY start no\r\n * connectors — doctor must not open database/cache/socket connections. The\r\n * connectors check therefore reports the registered set and which (if any) are\r\n * already active without forcing them up.\r\n */\r\nexport const doctorCommand = command({\r\n  name: \"doctor\",\r\n  description:\r\n    \"Run read-only health checks (routes, config, connectors, optional peers, health endpoints, release hygiene) and print a pass/warn/fail report\",\r\n  action: doctorCommandAction,\r\n  preload: {\r\n    config: true,\r\n    env: true,\r\n    bootstrap: true,\r\n  },\r\n});\r\n"],"mappings":";;;;;;;;;;;;;;;AAcA,MAAa,gBAAgB,QAAQ;CACnC,MAAM;CACN,aACE;CACF,QAAQ;CACR,SAAS;EACP,QAAQ;EACR,KAAK;EACL,WAAW;CACb;AACF,CAAC"}

package/esm/cli/commands/drop-tables.command.mjs

@@ -1,4 +1,4 @@
-import { command } from "../cli-command.mjs";
+import { command } from "../../commands/cli-command.mjs";
 import { dropTablesAction } from "../../database/drop-tables-action.mjs";
 
 //#region ../core/src/cli/commands/drop-tables.command.ts

package/esm/cli/commands/drop-tables.command.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"drop-tables.command.mjs","names":[],"sources":["../../../../../../../../core/src/cli/commands/drop-tables.command.ts"],"sourcesContent":["import { dropTablesAction } from \"../../database/drop-tables-action\";\nimport { command } from \"../cli-command\";\n\nexport const dropTablesCommand = command({\n  name: \"drop.tables\",\n  description: \"Drop all tables in the database\",\n  action: dropTablesAction,\n  preload: {\n    config: [\"database\", \"log\"],\n    env: true,\n    connectors: [\"database\", \"logger\"],\n  },\n  options: [\n    {\n      text: \"--force, -f\",\n      description: \"Drop tables without confirmation\",\n      type: \"boolean\",\n    },\n  ],\n});\n"],"mappings":";;;;AAGA,MAAa,oBAAoB,QAAQ;CACvC,MAAM;CACN,aAAa;CACb,QAAQ;CACR,SAAS;EACP,QAAQ,CAAC,YAAY,KAAK;EAC1B,KAAK;EACL,YAAY,CAAC,YAAY,QAAQ;CACnC;CACA,SAAS,CACP;EACE,MAAM;EACN,aAAa;EACb,MAAM;CACR,CACF;AACF,CAAC"}
+{"version":3,"file":"drop-tables.command.mjs","names":[],"sources":["../../../../../../../../core/src/cli/commands/drop-tables.command.ts"],"sourcesContent":["import { dropTablesAction } from \"../../database/drop-tables-action\";\r\nimport { command } from \"../../commands/cli-command\";\r\n\r\nexport const dropTablesCommand = command({\r\n  name: \"drop.tables\",\r\n  description: \"Drop all tables in the database\",\r\n  action: dropTablesAction,\r\n  preload: {\r\n    config: [\"database\", \"log\"],\r\n    env: true,\r\n    connectors: [\"database\", \"logger\"],\r\n  },\r\n  options: [\r\n    {\r\n      text: \"--force, -f\",\r\n      description: \"Drop tables without confirmation\",\r\n      type: \"boolean\",\r\n    },\r\n  ],\r\n});\r\n"],"mappings":";;;;AAGA,MAAa,oBAAoB,QAAQ;CACvC,MAAM;CACN,aAAa;CACb,QAAQ;CACR,SAAS;EACP,QAAQ,CAAC,YAAY,KAAK;EAC1B,KAAK;EACL,YAAY,CAAC,YAAY,QAAQ;CACnC;CACA,SAAS,CACP;EACE,MAAM;EACN,aAAa;EACb,MAAM;CACR,CACF;AACF,CAAC"}