@dudousxd/nestjs-durable-dashboard 0.22.2 → 0.22.4

package/dist/server/index.js

@@ -1,5 +1,663 @@
-export * from './dashboard.service.js';
-export * from './durable-api.controller.js';
-export * from './durable-dashboard.module.js';
-export * from './durable-ui.controller.js';
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/server/dashboard.service.ts
+import { STATE_STORE_CANONICAL, WorkflowEngine, collectMetrics } from "@dudousxd/nestjs-durable-core";
+import { Inject, Injectable } from "@nestjs/common";
+import { Observable } from "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 = 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 Observable((subscriber) => {
+      const off = this.engine.subscribe((event) => {
+        if (event.runId === runId) subscriber.next({
+          data: event
+        });
+      });
+      return () => off();
+    });
+  }
+};
+DashboardService = _ts_decorate([
+  Injectable(),
+  _ts_param(0, Inject(STATE_STORE_CANONICAL)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof StateStore === "undefined" ? Object : StateStore,
+    typeof WorkflowEngine === "undefined" ? Object : WorkflowEngine
+  ])
+], DashboardService);
+
+// src/server/durable-api.controller.ts
+import { Body, Controller, Get, Header, NotFoundException, Param, Post, Query, Sse } from "@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 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 NotFoundException(`run ${id} not found`);
+    return result;
+  }
+  async continue(id) {
+    const result = await this.dashboard.continue(id);
+    if (!result) throw new 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 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([
+  Get("runs"),
+  _ts_param2(0, Query("status")),
+  _ts_param2(1, Query("workflow")),
+  _ts_param2(2, Query("tag")),
+  _ts_param2(3, 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([
+  Get("metrics"),
+  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([
+  Get("workers"),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", []),
+  _ts_metadata2("design:returntype", void 0)
+], DurableApiController.prototype, "workers", null);
+_ts_decorate2([
+  Get("runs/:id"),
+  _ts_param2(0, Param("id")),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata2("design:returntype", Promise)
+], DurableApiController.prototype, "run", null);
+_ts_decorate2([
+  Sse("runs/:id/stream"),
+  _ts_param2(0, Param("id")),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata2("design:returntype", void 0)
+], DurableApiController.prototype, "stream", null);
+_ts_decorate2([
+  Post("runs/:id/retry"),
+  _ts_param2(0, Param("id")),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata2("design:returntype", void 0)
+], DurableApiController.prototype, "retry", null);
+_ts_decorate2([
+  Post("runs/:id/retry-with-input"),
+  _ts_param2(0, Param("id")),
+  _ts_param2(1, Body()),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    String,
+    Object
+  ]),
+  _ts_metadata2("design:returntype", void 0)
+], DurableApiController.prototype, "retryWithInput", null);
+_ts_decorate2([
+  Post("bulk/:action"),
+  _ts_param2(0, Param("action")),
+  _ts_param2(1, Query("status")),
+  _ts_param2(2, Query("tag")),
+  _ts_param2(3, Query("workflow")),
+  _ts_param2(4, Query("attr")),
+  _ts_param2(5, 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([
+  Post("runs/:id/cancel"),
+  _ts_param2(0, Param("id")),
+  _ts_param2(1, Query("compensate")),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    String,
+    String
+  ]),
+  _ts_metadata2("design:returntype", Promise)
+], DurableApiController.prototype, "cancel", null);
+_ts_decorate2([
+  Post("runs/:id/continue"),
+  _ts_param2(0, Param("id")),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata2("design:returntype", Promise)
+], DurableApiController.prototype, "continue", null);
+_ts_decorate2([
+  Post("webhooks/:token"),
+  _ts_param2(0, Param("token")),
+  _ts_param2(1, Body()),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    String,
+    Object
+  ]),
+  _ts_metadata2("design:returntype", Promise)
+], DurableApiController.prototype, "webhook", null);
+_ts_decorate2([
+  Get("runs/:id/events/:key"),
+  _ts_param2(0, Param("id")),
+  _ts_param2(1, 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([
+  Post("runs/:id/updates/:name"),
+  _ts_param2(0, Param("id")),
+  _ts_param2(1, Param("name")),
+  _ts_param2(2, 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([
+  Controller(),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof DashboardService === "undefined" ? Object : DashboardService
+  ])
+], DurableApiController);
+
+// src/server/durable-dashboard.module.ts
+import { Module } from "@nestjs/common";
+import { RouterModule } from "@nestjs/core";
+
+// src/server/durable-ui.controller.ts
+import { existsSync, readFileSync } from "node:fs";
+import { basename, extname, join, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Controller as Controller2, Get as Get2, Header as Header2, Inject as Inject2, NotFoundException as NotFoundException2, Param as Param2, StreamableFile } from "@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 fileURLToPath(new URL("../spa", import.meta.url));
+}
+__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 = join(this.dir, "index.html");
+    if (!existsSync(indexPath)) {
+      throw new NotFoundException2("Dashboard is not built. Run the package build.");
+    }
+    const html = 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 = basename(file);
+    if (safe !== file) throw new NotFoundException2();
+    const root = resolve(this.dir, "assets");
+    const assetPath = resolve(root, safe);
+    if (!assetPath.startsWith(root + sep) || !existsSync(assetPath)) {
+      throw new NotFoundException2();
+    }
+    const type = CONTENT_TYPES[extname(safe)] ?? "application/octet-stream";
+    return new StreamableFile(readFileSync(assetPath), {
+      type
+    });
+  }
+};
+_ts_decorate3([
+  Get2(),
+  Header2("Content-Type", "text/html; charset=utf-8"),
+  Header2("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([
+  Get2("assets/:file"),
+  Header2("Cache-Control", "public, max-age=31536000, immutable"),
+  _ts_param3(0, Param2("file")),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata3("design:returntype", typeof StreamableFile === "undefined" ? Object : StreamableFile)
+], DurableUiController.prototype, "asset", null);
+DurableUiController = _ts_decorate3([
+  Controller2(),
+  _ts_param3(0, Inject2(DASHBOARD_BASE_PATH)),
+  _ts_param3(1, Inject2(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([
+  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,
+        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([
+  Module({})
+], DurableDashboardModule);
+export {
+  DASHBOARD_API_PATH,
+  DASHBOARD_BASE_PATH,
+  DashboardService,
+  DurableApiController,
+  DurableApiModule,
+  DurableDashboardModule,
+  DurableUiController
+};
 //# sourceMappingURL=index.js.map