@dudousxd/nestjs-durable-dashboard 0.43.2 → 0.45.0

package/dist/server/index.cjs

@@ -140,6 +140,12 @@ var DashboardService = class {
   runFacets(query) {
     return this.gateway.runFacets(query);
   }
+  /** The distinct values of one filter axis over the same predicates — what fills the console's
+  *  tenant/tag/attribute pickers, so an operator picks a value that exists instead of typing one
+  *  blind. `[]` when the store cannot enumerate them; the pickers then fall back to free text. */
+  runValueFacets(axis, query, opts) {
+    return this.gateway.runValueFacets(axis, query, opts);
+  }
   /** This deployment's durable role (control plane vs tenant) + tenant name — for the dashboard header
   *  badge. Routes through the gateway, which knows its own topology (store-backed = operator, proxy =
   *  tenant). Works on both topologies (no store/engine needed). */
@@ -248,10 +254,95 @@ DashboardService = _ts_decorate([
 ], DashboardService);
 
 // src/server/durable-api.controller.ts
-var import_common2 = require("@nestjs/common");
+var import_nestjs_filter2 = require("@dudousxd/nestjs-filter");
+var import_common4 = require("@nestjs/common");
+
+// src/server/durable-run.ts
+var DurableRun = class {
+  static {
+    __name(this, "DurableRun");
+  }
+  workflow;
+  status;
+  /** `null` for a run no package claims — see `WorkflowRun.origin`. */
+  origin;
+  /** Tenant / worker-pool partition. */
+  namespace;
+  /**
+  * ONE of the run's tags. Singular deliberately: a run carries a SET of tags, so a predicate here
+  * asks about membership (`tag in [etl, nightly]` = runs carrying either), never equality with the
+  * whole set.
+  */
+  tag;
+  /** Typed search attributes, addressed per key as `attr.<key>` — a JSON sub-path, not a column. */
+  attr;
+};
+var ATTRIBUTE_FIELD = "attr";
+var DURABLE_RUN_FIELDS = [
+  {
+    name: "workflow",
+    columnName: "workflow",
+    type: "string"
+  },
+  {
+    name: "status",
+    columnName: "status",
+    type: "string"
+  },
+  {
+    name: "origin",
+    columnName: "origin",
+    type: "string"
+  },
+  {
+    name: "namespace",
+    columnName: "namespace",
+    type: "string"
+  },
+  {
+    name: "tag",
+    columnName: "tags",
+    type: "string"
+  },
+  {
+    name: ATTRIBUTE_FIELD,
+    columnName: "search_attributes",
+    type: "json"
+  }
+];
+function runValueAxisFor(field) {
+  if (field === ATTRIBUTE_FIELD) return {
+    field: "attributeKey"
+  };
+  if (field.startsWith(`${ATTRIBUTE_FIELD}.`)) {
+    const key = field.slice(ATTRIBUTE_FIELD.length + 1);
+    return key ? {
+      field: "attributeValue",
+      key
+    } : null;
+  }
+  if (field === "workflow" || field === "status" || field === "origin" || field === "namespace" || field === "tag") {
+    return {
+      field
+    };
+  }
+  return null;
+}
+__name(runValueAxisFor, "runValueAxisFor");
+
+// src/server/run-list-row.ts
+function toRunListRow(run) {
+  const { input: _input, output: _output, error: _error, ...row } = run;
+  return row;
+}
+__name(toRunListRow, "toRunListRow");
+
+// src/server/run.filter.ts
+var import_nestjs_filter = require("@dudousxd/nestjs-filter");
+var import_common3 = require("@nestjs/common");
 
 // src/server/attr-filter.ts
-var ATTR_OPS = /* @__PURE__ */ new Set([
+var SCALAR_OPS = /* @__PURE__ */ new Set([
   "eq",
   "ne",
   "gt",
@@ -259,6 +350,7 @@ var ATTR_OPS = /* @__PURE__ */ new Set([
   "lt",
   "lte"
 ]);
+var IN_SEPARATOR = "|";
 function coerce(v) {
   if (v === "true") return true;
   if (v === "false") return false;
@@ -274,25 +366,60 @@ function parseAttrFilters(attr) {
   const filters = [];
   for (const entry of raw) {
     const [key, op, ...rest] = entry.split(":");
-    if (!key || !ATTR_OPS.has(op) || rest.length === 0) continue;
+    if (!key || rest.length === 0) continue;
+    const operand = rest.join(":");
+    if (op === "in") {
+      const values = operand.split(IN_SEPARATOR).filter(Boolean).map(coerce);
+      if (values.length) filters.push({
+        key,
+        op: "in",
+        values
+      });
+      continue;
+    }
+    if (!SCALAR_OPS.has(op)) continue;
     filters.push({
       key,
       op,
-      value: coerce(rest.join(":"))
+      value: coerce(operand)
     });
   }
   return filters.length ? filters : void 0;
 }
 __name(parseAttrFilters, "parseAttrFilters");
 
-// src/server/run-list-row.ts
-function toRunListRow(run) {
-  const { input: _input, output: _output, error: _error, ...row } = run;
-  return row;
-}
-__name(toRunListRow, "toRunListRow");
+// src/server/run-query.adapter.ts
+var import_nestjs_durable_core2 = require("@dudousxd/nestjs-durable-core");
+var import_common2 = require("@nestjs/common");
 
-// src/server/durable-api.controller.ts
+// src/server/run-query-draft.ts
+var RunQueryDraft2 = class {
+  static {
+    __name(this, "RunQueryDraft");
+  }
+  query = {};
+  /** Narrow by one or more predicates. Later calls overwrite the same field — the runner applies one
+  *  clause per field, so the last one wins, exactly as a repeated `where` on a builder would. */
+  narrow(patch) {
+    Object.assign(this.query, patch);
+  }
+  /** Add one search-attribute predicate. These ACCUMULATE (unlike {@link narrow}) because
+  *  `RunQuery.attributes` is an ANDed list — two predicates on different keys are both meant. */
+  attribute(filter) {
+    this.query.attributes = [
+      ...this.query.attributes ?? [],
+      filter
+    ];
+  }
+  /** The predicates minus the page window and the axes a facet count reports on — what
+  *  `runFacets`/`runValueFacets` are taken over. */
+  facetQuery() {
+    const { status, statuses, origin, origins, limit, offset, ...facetQuery } = this.query;
+    return facetQuery;
+  }
+};
+
+// src/server/run-query.adapter.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);
@@ -304,73 +431,527 @@ function _ts_metadata2(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 __name(_ts_metadata2, "_ts_metadata");
+var RUN_QUERY_ADAPTER = Symbol("DURABLE_RUN_QUERY_ADAPTER");
+var FIXED_ORDER = {
+  field: "createdAt",
+  direction: "desc"
+};
+function coerce2(value) {
+  if (typeof value === "number" || typeof value === "boolean") return value;
+  const raw = String(value);
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  if (raw !== "" && !Number.isNaN(Number(raw))) return Number(raw);
+  return raw;
+}
+__name(coerce2, "coerce");
+function operands(clause) {
+  return Array.isArray(clause.value) ? clause.value : [
+    clause.value
+  ];
+}
+__name(operands, "operands");
+function unsupported(clause, supported) {
+  throw new import_common2.BadRequestException(`The durable run list cannot filter \`${clause.field}\` with \`${clause.operator}\`. Supported here: ${supported}.`);
+}
+__name(unsupported, "unsupported");
+var RunQueryAdapter = class {
+  static {
+    __name(this, "RunQueryAdapter");
+  }
+  gateway;
+  constructor(gateway) {
+    this.gateway = gateway;
+  }
+  createQueryBuilder(entity) {
+    this.assertDurableRun(entity);
+    return new RunQueryDraft2();
+  }
+  getEntityFields(entity) {
+    return entity === DurableRun ? DURABLE_RUN_FIELDS : null;
+  }
+  /** No relations: a run is a flat row here, and the one nested-looking address (`attr.<key>`) is a
+  *  JSON path. Returning `[]` (not null) tells the runner the answer is "none", not "can't say". */
+  getEntityRelations() {
+    return [];
+  }
+  /**
+  * Which addresses resolve, and as what. `attr` and `attr.<key>` are JSON paths — that classification
+  * is what routes a flat `?attr.tier=pro` through the same translation as a structured
+  * `where[attr.tier]`, instead of it being dropped as an unknown key.
+  */
+  resolveFieldPath(entity, path) {
+    if (entity !== DurableRun) return null;
+    if (path === ATTRIBUTE_FIELD || path.startsWith(`${ATTRIBUTE_FIELD}.`)) return "json";
+    return DURABLE_RUN_FIELDS.some((f) => f.name === path) ? "field" : null;
+  }
+  applyColumnFilters(qb, filters, entity) {
+    if (entity) this.assertDurableRun(entity);
+    const draft = this.draft(qb);
+    for (const clause of filters) {
+      if (clause.AND || clause.OR) {
+        throw new import_common2.BadRequestException("The durable run list cannot filter with nested AND/OR groups: its predicates are a flat conjunction.");
+      }
+      this.applyClause(draft, clause);
+    }
+  }
+  applyClause(draft, clause) {
+    const { field, operator } = clause;
+    if (field === ATTRIBUTE_FIELD || field.startsWith(`${ATTRIBUTE_FIELD}.`)) {
+      this.applyAttributeClause(draft, clause);
+      return;
+    }
+    const anyOf = operator === "in" || operator === "isAnyOf";
+    switch (field) {
+      case "status":
+        if (operator === "equals") {
+          draft.narrow({
+            status: String(clause.value)
+          });
+        } else if (anyOf) {
+          draft.narrow({
+            statuses: operands(clause).map((v) => String(v))
+          });
+        } else {
+          unsupported(clause, "equals, in");
+        }
+        return;
+      case "workflow":
+        if (operator === "equals") {
+          draft.narrow({
+            workflow: String(clause.value)
+          });
+        } else if (anyOf) {
+          draft.narrow({
+            workflows: operands(clause).map(String)
+          });
+        } else {
+          unsupported(clause, "equals, in");
+        }
+        return;
+      case "namespace":
+        if (operator === "equals") {
+          draft.narrow({
+            namespace: String(clause.value)
+          });
+        } else if (anyOf) {
+          draft.narrow({
+            namespaces: operands(clause).map(String)
+          });
+        } else {
+          unsupported(clause, "equals, in");
+        }
+        return;
+      case "tag":
+        if (operator === "equals") {
+          draft.narrow({
+            tag: String(clause.value)
+          });
+        } else if (anyOf) {
+          draft.narrow({
+            tags: operands(clause).map(String)
+          });
+        } else {
+          unsupported(clause, "equals, in");
+        }
+        return;
+      case "origin":
+        if (operator === "isNull") {
+          draft.narrow({
+            origin: null
+          });
+        } else if (operator === "equals") {
+          draft.narrow({
+            origin: clause.value === null ? null : String(clause.value)
+          });
+        } else if (anyOf) {
+          draft.narrow({
+            origins: operands(clause).map((v) => v === null ? null : String(v))
+          });
+        } else {
+          unsupported(clause, "equals, in, isNull");
+        }
+        return;
+      default:
+        unsupported(clause, `one of ${DURABLE_RUN_FIELDS.map((f) => f.name).join(", ")}`);
+    }
+  }
+  /** `attr.<key>` → one {@link AttributeFilter}. The operator set is the store's, so the mapping is
+  *  1:1 and anything outside it is rejected rather than approximated. */
+  applyAttributeClause(draft, clause) {
+    const key = clause.field.slice(ATTRIBUTE_FIELD.length + 1);
+    if (!key) {
+      throw new import_common2.BadRequestException("Filtering search attributes needs a key: `attr.<key>`, e.g. `attr.tier`.");
+    }
+    const scalarOps = {
+      equals: "eq",
+      notEquals: "ne",
+      gt: "gt",
+      gte: "gte",
+      lt: "lt",
+      lte: "lte"
+    };
+    const scalar = scalarOps[clause.operator];
+    if (scalar) {
+      draft.attribute({
+        key,
+        op: scalar,
+        value: coerce2(clause.value)
+      });
+      return;
+    }
+    if (clause.operator === "in" || clause.operator === "isAnyOf") {
+      draft.attribute({
+        key,
+        op: "in",
+        values: operands(clause).map(coerce2)
+      });
+      return;
+    }
+    unsupported(clause, "equals, notEquals, gt, gte, lt, lte, in");
+  }
+  applyOffsetPagination(qb, page2, size) {
+    this.draft(qb).narrow({
+      limit: size,
+      offset: (page2 - 1) * size
+    });
+  }
+  /**
+  * A run listing has ONE order — newest first — because that is what every store adapter's
+  * `listRuns` emits and what the console's paging depends on. A request for any other sort is
+  * refused rather than accepted and ignored: silently returning a differently-ordered page is how a
+  * paginated list starts duplicating and skipping rows.
+  */
+  applySort(_qb, sorts) {
+    for (const sort of sorts) {
+      if (sort.field !== FIXED_ORDER.field || sort.direction !== FIXED_ORDER.direction) {
+        throw new import_common2.BadRequestException(`The durable run list is always ordered \`${FIXED_ORDER.field} ${FIXED_ORDER.direction}\` and cannot be sorted by \`${sort.field} ${sort.direction}\`.`);
+      }
+    }
+  }
+  getResult(qb) {
+    return this.gateway.listRuns(this.draft(qb).query);
+  }
+  /**
+  * A page plus the size of the whole matching set. The total comes from the facet aggregate rather
+  * than from a second listing — that is the entire reason durable exposes one, and it keeps the
+  * count exact while the page stays bounded.
+  */
+  async getResultAndCount(qb) {
+    const draft = this.draft(qb);
+    const [rows, facets] = await Promise.all([
+      this.gateway.listRuns(draft.query),
+      this.gateway.runFacets(draft.facetQuery())
+    ]);
+    const { status, statuses, origin, origins } = draft.query;
+    const total = facets.filter((cell) => {
+      if (status && cell.status !== status) return false;
+      if (statuses && !statuses.includes(cell.status)) return false;
+      if (origin !== void 0 && cell.origin !== origin) return false;
+      if (origins && !origins.includes(cell.origin)) return false;
+      return true;
+    }).reduce((sum, cell) => sum + cell.count, 0);
+    return {
+      rows,
+      total
+    };
+  }
+  /**
+  * The distinct values of one field over the runs the active predicates select — the console's
+  * pickers. `limit` is honoured because it has to be: tag and search-attribute cardinality grows
+  * with the data, so the unbounded answer is a listing rather than an aggregate.
+  */
+  async groupByCount(qb, field, entity, opts) {
+    this.assertDurableRun(entity);
+    if (typeof field !== "string") {
+      throw new import_common2.BadRequestException("The durable run list has no computed fields to group by \u2014 group by one of its own fields.");
+    }
+    if (opts?.bucket !== void 0) {
+      throw new import_common2.BadRequestException("The durable run list cannot bucket a group-by-count: none of its filterable fields is numeric.");
+    }
+    const axis = runValueAxisFor(field);
+    if (!axis) {
+      throw new import_common2.BadRequestException(`The durable run list cannot enumerate values of \`${field}\`.`);
+    }
+    const rows = await this.gateway.runValueFacets(axis, this.draft(qb).facetQuery(), {
+      limit: opts?.limit ?? import_nestjs_durable_core2.RUN_VALUE_FACET_LIMIT
+    });
+    return rows.map((row) => ({
+      value: row.value,
+      count: row.count
+    }));
+  }
+  getPrimaryKey() {
+    return "id";
+  }
+  draft(qb) {
+    if (!(qb instanceof RunQueryDraft2)) {
+      throw new Error("The durable run adapter was handed a query builder it did not create. A filter using it must declare `@Filterable({ entity: DurableRun, adapter: RUN_QUERY_ADAPTER })`.");
+    }
+    return qb;
+  }
+  assertDurableRun(entity) {
+    if (entity !== DurableRun) {
+      throw new Error(`The durable run adapter only answers for DurableRun, not ${entity?.name ?? String(entity)}.`);
+    }
+  }
+};
+RunQueryAdapter = _ts_decorate2([
+  (0, import_common2.Injectable)(),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof import_nestjs_durable_core2.RunGateway === "undefined" ? Object : import_nestjs_durable_core2.RunGateway
+  ])
+], RunQueryAdapter);
+
+// src/server/run.filter.ts
+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 list(value) {
+  return (Array.isArray(value) ? value : [
+    value
+  ]).filter((v) => v !== void 0 && v !== null && v !== "").map(String);
+}
+__name(list, "list");
+function bound(value) {
+  const n = Number(value);
+  return value !== void 0 && value !== "" && Number.isInteger(n) && n >= 0 ? n : void 0;
+}
+__name(bound, "bound");
+var RunFilter = class extends import_nestjs_filter.BaseFilter {
+  static {
+    __name(this, "RunFilter");
+  }
+  /** One status narrows; several match ANY of them — how a caller asks for a SET (the console's
+  *  in-flight sibling query, for one). */
+  applyStatus(value) {
+    const values = list(value);
+    if (values.length === 0) return;
+    this.$query.narrow(values.length === 1 ? {
+      status: values[0]
+    } : {
+      statuses: values
+    });
+  }
+  applyWorkflow(value) {
+    const values = list(value);
+    if (values.length === 0) return;
+    this.$query.narrow(values.length === 1 ? {
+      workflow: values[0]
+    } : {
+      workflows: values
+    });
+  }
+  /** A blank param (`?namespace=`, from a cleared filter box) is the same as an absent one; passing
+  *  `''` through would be an exact match on a tenant nobody has, i.e. a silently empty console. */
+  applyNamespace(value) {
+    const values = list(value);
+    if (values.length === 0) return;
+    this.$query.narrow(values.length === 1 ? {
+      namespace: values[0]
+    } : {
+      namespaces: values
+    });
+  }
+  applyTag(value) {
+    const values = list(value);
+    if (values.length === 0) return;
+    this.$query.narrow(values.length === 1 ? {
+      tag: values[0]
+    } : {
+      tags: values
+    });
+  }
+  /**
+  * Origin has THREE states rather than two — a named package, the unattributed bucket, or no
+  * restriction — and the bucket rides on its own `unattributed` param rather than on a reserved
+  * `origin` value, because any reserved string is a package name someone can legitimately have and a
+  * console that quietly reinterpreted it would show the wrong runs.
+  *
+  * Both keys resolve through one function, called from either, reading the RAW input each time:
+  * the answer depends on both params, and `@FilterFor` dispatch follows the order the client's keys
+  * happen to arrive in. Recomputing from the input makes the result the same either way, where
+  * accumulating onto the draft would make `?origin=x&unattributed=true` mean different things
+  * depending on key order.
+  *
+  * Sent together they are a UNION, not a contradiction: `origins` carries the absent bucket
+  * alongside named packages, which is the "this package plus the runs nothing claims" view that a
+  * single `origin` value cannot express at all.
+  */
+  applyOrigin() {
+    this.resolveOrigin();
+  }
+  applyUnattributed() {
+    this.resolveOrigin();
+  }
+  resolveOrigin() {
+    const named = list(this.$input.origin);
+    const raw = this.$input.unattributed;
+    const wantsUnattributed = raw === "true" || raw === "1" || raw === true;
+    const values = [
+      ...named,
+      ...wantsUnattributed ? [
+        null
+      ] : []
+    ];
+    if (values.length === 0) return;
+    if (values.length === 1) {
+      const only = values[0];
+      this.$query.narrow({
+        origin: only
+      });
+      return;
+    }
+    this.$query.narrow({
+      origins: values
+    });
+  }
+  /** Comma/repeat-separated `key:op:value` predicates (e.g. `amount:gte:200`), ANDed. The structured
+  *  spelling of the same thing is `filter[where][attr.amount][gte]=200`. */
+  applyAttributes(value) {
+    for (const filter of parseAttrFilters(value) ?? []) {
+      this.$query.attribute(filter);
+    }
+  }
+  applyLimit(value) {
+    const limit = bound(value);
+    if (limit !== void 0) this.$query.narrow({
+      limit
+    });
+  }
+  applyOffset(value) {
+    const offset = bound(value);
+    if (offset !== void 0) this.$query.narrow({
+      offset
+    });
+  }
+};
+_ts_decorate3([
+  (0, import_nestjs_filter.FilterFor)("status"),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    Object
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], RunFilter.prototype, "applyStatus", null);
+_ts_decorate3([
+  (0, import_nestjs_filter.FilterFor)("workflow"),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    Object
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], RunFilter.prototype, "applyWorkflow", null);
+_ts_decorate3([
+  (0, import_nestjs_filter.FilterFor)("namespace"),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    Object
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], RunFilter.prototype, "applyNamespace", null);
+_ts_decorate3([
+  (0, import_nestjs_filter.FilterFor)("tag"),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    Object
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], RunFilter.prototype, "applyTag", null);
+_ts_decorate3([
+  (0, import_nestjs_filter.FilterFor)("origin"),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", []),
+  _ts_metadata3("design:returntype", void 0)
+], RunFilter.prototype, "applyOrigin", null);
+_ts_decorate3([
+  (0, import_nestjs_filter.FilterFor)("unattributed"),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", []),
+  _ts_metadata3("design:returntype", void 0)
+], RunFilter.prototype, "applyUnattributed", null);
+_ts_decorate3([
+  (0, import_nestjs_filter.FilterFor)("attr"),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    Object
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], RunFilter.prototype, "applyAttributes", null);
+_ts_decorate3([
+  (0, import_nestjs_filter.FilterFor)("limit"),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    Object
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], RunFilter.prototype, "applyLimit", null);
+_ts_decorate3([
+  (0, import_nestjs_filter.FilterFor)("offset"),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    Object
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], RunFilter.prototype, "applyOffset", null);
+RunFilter = _ts_decorate3([
+  (0, import_common3.Injectable)(),
+  (0, import_nestjs_filter.Filterable)({
+    entity: DurableRun,
+    adapter: RUN_QUERY_ADAPTER,
+    autoFields: false
+  })
+], RunFilter);
+
+// src/server/durable-api.controller.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 _ts_metadata4(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata4, "_ts_metadata");
 function _ts_param2(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
 __name(_ts_param2, "_ts_param");
-function pageBounds(limit, offset) {
-  const bound = /* @__PURE__ */ __name((raw) => {
-    const n = Number(raw);
-    return raw !== void 0 && raw !== "" && Number.isInteger(n) && n >= 0 ? n : void 0;
-  }, "bound");
-  const l = bound(limit);
-  const o = bound(offset);
-  return {
-    ...l !== void 0 ? {
-      limit: l
-    } : {},
-    ...o !== void 0 ? {
-      offset: o
-    } : {}
-  };
-}
-__name(pageBounds, "pageBounds");
-function statusPredicate(status) {
-  if (Array.isArray(status)) return status.length ? {
-    statuses: status
-  } : {};
-  return status ? {
-    status
-  } : {};
-}
-__name(statusPredicate, "statusPredicate");
-function originPredicate(origin, unattributed) {
-  if (unattributed === "true" || unattributed === "1") return {
-    origin: null
-  };
-  return origin ? {
-    origin
-  } : {};
-}
-__name(originPredicate, "originPredicate");
 var DurableApiController = class {
   static {
     __name(this, "DurableApiController");
   }
   dashboard;
-  constructor(dashboard) {
+  runner;
+  constructor(dashboard, runner) {
     this.dashboard = dashboard;
+    this.runner = runner;
   }
   /**
-  * The run list, filtered by whatever the operator asked for. Every predicate is OPTIONAL and an
-  * omitted one means "don't narrow on this axis" — in particular `namespace`, whose absence keeps
-  * the historical, deliberate behaviour that read paths are NOT namespace-scoped (core,
-  * `WorkflowRun.namespace`): the console shows every tenant's runs until an operator chooses one.
-  * A blank param (`?namespace=`, from a cleared filter box) is the same as an absent one; passing
-  * `''` through would be an exact match on a tenant nobody has, i.e. a silently empty console.
+  * The run list, filtered by whatever the operator asked for.
+  *
+  * The predicates are parsed, validated and translated by `@dudousxd/nestjs-filter` (see
+  * `RunFilter` for the two spellings it accepts, and `RunQueryAdapter` for how they become a
+  * `RunQuery`). Every predicate is OPTIONAL and an omitted one means "don't narrow on this axis" —
+  * in particular `namespace`, whose absence keeps the historical, deliberate behaviour that read
+  * paths are NOT namespace-scoped (core, `WorkflowRun.namespace`): the console shows every tenant's
+  * runs until an operator chooses one.
   */
-  async runs(status, workflow, tag, attr, namespace, origin, unattributed, limit, offset) {
-    const runs = await this.dashboard.listRuns({
-      ...statusPredicate(status),
-      workflow,
-      tag,
-      attributes: parseAttrFilters(attr),
-      namespace: namespace || void 0,
-      ...originPredicate(origin, unattributed),
-      ...pageBounds(limit, offset)
-    });
+  async runs(draft) {
+    const runs = await this.dashboard.listRuns(draft.query);
     return runs.map(toRunListRow);
   }
   /**
@@ -378,15 +959,28 @@ var DurableApiController = class {
   * `GET runs`. This is what lets that listing be PAGED at all: the page bounds what the console
   * renders, this bounds nothing and keeps its status and origin chips exact.
   *
-  * `status`, `origin` and the page bounds are deliberately NOT accepted — they are the axes being
-  * counted, so narrowing by them would report the answer back to itself.
+  * `status`, `origin` and the page bounds are accepted (the route takes the same filter) but
+  * deliberately DROPPED before counting — they are the axes being counted, so narrowing by them
+  * would report the answer back to itself.
+  */
+  facets(draft) {
+    return this.dashboard.runFacets(draft.facetQuery());
+  }
+  /**
+  * The distinct values one filter field takes across the runs matching every OTHER active
+  * predicate, with counts — what the console's tenant/tag/attribute pickers list.
+  *
+  * `?groupByCount[field]=tag&groupByCount[limit]=20`, with the filters in the structured
+  * `filter[where][...]` form (what `filterQuery()` builds). Scoping the values to the active
+  * filters is the point: picking a tenant leaves the tag picker offering only that tenant's tags,
+  * so a picker never offers a value whose result set is empty.
+  *
+  * `limit` matters rather than being a nicety — tag and attribute cardinality grows with the data
+  * (a `singleton:<key>` tag is minted per key), so the unbounded answer is a listing.
   */
-  facets(workflow, tag, attr, namespace) {
-    return this.dashboard.runFacets({
-      workflow,
-      tag,
-      attributes: parseAttrFilters(attr),
-      namespace: namespace || void 0
+  values(query) {
+    return this.runner.groupByCount(DurableRun, query, {
+      filterClass: RunFilter
     });
   }
   /** Prometheus-text metrics (runs/steps by outcome, per-workflow counts) for a scrape. */
@@ -403,7 +997,7 @@ var DurableApiController = class {
   }
   async run(id) {
     const detail = await this.dashboard.getRunDetail(id);
-    if (!detail) throw new import_common2.NotFoundException(`run ${id} not found`);
+    if (!detail) throw new import_common4.NotFoundException(`run ${id} not found`);
     return detail;
   }
   /** Server-Sent Events stream of a run's live lifecycle events — the dashboard tails it instead
@@ -423,18 +1017,9 @@ var DurableApiController = class {
   * The filter takes the SAME params as `GET runs` and is parsed identically, so "retry all" acts on
   * exactly the set the operator was looking at rather than a wider one.
   */
-  bulk(action, status, tag, workflow, attr, compensate, namespace, origin, unattributed) {
-    return this.dashboard.bulk(action === "cancel" ? "cancel" : "retry", {
-      status,
-      tag,
-      workflow,
-      attributes: parseAttrFilters(attr),
-      namespace: namespace || void 0,
-      // The unattributed bucket is a scope a console can actually SELECT, so a bulk action launched
-      // under it must be narrowed to it. Dropping the param would widen a retry/cancel to every
-      // origin — acting on runs the operator was not looking at.
-      ...originPredicate(origin, unattributed)
-    }, {
+  bulk(action, draft, compensate) {
+    const { limit, offset, ...filter } = draft.query;
+    return this.dashboard.bulk(action === "cancel" ? "cancel" : "retry", filter, {
       compensate: compensate === "true"
     });
   }
@@ -442,18 +1027,18 @@ var DurableApiController = class {
     const result = await this.dashboard.cancel(id, {
       compensate: compensate === "true"
     });
-    if (!result) throw new import_common2.NotFoundException(`run ${id} not found`);
+    if (!result) throw new import_common4.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`);
+    if (!result) throw new import_common4.NotFoundException(`run ${id} is not paused at a breakpoint`);
     return result;
   }
   /** Re-dispatch a run's stuck `pending` remote steps — recovery for a lost step dispatch. */
   async redispatch(id) {
     const result = await this.dashboard.redispatch(id);
-    if (!result) throw new import_common2.NotFoundException(`run ${id} not found`);
+    if (!result) throw new import_common4.NotFoundException(`run ${id} not found`);
     return result;
   }
   /**
@@ -464,7 +1049,7 @@ var DurableApiController = class {
   */
   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}`);
+    if (!result) throw new import_common4.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). */
@@ -476,202 +1061,179 @@ var DurableApiController = class {
     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_param2(4, (0, import_common2.Query)("namespace")),
-  _ts_param2(5, (0, import_common2.Query)("origin")),
-  _ts_param2(6, (0, import_common2.Query)("unattributed")),
-  _ts_param2(7, (0, import_common2.Query)("limit")),
-  _ts_param2(8, (0, import_common2.Query)("offset")),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", [
-    Object,
-    String,
-    String,
-    Object,
-    String,
-    String,
-    String,
-    String,
-    String
+_ts_decorate4([
+  (0, import_common4.Get)("runs"),
+  _ts_param2(0, (0, import_nestjs_filter2.ApplyFilter)(RunFilter)),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    typeof RunQueryDraft === "undefined" ? Object : RunQueryDraft
   ]),
-  _ts_metadata2("design:returntype", Promise)
+  _ts_metadata4("design:returntype", Promise)
 ], DurableApiController.prototype, "runs", null);
-_ts_decorate2([
-  (0, import_common2.Get)("runs/facets"),
-  _ts_param2(0, (0, import_common2.Query)("workflow")),
-  _ts_param2(1, (0, import_common2.Query)("tag")),
-  _ts_param2(2, (0, import_common2.Query)("attr")),
-  _ts_param2(3, (0, import_common2.Query)("namespace")),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", [
-    String,
-    String,
-    Object,
-    String
+_ts_decorate4([
+  (0, import_common4.Get)("runs/facets"),
+  _ts_param2(0, (0, import_nestjs_filter2.ApplyFilter)(RunFilter)),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    typeof RunQueryDraft === "undefined" ? Object : RunQueryDraft
   ]),
-  _ts_metadata2("design:returntype", void 0)
+  _ts_metadata4("design:returntype", void 0)
 ], DurableApiController.prototype, "facets", 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)
+_ts_decorate4([
+  (0, import_common4.Get)("runs/values"),
+  _ts_param2(0, (0, import_common4.Query)()),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    typeof Record === "undefined" ? Object : Record
+  ]),
+  _ts_metadata4("design:returntype", void 0)
+], DurableApiController.prototype, "values", null);
+_ts_decorate4([
+  (0, import_common4.Get)("metrics"),
+  (0, import_common4.Header)("Content-Type", "text/plain; version=0.0.4"),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", []),
+  _ts_metadata4("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)
+_ts_decorate4([
+  (0, import_common4.Get)("workers"),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", []),
+  _ts_metadata4("design:returntype", void 0)
 ], DurableApiController.prototype, "workers", null);
-_ts_decorate2([
-  (0, import_common2.Get)("topology"),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", []),
-  _ts_metadata2("design:returntype", void 0)
+_ts_decorate4([
+  (0, import_common4.Get)("topology"),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", []),
+  _ts_metadata4("design:returntype", void 0)
 ], DurableApiController.prototype, "topology", 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", [
+_ts_decorate4([
+  (0, import_common4.Get)("runs/:id"),
+  _ts_param2(0, (0, import_common4.Param)("id")),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
     String
   ]),
-  _ts_metadata2("design:returntype", Promise)
+  _ts_metadata4("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", [
+_ts_decorate4([
+  (0, import_common4.Sse)("runs/:id/stream"),
+  _ts_param2(0, (0, import_common4.Param)("id")),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
     String
   ]),
-  _ts_metadata2("design:returntype", void 0)
+  _ts_metadata4("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", [
+_ts_decorate4([
+  (0, import_common4.Post)("runs/:id/retry"),
+  _ts_param2(0, (0, import_common4.Param)("id")),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
     String
   ]),
-  _ts_metadata2("design:returntype", void 0)
+  _ts_metadata4("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", [
+_ts_decorate4([
+  (0, import_common4.Post)("runs/:id/retry-with-input"),
+  _ts_param2(0, (0, import_common4.Param)("id")),
+  _ts_param2(1, (0, import_common4.Body)()),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
     String,
     Object
   ]),
-  _ts_metadata2("design:returntype", void 0)
+  _ts_metadata4("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_param2(6, (0, import_common2.Query)("namespace")),
-  _ts_param2(7, (0, import_common2.Query)("origin")),
-  _ts_param2(8, (0, import_common2.Query)("unattributed")),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", [
-    String,
-    typeof RunStatus === "undefined" ? Object : RunStatus,
-    String,
-    String,
-    Object,
-    String,
-    String,
+_ts_decorate4([
+  (0, import_common4.Post)("bulk/:action"),
+  _ts_param2(0, (0, import_common4.Param)("action")),
+  _ts_param2(1, (0, import_nestjs_filter2.ApplyFilter)(RunFilter)),
+  _ts_param2(2, (0, import_common4.Query)("compensate")),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
     String,
+    typeof RunQueryDraft === "undefined" ? Object : RunQueryDraft,
     String
   ]),
-  _ts_metadata2("design:returntype", void 0)
+  _ts_metadata4("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", [
+_ts_decorate4([
+  (0, import_common4.Post)("runs/:id/cancel"),
+  _ts_param2(0, (0, import_common4.Param)("id")),
+  _ts_param2(1, (0, import_common4.Query)("compensate")),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
     String,
     String
   ]),
-  _ts_metadata2("design:returntype", Promise)
+  _ts_metadata4("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", [
+_ts_decorate4([
+  (0, import_common4.Post)("runs/:id/continue"),
+  _ts_param2(0, (0, import_common4.Param)("id")),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
     String
   ]),
-  _ts_metadata2("design:returntype", Promise)
+  _ts_metadata4("design:returntype", Promise)
 ], DurableApiController.prototype, "continue", null);
-_ts_decorate2([
-  (0, import_common2.Post)("runs/:id/redispatch"),
-  _ts_param2(0, (0, import_common2.Param)("id")),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", [
+_ts_decorate4([
+  (0, import_common4.Post)("runs/:id/redispatch"),
+  _ts_param2(0, (0, import_common4.Param)("id")),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
     String
   ]),
-  _ts_metadata2("design:returntype", Promise)
+  _ts_metadata4("design:returntype", Promise)
 ], DurableApiController.prototype, "redispatch", 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", [
+_ts_decorate4([
+  (0, import_common4.Post)("webhooks/:token"),
+  _ts_param2(0, (0, import_common4.Param)("token")),
+  _ts_param2(1, (0, import_common4.Body)()),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
     String,
     Object
   ]),
-  _ts_metadata2("design:returntype", Promise)
+  _ts_metadata4("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", [
+_ts_decorate4([
+  (0, import_common4.Get)("runs/:id/events/:key"),
+  _ts_param2(0, (0, import_common4.Param)("id")),
+  _ts_param2(1, (0, import_common4.Param)("key")),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
     String,
     String
   ]),
-  _ts_metadata2("design:returntype", void 0)
+  _ts_metadata4("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", [
+_ts_decorate4([
+  (0, import_common4.Post)("runs/:id/updates/:name"),
+  _ts_param2(0, (0, import_common4.Param)("id")),
+  _ts_param2(1, (0, import_common4.Param)("name")),
+  _ts_param2(2, (0, import_common4.Body)()),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
     String,
     String,
     Object
   ]),
-  _ts_metadata2("design:returntype", void 0)
+  _ts_metadata4("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 = _ts_decorate4([
+  (0, import_common4.Controller)(),
+  (0, import_common4.UseInterceptors)(import_nestjs_filter2.ApplyFilterInterceptor),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    typeof DashboardService === "undefined" ? Object : DashboardService,
+    typeof import_nestjs_filter2.FilterRunner === "undefined" ? Object : import_nestjs_filter2.FilterRunner
   ])
 ], DurableApiController);
 
 // src/server/durable-auth.controller.ts
-var import_common6 = require("@nestjs/common");
+var import_common8 = require("@nestjs/common");
 
 // src/server/auth/dashboard-auth-config.ts
 var DASHBOARD_AUTH = Symbol("DASHBOARD_AUTH");
@@ -1223,18 +1785,18 @@ __name(maybeRenewSession, "maybeRenewSession");
 var import_node_fs = require("fs");
 var import_node_path = require("path");
 var import_node_url = require("url");
-var import_common5 = require("@nestjs/common");
+var import_common7 = require("@nestjs/common");
 
 // src/server/auth/login-redirect.exception.ts
-var import_common3 = require("@nestjs/common");
-function _ts_decorate3(decorators, target, key, desc) {
+var import_common5 = require("@nestjs/common");
+function _ts_decorate5(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");
-var DashboardLoginRedirectException = class extends import_common3.HttpException {
+__name(_ts_decorate5, "_ts_decorate");
+var DashboardLoginRedirectException = class extends import_common5.HttpException {
   static {
     __name(this, "DashboardLoginRedirectException");
   }
@@ -1242,7 +1804,7 @@ var DashboardLoginRedirectException = class extends import_common3.HttpException
   constructor(location) {
     super({
       location
-    }, import_common3.HttpStatus.FOUND), this.location = location;
+    }, import_common5.HttpStatus.FOUND), this.location = location;
   }
 };
 var DashboardLoginRedirectFilter = class {
@@ -1254,30 +1816,30 @@ var DashboardLoginRedirectFilter = class {
     redirectRaw(response, exception.location);
   }
 };
-DashboardLoginRedirectFilter = _ts_decorate3([
-  (0, import_common3.Catch)(DashboardLoginRedirectException)
+DashboardLoginRedirectFilter = _ts_decorate5([
+  (0, import_common5.Catch)(DashboardLoginRedirectException)
 ], DashboardLoginRedirectFilter);
 
 // src/server/auth/session-required.exception.ts
-var import_common4 = require("@nestjs/common");
-function _ts_decorate4(decorators, target, key, desc) {
+var import_common6 = require("@nestjs/common");
+function _ts_decorate6(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 _ts_metadata3(k, v) {
+__name(_ts_decorate6, "_ts_decorate");
+function _ts_metadata5(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata3, "_ts_metadata");
+__name(_ts_metadata5, "_ts_metadata");
 function _ts_param3(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
 __name(_ts_param3, "_ts_param");
-var DashboardSessionRequiredException = class extends import_common4.HttpException {
+var DashboardSessionRequiredException = class extends import_common6.HttpException {
   static {
     __name(this, "DashboardSessionRequiredException");
   }
@@ -1285,7 +1847,7 @@ var DashboardSessionRequiredException = class extends import_common4.HttpExcepti
   constructor(basePath) {
     super({
       basePath
-    }, import_common4.HttpStatus.UNAUTHORIZED), this.basePath = basePath;
+    }, import_common6.HttpStatus.UNAUTHORIZED), this.basePath = basePath;
   }
 };
 var DashboardSessionRequiredFilter = class _DashboardSessionRequiredFilter {
@@ -1293,7 +1855,7 @@ var DashboardSessionRequiredFilter = class _DashboardSessionRequiredFilter {
     __name(this, "DashboardSessionRequiredFilter");
   }
   auth;
-  logger = new import_common4.Logger(_DashboardSessionRequiredFilter.name);
+  logger = new import_common6.Logger(_DashboardSessionRequiredFilter.name);
   warned = false;
   constructor(auth = null) {
     this.auth = auth;
@@ -1316,7 +1878,7 @@ var DashboardSessionRequiredFilter = class _DashboardSessionRequiredFilter {
         if (responseAlreadyWritten(response)) return;
       }
     }
-    writeHtmlRaw(response, renderSessionRequiredPage(exception.basePath), import_common4.HttpStatus.UNAUTHORIZED);
+    writeHtmlRaw(response, renderSessionRequiredPage(exception.basePath), import_common6.HttpStatus.UNAUTHORIZED);
   }
   /** Once per process, not once per request: a broken hook fires on every denied navigation. */
   warnOnce(message) {
@@ -1325,28 +1887,28 @@ var DashboardSessionRequiredFilter = class _DashboardSessionRequiredFilter {
     this.logger.warn(message);
   }
 };
-DashboardSessionRequiredFilter = _ts_decorate4([
-  (0, import_common4.Catch)(DashboardSessionRequiredException),
-  _ts_param3(0, (0, import_common4.Optional)()),
-  _ts_param3(0, (0, import_common4.Inject)(DASHBOARD_AUTH)),
-  _ts_metadata3("design:type", Function),
-  _ts_metadata3("design:paramtypes", [
+DashboardSessionRequiredFilter = _ts_decorate6([
+  (0, import_common6.Catch)(DashboardSessionRequiredException),
+  _ts_param3(0, (0, import_common6.Optional)()),
+  _ts_param3(0, (0, import_common6.Inject)(DASHBOARD_AUTH)),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
     Object
   ])
 ], DashboardSessionRequiredFilter);
 
 // src/server/durable-ui.controller.ts
-function _ts_decorate5(decorators, target, key, desc) {
+function _ts_decorate7(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_decorate5, "_ts_decorate");
-function _ts_metadata4(k, v) {
+__name(_ts_decorate7, "_ts_decorate");
+function _ts_metadata6(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata4, "_ts_metadata");
+__name(_ts_metadata6, "_ts_metadata");
 function _ts_param4(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -1385,7 +1947,7 @@ var DurableUiController = class {
   index() {
     const indexPath = (0, import_node_path.join)(this.dir, "index.html");
     if (!(0, import_node_fs.existsSync)(indexPath)) {
-      throw new import_common5.NotFoundException("Dashboard is not built. Run the package build.");
+      throw new import_common7.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>`;
@@ -1393,60 +1955,60 @@ var DurableUiController = class {
   }
   asset(file) {
     const safe = (0, import_node_path.basename)(file);
-    if (safe !== file) throw new import_common5.NotFoundException();
+    if (safe !== file) throw new import_common7.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_common5.NotFoundException();
+      throw new import_common7.NotFoundException();
     }
     const type = CONTENT_TYPES[(0, import_node_path.extname)(safe)] ?? "application/octet-stream";
-    return new import_common5.StreamableFile((0, import_node_fs.readFileSync)(assetPath), {
+    return new import_common7.StreamableFile((0, import_node_fs.readFileSync)(assetPath), {
       type
     });
   }
 };
-_ts_decorate5([
-  (0, import_common5.Get)(),
-  (0, import_common5.Header)("Content-Type", "text/html; charset=utf-8"),
-  (0, import_common5.Header)("Cache-Control", "no-store, must-revalidate"),
-  _ts_metadata4("design:type", Function),
-  _ts_metadata4("design:paramtypes", []),
-  _ts_metadata4("design:returntype", String)
+_ts_decorate7([
+  (0, import_common7.Get)(),
+  (0, import_common7.Header)("Content-Type", "text/html; charset=utf-8"),
+  (0, import_common7.Header)("Cache-Control", "no-store, must-revalidate"),
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", []),
+  _ts_metadata6("design:returntype", String)
 ], DurableUiController.prototype, "index", null);
-_ts_decorate5([
-  (0, import_common5.Get)("assets/:file"),
-  (0, import_common5.Header)("Cache-Control", "public, max-age=31536000, immutable"),
-  _ts_param4(0, (0, import_common5.Param)("file")),
-  _ts_metadata4("design:type", Function),
-  _ts_metadata4("design:paramtypes", [
+_ts_decorate7([
+  (0, import_common7.Get)("assets/:file"),
+  (0, import_common7.Header)("Cache-Control", "public, max-age=31536000, immutable"),
+  _ts_param4(0, (0, import_common7.Param)("file")),
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", [
     String
   ]),
-  _ts_metadata4("design:returntype", typeof import_common5.StreamableFile === "undefined" ? Object : import_common5.StreamableFile)
+  _ts_metadata6("design:returntype", typeof import_common7.StreamableFile === "undefined" ? Object : import_common7.StreamableFile)
 ], DurableUiController.prototype, "asset", null);
-DurableUiController = _ts_decorate5([
-  (0, import_common5.UseFilters)(DashboardLoginRedirectFilter, DashboardSessionRequiredFilter),
-  (0, import_common5.Controller)(),
-  _ts_param4(0, (0, import_common5.Inject)(DASHBOARD_BASE_PATH)),
-  _ts_param4(1, (0, import_common5.Inject)(DASHBOARD_API_PATH)),
-  _ts_metadata4("design:type", Function),
-  _ts_metadata4("design:paramtypes", [
+DurableUiController = _ts_decorate7([
+  (0, import_common7.UseFilters)(DashboardLoginRedirectFilter, DashboardSessionRequiredFilter),
+  (0, import_common7.Controller)(),
+  _ts_param4(0, (0, import_common7.Inject)(DASHBOARD_BASE_PATH)),
+  _ts_param4(1, (0, import_common7.Inject)(DASHBOARD_API_PATH)),
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", [
     String,
     String
   ])
 ], DurableUiController);
 
 // src/server/durable-auth.controller.ts
-function _ts_decorate6(decorators, target, key, desc) {
+function _ts_decorate8(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_decorate6, "_ts_decorate");
-function _ts_metadata5(k, v) {
+__name(_ts_decorate8, "_ts_decorate");
+function _ts_metadata7(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata5, "_ts_metadata");
+__name(_ts_metadata7, "_ts_metadata");
 function _ts_param5(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -1463,7 +2025,7 @@ var DurableAuthController = class _DurableAuthController {
   }
   auth;
   basePath;
-  logger = new import_common6.Logger(_DurableAuthController.name);
+  logger = new import_common8.Logger(_DurableAuthController.name);
   /** Warn once per hook kind so a throwing hook doesn't spam logs on every failed attempt. */
   warnedHooks = /* @__PURE__ */ new Set();
   constructor(auth, basePath) {
@@ -1475,7 +2037,7 @@ var DurableAuthController = class _DurableAuthController {
   // the developer-controlled `basePath`.
   loginPage() {
     const auth = this.requireAuth();
-    if (!auth.modes.includes("login")) throw new import_common6.NotFoundException();
+    if (!auth.modes.includes("login")) throw new import_common8.NotFoundException();
     return renderLoginPage(this.basePath);
   }
   // Called by the login page's own fetch (JSON, not a classic form POST — see `login-page.ts` for
@@ -1484,13 +2046,13 @@ var DurableAuthController = class _DurableAuthController {
   // (unknown user, wrong password, throwing hook) — no user-enumeration.
   async login(body, request, response) {
     const auth = this.requireAuth();
-    if (!auth.modes.includes("login")) throw new import_common6.NotFoundException();
+    if (!auth.modes.includes("login")) throw new import_common8.NotFoundException();
     if (!isString(body?.username) || !isString(body?.password)) {
-      throw new import_common6.BadRequestException("Body must include string `username` and `password`.");
+      throw new import_common8.BadRequestException("Body must include string `username` and `password`.");
     }
     const { username, password } = body;
     const user = await this.runHook("login", () => auth.login?.(username, password) ?? null);
-    if (!user) throw new import_common6.UnauthorizedException({
+    if (!user) throw new import_common8.UnauthorizedException({
       message: "Invalid username or password."
     });
     issueSessionCookie(user, {
@@ -1507,9 +2069,9 @@ var DurableAuthController = class _DurableAuthController {
   // guard decides, and no credential ever reaches this library.
   async session(request, response) {
     const auth = this.requireAuth();
-    if (!auth.modes.includes("session")) throw new import_common6.NotFoundException();
+    if (!auth.modes.includes("session")) throw new import_common8.NotFoundException();
     const user = await this.runHook("session", () => auth.session?.(request) ?? null);
-    if (!user) throw new import_common6.UnauthorizedException();
+    if (!user) throw new import_common8.UnauthorizedException();
     issueSessionCookie(user, {
       auth,
       request,
@@ -1528,7 +2090,7 @@ var DurableAuthController = class _DurableAuthController {
     redirectRaw(response, this.auth?.modes.includes("login") ? `${this.basePath}/login` : this.basePath);
   }
   requireAuth() {
-    if (!this.auth) throw new import_common6.NotFoundException();
+    if (!this.auth) throw new import_common8.NotFoundException();
     return this.auth;
   }
   /**
@@ -1548,62 +2110,62 @@ var DurableAuthController = class _DurableAuthController {
     }
   }
 };
-_ts_decorate6([
-  (0, import_common6.Get)("login"),
-  (0, import_common6.Header)("Content-Type", "text/html; charset=utf-8"),
-  (0, import_common6.Header)("Cache-Control", "no-store, must-revalidate"),
-  _ts_metadata5("design:type", Function),
-  _ts_metadata5("design:paramtypes", []),
-  _ts_metadata5("design:returntype", String)
+_ts_decorate8([
+  (0, import_common8.Get)("login"),
+  (0, import_common8.Header)("Content-Type", "text/html; charset=utf-8"),
+  (0, import_common8.Header)("Cache-Control", "no-store, must-revalidate"),
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", []),
+  _ts_metadata7("design:returntype", String)
 ], DurableAuthController.prototype, "loginPage", null);
-_ts_decorate6([
-  (0, import_common6.Post)("login"),
-  (0, import_common6.HttpCode)(200),
-  _ts_param5(0, (0, import_common6.Body)()),
-  _ts_param5(1, (0, import_common6.Req)()),
-  _ts_param5(2, (0, import_common6.Res)({
+_ts_decorate8([
+  (0, import_common8.Post)("login"),
+  (0, import_common8.HttpCode)(200),
+  _ts_param5(0, (0, import_common8.Body)()),
+  _ts_param5(1, (0, import_common8.Req)()),
+  _ts_param5(2, (0, import_common8.Res)({
     passthrough: true
   })),
-  _ts_metadata5("design:type", Function),
-  _ts_metadata5("design:paramtypes", [
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", [
     typeof LoginBody === "undefined" ? Object : LoginBody,
     Object,
     Object
   ]),
-  _ts_metadata5("design:returntype", Promise)
+  _ts_metadata7("design:returntype", Promise)
 ], DurableAuthController.prototype, "login", null);
-_ts_decorate6([
-  (0, import_common6.Post)("session"),
-  (0, import_common6.HttpCode)(204),
-  _ts_param5(0, (0, import_common6.Req)()),
-  _ts_param5(1, (0, import_common6.Res)({
+_ts_decorate8([
+  (0, import_common8.Post)("session"),
+  (0, import_common8.HttpCode)(204),
+  _ts_param5(0, (0, import_common8.Req)()),
+  _ts_param5(1, (0, import_common8.Res)({
     passthrough: true
   })),
-  _ts_metadata5("design:type", Function),
-  _ts_metadata5("design:paramtypes", [
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", [
     Object,
     Object
   ]),
-  _ts_metadata5("design:returntype", Promise)
+  _ts_metadata7("design:returntype", Promise)
 ], DurableAuthController.prototype, "session", null);
-_ts_decorate6([
-  (0, import_common6.Get)("logout"),
-  _ts_param5(0, (0, import_common6.Req)()),
-  _ts_param5(1, (0, import_common6.Res)()),
-  _ts_metadata5("design:type", Function),
-  _ts_metadata5("design:paramtypes", [
+_ts_decorate8([
+  (0, import_common8.Get)("logout"),
+  _ts_param5(0, (0, import_common8.Req)()),
+  _ts_param5(1, (0, import_common8.Res)()),
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", [
     Object,
     Object
   ]),
-  _ts_metadata5("design:returntype", void 0)
+  _ts_metadata7("design:returntype", void 0)
 ], DurableAuthController.prototype, "logout", null);
-DurableAuthController = _ts_decorate6([
-  (0, import_common6.Controller)(),
-  _ts_param5(0, (0, import_common6.Optional)()),
-  _ts_param5(0, (0, import_common6.Inject)(DASHBOARD_AUTH)),
-  _ts_param5(1, (0, import_common6.Inject)(DASHBOARD_BASE_PATH)),
-  _ts_metadata5("design:type", Function),
-  _ts_metadata5("design:paramtypes", [
+DurableAuthController = _ts_decorate8([
+  (0, import_common8.Controller)(),
+  _ts_param5(0, (0, import_common8.Optional)()),
+  _ts_param5(0, (0, import_common8.Inject)(DASHBOARD_AUTH)),
+  _ts_param5(1, (0, import_common8.Inject)(DASHBOARD_BASE_PATH)),
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", [
     Object,
     String
   ])
@@ -1611,22 +2173,23 @@ DurableAuthController = _ts_decorate6([
 
 // src/server/durable-dashboard.module.ts
 var import_reflect_metadata = require("reflect-metadata");
-var import_common8 = require("@nestjs/common");
+var import_nestjs_filter3 = require("@dudousxd/nestjs-filter");
+var import_common10 = require("@nestjs/common");
 var import_core = require("@nestjs/core");
 
 // src/server/durable-session.guard.ts
-var import_common7 = require("@nestjs/common");
-function _ts_decorate7(decorators, target, key, desc) {
+var import_common9 = require("@nestjs/common");
+function _ts_decorate9(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_decorate7, "_ts_decorate");
-function _ts_metadata6(k, v) {
+__name(_ts_decorate9, "_ts_decorate");
+function _ts_metadata8(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata6, "_ts_metadata");
+__name(_ts_metadata8, "_ts_metadata");
 function _ts_param6(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -1673,12 +2236,12 @@ var DurableUiSessionGuard = class {
     throw new DashboardLoginRedirectException(`${this.basePath}/login?returnTo=${returnTo}`);
   }
 };
-DurableUiSessionGuard = _ts_decorate7([
-  (0, import_common7.Injectable)(),
-  _ts_param6(0, (0, import_common7.Inject)(DASHBOARD_AUTH)),
-  _ts_param6(1, (0, import_common7.Inject)(DASHBOARD_BASE_PATH)),
-  _ts_metadata6("design:type", Function),
-  _ts_metadata6("design:paramtypes", [
+DurableUiSessionGuard = _ts_decorate9([
+  (0, import_common9.Injectable)(),
+  _ts_param6(0, (0, import_common9.Inject)(DASHBOARD_AUTH)),
+  _ts_param6(1, (0, import_common9.Inject)(DASHBOARD_BASE_PATH)),
+  _ts_metadata8("design:type", Function),
+  _ts_metadata8("design:paramtypes", [
     Object,
     String
   ])
@@ -1710,30 +2273,30 @@ var DurableApiSessionGuard = class {
   * 401; `DurableUiSessionGuard`'s redirect/session-required exceptions above don't reach it.
   */
   unauthorized(auth) {
-    return new import_common7.UnauthorizedException({
+    return new import_common9.UnauthorizedException({
       auth: {
         modes: auth.modes
       }
     });
   }
 };
-DurableApiSessionGuard = _ts_decorate7([
-  (0, import_common7.Injectable)(),
-  _ts_param6(0, (0, import_common7.Inject)(DASHBOARD_AUTH)),
-  _ts_metadata6("design:type", Function),
-  _ts_metadata6("design:paramtypes", [
+DurableApiSessionGuard = _ts_decorate9([
+  (0, import_common9.Injectable)(),
+  _ts_param6(0, (0, import_common9.Inject)(DASHBOARD_AUTH)),
+  _ts_metadata8("design:type", Function),
+  _ts_metadata8("design:paramtypes", [
     Object
   ])
 ], DurableApiSessionGuard);
 
 // src/server/durable-dashboard.module.ts
-function _ts_decorate8(decorators, target, key, desc) {
+function _ts_decorate10(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_decorate8, "_ts_decorate");
+__name(_ts_decorate10, "_ts_decorate");
 var GUARDS_METADATA = "__guards__";
 function normalize(path) {
   return `/${path.replace(/^\/+|\/+$/g, "")}`;
@@ -1765,6 +2328,37 @@ var DurableApiModule = class _DurableApiModule {
       ],
       providers: [
         DashboardService,
+        // `@dudousxd/nestjs-filter` is wired PRIVATELY here rather than through
+        // `FilterModule.forRoot()`, which is a global registration. A library calling that would
+        // fight the host app over one set of module options and register a second app-wide
+        // interceptor — and it cannot tell at module-definition time whether the host already
+        // called it. Everything below is scoped to this module, so the console composes with an app
+        // that uses the filter library, and with one that has never heard of it, identically.
+        //
+        // `validation: 'off'`: the run filter's inputs are validated by their own translation —
+        // every field/operator pair either maps onto a `RunQuery` predicate or is rejected by
+        // name — so there is nothing left for class-validator to check, and requiring it would put
+        // a peer dependency on every consumer of this dashboard for no gain.
+        //
+        // The `null` adapter is the GLOBAL one, deliberately absent: `RunFilter` names its own via
+        // `@Filterable({ adapter })`, so the console runs on the durable run gateway while the host
+        // app's filters keep running on whatever adapter it registered.
+        {
+          provide: import_nestjs_filter3.FilterRunner,
+          useFactory: /* @__PURE__ */ __name((moduleRef) => new import_nestjs_filter3.FilterRunner(moduleRef, {
+            validation: "off"
+          }, null), "useFactory"),
+          inject: [
+            import_core.ModuleRef
+          ]
+        },
+        import_nestjs_filter3.ApplyFilterInterceptor,
+        RunQueryAdapter,
+        {
+          provide: RUN_QUERY_ADAPTER,
+          useExisting: RunQueryAdapter
+        },
+        RunFilter,
         options.authProvider,
         DurableApiSessionGuard,
         ...options.guards ?? []
@@ -1775,8 +2369,8 @@ var DurableApiModule = class _DurableApiModule {
     };
   }
 };
-DurableApiModule = _ts_decorate8([
-  (0, import_common8.Module)({})
+DurableApiModule = _ts_decorate10([
+  (0, import_common10.Module)({})
 ], DurableApiModule);
 var DurableDashboardModule = class _DurableDashboardModule {
   static {
@@ -1861,8 +2455,8 @@ var DurableDashboardModule = class _DurableDashboardModule {
     };
   }
 };
-DurableDashboardModule = _ts_decorate8([
-  (0, import_common8.Module)({})
+DurableDashboardModule = _ts_decorate10([
+  (0, import_common10.Module)({})
 ], DurableDashboardModule);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {