@dunx/dashboard 1.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Petar Zarkov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,242 @@
+# @dunx/dashboard
+
+One page over a running dunx app: the routes it serves, the container it built,
+the gateways it upgrades, Redis, the config keys and the process itself - **with
+bull-board mounted for the queues**. Opt in with one module and one `app.use`.
+
+```bash
+bun add @dunx/dashboard
+```
+
+An operator looking at a running dunx service has had three surfaces over the same
+data and none of them the one they wanted. `/docs` answers "what can a client
+call". `@dunx/mcp` answers the same questions for an agent, over stdio. Nothing
+answered **"what is this process actually doing"**. This is that page, and it is
+cheap because every panel reads data dunx already computes.
+
+## Mount it
+
+```ts
+import { DashboardMiddleware, DashboardModule } from '@dunx/dashboard';
+import { JobPublisher, QueueModule } from '@dunx/infra/queue';
+import { RedisConnection, RedisModule } from '@dunx/infra/redis';
+
+@Module({
+  imports: [
+    DashboardModule.forRootAsync({
+      // This dynamic module is its own scope, so whatever exports the tokens the
+      // factory injects goes here.
+      imports: [QueueModule, RedisModule],
+      useFactory: (queues: JobPublisher, redis: RedisConnection) => ({
+        queues,
+        redis,
+        authorize: (req) => req.headers.get('x-ops-key') === process.env.OPS_KEY,
+      }),
+      inject: [JobPublisher, RedisConnection] as const,
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+```ts
+const app = await HttpFactory.create(AppModule);
+app.use(DashboardMiddleware, SessionGuard); // the dashboard first - see below
+await app.listen(3000);
+```
+
+That is the whole wiring. `JobPublisher` and `RedisConnection` are accepted **as
+they are**: this package restates what it needs from them structurally and depends
+on `@dunx/infra`, `bullmq` and `ioredis` not at all, so an app with no queues does
+not install a queue library to look at its routes.
+
+## Six panels
+
+| Panel                   | Reads                                                                              | Lifetime |
+| ----------------------- | ---------------------------------------------------------------------------------- | -------- |
+| **Overview**            | counts, uptime, heap, Bun version, dependency probes                              | polled   |
+| **Routes**              | `routesOf` - method, path, controller, module, guards, `@Roles`/`@Public`, schemas | static   |
+| **Gateways**            | `gatewaysOf` - upgrade path, the event each handler claims                         | static   |
+| **Modules & providers** | `providersOf`, `modulesOf` - what each module binds, exports and injects           | static   |
+| **Queues & Redis**      | queue names and a link to **bull-board**; Redis `PING` and `INFO`                 | polled   |
+| **Configuration**       | keys and types, values only where you allow them                                   | static   |
+
+The provider panel is the one that earns its place fastest. A missing-binding error
+names one token; reconstructing which module bound what and why the graph did not
+close is otherwise a grep across every `@Module`. An **unresolvable constructor
+parameter** - an interface, a primitive, a union, a type-only import - is called out
+in red on the overview, because each one is a boot error waiting to happen.
+
+The static panels use the same readers `@dunx/mcp` answers with, and they construct
+nothing. That is the deliberate inversion of MCP's rule: MCP refuses runtime
+questions because booting an app to answer them would open databases and bind
+sockets, and this package is *already inside* a booted app, so the reason does not
+apply. Stating it per panel is what stops the dashboard growing a `boot()`.
+
+## Every panel has a JSON sibling
+
+```bash
+curl -H 'x-ops-key: …' $APP/_dunx/api/snapshot
+curl -H 'x-ops-key: …' $APP/_dunx/api/runtime
+curl -H 'x-ops-key: …' $APP/_dunx/api/redis
+curl -H 'x-ops-key: …' $APP/_dunx/api/queues     # names only; the board is at /_dunx/queues
+```
+
+These are the endpoints the page itself uses, and they are supported rather than an
+implementation detail - which is what makes the dashboard usable on a box with no
+browser. Their types are exported (`Snapshot`, `RuntimeReport`, `RedisReport`,
+`QueuesReport`), so a `fetch` of them is typed. Anything *about* a queue is
+bull-board's own API, under `{path}/queues`.
+
+## Security
+
+**`authorize` has no default. Leaving it out serves the page to anyone who can
+reach the port**, and the page is routes plus config plus the provider graph on one
+screen - a reconnaissance gift. Omitting it logs a warning naming the mount at boot,
+because "fine behind a private network" is a real answer and guessing is not.
+
+Four things follow, and none is obvious:
+
+- **A rejected request gets 404, not 403.** A dashboard that announces itself to an
+  unauthenticated caller has told them where to keep knocking.
+- **Register it ahead of any session guard.** With the middleware last in the chain,
+  a `SessionGuard` answers every dashboard request `401` before `authorize` runs,
+  which defeats the 404 contract entirely.
+- **So `authorize` must be self-sufficient.** It receives the raw `Request` and runs
+  before anything has written an `AuthContext` - ask your auth library directly.
+- **`commands: false`** puts bull-board in its own read-only mode. Everything else
+  on the page only ever reports, so this is entirely about the queues. `authorize`
+  gates who reaches the mount; this gates what they can do once there.
+
+### Configuration is redacted by default
+
+`ConfigService` holds whatever your `validate` returned, which includes every secret
+you have. A deny-list of the usual suspects - `SECRET`, `PASSWORD`, `TOKEN` - looks
+careful and leaks the first key nobody thought of, so **the default reveals
+nothing**: the panel shows keys and types, which is most of what it is wanted for,
+and a value appears only where you say so.
+
+```ts
+config: appConfig,           // ConfigService satisfies this as written
+reveal: (key) => key === 'NODE_ENV' || key.startsWith('PUBLIC_'),
+```
+
+There is no "reveal" control on the page. Redaction is decided at boot by the app,
+not per click by whoever reached it.
+
+## The queues are bull-board's
+
+**dunx renders no queue UI.** `{path}/queues` is
+[bull-board](https://github.com/felixmosh/bull-board), mounted - flows, job logs,
+the repeatable-job editor, per-queue metrics, redis stats, retry/promote/clean, all
+of it, and none of it dunx's to maintain.
+
+This package briefly shipped its own queue table, and that was the wrong call under
+the framework's first rule: never invent what a mature library already solves. The
+one thing that had ever justified hand-rolling it was that mounting bull-board on
+`Bun.serve` meant writing a server adapter - which the deleted
+`@dunx/queue-dashboard` did, and which was a liability. **bull-board 8.6.0 ships
+`@bull-board/bun`**, so that reason is gone and the integration is three calls.
+
+It also disposes of the question that started all this: `Queue.getWorkers()` returns
+`[]` on Bun, because bullmq matches workers by client name through `CLIENT LIST` and
+its Bun adapter never names a connection. Whatever bullmq can report on Bun is
+bull-board's to report. dunx is not in the business of papering over it, and a
+dashboard that quietly worked around a library's limitation would be a worse place
+to find out about it.
+
+```bash
+bun add @bull-board/api @bull-board/ui @bull-board/bun
+```
+
+All three are **optional peers**. Without them the queues panel says so and names
+the install line; nothing else on the page is affected.
+
+Two things dunx does contribute, and they are the two bull-board cannot know:
+
+- **It is behind the same `authorize`** as the rest of the mount, and answers the
+  same 404 to a caller that fails it.
+- **`commands: false` maps onto bull-board's own `readOnlyMode`** rather than dunx
+  refusing its POSTs. It already has the switch; a second implementation would
+  disagree the moment bull-board grew an operation dunx had not heard of.
+
+One caveat worth knowing: **bull-board's page loads a webfont from Google Fonts.**
+dunx's own page fetches nothing, and that guarantee does not extend across the
+handoff.
+
+### Naming a queue this process only consumes
+
+A queue is a key prefix opened on first use, so `JobPublisher.opened` lists only what
+this process has **published** to. A worker that drains `thumbnails` and publishes
+nothing has opened nothing, and the queue would be invisible on the page that exists
+to show it:
+
+```ts
+queueNames: ['thumbnails'],
+```
+
+This is free. The board - and therefore any connection to the broker - is built on
+the **first request for `{path}/queues`**, never at boot and never by the polling
+`/api/queues` endpoint, which reads names straight off the options. An app that
+mounts the dashboard and never opens the board holds no socket for it, which is what
+lets a process still exit cleanly against an absent Redis.
+
+## Options
+
+| Option            | Default    | Notes                                                          |
+| ----------------- | ---------- | -------------------------------------------------------------- |
+| `path`            | `/_dunx`   | **`setGlobalPrefix` does not move it** - see below             |
+| `authorize`       | *none*     | No default. See Security                                       |
+| `title`           | `'dunx'`   | Header and `<title>`                                            |
+| `queues`          | *none*     | `JobPublisher`                                                  |
+| `queueNames`      | `[]`       | Queues this process only consumes                              |
+| `redis`           | *none*     | `RedisConnection`                                               |
+| `config`          | *none*     | `ConfigService`. Absent means no config panel                  |
+| `reveal`          | reveal none| Per-key opt in                                                 |
+| `probes`          | `[]`       | Anything else worth a light                                    |
+| `openApiPath`     | *none*     | Links each route row into the explorer                         |
+| `pollMs`          | `5000`     | `0` turns polling off and leaves the refresh button            |
+| `probeTimeoutMs`  | `2000`     | A hung probe costs one light, not the page                     |
+| `commands`        | `true`     | `false` → bull-board's own `readOnlyMode`                      |
+
+`app.setGlobalPrefix('api')` prefixes routes discovered from controllers. The
+dashboard is a **middleware matching a path**, not one of those - which is exactly
+what lets it serve a route table handed over at runtime without generating a
+controller per panel. With a global prefix, say so:
+
+```ts
+path: '/api/_dunx',
+```
+
+## Probes
+
+Anything with a name and a `check()`. It is awaited with a timeout and never allowed
+to throw into a response, so a hung dependency costs one light rather than the page -
+and a probe that did not answer reads `unknown`, never `down`, because those are
+different facts and one of them sends somebody to restart a healthy service.
+
+```ts
+probes: [
+  {
+    name: 'database',
+    check: async () => {
+      await db.execute(sql`select 1`);
+      return { state: 'up', detail: 'sqlite' };
+    },
+  },
+],
+```
+
+Passing `redis` adds one automatically, on `PING` rather than the connected flag: a
+flag says a socket is up and a round trip says the server is answering.
+
+## The page
+
+Server-rendered shell, React + Mantine inside it, **inlined** - no CDN, no `src=`,
+no `<link>`, so it opens on a host with no egress. It shares its theme and
+components with the dunx documentation site and the API explorer, so the three look
+like one product.
+
+The bundle sits behind `@dunx/dashboard/ui` and is reached with `await import()` on
+the first request for the page, so an app that mounts the module and never opens it
+pays nothing at boot. It is built by `internal/dashboard-ui`.

package/dist/api/bounded.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Every read the dashboard makes off-process is bounded, and this is the one
+ * implementation of that.
+ *
+ * The failure it exists for is specific and was measured: with Redis unreachable,
+ * a queue's `getJobCounts` waits out the connection timeout - 5 s by default in
+ * `@dunx/infra/queue` - so opening the dashboard on a broken broker hung the page
+ * for exactly as long as the thing you opened it to look at was broken. A
+ * dependency being down must cost one panel, not the page.
+ *
+ * The fallback is a **value**, not a rejection: a queue that could not be reached
+ * still gets a row saying so, which is the whole point of looking.
+ */
+export declare const bounded: <T>(work: () => Promise<T>, ms: number, onTimeout: () => T) => Promise<T>;

package/dist/api/redis.d.ts

@@ -0,0 +1,9 @@
+import type { RedisProbe } from '../contracts.js';
+import type { RedisReport } from './types.js';
+/**
+ * `INFO` replies as a text blob of `key:value` lines with `# Section` headers.
+ * Parsed here rather than adding a method per field to `RedisProbe`, which is how a
+ * structural restatement turns into a client library.
+ */
+export declare const parseInfo: (raw: string) => Readonly<Record<string, string>>;
+export declare const redisReport: (redis: RedisProbe, timeoutMs: number) => Promise<RedisReport>;

