@warlock.js/core 5.28.0 → 5.30.0

package/CHANGELOG.md

@@ -6,6 +6,77 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 > ⚠ **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.**
 
+## 5.30.0 - 2026-10-16
+
+### Upgrading
+
+- **BREAKING (only for a custom log channel that reads `context.request` or `context.response`):** request log entries now carry a plain `RequestLogSnapshot` instead of the `Request`/`Response` instances. Read the fields you need from the snapshot, or call `request.toLogSnapshot()` in your own log calls.
+- **The image-variant cache moves to a new layout (FW-10):** derivatives cached by 5.29 under `<cacheDirectory>/<2 hex>/<hash>.<ext>` are no longer read; each is re-rendered on its next request. Delete those old two-level files once (or call `purgeImageVariants()`) to reclaim the space.
+
+### Added
+
+- **`request.signal`**: an `AbortSignal` that aborts when the client disconnects before the response finishes (not when the request body finishes reading, never on normal completion); its listener is attached on first access and removed when the response closes (WR-012).
+- **Stream backpressure**: `response.stream()`'s controller gains `write(data)` (sends, then waits until the client can take more; `false` once it is gone), `drain()`, `backpressured`, `signal` (aborted on client disconnect, not on `end()`) and `onDisconnect(fn)`, matching `response.sse()` (WR-006).
+- **SSE backpressure**: `sse.write(event, data, id?)` sends and waits until the client can take more (`false` once it is gone), plus `sse.drain()`, `sse.backpressured` and `sse.signal` (aborted on disconnect) (WR-006).
+- **`http.serverOptions` is typed** (`HttpServerOptions`), including Node's native `http` options such as `serverOptions.http.maxHeaderSize`; it was already forwarded to Fastify but the config type could not express it (WR-005).
+- **`@warlock.js/core/errors`**: a side-effect-free subpath with `HttpError` and its subclasses (`BadRequestError`, `ResourceNotFoundError`, …). A standalone helper or worker can import it without bundling Cascade, Cache or the MongoDB driver; the classes are the same ones the root exports, so `instanceof` holds across both (WR-017).
+- **`http.errorMapper`**: map errors that are not an `HttpError` to `{ status, message?, payload? }` (or an `HttpError`), so domain errors shared with non-HTTP processes need not extend Core. A mapped 5xx stays opaque unless the mapper sets a message; a mapper that throws is logged and ignored (WR-018).
+- **Per-route request logging policy**: `logging: { body?: boolean, query?: boolean }` on a route, with app-wide defaults under `http.logging` (plus `redactQueryParams`). It is applied before any log entry is built, so a schema- or middleware-rejected body never reaches a log channel (WR-003).
+- **`request.toLogSnapshot()`**, `buildRequestLogSnapshot()` and `redactUrlCredentials()`: the bounded, plain-data view of a request that log entries now carry (WR-003).
+- **`purgeImageVariants(path?, { disk? })`** removes one file's cached image derivatives, or a disk's whole derivative cache (FW-10).
+- **`createUploadedFileController({ disk })`** serves the originals and variants of any local disk, and **`resolveImageVariant({ disk?, path, variant, format? })`** resolves (and renders on a miss) one variant for an app's own route, e.g. a private disk behind auth. `uploadedFileController` is `createUploadedFileController()` (FW-11).
+- **Shared rate limits:** `http.rateLimit.store: "cache"` counts in `@warlock.js/cache`, so every process on a shared driver (Redis, Postgres) shares the limit; `middleware.rateLimit()` follows it or takes its own `store` and a stable `name`. A `@fastify/rate-limit` store class can be passed as `store` too. Windows are fixed and clock-aligned. Each route with its own `rateLimit` counts separately (namespaced by method and URL from the plugin's `routeInfo`, hashed so `/users/:id` and `/users/id` never merge). A cache outage fails open on both limiters (`skipOnError` defaults to `true` for this store) and is logged at most once a minute. The `null` and `file` cache drivers are refused with `UnsupportedRateLimitDriverError` (one stores nothing, the other never sweeps expired windows and does not share increments between processes) (FW-14).
+
+### Changed
+
+- **`response.stream()` no longer keeps rendered chunks.** `response.body` after `end()` holds the last `retainChunks` chunks written by `send()`, `write()` or `render()` (`response.stream(type, { retainChunks })`, default 0); it used to hold every `render()` chunk (WR-006).
+- `response.stream()`: after the client disconnects, `send()`/`render()` are silent no-ops and `ended` is `true` (they used to write to the closed socket); `send()` after `end()` still throws.
+- **`@fastify/static` is only loaded when there is something to serve** — at least one `router.directory()`, or an existing public folder (`storage.publicRoot`, which now also accepts `false` to turn it off). Its directory-listing module calls `os.cpus()` at load, which cost a measured ~0.4–0.5 s of cold start in an app that served neither (WR-027). With no public folder, `reply.sendFile` is no longer decorated by that plugin; `response.sendFile()` is unaffected.
+- `@warlock.js/core/errors` also resolves inside the framework repository (a root `errors/index.ts` re-export, not published), so workspace packages and tests can import it by its package name (WR-017).
+- **`response.sse()` no longer keeps every sent event.** `response.body` after `end()` holds the last `retainEvents` events (`response.sse({ retainEvents })`, default 0), so long-lived streams no longer grow with their history (WR-006).
+- **BREAKING (only for a custom log channel that reads `context.request`/`context.response`):** **request log entries carry a `RequestLogSnapshot`, not the `Request`/`Response` instances** (`context.request` is `{ id, method, url, route, name, ip, userAgent, query?, body? }`; `response.log` adds `{ statusCode }`). Native request/reply graphs no longer reach log channels, and credential-bearing query values (`secret`, `token`, `apiKey`, `signature`, `code`, `X-Amz-*`, …) are masked in the logged URL (WR-003).
+- **`warlock add notifications` writes a smaller, convention-following module** (FW-09): `models/notification/` (model with a `NotificationResource`, migration), `resources/`, a validated `schema/list-notifications.schema.ts` (`limit` capped at 50, no `request.all()`), a guarded `types/notifications-request.type.ts`, `services/`, `utils/locales.json`, one controller per file for list / unread-count / mark-read / mark-all-read registered through `router.route()`, a commented `gate()` permission hook, and a 401 spec per controller when the app has the test feature. The clear-all and delete endpoints are no longer generated. Apps that already have a notification model (5.29 layout included) are skipped, and a freshly ejected `config/notifications.ts` then imports the 5.29 model path. In an app that already has `src/app/notifications`, no second model or migration is added, existing files are kept (and listed), and `notFound` is merged into an existing `utils/locales.json`. The mark-read controller turns a numeric `:id` into a number (integer ids on the default MongoDB stack) and keeps other ids as strings; the list query drops unknown keys such as a cache-busting `_` instead of rejecting them.
+- Image derivatives are cached per source (`<cacheDirectory>/<2 hex>/<sourceKey>/<size-mtime>/<hash>.<ext>`). Deleting or moving a file through a local disk (`delete`, `deleteMany`, `move`, and `deleteDirectory` for every file under it) removes its derivatives, and a rewritten source's old derivatives are pruned once a new one is written, so the cache no longer grows forever. Pruning re-checks the source first, so a request that read an older version never deletes the newer version's derivatives, and a derivative pruned mid-request is rendered again instead of answering 500 (FW-10).
+- Concurrent variant requests for the same file on two disks (a mirror copied with its mtime) no longer share one generation, which left the second target unwritten and answered 500 (FW-11).
+- A warning is logged once when the image-variant cache sits inside the public folder: a configured `uploads.images.cacheDirectory` is shared by every local disk, so private derivatives there would be publicly served.
+- `storage.use(name)` (and `StorageManagerContract.use`) is typed as `ScopedStorage`, the class it returns, so `deleteDirectory`, `copyDirectory`, `moveDirectory`, `emptyDirectory`, `putFromUrl`, `prepend` and `append` type-check without a cast (FW-12).
+- `middleware.rateLimit()` returns an async middleware (its in-memory path still completes synchronously).
+- The `run-app` skill lists where each pnpm version reads build approvals (`allowBuilds` on 10.26+, workspace `onlyBuiltDependencies` on 10.5–10.25, `package.json` before 10.5); it used to say only `allowBuilds` works.
+
+### Fixed
+
+- Graceful shutdown no longer waits out its timeout on keep-alive connections whose request finished during the drain: in-flight responses answer `Connection: close` and connections are closed as they go idle (default `forceCloseConnections: "idle"`), so later connectors still shut down. Active responses are never cut short (WR-014).
+- A `response.sse()` or `response.stream()` started after graceful shutdown began keeps the drain's `Connection: close`; its own `Connection: keep-alive` used to override it and hold `close()` until the shutdown timeout.
+- `response.sse()` removes line breaks and NUL from event names and ids, and writes a multi-line `comment()` as one comment line per line, so values built from user input cannot inject SSE fields or events.
+- An `onDisconnect` handler on `response.sse()` or `response.stream()` that throws is logged and no longer crashes the process or skips the handlers after it.
+- `warlock.config.ts` loads when it imports local TypeScript without an extension (`./src/connectors/local`) or through a tsconfig `paths` alias, on Node without native TypeScript and with native type stripping alike. The fallback bundles the config's local graph with esbuild, keeps packages external (one `BaseConnector`/container identity), runs the config once, rethrows its own errors unchanged, keeps each inlined module's `import.meta.url`, and removes its temp file (WR-004).
+- `v.file()` rule methods (`maxSize`, `image`, `accept`, `mimeType`, …) return `this`, so the `UploadedFile` output type survives the chain; `saveTo()` is typed as a `string` output (WR-020).
+- The dev server and the HTTP test server register module `src/app/<module>/utils/locales.json` dictionaries at boot; they were left out of the boot file set, so `t()` printed raw keys until the file was edited (FW-02).
+- The HTTP test server no longer keeps Vitest's main process alive after teardown: the loader-hook `MessagePort` is unreferenced except while a version-bump flush waits for its acknowledgement (FW-05).
+- A quoted config key (`"machine-thumb"`, `'single-quoted'`) is written to `.warlock/typings/config.d.ts` without its quotes, so the generated file stays valid TypeScript; computed keys are skipped, and a quoted storage driver name is no longer quoted twice (FW-06). The typings manifest now records its generator version, and a manifest written by an older version is discarded, so a `config.d.ts` broken by 5.29 is regenerated on the first boot after upgrading instead of only when a config file changes.
+- The circular-dependency check no longer reports a file as importing itself because a comment mentions `import("./same-file")`: the regex fallback ignores comments and self imports are not dependency edges (FW-13). Comments are found with the TypeScript parser, so a regex literal such as `/\/*$/` or `//` inside JSX text is never mistaken for one and the imports after it are kept. A pure `export type { X } from` re-export adds no dependency edge on either parsing path.
+- `warlock add web`'s `src/web/root.tsx` stub notes that `<Head />` renders the viewport tag (`metadata.viewport` changes or disables it) and does not hand-write a second one (FW-03).
+- Mail logs no longer print recipient addresses: send, development, test-mode, partial-rejection and error lines show `m***@example.com` (FW-04). `MailResult` and a thrown `MailError` still carry the real addresses.
+- `http.rateLimit` had no way to share counts between processes except an ioredis client, which the node-redis connection of `@warlock.js/cache` cannot provide (FW-14).
+- Request log snapshots mask credential query parameters (`code`, `signature`, `sig`, `X-Amz-*`, `X-Goog-*`, the logger's secret keys and `http.logging.redactQueryParams`) in the parsed `query` too, not only in `url`; OAuth authorization codes no longer reach log lines. New `redactQueryCredentials()`.
+- `warlock.config.ts` fallback: a catch-all tsconfig `paths` pattern (`"*": ["./types/*"]`) no longer inlines packages into the config bundle; an alias is inlined only when it resolves outside `node_modules`.
+- `warlock.config.ts` fallback: `import.meta.url`/`dirname`/`filename` are replaced only where they are real expressions, so the same words inside a string or comment no longer break or alter the bundled config.
+- `warlock.config.ts` fallback runs only for the config's own unresolved relative or aliased imports (not for a package that is not installed, or a module missing inside `node_modules`), and also when native type stripping refuses the TypeScript (`ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX`, `ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING`). A loading error in the bundled config names `warlock.config.ts` instead of the temporary module.
+- `warlock add image` on pnpm 9 and 10.0–10.4 no longer creates a settings-only `pnpm-workspace.yaml` (`packages field missing or empty`): the sharp approval goes where the installed pnpm reads it (`package.json` `pnpm.onlyBuiltDependencies` before 10.5, the workspace's `onlyBuiltDependencies` on 10.5–10.25, `allowBuilds` from 10.26). Inside a parent pnpm workspace no per-app file is written.
+
+## 5.29.0 - 2026-10-01
+
+### Added
+
+- **`nullable(Resource)`**: a resource that may be `null`, accepted as a `defineResource` field and in `responseSchema` bodies. A field outputs `null` (not omitted) for null/undefined input; `ResourceOutput`/`ResponseBodyOutput` type it as `Output | null`; OpenAPI documents it as `oneOf [resource, null]`; route types emit `… | null` (FORMAI).
+- **`[Resource]` list fields in `defineResource`**: each item is mapped through the resource, `[]` stays `[]`, and the output type is an array (the same syntax `responseSchema` already accepts). Plain `Resource` fields behave as before (FORMAI).
+
+### Fixed
+
+- Cast strings inside an `arrayOf({...})` item schema (`"number"`, `"string?"`, `"date"`, `"string[]"`) were silently dropped from the resource output; they are now cast like top-level fields, matching the output type.
+- `parseLocaleDictionary()` accepts `defaultNamespace` as a function, called only when the file declares no `$group`, so a folder that cannot name a namespace never fails a file with an explicit `$group`.
+- `warlock dev` publishes each `src/app` file it reloads (`{ url, generation }`, after the loader hook confirms the bump) through the `development.appModules` container key, so `@warlock.js/web` can load the same module instance in page loaders.
+
 ## 5.28.0 - 2026-10-01
 
 ### Added

package/esm/application/app.d.mts

@@ -3,7 +3,7 @@ import { DataSource } from "@warlock.js/cascade";
 import { FastifyInstance } from "fastify";
 import { Server } from "socket.io";
 
-//#region ../core/src/application/app.d.ts
+//#region ../../packages/core/src/application/app.d.ts
 type RuntimeApplication = {
   socket: Server | undefined;
   http: FastifyInstance | undefined;

package/esm/application/app.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"app.d.mts","names":[],"sources":["../../../../../../../core/src/application/app.ts"],"mappings":";;;;;;KAMK,kBAAA;EACH,MAAA,EAAQ,MAAA;EACR,IAAA,EAAM,eAAA;EACN,MAAA,EAAQ,MAAA;EACR,QAAA,EAAU,UAAA;AAAA;AAAA,cAGC,GAAA,EAAK,kBAkCjB"}
+{"version":3,"file":"app.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/application/app.ts"],"mappings":";;;;;;KAMK,kBAAA;EACH,MAAA,EAAQ,MAAA;EACR,IAAA,EAAM,eAAA;EACN,MAAA,EAAQ,MAAA;EACR,QAAA,EAAU,UAAA;AAAA;AAAA,cAGC,GAAA,EAAK,kBAkCjB"}

package/esm/application/app.mjs

@@ -1,6 +1,6 @@
 import { container } from "../container/index.mjs";
 
-//#region ../core/src/application/app.ts
+//#region ../../packages/core/src/application/app.ts
 const app = {
 	/**
 	* Socket Io Instance

package/esm/application/app.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"app.mjs","names":[],"sources":["../../../../../../../core/src/application/app.ts"],"sourcesContent":["import { type DataSource } from \"@warlock.js/cascade\";\nimport { type FastifyInstance } from \"fastify\";\nimport { type Server } from \"socket.io\";\nimport { type Router } from \"../router\";\nimport { container } from \"./../container\";\n\ntype RuntimeApplication = {\n  socket: Server | undefined;\n  http: FastifyInstance | undefined;\n  router: Router;\n  database: DataSource | undefined;\n};\n\nexport const app: RuntimeApplication = {\n  /**\n   * Socket Io Instance\n   * Available only if socket.io config file exists\n   */\n  get socket() {\n    return container.tryGet(\"socket\");\n  },\n  /**\n   * HTTP Server Instance\n   * Available only if http config file exists\n   */\n  get http() {\n    return container.tryGet(\"http.server\");\n  },\n  /**\n   * Router Instance\n   *\n   * Unlike `socket`/`database`, the router is set unconditionally at\n   * `router.ts` module load (there is no \"no router configured\" case), so a\n   * miss here is never a legitimate absence — it means either a genuine bug\n   * or a duplicate-instance dev-path read. `get` surfaces that instead of\n   * silently returning `undefined`.\n   */\n  get router() {\n    return container.get(\"router\");\n  },\n  /**\n   * Database Instance\n   * Available only if database config file exists\n   */\n  get database() {\n    return container.tryGet(\"database.source\");\n  },\n};\n"],"mappings":";;;AAaA,MAAa,MAA0B;;;;;CAKrC,IAAI,SAAS;EACX,OAAO,UAAU,OAAO,QAAQ;CAClC;;;;;CAKA,IAAI,OAAO;EACT,OAAO,UAAU,OAAO,aAAa;CACvC;;;;;;;;;;CAUA,IAAI,SAAS;EACX,OAAO,UAAU,IAAI,QAAQ;CAC/B;;;;;CAKA,IAAI,WAAW;EACb,OAAO,UAAU,OAAO,iBAAiB;CAC3C;AACF"}
+{"version":3,"file":"app.mjs","names":[],"sources":["../../../../../../../../packages/core/src/application/app.ts"],"sourcesContent":["import { type DataSource } from \"@warlock.js/cascade\";\nimport { type FastifyInstance } from \"fastify\";\nimport { type Server } from \"socket.io\";\nimport { type Router } from \"../router\";\nimport { container } from \"./../container\";\n\ntype RuntimeApplication = {\n  socket: Server | undefined;\n  http: FastifyInstance | undefined;\n  router: Router;\n  database: DataSource | undefined;\n};\n\nexport const app: RuntimeApplication = {\n  /**\n   * Socket Io Instance\n   * Available only if socket.io config file exists\n   */\n  get socket() {\n    return container.tryGet(\"socket\");\n  },\n  /**\n   * HTTP Server Instance\n   * Available only if http config file exists\n   */\n  get http() {\n    return container.tryGet(\"http.server\");\n  },\n  /**\n   * Router Instance\n   *\n   * Unlike `socket`/`database`, the router is set unconditionally at\n   * `router.ts` module load (there is no \"no router configured\" case), so a\n   * miss here is never a legitimate absence — it means either a genuine bug\n   * or a duplicate-instance dev-path read. `get` surfaces that instead of\n   * silently returning `undefined`.\n   */\n  get router() {\n    return container.get(\"router\");\n  },\n  /**\n   * Database Instance\n   * Available only if database config file exists\n   */\n  get database() {\n    return container.tryGet(\"database.source\");\n  },\n};\n"],"mappings":";;;AAaA,MAAa,MAA0B;;;;;CAKrC,IAAI,SAAS;EACX,OAAO,UAAU,OAAO,QAAQ;CAClC;;;;;CAKA,IAAI,OAAO;EACT,OAAO,UAAU,OAAO,aAAa;CACvC;;;;;;;;;;CAUA,IAAI,SAAS;EACX,OAAO,UAAU,IAAI,QAAQ;CAC/B;;;;;CAKA,IAAI,WAAW;EACb,OAAO,UAAU,OAAO,iBAAiB;CAC3C;AACF"}

package/esm/application/application-config-types.d.mts

@@ -1,4 +1,4 @@
-//#region ../core/src/application/application-config-types.d.ts
+//#region ../../packages/core/src/application/application-config-types.d.ts
 type AppConfigurations = {
   /**
    * App name

package/esm/application/application-config-types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"application-config-types.d.mts","names":[],"sources":["../../../../../../../core/src/application/application-config-types.ts"],"mappings":";KAAY,iBAAA;EAAA;;;EAIV,OAAA;EAAA;;;;;EAMA,UAAA;EAuBW;AAAA;;;;EAjBX,OAAA;;;;;;;;;EASA,SAAA;;;;EAIA,QAAA;;;;EAIA,WAAA;AAAA"}
+{"version":3,"file":"application-config-types.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/application/application-config-types.ts"],"mappings":";KAAY,iBAAA;EAAA;;;EAIV,OAAA;EAAA;;;;;EAMA,UAAA;EAuBW;AAAA;;;;EAjBX,OAAA;;;;;;;;;EASA,SAAA;;;;EAIA,QAAA;;;;EAIA,WAAA;AAAA"}

package/esm/application/application.d.mts

@@ -1,7 +1,7 @@
 import { Environment, RuntimeStrategy } from "../utils/environment.mjs";
 import { AppRole } from "./roles.mjs";
 
-//#region ../core/src/application/application.d.ts
+//#region ../../packages/core/src/application/application.d.ts
 /**
  * Snapshot of the global facts known the moment the application finished
  * booting: every connector (early + late) is active and all app files

package/esm/application/application.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"application.d.mts","names":[],"sources":["../../../../../../../core/src/application/application.ts"],"mappings":";;;;;;AAkBA;;;;KAAY,WAAA;EACV,WAAA,EAAa,WAAA;EACb,eAAA,EAAiB,eAAe;EAAf;;;AAKH;EAAd,cAAA;AAAA;;;;;;KAQU,YAAA,IAAgB,OAAA,EAAS,WAAA,YAAuB,OAAO;AAAA;AAYnE;;;;AAAgD;AAkBhD;;;;AA9BmE,KAYvD,aAAA,gBAA6B,OAAO;AAoBhD;;;;;AAAA,KAFY,gBAAA,gBAAgC,OAAO;AAAA,cAEtC,WAAA;EAwHyB;;;EAAA,gBApHb,SAAA,EAAS,IAAA;EA4OY;;;EAAA,OAvO9B,eAAA,EAAiB,eAAA;EAqVG;;;EAAA,eAhVnB,MAAA;EAkYa;;;EAAA,eA7Xb,WAAA;EAfiB;;;;EAAA,eAqBjB,aAAA;EAAA;;;;;EAAA,eAOA,SAAA;EA8BG;;;;EAAA,eAxBH,cAAA;EAiDD;;;;;;EAAA,eAzCC,UAAA;EA0EqB;;;;EAAA,eApErB,YAAA;EA8JD;;;EAAA,eAzJC,iBAAA;EAuL6B;;;EAAA,WAlL1B,OAAA;EAiOO;;;EAAA,OA1NX,kBAAA,CAAmB,QAAA,EAAU,eAAA;EA2QzB;;;;;EAAA,WAlQA,QAAA;EAuRA;;;;;EAAA,OA9QJ,aAAA,CAAc,IAAA;EA6SV;;;;;;;;;;;;AAsDU;;EAtDV,OA3RJ,UAAA,CAAW,QAAA,EAAU,YAAA;;;;;SAerB,UAAA,IAAc,OAAA,CAAQ,WAAA;;;;;;;;;;;;;;;SAwBtB,UAAA,CAAW,OAAA,EAAS,WAAA;;;;;iBAgCb,eAAA;;;;;;;;;;;;;;;;;;;;;;;;SAkCP,cAAA,CAAe,SAAA,EAAW,aAAA;;;;;;;;;;;;;;;;;;SA8BpB,oBAAA,IAAwB,OAAA;;;;;;aAgC1B,cAAA;;;;;;;;;;;;SAeJ,UAAA,CAAW,QAAA,EAAU,gBAAA;;;;;;;;;;SAmBf,gBAAA,IAAoB,OAAA;;;;;iBAmBnB,mBAAA;;;;aAWH,MAAA;;;;aAOA,WAAA,IAAe,WAAA;;;;SAOnB,cAAA,CAAe,GAAA,EAAK,WAAA;;;;aAOhB,YAAA;;;;aAOA,aAAA;;;;aAOA,MAAA;;;;;;aASA,KAAA,IAAS,WAAA,CAAY,OAAA;;;;;aAQrB,KAAA,IAAS,WAAA;;;;;;;;;SAYb,OAAA,CAAQ,IAAA,EAAM,OAAA;;;;aAOV,QAAA;;;;aAOA,OAAA;;;;aAOA,OAAA;;;;aAOA,WAAA;;;;aAOA,WAAA;;;;aAOA,UAAA;AAAA"}
+{"version":3,"file":"application.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/application/application.ts"],"mappings":";;;;;;AAkBA;;;;KAAY,WAAA;EACV,WAAA,EAAa,WAAA;EACb,eAAA,EAAiB,eAAe;EAAf;;;AAKH;EAAd,cAAA;AAAA;;;;;;KAQU,YAAA,IAAgB,OAAA,EAAS,WAAA,YAAuB,OAAO;AAAA;AAYnE;;;;AAAgD;AAkBhD;;;;AA9BmE,KAYvD,aAAA,gBAA6B,OAAO;AAoBhD;;;;;AAAA,KAFY,gBAAA,gBAAgC,OAAO;AAAA,cAEtC,WAAA;EAwHyB;;;EAAA,gBApHb,SAAA,EAAS,IAAA;EA4OY;;;EAAA,OAvO9B,eAAA,EAAiB,eAAA;EAqVG;;;EAAA,eAhVnB,MAAA;EAkYa;;;EAAA,eA7Xb,WAAA;EAfiB;;;;EAAA,eAqBjB,aAAA;EAAA;;;;;EAAA,eAOA,SAAA;EA8BG;;;;EAAA,eAxBH,cAAA;EAiDD;;;;;;EAAA,eAzCC,UAAA;EA0EqB;;;;EAAA,eApErB,YAAA;EA8JD;;;EAAA,eAzJC,iBAAA;EAuL6B;;;EAAA,WAlL1B,OAAA;EAiOO;;;EAAA,OA1NX,kBAAA,CAAmB,QAAA,EAAU,eAAA;EA2QzB;;;;;EAAA,WAlQA,QAAA;EAuRA;;;;;EAAA,OA9QJ,aAAA,CAAc,IAAA;EA6SV;;;;;;;;;;;;AAsDU;;EAtDV,OA3RJ,UAAA,CAAW,QAAA,EAAU,YAAA;;;;;SAerB,UAAA,IAAc,OAAA,CAAQ,WAAA;;;;;;;;;;;;;;;SAwBtB,UAAA,CAAW,OAAA,EAAS,WAAA;;;;;iBAgCb,eAAA;;;;;;;;;;;;;;;;;;;;;;;;SAkCP,cAAA,CAAe,SAAA,EAAW,aAAA;;;;;;;;;;;;;;;;;;SA8BpB,oBAAA,IAAwB,OAAA;;;;;;aAgC1B,cAAA;;;;;;;;;;;;SAeJ,UAAA,CAAW,QAAA,EAAU,gBAAA;;;;;;;;;;SAmBf,gBAAA,IAAoB,OAAA;;;;;iBAmBnB,mBAAA;;;;aAWH,MAAA;;;;aAOA,WAAA,IAAe,WAAA;;;;SAOnB,cAAA,CAAe,GAAA,EAAK,WAAA;;;;aAOhB,YAAA;;;;aAOA,aAAA;;;;aAOA,MAAA;;;;;;aASA,KAAA,IAAS,WAAA,CAAY,OAAA;;;;;aAQrB,KAAA,IAAS,WAAA;;;;;;;;;SAYb,OAAA,CAAQ,IAAA,EAAM,OAAA;;;;aAOV,QAAA;;;;aAOA,OAAA;;;;aAOA,OAAA;;;;aAOA,WAAA;;;;aAOA,WAAA;;;;aAOA,UAAA;AAAA"}

package/esm/application/application.mjs

@@ -5,7 +5,7 @@ import { getFrameworkVersion } from "../utils/framework-vesion.mjs";
 import { getRoles, getSites, hasRole } from "./roles.mjs";
 import { log } from "@warlock.js/logger";
 
-//#region ../core/src/application/application.ts
+//#region ../../packages/core/src/application/application.ts
 const ErrorWithCause = Error;
 var Application = class {
 	static {

package/esm/application/application.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"application.mjs","names":[],"sources":["../../../../../../../core/src/application/application.ts"],"sourcesContent":["import { log } from \"@warlock.js/logger\";\nimport { BOOT_SIGNAL_VERSION, sendBootSignal } from \"./boot-signal\";\nimport {\n  environment,\n  setEnvironment,\n  type Environment,\n  type RuntimeStrategy,\n} from \"../utils/environment\";\nimport { getFrameworkVersion } from \"../utils/framework-vesion\";\nimport { appPath, publicPath, rootPath, srcPath, storagePath, uploadsPath } from \"../utils/paths\";\nimport { getRoles, getSites, hasRole, type AppRole } from \"./roles\";\n\n/**\n * Snapshot of the global facts known the moment the application finished\n * booting: every connector (early + late) is active and all app files\n * (locales, events, main, routes) are loaded. Passed to every\n * `Application.onceBooted` listener and resolved from `Application.whenBooted`.\n */\nexport type BootContext = {\n  environment: Environment;\n  runtimeStrategy: RuntimeStrategy;\n  /**\n   * Wall-clock milliseconds the boot took. The dev server measures it; the\n   * production entry omits it.\n   */\n  bootDurationMs?: number;\n};\n\n/**\n * A callback registered through `Application.onceBooted`. May be async — its\n * rejection is caught and logged so a single listener can never break boot or\n * the other listeners.\n */\nexport type BootListener = (context: BootContext) => void | Promise<void>;\n\n/**\n * A callback registered through `Application.onValidateBoot`. May be async —\n * unlike {@link BootListener}, its rejection is NOT caught: it aborts boot.\n *\n * Use this for configuration that makes the application WRONG rather than\n * degraded when missing (a signing secret, a required integration key) — the\n * kind of check that must fail closed. Use `onceBooted` for everything else;\n * that contract stays fire-and-forget on purpose (it is the right behaviour\n * for plugins reacting to boot, not for gating it).\n */\nexport type BootValidator = () => void | Promise<void>;\n\n/**\n * `new Error(message, { cause })` is ES2022, and this package still compiles\n * against the ES2020 lib, where `Error` is typed as taking a message only.\n * Node has supported the option since v16, so this is the type layer\n * catching up with the runtime, not a change in what the code does. Same\n * workaround as `image.ts` (see #16).\n */\ntype ErrorWithCauseConstructor = new (message: string, options: { cause: unknown }) => Error;\n\nconst ErrorWithCause = Error as ErrorWithCauseConstructor;\n\n/**\n * A callback registered through `Application.onShutdown`. Runs once, while the\n * connectors (db, cache, http) are still up, so it can release app-owned\n * resources cleanly. May be async — its rejection is caught and logged.\n */\nexport type ShutdownListener = () => void | Promise<void>;\n\nexport class Application {\n  /**\n   * Project start time regarding the process start time\n   */\n  public static readonly startedAt = new Date(Date.now() - process.uptime() * 1000);\n\n  /**\n   * Runtime strategy\n   */\n  public static runtimeStrategy: RuntimeStrategy;\n\n  /**\n   * Whether the application has finished booting. Flipped once by `markBooted`.\n   */\n  private static booted = false;\n\n  /**\n   * The boot context, set once booted so it can be replayed to late subscribers.\n   */\n  private static bootContext: BootContext | undefined;\n\n  /**\n   * Listeners queued before boot completed, drained in registration order by\n   * `markBooted`.\n   */\n  private static bootListeners: BootListener[] = [];\n\n  /**\n   * Whether `runStartupValidators` has already run. Flipped once, so a\n   * validator registered afterwards is refused instead of silently skipped\n   * or run too late to matter.\n   */\n  private static validated = false;\n\n  /**\n   * Startup validators queued before `runStartupValidators` ran, drained in\n   * registration order.\n   */\n  private static bootValidators: BootValidator[] = [];\n\n  /**\n   * The http port this process actually bound, once it has. Reported in the\n   * readiness signal so a supervisor knows where to send its health check\n   * instead of re-deriving it from config it may not be able to read.\n   * Undefined for an app with no http connector — a queue worker still boots.\n   */\n  private static servedPort: number | undefined;\n\n  /**\n   * Whether the application has begun (or finished) shutting down. Flipped once\n   * by `runShutdownHooks`.\n   */\n  private static shuttingDown = false;\n\n  /**\n   * Teardown callbacks, run once when shutdown begins.\n   */\n  private static shutdownListeners: ShutdownListener[] = [];\n\n  /**\n   * Get framework version\n   */\n  public static get version() {\n    return getFrameworkVersion();\n  }\n\n  /**\n   * Set the runtime strategy\n   */\n  public static setRuntimeStrategy(strategy: RuntimeStrategy) {\n    this.runtimeStrategy = strategy;\n  }\n\n  /**\n   * Whether the application has finished booting — every connector in both\n   * the early and late phases is active and all app files (locales, events,\n   * main, routes) have been loaded.\n   */\n  public static get isBooted(): boolean {\n    return this.booted;\n  }\n\n  /**\n   * Record the http port this process bound.\n   *\n   * @internal The http connector calls this after a successful `listen`.\n   */\n  public static setServedPort(port: number): void {\n    this.servedPort = port;\n  }\n\n  /**\n   * Run a callback once the application is fully booted.\n   *\n   * App files (`main` / `events` / `routes` / locales) are imported BEFORE the\n   * late-phase connectors (http, socket) start, so a listener registered at\n   * import time waits for the whole sequence to finish before it runs. If the\n   * application is already booted, the callback runs on the next microtask —\n   * so a late subscriber never silently misses the event.\n   *\n   * @example\n   * Application.onceBooted(({ environment }) => {\n   *   log.info(\"app\", \"booted\", `ready in ${environment}`);\n   * });\n   */\n  public static onceBooted(listener: BootListener): void {\n    if (this.booted && this.bootContext) {\n      const context = this.bootContext;\n      void this.runBootListener(listener, context);\n\n      return;\n    }\n\n    this.bootListeners.push(listener);\n  }\n\n  /**\n   * Promise form of {@link onceBooted} — resolves with the boot context once\n   * the application is booted, or immediately if it already is.\n   */\n  public static whenBooted(): Promise<BootContext> {\n    if (this.booted && this.bootContext) {\n      return Promise.resolve(this.bootContext);\n    }\n\n    return new Promise<BootContext>((resolve) => {\n      this.onceBooted((context) => resolve(context));\n    });\n  }\n\n  /**\n   * Flip the boot latch and drain every queued listener. The dev server and\n   * the production entry call this once, right after the late phase starts. It\n   * is idempotent — a second call is a no-op, so a double-invoke can never\n   * double-fire listeners.\n   *\n   * Also reports readiness to a supervising parent process — this is the one\n   * moment in the lifecycle where \"the application is serving\" is true, so it\n   * is the only honest source for `warlock start`'s success banner. Sent before\n   * the listeners run: a slow or hanging `onceBooted` listener must not delay\n   * the parent's view of a server that is already accepting requests.\n   *\n   * @internal Framework entry points call this; application code must not.\n   */\n  public static markBooted(context: BootContext): void {\n    if (this.booted) {\n      return;\n    }\n\n    this.booted = true;\n    this.bootContext = context;\n\n    sendBootSignal({\n      type: \"warlock:ready\",\n      version: BOOT_SIGNAL_VERSION,\n      pid: process.pid,\n      at: new Date().toISOString(),\n      environment: context.environment,\n      runtimeStrategy: context.runtimeStrategy,\n      bootDurationMs: context.bootDurationMs,\n      port: this.servedPort,\n      roles: [...this.roles],\n    });\n\n    const listeners = this.bootListeners;\n    this.bootListeners = [];\n\n    for (const listener of listeners) {\n      void this.runBootListener(listener, context);\n    }\n  }\n\n  /**\n   * Invoke a single boot listener, isolating its failure so neither boot nor\n   * the remaining listeners are affected.\n   */\n  private static async runBootListener(\n    listener: BootListener,\n    context: BootContext,\n  ): Promise<void> {\n    try {\n      await listener(context);\n    } catch (error) {\n      log.error(\"application\", \"booted-listener\", error as Error);\n    }\n  }\n\n  /**\n   * Register a startup validator — distinct from {@link onceBooted}. A\n   * rejecting validator aborts boot instead of being caught and logged, so\n   * this is where configuration that must fail closed belongs (a signing\n   * secret, a required integration key), not `onceBooted`.\n   *\n   * Must be registered before the framework calls `runStartupValidators` —\n   * typically at module scope in `src/app/main.ts`, the same place a\n   * `BootListener` would be registered. Registering one after validation has\n   * already run throws: by then a rejection could no longer stop the app\n   * from serving, so running it late would silently defeat the guarantee\n   * this hook exists to give.\n   *\n   * @example\n   * Application.onValidateBoot(() => {\n   *   if (!env(\"JWT_SECRET\")) {\n   *     throw new Error(\n   *       \"JWT_SECRET is not set. Sessions cannot be signed without it. \" +\n   *         \"Generate one with `yarn jwt` and put it in .env.\",\n   *     );\n   *   }\n   * });\n   */\n  public static onValidateBoot(validator: BootValidator): void {\n    if (this.validated) {\n      throw new Error(\n        \"Application.onValidateBoot(): startup validators already ran — \" +\n          \"this validator was registered too late to block boot. Register it \" +\n          \"before the framework calls Application.runStartupValidators(), \" +\n          \"typically at module scope in `src/app/main.ts`.\",\n      );\n    }\n\n    this.bootValidators.push(validator);\n  }\n\n  /**\n   * Run every registered startup validator, in registration order, and abort\n   * on the first rejection. Idempotent — a second call is a no-op.\n   *\n   * Distinct from `runBootListener`: a listener's failure is isolated so it\n   * can never break boot; a validator's failure IS the boot failing — that is\n   * the entire point of registering one instead of the other. The thrown\n   * error names the failing validator and the original cause, so whatever\n   * catches it (the dev server's boot try/catch, the production entry's\n   * top-level await) reports which check failed and why, not a bare\n   * rejection.\n   *\n   * @internal Framework entry points call this once app code (main.ts et al)\n   * has loaded and BEFORE late-phase connectors (http, socket) start, so a\n   * failing validator runs before anything can bind a port or accept a\n   * request. Application code must not call this directly.\n   */\n  public static async runStartupValidators(): Promise<void> {\n    if (this.validated) {\n      return;\n    }\n\n    this.validated = true;\n\n    const validators = this.bootValidators;\n    this.bootValidators = [];\n\n    for (const validator of validators) {\n      try {\n        await validator();\n      } catch (error) {\n        const name = validator.name || \"<anonymous>\";\n        const cause = error instanceof Error ? error.message : String(error);\n\n        throw new ErrorWithCause(\n          `Startup validator \"${name}\" rejected boot: ${cause}. ` +\n            `Fix the condition it checks, or remove the validator if it no ` +\n            `longer applies — boot cannot proceed while it fails.`,\n          { cause: error },\n        );\n      }\n    }\n  }\n\n  /**\n   * Whether the application has begun shutting down. Once true, readiness\n   * checks report not-ready so a load balancer drains this instance before the\n   * HTTP server stops accepting requests.\n   */\n  public static get isShuttingDown(): boolean {\n    return this.shuttingDown;\n  }\n\n  /**\n   * Register a teardown callback, run once when the application shuts down —\n   * before the connectors (db, cache, http) are torn down, so it can still use\n   * them. The natural place to close an app-owned resource opened in\n   * `onceBooted`. If shutdown has already begun, the callback runs immediately.\n   *\n   * @example\n   * Application.onShutdown(async () => {\n   *   await myQueueConsumer.stop();\n   * });\n   */\n  public static onShutdown(listener: ShutdownListener): void {\n    if (this.shuttingDown) {\n      void this.runShutdownListener(listener);\n\n      return;\n    }\n\n    this.shutdownListeners.push(listener);\n  }\n\n  /**\n   * Flip the shutdown latch and run every teardown callback. The connectors\n   * manager calls this at the start of shutdown — before any connector is torn\n   * down. Idempotent and error-isolated: each callback is awaited, a thrown one\n   * is logged and does not stop the rest. Listeners run LIFO (reverse of\n   * registration), mirroring resource-unwind order.\n   *\n   * @internal Framework entry points call this; application code must not.\n   */\n  public static async runShutdownHooks(): Promise<void> {\n    if (this.shuttingDown) {\n      return;\n    }\n\n    this.shuttingDown = true;\n\n    const listeners = this.shutdownListeners.reverse();\n    this.shutdownListeners = [];\n\n    for (const listener of listeners) {\n      await this.runShutdownListener(listener);\n    }\n  }\n\n  /**\n   * Invoke a single teardown callback, isolating its failure so the rest still\n   * run and shutdown is never blocked by one bad hook.\n   */\n  private static async runShutdownListener(listener: ShutdownListener): Promise<void> {\n    try {\n      await listener();\n    } catch (error) {\n      log.error(\"application\", \"shutdown-listener\", error as Error);\n    }\n  }\n\n  /**\n   * Get project uptime in milliseconds\n   */\n  public static get uptime(): number {\n    return process.uptime() * 1000;\n  }\n\n  /**\n   * Get the current environment\n   */\n  public static get environment(): Environment {\n    return environment();\n  }\n\n  /**\n   * Set the current environment\n   */\n  public static setEnvironment(env: Environment) {\n    setEnvironment(env);\n  }\n\n  /**\n   * Check if the application is running in production environment\n   */\n  public static get isProduction(): boolean {\n    return this.environment === \"production\";\n  }\n\n  /**\n   * Check if the application is running in development environment\n   */\n  public static get isDevelopment(): boolean {\n    return this.environment === \"development\";\n  }\n\n  /**\n   * Check if the application is running in test environment\n   */\n  public static get isTest(): boolean {\n    return this.environment === \"test\";\n  }\n\n  /**\n   * The roles this process serves — `WARLOCK_ROLES`, resolved once at\n   * bootstrap. Every role is on when the variable is absent (plain `warlock\n   * start`, `warlock dev`, and tests).\n   */\n  public static get roles(): ReadonlySet<AppRole> {\n    return getRoles();\n  }\n\n  /**\n   * The site keys this process installs pages for — `WARLOCK_SITES`,\n   * resolved once at bootstrap. `undefined` means every site.\n   */\n  public static get sites(): ReadonlySet<string> | undefined {\n    return getSites();\n  }\n\n  /**\n   * Whether this process serves the given role.\n   *\n   * @example\n   * if (Application.hasRole(\"worker\")) {\n   *   scheduler.start();\n   * }\n   */\n  public static hasRole(role: AppRole): boolean {\n    return hasRole(role);\n  }\n\n  /**\n   * Get the root path\n   */\n  public static get rootPath(): string {\n    return rootPath();\n  }\n\n  /**\n   * Get the src path\n   */\n  public static get srcPath(): string {\n    return srcPath();\n  }\n\n  /**\n   * Get the app path\n   */\n  public static get appPath(): string {\n    return appPath();\n  }\n\n  /**\n   * Get the storage path\n   */\n  public static get storagePath(): string {\n    return storagePath();\n  }\n\n  /**\n   * Get the uploads path\n   */\n  public static get uploadsPath(): string {\n    return uploadsPath();\n  }\n\n  /**\n   * Get the public path\n   */\n  public static get publicPath(): string {\n    return publicPath();\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"application.mjs","names":[],"sources":["../../../../../../../../packages/core/src/application/application.ts"],"sourcesContent":["import { log } from \"@warlock.js/logger\";\nimport { BOOT_SIGNAL_VERSION, sendBootSignal } from \"./boot-signal\";\nimport {\n  environment,\n  setEnvironment,\n  type Environment,\n  type RuntimeStrategy,\n} from \"../utils/environment\";\nimport { getFrameworkVersion } from \"../utils/framework-vesion\";\nimport { appPath, publicPath, rootPath, srcPath, storagePath, uploadsPath } from \"../utils/paths\";\nimport { getRoles, getSites, hasRole, type AppRole } from \"./roles\";\n\n/**\n * Snapshot of the global facts known the moment the application finished\n * booting: every connector (early + late) is active and all app files\n * (locales, events, main, routes) are loaded. Passed to every\n * `Application.onceBooted` listener and resolved from `Application.whenBooted`.\n */\nexport type BootContext = {\n  environment: Environment;\n  runtimeStrategy: RuntimeStrategy;\n  /**\n   * Wall-clock milliseconds the boot took. The dev server measures it; the\n   * production entry omits it.\n   */\n  bootDurationMs?: number;\n};\n\n/**\n * A callback registered through `Application.onceBooted`. May be async — its\n * rejection is caught and logged so a single listener can never break boot or\n * the other listeners.\n */\nexport type BootListener = (context: BootContext) => void | Promise<void>;\n\n/**\n * A callback registered through `Application.onValidateBoot`. May be async —\n * unlike {@link BootListener}, its rejection is NOT caught: it aborts boot.\n *\n * Use this for configuration that makes the application WRONG rather than\n * degraded when missing (a signing secret, a required integration key) — the\n * kind of check that must fail closed. Use `onceBooted` for everything else;\n * that contract stays fire-and-forget on purpose (it is the right behaviour\n * for plugins reacting to boot, not for gating it).\n */\nexport type BootValidator = () => void | Promise<void>;\n\n/**\n * `new Error(message, { cause })` is ES2022, and this package still compiles\n * against the ES2020 lib, where `Error` is typed as taking a message only.\n * Node has supported the option since v16, so this is the type layer\n * catching up with the runtime, not a change in what the code does. Same\n * workaround as `image.ts` (see #16).\n */\ntype ErrorWithCauseConstructor = new (message: string, options: { cause: unknown }) => Error;\n\nconst ErrorWithCause = Error as ErrorWithCauseConstructor;\n\n/**\n * A callback registered through `Application.onShutdown`. Runs once, while the\n * connectors (db, cache, http) are still up, so it can release app-owned\n * resources cleanly. May be async — its rejection is caught and logged.\n */\nexport type ShutdownListener = () => void | Promise<void>;\n\nexport class Application {\n  /**\n   * Project start time regarding the process start time\n   */\n  public static readonly startedAt = new Date(Date.now() - process.uptime() * 1000);\n\n  /**\n   * Runtime strategy\n   */\n  public static runtimeStrategy: RuntimeStrategy;\n\n  /**\n   * Whether the application has finished booting. Flipped once by `markBooted`.\n   */\n  private static booted = false;\n\n  /**\n   * The boot context, set once booted so it can be replayed to late subscribers.\n   */\n  private static bootContext: BootContext | undefined;\n\n  /**\n   * Listeners queued before boot completed, drained in registration order by\n   * `markBooted`.\n   */\n  private static bootListeners: BootListener[] = [];\n\n  /**\n   * Whether `runStartupValidators` has already run. Flipped once, so a\n   * validator registered afterwards is refused instead of silently skipped\n   * or run too late to matter.\n   */\n  private static validated = false;\n\n  /**\n   * Startup validators queued before `runStartupValidators` ran, drained in\n   * registration order.\n   */\n  private static bootValidators: BootValidator[] = [];\n\n  /**\n   * The http port this process actually bound, once it has. Reported in the\n   * readiness signal so a supervisor knows where to send its health check\n   * instead of re-deriving it from config it may not be able to read.\n   * Undefined for an app with no http connector — a queue worker still boots.\n   */\n  private static servedPort: number | undefined;\n\n  /**\n   * Whether the application has begun (or finished) shutting down. Flipped once\n   * by `runShutdownHooks`.\n   */\n  private static shuttingDown = false;\n\n  /**\n   * Teardown callbacks, run once when shutdown begins.\n   */\n  private static shutdownListeners: ShutdownListener[] = [];\n\n  /**\n   * Get framework version\n   */\n  public static get version() {\n    return getFrameworkVersion();\n  }\n\n  /**\n   * Set the runtime strategy\n   */\n  public static setRuntimeStrategy(strategy: RuntimeStrategy) {\n    this.runtimeStrategy = strategy;\n  }\n\n  /**\n   * Whether the application has finished booting — every connector in both\n   * the early and late phases is active and all app files (locales, events,\n   * main, routes) have been loaded.\n   */\n  public static get isBooted(): boolean {\n    return this.booted;\n  }\n\n  /**\n   * Record the http port this process bound.\n   *\n   * @internal The http connector calls this after a successful `listen`.\n   */\n  public static setServedPort(port: number): void {\n    this.servedPort = port;\n  }\n\n  /**\n   * Run a callback once the application is fully booted.\n   *\n   * App files (`main` / `events` / `routes` / locales) are imported BEFORE the\n   * late-phase connectors (http, socket) start, so a listener registered at\n   * import time waits for the whole sequence to finish before it runs. If the\n   * application is already booted, the callback runs on the next microtask —\n   * so a late subscriber never silently misses the event.\n   *\n   * @example\n   * Application.onceBooted(({ environment }) => {\n   *   log.info(\"app\", \"booted\", `ready in ${environment}`);\n   * });\n   */\n  public static onceBooted(listener: BootListener): void {\n    if (this.booted && this.bootContext) {\n      const context = this.bootContext;\n      void this.runBootListener(listener, context);\n\n      return;\n    }\n\n    this.bootListeners.push(listener);\n  }\n\n  /**\n   * Promise form of {@link onceBooted} — resolves with the boot context once\n   * the application is booted, or immediately if it already is.\n   */\n  public static whenBooted(): Promise<BootContext> {\n    if (this.booted && this.bootContext) {\n      return Promise.resolve(this.bootContext);\n    }\n\n    return new Promise<BootContext>((resolve) => {\n      this.onceBooted((context) => resolve(context));\n    });\n  }\n\n  /**\n   * Flip the boot latch and drain every queued listener. The dev server and\n   * the production entry call this once, right after the late phase starts. It\n   * is idempotent — a second call is a no-op, so a double-invoke can never\n   * double-fire listeners.\n   *\n   * Also reports readiness to a supervising parent process — this is the one\n   * moment in the lifecycle where \"the application is serving\" is true, so it\n   * is the only honest source for `warlock start`'s success banner. Sent before\n   * the listeners run: a slow or hanging `onceBooted` listener must not delay\n   * the parent's view of a server that is already accepting requests.\n   *\n   * @internal Framework entry points call this; application code must not.\n   */\n  public static markBooted(context: BootContext): void {\n    if (this.booted) {\n      return;\n    }\n\n    this.booted = true;\n    this.bootContext = context;\n\n    sendBootSignal({\n      type: \"warlock:ready\",\n      version: BOOT_SIGNAL_VERSION,\n      pid: process.pid,\n      at: new Date().toISOString(),\n      environment: context.environment,\n      runtimeStrategy: context.runtimeStrategy,\n      bootDurationMs: context.bootDurationMs,\n      port: this.servedPort,\n      roles: [...this.roles],\n    });\n\n    const listeners = this.bootListeners;\n    this.bootListeners = [];\n\n    for (const listener of listeners) {\n      void this.runBootListener(listener, context);\n    }\n  }\n\n  /**\n   * Invoke a single boot listener, isolating its failure so neither boot nor\n   * the remaining listeners are affected.\n   */\n  private static async runBootListener(\n    listener: BootListener,\n    context: BootContext,\n  ): Promise<void> {\n    try {\n      await listener(context);\n    } catch (error) {\n      log.error(\"application\", \"booted-listener\", error as Error);\n    }\n  }\n\n  /**\n   * Register a startup validator — distinct from {@link onceBooted}. A\n   * rejecting validator aborts boot instead of being caught and logged, so\n   * this is where configuration that must fail closed belongs (a signing\n   * secret, a required integration key), not `onceBooted`.\n   *\n   * Must be registered before the framework calls `runStartupValidators` —\n   * typically at module scope in `src/app/main.ts`, the same place a\n   * `BootListener` would be registered. Registering one after validation has\n   * already run throws: by then a rejection could no longer stop the app\n   * from serving, so running it late would silently defeat the guarantee\n   * this hook exists to give.\n   *\n   * @example\n   * Application.onValidateBoot(() => {\n   *   if (!env(\"JWT_SECRET\")) {\n   *     throw new Error(\n   *       \"JWT_SECRET is not set. Sessions cannot be signed without it. \" +\n   *         \"Generate one with `yarn jwt` and put it in .env.\",\n   *     );\n   *   }\n   * });\n   */\n  public static onValidateBoot(validator: BootValidator): void {\n    if (this.validated) {\n      throw new Error(\n        \"Application.onValidateBoot(): startup validators already ran — \" +\n          \"this validator was registered too late to block boot. Register it \" +\n          \"before the framework calls Application.runStartupValidators(), \" +\n          \"typically at module scope in `src/app/main.ts`.\",\n      );\n    }\n\n    this.bootValidators.push(validator);\n  }\n\n  /**\n   * Run every registered startup validator, in registration order, and abort\n   * on the first rejection. Idempotent — a second call is a no-op.\n   *\n   * Distinct from `runBootListener`: a listener's failure is isolated so it\n   * can never break boot; a validator's failure IS the boot failing — that is\n   * the entire point of registering one instead of the other. The thrown\n   * error names the failing validator and the original cause, so whatever\n   * catches it (the dev server's boot try/catch, the production entry's\n   * top-level await) reports which check failed and why, not a bare\n   * rejection.\n   *\n   * @internal Framework entry points call this once app code (main.ts et al)\n   * has loaded and BEFORE late-phase connectors (http, socket) start, so a\n   * failing validator runs before anything can bind a port or accept a\n   * request. Application code must not call this directly.\n   */\n  public static async runStartupValidators(): Promise<void> {\n    if (this.validated) {\n      return;\n    }\n\n    this.validated = true;\n\n    const validators = this.bootValidators;\n    this.bootValidators = [];\n\n    for (const validator of validators) {\n      try {\n        await validator();\n      } catch (error) {\n        const name = validator.name || \"<anonymous>\";\n        const cause = error instanceof Error ? error.message : String(error);\n\n        throw new ErrorWithCause(\n          `Startup validator \"${name}\" rejected boot: ${cause}. ` +\n            `Fix the condition it checks, or remove the validator if it no ` +\n            `longer applies — boot cannot proceed while it fails.`,\n          { cause: error },\n        );\n      }\n    }\n  }\n\n  /**\n   * Whether the application has begun shutting down. Once true, readiness\n   * checks report not-ready so a load balancer drains this instance before the\n   * HTTP server stops accepting requests.\n   */\n  public static get isShuttingDown(): boolean {\n    return this.shuttingDown;\n  }\n\n  /**\n   * Register a teardown callback, run once when the application shuts down —\n   * before the connectors (db, cache, http) are torn down, so it can still use\n   * them. The natural place to close an app-owned resource opened in\n   * `onceBooted`. If shutdown has already begun, the callback runs immediately.\n   *\n   * @example\n   * Application.onShutdown(async () => {\n   *   await myQueueConsumer.stop();\n   * });\n   */\n  public static onShutdown(listener: ShutdownListener): void {\n    if (this.shuttingDown) {\n      void this.runShutdownListener(listener);\n\n      return;\n    }\n\n    this.shutdownListeners.push(listener);\n  }\n\n  /**\n   * Flip the shutdown latch and run every teardown callback. The connectors\n   * manager calls this at the start of shutdown — before any connector is torn\n   * down. Idempotent and error-isolated: each callback is awaited, a thrown one\n   * is logged and does not stop the rest. Listeners run LIFO (reverse of\n   * registration), mirroring resource-unwind order.\n   *\n   * @internal Framework entry points call this; application code must not.\n   */\n  public static async runShutdownHooks(): Promise<void> {\n    if (this.shuttingDown) {\n      return;\n    }\n\n    this.shuttingDown = true;\n\n    const listeners = this.shutdownListeners.reverse();\n    this.shutdownListeners = [];\n\n    for (const listener of listeners) {\n      await this.runShutdownListener(listener);\n    }\n  }\n\n  /**\n   * Invoke a single teardown callback, isolating its failure so the rest still\n   * run and shutdown is never blocked by one bad hook.\n   */\n  private static async runShutdownListener(listener: ShutdownListener): Promise<void> {\n    try {\n      await listener();\n    } catch (error) {\n      log.error(\"application\", \"shutdown-listener\", error as Error);\n    }\n  }\n\n  /**\n   * Get project uptime in milliseconds\n   */\n  public static get uptime(): number {\n    return process.uptime() * 1000;\n  }\n\n  /**\n   * Get the current environment\n   */\n  public static get environment(): Environment {\n    return environment();\n  }\n\n  /**\n   * Set the current environment\n   */\n  public static setEnvironment(env: Environment) {\n    setEnvironment(env);\n  }\n\n  /**\n   * Check if the application is running in production environment\n   */\n  public static get isProduction(): boolean {\n    return this.environment === \"production\";\n  }\n\n  /**\n   * Check if the application is running in development environment\n   */\n  public static get isDevelopment(): boolean {\n    return this.environment === \"development\";\n  }\n\n  /**\n   * Check if the application is running in test environment\n   */\n  public static get isTest(): boolean {\n    return this.environment === \"test\";\n  }\n\n  /**\n   * The roles this process serves — `WARLOCK_ROLES`, resolved once at\n   * bootstrap. Every role is on when the variable is absent (plain `warlock\n   * start`, `warlock dev`, and tests).\n   */\n  public static get roles(): ReadonlySet<AppRole> {\n    return getRoles();\n  }\n\n  /**\n   * The site keys this process installs pages for — `WARLOCK_SITES`,\n   * resolved once at bootstrap. `undefined` means every site.\n   */\n  public static get sites(): ReadonlySet<string> | undefined {\n    return getSites();\n  }\n\n  /**\n   * Whether this process serves the given role.\n   *\n   * @example\n   * if (Application.hasRole(\"worker\")) {\n   *   scheduler.start();\n   * }\n   */\n  public static hasRole(role: AppRole): boolean {\n    return hasRole(role);\n  }\n\n  /**\n   * Get the root path\n   */\n  public static get rootPath(): string {\n    return rootPath();\n  }\n\n  /**\n   * Get the src path\n   */\n  public static get srcPath(): string {\n    return srcPath();\n  }\n\n  /**\n   * Get the app path\n   */\n  public static get appPath(): string {\n    return appPath();\n  }\n\n  /**\n   * Get the storage path\n   */\n  public static get storagePath(): string {\n    return storagePath();\n  }\n\n  /**\n   * Get the uploads path\n   */\n  public static get uploadsPath(): string {\n    return uploadsPath();\n  }\n\n  /**\n   * Get the public path\n   */\n  public static get publicPath(): string {\n    return publicPath();\n  }\n}\n"],"mappings":"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"}

package/esm/application/boot-signal.d.mts

@@ -1,6 +1,6 @@
 import { Environment, RuntimeStrategy } from "../utils/environment.mjs";
 
-//#region ../core/src/application/boot-signal.d.ts
+//#region ../../packages/core/src/application/boot-signal.d.ts
 /**
  * The only message type the boot channel carries today. Named rather than
  * inlined because both the sender (`sendBootSignal`) and the receiver

package/esm/application/boot-signal.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"boot-signal.d.mts","names":[],"sources":["../../../../../../../core/src/application/boot-signal.ts"],"mappings":";;;;;AAOA;;;KAAY,cAAA;AAAc;AAS1B;;;;AAAgC;AAUhC;AAnB0B,cASb,mBAAA;;;;;;;;;KAUD,UAAA;EACV,IAAA,EAAM,cAAA;EACN,OAAA,UAKA;EAHA,GAAA,UAIA;EAFA,EAAA;EACA,WAAA,EAAa,WAAA;EACb,eAAA,EAAiB,eAAA;EACjB,cAAA,WAIK;EAFL,IAAA,WAcW;EAZX,KAAA;AAAA;;AAY8B;AAoBhC;;;;AAAiD;AA4BjD;;cAhDa,mBAAA;;;;;;AAgDwD;;;;;;;;;;;;;iBA5BrD,cAAA,CAAe,MAAkB,EAAV,UAAU;;;;;;;;;;iBA4BjC,YAAA,CAAa,OAAA,YAAmB,OAAA,IAAW,UAAU"}
+{"version":3,"file":"boot-signal.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/application/boot-signal.ts"],"mappings":";;;;;AAOA;;;KAAY,cAAA;AAAc;AAS1B;;;;AAAgC;AAUhC;AAnB0B,cASb,mBAAA;;;;;;;;;KAUD,UAAA;EACV,IAAA,EAAM,cAAA;EACN,OAAA,UAKA;EAHA,GAAA,UAIA;EAFA,EAAA;EACA,WAAA,EAAa,WAAA;EACb,eAAA,EAAiB,eAAA;EACjB,cAAA,WAIK;EAFL,IAAA,WAcW;EAZX,KAAA;AAAA;;AAY8B;AAoBhC;;;;AAAiD;AA4BjD;;cAhDa,mBAAA;;;;;;AAgDwD;;;;;;;;;;;;;iBA5BrD,cAAA,CAAe,MAAkB,EAAV,UAAU;;;;;;;;;;iBA4BjC,YAAA,CAAa,OAAA,YAAmB,OAAA,IAAW,UAAU"}

package/esm/application/boot-signal.mjs

@@ -1,4 +1,4 @@
-//#region ../core/src/application/boot-signal.ts
+//#region ../../packages/core/src/application/boot-signal.ts
 /**
 * Schema version of {@link BootSignal}.
 *

package/esm/application/boot-signal.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"boot-signal.mjs","names":[],"sources":["../../../../../../../core/src/application/boot-signal.ts"],"sourcesContent":["import type { Environment, RuntimeStrategy } from \"../utils/environment\";\n\n/**\n * The only message type the boot channel carries today. Named rather than\n * inlined because both the sender (`sendBootSignal`) and the receiver\n * (`warlock start`) must agree on the exact literal.\n */\nexport type BootSignalType = \"warlock:ready\";\n\n/**\n * Schema version of {@link BootSignal}.\n *\n * Present from the first release on purpose: a version field cannot be added to\n * a shipped wire format without a flag day, and this one has to be able to\n * evolve while older CLIs are still supervising newer bundles.\n */\nexport const BOOT_SIGNAL_VERSION = 1;\n\n/**\n * What a booted child process tells its supervising parent over the IPC\n * channel `warlock start` opens for it.\n *\n * This is a wire contract, not an internal detail: `warlock start` prints its\n * success banner **only** when this arrives, so anything watching that banner\n * (a CI gate, a process supervisor) transitively depends on it.\n */\nexport type BootSignal = {\n  type: BootSignalType;\n  version: number;\n  /** The application process, so a supervisor can address it directly. */\n  pid: number;\n  /** When the boot completed, ISO-8601. */\n  at: string;\n  environment: Environment;\n  runtimeStrategy: RuntimeStrategy;\n  bootDurationMs?: number;\n  /** The bound http port, absent for an app with no http connector. */\n  port?: number;\n  /** The roles this process serves — see `Application.roles`. */\n  roles: string[];\n};\n\n/**\n * Environment flag `warlock start` sets on the process it supervises.\n *\n * An IPC channel alone is NOT proof that the parent speaks this protocol —\n * pm2, a vitest worker fork, and any custom supervisor all hand their child a\n * channel they use for their own messages. Writing to one of those, and then\n * closing it, corrupts someone else's protocol and can kill the process. The\n * flag is the handshake: only a parent that set it gets signalled.\n */\nexport const BOOT_SIGNAL_ENV_KEY = \"WARLOCK_BOOT_SIGNAL\";\n\n/**\n * Report a completed boot to the parent process, if one is supervising.\n *\n * Two conditions must both hold: the process was spawned with an `ipc` stdio\n * channel (`process.send` exists), and the parent identified itself with\n * {@link BOOT_SIGNAL_ENV_KEY}. A bundle run directly (`node app.mjs`, a Docker\n * `CMD`) or under a foreign supervisor is a no-op, so the signal never changes\n * how a standalone process behaves and never touches a channel we don't own.\n *\n * The channel is closed as soon as the message is flushed. An open IPC channel\n * holds a `ref` on the child's event loop, which would keep a finished or\n * wedged process alive and indistinguishable from a healthy server — the exact\n * confusion this signal exists to remove. One message, then disconnect.\n *\n * Failure to send is deliberately swallowed: the parent may have already\n * detached or died, and a supervisor going away must never take down a\n * healthy application.\n */\nexport function sendBootSignal(signal: BootSignal): void {\n  if (typeof process.send !== \"function\" || process.env[BOOT_SIGNAL_ENV_KEY] !== \"1\") {\n    return;\n  }\n\n  // Consumed here so it cannot be inherited by anything this app itself spawns\n  // and make a grandchild report readiness on a channel meant for someone else.\n  delete process.env[BOOT_SIGNAL_ENV_KEY];\n\n  try {\n    process.send(signal, undefined, undefined, () => {\n      process.disconnect?.();\n    });\n  } catch {\n    // The channel closed between the check and the write — the app is up\n    // regardless, and there is no longer anyone to tell.\n  }\n}\n\n/**\n * Narrow an arbitrary IPC payload to a {@link BootSignal}.\n *\n * The parent receives whatever the child chooses to send, so the message is\n * untrusted input and is validated before it is allowed to flip the parent's\n * \"the server is up\" state. A *newer* version than this CLI knows is still\n * accepted — readiness is readiness, and refusing it would make an old\n * supervisor report a healthy app as failed.\n */\nexport function isBootSignal(message: unknown): message is BootSignal {\n  if (typeof message !== \"object\" || message === null) {\n    return false;\n  }\n\n  const candidate = message as { type?: unknown; version?: unknown };\n\n  return candidate.type === \"warlock:ready\" && typeof candidate.version === \"number\";\n}\n"],"mappings":";;;;;;;;AAgBA,MAAa,sBAAsB;;;;;;;;;;AAmCnC,MAAa,sBAAsB;;;;;;;;;;;;;;;;;;;AAoBnC,SAAgB,eAAe,QAA0B;CACvD,IAAI,OAAO,QAAQ,SAAS,cAAc,QAAQ,+BAA6B,KAC7E;CAKF,OAAO,QAAQ,IAAI;CAEnB,IAAI;EACF,QAAQ,KAAK,QAAQ,QAAW,cAAiB;GAC/C,QAAQ,aAAa;EACvB,CAAC;CACH,QAAQ,CAGR;AACF;;;;;;;;;;AAWA,SAAgB,aAAa,SAAyC;CACpE,IAAI,OAAO,YAAY,YAAY,YAAY,MAC7C,OAAO;CAGT,MAAM,YAAY;CAElB,OAAO,UAAU,SAAS,mBAAmB,OAAO,UAAU,YAAY;AAC5E"}
+{"version":3,"file":"boot-signal.mjs","names":[],"sources":["../../../../../../../../packages/core/src/application/boot-signal.ts"],"sourcesContent":["import type { Environment, RuntimeStrategy } from \"../utils/environment\";\n\n/**\n * The only message type the boot channel carries today. Named rather than\n * inlined because both the sender (`sendBootSignal`) and the receiver\n * (`warlock start`) must agree on the exact literal.\n */\nexport type BootSignalType = \"warlock:ready\";\n\n/**\n * Schema version of {@link BootSignal}.\n *\n * Present from the first release on purpose: a version field cannot be added to\n * a shipped wire format without a flag day, and this one has to be able to\n * evolve while older CLIs are still supervising newer bundles.\n */\nexport const BOOT_SIGNAL_VERSION = 1;\n\n/**\n * What a booted child process tells its supervising parent over the IPC\n * channel `warlock start` opens for it.\n *\n * This is a wire contract, not an internal detail: `warlock start` prints its\n * success banner **only** when this arrives, so anything watching that banner\n * (a CI gate, a process supervisor) transitively depends on it.\n */\nexport type BootSignal = {\n  type: BootSignalType;\n  version: number;\n  /** The application process, so a supervisor can address it directly. */\n  pid: number;\n  /** When the boot completed, ISO-8601. */\n  at: string;\n  environment: Environment;\n  runtimeStrategy: RuntimeStrategy;\n  bootDurationMs?: number;\n  /** The bound http port, absent for an app with no http connector. */\n  port?: number;\n  /** The roles this process serves — see `Application.roles`. */\n  roles: string[];\n};\n\n/**\n * Environment flag `warlock start` sets on the process it supervises.\n *\n * An IPC channel alone is NOT proof that the parent speaks this protocol —\n * pm2, a vitest worker fork, and any custom supervisor all hand their child a\n * channel they use for their own messages. Writing to one of those, and then\n * closing it, corrupts someone else's protocol and can kill the process. The\n * flag is the handshake: only a parent that set it gets signalled.\n */\nexport const BOOT_SIGNAL_ENV_KEY = \"WARLOCK_BOOT_SIGNAL\";\n\n/**\n * Report a completed boot to the parent process, if one is supervising.\n *\n * Two conditions must both hold: the process was spawned with an `ipc` stdio\n * channel (`process.send` exists), and the parent identified itself with\n * {@link BOOT_SIGNAL_ENV_KEY}. A bundle run directly (`node app.mjs`, a Docker\n * `CMD`) or under a foreign supervisor is a no-op, so the signal never changes\n * how a standalone process behaves and never touches a channel we don't own.\n *\n * The channel is closed as soon as the message is flushed. An open IPC channel\n * holds a `ref` on the child's event loop, which would keep a finished or\n * wedged process alive and indistinguishable from a healthy server — the exact\n * confusion this signal exists to remove. One message, then disconnect.\n *\n * Failure to send is deliberately swallowed: the parent may have already\n * detached or died, and a supervisor going away must never take down a\n * healthy application.\n */\nexport function sendBootSignal(signal: BootSignal): void {\n  if (typeof process.send !== \"function\" || process.env[BOOT_SIGNAL_ENV_KEY] !== \"1\") {\n    return;\n  }\n\n  // Consumed here so it cannot be inherited by anything this app itself spawns\n  // and make a grandchild report readiness on a channel meant for someone else.\n  delete process.env[BOOT_SIGNAL_ENV_KEY];\n\n  try {\n    process.send(signal, undefined, undefined, () => {\n      process.disconnect?.();\n    });\n  } catch {\n    // The channel closed between the check and the write — the app is up\n    // regardless, and there is no longer anyone to tell.\n  }\n}\n\n/**\n * Narrow an arbitrary IPC payload to a {@link BootSignal}.\n *\n * The parent receives whatever the child chooses to send, so the message is\n * untrusted input and is validated before it is allowed to flip the parent's\n * \"the server is up\" state. A *newer* version than this CLI knows is still\n * accepted — readiness is readiness, and refusing it would make an old\n * supervisor report a healthy app as failed.\n */\nexport function isBootSignal(message: unknown): message is BootSignal {\n  if (typeof message !== \"object\" || message === null) {\n    return false;\n  }\n\n  const candidate = message as { type?: unknown; version?: unknown };\n\n  return candidate.type === \"warlock:ready\" && typeof candidate.version === \"number\";\n}\n"],"mappings":";;;;;;;;AAgBA,MAAa,sBAAsB;;;;;;;;;;AAmCnC,MAAa,sBAAsB;;;;;;;;;;;;;;;;;;;AAoBnC,SAAgB,eAAe,QAA0B;CACvD,IAAI,OAAO,QAAQ,SAAS,cAAc,QAAQ,+BAA6B,KAC7E;CAKF,OAAO,QAAQ,IAAI;CAEnB,IAAI;EACF,QAAQ,KAAK,QAAQ,QAAW,cAAiB;GAC/C,QAAQ,aAAa;EACvB,CAAC;CACH,QAAQ,CAGR;AACF;;;;;;;;;;AAWA,SAAgB,aAAa,SAAyC;CACpE,IAAI,OAAO,YAAY,YAAY,YAAY,MAC7C,OAAO;CAGT,MAAM,YAAY;CAElB,OAAO,UAAU,SAAS,mBAAmB,OAAO,UAAU,YAAY;AAC5E"}

package/esm/application/public-url.d.mts

@@ -1,4 +1,4 @@
-//#region ../core/src/application/public-url.d.ts
+//#region ../../packages/core/src/application/public-url.d.ts
 /**
  * The application's public origin — the ONE absolute-URL source every
  * consumer that needs one (the sitemap route, canonical links, OG tags,

package/esm/application/public-url.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"public-url.d.mts","names":[],"sources":["../../../../../../../core/src/application/public-url.ts"],"mappings":";;AAiBA;;;;AAA4B;;;;;;;;;;iBAAZ,YAAA"}
+{"version":3,"file":"public-url.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/application/public-url.ts"],"mappings":";;AAiBA;;;;AAA4B;;;;;;;;;;iBAAZ,YAAA"}

package/esm/application/public-url.mjs

@@ -1,7 +1,7 @@
 import { config } from "../config/config-getter.mjs";
 import "../config/index.mjs";
 
-//#region ../core/src/application/public-url.ts
+//#region ../../packages/core/src/application/public-url.ts
 /**
 * The application's public origin — the ONE absolute-URL source every
 * consumer that needs one (the sitemap route, canonical links, OG tags,

package/esm/application/public-url.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"public-url.mjs","names":[],"sources":["../../../../../../../core/src/application/public-url.ts"],"sourcesContent":["import { config } from \"../config\";\n\n/**\n * The application's public origin — the ONE absolute-URL source every\n * consumer that needs one (the sitemap route, canonical links, OG tags,\n * absolute URLs in mail) reads instead of each keeping its own copy.\n *\n * `app.publicUrl` wins over the `PUBLIC_APP_URL` env fallback. Deliberately\n * does not fall back further to a request-derived origin: a sitemap (or any\n * other absolute URL) served from the wrong host is worse than a boot that\n * refuses to start, because nothing downstream ever tells you it was wrong.\n *\n * Optional in general — most apps have no consumer that needs it yet.\n * Returns `undefined` rather than throwing; a consumer that requires the\n * value (e.g. the sitemap route, at boot) is responsible for failing loudly\n * itself, naming both `app.publicUrl` and `PUBLIC_APP_URL`.\n */\nexport function getPublicUrl(): string | undefined {\n  return config.key<string | undefined>(\"app.publicUrl\") || process.env.PUBLIC_APP_URL || undefined;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAiBA,SAAgB,eAAmC;CACjD,OAAO,OAAO,IAAwB,eAAe,KAAK,QAAQ,IAAI,kBAAkB;AAC1F"}
+{"version":3,"file":"public-url.mjs","names":[],"sources":["../../../../../../../../packages/core/src/application/public-url.ts"],"sourcesContent":["import { config } from \"../config\";\n\n/**\n * The application's public origin — the ONE absolute-URL source every\n * consumer that needs one (the sitemap route, canonical links, OG tags,\n * absolute URLs in mail) reads instead of each keeping its own copy.\n *\n * `app.publicUrl` wins over the `PUBLIC_APP_URL` env fallback. Deliberately\n * does not fall back further to a request-derived origin: a sitemap (or any\n * other absolute URL) served from the wrong host is worse than a boot that\n * refuses to start, because nothing downstream ever tells you it was wrong.\n *\n * Optional in general — most apps have no consumer that needs it yet.\n * Returns `undefined` rather than throwing; a consumer that requires the\n * value (e.g. the sitemap route, at boot) is responsible for failing loudly\n * itself, naming both `app.publicUrl` and `PUBLIC_APP_URL`.\n */\nexport function getPublicUrl(): string | undefined {\n  return config.key<string | undefined>(\"app.publicUrl\") || process.env.PUBLIC_APP_URL || undefined;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAiBA,SAAgB,eAAmC;CACjD,OAAO,OAAO,IAAwB,eAAe,KAAK,QAAQ,IAAI,kBAAkB;AAC1F"}

package/esm/application/roles.d.mts

@@ -1,4 +1,4 @@
-//#region ../core/src/application/roles.d.ts
+//#region ../../packages/core/src/application/roles.d.ts
 /**
  * The three ways a process booted from the same build can serve traffic.
  * `api` and `web` both bind the http port (§`servesHttp`); `worker` never

package/esm/application/roles.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"roles.d.mts","names":[],"sources":["../../../../../../../core/src/application/roles.ts"],"mappings":";;AAKA;;;;cAAa,SAAA;AAMb;;;;AAAA,KAAY,OAAA,WAAkB,SAAS;AAcvC;;;;;;;;AAA0E;AAiC1E;AAjCA,iBAAgB,UAAA,CAAW,KAAA,uBAA4B,WAAW,CAAC,OAAA;;;AAiCD;AAuBlE;;;;;;;iBAvBgB,UAAA,CAAW,KAAA,uBAA4B,WAAW;;;;;;;iBAuBlD,yBAAA,CACd,KAAA,EAAO,WAAA,CAAY,OAAA,GACnB,KAAA,EAAO,WAAA;AA0CT;;;AAAA,iBAAgB,QAAA,IAAY,WAAW,CAAC,OAAA;AAAO;AAQ/C;;;AAR+C,iBAQ/B,QAAA,IAAY,WAAW;AAAA;AAOvC;;AAPuC,iBAOvB,OAAA,CAAQ,IAAa,EAAP,OAAO;;AAAA;AAUrC;;;;iBAAgB,UAAA;AAahB;;;;AAAuC;;;AAAvC,iBAAgB,uBAAA"}
+{"version":3,"file":"roles.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/application/roles.ts"],"mappings":";;AAKA;;;;cAAa,SAAA;AAMb;;;;AAAA,KAAY,OAAA,WAAkB,SAAS;AAcvC;;;;;;;;AAA0E;AAiC1E;AAjCA,iBAAgB,UAAA,CAAW,KAAA,uBAA4B,WAAW,CAAC,OAAA;;;AAiCD;AAuBlE;;;;;;;iBAvBgB,UAAA,CAAW,KAAA,uBAA4B,WAAW;;;;;;;iBAuBlD,yBAAA,CACd,KAAA,EAAO,WAAA,CAAY,OAAA,GACnB,KAAA,EAAO,WAAA;AA0CT;;;AAAA,iBAAgB,QAAA,IAAY,WAAW,CAAC,OAAA;AAAO;AAQ/C;;;AAR+C,iBAQ/B,QAAA,IAAY,WAAW;AAAA;AAOvC;;AAPuC,iBAOvB,OAAA,CAAQ,IAAa,EAAP,OAAO;;AAAA;AAUrC;;;;iBAAgB,UAAA;AAahB;;;;AAAuC;;;AAAvC,iBAAgB,uBAAA"}

package/esm/application/roles.mjs

@@ -1,4 +1,4 @@
-//#region ../core/src/application/roles.ts
+//#region ../../packages/core/src/application/roles.ts
 /**
 * The three ways a process booted from the same build can serve traffic.
 * `api` and `web` both bind the http port (§`servesHttp`); `worker` never

package/esm/application/roles.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"roles.mjs","names":[],"sources":["../../../../../../../core/src/application/roles.ts"],"sourcesContent":["/**\n * The three ways a process booted from the same build can serve traffic.\n * `api` and `web` both bind the http port (§`servesHttp`); `worker` never\n * does — it exists to run queue workers, the scheduler and `worker.ts`.\n */\nexport const APP_ROLES = [\"api\", \"web\", \"worker\"] as const;\n\n/**\n * One of {@link APP_ROLES}. What `Application.hasRole` checks and what\n * `warlock start --role` accepts, comma-separated.\n */\nexport type AppRole = (typeof APP_ROLES)[number];\n\nconst VALID_ROLES_LIST = APP_ROLES.join(\", \");\n\n/**\n * Parse a `--role` / `WARLOCK_ROLES` value into the set of roles a process\n * should serve.\n *\n * `undefined` (the flag/variable absent) means \"every role\" — the same\n * behaviour `warlock start` and `warlock dev` had before roles existed, so a\n * plain `start` or a test run is unaffected. An explicit but empty list, or\n * an entry that is not one of {@link APP_ROLES}, throws rather than silently\n * falling back to \"every role\", since that would mask a typo as full traffic.\n */\nexport function parseRoles(value: string | undefined): ReadonlySet<AppRole> {\n  if (value === undefined) {\n    return new Set(APP_ROLES);\n  }\n\n  const entries = value\n    .split(\",\")\n    .map((entry) => entry.trim().toLowerCase())\n    .filter((entry) => entry.length > 0);\n\n  if (entries.length === 0) {\n    throw new Error(`--role received an empty list. Valid roles: ${VALID_ROLES_LIST}.`);\n  }\n\n  for (const entry of entries) {\n    if (!(APP_ROLES as readonly string[]).includes(entry)) {\n      throw new Error(`Unknown role \"${entry}\". Valid roles: ${VALID_ROLES_LIST}.`);\n    }\n  }\n\n  return new Set(entries as AppRole[]);\n}\n\n/**\n * Parse a `--sites` / `WARLOCK_SITES` value into the set of site keys a\n * `web` process should install pages for.\n *\n * `undefined` means \"every site\" (the default, unfiltered behaviour). An\n * explicit but empty list throws rather than silently meaning \"every site\"\n * or \"no site\" — both would be surprising for a flag that was actually\n * passed. Cross-checking against the active roles and against `web.sites`\n * config happens where both are known, not here.\n */\nexport function parseSites(value: string | undefined): ReadonlySet<string> | undefined {\n  if (value === undefined) {\n    return undefined;\n  }\n\n  const entries = value\n    .split(\",\")\n    .map((entry) => entry.trim())\n    .filter((entry) => entry.length > 0);\n\n  if (entries.length === 0) {\n    throw new Error(\"--sites received an empty list.\");\n  }\n\n  return new Set(entries);\n}\n\n/**\n * `--sites` only makes sense alongside the `web` role — an `api`- or\n * `worker`-only process never installs pages, so a sites filter on it could\n * never do anything, and staying silent about that would hide a\n * misconfigured deploy.\n */\nexport function assertSitesRequireWebRole(\n  roles: ReadonlySet<AppRole>,\n  sites: ReadonlySet<string> | undefined,\n): void {\n  if (sites !== undefined && !roles.has(\"web\")) {\n    throw new Error(\"--sites only applies to the web role\");\n  }\n}\n\nlet cachedRoles: ReadonlySet<AppRole> | undefined;\nlet cachedSites: ReadonlySet<string> | undefined;\nlet sitesResolved = false;\n\n/**\n * The roles this process serves, resolved from `WARLOCK_ROLES` once and\n * cached for the life of the process — the env var is bootstrap input, not\n * something that can meaningfully change mid-run.\n */\nfunction resolveRoles(): ReadonlySet<AppRole> {\n  if (!cachedRoles) {\n    cachedRoles = parseRoles(process.env.WARLOCK_ROLES);\n  }\n\n  return cachedRoles;\n}\n\n/**\n * The sites this process installs pages for, resolved from `WARLOCK_SITES`\n * once and cached alongside {@link resolveRoles}. `undefined` means every\n * site.\n */\nfunction resolveSites(): ReadonlySet<string> | undefined {\n  if (!sitesResolved) {\n    cachedSites = parseSites(process.env.WARLOCK_SITES);\n    assertSitesRequireWebRole(resolveRoles(), cachedSites);\n    sitesResolved = true;\n  }\n\n  return cachedSites;\n}\n\n/**\n * The roles this process serves. See {@link resolveRoles}.\n */\nexport function getRoles(): ReadonlySet<AppRole> {\n  return resolveRoles();\n}\n\n/**\n * The sites this process installs pages for, or `undefined` for every site.\n * See {@link resolveSites}.\n */\nexport function getSites(): ReadonlySet<string> | undefined {\n  return resolveSites();\n}\n\n/**\n * Whether this process serves the given role.\n */\nexport function hasRole(role: AppRole): boolean {\n  return resolveRoles().has(role);\n}\n\n/**\n * Whether this process should bind the http port — true when it serves\n * `api` or `web`, false for a `worker`-only process. Shared by the http\n * connector (skips `listen()`) and the production port preflight (skips the\n * probe), so both agree on the same condition.\n */\nexport function servesHttp(): boolean {\n  const roles = resolveRoles();\n\n  return roles.has(\"api\") || roles.has(\"web\");\n}\n\n/**\n * Drop the cached roles/sites so the next call to {@link getRoles} /\n * {@link getSites} re-reads `process.env`.\n *\n * @internal Test-only — production code resolves once per process on\n * purpose (see {@link resolveRoles}).\n */\nexport function resetRolesCacheForTests(): void {\n  cachedRoles = undefined;\n  cachedSites = undefined;\n  sitesResolved = false;\n}\n"],"mappings":";;;;;;AAKA,MAAa,YAAY;CAAC;CAAO;CAAO;AAAQ;AAQhD,MAAM,mBAAmB,UAAU,KAAK,IAAI;;;;;;;;;;;AAY5C,SAAgB,WAAW,OAAiD;CAC1E,IAAI,UAAU,QACZ,OAAO,IAAI,IAAI,SAAS;CAG1B,MAAM,UAAU,MACb,MAAM,GAAG,CAAC,CACV,KAAK,UAAU,MAAM,KAAK,CAAC,CAAC,YAAY,CAAC,CAAC,CAC1C,QAAQ,UAAU,MAAM,SAAS,CAAC;CAErC,IAAI,QAAQ,WAAW,GACrB,MAAM,IAAI,MAAM,+CAA+C,iBAAiB,EAAE;CAGpF,KAAK,MAAM,SAAS,SAClB,IAAI,CAAE,UAAgC,SAAS,KAAK,GAClD,MAAM,IAAI,MAAM,iBAAiB,MAAM,kBAAkB,iBAAiB,EAAE;CAIhF,OAAO,IAAI,IAAI,OAAoB;AACrC;;;;;;;;;;;AAYA,SAAgB,WAAW,OAA4D;CACrF,IAAI,UAAU,QACZ;CAGF,MAAM,UAAU,MACb,MAAM,GAAG,CAAC,CACV,KAAK,UAAU,MAAM,KAAK,CAAC,CAAC,CAC5B,QAAQ,UAAU,MAAM,SAAS,CAAC;CAErC,IAAI,QAAQ,WAAW,GACrB,MAAM,IAAI,MAAM,iCAAiC;CAGnD,OAAO,IAAI,IAAI,OAAO;AACxB;;;;;;;AAQA,SAAgB,0BACd,OACA,OACM;CACN,IAAI,UAAU,UAAa,CAAC,MAAM,IAAI,KAAK,GACzC,MAAM,IAAI,MAAM,sCAAsC;AAE1D;AAEA,IAAI;AACJ,IAAI;AACJ,IAAI,gBAAgB;;;;;;AAOpB,SAAS,eAAqC;CAC5C,IAAI,CAAC,aACH,cAAc,WAAW,QAAQ,IAAI,aAAa;CAGpD,OAAO;AACT;;;;;;AAOA,SAAS,eAAgD;CACvD,IAAI,CAAC,eAAe;EAClB,cAAc,WAAW,QAAQ,IAAI,aAAa;EAClD,0BAA0B,aAAa,GAAG,WAAW;EACrD,gBAAgB;CAClB;CAEA,OAAO;AACT;;;;AAKA,SAAgB,WAAiC;CAC/C,OAAO,aAAa;AACtB;;;;;AAMA,SAAgB,WAA4C;CAC1D,OAAO,aAAa;AACtB;;;;AAKA,SAAgB,QAAQ,MAAwB;CAC9C,OAAO,aAAa,CAAC,CAAC,IAAI,IAAI;AAChC;;;;;;;AAQA,SAAgB,aAAsB;CACpC,MAAM,QAAQ,aAAa;CAE3B,OAAO,MAAM,IAAI,KAAK,KAAK,MAAM,IAAI,KAAK;AAC5C;;;;;;;;AASA,SAAgB,0BAAgC;CAC9C,cAAc;CACd,cAAc;CACd,gBAAgB;AAClB"}
+{"version":3,"file":"roles.mjs","names":[],"sources":["../../../../../../../../packages/core/src/application/roles.ts"],"sourcesContent":["/**\n * The three ways a process booted from the same build can serve traffic.\n * `api` and `web` both bind the http port (§`servesHttp`); `worker` never\n * does — it exists to run queue workers, the scheduler and `worker.ts`.\n */\nexport const APP_ROLES = [\"api\", \"web\", \"worker\"] as const;\n\n/**\n * One of {@link APP_ROLES}. What `Application.hasRole` checks and what\n * `warlock start --role` accepts, comma-separated.\n */\nexport type AppRole = (typeof APP_ROLES)[number];\n\nconst VALID_ROLES_LIST = APP_ROLES.join(\", \");\n\n/**\n * Parse a `--role` / `WARLOCK_ROLES` value into the set of roles a process\n * should serve.\n *\n * `undefined` (the flag/variable absent) means \"every role\" — the same\n * behaviour `warlock start` and `warlock dev` had before roles existed, so a\n * plain `start` or a test run is unaffected. An explicit but empty list, or\n * an entry that is not one of {@link APP_ROLES}, throws rather than silently\n * falling back to \"every role\", since that would mask a typo as full traffic.\n */\nexport function parseRoles(value: string | undefined): ReadonlySet<AppRole> {\n  if (value === undefined) {\n    return new Set(APP_ROLES);\n  }\n\n  const entries = value\n    .split(\",\")\n    .map((entry) => entry.trim().toLowerCase())\n    .filter((entry) => entry.length > 0);\n\n  if (entries.length === 0) {\n    throw new Error(`--role received an empty list. Valid roles: ${VALID_ROLES_LIST}.`);\n  }\n\n  for (const entry of entries) {\n    if (!(APP_ROLES as readonly string[]).includes(entry)) {\n      throw new Error(`Unknown role \"${entry}\". Valid roles: ${VALID_ROLES_LIST}.`);\n    }\n  }\n\n  return new Set(entries as AppRole[]);\n}\n\n/**\n * Parse a `--sites` / `WARLOCK_SITES` value into the set of site keys a\n * `web` process should install pages for.\n *\n * `undefined` means \"every site\" (the default, unfiltered behaviour). An\n * explicit but empty list throws rather than silently meaning \"every site\"\n * or \"no site\" — both would be surprising for a flag that was actually\n * passed. Cross-checking against the active roles and against `web.sites`\n * config happens where both are known, not here.\n */\nexport function parseSites(value: string | undefined): ReadonlySet<string> | undefined {\n  if (value === undefined) {\n    return undefined;\n  }\n\n  const entries = value\n    .split(\",\")\n    .map((entry) => entry.trim())\n    .filter((entry) => entry.length > 0);\n\n  if (entries.length === 0) {\n    throw new Error(\"--sites received an empty list.\");\n  }\n\n  return new Set(entries);\n}\n\n/**\n * `--sites` only makes sense alongside the `web` role — an `api`- or\n * `worker`-only process never installs pages, so a sites filter on it could\n * never do anything, and staying silent about that would hide a\n * misconfigured deploy.\n */\nexport function assertSitesRequireWebRole(\n  roles: ReadonlySet<AppRole>,\n  sites: ReadonlySet<string> | undefined,\n): void {\n  if (sites !== undefined && !roles.has(\"web\")) {\n    throw new Error(\"--sites only applies to the web role\");\n  }\n}\n\nlet cachedRoles: ReadonlySet<AppRole> | undefined;\nlet cachedSites: ReadonlySet<string> | undefined;\nlet sitesResolved = false;\n\n/**\n * The roles this process serves, resolved from `WARLOCK_ROLES` once and\n * cached for the life of the process — the env var is bootstrap input, not\n * something that can meaningfully change mid-run.\n */\nfunction resolveRoles(): ReadonlySet<AppRole> {\n  if (!cachedRoles) {\n    cachedRoles = parseRoles(process.env.WARLOCK_ROLES);\n  }\n\n  return cachedRoles;\n}\n\n/**\n * The sites this process installs pages for, resolved from `WARLOCK_SITES`\n * once and cached alongside {@link resolveRoles}. `undefined` means every\n * site.\n */\nfunction resolveSites(): ReadonlySet<string> | undefined {\n  if (!sitesResolved) {\n    cachedSites = parseSites(process.env.WARLOCK_SITES);\n    assertSitesRequireWebRole(resolveRoles(), cachedSites);\n    sitesResolved = true;\n  }\n\n  return cachedSites;\n}\n\n/**\n * The roles this process serves. See {@link resolveRoles}.\n */\nexport function getRoles(): ReadonlySet<AppRole> {\n  return resolveRoles();\n}\n\n/**\n * The sites this process installs pages for, or `undefined` for every site.\n * See {@link resolveSites}.\n */\nexport function getSites(): ReadonlySet<string> | undefined {\n  return resolveSites();\n}\n\n/**\n * Whether this process serves the given role.\n */\nexport function hasRole(role: AppRole): boolean {\n  return resolveRoles().has(role);\n}\n\n/**\n * Whether this process should bind the http port — true when it serves\n * `api` or `web`, false for a `worker`-only process. Shared by the http\n * connector (skips `listen()`) and the production port preflight (skips the\n * probe), so both agree on the same condition.\n */\nexport function servesHttp(): boolean {\n  const roles = resolveRoles();\n\n  return roles.has(\"api\") || roles.has(\"web\");\n}\n\n/**\n * Drop the cached roles/sites so the next call to {@link getRoles} /\n * {@link getSites} re-reads `process.env`.\n *\n * @internal Test-only — production code resolves once per process on\n * purpose (see {@link resolveRoles}).\n */\nexport function resetRolesCacheForTests(): void {\n  cachedRoles = undefined;\n  cachedSites = undefined;\n  sitesResolved = false;\n}\n"],"mappings":";;;;;;AAKA,MAAa,YAAY;CAAC;CAAO;CAAO;AAAQ;AAQhD,MAAM,mBAAmB,UAAU,KAAK,IAAI;;;;;;;;;;;AAY5C,SAAgB,WAAW,OAAiD;CAC1E,IAAI,UAAU,QACZ,OAAO,IAAI,IAAI,SAAS;CAG1B,MAAM,UAAU,MACb,MAAM,GAAG,CAAC,CACV,KAAK,UAAU,MAAM,KAAK,CAAC,CAAC,YAAY,CAAC,CAAC,CAC1C,QAAQ,UAAU,MAAM,SAAS,CAAC;CAErC,IAAI,QAAQ,WAAW,GACrB,MAAM,IAAI,MAAM,+CAA+C,iBAAiB,EAAE;CAGpF,KAAK,MAAM,SAAS,SAClB,IAAI,CAAE,UAAgC,SAAS,KAAK,GAClD,MAAM,IAAI,MAAM,iBAAiB,MAAM,kBAAkB,iBAAiB,EAAE;CAIhF,OAAO,IAAI,IAAI,OAAoB;AACrC;;;;;;;;;;;AAYA,SAAgB,WAAW,OAA4D;CACrF,IAAI,UAAU,QACZ;CAGF,MAAM,UAAU,MACb,MAAM,GAAG,CAAC,CACV,KAAK,UAAU,MAAM,KAAK,CAAC,CAAC,CAC5B,QAAQ,UAAU,MAAM,SAAS,CAAC;CAErC,IAAI,QAAQ,WAAW,GACrB,MAAM,IAAI,MAAM,iCAAiC;CAGnD,OAAO,IAAI,IAAI,OAAO;AACxB;;;;;;;AAQA,SAAgB,0BACd,OACA,OACM;CACN,IAAI,UAAU,UAAa,CAAC,MAAM,IAAI,KAAK,GACzC,MAAM,IAAI,MAAM,sCAAsC;AAE1D;AAEA,IAAI;AACJ,IAAI;AACJ,IAAI,gBAAgB;;;;;;AAOpB,SAAS,eAAqC;CAC5C,IAAI,CAAC,aACH,cAAc,WAAW,QAAQ,IAAI,aAAa;CAGpD,OAAO;AACT;;;;;;AAOA,SAAS,eAAgD;CACvD,IAAI,CAAC,eAAe;EAClB,cAAc,WAAW,QAAQ,IAAI,aAAa;EAClD,0BAA0B,aAAa,GAAG,WAAW;EACrD,gBAAgB;CAClB;CAEA,OAAO;AACT;;;;AAKA,SAAgB,WAAiC;CAC/C,OAAO,aAAa;AACtB;;;;;AAMA,SAAgB,WAA4C;CAC1D,OAAO,aAAa;AACtB;;;;AAKA,SAAgB,QAAQ,MAAwB;CAC9C,OAAO,aAAa,CAAC,CAAC,IAAI,IAAI;AAChC;;;;;;;AAQA,SAAgB,aAAsB;CACpC,MAAM,QAAQ,aAAa;CAE3B,OAAO,MAAM,IAAI,KAAK,KAAK,MAAM,IAAI,KAAK;AAC5C;;;;;;;;AASA,SAAgB,0BAAgC;CAC9C,cAAc;CACd,cAAc;CACd,gBAAgB;AAClB"}

package/esm/benchmark/benchmark-snapshots.d.mts

@@ -1,6 +1,6 @@
 import { BenchmarkErrorResult, BenchmarkSnapshotsOptions, BenchmarkSuccessResult } from "./types.mjs";
 
-//#region ../core/src/benchmark/benchmark-snapshots.d.ts
+//#region ../../packages/core/src/benchmark/benchmark-snapshots.d.ts
 declare class BenchmarkSnapshots {
   private readonly maxSnapshots;
   private readonly capture;

package/esm/benchmark/benchmark-snapshots.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"benchmark-snapshots.d.mts","names":[],"sources":["../../../../../../../core/src/benchmark/benchmark-snapshots.ts"],"mappings":";;;cAMa,kBAAA;EAAA,iBACM,YAAA;EAAA,iBACA,OAAA;EAAA,iBACA,SAAA;cAKE,OAAA,GAAU,yBAAA;EAAA;;;;;;;;;EActB,MAAA,CAAO,MAAA,EAAQ,sBAAA,YAAkC,oBAAA;EArBvC;;;;;;;;;EAgDV,YAAA,CAAa,IAAA,YAAgB,sBAAA,YAAkC,oBAAA;EAA/D;;;;;;;;EAYA,YAAA,IAAgB,MAAA,UAEpB,sBAAA,YAAkC,oBAAA;EAoBxB;;AAAa;;;;;;;EAAnB,KAAA,CAAM,IAAA;AAAA"}
+{"version":3,"file":"benchmark-snapshots.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/benchmark/benchmark-snapshots.ts"],"mappings":";;;cAMa,kBAAA;EAAA,iBACM,YAAA;EAAA,iBACA,OAAA;EAAA,iBACA,SAAA;cAKE,OAAA,GAAU,yBAAA;EAAA;;;;;;;;;EActB,MAAA,CAAO,MAAA,EAAQ,sBAAA,YAAkC,oBAAA;EArBvC;;;;;;;;;EAgDV,YAAA,CAAa,IAAA,YAAgB,sBAAA,YAAkC,oBAAA;EAA/D;;;;;;;;EAYA,YAAA,IAAgB,MAAA,UAEpB,sBAAA,YAAkC,oBAAA;EAoBxB;;AAAa;;;;;;;EAAnB,KAAA,CAAM,IAAA;AAAA"}

package/esm/benchmark/benchmark-snapshots.mjs

@@ -1,4 +1,4 @@
-//#region ../core/src/benchmark/benchmark-snapshots.ts
+//#region ../../packages/core/src/benchmark/benchmark-snapshots.ts
 var BenchmarkSnapshots = class {
 	constructor(options) {
 		this.snapshots = /* @__PURE__ */ new Map();

package/esm/benchmark/benchmark-snapshots.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"benchmark-snapshots.mjs","names":[],"sources":["../../../../../../../core/src/benchmark/benchmark-snapshots.ts"],"sourcesContent":["import type {\n  BenchmarkErrorResult,\n  BenchmarkSnapshotsOptions,\n  BenchmarkSuccessResult,\n} from \"./types\";\n\nexport class BenchmarkSnapshots {\n  private readonly maxSnapshots: number;\n  private readonly capture: \"error\" | \"value\" | \"all\";\n  private readonly snapshots = new Map<\n    string,\n    (BenchmarkSuccessResult<unknown> | BenchmarkErrorResult)[]\n  >();\n\n  public constructor(options?: BenchmarkSnapshotsOptions) {\n    this.maxSnapshots = options?.maxSnapshots ?? 100;\n    this.capture = options?.capture ?? \"error\";\n  }\n\n  /**\n   * Record a raw result. Called automatically by measure() when a snapshotContainer is set.\n   * Respects the `capture` setting — ignores results that don't match.\n   *\n   * @param result - The success or error result to record.\n   *\n   * @example\n   * snapshots.record(result);\n   */\n  public record(result: BenchmarkSuccessResult<unknown> | BenchmarkErrorResult): void {\n    if (this.capture === \"error\" && result.success) return;\n    if (this.capture === \"value\" && !result.success) return;\n\n    let list = this.snapshots.get(result.name);\n\n    if (!list) {\n      list = [];\n      this.snapshots.set(result.name, list);\n    }\n\n    if (list.length >= this.maxSnapshots && this.maxSnapshots > 0) {\n      list.shift(); // Evict oldest\n    }\n\n    list.push(result);\n  }\n\n  /**\n   * Get all snapshots for one operation name.\n   *\n   * @param name - The operation name.\n   * @returns Array of snapshots for the operation.\n   *\n   * @example\n   * snapshots.getSnapshots(\"db-query\");\n   */\n  public getSnapshots(name: string): (BenchmarkSuccessResult<unknown> | BenchmarkErrorResult)[] {\n    return this.snapshots.get(name) ?? [];\n  }\n\n  /**\n   * Get all snapshots for all tracked operations.\n   *\n   * @returns A mapping of operation names to their snapshots array.\n   *\n   * @example\n   * snapshots.allSnapshots();\n   */\n  public allSnapshots(): Record<\n    string,\n    (BenchmarkSuccessResult<unknown> | BenchmarkErrorResult)[]\n  > {\n    const all: Record<string, (BenchmarkSuccessResult<unknown> | BenchmarkErrorResult)[]> = {};\n\n    for (const [name, list] of this.snapshots.entries()) {\n      all[name] = [...list];\n    }\n\n    return all;\n  }\n\n  /**\n   * Clear snapshots for one or all operations.\n   *\n   * @param name - Optional operation name. If omitted, clears all snapshots.\n   *\n   * @example\n   * snapshots.reset(\"db-query\");\n   * snapshots.reset();\n   */\n  public reset(name?: string): void {\n    if (name) {\n      this.snapshots.delete(name);\n    } else {\n      this.snapshots.clear();\n    }\n  }\n}\n"],"mappings":";AAMA,IAAa,qBAAb,MAAgC;CAQ9B,AAAO,YAAY,SAAqC;mCAL3B,IAAI,IAG/B;EAGA,KAAK,eAAe,SAAS,gBAAgB;EAC7C,KAAK,UAAU,SAAS,WAAW;CACrC;;;;;;;;;;CAWA,AAAO,OAAO,QAAsE;EAClF,IAAI,KAAK,YAAY,WAAW,OAAO,SAAS;EAChD,IAAI,KAAK,YAAY,WAAW,CAAC,OAAO,SAAS;EAEjD,IAAI,OAAO,KAAK,UAAU,IAAI,OAAO,IAAI;EAEzC,IAAI,CAAC,MAAM;GACT,OAAO,CAAC;GACR,KAAK,UAAU,IAAI,OAAO,MAAM,IAAI;EACtC;EAEA,IAAI,KAAK,UAAU,KAAK,gBAAgB,KAAK,eAAe,GAC1D,KAAK,MAAM;EAGb,KAAK,KAAK,MAAM;CAClB;;;;;;;;;;CAWA,AAAO,aAAa,MAA0E;EAC5F,OAAO,KAAK,UAAU,IAAI,IAAI,KAAK,CAAC;CACtC;;;;;;;;;CAUA,AAAO,eAGL;EACA,MAAM,MAAkF,CAAC;EAEzF,KAAK,MAAM,CAAC,MAAM,SAAS,KAAK,UAAU,QAAQ,GAChD,IAAI,QAAQ,CAAC,GAAG,IAAI;EAGtB,OAAO;CACT;;;;;;;;;;CAWA,AAAO,MAAM,MAAqB;EAChC,IAAI,MACF,KAAK,UAAU,OAAO,IAAI;OAE1B,KAAK,UAAU,MAAM;CAEzB;AACF"}
+{"version":3,"file":"benchmark-snapshots.mjs","names":[],"sources":["../../../../../../../../packages/core/src/benchmark/benchmark-snapshots.ts"],"sourcesContent":["import type {\n  BenchmarkErrorResult,\n  BenchmarkSnapshotsOptions,\n  BenchmarkSuccessResult,\n} from \"./types\";\n\nexport class BenchmarkSnapshots {\n  private readonly maxSnapshots: number;\n  private readonly capture: \"error\" | \"value\" | \"all\";\n  private readonly snapshots = new Map<\n    string,\n    (BenchmarkSuccessResult<unknown> | BenchmarkErrorResult)[]\n  >();\n\n  public constructor(options?: BenchmarkSnapshotsOptions) {\n    this.maxSnapshots = options?.maxSnapshots ?? 100;\n    this.capture = options?.capture ?? \"error\";\n  }\n\n  /**\n   * Record a raw result. Called automatically by measure() when a snapshotContainer is set.\n   * Respects the `capture` setting — ignores results that don't match.\n   *\n   * @param result - The success or error result to record.\n   *\n   * @example\n   * snapshots.record(result);\n   */\n  public record(result: BenchmarkSuccessResult<unknown> | BenchmarkErrorResult): void {\n    if (this.capture === \"error\" && result.success) return;\n    if (this.capture === \"value\" && !result.success) return;\n\n    let list = this.snapshots.get(result.name);\n\n    if (!list) {\n      list = [];\n      this.snapshots.set(result.name, list);\n    }\n\n    if (list.length >= this.maxSnapshots && this.maxSnapshots > 0) {\n      list.shift(); // Evict oldest\n    }\n\n    list.push(result);\n  }\n\n  /**\n   * Get all snapshots for one operation name.\n   *\n   * @param name - The operation name.\n   * @returns Array of snapshots for the operation.\n   *\n   * @example\n   * snapshots.getSnapshots(\"db-query\");\n   */\n  public getSnapshots(name: string): (BenchmarkSuccessResult<unknown> | BenchmarkErrorResult)[] {\n    return this.snapshots.get(name) ?? [];\n  }\n\n  /**\n   * Get all snapshots for all tracked operations.\n   *\n   * @returns A mapping of operation names to their snapshots array.\n   *\n   * @example\n   * snapshots.allSnapshots();\n   */\n  public allSnapshots(): Record<\n    string,\n    (BenchmarkSuccessResult<unknown> | BenchmarkErrorResult)[]\n  > {\n    const all: Record<string, (BenchmarkSuccessResult<unknown> | BenchmarkErrorResult)[]> = {};\n\n    for (const [name, list] of this.snapshots.entries()) {\n      all[name] = [...list];\n    }\n\n    return all;\n  }\n\n  /**\n   * Clear snapshots for one or all operations.\n   *\n   * @param name - Optional operation name. If omitted, clears all snapshots.\n   *\n   * @example\n   * snapshots.reset(\"db-query\");\n   * snapshots.reset();\n   */\n  public reset(name?: string): void {\n    if (name) {\n      this.snapshots.delete(name);\n    } else {\n      this.snapshots.clear();\n    }\n  }\n}\n"],"mappings":";AAMA,IAAa,qBAAb,MAAgC;CAQ9B,AAAO,YAAY,SAAqC;mCAL3B,IAAI,IAG/B;EAGA,KAAK,eAAe,SAAS,gBAAgB;EAC7C,KAAK,UAAU,SAAS,WAAW;CACrC;;;;;;;;;;CAWA,AAAO,OAAO,QAAsE;EAClF,IAAI,KAAK,YAAY,WAAW,OAAO,SAAS;EAChD,IAAI,KAAK,YAAY,WAAW,CAAC,OAAO,SAAS;EAEjD,IAAI,OAAO,KAAK,UAAU,IAAI,OAAO,IAAI;EAEzC,IAAI,CAAC,MAAM;GACT,OAAO,CAAC;GACR,KAAK,UAAU,IAAI,OAAO,MAAM,IAAI;EACtC;EAEA,IAAI,KAAK,UAAU,KAAK,gBAAgB,KAAK,eAAe,GAC1D,KAAK,MAAM;EAGb,KAAK,KAAK,MAAM;CAClB;;;;;;;;;;CAWA,AAAO,aAAa,MAA0E;EAC5F,OAAO,KAAK,UAAU,IAAI,IAAI,KAAK,CAAC;CACtC;;;;;;;;;CAUA,AAAO,eAGL;EACA,MAAM,MAAkF,CAAC;EAEzF,KAAK,MAAM,CAAC,MAAM,SAAS,KAAK,UAAU,QAAQ,GAChD,IAAI,QAAQ,CAAC,GAAG,IAAI;EAGtB,OAAO;CACT;;;;;;;;;;CAWA,AAAO,MAAM,MAAqB;EAChC,IAAI,MACF,KAAK,UAAU,OAAO,IAAI;OAE1B,KAAK,UAAU,MAAM;CAEzB;AACF"}

package/esm/benchmark/benchmark.d.mts

@@ -1,6 +1,6 @@
 import { BenchmarkErrorResult, BenchmarkOptions, BenchmarkSuccessResult } from "./types.mjs";
 
-//#region ../core/src/benchmark/benchmark.d.ts
+//#region ../../packages/core/src/benchmark/benchmark.d.ts
 /**
  * Measure the execution time of a function and classify its performance.
  *

package/esm/benchmark/benchmark.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"benchmark.d.mts","names":[],"sources":["../../../../../../../core/src/benchmark/benchmark.ts"],"mappings":";;;;;AA+CA;;;;;;;;;;;;;;;;;;;;iBAAsB,OAAA,IACpB,IAAA,UACA,EAAA,QAAU,CAAA,GAAI,OAAA,CAAQ,CAAA,GACtB,OAAA,GAAU,gBAAA,CAAiB,CAAA,IAC1B,OAAA,CAAQ,sBAAA,CAAuB,CAAA,IAAK,oBAAA"}
+{"version":3,"file":"benchmark.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/benchmark/benchmark.ts"],"mappings":";;;;;AA+CA;;;;;;;;;;;;;;;;;;;;iBAAsB,OAAA,IACpB,IAAA,UACA,EAAA,QAAU,CAAA,GAAI,OAAA,CAAQ,CAAA,GACtB,OAAA,GAAU,gBAAA,CAAiB,CAAA,IAC1B,OAAA,CAAQ,sBAAA,CAAuB,CAAA,IAAK,oBAAA"}

package/esm/benchmark/benchmark.mjs

@@ -1,7 +1,7 @@
 import { config } from "../config/config-getter.mjs";
 import "../config/index.mjs";
 
-//#region ../core/src/benchmark/benchmark.ts
+//#region ../../packages/core/src/benchmark/benchmark.ts
 /**
 * Classifies latency into "excellent", "good", or "poor" based on thresholds.
 *

package/esm/benchmark/benchmark.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"benchmark.mjs","names":[],"sources":["../../../../../../../core/src/benchmark/benchmark.ts"],"sourcesContent":["import { config } from \"../config\";\nimport type {\n  BenchmarkConfigurations,\n  BenchmarkErrorResult,\n  BenchmarkOptions,\n  BenchmarkSuccessResult,\n} from \"./types\";\n\n/**\n * Classifies latency into \"excellent\", \"good\", or \"poor\" based on thresholds.\n *\n * @example\n * latencyState(80, { excellent: 100, poor: 500 })  // \"excellent\"\n * latencyState(300, { excellent: 100, poor: 500 }) // \"good\"\n * latencyState(600, { excellent: 100, poor: 500 }) // \"poor\"\n */\nfunction latencyState(\n  latency: number,\n  range: { excellent: number; poor: number },\n): \"excellent\" | \"good\" | \"poor\" {\n  if (latency <= range.excellent) return \"excellent\";\n  if (latency >= range.poor) return \"poor\";\n  return \"good\";\n}\n\n/**\n * Measure the execution time of a function and classify its performance.\n *\n * When `enabled` is false, fn() is still called but no timing runs and no hooks fire.\n * A zeroed SuccessResult is returned to keep the return type stable for all callers.\n *\n * @example\n * ```ts\n * const result = await measure(\"db-query\", () => db.query(\"SELECT 1\"), {\n *   latencyRange: { excellent: 100, poor: 500 },\n *   onComplete: (r) => metrics.record(r.latency),\n *   onError:    (r) => logger.error(\"query failed\", r.error),\n *   onFinish:   (r) => logger.info(`${r.name} took ${r.latency}ms`),\n * });\n *\n * if (result.success) {\n *   console.log(result.value);\n * } else {\n *   console.error(result.error);\n * }\n * ```\n */\nexport async function measure<T>(\n  name: string,\n  fn: () => T | Promise<T>,\n  options?: BenchmarkOptions<T>,\n): Promise<BenchmarkSuccessResult<T> | BenchmarkErrorResult> {\n  const benchmarkConfig = config.get<BenchmarkConfigurations>(\"benchmark\");\n\n  // Fast path: disabled (inline option wins over global config) — call fn() and\n  // return a zeroed success wrapper. No timing, no hooks. Re-throws if fn() throws.\n  if ((options?.enabled ?? benchmarkConfig?.enabled) === false) {\n    const value = await fn();\n    return {\n      name,\n      success: true,\n      value,\n      latency: 0,\n      state: \"excellent\",\n      tags: options?.tags,\n      startedAt: new Date(),\n      endedAt: new Date(),\n    };\n  }\n\n  // Resolve latency range from inline options or global config\n  const latencyRange = options?.latencyRange ?? benchmarkConfig?.latencyRange;\n\n  const startedAt = new Date();\n  const startTime = performance.now();\n  const profiler = options?.profiler ?? benchmarkConfig?.profiler;\n  const snapshotContainer = options?.snapshotContainer ?? benchmarkConfig?.snapshotContainer;\n\n  // Observers must never turn a successful call into a reported failure\n  // (callers such as use-case retry on failure), so each one is isolated.\n  const isolate = (observer: () => void) => {\n    try {\n      observer();\n    } catch (observerError) {\n      console.error(`[benchmark] observer for \"${name}\" threw`, observerError);\n    }\n  };\n\n  let value: T;\n\n  try {\n    value = await fn();\n  } catch (thrown) {\n    // Decide whether to benchmark this error or just re-throw immediately\n    const shouldBenchmark = options?.shouldBenchmarkError\n      ? options.shouldBenchmarkError(thrown)\n      : true;\n\n    if (!shouldBenchmark) {\n      throw thrown;\n    }\n\n    // Capture timing even on failure — a 30s timeout is very different from a 2ms crash\n    const endTime = performance.now();\n    const latency = Math.round(endTime - startTime);\n    const state = latencyRange ? latencyState(latency, latencyRange) : \"poor\";\n\n    // Normalize thrown value to something consistent\n    const error = thrown instanceof Error ? thrown : new Error(String(thrown));\n\n    const result: BenchmarkErrorResult = {\n      name,\n      success: false,\n      error,\n      latency,\n      state,\n      tags: options?.tags,\n      startedAt,\n      endedAt: new Date(),\n    };\n\n    if (profiler) isolate(() => profiler.record(result));\n    if (snapshotContainer) isolate(() => snapshotContainer.record(result));\n    isolate(() => options?.onError?.(result));\n    isolate(() => options?.onFinish?.(result));\n\n    return result;\n  }\n\n  const endTime = performance.now();\n  const latency = Math.round(endTime - startTime);\n  const state = latencyRange ? latencyState(latency, latencyRange) : \"good\";\n\n  const result: BenchmarkSuccessResult<T> = {\n    name,\n    success: true,\n    value,\n    latency,\n    state,\n    tags: options?.tags,\n    startedAt,\n    endedAt: new Date(),\n  };\n\n  if (profiler) isolate(() => profiler.record(result));\n  if (snapshotContainer) isolate(() => snapshotContainer.record(result));\n  isolate(() => options?.onComplete?.(result));\n  isolate(() => options?.onFinish?.(result));\n\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;AAgBA,SAAS,aACP,SACA,OAC+B;CAC/B,IAAI,WAAW,MAAM,WAAW,OAAO;CACvC,IAAI,WAAW,MAAM,MAAM,OAAO;CAClC,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;AAwBA,eAAsB,QACpB,MACA,IACA,SAC2D;CAC3D,MAAM,kBAAkB,OAAO,IAA6B,WAAW;CAIvE,KAAK,SAAS,WAAW,iBAAiB,aAAa,OAErD,OAAO;EACL;EACA,SAAS;EACT,aAJkB,GAAG;EAKrB,SAAS;EACT,OAAO;EACP,MAAM,SAAS;EACf,2BAAW,IAAI,KAAK;EACpB,yBAAS,IAAI,KAAK;CACpB;CAIF,MAAM,eAAe,SAAS,gBAAgB,iBAAiB;CAE/D,MAAM,4BAAY,IAAI,KAAK;CAC3B,MAAM,YAAY,YAAY,IAAI;CAClC,MAAM,WAAW,SAAS,YAAY,iBAAiB;CACvD,MAAM,oBAAoB,SAAS,qBAAqB,iBAAiB;CAIzE,MAAM,WAAW,aAAyB;EACxC,IAAI;GACF,SAAS;EACX,SAAS,eAAe;GACtB,QAAQ,MAAM,6BAA6B,KAAK,UAAU,aAAa;EACzE;CACF;CAEA,IAAI;CAEJ,IAAI;EACF,QAAQ,MAAM,GAAG;CACnB,SAAS,QAAQ;EAMf,IAAI,EAJoB,SAAS,uBAC7B,QAAQ,qBAAqB,MAAM,IACnC,OAGF,MAAM;EAIR,MAAM,UAAU,YAAY,IAAI;EAChC,MAAM,UAAU,KAAK,MAAM,UAAU,SAAS;EAC9C,MAAM,QAAQ,eAAe,aAAa,SAAS,YAAY,IAAI;EAKnE,MAAM,SAA+B;GACnC;GACA,SAAS;GACT,OALY,kBAAkB,QAAQ,SAAS,IAAI,MAAM,OAAO,MAAM,CAAC;GAMvE;GACA;GACA,MAAM,SAAS;GACf;GACA,yBAAS,IAAI,KAAK;EACpB;EAEA,IAAI,UAAU,cAAc,SAAS,OAAO,MAAM,CAAC;EACnD,IAAI,mBAAmB,cAAc,kBAAkB,OAAO,MAAM,CAAC;EACrE,cAAc,SAAS,UAAU,MAAM,CAAC;EACxC,cAAc,SAAS,WAAW,MAAM,CAAC;EAEzC,OAAO;CACT;CAEA,MAAM,UAAU,YAAY,IAAI;CAChC,MAAM,UAAU,KAAK,MAAM,UAAU,SAAS;CAC9C,MAAM,QAAQ,eAAe,aAAa,SAAS,YAAY,IAAI;CAEnE,MAAM,SAAoC;EACxC;EACA,SAAS;EACT;EACA;EACA;EACA,MAAM,SAAS;EACf;EACA,yBAAS,IAAI,KAAK;CACpB;CAEA,IAAI,UAAU,cAAc,SAAS,OAAO,MAAM,CAAC;CACnD,IAAI,mBAAmB,cAAc,kBAAkB,OAAO,MAAM,CAAC;CACrE,cAAc,SAAS,aAAa,MAAM,CAAC;CAC3C,cAAc,SAAS,WAAW,MAAM,CAAC;CAEzC,OAAO;AACT"}
+{"version":3,"file":"benchmark.mjs","names":[],"sources":["../../../../../../../../packages/core/src/benchmark/benchmark.ts"],"sourcesContent":["import { config } from \"../config\";\nimport type {\n  BenchmarkConfigurations,\n  BenchmarkErrorResult,\n  BenchmarkOptions,\n  BenchmarkSuccessResult,\n} from \"./types\";\n\n/**\n * Classifies latency into \"excellent\", \"good\", or \"poor\" based on thresholds.\n *\n * @example\n * latencyState(80, { excellent: 100, poor: 500 })  // \"excellent\"\n * latencyState(300, { excellent: 100, poor: 500 }) // \"good\"\n * latencyState(600, { excellent: 100, poor: 500 }) // \"poor\"\n */\nfunction latencyState(\n  latency: number,\n  range: { excellent: number; poor: number },\n): \"excellent\" | \"good\" | \"poor\" {\n  if (latency <= range.excellent) return \"excellent\";\n  if (latency >= range.poor) return \"poor\";\n  return \"good\";\n}\n\n/**\n * Measure the execution time of a function and classify its performance.\n *\n * When `enabled` is false, fn() is still called but no timing runs and no hooks fire.\n * A zeroed SuccessResult is returned to keep the return type stable for all callers.\n *\n * @example\n * ```ts\n * const result = await measure(\"db-query\", () => db.query(\"SELECT 1\"), {\n *   latencyRange: { excellent: 100, poor: 500 },\n *   onComplete: (r) => metrics.record(r.latency),\n *   onError:    (r) => logger.error(\"query failed\", r.error),\n *   onFinish:   (r) => logger.info(`${r.name} took ${r.latency}ms`),\n * });\n *\n * if (result.success) {\n *   console.log(result.value);\n * } else {\n *   console.error(result.error);\n * }\n * ```\n */\nexport async function measure<T>(\n  name: string,\n  fn: () => T | Promise<T>,\n  options?: BenchmarkOptions<T>,\n): Promise<BenchmarkSuccessResult<T> | BenchmarkErrorResult> {\n  const benchmarkConfig = config.get<BenchmarkConfigurations>(\"benchmark\");\n\n  // Fast path: disabled (inline option wins over global config) — call fn() and\n  // return a zeroed success wrapper. No timing, no hooks. Re-throws if fn() throws.\n  if ((options?.enabled ?? benchmarkConfig?.enabled) === false) {\n    const value = await fn();\n    return {\n      name,\n      success: true,\n      value,\n      latency: 0,\n      state: \"excellent\",\n      tags: options?.tags,\n      startedAt: new Date(),\n      endedAt: new Date(),\n    };\n  }\n\n  // Resolve latency range from inline options or global config\n  const latencyRange = options?.latencyRange ?? benchmarkConfig?.latencyRange;\n\n  const startedAt = new Date();\n  const startTime = performance.now();\n  const profiler = options?.profiler ?? benchmarkConfig?.profiler;\n  const snapshotContainer = options?.snapshotContainer ?? benchmarkConfig?.snapshotContainer;\n\n  // Observers must never turn a successful call into a reported failure\n  // (callers such as use-case retry on failure), so each one is isolated.\n  const isolate = (observer: () => void) => {\n    try {\n      observer();\n    } catch (observerError) {\n      console.error(`[benchmark] observer for \"${name}\" threw`, observerError);\n    }\n  };\n\n  let value: T;\n\n  try {\n    value = await fn();\n  } catch (thrown) {\n    // Decide whether to benchmark this error or just re-throw immediately\n    const shouldBenchmark = options?.shouldBenchmarkError\n      ? options.shouldBenchmarkError(thrown)\n      : true;\n\n    if (!shouldBenchmark) {\n      throw thrown;\n    }\n\n    // Capture timing even on failure — a 30s timeout is very different from a 2ms crash\n    const endTime = performance.now();\n    const latency = Math.round(endTime - startTime);\n    const state = latencyRange ? latencyState(latency, latencyRange) : \"poor\";\n\n    // Normalize thrown value to something consistent\n    const error = thrown instanceof Error ? thrown : new Error(String(thrown));\n\n    const result: BenchmarkErrorResult = {\n      name,\n      success: false,\n      error,\n      latency,\n      state,\n      tags: options?.tags,\n      startedAt,\n      endedAt: new Date(),\n    };\n\n    if (profiler) isolate(() => profiler.record(result));\n    if (snapshotContainer) isolate(() => snapshotContainer.record(result));\n    isolate(() => options?.onError?.(result));\n    isolate(() => options?.onFinish?.(result));\n\n    return result;\n  }\n\n  const endTime = performance.now();\n  const latency = Math.round(endTime - startTime);\n  const state = latencyRange ? latencyState(latency, latencyRange) : \"good\";\n\n  const result: BenchmarkSuccessResult<T> = {\n    name,\n    success: true,\n    value,\n    latency,\n    state,\n    tags: options?.tags,\n    startedAt,\n    endedAt: new Date(),\n  };\n\n  if (profiler) isolate(() => profiler.record(result));\n  if (snapshotContainer) isolate(() => snapshotContainer.record(result));\n  isolate(() => options?.onComplete?.(result));\n  isolate(() => options?.onFinish?.(result));\n\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;AAgBA,SAAS,aACP,SACA,OAC+B;CAC/B,IAAI,WAAW,MAAM,WAAW,OAAO;CACvC,IAAI,WAAW,MAAM,MAAM,OAAO;CAClC,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;AAwBA,eAAsB,QACpB,MACA,IACA,SAC2D;CAC3D,MAAM,kBAAkB,OAAO,IAA6B,WAAW;CAIvE,KAAK,SAAS,WAAW,iBAAiB,aAAa,OAErD,OAAO;EACL;EACA,SAAS;EACT,aAJkB,GAAG;EAKrB,SAAS;EACT,OAAO;EACP,MAAM,SAAS;EACf,2BAAW,IAAI,KAAK;EACpB,yBAAS,IAAI,KAAK;CACpB;CAIF,MAAM,eAAe,SAAS,gBAAgB,iBAAiB;CAE/D,MAAM,4BAAY,IAAI,KAAK;CAC3B,MAAM,YAAY,YAAY,IAAI;CAClC,MAAM,WAAW,SAAS,YAAY,iBAAiB;CACvD,MAAM,oBAAoB,SAAS,qBAAqB,iBAAiB;CAIzE,MAAM,WAAW,aAAyB;EACxC,IAAI;GACF,SAAS;EACX,SAAS,eAAe;GACtB,QAAQ,MAAM,6BAA6B,KAAK,UAAU,aAAa;EACzE;CACF;CAEA,IAAI;CAEJ,IAAI;EACF,QAAQ,MAAM,GAAG;CACnB,SAAS,QAAQ;EAMf,IAAI,EAJoB,SAAS,uBAC7B,QAAQ,qBAAqB,MAAM,IACnC,OAGF,MAAM;EAIR,MAAM,UAAU,YAAY,IAAI;EAChC,MAAM,UAAU,KAAK,MAAM,UAAU,SAAS;EAC9C,MAAM,QAAQ,eAAe,aAAa,SAAS,YAAY,IAAI;EAKnE,MAAM,SAA+B;GACnC;GACA,SAAS;GACT,OALY,kBAAkB,QAAQ,SAAS,IAAI,MAAM,OAAO,MAAM,CAAC;GAMvE;GACA;GACA,MAAM,SAAS;GACf;GACA,yBAAS,IAAI,KAAK;EACpB;EAEA,IAAI,UAAU,cAAc,SAAS,OAAO,MAAM,CAAC;EACnD,IAAI,mBAAmB,cAAc,kBAAkB,OAAO,MAAM,CAAC;EACrE,cAAc,SAAS,UAAU,MAAM,CAAC;EACxC,cAAc,SAAS,WAAW,MAAM,CAAC;EAEzC,OAAO;CACT;CAEA,MAAM,UAAU,YAAY,IAAI;CAChC,MAAM,UAAU,KAAK,MAAM,UAAU,SAAS;CAC9C,MAAM,QAAQ,eAAe,aAAa,SAAS,YAAY,IAAI;CAEnE,MAAM,SAAoC;EACxC;EACA,SAAS;EACT;EACA;EACA;EACA,MAAM,SAAS;EACf;EACA,yBAAS,IAAI,KAAK;CACpB;CAEA,IAAI,UAAU,cAAc,SAAS,OAAO,MAAM,CAAC;CACnD,IAAI,mBAAmB,cAAc,kBAAkB,OAAO,MAAM,CAAC;CACrE,cAAc,SAAS,aAAa,MAAM,CAAC;CAC3C,cAAc,SAAS,WAAW,MAAM,CAAC;CAEzC,OAAO;AACT"}

package/esm/benchmark/channels/console.channel.d.mts

@@ -1,6 +1,6 @@
 import { BenchmarkChannel, BenchmarkStats } from "../types.mjs";
 
-//#region ../core/src/benchmark/channels/console.channel.d.ts
+//#region ../../packages/core/src/benchmark/channels/console.channel.d.ts
 declare class ConsoleChannel implements BenchmarkChannel {
   /**
    * Pretty-prints a stats table per operation on onFlush().

package/esm/benchmark/channels/console.channel.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"console.channel.d.mts","names":[],"sources":["../../../../../../../../core/src/benchmark/channels/console.channel.ts"],"mappings":";;;cAEa,cAAA,YAA0B,gBAAA;;AAAvC;;;;;;;;EAUS,OAAA,CAAQ,KAAA,EAAO,MAAA,SAAe,cAAA;AAAA"}
+{"version":3,"file":"console.channel.d.mts","names":[],"sources":["../../../../../../../../../packages/core/src/benchmark/channels/console.channel.ts"],"mappings":";;;cAEa,cAAA,YAA0B,gBAAA;;AAAvC;;;;;;;;EAUS,OAAA,CAAQ,KAAA,EAAO,MAAA,SAAe,cAAA;AAAA"}

package/esm/benchmark/channels/console.channel.mjs

@@ -1,4 +1,4 @@
-//#region ../core/src/benchmark/channels/console.channel.ts
+//#region ../../packages/core/src/benchmark/channels/console.channel.ts
 var ConsoleChannel = class {
 	/**
 	* Pretty-prints a stats table per operation on onFlush().

package/esm/benchmark/channels/console.channel.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"console.channel.mjs","names":[],"sources":["../../../../../../../../core/src/benchmark/channels/console.channel.ts"],"sourcesContent":["import type { BenchmarkChannel, BenchmarkStats } from \"../types\";\n\nexport class ConsoleChannel implements BenchmarkChannel {\n  /**\n   * Pretty-prints a stats table per operation on onFlush().\n   *\n   * @param stats - Aggregated stats for all tracked operations.\n   *\n   * @example\n   * const channel = new ConsoleChannel();\n   * channel.onFlush({ \"db-query\": { p50: 10, count: 100, ... } });\n   */\n  public onFlush(stats: Record<string, BenchmarkStats>): void {\n    const tableData: Record<string, any> = {};\n\n    for (const [name, operationStats] of Object.entries(stats)) {\n      tableData[name] = {\n        \"p50 (ms)\": operationStats.p50,\n        \"p90 (ms)\": operationStats.p90,\n        \"p95 (ms)\": operationStats.p95,\n        \"p99 (ms)\": operationStats.p99,\n        \"Avg (ms)\": operationStats.avg,\n        \"Min (ms)\": operationStats.min,\n        \"Max (ms)\": operationStats.max,\n        \"Error Rate\": `${(operationStats.errorRate * 100).toFixed(2)}%`,\n        Errors: operationStats.errors,\n        Count: operationStats.count,\n      };\n    }\n\n    console.table(tableData);\n  }\n}\n"],"mappings":";AAEA,IAAa,iBAAb,MAAwD;;;;;;;;;;CAUtD,AAAO,QAAQ,OAA6C;EAC1D,MAAM,YAAiC,CAAC;EAExC,KAAK,MAAM,CAAC,MAAM,mBAAmB,OAAO,QAAQ,KAAK,GACvD,UAAU,QAAQ;GAChB,YAAY,eAAe;GAC3B,YAAY,eAAe;GAC3B,YAAY,eAAe;GAC3B,YAAY,eAAe;GAC3B,YAAY,eAAe;GAC3B,YAAY,eAAe;GAC3B,YAAY,eAAe;GAC3B,cAAc,IAAI,eAAe,YAAY,IAAG,CAAE,QAAQ,CAAC,EAAE;GAC7D,QAAQ,eAAe;GACvB,OAAO,eAAe;EACxB;EAGF,QAAQ,MAAM,SAAS;CACzB;AACF"}
+{"version":3,"file":"console.channel.mjs","names":[],"sources":["../../../../../../../../../packages/core/src/benchmark/channels/console.channel.ts"],"sourcesContent":["import type { BenchmarkChannel, BenchmarkStats } from \"../types\";\n\nexport class ConsoleChannel implements BenchmarkChannel {\n  /**\n   * Pretty-prints a stats table per operation on onFlush().\n   *\n   * @param stats - Aggregated stats for all tracked operations.\n   *\n   * @example\n   * const channel = new ConsoleChannel();\n   * channel.onFlush({ \"db-query\": { p50: 10, count: 100, ... } });\n   */\n  public onFlush(stats: Record<string, BenchmarkStats>): void {\n    const tableData: Record<string, any> = {};\n\n    for (const [name, operationStats] of Object.entries(stats)) {\n      tableData[name] = {\n        \"p50 (ms)\": operationStats.p50,\n        \"p90 (ms)\": operationStats.p90,\n        \"p95 (ms)\": operationStats.p95,\n        \"p99 (ms)\": operationStats.p99,\n        \"Avg (ms)\": operationStats.avg,\n        \"Min (ms)\": operationStats.min,\n        \"Max (ms)\": operationStats.max,\n        \"Error Rate\": `${(operationStats.errorRate * 100).toFixed(2)}%`,\n        Errors: operationStats.errors,\n        Count: operationStats.count,\n      };\n    }\n\n    console.table(tableData);\n  }\n}\n"],"mappings":";AAEA,IAAa,iBAAb,MAAwD;;;;;;;;;;CAUtD,AAAO,QAAQ,OAA6C;EAC1D,MAAM,YAAiC,CAAC;EAExC,KAAK,MAAM,CAAC,MAAM,mBAAmB,OAAO,QAAQ,KAAK,GACvD,UAAU,QAAQ;GAChB,YAAY,eAAe;GAC3B,YAAY,eAAe;GAC3B,YAAY,eAAe;GAC3B,YAAY,eAAe;GAC3B,YAAY,eAAe;GAC3B,YAAY,eAAe;GAC3B,YAAY,eAAe;GAC3B,cAAc,IAAI,eAAe,YAAY,IAAG,CAAE,QAAQ,CAAC,EAAE;GAC7D,QAAQ,eAAe;GACvB,OAAO,eAAe;EACxB;EAGF,QAAQ,MAAM,SAAS;CACzB;AACF"}

package/esm/benchmark/channels/noop.channel.d.mts

@@ -1,6 +1,6 @@
 import { BenchmarkChannel } from "../types.mjs";
 
-//#region ../core/src/benchmark/channels/noop.channel.d.ts
+//#region ../../packages/core/src/benchmark/channels/noop.channel.d.ts
 declare class NoopChannel implements BenchmarkChannel {
   onFlush(): void;
 }

package/esm/benchmark/channels/noop.channel.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"noop.channel.d.mts","names":[],"sources":["../../../../../../../../core/src/benchmark/channels/noop.channel.ts"],"mappings":";;;cAEa,WAAA,YAAuB,gBAAgB;EAC3C,OAAO;AAAA"}
+{"version":3,"file":"noop.channel.d.mts","names":[],"sources":["../../../../../../../../../packages/core/src/benchmark/channels/noop.channel.ts"],"mappings":";;;cAEa,WAAA,YAAuB,gBAAgB;EAC3C,OAAO;AAAA"}

package/esm/benchmark/channels/noop.channel.mjs

@@ -1,4 +1,4 @@
-//#region ../core/src/benchmark/channels/noop.channel.ts
+//#region ../../packages/core/src/benchmark/channels/noop.channel.ts
 var NoopChannel = class {
 	onFlush() {}
 };

package/esm/benchmark/channels/noop.channel.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"noop.channel.mjs","names":[],"sources":["../../../../../../../../core/src/benchmark/channels/noop.channel.ts"],"sourcesContent":["import type { BenchmarkChannel } from \"../types\";\n\nexport class NoopChannel implements BenchmarkChannel {\n  public onFlush(): void {}\n}\n"],"mappings":";AAEA,IAAa,cAAb,MAAqD;CACnD,AAAO,UAAgB,CAAC;AAC1B"}
+{"version":3,"file":"noop.channel.mjs","names":[],"sources":["../../../../../../../../../packages/core/src/benchmark/channels/noop.channel.ts"],"sourcesContent":["import type { BenchmarkChannel } from \"../types\";\n\nexport class NoopChannel implements BenchmarkChannel {\n  public onFlush(): void {}\n}\n"],"mappings":";AAEA,IAAa,cAAb,MAAqD;CACnD,AAAO,UAAgB,CAAC;AAC1B"}