Function rowMatchesFilter

showcase/harness/src/fleet/queue-client.test.ts:191–286

* Shared `status`/`probe_key` filter evaluation for BOTH fake PB clients * (`makeFakePb` + `makePagingPb`). A clause on a field OR OPERATOR the fakes * can't honor THROWS loudly — matching the fakes' own unsupported-method * philosophy — so a future test exercising an unmodeled filter shape can

(row: FilterableRow, filter?: string)

 * these filters legitimately carries operator characters.
 */
function rowMatchesFilter(row: FilterableRow, filter?: string): boolean {
  if (!filter) return true;
  for (const [, field, op] of filter.matchAll(
    /([A-Za-z_][\w.]*)\s*(\?~|\?=|!~|!=|<=|>=|<|>|~|=)/g,
  )) {
    if (field !== "status" && field !== "probe_key" && field !== "id") {
      throw new Error(
        `fake-pb: filter clause on unsupported field "${field}" — only status/probe_key/id are honored (filter: ${filter})`,
      );
    }
    if (field === "status" && op !== "=") {
      throw new Error(
        `fake-pb: status clause with unsupported operator "${op}" — only \`=\` is honored (filter: ${filter})`,
      );
    }
    if (field === "probe_key" && !["=", "!=", "~", "!~"].includes(op)) {
      throw new Error(
        `fake-pb: probe_key clause with unsupported operator "${op}" (filter: ${filter})`,
      );
    }
    // `id` is honored for the NEGATIVE equality only (the discovery
    // by-row-id exclusion for clause-unsafe families); anything else throws
    // per the fakes' philosophy.
    if (field === "id" && op !== "!=") {
      throw new Error(
        `fake-pb: id clause with unsupported operator "${op}" — only \`!=\` is honored (filter: ${filter})`,
      );
    }
  }
  // BOOLEAN-CONNECTIVE GUARD: the evaluation below ORs all POSITIVE clauses
  // per field (faithful to the production inclusion groups, which are
  // `(probe_key ~ x || probe_key = y)` / `(status = a || status = b)`) and
  // ANDs negatives. Two positive clauses for ONE field joined WITHOUT a
  // `||` between them are ANDed in the real grammar — a shape this OR-model
  // would evaluate wrong, so it must throw rather than pass vacuously.
  //
  // KNOWN LIMITATION (interleaved `||`, G1h): the guard only checks that the
  // RAW TEXT between two same-field positives contains a `||` — it is blind
  // to grouping/precedence. A filter like
  // `probe_key = "a" || status = "x" && probe_key = "b"` interleaves a
  // different field between the two probe_key positives; the separator
  // contains `||`, so the guard passes, yet the OR-model flattens what the
  // real grammar binds as `a || (x && b)`. No production builder emits such
  // a shape (inclusion groups are homogeneous parenthesized ORs); a future
  // test that does must extend the matcher, not trust it.
  const assertPositivesOrJoined = (field: string, re: RegExp): void => {
    const ms = [...filter.matchAll(re)];
    for (let i = 1; i < ms.length; i++) {
      const prev = ms[i - 1];
      const sep = filter.slice((prev.index ?? 0) + prev[0].length, ms[i].index);
      if (!sep.includes("||")) {
        throw new Error(
          `fake-pb: multiple positive ${field} clauses ANDed — the OR-model cannot honor this shape (filter: ${filter})`,
        );
      }
    }
  };
  // `(?:~|=)` requires the operator DIRECTLY after the field (`!~`/`!=`