package/dist/api/runtime.d.ts

@@ -0,0 +1,13 @@
+import type { DashboardProbe } from '../contracts.js';
+import type { DashboardOptions } from '../options.js';
+import type { ProbeReport, RuntimeReport } from './types.js';
+export declare const runProbe: (probe: DashboardProbe, timeoutMs: number) => Promise<ProbeReport>;
+/**
+ * The Redis handle, if the app passed one, as a probe like any other - so the
+ * lights row has one shape and the panel does not special-case its own dependency.
+ *
+ * `ping` rather than `connected`: the flag says whether a socket is up, and a
+ * round trip says whether the server is answering, which is the question.
+ */
+export declare const redisProbe: (redis: NonNullable<DashboardOptions['redis']>) => DashboardProbe;
+export declare const runtimeReport: (options: DashboardOptions, startedAt: number) => Promise<RuntimeReport>;

package/dist/api/snapshot.d.ts

@@ -0,0 +1,13 @@
+import { type ModuleRef } from '@dunx/core';
+import type { DashboardOptions } from '../options.js';
+import type { ConfigEntry, Meta, Snapshot } from './types.js';
+/**
+ * Keys, types, and a value only where the app's `reveal` predicate said so.
+ *
+ * Sorted, because a config panel is read by scanning for a key rather than in
+ * declaration order, and `validate` returns whatever object literal order the app
+ * happened to write.
+ */
+export declare const configEntries: (values: object, reveal: DashboardOptions['reveal']) => readonly ConfigEntry[];
+export declare const metaOf: (options: DashboardOptions) => Meta;
+export declare const snapshotOf: (root: ModuleRef, options: DashboardOptions) => Snapshot;

