lighthouse-audit-utils 1.0.0 → 1.2.3

package/README.md

@@ -1,14 +1,17 @@
 # lighthouse-audit-utils
 
-Everything you'd do with a finished Lighthouse run, in one call: write the
-reports to disk, print the fix list to the terminal, and fail the run if a
-category scored below its threshold. Each step can be configured or disabled.
+Programmatic [Lighthouse](https://github.com/GoogleChrome/lighthouse) audit utilities for CI and performance testing: score-threshold checking, HTML/JSON report writing, and a recommendations logger (ie, what is seen in a lighthouse report UI), all from a finished Lighthouse run in one call. Each step can be configured or disabled.
+
+Running the audits from Playwright? [`lighthouse-audit-utils/playwright`](#playwright)
+ships the CDP wiring as a fixture, so a test can audit whatever page it's on —
+handy for Lighthouse CI-style performance budgets inside a Playwright suite.
 
 ```bash
 npm install --save-dev lighthouse-audit-utils
 ```
 
-`lighthouse` is a peer dependency.
+`lighthouse` is a peer dependency; `@playwright/test` is an optional one, needed
+only if using the [Playwright entrypoint](#playwright).
 
 ## Usage
 
@@ -56,16 +59,15 @@ await handleAuditResult({
 ```
 
 The three steps run in that order — reports, recommendations, thresholds — so a
-failing run still prints its fix list before throwing.
+failing run still prints its recommendations before throwing.
 
 | Option            | Default    | Description                                                  |
 | ----------------- | ---------- | ------------------------------------------------------------ |
 | `result`          | _required_ | The full `RunnerResult` from a Lighthouse run                |
 | `reports`         | _none_     | Where to write the reports; omit to skip writing them        |
-| `recommendations` | _none_     | Recommendation logging options, or `false` to skip                  |
+| `recommendations` | _none_     | Recommendation logging options, or `false` to skip           |
 | `thresholds`      | `100`      | Minimum scores (0-100) — one number for all, or per category |
-| `ignoreError`     | `false`    | Return the threshold failures rather than throwing on them              |
-
+| `ignoreError`     | `false`    | Return the threshold failures rather than throwing on them   |
 
 ```ts
 // just the log
@@ -115,7 +117,7 @@ Pass `recommendations: false` to skip the log entirely.
 
 #### Output
 
-The log is the same fix list the report UI shows — failing audits, their
+The log is the same recommendations the report UI shows — failing audits, their
 estimated savings, and the individual offending URLs/nodes — so a failing CI run
 is actionable without downloading and opening the HTML report. Audits are
 grouped by category and sorted by estimated savings, so the biggest wins come
@@ -140,13 +142,88 @@ Performance: 87
       render-blocking-insight · score 50
         - https://example.com/assets/index.css  ·  Transfer Size: 12.4 KiB  ·  Duration: 52 ms
 
-Accessibility: 100 — nothing to fix
+Accessibility: 100 — nothing to flag
 ```
 
-## Example: Playwright
+## Individual utilities
 
-Lighthouse navigates over the CDP port itself, so launch a persistent context on
-that port and point `lighthouse` at it.
+The three steps are also exported on their own, each taking the report first and
+its options second:
+
+```ts
+writeReports(result, { directory, name })
+logRecommendations(lhr, { label, maxItems, maxValueLength })
+checkAgainstThresholds(lhr, { thresholds, ignoreError })
+```
+
+## Playwright
+
+`lighthouse-audit-utils/playwright` ships the wiring as a fixture.
+
+```ts
+// fixtures.ts
+import { desktopConfig } from 'lighthouse'
+import { withLighthouse } from 'lighthouse-audit-utils/playwright'
+
+export const lighthouseTest = withLighthouse({
+  basePort: 9222,
+  lighthouseArgs: {
+    flags: { disableStorageReset: true, output: ['html', 'json'] },
+    config: {
+      extends: 'lighthouse:default',
+      settings: { skipAudits: ['color-contrast'] },
+    },
+  },
+  thresholds: { performance: 70 },
+})
+
+// a.spec.ts
+lighthouseTest('home page', async ({ page, runAudit }) => {
+  await page.goto('/')
+  await runAudit({
+    name: 'desktop',
+    lighthouseArgs: { config: desktopConfig },
+  })
+  await runAudit({ name: 'mobile', thresholds: { performance: 60 } }) // merges over the fixture's value
+})
+```
+
+- Each call to `runAudit` audits whatever page the test is currently on and writes its reports to the test's output directory.
+- Run `runAudit` more than once for more than one form factor
+  — wrap the calls in `test.step` if you want them grouped in the report.
+- `withLighthouse(options, test)` takes the test to extend second, so you can layer
+  it onto your own fixtures; omit it to start from Playwright's `test`.
+
+| Option           | Required | Description                                                                              |
+| ---------------- | -------- | ---------------------------------------------------------------------------------------- |
+| `basePort`       | yes      | First worker's CDP port; each further worker gets the next one up                        |
+| `lighthouseArgs` | no       | `flags` and `config` for `lighthouse()`; `url` and `flags.port` are set for you          |
+| `reports`        | no       | `(context) => { directory, name }`, or `false` to skip writing them                      |
+| `launchOptions`  | no       | Merged into the persistent context launch, which already sets the CDP port and `baseURL` |
+
+Plus everything [`runAudit`](#usage) from `lighthouse-audit-utils` takes —
+`thresholds`, `ignoreError`, `recommendations`.
+
+The `runAudit` fixture takes `name` — which names that run's reports, so two
+audits in one test don't overwrite each other — and `lighthouseArgs`,
+`thresholds`, `ignoreError` and `recommendations`, to overwrite the overall fixture's:
+
+```ts
+const { result, failures } = await runAudit({
+  name: 'logged-in',
+  thresholds: { performance: 50 },
+  lighthouseArgs: { config: { settings: { onlyCategories: ['performance'] } } },
+})
+```
+
+`thresholds` merge when both are objects; anything else replaces, since a flat
+number can't be partially overridden.
+
+`context` is overridden to launch a persistent Chrome profile on the CDP port,
+since Lighthouse navigates over that port itself rather than driving the
+Playwright `page` — this way both see the same browser session.
+
+### Doing it by hand
 
 ```ts
 import { desktopConfig } from 'lighthouse'
@@ -163,17 +240,6 @@ await runAudit({
 })
 ```
 
-## Individual utilities
-
-The three steps are also exported on their own, each taking the report first and
-its options second:
-
-```ts
-writeReports(result, { directory, name })
-logRecommendations(lhr, { label, maxItems, maxValueLength })
-checkAgainstThresholds(lhr, { thresholds, ignoreError })
-```
-
 ## Development
 
 ```bash

package/dist/chunk-4DICEJP6.js

@@ -0,0 +1,510 @@
+import { mkdir, writeFile } from 'fs/promises';
+import path from 'path';
+import lighthouse from 'lighthouse';
+
+// lighthouse-audit-utils 1.2.3
+
+// node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/predicate/isPrimitive.mjs
+function isPrimitive(value) {
+  return value == null || typeof value !== "object" && typeof value !== "function";
+}
+
+// node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/predicate/isTypedArray.mjs
+function isTypedArray(x) {
+  return ArrayBuffer.isView(x) && !(x instanceof DataView);
+}
+
+// node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/object/clone.mjs
+function clone(obj) {
+  if (isPrimitive(obj)) return obj;
+  if (Array.isArray(obj) || isTypedArray(obj) || obj instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && obj instanceof SharedArrayBuffer) return obj.slice(0);
+  const prototype = Object.getPrototypeOf(obj);
+  if (prototype == null) return Object.assign(Object.create(prototype), obj);
+  const Constructor = prototype.constructor;
+  if (obj instanceof Date || obj instanceof Map || obj instanceof Set) return new Constructor(obj);
+  if (obj instanceof RegExp) {
+    const newRegExp = new Constructor(obj);
+    newRegExp.lastIndex = obj.lastIndex;
+    return newRegExp;
+  }
+  if (obj instanceof DataView) return new Constructor(obj.buffer.slice(0));
+  if (obj instanceof Error) {
+    let newError;
+    if (obj instanceof AggregateError) newError = new Constructor(obj.errors, obj.message, { cause: obj.cause });
+    else newError = new Constructor(obj.message, { cause: obj.cause });
+    newError.stack = obj.stack;
+    Object.assign(newError, obj);
+    return newError;
+  }
+  if (typeof File !== "undefined" && obj instanceof File) return new Constructor([obj], obj.name, {
+    type: obj.type,
+    lastModified: obj.lastModified
+  });
+  if (typeof obj === "object") return Object.assign(Object.create(prototype), obj);
+  return obj;
+}
+
+// node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/compat/_internal/getSymbols.mjs
+function getSymbols(object) {
+  return Object.getOwnPropertySymbols(object).filter((symbol) => Object.prototype.propertyIsEnumerable.call(object, symbol));
+}
+
+// node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/compat/_internal/getTag.mjs
+function getTag(value) {
+  if (value == null) return value === void 0 ? "[object Undefined]" : "[object Null]";
+  return Object.prototype.toString.call(value);
+}
+
+// node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/compat/_internal/tags.mjs
+var regexpTag = "[object RegExp]";
+var stringTag = "[object String]";
+var numberTag = "[object Number]";
+var booleanTag = "[object Boolean]";
+var argumentsTag = "[object Arguments]";
+var symbolTag = "[object Symbol]";
+var dateTag = "[object Date]";
+var mapTag = "[object Map]";
+var setTag = "[object Set]";
+var arrayTag = "[object Array]";
+var arrayBufferTag = "[object ArrayBuffer]";
+var objectTag = "[object Object]";
+var dataViewTag = "[object DataView]";
+var uint8ArrayTag = "[object Uint8Array]";
+var uint8ClampedArrayTag = "[object Uint8ClampedArray]";
+var uint16ArrayTag = "[object Uint16Array]";
+var uint32ArrayTag = "[object Uint32Array]";
+var int8ArrayTag = "[object Int8Array]";
+var int16ArrayTag = "[object Int16Array]";
+var int32ArrayTag = "[object Int32Array]";
+var float32ArrayTag = "[object Float32Array]";
+var float64ArrayTag = "[object Float64Array]";
+
+// node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/_internal/globalThis.mjs
+var globalThis_ = typeof globalThis === "object" && globalThis || typeof window === "object" && window || typeof self === "object" && self || typeof global === "object" && global || /* @__PURE__ */ (function() {
+  return this;
+})();
+
+// node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/predicate/isBuffer.mjs
+function isBuffer(x) {
+  return typeof globalThis_.Buffer !== "undefined" && globalThis_.Buffer.isBuffer(x);
+}
+
+// node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/object/cloneDeepWith.mjs
+function cloneDeepWithImpl(valueToClone, keyToClone, objectToClone, stack = /* @__PURE__ */ new Map(), cloneValue = void 0) {
+  const cloned = cloneValue?.(valueToClone, keyToClone, objectToClone, stack);
+  if (cloned !== void 0) return cloned;
+  if (isPrimitive(valueToClone)) return valueToClone;
+  if (stack.has(valueToClone)) return stack.get(valueToClone);
+  if (Array.isArray(valueToClone)) {
+    const result = new Array(valueToClone.length);
+    stack.set(valueToClone, result);
+    for (let i = 0; i < valueToClone.length; i++) result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue);
+    if (Object.hasOwn(valueToClone, "index")) result.index = valueToClone.index;
+    if (Object.hasOwn(valueToClone, "input")) result.input = valueToClone.input;
+    return result;
+  }
+  if (valueToClone instanceof Date) return new Date(valueToClone.getTime());
+  if (valueToClone instanceof RegExp) {
+    const result = new RegExp(valueToClone.source, valueToClone.flags);
+    result.lastIndex = valueToClone.lastIndex;
+    return result;
+  }
+  if (valueToClone instanceof Map) {
+    const result = /* @__PURE__ */ new Map();
+    stack.set(valueToClone, result);
+    for (const [key, value] of valueToClone) result.set(key, cloneDeepWithImpl(value, key, objectToClone, stack, cloneValue));
+    return result;
+  }
+  if (valueToClone instanceof Set) {
+    const result = /* @__PURE__ */ new Set();
+    stack.set(valueToClone, result);
+    for (const value of valueToClone) result.add(cloneDeepWithImpl(value, void 0, objectToClone, stack, cloneValue));
+    return result;
+  }
+  if (isBuffer(valueToClone)) return valueToClone.subarray();
+  if (isTypedArray(valueToClone)) {
+    const result = new (Object.getPrototypeOf(valueToClone)).constructor(valueToClone.length);
+    stack.set(valueToClone, result);
+    for (let i = 0; i < valueToClone.length; i++) result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (valueToClone instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && valueToClone instanceof SharedArrayBuffer) return valueToClone.slice(0);
+  if (valueToClone instanceof DataView) {
+    const result = new DataView(valueToClone.buffer.slice(0), valueToClone.byteOffset, valueToClone.byteLength);
+    stack.set(valueToClone, result);
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (typeof File !== "undefined" && valueToClone instanceof File) {
+    const result = new File([valueToClone], valueToClone.name, { type: valueToClone.type });
+    stack.set(valueToClone, result);
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (typeof Blob !== "undefined" && valueToClone instanceof Blob) {
+    const result = new Blob([valueToClone], { type: valueToClone.type });
+    stack.set(valueToClone, result);
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (valueToClone instanceof Error) {
+    const result = structuredClone(valueToClone);
+    stack.set(valueToClone, result);
+    result.message = valueToClone.message;
+    result.name = valueToClone.name;
+    result.stack = valueToClone.stack;
+    result.cause = valueToClone.cause;
+    result.constructor = valueToClone.constructor;
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (valueToClone instanceof Boolean) {
+    const result = new Boolean(valueToClone.valueOf());
+    stack.set(valueToClone, result);
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (valueToClone instanceof Number) {
+    const result = new Number(valueToClone.valueOf());
+    stack.set(valueToClone, result);
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (valueToClone instanceof String) {
+    const result = new String(valueToClone.valueOf());
+    stack.set(valueToClone, result);
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (typeof valueToClone === "object" && isCloneableObject(valueToClone)) {
+    const result = Object.create(Object.getPrototypeOf(valueToClone));
+    stack.set(valueToClone, result);
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  return valueToClone;
+}
+function copyProperties(target, source, objectToClone = target, stack, cloneValue) {
+  const keys = [...Object.keys(source), ...getSymbols(source)];
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    const descriptor = Object.getOwnPropertyDescriptor(target, key);
+    if (descriptor == null || descriptor.writable) target[key] = cloneDeepWithImpl(source[key], key, objectToClone, stack, cloneValue);
+  }
+}
+function isCloneableObject(object) {
+  switch (getTag(object)) {
+    case argumentsTag:
+    case arrayTag:
+    case arrayBufferTag:
+    case dataViewTag:
+    case booleanTag:
+    case dateTag:
+    case float32ArrayTag:
+    case float64ArrayTag:
+    case int8ArrayTag:
+    case int16ArrayTag:
+    case int32ArrayTag:
+    case mapTag:
+    case numberTag:
+    case objectTag:
+    case regexpTag:
+    case setTag:
+    case stringTag:
+    case symbolTag:
+    case uint8ArrayTag:
+    case uint8ClampedArrayTag:
+    case uint16ArrayTag:
+    case uint32ArrayTag:
+      return true;
+    default:
+      return false;
+  }
+}
+
+// node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/object/cloneDeep.mjs
+function cloneDeep(obj) {
+  return cloneDeepWithImpl(obj, void 0, obj, /* @__PURE__ */ new Map(), void 0);
+}
+
+// node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/predicate/isPlainObject.mjs
+function isPlainObject(value) {
+  if (!value || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  if (!(proto === null || proto === Object.prototype || Object.getPrototypeOf(proto) === null)) return false;
+  return Object.prototype.toString.call(value) === "[object Object]";
+}
+
+// node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/_internal/isUnsafeProperty.mjs
+function isUnsafeProperty(key) {
+  return key === "__proto__";
+}
+
+// node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/object/mergeWith.mjs
+function mergeWith(target, source, merge) {
+  const sourceKeys = Object.keys(source);
+  for (let i = 0; i < sourceKeys.length; i++) {
+    const key = sourceKeys[i];
+    if (isUnsafeProperty(key)) continue;
+    const sourceValue = source[key];
+    const targetValue = target[key];
+    const merged = merge(targetValue, sourceValue, key, target, source);
+    if (merged !== void 0) target[key] = merged;
+    else if (Array.isArray(sourceValue)) if (Array.isArray(targetValue)) target[key] = mergeWith(targetValue, sourceValue, merge);
+    else target[key] = mergeWith([], sourceValue, merge);
+    else if (isPlainObject(sourceValue)) if (isPlainObject(targetValue)) target[key] = mergeWith(targetValue, sourceValue, merge);
+    else target[key] = mergeWith({}, sourceValue, merge);
+    else if (targetValue === void 0 || sourceValue !== void 0) target[key] = sourceValue;
+  }
+  return target;
+}
+
+// node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/object/toMerged.mjs
+function toMerged(target, source) {
+  return mergeWith(cloneDeep(target), source, function mergeRecursively(targetValue, sourceValue) {
+    if (Array.isArray(sourceValue)) if (Array.isArray(targetValue)) return mergeWith(clone(targetValue), sourceValue, mergeRecursively);
+    else return mergeWith([], sourceValue, mergeRecursively);
+    else if (isPlainObject(sourceValue)) if (isPlainObject(targetValue)) return mergeWith(clone(targetValue), sourceValue, mergeRecursively);
+    else return mergeWith({}, sourceValue, mergeRecursively);
+  });
+}
+
+// node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/array/compact.mjs
+function compact(arr) {
+  const result = [];
+  for (let i = 0; i < arr.length; i++) {
+    const item = arr[i];
+    if (item) result.push(item);
+  }
+  return result;
+}
+
+// node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/_internal/compareValues.mjs
+function nullishRank(value) {
+  if (value === null) return 1;
+  if (value === void 0) return 2;
+  return 0;
+}
+function compareAscending(a, b) {
+  const aRank = nullishRank(a);
+  const bRank = nullishRank(b);
+  if (aRank < bRank) return -1;
+  if (aRank > bRank) return 1;
+  if (aRank !== 0) return 0;
+  if (a < b) return -1;
+  if (a > b) return 1;
+  return 0;
+}
+function compareValues(a, b, order) {
+  return order === "asc" ? compareAscending(a, b) : compareAscending(b, a);
+}
+
+// node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/array/orderBy.mjs
+function orderBy(arr, criteria, orders) {
+  return arr.slice().sort((a, b) => {
+    const ordersLength = orders.length;
+    for (let i = 0; i < criteria.length; i++) {
+      const order = ordersLength > i ? orders[i] : orders[ordersLength - 1];
+      const criterion = criteria[i];
+      const criterionIsFunction = typeof criterion === "function";
+      const result = compareValues(criterionIsFunction ? criterion(a) : a[criterion], criterionIsFunction ? criterion(b) : b[criterion], order);
+      if (result !== 0) return result;
+    }
+    return 0;
+  });
+}
+
+// src/log-recommendations.ts
+var resolveMetricSavings = (audit) => Object.entries(audit.metricSavings ?? {}).filter(([, ms]) => !!ms);
+var metricValueType = (metric) => metric === "CLS" ? "numeric" : "ms";
+var formatValue = (value, valueType, maxValueLength) => {
+  if (value === void 0 || typeof value === "boolean") {
+    return "";
+  }
+  if (typeof value === "number") {
+    if (valueType === "bytes") {
+      const kib = value / 1024;
+      const rounded = kib >= 100 ? Math.round(kib) : Math.round(kib * 10) / 10;
+      return `${rounded} KiB`;
+    }
+    if (valueType === "ms" || valueType === "timespanMs") {
+      return `${Math.round(value)} ms`;
+    }
+    return String(Math.round(value * 100) / 100);
+  }
+  const text = (() => {
+    if (typeof value === "string") {
+      return value;
+    }
+    if (!("type" in value)) {
+      return "";
+    }
+    switch (value.type) {
+      case "url":
+        return value.value;
+      case "link":
+        return value.url || value.text;
+      case "code":
+        return String(value.value);
+      case "node":
+        return value.nodeLabel ?? value.selector ?? value.snippet ?? "";
+      case "source-location":
+        return `${value.url}:${value.line}:${value.column}`;
+      default:
+        return "";
+    }
+  })();
+  const singleLine = text.replace(/\s+/g, " ").trim();
+  return singleLine.length > maxValueLength ? `${singleLine.slice(0, maxValueLength)}\u2026` : singleLine;
+};
+var formatItems = (details, { maxItems, maxValueLength }) => {
+  if (details?.type !== "opportunity" && details?.type !== "table") {
+    return [];
+  }
+  const [identity, ...measures] = details.headings.filter(({ key }) => !!key);
+  if (!identity) {
+    return [];
+  }
+  const MEASURE_TYPES = [
+    "bytes",
+    "ms",
+    "timespanMs",
+    "numeric"
+  ];
+  const lines = details.items.slice(0, maxItems).map((item) => {
+    const columns = [
+      formatValue(item[identity.key ?? ""], identity.valueType, maxValueLength),
+      ...measures.filter(({ valueType }) => MEASURE_TYPES.includes(valueType)).map(
+        (heading) => `${heading.label}: ${formatValue(item[heading.key ?? ""], heading.valueType, maxValueLength)}`
+      )
+    ];
+    return `        - ${compact(columns).join("  \xB7  ")}`;
+  });
+  const remaining = details.items.length - maxItems;
+  if (remaining > 0) {
+    lines.push(`        - \u2026and ${remaining} more`);
+  }
+  return lines;
+};
+var logRecommendations = (lhr, {
+  label,
+  maxItems = 5,
+  maxValueLength = 120
+}) => {
+  const lines = [
+    "",
+    `\u2500\u2500\u2500\u2500\u2500 Lighthouse recommendations${label ? `: ${label}` : ""} \u2014 ${lhr.finalDisplayedUrl} \u2500\u2500\u2500\u2500\u2500`
+  ];
+  for (const category of Object.values(lhr.categories)) {
+    const categoryScoreValue = category.score === null ? "N/A" : Math.round(category.score * 100);
+    const categoryLine = `${category.title}: ${categoryScoreValue}`;
+    const failing = orderBy(
+      category.auditRefs.map(({ id }) => lhr.audits[id]).filter((audit) => !!audit && audit.score !== null && audit.score < 1),
+      [
+        (audit) => Math.max(0, ...resolveMetricSavings(audit).map(([, ms]) => ms)),
+        ({ score }) => score ?? 0
+      ],
+      ["desc", "asc"]
+    );
+    if (!failing.length) {
+      lines.push("", `${categoryLine} \u2014 nothing to flag`);
+      continue;
+    }
+    lines.push("", categoryLine);
+    for (const audit of failing) {
+      const displayValue = audit.displayValue ? ` (${audit.displayValue})` : "";
+      const savingsValue = (() => {
+        if (audit.displayValue?.toLowerCase().includes("savings")) {
+          return "";
+        }
+        const overallSavingsBytes = audit.details?.type === "opportunity" ? audit.details.overallSavingsBytes : void 0;
+        const estSavings = compact([
+          ...resolveMetricSavings(audit).map(
+            ([metric, value]) => `${metric} ${formatValue(value, metricValueType(metric), maxValueLength)}`
+          ),
+          formatValue(overallSavingsBytes, "bytes", maxValueLength)
+        ]);
+        return estSavings.length ? ` \u2014 est. savings: ${estSavings.join(", ")}` : "";
+      })();
+      const scoreValue = audit.score === null ? "N/A" : Math.round(audit.score * 100);
+      lines.push(`  \u2022 ${audit.title}${displayValue}${savingsValue}`);
+      lines.push(`      ${audit.id} \xB7 score ${scoreValue}`);
+      lines.push(...formatItems(audit.details, { maxItems, maxValueLength }));
+    }
+  }
+  lines.push("");
+  console.log(lines.join("\n"));
+};
+
+// src/thresholds.ts
+var thresholdFailureMessage = (failures) => [
+  "Lighthouse thresholds not met:",
+  ...failures.map(
+    ({ category, minimum, score }) => `${category} scored ${score}, below the ${minimum} threshold`
+  )
+].join("\n");
+var checkAgainstThresholds = (lhr, { thresholds = 100, ignoreError }) => {
+  const isFlat = typeof thresholds === "number";
+  const defaultMinimum = isFlat ? thresholds : 100;
+  const minimums = isFlat ? {} : thresholds ?? {};
+  const failures = Object.values(lhr.categories).filter((c) => c.score !== null).map(({ id, score }) => ({
+    category: id,
+    minimum: minimums[id] ?? defaultMinimum,
+    score: score * 100
+  })).filter(({ score, minimum }) => score < minimum);
+  if (!failures.length) {
+    return void 0;
+  }
+  if (!ignoreError) {
+    throw new Error(thresholdFailureMessage(failures));
+  }
+  return failures;
+};
+var writeReports = async (result, { directory, name }) => {
+  const formats = [result.lhr.configSettings.output].flat();
+  await mkdir(directory, { recursive: true });
+  await Promise.all(
+    [result.report].flat().map(
+      (report, i) => writeFile(path.join(directory, `${name}.${formats[i]}`), report)
+    )
+  );
+};
+
+// src/handle-audit-result.ts
+var handleAuditResult = async ({
+  result,
+  reports,
+  thresholds,
+  ignoreError,
+  recommendations
+}) => {
+  if (reports) {
+    await writeReports(result, reports);
+  }
+  if (recommendations !== false) {
+    logRecommendations(result.lhr, {
+      label: reports?.name,
+      ...recommendations
+    });
+  }
+  const failures = checkAgainstThresholds(result.lhr, {
+    thresholds,
+    ignoreError
+  });
+  return failures;
+};
+var runAudit = async ({
+  lighthouseArgs: { url, flags, config },
+  ...handleArgs
+}) => {
+  const result = await lighthouse(url, flags, config);
+  if (!result) {
+    throw new Error(`Lighthouse returned no result for ${url}`);
+  }
+  const failures = await handleAuditResult({ result, ...handleArgs });
+  return { result, failures };
+};
+
+export { checkAgainstThresholds, handleAuditResult, logRecommendations, runAudit, toMerged, writeReports };
+//# sourceMappingURL=chunk-4DICEJP6.js.map
+//# sourceMappingURL=chunk-4DICEJP6.js.map