@warlock.js/core 4.12.0 → 4.14.0

package/skills/test-service/SKILL.md

@@ -1,13 +1,23 @@
 ---
 name: test-service
-description: 'Pure unit tests against services, repositories, models, and use-cases — `setupTest({ connectors })` bootstraps each Vitest worker with its own DB/cache connections so you can call your code directly. Triggers: `setupTest`, `src/test-setup.ts`, `tests.connectors`, `Application.setEnvironment`; "unit-test a service", "test a repository query", "vitest setupFiles", "skip connectors for pure-logic tests"; typical import `import { setupTest } from "@warlock.js/core"`. Skip: HTTP integration — `@warlock.js/core/test-http/SKILL.md`; warlock add test scaffold — `@warlock.js/core/write-cli-command/SKILL.md`; competing tooling: jest direct, `supertest`, `nock`.'
+description: 'Pure unit tests against services, repositories, models, and use-cases — `setupTest({ connectors })` bootstraps the framework with its own DB/cache connections so you can call your code directly, and `teardownTest()` closes it. Triggers: `setupTest`, `teardownTest`, `src/test-setup.ts`, `tests.connectors`, `tests.setupTimeout`, `Application.setEnvironment`; "unit-test a service", "test a repository query", "vitest setupFiles", "skip connectors for pure-logic tests"; typical import `import { setupTest, teardownTest } from "@warlock.js/core/tests"`. Skip: HTTP integration — `@warlock.js/core/test-http/SKILL.md`; warlock add test scaffold — `@warlock.js/core/write-cli-command/SKILL.md`; competing tooling: jest direct, `supertest`, `nock`.'
 ---
 
 # Warlock — test a service
 
-For unit tests, you import the thing under test and call it directly. No HTTP, no fetch, no controllers. Framework testing in Warlock is about getting your **service layer** under test efficiently — and that means each Vitest worker needs its own bootstrapped framework with a DB connection.
+For unit tests, you import the thing under test and call it directly. No HTTP, no fetch, no controllers. Framework testing in Warlock is about getting your **service layer** under test efficiently — and that means your tests need a bootstrapped framework with a DB connection.
 
-`setupTest()` is the one-call bootstrap that gives each worker that environment.
+`setupTest()` is the one-call bootstrap that provides that environment; `teardownTest()` closes it.
+
+⚠ **Corrected in 4.14.0 — `setupTest` is CALLED once per TEST FILE, not once per worker.** Every version of this skill through 4.13.0 said "per worker", the generated `src/test-setup.ts` carries a `Per-Worker Test Setup` comment saying the same thing, and **both were wrong.** Vitest runs `setupFiles` before **each test file**, and the setup module's registry is rebuilt every time — measured across all four `pool` × `isolate` combinations.
+
+⛔ **If your project was generated before 4.14.0, fix BOTH the comment and the call.** The comment is false, **and** the generated `setupTest({ connectors: true })` is now an *explicit* value that overrides your `src/config/tests.ts`. **Bare `setupTest()` is the correct call.**
+
+**The lifetime is FILE-SCOPED, on purpose.** Your setup file bootstraps the framework and its `afterAll(teardownTest)` closes it, once per test file. **One owner, one pairing — correct under every pool, every isolation setting, and watch mode.**
+
+⚠ **A worker-scoped lifetime is possible and is deliberately not shipped yet.** Lifecycle state now lives in the worker runtime, so leaving the framework running would let every file in a worker share one bootstrap. Two things block claiming it: under `pool: "threads"` we cannot observe whether Node reclaims a torn-down thread's sockets and pools, and **in watch mode Vitest reuses workers between reruns, so there is no recycle and no cleanup owner.** It gets taken when the real cost is measured and the integration is chosen, not inherited. See *Lifecycle and repeated calls* below.
+
+⚠ **Changed in 4.13.0 — the import is a subpath now.** `setupTest` used to be re-exported from the package root; it is not any more, because that put the test helpers into every application's production module graph. `import { setupTest } from "@warlock.js/core"` now fails with *"has no exported member"* — **add `/tests` to the specifier and nothing else changes.**
 
 ## The shape
 
@@ -32,12 +42,12 @@ describe("registerUserService", () => {
 });
 ```
 
-No `beforeAll(setupTest)` in this file — the project's `src/test-setup.ts` (registered as `setupFiles` in `vite.config.ts`) already ran it once per worker before any test executed.
+No `beforeAll(setupTest)` in this file — the project's `src/test-setup.ts` (registered as `setupFiles` in `vite.config.ts`) already ran it **before this file's tests executed**, as it does before every test file.
 
-## `setupTest({ connectors })` — the worker bootstrap
+## `setupTest({ connectors })` — the bootstrap
 
 ```ts
