@thi.ng/pixel-analysis 1.1.1 → 2.0.0

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2025-07-27T16:56:27Z
+- **Last updated**: 2025-07-30T22:32:35Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.
@@ -11,6 +11,19 @@ See [Conventional Commits](https://conventionalcommits.org/) for commit guidelin
 **Note:** Unlisted _patch_ versions only involve non-code or otherwise excluded changes
 and/or version bumps of transitive dependencies.
 
+# [2.0.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/pixel-analysis@2.0.0) (2025-07-30)
+
+#### 🛑 Breaking changes
+
+- update color analysis result types, add aggregation ([8c70504](https://github.com/thi-ng/umbrella/commit/8c70504))
+- BREAKING CHANGE:  update color analysis result types, add aggregation
+  - add `BaseColorAnalysisResult`, `AggregatedColorAnalysisResult`
+  - update `ColorAnalysisResult`, use `Metrics`
+  - add `aggregateColorResults()`
+  - update `analyzeColors()`, `deriveColorResults()`
+  - rename `computeHueRange()` => `hueRange()`
+  - update deps
+
 ### [1.1.1](https://github.com/thi-ng/umbrella/tree/@thi.ng/pixel-analysis@1.1.1) (2025-07-27)
 
 #### 🩹 Bug fixes

package/README.md

@@ -7,7 +7,7 @@
 [![Mastodon Follow](https://img.shields.io/mastodon/follow/109331703950160316?domain=https%3A%2F%2Fmastodon.thi.ng&style=social)](https://mastodon.thi.ng/@toxi)
 
 > [!NOTE]
-> This is one of 209 standalone projects, maintained as part
+> This is one of 210 standalone projects, maintained as part
 > of the [@thi.ng/umbrella](https://github.com/thi-ng/umbrella/) monorepo
 > and anti-framework.
 >
@@ -81,7 +81,7 @@ For Node.js REPL:
 const pa = await import("@thi.ng/pixel-analysis");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 1.89 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 1.87 KB
 
 ## Dependencies
 
@@ -90,6 +90,7 @@ Package sizes (brotli'd, pre-treeshake): ESM: 1.89 KB
 - [@thi.ng/color](https://github.com/thi-ng/umbrella/tree/develop/packages/color)
 - [@thi.ng/compare](https://github.com/thi-ng/umbrella/tree/develop/packages/compare)
 - [@thi.ng/math](https://github.com/thi-ng/umbrella/tree/develop/packages/math)
+- [@thi.ng/metrics](https://github.com/thi-ng/umbrella/tree/develop/packages/metrics)
 - [@thi.ng/pixel](https://github.com/thi-ng/umbrella/tree/develop/packages/pixel)
 - [@thi.ng/pixel-convolve](https://github.com/thi-ng/umbrella/tree/develop/packages/pixel-convolve)
 - [@thi.ng/pixel-dominant-colors](https://github.com/thi-ng/umbrella/tree/develop/packages/pixel-dominant-colors)

package/analyze-colors.d.ts

@@ -1,6 +1,6 @@
 import { FloatBuffer } from "@thi.ng/pixel/float";
 import { IntBuffer } from "@thi.ng/pixel/int";
-import type { ColorAnalysisOpts, ColorAnalysisResult } from "./api.js";
+import type { AggregatedColorAnalysisResult, BaseColorAnalysisResult, ColorAnalysisOpts, ColorAnalysisResult } from "./api.js";
 import { type DEFAULT_TEMPERATURE_COEFFS } from "./hues.js";
 /**
  * Performs a set of image/color analyses on provided pixel buffer.
@@ -10,12 +10,15 @@ import { type DEFAULT_TEMPERATURE_COEFFS } from "./hues.js";
  */
 export declare const analyzeColors: (img: FloatBuffer | IntBuffer, opts?: Partial<ColorAnalysisOpts>) => ColorAnalysisResult;
 /**
- * Computes a number of metrics (partial {@link ColorAnalysisResult}) derived from
- * given raw SRGB colors. Helper function for {@link analyzeColors}.
+ * Computes a number of metrics (partial {@link ColorAnalysisResult}) derived
+ * from given raw SRGB colors and their (normalized) areas. Helper function for
+ * {@link analyzeColors}.
  *
  * @param colors
+ * @param areas
  * @param minSat
  * @param tempCoeffs
  */
-export declare const derivedColorResults: (colors: number[][], minSat?: number, tempCoeffs?: typeof DEFAULT_TEMPERATURE_COEFFS) => Pick<ColorAnalysisResult, "css" | "srgb" | "hsv" | "oklch" | "hue" | "sat" | "luma" | "contrast" | "colorContrast" | "temperature">;
+export declare const deriveColorResults: (colors: number[][], areas?: number[], minSat?: number, tempCoeffs?: typeof DEFAULT_TEMPERATURE_COEFFS) => BaseColorAnalysisResult;
+export declare const aggregateColorResults: (results: Omit<ColorAnalysisResult, "img" | "imgGray" | "imgHsv">[], numColors?: number) => AggregatedColorAnalysisResult;
 //# sourceMappingURL=analyze-colors.d.ts.map

package/analyze-colors.js

@@ -6,8 +6,16 @@ import { oklch } from "@thi.ng/color/oklch/oklch";
 import { srgb } from "@thi.ng/color/srgb/srgb";
 import { compareByKey } from "@thi.ng/compare/keys";
 import { compareNumDesc } from "@thi.ng/compare/numeric";
-import { TAU } from "@thi.ng/math/api";
 import { fit } from "@thi.ng/math/fit";
+import {
+  aggregateCircularMetrics,
+  aggregateMetrics,
+  aggregateWeightedMetrics,
+  defCircularMetric,
+  defMetric,
+  defWeightedMetric
+} from "@thi.ng/metrics/metrics";
+import { dominantColorsMeanCut } from "@thi.ng/pixel-dominant-colors";
 import { dominantColorsKmeans } from "@thi.ng/pixel-dominant-colors/kmeans";
 import { FloatBuffer } from "@thi.ng/pixel/float";
 import { FLOAT_GRAY } from "@thi.ng/pixel/format/float-gray";
@@ -16,20 +24,11 @@ import { FLOAT_RGBA } from "@thi.ng/pixel/format/float-rgba";
 import { IntBuffer } from "@thi.ng/pixel/int";
 import { map } from "@thi.ng/transducers/map";
 import { max } from "@thi.ng/transducers/max";
-import { minMax } from "@thi.ng/transducers/min-max";
 import { permutations } from "@thi.ng/transducers/permutations";
-import { reduce } from "@thi.ng/transducers/reduce";
 import { transduce } from "@thi.ng/transducers/transduce";
-import { circularMean, circularSD } from "@thi.ng/vectors/circular";
-import { dot } from "@thi.ng/vectors/dot";
-import { vmean } from "@thi.ng/vectors/mean";
-import { mulN } from "@thi.ng/vectors/muln";
 import { roundN } from "@thi.ng/vectors/roundn";
-import { sd } from "@thi.ng/vectors/variance";
-import {
-  computeHueRange,
-  temperature
-} from "./hues.js";
+import { ones } from "@thi.ng/vectors/setn";
+import { temperature } from "./hues.js";
 const analyzeColors = (img, opts) => {
   let $img = img.format !== FLOAT_RGBA ? img.as(FLOAT_RGBA) : img;
   if (opts?.size) $img = __resize($img, opts.size);
@@ -37,68 +36,46 @@ const analyzeColors = (img, opts) => {
   const imgHsv = $img.as(FLOAT_HSVA);
   const colors = __dominantColors($img, opts);
   const colorAreas = colors.map((x) => x.area);
-  const derived = derivedColorResults(
+  const derived = deriveColorResults(
     colors.map((x) => x.color),
+    colorAreas,
     opts?.minSat,
     opts?.tempCoeffs
   );
-  const lumaRangeImg = reduce(minMax(), imgGray.data);
-  const weightedLuma = dot(derived.srgb.map(luminanceSrgb), colorAreas);
-  const weightedChroma = dot(
-    derived.oklch.map((x) => x[1]),
-    colorAreas
-  );
-  const weightedSat = dot(
-    derived.hsv.map((x) => x[1]),
-    colorAreas
-  );
+  const lumImg = defMetric(imgGray.data);
   return {
+    ...derived,
     img: $img,
     imgGray,
     imgHsv,
-    ...derived,
-    area: colorAreas,
+    lumImg,
     temperature: temperature(imgHsv, opts?.minSat, opts?.tempCoeffs),
-    contrastImg: lumaRangeImg[1] - lumaRangeImg[0],
-    lumaRangeImg,
-    weightedSat,
-    weightedLuma,
-    weightedChroma
+    contrastImg: lumImg.max - lumImg.min
   };
 };
-const derivedColorResults = (colors, minSat, tempCoeffs) => {
+const deriveColorResults = (colors, areas = ones(colors.length), minSat, tempCoeffs) => {
   const dominantLuma = colors.map((x) => luminanceSrgb(x));
   const dominantSrgb = colors.map((x) => srgb(x));
   const dominantHsv = dominantSrgb.map((x) => hsv(x));
   const dominantOklch = dominantSrgb.map((x) => oklch(x));
   const dominantCss = dominantSrgb.map((x) => css(x));
   const hues = dominantHsv.map((x) => x[0]);
-  const huesRad = mulN([], hues, TAU);
   const sats = dominantHsv.map((x) => x[1]);
-  const meanHue = circularMean(huesRad) / TAU;
-  const hueRange = computeHueRange(hues, meanHue);
-  const lumaRange = reduce(minMax(), dominantLuma);
+  const lum = defWeightedMetric(dominantLuma, areas);
   return {
     css: dominantCss,
     srgb: dominantSrgb,
     hsv: dominantHsv,
     oklch: dominantOklch,
-    hue: {
-      mean: meanHue,
-      range: hueRange,
-      sd: circularSD(huesRad) / TAU
-    },
-    sat: {
-      mean: vmean(sats),
-      range: reduce(minMax(), sats),
-      sd: sd(sats)
-    },
-    luma: {
-      mean: vmean(dominantLuma),
-      range: lumaRange,
-      sd: sd(dominantLuma)
-    },
-    contrast: lumaRange[1] - lumaRange[0],
+    hue: defCircularMetric(hues),
+    sat: defWeightedMetric(sats, areas),
+    chroma: defWeightedMetric(
+      dominantOklch.map((x) => x[1]),
+      areas
+    ),
+    lum,
+    areas,
+    contrast: lum.max - lum.min,
     colorContrast: fit(
       transduce(
         map((pair) => contrastWCAG(...pair)),
@@ -113,6 +90,33 @@ const derivedColorResults = (colors, minSat, tempCoeffs) => {
     temperature: temperature(dominantHsv, minSat, tempCoeffs)
   };
 };
+const aggregateColorResults = (results, numColors = 4) => {
+  const dominant = dominantColorsMeanCut(
+    results.flatMap((res) => res.srgb),
+    numColors
+  ).map((x) => srgb(x.color));
+  return {
+    srgb: dominant,
+    css: dominant.map((x) => css(x)),
+    hsv: dominant.map((x) => hsv(x)),
+    oklch: dominant.map((x) => oklch(x)),
+    hue: aggregateCircularMetrics(results.map((x) => x.hue)),
+    sat: aggregateWeightedMetrics(results.map((x) => x.sat)),
+    chroma: aggregateWeightedMetrics(results.map((x) => x.chroma)),
+    lum: aggregateWeightedMetrics(results.map((x) => x.lum)),
+    lumImg: aggregateMetrics(results.map((x) => x.lumImg)),
+    contrast: defMetric(results.map((x) => x.contrast)),
+    contrastImg: defMetric(results.map((x) => x.contrastImg)),
+    colorContrast: defMetric(results.map((x) => x.colorContrast)),
+    temperature: {
+      meanHue: defCircularMetric(
+        results.map((x) => x.temperature.meanHue)
+      ),
+      temp: defMetric(results.map((x) => x.temperature.temp)),
+      areaTemp: defMetric(results.map((x) => x.temperature.areaTemp))
+    }
+  };
+};
 const __dominantColors = (img, {
   dominantFn = dominantColorsKmeans,
   numColors = 4,
@@ -126,6 +130,7 @@ const __resize = ($img, size) => {
   return $img.resize(w, h);
 };
 export {
+  aggregateColorResults,
   analyzeColors,
-  derivedColorResults
+  deriveColorResults
 };

package/analyze-features.js

@@ -12,9 +12,9 @@ const { sqrt } = Math;
 const FMT_EDGE = FLOAT_GRAY_RANGE(-24, 24);
 const FMT_SOBEL = FLOAT_GRAY_RANGE(-4, 4);
 const analyzeFeatures = (img) => {
-  const $img = img.format !== FLOAT_GRAY ? img.as(FLOAT_GRAY) : img;
-  const { width, height } = $img;
+  const { width, height } = img;
   const numPixels = width * height;
+  const $img = img.format !== FLOAT_GRAY ? img.as(FLOAT_GRAY) : img;
   const imgEdge = convolveImage($img, { kernel: EDGE5 });
   imgEdge.format = FMT_EDGE;
   const imgSobelX = convolveImage($img, { kernel: SOBEL_X });

package/api.d.ts

@@ -1,12 +1,9 @@
 import type { Fn2 } from "@thi.ng/api";
 import type { HSV, Oklch, SRGB } from "@thi.ng/color";
+import type { Metric, WeightedMetric } from "@thi.ng/metrics";
 import type { FloatBuffer } from "@thi.ng/pixel";
 import type { DominantColor } from "@thi.ng/pixel-dominant-colors";
 import type { DEFAULT_TEMPERATURE_COEFFS } from "./hues.js";
-/**
- * 2-tuple representing a closed [min,max] value range/interval
- */
-export type Range = [number, number];
 export interface ColorAnalysisOpts {
     /**
      * Max. number of dominant colors.
@@ -37,22 +34,7 @@ export interface ColorAnalysisOpts {
      */
     prec: number;
 }
-/**
- * Result data structure returned by {@link analyzeColors}.
- */
-export interface ColorAnalysisResult {
-    /**
-     * Input image, possibly converted to float RGBA & resized.
-     */
-    img: FloatBuffer;
-    /**
-     * Float grayscale version of {@link ColorAnalysisResult.img}.
-     */
-    imgGray: FloatBuffer;
-    /**
-     * Float HSV version of {@link ColorAnalysisResult.img}.
-     */
-    imgHsv: FloatBuffer;
+export interface BaseColorAnalysisResult {
     /**
      * Dominant colors as CSS (hex) strings
      */
@@ -70,58 +52,31 @@ export interface ColorAnalysisResult {
      */
     oklch: Oklch[];
     /**
-     * Normalized areas of dominant color clusters
-     */
-    area: number[];
-    hue: {
-        /**
-         * Normalized mean hue (using circular mean).
-         */
-        mean: number;
-        /**
-         * Min/max HSV hue range of dominant colors. IMPORTANT: In case of
-         * circular overflow (360 => 0 degrees), the min hue WILL be greater
-         * than the max hue (e.g. a hue range of `[0.8, 0.2]` indicates the hue
-         * range from magenta -> orange). Also see {@link ColorAnalysisResult.hue.mean}.
-         */
-        range: Range;
-        /**
-         * Circular standard deviation of normalized hues.
-         */
-        sd: number;
-    };
-    sat: {
-        /**
-         * Mean saturation
-         */
-        mean: number;
-        /**
-         * Min/max HSV saturation range of dominant colors
-         */
-        range: Range;
-        /**
-         * Standard deviation of normalized saturation.
-         */
-        sd: number;
-    };
-    luma: {
-        /**
-         * Mean luminance
-         */
-        mean: number;
-        /**
-         * Min/max luminance range of dominant colors (obtained from SRGB)
-         */
-        range: Range;
-        /**
-         * Standard deviation of normalized luminance.
-         */
-        sd: number;
-    };
+     * HSV hue metrics of dominant colors.
+     *
+     * @remarks
+     * The mean and standard deviation are computed using circular versions. In
+     * case of circular overflow (1.0 => 0, aka 360 => 0 degrees), the min hue
+     * WILL be greater than the max hue (e.g. a hue range of `[0.8, 0.2]`
+     * indicates the hue range from magenta -> orange).
+     */
+    hue: Metric;
     /**
-     * Min/max luminance range of entire grayscale image (obtained from SRGB)
+     * HSV saturation metrics of dominant colors.
      */
-    lumaRangeImg: Range;
+    sat: WeightedMetric;
+    /**
+     * Oklch chroma metrics of dominant colors.
+     */
+    chroma: WeightedMetric;
+    /**
+     * sRGB-based luminance metrics of dominant colors.
+     */
+    lum: WeightedMetric;
+    /**
+     * Normalized areas of dominant colors
+     */
+    areas: number[];
     /**
      * Comprehensive {@link TemperatureResult} as produced by
      * {@link temperature}. Also see {@link ColorAnalysisOpts.minSat} and
@@ -133,28 +88,60 @@ export interface ColorAnalysisResult {
      * {@link ColorAnalysisResult.lumaRange}).
      */
     contrast: number;
-    /**
-     * Luminance contrast of entire grayscale image (i.e. delta of
-     * {@link ColorAnalysisResult.lumaRangeImg}).
-     */
-    contrastImg: number;
     /**
      * Max. normalized WCAG color contrast of dominant colors. The original WCAG
      * result range [1,21] is rescaled to [0,1].
      */
     colorContrast: number;
+}
+/**
+ * Result data structure returned by {@link analyzeColors}.
+ */
+export interface ColorAnalysisResult extends BaseColorAnalysisResult {
+    /**
+     * Input image, possibly converted to float RGBA & resized.
+     */
+    img: FloatBuffer;
+    /**
+     * Float grayscale version of {@link ColorAnalysisResult.img}.
+     */
+    imgGray: FloatBuffer;
     /**
-     * Average luminance of dominant colors, weighted by area.
+     * Float HSV version of {@link ColorAnalysisResult.img}.
      */
-    weightedLuma: number;
+    imgHsv: FloatBuffer;
     /**
-     * Average HSV saturation of dominant colors, weighted by area.
+     * Min/max luminance range of entire grayscale image (obtained from SRGB)
      */
-    weightedSat: number;
+    lumImg: Metric;
     /**
-     * Average Oklch chroma of dominant colors, weighted by area.
+     * Luminance contrast of entire grayscale image (i.e. delta of
+     * {@link ColorAnalysisResult.lumaRangeImg}).
      */
-    weightedChroma: number;
+    contrastImg: number;
+}
+/**
+ * Aggregated version of {@link BaseColorAnalysisResult}. Return type of
+ * {@link aggregateColorResults}.
+ */
+export interface AggregatedColorAnalysisResult {
+    css: string[];
+    srgb: SRGB[];
+    hsv: HSV[];
+    oklch: Oklch[];
+    hue: Metric;
+    sat: WeightedMetric;
+    chroma: WeightedMetric;
+    lum: WeightedMetric;
+    lumImg: Metric;
+    contrast: Metric;
+    contrastImg: Metric;
+    colorContrast: Metric;
+    temperature: {
+        meanHue: Metric;
+        temp: Metric;
+        areaTemp: Metric;
+    };
 }
 /**
  * Result type for {@link temparature}.

package/hues.d.ts

@@ -87,15 +87,14 @@ export declare const hueRangeAreaIntensity: (colors: Iterable<ReadonlyVec>, hueR
  */
 export declare const meanIntensity: (colors: Iterable<ReadonlyVec>) => number;
 /**
- * Constructs the min/max range of given normalized `hues` around given mean hue
+ * Constructs a min/max range of given normalized `hues` around given `mean` hue
  * (also normalized), considering circular wrap-around. If `min > max` in the
- * result `[min,max]`, then the hue range is crossing 0 degrees.
+ * result `[min,max]`, then the hue range is crossing zero.
  *
  * @param hues
- * @param range
  * @param mean
  */
-export declare const computeHueRange: (hues: number[], mean: number) => [number, number];
+export declare const hueRange: (values: import("@thi.ng/api").NumericArray, mean: number) => import("@thi.ng/metrics").Range;
 /**
  * Computes an abstract measure of a normalized "color temperature" of the given
  * HSV `colors` (also normalized in [0,1] range). Results closer to 1.0 indicate

package/hues.js

@@ -1,15 +1,14 @@
 import { ensureArray } from "@thi.ng/arrays/ensure-array";
 import { compareByKey } from "@thi.ng/compare";
 import { TAU } from "@thi.ng/math/api";
+import { roundTo } from "@thi.ng/math/prec";
+import { smoothStep } from "@thi.ng/math/step";
+import { circularRange } from "@thi.ng/metrics/metrics";
 import { normFrequenciesAuto, repeat, transduce } from "@thi.ng/transducers";
 import { map } from "@thi.ng/transducers/map";
 import { mapcat } from "@thi.ng/transducers/mapcat";
 import { mean } from "@thi.ng/transducers/mean";
-import { minMax } from "@thi.ng/transducers/min-max";
-import { reduce } from "@thi.ng/transducers/reduce";
 import { circularMean } from "@thi.ng/vectors/circular";
-import { fract, roundTo } from "@thi.ng/math/prec";
-import { smoothStep } from "@thi.ng/math/step";
 function* selectHueRange(colors, minHue, maxHue, minSat) {
   const pred = __hueSelector(minHue, maxHue);
   for (let col of colors) {
@@ -64,29 +63,7 @@ const meanIntensity = (colors) => transduce(
   mean(),
   colors
 );
-const computeHueRange = (hues, mean2) => {
-  const range = reduce(minMax(), hues);
-  const [min, max] = range;
-  if (mean2 < min || mean2 > max) {
-    return [
-      hues.reduce(
-        (acc, x) => {
-          const d = fract(mean2 - x);
-          return d < 0.5 && d > acc[1] ? [x, d] : acc;
-        },
-        [max, fract(mean2 - max)]
-      )[0],
-      hues.reduce(
-        (acc, x) => {
-          const d = fract(x - mean2);
-          return d < 0.5 && d > acc[1] ? [x, d] : acc;
-        },
-        [min, fract(min - mean2)]
-      )[0]
-    ];
-  }
-  return range;
-};
+const hueRange = circularRange;
 const temperature = (colors, minSat = 0.2, coeffs) => {
   const $colors = ensureArray(colors);
   const filtered = $colors.filter((x) => x[1] >= minSat);
@@ -121,8 +98,8 @@ const DEFAULT_TEMPERATURE_COEFFS = [
 const hueTemperature = (hue, [a, b, c, d] = DEFAULT_TEMPERATURE_COEFFS) => 2 * (hue < 2 / 3 ? smoothStep(b, a, hue) : smoothStep(c, d, hue)) - 1;
 export {
   DEFAULT_TEMPERATURE_COEFFS,
-  computeHueRange,
   countHueRange,
+  hueRange,
   hueRangeArea,
   hueRangeAreaIntensity,
   hueTemperature,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/pixel-analysis",
-  "version": "1.1.1",
+  "version": "2.0.0",
   "description": "Image color & feature analysis utilities",
   "type": "module",
   "module": "./index.js",
@@ -39,16 +39,17 @@
     "tool:tangle": "../../node_modules/.bin/tangle src/**/*.ts"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.11.32",
-    "@thi.ng/arrays": "^2.13.5",
-    "@thi.ng/color": "^5.7.52",
-    "@thi.ng/compare": "^2.4.24",
-    "@thi.ng/math": "^5.11.32",
-    "@thi.ng/pixel": "^7.5.4",
-    "@thi.ng/pixel-convolve": "^1.1.4",
-    "@thi.ng/pixel-dominant-colors": "^2.0.7",
-    "@thi.ng/transducers": "^9.6.3",
-    "@thi.ng/vectors": "^8.5.1"
+    "@thi.ng/api": "^8.11.33",
+    "@thi.ng/arrays": "^2.13.6",
+    "@thi.ng/color": "^5.7.53",
+    "@thi.ng/compare": "^2.4.25",
+    "@thi.ng/math": "^5.11.33",
+    "@thi.ng/metrics": "^0.1.0",
+    "@thi.ng/pixel": "^7.5.5",
+    "@thi.ng/pixel-convolve": "^1.1.5",
+    "@thi.ng/pixel-dominant-colors": "^2.0.8",
+    "@thi.ng/transducers": "^9.6.4",
+    "@thi.ng/vectors": "^8.6.0"
   },
   "devDependencies": {
     "esbuild": "^0.25.8",
@@ -112,5 +113,5 @@
     "status": "beta",
     "year": 2024
   },
-  "gitHead": "77f9f42528ac3c6209429fb798e3be69f52fcff2\n"
+  "gitHead": "1df8a3a9061257ea73ccf1ab9cdf63c81a9f519f\n"
 }