@msqd/lydia 0.0.0-stage → 0.6.1

package/dist/Models/Filters/dates.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A `YYYY-MM-DD` calendar day as local midnight. `new Date("YYYY-MM-DD")` reads UTC midnight instead,
+ * which shifts the day for anyone west or far east of Greenwich. A string that is not a real day
+ * answers undefined, so the caller treats it as no bound.
+ */
+export declare function parseLocalDay(day: string): Date | undefined;
+/** The local calendar day of `now` as `YYYY-MM-DD`; `toISOString()` would give the UTC one. */
+export declare function localToday(now?: Date): string;

package/dist/Models/Filters/dates.js

@@ -0,0 +1,16 @@
+const d = /^(\d{4})-(\d{2})-(\d{2})$/;
+function u(t) {
+  const e = d.exec(t);
+  if (!e)
+    return;
+  const [r, n, o] = [Number(e[1]), Number(e[2]), Number(e[3])], a = new Date(r, n - 1, o);
+  return a.getFullYear() === r && a.getMonth() === n - 1 && a.getDate() === o ? a : void 0;
+}
+const c = (t) => String(t).padStart(2, "0");
+function g(t = /* @__PURE__ */ new Date()) {
+  return `${t.getFullYear()}-${c(t.getMonth() + 1)}-${c(t.getDate())}`;
+}
+export {
+  g as localToday,
+  u as parseLocalDay
+};

package/dist/Models/Filters/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export * from "./active.js";
+export * from "./read.js";
+export * from "./dates.js";

package/dist/Models/Filters/index.js

@@ -0,0 +1,13 @@
+import { countActiveFilters as a, hasActiveFilters as o } from "./active.js";
+import { readArray as l, readDates as c, readRange as d, readSingle as i } from "./read.js";
+import { localToday as p, parseLocalDay as f } from "./dates.js";
+export {
+  a as countActiveFilters,
+  o as hasActiveFilters,
+  p as localToday,
+  f as parseLocalDay,
+  l as readArray,
+  c as readDates,
+  d as readRange,
+  i as readSingle
+};

package/dist/Models/Filters/read.d.ts

@@ -0,0 +1,9 @@
+import type { DateRangeFilter, Filters, MinMaxFilter } from "./types.js";
+/** The selected values of a multiple choice facet; empty unless the filter is a list of strings. */
+export declare function readArray(filters: Filters | undefined, name: string): string[];
+/** The bounds of a range facet; a bound that is not a finite number is absent. */
+export declare function readRange(filters: Filters | undefined, name: string): MinMaxFilter;
+/** The dates of a date range facet; a date that is not a string is absent. */
+export declare function readDates(filters: Filters | undefined, name: string): DateRangeFilter;
+/** The chosen value of a single choice facet; undefined unless the filter is a string. */
+export declare function readSingle(filters: Filters | undefined, name: string): string | undefined;

package/dist/Models/Filters/read.js

@@ -0,0 +1,22 @@
+const n = (t, r) => t?.[r], s = (t) => typeof t == "object" && t !== null && !Array.isArray(t), i = (t) => typeof t == "string" ? t : void 0, o = (t) => typeof t == "number" && Number.isFinite(t) ? t : void 0, a = (t) => Object.fromEntries(Object.entries(t).filter(([, r]) => r !== void 0));
+function d(t, r) {
+  const e = n(t, r);
+  return Array.isArray(e) && e.every((c) => typeof c == "string") ? e : [];
+}
+function f(t, r) {
+  const e = n(t, r);
+  return s(e) ? a({ min: o(e.min), max: o(e.max) }) : {};
+}
+function u(t, r) {
+  const e = n(t, r);
+  return s(e) ? a({ startDate: i(e.startDate), endDate: i(e.endDate) }) : {};
+}
+function y(t, r) {
+  return i(n(t, r));
+}
+export {
+  d as readArray,
+  u as readDates,
+  f as readRange,
+  y as readSingle
+};