-import { setupTest } from "@warlock.js/core";
+import { setupTest } from "@warlock.js/core/tests";
 
 await setupTest({ connectors: true });
 ```
@@ -49,10 +59,10 @@ What it does (in order):
 3. Runs `bootstrap()` — env, app, prestart hooks.
 4. Initializes the `filesOrchestrator` (module/route/config discovery, no file watching).
 5. Loads all `src/config/*.ts` files.
-6. Reads `tests.connectors` from config (overrides the parameter if set).
+6. Resolves the connector selection — **an explicit parameter wins, then `tests.connectors` from config, then the `true` default.** See *Selecting connectors* below.
 7. Starts the chosen connectors — but **never `http`** when you pass a boolean. HTTP is the global-setup's job.
 
-The result: each worker has its own DB/cache/logger/storage connections. Models save, repositories query, services run. Same code as production, just isolated to the test process.
+The result: DB/cache/logger/storage connections your code can use. Models save, repositories query, services run. Same code as production, just isolated to the test process.
 
 ### The `connectors` parameter
 
@@ -62,9 +72,9 @@ The result: each worker has its own DB/cache/logger/storage connections. Models
 | `false`                | None                                                             | Pure logic tests with no DB / cache touches (parsers, validators, util functions). |
 | `["database", "cache"]` | Just those, in that order                                        | A test that only needs DB but not, say, the storage driver. |
 
-The default `true` is the sane choice. Reach for `false` when the unit you're testing genuinely doesn't talk to any framework subsystem — pulling up a DB connection per worker just to test a string parser is wasted setup time.
+The default `true` is the sane choice. Reach for `false` when the unit you're testing genuinely doesn't talk to any framework subsystem — pulling up a DB connection **for every file** just to test a string parser is wasted setup time.
 
-### Override via config — `src/config/tests.ts`
+### Selecting connectors — `src/config/tests.ts`
 
 ```ts title="src/config/tests.ts"
 const testsConfigurations = {
@@ -74,7 +84,33 @@ const testsConfigurations = {
 export default testsConfigurations;
 ```
 
-If `tests.connectors` is set, **it wins over the `setupTest({ connectors })` parameter**. Use this when every test file in the project agrees on the same minimal connector list — saves repeating the explicit array in `test-setup.ts`.
+⚠ **BREAKING in 4.14.0 — the precedence flipped.**
+
+| | Order |
+|---|---|
+| **4.13.0 and earlier** | `tests.connectors` config **>** `setupTest({ connectors })` parameter **>** `true` |
+| **4.14.0 onward** | **explicit `setupTest({ connectors })` parameter** **>** `tests.connectors` config **>** `true` |
+
+**An explicit call-site value now beats project config.** If your project sets `tests.connectors` *and* some test file passes `connectors` explicitly, **that file will start a different connector set after upgrading.** Search for `setupTest({` across your tests before you upgrade — a call passing `connectors` was previously ignored and is now honoured.
+
+**"Explicit" means you supplied a non-`undefined` value.** Both of these fall through to config:
+
+```ts
+await setupTest();                       // → tests.connectors, else true
+await setupTest({});                     // → tests.connectors, else true
+await setupTest({ connectors: undefined }); // → tests.connectors, else true — NOT "start none"
+```
+
+The `undefined` rule is deliberate: an optional variable that happens to be `undefined` must not silently erase your project config.
+
+```ts
+await setupTest({ connectors: false });        // → none, even if config says otherwise
+await setupTest({ connectors: ["database"] }); // → exactly that, even if config differs
+```
+
+⚠ **The generated `src/test-setup.ts` calls `setupTest()` with no argument, on purpose.** If you "helpfully" change it to `setupTest({ connectors: true })`, you have made it explicit and **erased the `tests.connectors` layer for the whole project.**
+
+Use `tests.connectors` when every test file agrees on the same minimal list — it saves repeating the array, and individual files can still override it.
 
 ## Project wiring — `src/test-setup.ts` + `vite.config.ts`
 
@@ -82,16 +118,24 @@ The `warlock add test` feature creates both files. The standard wiring:
 
 ```ts title="src/test-setup.ts"
 /**
- * Per-Worker Test Setup
- * Runs in EACH Vitest worker thread before tests execute.
+ * Test Setup
+ * Runs before EACH test file — not once per worker.
  */
-import { setupTest } from "@warlock.js/core";
+import { afterAll } from "vitest";
+import { setupTest, teardownTest } from "@warlock.js/core/tests";
 
-await setupTest({ connectors: true });
+await setupTest();
+afterAll(teardownTest);
 ```
 
+⛔ **Three things changed here in 4.14.0. If you generated this file earlier, replace all three — it is not a comment fix.**
+
+1. **`afterAll(teardownTest)` is new and mandatory.** Nothing else closes the framework your tests started. This is what makes the lifetime file-scoped and owned rather than left running.
+2. **The call is now bare `setupTest()`, not `setupTest({ connectors: true })`.** Under the flipped precedence, passing `true` is an *explicit* value and would override `tests.connectors` for **every file in the project.** Bare means "whatever this project configured, else the default".
+3. **The comment used to say `Per-Worker Test Setup` / "Runs in EACH Vitest worker thread".** False — see the top of this skill.
+
 ```ts title="vite.config.ts"
-import { lowerStage3Decorators } from "@warlock.js/core";
+import { lowerStage3Decorators } from "@warlock.js/core/vite";
 import mongezVite from "@mongez/vite";
 import { defineConfig } from "vitest/config";
 