package/dist/api/types.d.ts

@@ -0,0 +1,110 @@
+import type { ModuleNode, ProviderNode } from '@dunx/core';
+import type { GatewayNode, RouteNode } from '@dunx/http';
+import type { ProbeState } from '../contracts.js';
+/**
+ * Everything the page reads, declared once.
+ *
+ * `internal/dashboard-ui` imports these by relative path from this file, exactly
+ * as `internal/openapi-ui` imports `PageModel` from `@dunx/openapi`'s source - so
+ * the wire format has one declaration and the frontend cannot drift from the
+ * handler that fills it. The node types are re-exported rather than restated for
+ * the same reason: they are `@dunx/core`'s and `@dunx/http`'s, and a copy shaped
+ * for the browser would be a second thing to keep in step.
+ */
+export type { GatewayNode, ModuleNode, ProbeState, ProviderNode, RouteNode };
+/** Split by lifetime, which is also the split by endpoint. */
+export interface Meta {
+    readonly title: string;
+    /** The mount, so the bundle can build its own URLs without guessing. */
+    readonly basePath: string;
+    /** Where `@dunx/openapi` serves its explorer, if the app said. */
+    readonly openApiPath: string | undefined;
+    /** 0 disables polling. */
+    readonly pollMs: number;
+    /**
+     * Where bull-board is mounted, always `{basePath}/queues`. Carried rather than
+     * derived so the page never builds a URL the server did not agree to.
+     */
+    readonly queuesPath: string;
+}
+export interface ConfigEntry {
+    readonly key: string;
+    /** `typeof`, or `array`/`null`, so a shape is visible without the value. */
+    readonly type: string;
+    /**
+     * Present only when the app's `reveal` predicate said so. Absent means
+     * redacted - there is no sentinel string, because a sentinel is indistinguishable
+     * from a value that happens to be `'***'`.
+     */
+    readonly value?: unknown;
+}
+/**
+ * The half that cannot change while the process runs. One request, cached by the
+ * page for its lifetime.
+ */
+export interface Snapshot {
+    readonly meta: Meta;
+    readonly routes: readonly RouteNode[];
+    readonly gateways: readonly GatewayNode[];
+    readonly modules: readonly ModuleNode[];
+    readonly providers: readonly ProviderNode[];
+    /**
+     * Absent when no `ConfigService` is bound, which is a different fact from an
+     * empty config and is shown as one.
+     */
+    readonly config: readonly ConfigEntry[] | undefined;
+}
+export interface ProbeReport {
+    readonly name: string;
+    readonly state: ProbeState;
+    readonly detail?: string;
+    /** How long the probe took, so a slow dependency is visible before it fails. */
+    readonly ms: number;
+}
+export interface MemoryReport {
+    readonly rss: number;
+    readonly heapUsed: number;
+    readonly heapTotal: number;
+    readonly external: number;
+}
+/** The half that changes. Polled. */
+export interface RuntimeReport {
+    readonly pid: number;
+    readonly uptimeMs: number;
+    readonly bun: string;
+    readonly platform: string;
+    readonly arch: string;
+    readonly memory: MemoryReport;
+    readonly probes: readonly ProbeReport[];
+    /** Server clock, so the page can show ages rather than raw timestamps. */
+    readonly now: number;
+}
+export interface RedisReport {
+    readonly configured: true;
+    readonly connected: boolean;
+    readonly pingMs: number | undefined;
+    /**
+     * A curated handful from `INFO`: version, mode, uptime, connected clients, used
+     * memory, keyspace hits and misses. Not the whole blob - that is 200 lines and it
+     * is one `redis-cli INFO` away for anyone who wants it.
+     */
+    readonly info: Readonly<Record<string, string>>;
+    readonly error?: string;
+}
+/** No `redis` handle was passed, which is different from a broker being down. */
+export interface RedisAbsent {
+    readonly configured: false;
+}
+/**
+ * What the queues endpoint answers: **names, and nothing else.**
+ *
+ * Everything *about* a queue - counts, jobs, retries, flows, metrics - is
+ * bull-board's, mounted at `{path}/queues`. dunx renders no queue UI, so this
+ * exists only so the page knows whether to offer the link and what to say when
+ * there is nothing behind it.
+ */
+export interface QueuesReport {
+    readonly queues: readonly string[];
+    /** Why there is no board: no source, no queues opened, or bull-board absent. */
+    readonly unavailable?: string;
+}