package/dist/Models/Filters/types.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Base filter types inspired by HARP's filter system
+ * Designed to be URL-serializable and provide a unified state management approach
+ */
+/** Array of string values for multi-select filters (checkboxes) */
+export type ArrayFilter = string[] | undefined;
+/** Min/max range filter for numeric values (sliders) */
+export interface MinMaxFilter {
+    min?: number;
+    max?: number;
+}
+/** Single value filter for radio buttons */
+export type SingleFilter = string | undefined;
+/** Date range filter */
+export interface DateRangeFilter {
+    startDate?: string;
+    endDate?: string;
+}
+/** The value one facet holds. Read it through `readArray`, `readRange`, `readDates` or `readSingle`. */
+export type FilterValue = ArrayFilter | MinMaxFilter | SingleFilter | DateRangeFilter;
+/** Generic filters container */
+export type Filters = Record<string, FilterValue>;
+/** Filter metadata for display and validation */
+export interface FilterMeta {
+    name: string;
+    count?: number;
+    label?: string;
+    /** What the label stands for, in words ("Client Error" for "4xx"). Shown as a tooltip and read as the description. */
+    description?: string;
+}
+/**
+ * A value of a facet. With `under`, it is a class whose values hang beneath it (a status class and its codes): its
+ * `name` is the class token and each `under` name a code token (ADR 0002).
+ */
+export interface FacetOption extends FilterMeta {
+    under?: FilterMeta[];
+}
+/** Range filter metadata with marks for sliders */
+export interface RangeFilterMeta {
+    min: number;
+    max: number;
+    step?: number;
+    marks?: Array<{
+        value: number;
+        label: string;
+        className?: string;
+    }>;
+}
+/** Unified filter state change handler */
+export type FilterChangeHandler<T = FilterValue> = (filterName: string, value: T) => void;

package/dist/Models/Filters/types.js

@@ -0,0 +1 @@
+

package/dist/Models/Http/body.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A captured HTTP body as the proxy hands it over: raw text, a data URL or placeholder for binary
+ * content, or a parsed JSON document.
+ */
+export type HttpBody = string | Record<string, unknown> | unknown[];
+/** Text form of a body: strings as is, parsed documents as indented JSON. */
+export declare function stringifyBody(body: HttpBody): string;

package/dist/Models/Http/body.js

@@ -0,0 +1,6 @@
+function t(n) {
+  return typeof n == "string" ? n : JSON.stringify(n, null, 2);
+}
+export {
+  t as stringifyBody
+};

package/dist/Models/Http/contentDisposition.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Filename suggested by a `Content-Disposition` header value, made safe to use as a download name.
+ *
+ * Prefers `filename*` (RFC 5987) over `filename`. Control characters and path separators are
+ * removed and the result is capped at 255 characters. Parsing is linear in the header length.
+ */
+export declare function contentDispositionFilename(header: string): string | undefined;

package/dist/Models/Http/contentDisposition.js

