@dudousxd/nestjs-durable-dashboard 0.22.2 → 0.22.3

package/dist/server/index.cjs

@@ -0,0 +1,695 @@
+const __importMetaUrl = require('url').pathToFileURL(__filename).href;
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/server/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DASHBOARD_API_PATH: () => DASHBOARD_API_PATH,
+  DASHBOARD_BASE_PATH: () => DASHBOARD_BASE_PATH,
+  DashboardService: () => DashboardService,
+  DurableApiController: () => DurableApiController,
+  DurableApiModule: () => DurableApiModule,
+  DurableDashboardModule: () => DurableDashboardModule,
+  DurableUiController: () => DurableUiController
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/server/dashboard.service.ts
+var import_nestjs_durable_core = require("@dudousxd/nestjs-durable-core");
+var import_common = require("@nestjs/common");
+var import_rxjs = require("rxjs");
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var DashboardService = class {
+  static {
+    __name(this, "DashboardService");
+  }
+  store;
+  engine;
+  /** Prometheus counters accumulated from engine events since boot (per process). */
+  metricsCollector;
+  constructor(store, engine) {
+    this.store = store;
+    this.engine = engine;
+    this.metricsCollector = (0, import_nestjs_durable_core.collectMetrics)(this.engine);
+  }
+  /**
+  * Prometheus-text metrics for a `/metrics` scrape: the event-counters (runs/steps by outcome,
+  * per-workflow counts) plus live **backlog gauges** queried at scrape time — `durable_pending_runs`
+  * (the dispatch backlog: the key health signal of the dispatch model) and `durable_dead_runs` (DLQ
+  * size). Capped per status so the scrape can't load an unbounded result set.
+  */
+  async metrics() {
+    const cap = 1e4;
+    const [pending, running, dead] = await Promise.all([
+      this.store.listRuns({
+        status: "pending",
+        limit: cap
+      }),
+      this.store.listRuns({
+        status: "running",
+        limit: cap
+      }),
+      this.store.listRuns({
+        status: "dead",
+        limit: cap
+      })
+    ]);
+    const gauges = [
+      "# TYPE durable_pending_runs gauge",
+      `durable_pending_runs ${pending.length}`,
+      "# TYPE durable_running_runs gauge",
+      `durable_running_runs ${running.length}`,
+      "# TYPE durable_dead_runs gauge",
+      `durable_dead_runs ${dead.length}`
+    ];
+    const health = await this.engine.workerHealth();
+    if (health.length > 0) {
+      gauges.push("# TYPE durable_group_queue_depth gauge");
+      for (const h of health) {
+        gauges.push(`durable_group_queue_depth{group="${h.group}"} ${h.depth}`);
+      }
+      gauges.push("# TYPE durable_group_live_workers gauge");
+      for (const h of health) {
+        gauges.push(`durable_group_live_workers{group="${h.group}"} ${h.liveWorkers.length}`);
+      }
+    }
+    return `${this.metricsCollector.prometheus()}${gauges.join("\n")}
+`;
+  }
+  listRuns(query) {
+    return this.store.listRuns(query);
+  }
+  /** Per-group worker health (queue backlog + live worker heartbeats) for the Workers panel. The
+  *  alert state a row turns red on is `depth > 0 && liveWorkers.length === 0`. */
+  workerHealth() {
+    return this.engine.workerHealth();
+  }
+  async getRunDetail(runId) {
+    const run = await this.store.getRun(runId);
+    if (!run) return null;
+    const [timeline, children] = await Promise.all([
+      this.store.listCheckpoints(runId),
+      this.engine.getRunChildren(runId)
+    ]);
+    return {
+      run,
+      timeline,
+      children
+    };
+  }
+  /** Fix-and-replay a dead/failed run with a corrected input — a fresh linked run. Returns its id. */
+  retryWithInput(runId, input) {
+    return this.engine.retryWithInput(runId, input);
+  }
+  /** Re-run a failed/incomplete run; completed steps replay from their checkpoints. */
+  retry(runId) {
+    return this.engine.requeue(runId);
+  }
+  cancel(runId, opts) {
+    return this.engine.cancel(runId, opts);
+  }
+  /**
+  * Apply `retry` or `cancel` to every run matching a filter (status / tag / workflow) — e.g. "retry
+  * every `dead` run tagged `type:mel`". Capped at 500 runs per call; runs that can't be acted on
+  * (already terminal) are skipped. Returns how many matched and how many the action applied to.
+  */
+  async bulk(action, filter, opts) {
+    const runs = await this.store.listRuns({
+      ...filter,
+      limit: 500
+    });
+    let applied = 0;
+    for (const r of runs) {
+      try {
+        if (action === "retry") await this.engine.requeue(r.id);
+        else await this.engine.cancel(r.id, opts);
+        applied += 1;
+      } catch {
+      }
+    }
+    return {
+      matched: runs.length,
+      applied
+    };
+  }
+  /** Resume a run paused at a `ctx.breakpoint` (the "continue" button). */
+  continue(runId) {
+    return this.engine.continue(runId);
+  }
+  /**
+  * Deliver a `ctx.webhook()` callback: turn an inbound POST (token + body) into the signal the
+  * waiting run is parked on. Returns the run result, or `null` if no run waits on that token (a
+  * stale/duplicate callback) — a safe no-op the controller maps to 404.
+  */
+  deliverWebhook(token, body) {
+    return this.engine.signal(token, body);
+  }
+  /** Side-effect-free read of a value a run published via `ctx.setEvent` (a live query). */
+  getEvent(runId, key) {
+    return this.engine.getEvent(runId, key);
+  }
+  /** Deliver a validated `ctx.onUpdate` to a run; the validator may reject it (see UpdateResult). */
+  update(runId, name, arg) {
+    return this.engine.update(runId, name, arg);
+  }
+  /**
+  * Live stream of a run's lifecycle events for SSE. Backed by `engine.subscribe`, which — when the
+  * transport has a control plane — receives events from EVERY instance, so a dashboard-only pod
+  * tails a run executing on a worker pod. Without a control plane it only sees same-process events.
+  */
+  streamRun(runId) {
+    return new import_rxjs.Observable((subscriber) => {
+      const off = this.engine.subscribe((event) => {
+        if (event.runId === runId) subscriber.next({
+          data: event
+        });
+      });
+      return () => off();
+    });
+  }
+};
+DashboardService = _ts_decorate([
+  (0, import_common.Injectable)(),
+  _ts_param(0, (0, import_common.Inject)(import_nestjs_durable_core.STATE_STORE)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof StateStore === "undefined" ? Object : StateStore,
+    typeof import_nestjs_durable_core.WorkflowEngine === "undefined" ? Object : import_nestjs_durable_core.WorkflowEngine
+  ])
+], DashboardService);
+
+// src/server/durable-api.controller.ts
+var import_common2 = require("@nestjs/common");
+
+// src/server/attr-filter.ts
+var ATTR_OPS = /* @__PURE__ */ new Set([
+  "eq",
+  "ne",
+  "gt",
+  "gte",
+  "lt",
+  "lte"
+]);
+function coerce(v) {
+  if (v === "true") return true;
+  if (v === "false") return false;
+  if (v !== "" && !Number.isNaN(Number(v))) return Number(v);
+  return v;
+}
+__name(coerce, "coerce");
+function parseAttrFilters(attr) {
+  if (!attr) return void 0;
+  const raw = Array.isArray(attr) ? attr : [
+    attr
+  ];
+  const filters = [];
+  for (const entry of raw) {
+    const [key, op, ...rest] = entry.split(":");
+    if (!key || !ATTR_OPS.has(op) || rest.length === 0) continue;
+    filters.push({
+      key,
+      op,
+      value: coerce(rest.join(":"))
+    });
+  }
+  return filters.length ? filters : void 0;
+}
+__name(parseAttrFilters, "parseAttrFilters");
+
+// src/server/durable-api.controller.ts
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
+var DurableApiController = class {
+  static {
+    __name(this, "DurableApiController");
+  }
+  dashboard;
+  constructor(dashboard) {
+    this.dashboard = dashboard;
+  }
+  runs(status, workflow, tag, attr) {
+    return this.dashboard.listRuns({
+      status,
+      workflow,
+      tag,
+      attributes: parseAttrFilters(attr)
+    });
+  }
+  /** Prometheus-text metrics (runs/steps by outcome, per-workflow counts) for a scrape. */
+  metrics() {
+    return this.dashboard.metrics();
+  }
+  /** Per-group worker health (queue backlog + live worker heartbeats) for the Workers panel. */
+  workers() {
+    return this.dashboard.workerHealth();
+  }
+  async run(id) {
+    const detail = await this.dashboard.getRunDetail(id);
+    if (!detail) throw new import_common2.NotFoundException(`run ${id} not found`);
+    return detail;
+  }
+  /** Server-Sent Events stream of a run's live lifecycle events — the dashboard tails it instead
+  *  of polling. Cross-pod when the transport has a control plane (see DashboardService.streamRun). */
+  stream(id) {
+    return this.dashboard.streamRun(id);
+  }
+  retry(id) {
+    return this.dashboard.retry(id);
+  }
+  /** Fix-and-replay: re-run a dead/failed run with a corrected input (a fresh linked run). */
+  retryWithInput(id, body) {
+    return this.dashboard.retryWithInput(id, body?.input);
+  }
+  /** Bulk retry/cancel every run matching a filter (status / tag / workflow). */
+  bulk(action, status, tag, workflow, attr, compensate) {
+    return this.dashboard.bulk(action === "cancel" ? "cancel" : "retry", {
+      status,
+      tag,
+      workflow,
+      attributes: parseAttrFilters(attr)
+    }, {
+      compensate: compensate === "true"
+    });
+  }
+  async cancel(id, compensate) {
+    const result = await this.dashboard.cancel(id, {
+      compensate: compensate === "true"
+    });
+    if (!result) throw new import_common2.NotFoundException(`run ${id} not found`);
+    return result;
+  }
+  async continue(id) {
+    const result = await this.dashboard.continue(id);
+    if (!result) throw new import_common2.NotFoundException(`run ${id} is not paused at a breakpoint`);
+    return result;
+  }
+  /**
+  * Public callback endpoint for `ctx.webhook()`: a third party POSTs here (the url handed to it),
+  * and the body resumes the waiting run. NOTE: this is reachable by external systems — protect it
+  * by treating the token as a secret (it embeds runId:seq) and/or fronting it with signature
+  * verification in your own middleware.
+  */
+  async webhook(token, body) {
+    const result = await this.dashboard.deliverWebhook(token, body);
+    if (!result) throw new import_common2.NotFoundException(`no run is waiting on webhook ${token}`);
+    return result;
+  }
+  /** Live query: the latest value a run published for `key` via `ctx.setEvent` (no side effect). */
+  event(id, key) {
+    return this.dashboard.getEvent(id, key);
+  }
+  /** Deliver a validated `ctx.onUpdate` to a run; the body is the update argument. */
+  update(id, name, body) {
+    return this.dashboard.update(id, name, body);
+  }
+};
+_ts_decorate2([
+  (0, import_common2.Get)("runs"),
+  _ts_param2(0, (0, import_common2.Query)("status")),
+  _ts_param2(1, (0, import_common2.Query)("workflow")),
+  _ts_param2(2, (0, import_common2.Query)("tag")),
+  _ts_param2(3, (0, import_common2.Query)("attr")),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof RunStatus === "undefined" ? Object : RunStatus,
+    String,
+    String,
+    Object
+  ]),
+  _ts_metadata2("design:returntype", void 0)
+], DurableApiController.prototype, "runs", null);
+_ts_decorate2([
+  (0, import_common2.Get)("metrics"),
+  (0, import_common2.Header)("Content-Type", "text/plain; version=0.0.4"),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", []),
+  _ts_metadata2("design:returntype", void 0)
+], DurableApiController.prototype, "metrics", null);
+_ts_decorate2([
+  (0, import_common2.Get)("workers"),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", []),
+  _ts_metadata2("design:returntype", void 0)
+], DurableApiController.prototype, "workers", null);
+_ts_decorate2([
+  (0, import_common2.Get)("runs/:id"),
+  _ts_param2(0, (0, import_common2.Param)("id")),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata2("design:returntype", Promise)
+], DurableApiController.prototype, "run", null);
+_ts_decorate2([
+  (0, import_common2.Sse)("runs/:id/stream"),
+  _ts_param2(0, (0, import_common2.Param)("id")),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata2("design:returntype", void 0)
+], DurableApiController.prototype, "stream", null);
+_ts_decorate2([
+  (0, import_common2.Post)("runs/:id/retry"),
+  _ts_param2(0, (0, import_common2.Param)("id")),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata2("design:returntype", void 0)
+], DurableApiController.prototype, "retry", null);
+_ts_decorate2([
+  (0, import_common2.Post)("runs/:id/retry-with-input"),
+  _ts_param2(0, (0, import_common2.Param)("id")),
+  _ts_param2(1, (0, import_common2.Body)()),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    String,
+    Object
+  ]),
+  _ts_metadata2("design:returntype", void 0)
+], DurableApiController.prototype, "retryWithInput", null);
+_ts_decorate2([
+  (0, import_common2.Post)("bulk/:action"),
+  _ts_param2(0, (0, import_common2.Param)("action")),
+  _ts_param2(1, (0, import_common2.Query)("status")),
+  _ts_param2(2, (0, import_common2.Query)("tag")),
+  _ts_param2(3, (0, import_common2.Query)("workflow")),
+  _ts_param2(4, (0, import_common2.Query)("attr")),
+  _ts_param2(5, (0, import_common2.Query)("compensate")),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    String,
+    typeof RunStatus === "undefined" ? Object : RunStatus,
+    String,
+    String,
+    Object,
+    String
+  ]),
+  _ts_metadata2("design:returntype", void 0)
+], DurableApiController.prototype, "bulk", null);
+_ts_decorate2([
+  (0, import_common2.Post)("runs/:id/cancel"),
+  _ts_param2(0, (0, import_common2.Param)("id")),
+  _ts_param2(1, (0, import_common2.Query)("compensate")),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    String,
+    String
+  ]),
+  _ts_metadata2("design:returntype", Promise)
+], DurableApiController.prototype, "cancel", null);
+_ts_decorate2([
+  (0, import_common2.Post)("runs/:id/continue"),
+  _ts_param2(0, (0, import_common2.Param)("id")),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata2("design:returntype", Promise)
+], DurableApiController.prototype, "continue", null);
+_ts_decorate2([
+  (0, import_common2.Post)("webhooks/:token"),
+  _ts_param2(0, (0, import_common2.Param)("token")),
+  _ts_param2(1, (0, import_common2.Body)()),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    String,
+    Object
+  ]),
+  _ts_metadata2("design:returntype", Promise)
+], DurableApiController.prototype, "webhook", null);
+_ts_decorate2([
+  (0, import_common2.Get)("runs/:id/events/:key"),
+  _ts_param2(0, (0, import_common2.Param)("id")),
+  _ts_param2(1, (0, import_common2.Param)("key")),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    String,
+    String
+  ]),
+  _ts_metadata2("design:returntype", void 0)
+], DurableApiController.prototype, "event", null);
+_ts_decorate2([
+  (0, import_common2.Post)("runs/:id/updates/:name"),
+  _ts_param2(0, (0, import_common2.Param)("id")),
+  _ts_param2(1, (0, import_common2.Param)("name")),
+  _ts_param2(2, (0, import_common2.Body)()),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    String,
+    String,
+    Object
+  ]),
+  _ts_metadata2("design:returntype", void 0)
+], DurableApiController.prototype, "update", null);
+DurableApiController = _ts_decorate2([
+  (0, import_common2.Controller)(),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof DashboardService === "undefined" ? Object : DashboardService
+  ])
+], DurableApiController);
+
+// src/server/durable-dashboard.module.ts
+var import_common4 = require("@nestjs/common");
+var import_core = require("@nestjs/core");
+
+// src/server/durable-ui.controller.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_node_url = require("url");
+var import_common3 = require("@nestjs/common");
+function _ts_decorate3(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate3, "_ts_decorate");
+function _ts_metadata3(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata3, "_ts_metadata");
+function _ts_param3(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param3, "_ts_param");
+var DASHBOARD_BASE_PATH = Symbol("DASHBOARD_BASE_PATH");
+var DASHBOARD_API_PATH = Symbol("DASHBOARD_API_PATH");
+var BUILD_BASE = "/durable";
+function spaDir() {
+  return (0, import_node_url.fileURLToPath)(new URL("../spa", __importMetaUrl));
+}
+__name(spaDir, "spaDir");
+var CONTENT_TYPES = {
+  ".js": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".map": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".json": "application/json; charset=utf-8",
+  ".woff2": "font/woff2",
+  ".ico": "image/x-icon"
+};
+var DurableUiController = class {
+  static {
+    __name(this, "DurableUiController");
+  }
+  basePath;
+  apiBasePath;
+  dir = spaDir();
+  constructor(basePath, apiBasePath) {
+    this.basePath = basePath;
+    this.apiBasePath = apiBasePath;
+  }
+  // index.html references hash-named bundles, so it MUST NOT be cached (stale bundle = the
+  // classic "stuck loading after a deploy"). The hashed assets below are immutable.
+  index() {
+    const indexPath = (0, import_node_path.join)(this.dir, "index.html");
+    if (!(0, import_node_fs.existsSync)(indexPath)) {
+      throw new import_common3.NotFoundException("Dashboard is not built. Run the package build.");
+    }
+    const html = (0, import_node_fs.readFileSync)(indexPath, "utf8").replaceAll(`="${BUILD_BASE}/`, `="${this.basePath}/`);
+    const inject = `<script>window.__DURABLE_BASE__='${this.basePath}';window.__DURABLE_API__='${this.apiBasePath}';</script>`;
+    return html.includes("</head>") ? html.replace("</head>", `${inject}</head>`) : inject + html;
+  }
+  asset(file) {
+    const safe = (0, import_node_path.basename)(file);
+    if (safe !== file) throw new import_common3.NotFoundException();
+    const root = (0, import_node_path.resolve)(this.dir, "assets");
+    const assetPath = (0, import_node_path.resolve)(root, safe);
+    if (!assetPath.startsWith(root + import_node_path.sep) || !(0, import_node_fs.existsSync)(assetPath)) {
+      throw new import_common3.NotFoundException();
+    }
+    const type = CONTENT_TYPES[(0, import_node_path.extname)(safe)] ?? "application/octet-stream";
+    return new import_common3.StreamableFile((0, import_node_fs.readFileSync)(assetPath), {
+      type
+    });
+  }
+};
+_ts_decorate3([
+  (0, import_common3.Get)(),
+  (0, import_common3.Header)("Content-Type", "text/html; charset=utf-8"),
+  (0, import_common3.Header)("Cache-Control", "no-store, must-revalidate"),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", []),
+  _ts_metadata3("design:returntype", String)
+], DurableUiController.prototype, "index", null);
+_ts_decorate3([
+  (0, import_common3.Get)("assets/:file"),
+  (0, import_common3.Header)("Cache-Control", "public, max-age=31536000, immutable"),
+  _ts_param3(0, (0, import_common3.Param)("file")),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata3("design:returntype", typeof import_common3.StreamableFile === "undefined" ? Object : import_common3.StreamableFile)
+], DurableUiController.prototype, "asset", null);
+DurableUiController = _ts_decorate3([
+  (0, import_common3.Controller)(),
+  _ts_param3(0, (0, import_common3.Inject)(DASHBOARD_BASE_PATH)),
+  _ts_param3(1, (0, import_common3.Inject)(DASHBOARD_API_PATH)),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    String,
+    String
+  ])
+], DurableUiController);
+
+// src/server/durable-dashboard.module.ts
+function _ts_decorate4(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate4, "_ts_decorate");
+function normalize(path) {
+  return `/${path.replace(/^\/+|\/+$/g, "")}`;
+}
+__name(normalize, "normalize");
+var DurableApiModule = class {
+  static {
+    __name(this, "DurableApiModule");
+  }
+};
+DurableApiModule = _ts_decorate4([
+  (0, import_common4.Module)({
+    controllers: [
+      DurableApiController
+    ],
+    providers: [
+      DashboardService
+    ],
+    exports: [
+      DashboardService
+    ]
+  })
+], DurableApiModule);
+var DurableDashboardModule = class _DurableDashboardModule {
+  static {
+    __name(this, "DurableDashboardModule");
+  }
+  static forRoot(options = {}) {
+    const basePath = normalize(options.basePath ?? "/durable");
+    const apiBasePath = normalize(options.apiBasePath ?? `${basePath}/api`);
+    return {
+      module: _DurableDashboardModule,
+      imports: [
+        DurableApiModule,
+        import_core.RouterModule.register([
+          {
+            path: basePath,
+            module: _DurableDashboardModule
+          },
+          {
+            path: apiBasePath,
+            module: DurableApiModule
+          }
+        ])
+      ],
+      controllers: [
+        DurableUiController
+      ],
+      providers: [
+        {
+          provide: DASHBOARD_BASE_PATH,
+          useValue: basePath
+        },
+        {
+          provide: DASHBOARD_API_PATH,
+          useValue: apiBasePath
+        }
+      ],
+      // Re-export the API module so its DashboardService reaches importers (e.g. flip's own controllers).
+      exports: [
+        DurableApiModule
+      ]
+    };
+  }
+};
+DurableDashboardModule = _ts_decorate4([
+  (0, import_common4.Module)({})
+], DurableDashboardModule);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DASHBOARD_API_PATH,
+  DASHBOARD_BASE_PATH,
+  DashboardService,
+  DurableApiController,
+  DurableApiModule,
+  DurableDashboardModule,
+  DurableUiController
+});
+//# sourceMappingURL=index.cjs.map