package/dist/board.d.ts

@@ -0,0 +1,42 @@
+import type { DashboardOptions } from './options.js';
+/** The Bun route table `BunAdapter.getRoutes()` produces. */
+export type BoardRoutes = Record<string, Record<string, (req: Request) => Response | Promise<Response>>>;
+export interface Board {
+    /** Why there is no board, for the page to show. Absent when there is one. */
+    readonly unavailable?: string;
+    readonly routes?: BoardRoutes;
+    /** The entry route, so an unmatched client-side path serves the page. */
+    readonly entry?: (req: Request) => Response | Promise<Response>;
+    /** The queue names the board was built with, for the nav. */
+    readonly queues: readonly string[];
+}
+/**
+ * bull-board wants **queue objects**, not names, and `QueueSource.queue(name)`
+ * opens one - so this is the one place the dashboard touches a broker. It happens
+ * on the first request for the board and is memoised by the caller, not at boot: an
+ * app that mounts the dashboard and never opens the queues page must not hold a
+ * socket for it.
+ */
+/**
+ * The names alone, answerable **without opening anything**.
+ *
+ * That separation is the whole reason `/_dunx/api/queues` and `/_dunx/queues` are
+ * different endpoints: the page asks this one on every poll to decide whether to
+ * offer the link, and it must not open a socket to answer. Only somebody actually
+ * opening the board does that.
+ */
+export declare const boardNames: (options: DashboardOptions) => {
+    readonly names: readonly string[];
+    readonly unavailable?: string;
+};
+export declare const buildBoard: (options: DashboardOptions, basePath: string, favicon: string) => Promise<Board>;
+/**
+ * Dispatches against bull-board's **own** route table - an exact path match, plus
+ * the one `/*` prefix its static assets are served under.
+ *
+ * This is not the JavaScript router dunx bans. It never sees an app's routes: Bun
+ * still matches everything real, this runs only inside the dashboard mount, and the
+ * table it walks is the one bull-board handed over. Twenty lines here is the price
+ * of not asking `HttpFactory` to accept a foreign route table at boot.
+ */
+export declare const matchBoard: (routes: BoardRoutes, method: string, pathname: string) => ((req: Request) => Response | Promise<Response>) | undefined;