@@ -0,0 +1,51 @@
+import { percentDecode as l } from "./percent.js";
+const r = 255, f = /\s/;
+function u(n) {
+  const e = /* @__PURE__ */ new Map();
+  let t = n.indexOf(";");
+  if (t < 0) return e;
+  for (; t < n.length; ) {
+    t++;
+    const i = t;
+    for (; t < n.length && n[t] !== "=" && n[t] !== ";"; ) t++;
+    const o = n.slice(i, t).trim().toLowerCase();
+    if (n[t] !== "=") continue;
+    for (t++; t < n.length && f.test(n[t]); ) t++;
+    let s = "";
+    if (n[t] === '"') {
+      for (t++; t < n.length && n[t] !== '"'; )
+        n[t] === "\\" && t++, s += n[t] ?? "", t++;
+      for (t++; t < n.length && n[t] !== ";"; ) t++;
+    } else {
+      const c = t;
+      for (; t < n.length && n[t] !== ";"; ) t++;
+      s = n.slice(c, t).trim();
+    }
+    o && !e.has(o) && e.set(o, s);
+  }
+  return e;
+}
+function m(n) {
+  const e = /^([^']*)'[^']*'([\s\S]*)$/.exec(n);
+  if (!e) return;
+  const t = e[1].toLowerCase();
+  if (!(t !== "utf-8" && t !== "iso-8859-1"))
+    try {
+      return new TextDecoder(t, { fatal: !0 }).decode(l(e[2]));
+    } catch {
+      return;
+    }
+}
+function p(n) {
+  return Array.from(n).filter((t) => {
+    const i = t.codePointAt(0);
+    return i > 31 && i !== 127 && t !== "/" && t !== "\\";
+  }).slice(0, r).join("").trim() || void 0;
+}
+function a(n) {
+  const e = u(n), t = m(e.get("filename*") ?? "");
+  return p(t ?? e.get("filename") ?? "");
+}
+export {
+  a as contentDispositionFilename
+};

package/dist/Models/Http/dataUrl.d.ts

@@ -0,0 +1,12 @@
+export interface DecodedDataUrl {
+    /** Media type declared by the URL, without parameters; undefined when the URL omits it. */
+    mimeType: string | undefined;
+    bytes: Uint8Array;
+}
+/**
+ * Decode a `data:` URL into its bytes and media type.
+ *
+ * Only the first comma separates the header from the payload; the payload may contain more.
+ * Throws an `Error` on a URL that is not a data URL or whose base64 payload is invalid.
+ */
+export declare function decodeDataUrl(url: string): DecodedDataUrl;

package/dist/Models/Http/dataUrl.js

@@ -0,0 +1,21 @@
+import { percentDecode as i } from "./percent.js";
+const c = /^data:/i;
+function f(e) {
+  const t = e.indexOf(",");
+  if (!c.test(e) || t < 0)
+    throw new Error("Not a valid data URL");
+  const [r = "", ...n] = e.slice(5, t).split(";"), o = r.includes("/") ? r.trim().toLowerCase() : void 0, a = e.slice(t + 1);
+  return n.some((s) => s.trim().toLowerCase() === "base64") ? { mimeType: o, bytes: d(a) } : { mimeType: o, bytes: i(a) };
+}
+function d(e) {
+  let t;
+  try {
+    t = atob(Array.from(i(e), (r) => String.fromCharCode(r)).join(""));
+  } catch {
+    throw new Error("The data URL carries invalid base64");
+  }
+  return Uint8Array.from(t, (r) => r.charCodeAt(0));
+}
+export {
+  f as decodeDataUrl
+};

package/dist/Models/Http/headers.d.ts

@@ -0,0 +1,18 @@
+/**
+ * A single header occurrence, as it crossed the wire.
+ *
+ * Headers are modelled as an ordered sequence rather than a map because HTTP allows a name to
+ * repeat and `set-cookie` routinely does. A map would collapse those repeats and lose the order
+ * they arrived in.
+ */
+export interface HttpHeader {
+    name: string;
+    value: string;
+}
+/**
+ * Value of the first header matching `name`, compared case-insensitively.
+ *
+ * Lookup normalises case because HTTP header names are case-insensitive; display does not,
+ * because a recording of what crossed the wire should show the spelling that was used.
+ */
+export declare function findHeader(headers: HttpHeader[] | undefined, name: string): string | undefined;

package/dist/Models/Http/headers.js

@@ -0,0 +1,7 @@
+function a(e, n) {
+  const o = n.toLowerCase();
+  return e?.find((t) => t.name.toLowerCase() === o)?.value;
+}
+export {
+  a as findHeader
+};

package/dist/Models/Http/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./headers.js";
+export * from "./requestTarget.js";

package/dist/Models/Http/index.js

@@ -0,0 +1,6 @@
+import { findHeader as t } from "./headers.js";
+import { splitRequestTarget as f } from "./requestTarget.js";
+export {
+  t as findHeader,
+  f as splitRequestTarget
+};

package/dist/Models/Http/percent.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Decode `%XX` escapes into bytes. Unlike `decodeURIComponent` it never throws and does not
+ * require the decoded bytes to be UTF-8: a malformed escape is kept as is.
+ */
+export declare function percentDecode(input: string): Uint8Array;

package/dist/Models/Http/percent.js

@@ -0,0 +1,17 @@
+function u(o) {
+  if (o === void 0) return -1;
+  if (o >= 48 && o <= 57) return o - 48;
+  const n = o | 32;
+  return n >= 97 && n <= 102 ? n - 97 + 10 : -1;
+}
+function s(o) {
+  const n = new TextEncoder().encode(o), r = [];
+  for (let e = 0; e < n.length; e++) {
+    const t = n[e] === 37 ? u(n[e + 1]) : -1, c = t >= 0 ? u(n[e + 2]) : -1;
+    c >= 0 ? (r.push(t * 16 + c), e += 2) : r.push(n[e]);
+  }
+  return Uint8Array.from(r);
+}
+export {
+  s as percentDecode
+};

package/dist/Models/Http/requestTarget.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Split a captured request target at its first `?`, without parsing it.
+ *
+ * A captured target is attacker-controlled and may not be a valid URL, so nothing here can throw and
+ * nothing is normalised: `path` and `query` are the bytes that crossed the wire. `query` keeps its
+ * leading `?`, and is empty when the target has none.
+ */
+export declare function splitRequestTarget(raw: string): {
+    path: string;
+    query: string;
+};

package/dist/Models/Http/requestTarget.js

@@ -0,0 +1,7 @@
+function u(e) {
+  const t = e.indexOf("?");
+  return t === -1 ? { path: e, query: "" } : { path: e.slice(0, t), query: e.slice(t) };
+}
+export {
+  u as splitRequestTarget
+};

package/dist/Models/System/index.d.ts

@@ -0,0 +1 @@
+export * from "./types.js";

package/dist/Models/System/index.js

@@ -0,0 +1,7 @@
+import { circuitBreakerStatusMap as r, healthStatusMap as e, isCircuitBreakerStatus as i, isHealthStatus as s } from "./types.js";
+export {
+  r as circuitBreakerStatusMap,
+  e as healthStatusMap,
+  i as isCircuitBreakerStatus,
+  s as isHealthStatus
+};

package/dist/Models/System/types.d.ts

@@ -0,0 +1,20 @@
+/** How a status reads at a glance. A subset of what a badge can be coloured, so it can be handed to one. */
+export type StatusTone = "success" | "warning" | "danger" | "default";
+export type HealthStatus = "healthy" | "degraded" | "unhealthy";
+export type CircuitBreakerState = "open" | "closed" | "half-open";
+export type SystemStatus = HealthStatus | CircuitBreakerState;
+export interface HealthStatusConfig {
+    color: StatusTone;
+    label: string;
+    description?: string;
+}
+export interface CircuitBreakerStatusConfig {
+    color: StatusTone;
+    icon: string;
+    label: string;
+    description: string;
+}
+export declare const healthStatusMap: Record<HealthStatus, HealthStatusConfig>;
+export declare const circuitBreakerStatusMap: Record<CircuitBreakerState, CircuitBreakerStatusConfig>;
+export declare function isHealthStatus(status: string): status is HealthStatus;
+export declare function isCircuitBreakerStatus(status: string): status is CircuitBreakerState;

package/dist/Models/System/types.js

@@ -0,0 +1,48 @@
+const n = {
+  healthy: {
+    color: "success",
+    label: "Healthy",
+    description: "Service is operating normally"
+  },
+  degraded: {
+    color: "warning",
+    label: "Degraded",
+    description: "Service is experiencing issues"
+  },
+  unhealthy: {
+    color: "danger",
+    label: "Unhealthy",
+    description: "Service is not responding"
+  }
+}, o = {
+  closed: {
+    color: "success",
+    icon: "●",
+    label: "Closed",
+    description: "Normal operation"
+  },
+  "half-open": {
+    color: "warning",
+    icon: "◐",
+    label: "Half-Open",
+    description: "Testing recovery"
+  },
+  open: {
+    color: "danger",
+    icon: "○",
+    label: "Open",
+    description: "Blocking requests"
+  }
+};
+function r(e) {
+  return e === "healthy" || e === "degraded" || e === "unhealthy";
+}
+function i(e) {
+  return e === "open" || e === "closed" || e === "half-open";
+}
+export {
+  o as circuitBreakerStatusMap,
+  n as healthStatusMap,
+  i as isCircuitBreakerStatus,
+  r as isHealthStatus
+};

package/dist/Models/Tpdex.d.ts

@@ -0,0 +1,36 @@
+/**
+ * TPDEX (Transaction Performance Index) — the canonical performance scale and scoring.
+ *
+ * Converts a response time in milliseconds to a 0–100 performance score, and maps a score to a
+ * rating (label + colour token). This is domain data/logic (no JSX); presentation components import it.
+ */
+export interface TpdexRating {
+    label: string;
+    /** Lower bound of the rating; the last rating (G) has none. */
+    threshold?: number;
+    /**
+     * Tailwind background class, `bg-` plus the token's name. It repeats `token` because Tailwind finds a class by
+     * scanning for its literal text, so it cannot be built from `token` at runtime; a test keeps the two in step.
+     */
+    className: string;
+    /**
+     * Tailwind text class for a label drawn on `className`, read through
+     * `getTpdexTextClassName`. Omitted, the label is dark, which holds 4.5:1 on
+     * every fill of the scale but G's; G sets white.
+     */
+    textClassName?: string;
+    /**
+     * Theme token carrying the rating's colour, e.g. "--color-tpdex-a". Canvas renderers read it from the computed
+     * style (`resolveThemeColor`), so the badge and the chart follow the same retheme.
+     */
+    token: string;
+}
+export declare const tpdexScale: TpdexRating[];
+/** Map a 0–100 TPDEX score to its rating. */
+export declare function getTpdexRating(score: number): TpdexRating;
+/** Tailwind text class for a label drawn on the rating's fill. */
+export declare function getTpdexTextClassName(rating: TpdexRating): string;
+/** TPDEX score (0–100) for a single response time in ms. */
+export declare function calculateTpdexScore(responseTime: number): number;
+/** Average TPDEX score (0–100) across multiple response times in ms. */
+export declare function calculateAggregateTpdexScore(responseTimes: number[]): number;

package/dist/Models/Tpdex.js

@@ -0,0 +1,38 @@
+const r = [
+  { label: "A++", threshold: 98, className: "bg-tpdex-a-plus-plus", token: "--color-tpdex-a-plus-plus" },
+  { label: "A+", threshold: 96, className: "bg-tpdex-a-plus", token: "--color-tpdex-a-plus" },
+  { label: "A", threshold: 93, className: "bg-tpdex-a", token: "--color-tpdex-a" },
+  { label: "B", threshold: 83, className: "bg-tpdex-b", token: "--color-tpdex-b" },
+  { label: "C", threshold: 69, className: "bg-tpdex-c", token: "--color-tpdex-c" },
+  { label: "D", threshold: 49, className: "bg-tpdex-d", token: "--color-tpdex-d" },
+  { label: "E", threshold: 31, className: "bg-tpdex-e", token: "--color-tpdex-e" },
+  { label: "F", threshold: 17, className: "bg-tpdex-f", token: "--color-tpdex-f" },
+  { label: "G", className: "bg-tpdex-g", token: "--color-tpdex-g", textClassName: "text-white" }
+];
+function d(e) {
+  for (const t of r)
+    if (t.threshold === void 0 || e >= t.threshold)
+      return t;
+  throw new Error("Invalid score (but that should not happen).");
+}
+function n(e) {
+  return e.textClassName ?? "text-gray-950";
+}
+function s(e) {
+  return e < 1328 ? Math.min(1 - 722e-6 * e + 244e-9 * e ** 2 - 3e-11 * e ** 3, 1) : Math.max(-0.42115982438869104 * Math.log(Math.sqrt(e) + 1) + 1.9270515661020815, 0);
+}
+function c(e) {
+  return Math.trunc(s(e) * 100);
+}
+function h(e) {
+  if (e.length === 0) return 0;
+  const t = e.map((l) => c(l)), a = t.reduce((l, o) => l + o, 0);
+  return Math.trunc(a / t.length);
+}
+export {
+  h as calculateAggregateTpdexScore,
+  c as calculateTpdexScore,
+  d as getTpdexRating,
+  n as getTpdexTextClassName,
+  r as tpdexScale
+};

package/dist/Models/Transactions/Overview.d.ts

@@ -0,0 +1,19 @@
+export interface OverviewTransaction {
+    datetime: string;
+    count: number;
+    errors: number;
+    cached: number;
+}
+export interface OverviewTransactionsReport {
+    transactions: Array<OverviewTransaction>;
+}
+export interface OverviewData extends OverviewTransactionsReport {
+    errors: {
+        count: number;
+        rate: number;
+    };
+    count: number;
+    meanDuration: number;
+    meanTpdex: number;
+    timeRange: string;
+}

package/dist/Models/Transactions/Overview.js

@@ -0,0 +1 @@
+

package/dist/Models/Transactions/encoding.d.ts

@@ -0,0 +1,49 @@
+import type { Transaction } from "./types.js";
+/**
+ * How a transaction is encoded into the values its facets offer.
+ *
+ * These three encodings are shared by `deriveTransactionFacets`, which produces the vocabulary,
+ * and `filterTransactions`, which consumes selections from it. They have to agree: if a facet
+ * offers a value the filter cannot match, or the filter accepts one the facet never offers,
+ * nothing throws and nobody finds out. Two copies would drift silently, so there is one.
+ */
+/** The class token of a status code: `404` is in class `"4"`. */
+export declare const statusClassOf: (statusCode: number) => string;
+/**
+ * The status tokens a transaction answers to (ADR 0002): its class (`"4"`), its code (`"404"`), and
+ * `failure`, which is the transaction's own status and not a code.
+ */
+export declare const statusGroupsOf: (transaction: Transaction) => string[];
+/** `"4xx"` (in any case) is a label, not a value; a consumer that passes it means the class `"4"`. */
+export declare const canonicalStatusToken: (value: string) => string;
+export interface StatusSelection {
+    classes: string[];
+    codes: string[];
+    /** Codes excluded from a class that is selected whole. */
+    excluded: string[];
+    failure: boolean;
+}
+/**
+ * Reads status tokens into what they select. A value outside the vocabulary is reported with
+ * `console.error` and ignored, never dropped in silence: this runs during render, where a stale URL
+ * must not crash the page, and the report is how the typo or stale value gets found.
+ *
+ * A code beside its own class reads as the class, and an exclusion only means something beside its
+ * class, so both are dropped (ADR 0002, "Reading a filter").
+ */
+export declare function parseStatusSelection(values: string[]): StatusSelection;
+/**
+ * Cache status, folding the legacy `cached` boolean into the status it stands for.
+ *
+ * A transaction that reported nothing resolves to `unknown`, not to `miss`. "Nothing is known" and
+ * "the cache was consulted and did not have it" are different facts, and only the second is a miss;
+ * calling absence a miss makes a claim the transaction never made. An explicit `cached: false` is
+ * a claim, and stays a miss.
+ */
+export declare const effectiveCacheStatus: (transaction: Transaction) => string;
+/** Tags as `key=value` pairs: the key carries the meaning, so a bare value would conflate keys. */
+export declare const tagPairsOf: (transaction: Transaction) => string[];
+/** Status classes a facet may offer, in reading order. Anything outside this is not offered. */
+export declare const statusClassOrder: string[];
+/** Cache statuses a facet may offer, in reading order. `unknown` sits last: it is an absence. */
+export declare const cacheStatusOrder: string[];

package/dist/Models/Transactions/encoding.js

@@ -0,0 +1,26 @@
+const n = (e) => String(Math.floor(e / 100)), o = (e) => {
+  const t = [n(e.statusCode), String(e.statusCode)];
+  return e.status === "Failed" && t.push("failure"), t;
+}, u = (e) => e.replace(/^([1-5])xx$/i, "$1"), i = /^(?:[1-5]|[1-5]\d\d|-[1-5]\d\d|failure)$/;
+function l(e) {
+  const t = e.map(u).filter((s, c) => i.test(s) ? !0 : (console.error(
+    `Unknown status value "${e[c]}" ignored: expected a class ("4"), a code ("404"), an exclusion ("-404") or "failure".`
+  ), !1)), a = t.filter((s) => s.length === 1), r = (s) => a.includes(s[0]);
+  return {
+    classes: a,
+    codes: t.filter((s) => s.length === 3 && !r(s)),
+    excluded: t.filter((s) => s.startsWith("-") && r(s.slice(1))).map((s) => s.slice(1)),
+    failure: t.includes("failure")
+  };
+}
+const d = (e) => e.cacheStatus ? e.cacheStatus : e.cached === void 0 ? "unknown" : e.cached ? "hit" : "miss", f = (e) => Object.entries(e.tags ?? {}).map(([t, a]) => `${t}=${a}`), h = ["1", "2", "3", "4", "5"], p = ["hit", "miss", "stale", "bypass", "unknown"];
+export {
+  p as cacheStatusOrder,
+  u as canonicalStatusToken,
+  d as effectiveCacheStatus,
+  l as parseStatusSelection,
+  n as statusClassOf,
+  h as statusClassOrder,
+  o as statusGroupsOf,
+  f as tagPairsOf
+};

package/dist/Models/Transactions/endpoints.d.ts

@@ -0,0 +1,15 @@
+import type { Transaction } from "./types.js";
+/** Name under which transactions without an `apiName` are grouped. */
+export declare const UNKNOWN_API = "unknown-api";
+export type EndpointNodeType = "api" | "folder" | "endpoint";
+/** A node of the endpoint tree: an API, then the path segments below it. */
+export interface Selection {
+    type: EndpointNodeType;
+    apiName: string;
+    segments: string[];
+}
+export declare function apiOf(transaction: Transaction): string;
+/** Path segments of the request target: no query, no scheme or host. Never throws. */
+export declare function segmentsOf(transaction: Transaction): string[];
+/** Whether the transaction sits at or below the selected node, by whole segments. */
+export declare function isUnder(transaction: Transaction, selection: Pick<Selection, "apiName" | "segments">): boolean;

package/dist/Models/Transactions/endpoints.js

@@ -0,0 +1,21 @@
+import { splitRequestTarget as a } from "../Http/requestTarget.js";
+import { MAX_TREE_DEPTH as f } from "./treeDepth.js";
+const i = "unknown-api", m = /^[a-z][a-z0-9+.-]*:\/\/[^/]*/i;
+function o(e) {
+  return e.apiName || i;
+}
+function p(e) {
+  const { path: t } = a(e.url);
+  return t.replace(m, "").split("/").filter(Boolean);
+}
+function l(e, t) {
+  if (o(e) !== t.apiName) return !1;
+  const n = p(e);
+  return t.segments.length > f && n.length !== t.segments.length ? !1 : t.segments.every((r, s) => n[s] === r);
+}
+export {
+  i as UNKNOWN_API,
+  o as apiOf,
+  l as isUnder,
+  p as segmentsOf
+};