@@ -99,7 +143,7 @@ export default defineConfig({
   plugins: [lowerStage3Decorators(), mongezVite()],
   test: {
     globalSetup: "./src/test-global-setup.ts",  // ← HTTP server (see test-http skill)
-    setupFiles: ["./src/test-setup.ts"],         // ← runs setupTest per worker
+    setupFiles: ["./src/test-setup.ts"],         // ← runs setupTest before EACH test file
     environment: "node",
     globals: false,
     include: ["src/app/**/*.test.ts"],
@@ -204,17 +248,19 @@ afterEach(async () => {
 });
 ```
 
-Vitest runs tests in a single worker file sequentially, so an `afterEach` truncate gives each test a clean slate. For cross-file isolation, run the suite with `vitest --pool=forks --maxWorkers=N` and rely on the per-worker connection — each file's data stays within its worker until the run ends.
+Vitest runs the tests within one file sequentially, so an `afterEach` truncate gives each test a clean slate.
+
+⚠ **Cross-*file* isolation is not solved by this.** Separate workers get separate **connections**, not separate **rows** — two files pointed at the same database see each other's committed data regardless of pool or worker count. **Truncate what your file wrote; don't assume the worker boundary did it for you.** Real data isolation (DB-per-worker, transaction-per-test) is a separate piece of work and is not in this release.
 
 ### Skipping connectors for pure logic tests
 
 ```ts title="src/app/utils/tests/slugify.test.ts"
 import { beforeAll, describe, expect, it } from "vitest";
-import { setupTest } from "@warlock.js/core";
+import { setupTest } from "@warlock.js/core/tests";
 import { slugify } from "../utils/slugify";
 
 beforeAll(async () => {
-  await setupTest({ connectors: false });  // override the project default
+  await setupTest({ connectors: false });  // starts no connectors at all
 });
 
 describe("slugify", () => {
@@ -224,15 +270,112 @@ describe("slugify", () => {
 });
 ```
 
-`setupTest` is idempotent per worker (`isSetupComplete` flag) — calling it again with different options after `src/test-setup.ts` already ran is a no-op. To genuinely skip connectors, either set `tests.connectors: false` in config (project-wide) or rely on the default in `src/test-setup.ts` being what you want most of the time.
+⛔ **BREAKING in 4.14.0 — the example above now REJECTS if your project has a `src/test-setup.ts`.**
+
+Through 4.13.0 a second `setupTest` call with different options was a **silent no-op** — you asked for no connectors, got all of them, and nothing told you. In 4.14.0 a conflicting call **rejects with an error naming both the active and the requested selection**, because silently ignoring what you asked for is worse than failing.
+
+**If `src/test-setup.ts` already ran `setupTest()` in this file, use one of these instead:**
+
+```ts
+// 1. Tear down first, then set up differently — and PUT IT BACK when the file ends.
+import { afterAll, beforeAll } from "vitest";
+import { setupTest, teardownTest } from "@warlock.js/core/tests";
+
+beforeAll(async () => {
+  await teardownTest();
+  await setupTest({ connectors: false });
+});
+
+afterAll(async () => {
+  await teardownTest();      // ← REQUIRED, see below
+});
+```
+
+⛔ **The `afterAll` is not optional** — without it you leave a `connectors: false` runtime ready when the file ends.
+
+⚠ **This pattern interacts with the `afterAll(teardownTest)` in your setup file, and the relative ordering of the two has not been verified.** `teardownTest` is idempotent, so whichever runs second finds an idle lifecycle and no-ops — but **do not build anything on a particular order until someone has measured it.** This is the strongest argument for option 2 below.
+
+```ts
+// 2. Or don't call setupTest at all — a pure-logic test needs nothing from it.
+//    The connectors your setup file started are already running; you simply don't use them.
+```
+
+**3. Or set `tests.connectors: false` in `src/config/tests.ts`** if no test file in the project needs connectors.
+
+**Option 2 is usually right, and option 1 is easy to get wrong.** Tearing down and re-bootstrapping costs a full framework startup — twice, once for your file and once for the next — to avoid a DB connection you were never going to use. **Reach for option 1 only when a connector's mere presence breaks the thing you're testing**, not to save setup time.
+
+## Lifecycle and repeated calls
+
+`setupTest` / `teardownTest` are a pair. **The harness that calls one owns calling the other in the same context.**
+
+| Call | Behaviour |
+|---|---|
+| `setupTest(x)` while idle | bootstraps |
+| `setupTest(x)` while already ready with the **same** effective options | no-op |
+| `setupTest(y)` while ready or starting with **different** effective options | ⛔ **rejects**, naming active vs requested |
+| two concurrent `setupTest(x)` calls | share one startup |
+| `setupTest` after a failed setup | allowed — a failed setup unwinds and returns to idle |
+| `teardownTest()` while idle | no-op |
+| two concurrent `teardownTest()` calls | share one shutdown |
+| `setupTest(y)` after a **successful** teardown | allowed, different options fine |
+
+**"Same options" is compared by meaning, not by literal value** — connector arrays are deduplicated and compared as sets, so `["cache", "database"]` and `["database", "cache", "cache"]` are the same selection.
+
+⚠ **A failed shutdown poisons the lifecycle.** If `teardownTest()` rejects because the shutdown layer reported a failure, later `setupTest` calls **refuse until the Vitest worker is recycled** or a retried teardown fully succeeds. This is deliberate: a cleared flag does not prove that ports, sockets, pools or timers actually closed, and pretending otherwise hands you a "clean" run built on a leaked runtime.
+
+⚠ **What it cannot detect:** `connectorsManager.shutdown()` catches and logs individual connector failures internally. Those never reach this lifecycle, so they never poison it. It surfaces what that layer reports — no more.
+
+### `tests.setupTimeout` — the setup attempt is bounded
+
+**New in 4.14.0.** A setup attempt that never settles used to leave the lifecycle stuck in `starting` and take the worker down with an out-of-memory crash. It is now bounded.
+
+```ts title="src/config/tests.ts"
+const testsConfigurations = {
+  connectors: ["database", "logger"],
+  setupTimeout: 120000,   // milliseconds — this is the default
+};
+
+export default testsConfigurations;
+```
+
+**Default: `120000` (two minutes)** — far above a healthy cold start, below the point where you'd stop watching the terminal. When it expires:
+
+```
+setupTest() did not finish within 120000ms and is stuck in the "starting" state. The
+lifecycle is now poisoned: whatever that attempt had already started is not known to be
+closed, so later setupTest() calls refuse until the Vitest worker is recycled. If your
+cold start is legitimately slower than this, raise the bound with `tests.setupTimeout`
+in `src/config/tests.ts` — milliseconds, default 120000.
+```
+
+1. **It bounds the setup ATTEMPT, not teardown separately.** `teardownTest()` awaits the same attempt, so it inherits the bound — **one timer, not two.** A second teardown-side deadline was tried and rejected: it re-introduced the unbounded re-entry this whole guard exists to remove.
+2. **Expiry poisons the lifecycle**, it does not return to `idle`. The attempt may have started connectors nobody can now account for, so pretending the runtime is clean would be worse than refusing.
+3. **⛔ An invalid `setupTimeout` throws, naming the bad value.** Zero, negative and non-numeric all fail loudly rather than falling back to the default — a silent fallback would hide a typo behind a working suite.
+4. **The bound is measured from when the attempt started**, not from when config was read. `tests.setupTimeout` is only readable after `loadConfigFiles()`, which happens *inside* the window being bounded; re-arming naively would give you the default plus your configured value.
+
+⚠ **What is proven and what is not.** The nine guards above were each seen to fail under their own mutation. **But every spec injects its scheduler**, so the default *value* is tested while the production timer — and whether its `unref` actually releases the worker — is not. **And no spec observes a real hang**: the stuck attempt is a mock gate, not a socket that never returns. These prove what the lifecycle *decides*, not what a genuinely wedged connector does.
+
+### State is per worker runtime, not per module
+
+The lifecycle state lives in the worker runtime, not in a module variable. That matters because **Vitest rebuilds the module registry between test files while the worker itself keeps running** — so a module-level flag resets exactly where live DB connections and pools survive. Scope:
+
+- **`pool: "forks"`** — state is per worker **process**.
+- **`pool: "threads"`** — state is per worker **thread**. It does **not** cross threads; `globalThis` is per realm, not per process.
+
+In both cases the guard's scope matches the resource's scope, which is the point.
+
+⚠ **Not guaranteed:** under `threads` with `isolate: true`, Vitest tears the thread down while the process lives on. **Whether Node reclaims that thread's sockets and pools is unmeasured**, and nothing in this lifecycle can observe it.
 
 ## Gotchas
 
-- **`setupTest` is idempotent per worker.** Second + later calls early-return. You can't "swap" the connector set mid-run — the first call wins, including the one in `src/test-setup.ts`. Choose your worker default carefully.
-- **Per-worker connections are separate from the HTTP server's connections.** A row inserted by a service-level test is on the worker's connection; the HTTP test server has its own. They don't see each other unless they're both pointing at the same physical DB and the inserting test has already committed.
+- **`setupTest` runs per test file, not per worker** — every version of this skill through 4.13.0 said otherwise. **You pay one framework bootstrap per test file**, which is what 4.13.0 already cost; the difference is that it is now a chosen lifetime rather than a side effect of a module flag resetting.
+- ⛔ **Never delete the `afterAll(teardownTest)` from your setup file.** Without it nothing closes what `setupTest` opened, and the connectors outlive the file that started them.
+- ⛔ **You can't swap the connector set by calling `setupTest` again — it rejects now.** Through 4.13.0 the second call was silently ignored. Tear down first, or don't call it.
+- **These connections are separate from the HTTP test server's.** A row inserted by a service-level test is on this connection; the HTTP test server has its own. They only see each other if both point at the same physical DB **and** the inserting test has committed.
+- **`setupTest` takes over the process's `connectorsManager` for its lifetime.** Teardown is manager-wide, so **mixing `setupTest` with manually started connectors is unsupported** — teardown may close yours too.
 - **`NODE_ENV` is set to `"test"`** by `setupTest`. Code that branches on `Application.isProduction` / `Application.isDevelopment` sees `false` for both. If your tests need production-like config (cookies, CORS), set those values in `src/config/*.ts` explicitly under the test branch — don't rely on the env flag.
 - **No HTTP from this layer.** `setupTest({ connectors: true })` never starts the HTTP connector by design. Don't try to `request.app.http` your way to a fetch test — use the `test-http` skill instead.
-- **Don't import `vitest-setup` from `@warlock.js/core/src/...`.** The public surface is `import { setupTest } from "@warlock.js/core"`. Reaching into source paths breaks when the package layout shifts.
+- **Don't import `vitest-setup` from `@warlock.js/core/src/...`.** The public surface is `import { setupTest } from "@warlock.js/core/tests"`. Reaching into source paths breaks when the package layout shifts.
 - **Test files need the `.test.ts` suffix.** `include: ["src/app/**/*.test.ts"]` is what vitest scans. A file named `service.tests.ts` (plural) silently doesn't run.
 
 ## See also

package/skills/use-middleware/SKILL.md

@@ -81,6 +81,8 @@ Server errors (5xx) are not cached — clients can retry past a 5xx. 4xx respons
 
 `http.bodyLimit` in config is read by Fastify at server-start and applies to every body. `middleware.maxBodySize()` is a per-route middleware on top — it checks `Content-Length` after route match and rejects with 413 before body parsing runs. Use both: global as a safety net, per-route for tight caps on small-payload endpoints.
 
+⚠ **Since 4.13.0, configuring nothing gives you Fastify's own 1 MB limit.** Earlier versions defaulted to 200 GB, which **replaced** Fastify's protection rather than adding to it — so an app that set nothing had effectively no cap. **Set `bodyLimit` explicitly if you need more than 1 MB.**
+
 ```ts
 // src/config/http.ts
 export default { bodyLimit: 10 * 1024 * 1024 }; // 10MB globally
@@ -111,7 +113,9 @@ export default {
 
 ## `ipFilter` — fail-closed
 
-`deny` wins over `allow`. If the IP can't be read (empty / unparseable), the request is rejected with 403. Reads via `request.detectIp()` which honors `X-Real-IP` and `X-Forwarded-For` (Fastify starts with `trustProxy: true`).
+`deny` wins over `allow`. If the IP can't be read (empty / unparseable), the request is rejected with 403. Reads via `request.detectIp()`.
+
+⚠ **Since 4.13.0 `http.trustProxy` defaults to `false`**, so `request.detectIp()` returns the socket address and **`X-Real-IP` / `X-Forwarded-For` are ignored unless you opt in.** Set `trustProxy: true` **only when you are genuinely behind a proxy that overwrites those headers** — before 4.13.0 the default was `true`, which meant any client could set its own forwarding header and be believed.
 
 ```ts
 import { middleware } from "@warlock.js/core";

package/esm/cli/cli-command.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli-command.d.mts","names":[],"sources":["../../../../../../../core/src/cli/cli-command.ts"],"mappings":";;;cAUa,UAAA;EAqDF,IAAA;EArDE;;;EAIJ,aAAA,GAAgB,gBAAA;EAKA;;;EAAhB,aAAA,GAAgB,gBAAA;EAyDD;;;;EAnDf,gBAAA,GAAmB,gBAAA;EAuHuC;;;EAlH1D,cAAA,GAAiB,iBAAA;EAoNA;;;EA/MjB,kBAAA;EAuNqC;;;EAlNrC,cAAA,EAAgB,wBAAA;EArBhB;;;;;EA4BA,mBAAA;EAZA;;;EAiBA,YAAA;EAAA;;;EAKA,YAAA;EAOL;;;cADO,IAAA,UACP,WAAA;EAoBK;;;EARA,MAAA,CAAO,MAAA,EAAQ,gBAAA;EAyBf;;;EAjBA,WAAA,CAAY,WAAA;EAyBL;;;EAjBP,UAAA,CAAW,YAAA;EAkCX;;;;EAzBA,KAAA,CAAM,KAAA;EA0CN;;;EAlCA,MAAA,CAAO,MAAA,EAAQ,gBAAA;EAmCR;;;;EA1BP,SAAA,CAAU,MAAA,EAAQ,gBAAA;EAwDf;;;EAhDH,OAAA,CAAQ,OAAA,EAAS,gBAAA;EA8FhB;;;EArFD,aAAA,CAAc,YAAA;EAmHR;;;EA3GN,MAAA,CAAO,MAAA,EAAQ,gBAAA;EACf,MAAA,CAAO,IAAA,UAAc,WAAA,WAAsB,OAAA,GAAU,IAAA,CAAK,gBAAA;EA0GrB;AAS9C;;;;;;;;EAT8C,UA5ElC,WAAA,CAAY,MAAA,EAAQ,gBAAA,GAAmB,wBAAA;;;;;;;;;UA8CzC,iBAAA;;;;EAsBD,OAAA,CAAQ,OAAA,EAAS,iBAAA;;;;EAQX,OAAA,CAAQ,IAAA,EAAM,iBAAA,GAAiB,OAAA;AAAA;AAAA,iBAS9B,OAAA,CAAQ,OAAA,EAAS,iBAAA,GAAiB,UAAA"}

package/esm/cli/cli-command.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli-command.mjs","names":[],"sources":["../../../../../../../core/src/cli/cli-command.ts"],"sourcesContent":["import type {\n  CLICommandAction,\n  CLICommandOption,\n  CLICommandOptions,\n  CLICommandPreload,\n  CLICommandSource,\n  CommandActionData,\n  ResolvedCLICommandOption,\n} from \"./types\";\n\nexport class CLICommand {\n  /**\n   * Command source\n   */\n  public commandSource?: CLICommandSource;\n\n  /**\n   * Command action\n   */\n  public commandAction?: CLICommandAction;\n\n  /**\n   * Command pre action\n   * This will be executed before loading preloaders\n   */\n  public commandPreAction?: CLICommandAction;\n\n  /**\n   *    Command preload\n   */\n  public commandPreload?: CLICommandPreload;\n\n  /**\n   * Command description\n   */\n  public commandDescription?: string;\n\n  /**\n   * Command options\n   */\n  public commandOptions: ResolvedCLICommandOption[] = [];\n\n  /**\n   * Command relative path\n   * Available only for project commands\n   * Auto injected by the framework itself\n   */\n  public commandRelativePath?: string;\n\n  /**\n   * Determine if the command is persistent\n   */\n  public isPersistent: boolean = false;\n\n  /**\n   * Command alias (short name)\n   */\n  public commandAlias?: string;\n\n  /**\n   * Constructor\n   */\n  public constructor(\n    public name: string,\n    description?: string,\n  ) {\n    if (description) {\n      this.commandDescription = description;\n    }\n\n    return this;\n  }\n\n  /**\n   * Add command source\n   */\n  public source(source: CLICommandSource): this {\n    this.commandSource = source;\n    return this;\n  }\n\n  /**\n   * Set command description\n   */\n  public description(description: string): this {\n    this.commandDescription = description;\n    return this;\n  }\n\n  /**\n   * Determine if the command is persistent\n   */\n  public persistent(isPersistent = true): this {\n    this.isPersistent = isPersistent;\n    return this;\n  }\n\n  /**\n   * Set command alias (short name)\n   * @example .alias(\"m\") for \"migrate\"\n   */\n  public alias(alias: string): this {\n    this.commandAlias = alias;\n    return this;\n  }\n\n  /**\n   * Command action\n   */\n  public action(action: CLICommandAction): this {\n    this.commandAction = action;\n    return this;\n  }\n\n  /**\n   * Command pre action\n   * This will be executed before loading preloaders\n   */\n  public preAction(action: CLICommandAction): this {\n    this.commandPreAction = action;\n    return this;\n  }\n\n  /**\n   * Add command options\n   */\n  public options(options: CLICommandOption[]): this {\n    options.map((option) => this.option(option));\n\n    return this;\n  }\n\n  /**\n   * Add command relative path\n   */\n  public $relativePath(relativePath: string) {\n    this.commandRelativePath = relativePath;\n    return this;\n  }\n\n  /**\n   * Add command option\n   */\n  public option(option: CLICommandOption): this;\n  public option(name: string, description?: string, options?: Omit<CLICommandOption, \"name\">): this;\n  public option(\n    ...args: [CLICommandOption] | [string, string?, Omit<CLICommandOption, \"name\">?]\n  ): this {\n    let option: CLICommandOption;\n    if (args.length === 1) {\n      option = args[0] as CLICommandOption;\n    } else {\n      option = {\n        text: args[0],\n        description: args[1],\n        ...args[2],\n        name: \"\",\n      };\n    }\n\n    this.commandOptions.push(this.parseOption(option));\n\n    return this;\n  }\n\n  /**\n   * Parse option name and alias if exists\n   *\n   * Supports formats:\n   * - \"--port, -p\" → name: \"port\", alias: \"p\"\n   * - \"-p, --port\" → name: \"port\", alias: \"p\"\n   * - \"--port\" → name: \"port\", alias: undefined\n   * - \"-p\" → name: \"p\", alias: undefined\n   */\n  protected parseOption(option: CLICommandOption): ResolvedCLICommandOption {\n    const text = option.text.trim();\n\n    // Split by comma to check for alias\n    const parts = text.split(\",\").map((part) => part.trim());\n\n    let name = \"\";\n    let alias = \"\";\n\n    if (parts.length === 1) {\n      // Single option: \"--port\" or \"-p\"\n      name = this.extractOptionName(parts[0]);\n    } else if (parts.length === 2) {\n      // Two options: \"--port, -p\" or \"-p, --port\"\n      const first = parts[0];\n      const second = parts[1];\n\n      // Determine which is the long form (name) and which is short (alias)\n      if (first.startsWith(\"--\")) {\n        name = this.extractOptionName(first);\n        alias = this.extractOptionName(second);\n      } else {\n        name = this.extractOptionName(second);\n        alias = this.extractOptionName(first);\n      }\n    }\n\n    if (alias === \"h\" || name === \"help\") {\n      throw new Error(\"Help option is not allowed, it's reserved for displaying command help\");\n    }\n\n    return {\n      ...option,\n      name,\n      alias,\n    };\n  }\n\n  /**\n   * Extract option name from text (removes -- or -)\n   *\n   * @example\n   * extractOptionName(\"--port\") → \"port\"\n   * extractOptionName(\"-p\") → \"p\"\n   * extractOptionName(\"--port=3000\") → \"port\"\n   */\n  private extractOptionName(text: string): string {\n    // Remove leading dashes\n    let name = text.replace(/^-+/, \"\");\n\n    // Remove value assignment if exists (e.g., \"--port=3000\" → \"port\")\n    const equalIndex = name.indexOf(\"=\");\n    if (equalIndex !== -1) {\n      name = name.slice(0, equalIndex);\n    }\n\n    // Remove angle brackets if exists (e.g., \"--port <number>\" → \"port\")\n    const spaceIndex = name.indexOf(\" \");\n    if (spaceIndex !== -1) {\n      name = name.slice(0, spaceIndex);\n    }\n\n    return name.trim();\n  }\n\n  /**\n   * Command preload\n   */\n  public preload(options: CLICommandPreload) {\n    this.commandPreload = options;\n    return this;\n  }\n\n  /**\n   * Execute the command\n   */\n  public async execute(data: CommandActionData) {\n    if (!this.commandAction) {\n      throw new Error(`Command \"${this.name}\" has no action defined`);\n    }\n\n    await this.commandAction(data);\n  }\n}\n\nexport function command(options: CLICommandOptions) {\n  const commandInstnace = new CLICommand(options.name, options.description);\n\n  if (options.preload) {\n    commandInstnace.preload(options.preload);\n  }\n\n  if (options.persistent) {\n    commandInstnace.persistent(options.persistent);\n  }\n\n  if (options.alias) {\n    commandInstnace.alias(options.alias);\n  }\n\n  commandInstnace.action(options.action);\n\n  if (options.options) {\n    commandInstnace.options(options.options);\n  }\n\n  if (options.preAction) {\n    commandInstnace.preAction(options.preAction);\n  }\n\n  return commandInstnace;\n}\n"],"mappings":"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"}

package/esm/cli/types.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../../core/src/cli/types.ts"],"mappings":";;;;;AAgB4B;AAY5B;;;;KAZY,gBAAA;;;;AAwBK;AAsBjB;;;;;;KAlCY,iBAAA;EAuDV;;;;EAlDA,IAAA;EAiFA;;;AAA0B;AAgB5B;EA1FE,OAAA,EAAS,MAAM;AAAA;;;;;;;;;;AAiIP;AAGV;;;;;;;;;KA9GY,iBAAA;EAuHA;;;;;EAjHV,MAAA;EAiHiE;;AAAO;EA5GxE,QAAA;EAkI2B;;;EA7H3B,aAAA;EAsKQ;;;EAjKR,eAAA,GAAkB,eAAA;EA6HlB;;;EAxHA,WAAA;EAyIU;;;;;;;;;EA9HV,GAAA;;;;;EAMA,SAAA;;;;;;;;EASA,UAAA,GAAa,aAAa;AAAA;;;;;;;;;;;;;;KAgBhB,gBAAA;;;;;EAKV,IAAA;;;;;EAMA,IAAA;;;;;EAMA,KAAA;;;;EAKA,WAAA;;;;;EAMA,IAAA;;;;EAKA,YAAA;;;;;EAMA,QAAA;AAAA;AAAA,KAGU,wBAAA,GAA2B,IAAI,CAAC,gBAAA;EAC1C,IAAA;EACA,KAAA;AAAA;;;;;KAOU,gBAAA,IAAoB,IAAA,EAAM,iBAAA,YAA6B,OAAO;;;;;;;;;;;;;;;;;;;;;KAsB9D,iBAAA;;;;;EAKV,IAAA;;;;;EAMA,KAAA;;;;EAKA,WAAA;;;;;EAMA,OAAA,GAAU,iBAAA;;;;;;EAOV,UAAA;;;;;EAMA,SAAA,GAAY,gBAAA;;;;;EAMZ,MAAA,EAAQ,gBAAA;;;;;EAMR,OAAA,GAAU,gBAAA;AAAA"}

package/esm/dev-server/files-orchestrator.d.mts

@@ -1,89 +0,0 @@
-import { DependencyGraph } from "./dependency-graph.mjs";
-import { SpecialFilesCollector } from "./special-files-collector.mjs";
-import { FileOperations } from "./file-operations.mjs";
-import { FileManager } from "./file-manager.mjs";
-import { FilesWatcher } from "./files-watcher.mjs";
-import { FileHealthCheckerContract } from "./health-checker/file-health-checker.contract.mjs";
-import { FilesHealthcareManager } from "./health-checker/files-healthcare.manager.mjs";
-import { ModuleLoader } from "./module-loader.mjs";
-
-//#region ../core/src/dev-server/files-orchestrator.d.ts
-/**
- * Register a cleanup callback that fires before the current module is
- * unloaded by HMR. Stack-inspects the caller so user code doesn't need to
- * thread the FileManager through.
- */
-declare function onCleanup(callback: () => any): void;
-/**
- * Top-level coordinator for the dev server's file system.
- *
- * Owns: file discovery, the dependency graph, the manifest, the special-files
- * index, the file watcher, and the lifecycle of the ESM loader hook (which
- * provides cache-busting via `?v=N` version tokens).
- */
-declare class FilesOrchestrator {
-  readonly filesWatcher: FilesWatcher;
-  readonly files: Map<string, FileManager>;
-  private readonly manifest;
-  private readonly dependencyGraph;
-  private readonly healthCheckerManager;
-  readonly specialFilesCollector: SpecialFilesCollector;
-  readonly moduleLoader: ModuleLoader;
-  readonly fileOperations: FileOperations;
-  private readonly eventHandler;
-  /** Main-thread end of the MessageChannel to the loader hook worker. */
-  private loaderPort;
-  /** Resolve callbacks for pending `flushVersionBumps()` calls. */
-  private readonly pendingFlushes;
-  isInitialized: boolean;
-  constructor();
-  add(relativePath: string): Promise<FileManager>;
-  load<T>(relativePath: string, type?: string): Promise<T | undefined>;
-  getDependencyGraph(): DependencyGraph;
-  getInvalidationChain(file: string): string[];
-  getFiles(): Map<string, FileManager>;
-  getHealthCheckerManager(): FilesHealthcareManager;
-  /**
-   * Initialise managers and register the ESM loader hook. Must be called
-   * before any user `src/` module is dynamically imported.
-   */
-  init(): Promise<void>;
-  /**
-   * Tell the hook worker a file changed. The next `import()` of it will get
-   * a fresh `?v=N` URL → Node cache miss → fresh content.
-   */
-  bumpVersion(absolutePath: string): void;
-  /**
-   * Wait until the hook worker has processed every pending bump.
-   *
-   * `postMessage` is async — without this, a follow-up `import()` may
-   * resolve before the worker increments the counter and Node will return
-   * the cached old module.
-   */
-  flushVersionBumps(): Promise<void>;
-  /**
-   * Discover files on disk, reconcile against the manifest, build the dep
-   * graph, and persist the new manifest. Idempotent.
-   */
-  initializeAll(): Promise<void>;
-  checkHealth(files: {
-    added: string[];
-    changed: string[];
-    deleted: string[];
-  }): Promise<void>;
-  startCheckingHealth(healthCheckers?: FileHealthCheckerContract[]): Promise<void>;
-  /**
-   * Glob the src directory, returning relative paths.
-   */
-  getAllFilesFromFilesystem(): Promise<string[]>;
-  /**
-   * Process every file from scratch — used when no manifest exists.
-   */
-  private processFiles;
-  private reconcileFiles;
-  watchFiles(): Promise<void>;
-}
-declare const filesOrchestrator: FilesOrchestrator;
-//#endregion
-export { FilesOrchestrator, filesOrchestrator, onCleanup };
-//# sourceMappingURL=files-orchestrator.d.mts.map

package/esm/dev-server/files-orchestrator.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"files-orchestrator.d.mts","names":[],"sources":["../../../../../../../core/src/dev-server/files-orchestrator.ts"],"mappings":";;;;;;;;;;;;AA8BA;;;iBAAgB,SAAA,CAAU,QAAmB;AAAA;AAuB7C;;;;;;AAvB6C,cAuBhC,iBAAA;EAAA,SACK,YAAA,EAAY,YAAA;EAAA,SACZ,KAAA,EAAK,GAAA,SAAA,WAAA;EAAA,iBACJ,QAAA;EAAA,iBACA,eAAA;EAAA,iBACA,oBAAA;EAAA,SACD,qBAAA,EAAqB,qBAAA;EAAA,SACrB,YAAA,EAAY,YAAA;EAAA,SACZ,cAAA,EAAgB,cAAA;EAAA,iBACf,YAAA;EA+CiB;EAAA,QA5C1B,UAAA;EA4FoB;EAAA,iBAzFX,cAAA;EAEV,aAAA;;EAkBM,GAAA,CAAI,YAAA,WAAuB,OAAA,CAAQ,WAAA;EAInC,IAAA,IAAQ,YAAA,UAAsB,IAAA,YAAc,OAAA,CAAA,CAAA;EAKlD,kBAAA,IAAsB,eAAA;EAItB,oBAAA,CAAqB,IAAA;EAIrB,QAAA,IAAY,GAAA,SAAY,WAAA;EAIxB,uBAAA,IAA2B,sBAAA;EAvDN;;;;EA+Df,IAAA,IAAI,OAAA;EA5DA;;;;EAyFV,WAAA,CAAY,YAAA;EAtFS;;;;;;;EAiGrB,iBAAA,IAAqB,OAAA;EArEf;;;;EAkFA,aAAA,IAAa,OAAA;EAkBb,WAAA,CAAY,KAAA;IAAS,KAAA;IAAiB,OAAA;IAAmB,OAAA;EAAA,IAAmB,OAAA;EAc5E,mBAAA,CAAoB,cAAA,GAAiB,yBAAA,KAA8B,OAAA;EAzGnD;;;EAmHhB,yBAAA,IAA6B,OAAA;EA3GvB;;;EAAA,QAmHL,YAAA;EAAA,QAcA,cAAA;EAgCD,UAAA,IAAU,OAAA;AAAA;AAAA,cAuBZ,iBAAA,EAAiB,iBAA0B"}

package/esm/dev-server/files-watcher.d.mts

@@ -1,69 +0,0 @@
-//#region ../core/src/dev-server/files-watcher.d.ts
-type FileWatcherEvent = "change" | "delete" | "add" | "error" | "addDir" | "unlinkDir";
-type FileChangeCallback = (filePath: string) => void;
-type FileDeleteCallback = (filePath: string) => void;
-type FileAddCallback = (filePath: string) => void;
-type FileErrorCallback = (filePath: string, error: Error) => void;
-type FileAddDirCallback = (filePath: string) => void;
-type FileUnlinkDirCallback = (filePath: string) => void;
-type OnFileEventCallback = FileChangeCallback | FileDeleteCallback | FileAddCallback | FileErrorCallback | FileAddDirCallback | FileUnlinkDirCallback;
-/**
- * Watch configuration options
- */
-type WatchConfig = {
-  /**
-   * Glob patterns to include
-   */
-  include?: string[];
-  /**
-   * Glob patterns to exclude
-   */
-  exclude?: string[];
-};
-declare class FilesWatcher {
-  /**
-   * File watcher id
-   */
-  private id;
-  /**
-   * Watch for files changes
-   * @param config Optional watch configuration
-   */
-  watch(config?: WatchConfig): Promise<void>;
-  /**
-   * Trigger event immediately (no debouncing here)
-   * Debouncing is handled at the orchestrator level for batch processing
-   */
-  private triggerEvent;
-  /**
-   * On file change event
-   */
-  onFileChange(callback: FileChangeCallback): import("@mongez/events").EventSubscription;
-  /**
-   * On file delete event
-   */
-  onFileDelete(callback: FileDeleteCallback): import("@mongez/events").EventSubscription;
-  /**
-   * On file add event
-   */
-  onFileAdd(callback: FileAddCallback): import("@mongez/events").EventSubscription;
-  /**
-   * On file error event
-   */
-  onFileError(callback: FileErrorCallback): import("@mongez/events").EventSubscription;
-  /**
-   * On file add dir event
-   */
-  onDirectoryAdd(callback: FileAddDirCallback): import("@mongez/events").EventSubscription;
-  /**
-   * On file unlink dir event
-   */
-  onDirectoryRemove(callback: FileUnlinkDirCallback): import("@mongez/events").EventSubscription;
-  /**
-   * On file event
-   */
-  on(event: FileWatcherEvent, callback: OnFileEventCallback): import("@mongez/events").EventSubscription;
-}
-//#endregion
-export { FilesWatcher };
-//# sourceMappingURL=files-watcher.d.mts.map

package/esm/dev-server/files-watcher.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"files-watcher.d.mts","names":[],"sources":["../../../../../../../core/src/dev-server/files-watcher.ts"],"mappings":";KAOK,gBAAA;AAAA,KAEA,kBAAA,IAAsB,QAAgB;AAAA,KACtC,kBAAA,IAAsB,QAAgB;AAAA,KACtC,eAAA,IAAmB,QAAgB;AAAA,KACnC,iBAAA,IAAqB,QAAA,UAAkB,KAAA,EAAO,KAAK;AAAA,KACnD,kBAAA,IAAsB,QAAgB;AAAA,KACtC,qBAAA,IAAyB,QAAgB;AAAA,KACzC,mBAAA,GACD,kBAAA,GACA,kBAAA,GACA,eAAA,GACA,iBAAA,GACA,kBAAA,GACA,qBAAA;;;AAZuC;KAiB/B,WAAA;EAhBW;;;EAoBrB,OAAA;EAnBG;;;EAuBH,OAAO;AAAA;AAAA,cAsBI,YAAA;EA5CS;;;EAAA,QAgDZ,EAAA;EAhDyC;;;AAAK;EAsDzC,KAAA,CAAM,MAAA,GAAS,WAAA,GAAW,OAAA;EArDlB;;;AAAoB;EAApB,QA8Gb,YAAA;EA7GgB;;;EAoHjB,YAAA,CAAa,QAAA,EAAU,kBAAA,4BAAkB,iBAAA;EAnH7C;;;EA0HI,YAAA,CAAa,QAAA,EAAU,kBAAA,4BAAkB,iBAAA;EAxH9C;;;EA+HK,SAAA,CAAU,QAAA,EAAU,eAAA,4BAAe,iBAAA;EA3HxC;;;EAkIK,WAAA,CAAY,QAAA,EAAU,iBAAA,4BAAiB,iBAAA;EAtI5C;;;EA6IK,cAAA,CAAe,QAAA,EAAU,kBAAA,4BAAkB,iBAAA;EAzIhD;;AAAqB;EAgJhB,iBAAA,CAAkB,QAAA,EAAU,qBAAA,4BAAqB,iBAAA;EA3InC;;;EAkJd,EAAA,CAAG,KAAA,EAAO,gBAAA,EAAkB,QAAA,EAAU,mBAAA,4BAAmB,iBAAA;AAAA"}

package/esm/dev-server/health-checker/checkers/base-health-checker.d.mts

@@ -1,55 +0,0 @@
-import { FileManager } from "../../file-manager.mjs";
-import { FileHealthResult } from "../file-health-result.mjs";
-import { FileHealthCheckerContract, HealthCheckerFilesStats } from "../file-health-checker.contract.mjs";
-
-//#region ../core/src/dev-server/health-checker/checkers/base-health-checker.d.ts
-type CheckerFile = {
-  file: FileManager;
-  healthResult: FileHealthResult;
-};
-declare abstract class BaseHealthChecker implements FileHealthCheckerContract {
-  /**
-   * List of checked files
-   */
-  protected files: Map<string, CheckerFile>;
-  /**
-   * Health checker name (unique identifier)
-   */
-  abstract name: string;
-  /**
-   * Path to worker file (without extension)
-   *
-   * If provided, the checker runs in a dedicated worker thread.
-   * If undefined, the checker runs in the main thread.
-   *
-   * @see FileHealthCheckerContract.workerPath
-   */
-  workerPath?: string;
-  /**
-   * Initialize the health checker
-   */
-  abstract initialize(): void;
-  /**
-   * Detect when files are changed
-   */
-  onFileChanges(files: FileManager[]): Promise<void>;
-  /**
-   * Remove the given file from the checker
-   */
-  removeFile(file: FileManager): BaseHealthChecker;
-  /**
-   * Validate the health of the file
-   */
-  check(file: FileManager): Promise<FileHealthResult>;
-  /**
-   * Validate the health of the file
-   */
-  abstract validate(file: FileManager, result: FileHealthResult): Promise<FileHealthResult>;
-  /**
-   * Get the stats of the health checker
-   */
-  stats(): Promise<HealthCheckerFilesStats>;
-}
-//#endregion
-export { BaseHealthChecker };
-//# sourceMappingURL=base-health-checker.d.mts.map

package/esm/dev-server/health-checker/checkers/base-health-checker.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"base-health-checker.d.mts","names":[],"sources":["../../../../../../../../../core/src/dev-server/health-checker/checkers/base-health-checker.ts"],"mappings":";;;;;KAOK,WAAA;EACH,IAAA,EAAM,WAAA;EACN,YAAA,EAAc,gBAAgB;AAAA;AAAA,uBAGV,iBAAA,YAA6B,yBAAA;EAHnB;;;EAAA,UAOpB,KAAA,EAAO,GAAA,SAAY,WAAA;EAPf;;AAAgB;EAAhB,SAYE,IAAA;EATsB;;;;;;;;EAmB/B,UAAA;EAyBwC;;;EAAA,SApB/B,UAAA;EAkC+D;;;EA7BlE,aAAA,CAAc,KAAA,EAAO,WAAA,KAAgB,OAAA;EA7BD;;;EAoC1C,UAAA,CAAW,IAAA,EAAM,WAAA,GAAc,iBAAA;EAhC5B;;;EAwCG,KAAA,CAAM,IAAA,EAAM,WAAA,GAAc,OAAA,CAAQ,gBAAA;EAzBxC;;;EAAA,SAuCS,QAAA,CAAS,IAAA,EAAM,WAAA,EAAa,MAAA,EAAQ,gBAAA,GAAmB,OAAA,CAAQ,gBAAA;EA7BpD;;;EAkCd,KAAA,IAAS,OAAA,CAAQ,uBAAA;AAAA"}