package/dist/chunk-xg5554k6.js

@@ -0,0 +1,107 @@
+// @bun
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __name = (target, name) => {
+  Object.defineProperty(target, "name", {
+    value: name,
+    enumerable: false,
+    configurable: true
+  });
+  return target;
+};
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => (key in obj) ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== undefined && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({
+  kind: __decoratorStrings[kind],
+  name,
+  metadata,
+  addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null))
+});
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length;i < n; i++)
+    flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : {
+    get [name]() {
+      return __privateGet(this, extra);
+    },
+    set [name](x) {
+      __privateSet(this, extra, x);
+    }
+  }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1;i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => (name in x) };
+      if (k ^ 3)
+        access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2)
+        access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? undefined : { get: desc.get, set: desc.set } : target, ctx);
+    done._ = 1;
+    if (k ^ 4 || it === undefined)
+      __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null)
+      __typeError("Object expected");
+    else
+      __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __require = import.meta.require;
+
+// src/api/snapshot.ts
+import { modulesOf, providersOf } from "@dunx/core";
+import { gatewaysOf, isGateway, routesOf } from "@dunx/http";
+var typeOf = (value) => {
+  if (value === null)
+    return "null";
+  if (Array.isArray(value))
+    return "array";
+  return typeof value;
+};
+var configEntries = (values, reveal) => Object.entries(values).sort(([a], [b]) => a.localeCompare(b)).map(([key, value]) => ({
+  key,
+  type: typeOf(value),
+  ...reveal(key, value) ? { value } : {}
+}));
+var metaOf = (options) => ({
+  title: options.title,
+  basePath: options.path,
+  openApiPath: options.openApiPath,
+  pollMs: options.pollMs,
+  queuesPath: `${options.path}/queues`
+});
+var snapshotOf = (root, options) => ({
+  meta: metaOf(options),
+  routes: routesOf(root),
+  gateways: gatewaysOf(root),
+  modules: modulesOf(root, { isGateway }),
+  providers: providersOf(root, { isGateway }),
+  config: options.config === undefined ? undefined : configEntries(options.config.values, options.reveal)
+});
+
+export { __decoratorStart, __decoratorMetadata, __runInitializers, __decorateElement, __require, metaOf, snapshotOf };
+
+//# debugId=1DCCAFB7DE81D21D64756E2164756E21
+//# sourceMappingURL=chunk-xg5554k6.js.map

