@dudousxd/nestjs-durable-dashboard 0.43.2 → 0.45.0

package/dist/server/index.js

@@ -106,6 +106,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). */
@@ -214,10 +220,95 @@ DashboardService = _ts_decorate([
 ], DashboardService);
 
 // src/server/durable-api.controller.ts
-import { Body, Controller, Get, Header, NotFoundException, Param, Post, Query, Sse } from "@nestjs/common";
+import { ApplyFilter, ApplyFilterInterceptor, FilterRunner } from "@dudousxd/nestjs-filter";
+import { Body, Controller, Get, Header, NotFoundException, Param, Post, Query, Sse, UseInterceptors } from "@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
+import { BaseFilter, FilterFor, Filterable } from "@dudousxd/nestjs-filter";
+import { Injectable as Injectable3 } from "@nestjs/common";
 
 // src/server/attr-filter.ts
-var ATTR_OPS = /* @__PURE__ */ new Set([
+var SCALAR_OPS = /* @__PURE__ */ new Set([
   "eq",
   "ne",
   "gt",
@@ -225,6 +316,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;
@@ -240,25 +332,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
+import { RUN_VALUE_FACET_LIMIT, RunGateway as RunGateway2 } from "@dudousxd/nestjs-durable-core";
+import { BadRequestException, Injectable as Injectable2 } from "@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);
@@ -270,73 +397,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 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 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 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 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 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 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 BadRequestException(`The durable run list cannot enumerate values of \`${field}\`.`);
+    }
+    const rows = await this.gateway.runValueFacets(axis, this.draft(qb).facetQuery(), {
+      limit: opts?.limit ?? 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([
+  Injectable2(),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof RunGateway2 === "undefined" ? Object : RunGateway2
+  ])
+], 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 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([
+  FilterFor("status"),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    Object
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], RunFilter.prototype, "applyStatus", null);
+_ts_decorate3([
+  FilterFor("workflow"),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    Object
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], RunFilter.prototype, "applyWorkflow", null);
+_ts_decorate3([
+  FilterFor("namespace"),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    Object
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], RunFilter.prototype, "applyNamespace", null);
+_ts_decorate3([
+  FilterFor("tag"),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    Object
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], RunFilter.prototype, "applyTag", null);
+_ts_decorate3([
+  FilterFor("origin"),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", []),
+  _ts_metadata3("design:returntype", void 0)
+], RunFilter.prototype, "applyOrigin", null);
+_ts_decorate3([
+  FilterFor("unattributed"),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", []),
+  _ts_metadata3("design:returntype", void 0)
+], RunFilter.prototype, "applyUnattributed", null);
+_ts_decorate3([
+  FilterFor("attr"),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    Object
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], RunFilter.prototype, "applyAttributes", null);
+_ts_decorate3([
+  FilterFor("limit"),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    Object
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], RunFilter.prototype, "applyLimit", null);
+_ts_decorate3([
+  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([
+  Injectable3(),
+  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);
   }
   /**
@@ -344,15 +925,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. */
@@ -389,18 +983,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,202 +1027,179 @@ var DurableApiController = class {
     return this.dashboard.update(id, name, body);
   }
 };
-_ts_decorate2([
+_ts_decorate4([
   Get("runs"),
-  _ts_param2(0, Query("status")),
-  _ts_param2(1, Query("workflow")),
-  _ts_param2(2, Query("tag")),
-  _ts_param2(3, Query("attr")),
-  _ts_param2(4, Query("namespace")),
-  _ts_param2(5, Query("origin")),
-  _ts_param2(6, Query("unattributed")),
-  _ts_param2(7, Query("limit")),
-  _ts_param2(8, Query("offset")),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", [
-    Object,
-    String,
-    String,
-    Object,
-    String,
-    String,
-    String,
-    String,
-    String
+  _ts_param2(0, 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([
+_ts_decorate4([
   Get("runs/facets"),
-  _ts_param2(0, Query("workflow")),
-  _ts_param2(1, Query("tag")),
-  _ts_param2(2, Query("attr")),
-  _ts_param2(3, Query("namespace")),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", [
-    String,
-    String,
-    Object,
-    String
+  _ts_param2(0, 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([
+_ts_decorate4([
+  Get("runs/values"),
+  _ts_param2(0, 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([
   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)
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", []),
+  _ts_metadata4("design:returntype", void 0)
 ], DurableApiController.prototype, "metrics", null);
-_ts_decorate2([
+_ts_decorate4([
   Get("workers"),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", []),
-  _ts_metadata2("design:returntype", void 0)
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", []),
+  _ts_metadata4("design:returntype", void 0)
 ], DurableApiController.prototype, "workers", null);
-_ts_decorate2([
+_ts_decorate4([
   Get("topology"),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", []),
-  _ts_metadata2("design:returntype", void 0)
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", []),
+  _ts_metadata4("design:returntype", void 0)
 ], DurableApiController.prototype, "topology", null);
-_ts_decorate2([
+_ts_decorate4([
   Get("runs/:id"),
   _ts_param2(0, Param("id")),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", [
+  _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([
+_ts_decorate4([
   Sse("runs/:id/stream"),
   _ts_param2(0, Param("id")),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", [
+  _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([
+_ts_decorate4([
   Post("runs/:id/retry"),
   _ts_param2(0, Param("id")),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", [
+  _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([
+_ts_decorate4([
   Post("runs/:id/retry-with-input"),
   _ts_param2(0, Param("id")),
   _ts_param2(1, Body()),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", [
+  _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([
+_ts_decorate4([
   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_param2(6, Query("namespace")),
-  _ts_param2(7, Query("origin")),
-  _ts_param2(8, Query("unattributed")),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", [
-    String,
-    typeof RunStatus === "undefined" ? Object : RunStatus,
-    String,
-    String,
-    Object,
-    String,
-    String,
+  _ts_param2(1, ApplyFilter(RunFilter)),
+  _ts_param2(2, 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([
+_ts_decorate4([
   Post("runs/:id/cancel"),
   _ts_param2(0, Param("id")),
   _ts_param2(1, Query("compensate")),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", [
+  _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([
+_ts_decorate4([
   Post("runs/:id/continue"),
   _ts_param2(0, Param("id")),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", [
+  _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([
+_ts_decorate4([
   Post("runs/:id/redispatch"),
   _ts_param2(0, Param("id")),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", [
+  _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([
+_ts_decorate4([
   Post("webhooks/:token"),
   _ts_param2(0, Param("token")),
   _ts_param2(1, Body()),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", [
+  _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([
+_ts_decorate4([
   Get("runs/:id/events/:key"),
   _ts_param2(0, Param("id")),
   _ts_param2(1, Param("key")),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", [
+  _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([
+_ts_decorate4([
   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", [
+  _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([
+DurableApiController = _ts_decorate4([
   Controller(),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", [
-    typeof DashboardService === "undefined" ? Object : DashboardService
+  UseInterceptors(ApplyFilterInterceptor),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    typeof DashboardService === "undefined" ? Object : DashboardService,
+    typeof FilterRunner === "undefined" ? Object : FilterRunner
   ])
 ], DurableApiController);
 
 // src/server/durable-auth.controller.ts
-import { BadRequestException, Body as Body2, Controller as Controller3, Get as Get3, Header as Header3, HttpCode, Inject as Inject4, Logger as Logger2, NotFoundException as NotFoundException3, Optional as Optional3, Post as Post2, Req, Res, UnauthorizedException } from "@nestjs/common";
+import { BadRequestException as BadRequestException2, Body as Body2, Controller as Controller3, Get as Get3, Header as Header3, HttpCode, Inject as Inject4, Logger as Logger2, NotFoundException as NotFoundException3, Optional as Optional3, Post as Post2, Req, Res, UnauthorizedException } from "@nestjs/common";
 
 // src/server/auth/dashboard-auth-config.ts
 var DASHBOARD_AUTH = Symbol("DASHBOARD_AUTH");
@@ -1193,13 +1755,13 @@ import { Controller as Controller2, Get as Get2, Header as Header2, Inject as In
 
 // src/server/auth/login-redirect.exception.ts
 import { Catch, HttpException, HttpStatus } from "@nestjs/common";
-function _ts_decorate3(decorators, target, key, desc) {
+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");
+__name(_ts_decorate5, "_ts_decorate");
 var DashboardLoginRedirectException = class extends HttpException {
   static {
     __name(this, "DashboardLoginRedirectException");
@@ -1220,23 +1782,23 @@ var DashboardLoginRedirectFilter = class {
     redirectRaw(response, exception.location);
   }
 };
-DashboardLoginRedirectFilter = _ts_decorate3([
+DashboardLoginRedirectFilter = _ts_decorate5([
   Catch(DashboardLoginRedirectException)
 ], DashboardLoginRedirectFilter);
 
 // src/server/auth/session-required.exception.ts
 import { Catch as Catch2, HttpException as HttpException2, HttpStatus as HttpStatus2, Inject as Inject2, Logger, Optional as Optional2 } from "@nestjs/common";
-function _ts_decorate4(decorators, target, key, desc) {
+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);
@@ -1291,28 +1853,28 @@ var DashboardSessionRequiredFilter = class _DashboardSessionRequiredFilter {
     this.logger.warn(message);
   }
 };
-DashboardSessionRequiredFilter = _ts_decorate4([
+DashboardSessionRequiredFilter = _ts_decorate6([
   Catch2(DashboardSessionRequiredException),
   _ts_param3(0, Optional2()),
   _ts_param3(0, Inject2(DASHBOARD_AUTH)),
-  _ts_metadata3("design:type", Function),
-  _ts_metadata3("design:paramtypes", [
+  _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);
@@ -1371,48 +1933,48 @@ var DurableUiController = class {
     });
   }
 };
-_ts_decorate5([
+_ts_decorate7([
   Get2(),
   Header2("Content-Type", "text/html; charset=utf-8"),
   Header2("Cache-Control", "no-store, must-revalidate"),
-  _ts_metadata4("design:type", Function),
-  _ts_metadata4("design:paramtypes", []),
-  _ts_metadata4("design:returntype", String)
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", []),
+  _ts_metadata6("design:returntype", String)
 ], DurableUiController.prototype, "index", null);
-_ts_decorate5([
+_ts_decorate7([
   Get2("assets/:file"),
   Header2("Cache-Control", "public, max-age=31536000, immutable"),
   _ts_param4(0, Param2("file")),
-  _ts_metadata4("design:type", Function),
-  _ts_metadata4("design:paramtypes", [
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", [
     String
   ]),
-  _ts_metadata4("design:returntype", typeof StreamableFile === "undefined" ? Object : StreamableFile)
+  _ts_metadata6("design:returntype", typeof StreamableFile === "undefined" ? Object : StreamableFile)
 ], DurableUiController.prototype, "asset", null);
-DurableUiController = _ts_decorate5([
+DurableUiController = _ts_decorate7([
   UseFilters(DashboardLoginRedirectFilter, DashboardSessionRequiredFilter),
   Controller2(),
   _ts_param4(0, Inject3(DASHBOARD_BASE_PATH)),
   _ts_param4(1, Inject3(DASHBOARD_API_PATH)),
-  _ts_metadata4("design:type", Function),
-  _ts_metadata4("design:paramtypes", [
+  _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);
@@ -1452,7 +2014,7 @@ var DurableAuthController = class _DurableAuthController {
     const auth = this.requireAuth();
     if (!auth.modes.includes("login")) throw new NotFoundException3();
     if (!isString(body?.username) || !isString(body?.password)) {
-      throw new BadRequestException("Body must include string `username` and `password`.");
+      throw new BadRequestException2("Body must include string `username` and `password`.");
     }
     const { username, password } = body;
     const user = await this.runHook("login", () => auth.login?.(username, password) ?? null);
@@ -1514,15 +2076,15 @@ var DurableAuthController = class _DurableAuthController {
     }
   }
 };
-_ts_decorate6([
+_ts_decorate8([
   Get3("login"),
   Header3("Content-Type", "text/html; charset=utf-8"),
   Header3("Cache-Control", "no-store, must-revalidate"),
-  _ts_metadata5("design:type", Function),
-  _ts_metadata5("design:paramtypes", []),
-  _ts_metadata5("design:returntype", String)
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", []),
+  _ts_metadata7("design:returntype", String)
 ], DurableAuthController.prototype, "loginPage", null);
-_ts_decorate6([
+_ts_decorate8([
   Post2("login"),
   HttpCode(200),
   _ts_param5(0, Body2()),
@@ -1530,46 +2092,46 @@ _ts_decorate6([
   _ts_param5(2, 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([
+_ts_decorate8([
   Post2("session"),
   HttpCode(204),
   _ts_param5(0, Req()),
   _ts_param5(1, 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([
+_ts_decorate8([
   Get3("logout"),
   _ts_param5(0, Req()),
   _ts_param5(1, Res()),
-  _ts_metadata5("design:type", Function),
-  _ts_metadata5("design:paramtypes", [
+  _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([
+DurableAuthController = _ts_decorate8([
   Controller3(),
   _ts_param5(0, Optional3()),
   _ts_param5(0, Inject4(DASHBOARD_AUTH)),
   _ts_param5(1, Inject4(DASHBOARD_BASE_PATH)),
-  _ts_metadata5("design:type", Function),
-  _ts_metadata5("design:paramtypes", [
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", [
     Object,
     String
   ])
@@ -1577,22 +2139,23 @@ DurableAuthController = _ts_decorate6([
 
 // src/server/durable-dashboard.module.ts
 import "reflect-metadata";
+import { ApplyFilterInterceptor as ApplyFilterInterceptor2, FilterRunner as FilterRunner2 } from "@dudousxd/nestjs-filter";
 import { Module } from "@nestjs/common";
-import { RouterModule } from "@nestjs/core";
+import { ModuleRef, RouterModule } from "@nestjs/core";
 
 // src/server/durable-session.guard.ts
-import { Inject as Inject5, Injectable as Injectable2, UnauthorizedException as UnauthorizedException2 } from "@nestjs/common";
-function _ts_decorate7(decorators, target, key, desc) {
+import { Inject as Inject5, Injectable as Injectable4, UnauthorizedException as UnauthorizedException2 } from "@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);
@@ -1639,12 +2202,12 @@ var DurableUiSessionGuard = class {
     throw new DashboardLoginRedirectException(`${this.basePath}/login?returnTo=${returnTo}`);
   }
 };
-DurableUiSessionGuard = _ts_decorate7([
-  Injectable2(),
+DurableUiSessionGuard = _ts_decorate9([
+  Injectable4(),
   _ts_param6(0, Inject5(DASHBOARD_AUTH)),
   _ts_param6(1, Inject5(DASHBOARD_BASE_PATH)),
-  _ts_metadata6("design:type", Function),
-  _ts_metadata6("design:paramtypes", [
+  _ts_metadata8("design:type", Function),
+  _ts_metadata8("design:paramtypes", [
     Object,
     String
   ])
@@ -1683,23 +2246,23 @@ var DurableApiSessionGuard = class {
     });
   }
 };
-DurableApiSessionGuard = _ts_decorate7([
-  Injectable2(),
+DurableApiSessionGuard = _ts_decorate9([
+  Injectable4(),
   _ts_param6(0, Inject5(DASHBOARD_AUTH)),
-  _ts_metadata6("design:type", Function),
-  _ts_metadata6("design:paramtypes", [
+  _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, "")}`;
@@ -1731,6 +2294,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: FilterRunner2,
+          useFactory: /* @__PURE__ */ __name((moduleRef) => new FilterRunner2(moduleRef, {
+            validation: "off"
+          }, null), "useFactory"),
+          inject: [
+            ModuleRef
+          ]
+        },
+        ApplyFilterInterceptor2,
+        RunQueryAdapter,
+        {
+          provide: RUN_QUERY_ADAPTER,
+          useExisting: RunQueryAdapter
+        },
+        RunFilter,
         options.authProvider,
         DurableApiSessionGuard,
         ...options.guards ?? []
@@ -1741,7 +2335,7 @@ var DurableApiModule = class _DurableApiModule {
     };
   }
 };
-DurableApiModule = _ts_decorate8([
+DurableApiModule = _ts_decorate10([
   Module({})
 ], DurableApiModule);
 var DurableDashboardModule = class _DurableDashboardModule {
@@ -1827,7 +2421,7 @@ var DurableDashboardModule = class _DurableDashboardModule {
     };
   }
 };
-DurableDashboardModule = _ts_decorate8([
+DurableDashboardModule = _ts_decorate10([
   Module({})
 ], DurableDashboardModule);
 export {