package/esm/dev-server/health-checker/checkers/eslint-health-checker.d.mts

@@ -1,44 +0,0 @@
-import { FileManager } from "../../file-manager.mjs";
-import { FileHealthResult } from "../file-health-result.mjs";
-import { FileHealthCheckerContract } from "../file-health-checker.contract.mjs";
-import { BaseHealthChecker } from "./base-health-checker.mjs";
-
-//#region ../core/src/dev-server/health-checker/checkers/eslint-health-checker.d.ts
-declare class EslintHealthChecker extends BaseHealthChecker implements FileHealthCheckerContract {
-  /**
-   * ESLint instance (using new ESLint v9 API with flat config)
-   */
-  private eslint;
-  /**
-   * Health checker name
-   */
-  name: string;
-  /**
-   * Path to dedicated worker file for ESLint checking
-   * Runs in a separate thread to avoid blocking the main dev server
-   */
-  workerPath: string;
-  /**
-   * Whether checker is initialized
-   */
-  private initialized;
-  /**
-   * Check if file is a lintable file
-   */
-  private isLintableFile;
-  /**
-   * Initialize the health checker
-   */
-  initialize(): EslintHealthChecker;
-  /**
-   * Display health check results in a pretty format
-   */
-  private displayResults;
-  /**
-   * Validate the health of the file
-   */
-  validate(file: FileManager, result: FileHealthResult): Promise<FileHealthResult>;
-}
-//#endregion
-export { EslintHealthChecker };
-//# sourceMappingURL=eslint-health-checker.d.mts.map

package/esm/dev-server/health-checker/checkers/eslint-health-checker.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"eslint-health-checker.d.mts","names":[],"sources":["../../../../../../../../../core/src/dev-server/health-checker/checkers/eslint-health-checker.ts"],"mappings":";;;;;;cASa,mBAAA,SAA4B,iBAAA,YAA6B,yBAAA;;AAAtE;;UAIU,MAAA;EA+Ba;;;EA1Bd,IAAA;EA2K6D;;;;EArK7D,UAAA;EAfgC;;;EAAA,QAoB/B,WAAA;EALD;;;EAAA,QAUC,cAAA;EAUa;;;EAAd,UAAA,IAAc,mBAAA;EAiJC;;;EAAA,QA5Gd,cAAA;EA4GoE;;AAAgB;EAA/E,QAAA,CAAS,IAAA,EAAM,WAAA,EAAa,MAAA,EAAQ,gBAAA,GAAmB,OAAA,CAAQ,gBAAA;AAAA"}