package/dist/chunk-xg5554k6.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/api/snapshot.ts"],
+  "sourcesContent": [
+    "import { modulesOf, providersOf, type ModuleRef } from '@dunx/core';\nimport { gatewaysOf, isGateway, routesOf } from '@dunx/http';\nimport type { DashboardOptions } from '../options.js';\nimport type { ConfigEntry, Meta, Snapshot } from './types.js';\n\n/**\n * The static half of the page, built from the same readers `@dunx/mcp` answers\n * with. Nothing here constructs anything: `providersOf` and `routesOf` walk\n * prototypes, so this would answer identically before the app booted.\n *\n * That is the deliberate inversion of MCP's rule. MCP refuses runtime questions\n * because booting an app to answer them would open databases and bind sockets;\n * this package is *already inside* a booted app, so the reason does not apply and\n * the live panels ask the container directly. Splitting it per panel rather than\n * per package is what stops this file growing a `boot()`.\n */\n\nconst typeOf = (value: unknown): string => {\n  if (value === null) return 'null';\n  if (Array.isArray(value)) return 'array';\n  return typeof value;\n};\n\n/**\n * Keys, types, and a value only where the app's `reveal` predicate said so.\n *\n * Sorted, because a config panel is read by scanning for a key rather than in\n * declaration order, and `validate` returns whatever object literal order the app\n * happened to write.\n */\nexport const configEntries = (\n  values: object,\n  reveal: DashboardOptions['reveal'],\n): readonly ConfigEntry[] =>\n  Object.entries(values)\n    .sort(([a], [b]) => a.localeCompare(b))\n    .map(([key, value]: [string, unknown]) => ({\n      key,\n      type: typeOf(value),\n      ...(reveal(key, value) ? { value } : {}),\n    }));\n\nexport const metaOf = (options: DashboardOptions): Meta => ({\n  title: options.title,\n  basePath: options.path,\n  openApiPath: options.openApiPath,\n  pollMs: options.pollMs,\n  queuesPath: `${options.path}/queues`,\n});\n\nexport const snapshotOf = (\n  root: ModuleRef,\n  options: DashboardOptions,\n): Snapshot => ({\n  meta: metaOf(options),\n  routes: routesOf(root),\n  gateways: gatewaysOf(root),\n  // Core cannot import `@dunx/http`, so the gateway marker arrives as an option.\n  // Without it a gateway would be listed as an ordinary provider here while the\n  // gateways panel showed it as one, and the two panels would disagree.\n  modules: modulesOf(root, { isGateway }),\n  providers: providersOf(root, { isGateway }),\n  // Absent when the app passed no `config`, which the panel reports as such - a\n  // different fact from a configuration with no keys in it.\n  config:\n    options.config === undefined\n      ? undefined\n      : configEntries(options.config.values, options.reveal),\n});\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AACA;AAgBA,IAAM,SAAS,CAAC,UAA2B;AAAA,EACzC,IAAI,UAAU;AAAA,IAAM,OAAO;AAAA,EAC3B,IAAI,MAAM,QAAQ,KAAK;AAAA,IAAG,OAAO;AAAA,EACjC,OAAO,OAAO;AAAA;AAUT,IAAM,gBAAgB,CAC3B,QACA,WAEA,OAAO,QAAQ,MAAM,EAClB,KAAK,EAAE,KAAK,OAAO,EAAE,cAAc,CAAC,CAAC,EACrC,IAAI,EAAE,KAAK,YAA+B;AAAA,EACzC;AAAA,EACA,MAAM,OAAO,KAAK;AAAA,KACd,OAAO,KAAK,KAAK,IAAI,EAAE,MAAM,IAAI,CAAC;AACxC,EAAE;AAEC,IAAM,SAAS,CAAC,aAAqC;AAAA,EAC1D,OAAO,QAAQ;AAAA,EACf,UAAU,QAAQ;AAAA,EAClB,aAAa,QAAQ;AAAA,EACrB,QAAQ,QAAQ;AAAA,EAChB,YAAY,GAAG,QAAQ;AACzB;AAEO,IAAM,aAAa,CACxB,MACA,aACc;AAAA,EACd,MAAM,OAAO,OAAO;AAAA,EACpB,QAAQ,SAAS,IAAI;AAAA,EACrB,UAAU,WAAW,IAAI;AAAA,EAIzB,SAAS,UAAU,MAAM,EAAE,UAAU,CAAC;AAAA,EACtC,WAAW,YAAY,MAAM,EAAE,UAAU,CAAC;AAAA,EAG1C,QACE,QAAQ,WAAW,YACf,YACA,cAAc,QAAQ,OAAO,QAAQ,QAAQ,MAAM;AAC3D;",
+  "debugId": "1DCCAFB7DE81D21D64756E2164756E21",
+  "names": []
+}