multi-gauge 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 MultiGauge contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,124 @@
+# MultiGauge
+
+> A tiny, fast WebGPU instrument panel for realtime signals.
+
+MultiGauge renders modern, dark telemetry panels directly with WebGPU. It is plain JavaScript ESM, has no runtime dependencies, draws only when something changes, and does not care where values come from.
+
+![MultiGauge vehicle telemetry dashboard](./docs/multigauge-demo.png)
+
+```js
+import { MultiGauge } from 'multi-gauge';
+
+const panel = await MultiGauge.create(document.querySelector('canvas'), {
+    grid: { rows: 2, columns: 3, gap: 8 },
+    accent: '#00eaff',
+    gauges: [
+        {
+            id: 'speed',
+            type: 'arc',
+            label: 'SPEED',
+            min: 0,
+            max: 300,
+            unit: 'km/h',
+            bands: [
+                { from: 0, to: 160, kind: 'normal' },
+                { from: 240, to: 300, kind: 'critical' }
+            ],
+            markers: [{ id: 'target', value: 145 }]
+        },
+        { id: 'heading', type: 'compass', label: 'HDG' },
+        { id: 'radar', type: 'status', label: 'RADAR' }
+    ]
+});
+
+panel.update({ speed: 127, heading: 182, radar: true });
+```
+
+## What it renders
+
+- `arc`: scalar dial with configurable range, bands and markers.
+- `linear`: horizontal or vertical, with `fill`, `marker`, or `fill-marker` mode.
+- `compass`: cyclic dial; values wrap correctly around zero.
+- `status`: discrete boolean, number or string states with semantic colors.
+
+Bands are shared concepts across continuous gauge families. Arc, linear and compass bands can include a `label`, shown near the midpoint of the colored range when its measured text fits. Radial band labels sit close outside the arc with their baseline rotated along the midpoint tangent; labeled targets use a second, farther radial tier to avoid collisions. Status gauges use `states[].label` instead. `normal`, `warning`, `critical`, `inactive`, `target`, and custom theme keys remain separate from the panel accent.
+
+Moving value indicators and progress tracks use the panel accent. Static key markers use `target` by default—or their configured semantic `kind`—and cross the gauge track with the same short-stroke language in linear and radial gauges. Numeric readouts use the regular text color outside bands and adopt the semantic color of the active band; units remain neutral.
+
+Radial scale divisions use muted rounded strokes pointing toward the dial center. They scale with the dial and disappear below a useful radius. Arc endpoints and the midpoint are emphasized with slightly longer major ticks; compass cardinal positions remain reserved for `N`, `E`, `S`, and `W`.
+
+Responsive radial layout prioritizes the dial itself. Band and target labels reserve an outer tier only when the complete text fits and the remaining dial keeps a useful radius; otherwise the label disappears without an ellipsis while the marker remains visible.
+
+## Grid and header
+
+Cells use `row`, `col`, `rowSpan`, and `colSpan`. Omit `row` and `col` to use deterministic auto-placement. A header is independent from the grid:
+
+```js
+const panel = await MultiGauge.create(canvas, {
+    grid: { rows: 3, columns: 3 },
+    header: {
+        icon: new URL('./vehicle.svg', import.meta.url),
+        title: 'VEHICLE 01',
+        subtitle: 'Prototype',
+        badge: 'ONLINE'
+    },
+    gauges: []
+});
+```
+
+SVG, PNG and WebP header icons are decoded by browser APIs, uploaded once, and cached by URL in the shared GPU runtime. Text uses one shared GPU texture containing a small set of fixed Inter Variable raster styles. Smaller cells automatically reduce labels, ticks and secondary information.
+
+## Runtime updates
+
+```js
+panel.set('speed', 130);
+panel.update({ speed: 132, heading: 184 });
+panel.setMarker('speed', 'target', 150);
+
+panel.add({ id: 'temperature', type: 'linear', min: -40, max: 150 });
+panel.remove('temperature');
+```
+
+Multiple updates in one browser frame produce one render. There is no permanent animation loop and no scheduler per gauge. Dynamic values are written through reusable staging memory; glyph buffers are rebuilt only when a formatted readout or its semantic color changes. Text measurements use a bounded atlas cache. All panels on a page share one `GPUDevice`, pipelines, glyph atlas and icon cache.
+
+## Layout editing
+
+```js
+panel.move('speed', 0, 1);
+panel.resize('speed', 2, 2);
+panel.maximize('speed');
+panel.restoreGauge('speed');
+panel.minimize('speed');
+
+panel.setEditing(false); // optionally disable direct manipulation
+panel.setEditing(true);  // enable it again
+```
+
+Direct manipulation is enabled by default: drag anywhere inside a gauge to move it, or drag from any edge or corner to resize it. There is no edit mode or visible resize handle. Move and resize run as transactions: an outline follows the pointer, a placeholder shows the resolved grid destination, and the committed layout changes only on pointer release. Press `Escape` to cancel. Exact compatible footprints swap; other collisions use deterministic push/reflow. Failed operations leave the previous layout intact. The occupancy map—not the editor DOM—is the source of truth.
+
+Arc and compass gauges use their complete content region and place the numeric value and unit on separate centered lines inside the dial. Compass headings use a moving perimeter mark instead of a center needle, leaving the middle available for the heading value. Horizontal linear gauges keep their readout below the bar; vertical linear gauges place value and unit on one line to the right so the bar can use the full available height. Labels are measured against the glyph atlas, reduced through 9–12 px UI buckets, and truncated with an ellipsis only when necessary. The bundled Inter Variable font is loaded before atlas generation; glyph styles are rasterized at the active `devicePixelRatio`, use real font metrics and snap text quads to the physical pixel grid. Numeric values use stable tabular advances without introducing a second font family.
+
+## Persistence and lifecycle
+
+```js
+const json = JSON.stringify(panel.serialize());
+panel.restore(JSON.parse(json));
+
+console.log(panel.getStats());
+panel.destroy();
+```
+
+Serialized state contains only public grid, layout, gauge, header and visual configuration. `destroy()` cancels pending work and releases canvas-specific GPU resources, observers, editor DOM and icon references; shared resources remain available to other panels.
+
+WebGPU is required. MultiGauge fails with a clear `MultiGaugeError` rather than silently switching renderer.
+
+## Development
+
+```sh
+npm test
+npm run demo
+```
+
+Open `http://localhost:8080/demo/` for two simultaneous panels or `/benchmark/` for 1, 16, 64 and 100-gauge workloads at 10, 30 and 60 Hz. The benchmark also compares sixteen 1×1 panels with one 4×4 panel.
+
+MultiGauge is source-agnostic: call `set()` or `update()` from WebSocket, SSE, sensors, shared memory, audio, simulations, or manual controls. Transport adapters belong outside this core package.

package/package.json

@@ -0,0 +1,29 @@
+{
+    "name": "multi-gauge",
+    "version": "0.1.0",
+    "description": "A tiny, fast WebGPU instrument panel for realtime signals.",
+    "type": "module",
+    "exports": {
+        ".": "./src/index.js"
+    },
+    "files": [
+        "src",
+        "docs/multigauge-demo.png",
+        "README.md",
+        "LICENSE"
+    ],
+    "scripts": {
+        "test": "node --test",
+        "demo": "python3 -m http.server 8080 --bind localhost"
+    },
+    "keywords": [
+        "webgpu",
+        "gauge",
+        "telemetry",
+        "hmi"
+    ],
+    "license": "MIT",
+    "engines": {
+        "node": ">=20"
+    }
+}

package/src/MultiGauge.js

@@ -0,0 +1,358 @@
+import { MultiGaugeError } from './errors.js';
+import { GridLayout } from './layout/GridLayout.js';
+import { layoutPanel } from './layout/PanelLayout.js';
+import { coerceValue, normalizeGauge, serializeGauge, setGaugeMarker } from './model/GaugeModel.js';
+import { Renderer } from './gpu/Renderer.js';
+import { SharedGpuRuntime } from './gpu/GpuRuntime.js';
+import { GridEditor } from './interaction/GridEditor.js';
+import { resolveTheme } from './theme.js';
+
+/** A source-agnostic WebGPU panel containing multiple realtime gauges. */
+export class MultiGauge {
+    #canvas;
+    #runtime;
+    #renderer;
+    #layout;
+    #gauges = new Map();
+    #header;
+    #accent;
+    #theme;
+    #frame;
+    #staticDirty = true;
+    #dynamicDirty = true;
+    #destroyed = false;
+    #resizeObserver;
+    #width = 1;
+    #height = 1;
+    #panelLayout = layoutPanel({ width: 1, height: 1 });
+    #editor;
+    #previewEntries;
+    #stats = { updatesReceived: 0, rendersCoalesced: 0 };
+
+    /** Create a panel after the shared WebGPU runtime is ready. */
+    static async create(canvas, options = {}) {
+        if (!canvas || typeof canvas.getContext !== 'function') {
+            throw new MultiGaugeError('MultiGauge.create() requires a canvas.');
+        }
+        const runtime = await SharedGpuRuntime.get();
+        const panel = new MultiGauge(canvas, options, runtime);
+        panel.#initialize();
+        return panel;
+    }
+
+    constructor(canvas, options, runtime) {
+        this.#canvas = canvas;
+        this.#runtime = runtime;
+        this.#layout = new GridLayout(options.grid);
+        this.#accent = options.accent ?? '#00eaff';
+        this.#theme = resolveTheme(options.theme, this.#accent);
+        this.#header = options.header ? { ...options.header } : null;
+        this.#renderer = new Renderer(canvas, runtime, (all) => this.#invalidate(all));
+        for (const gauge of options.gauges ?? []) {
+            this.#addNow(gauge);
+        }
+    }
+
+    /** Add a gauge, auto-placing it when row/col are omitted. */
+    add(configuration) {
+        this.#assertAlive();
+        const gauge = this.#addNow(configuration);
+        this.#invalidate(true);
+        return { ...gauge };
+    }
+
+    /** Remove a gauge and free its cell occupancy. */
+    remove(id) {
+        this.#assertAlive();
+        if (!this.#gauges.delete(id)) {
+            return false;
+        }
+        this.#layout.remove(id);
+        this.#invalidate(true);
+        return true;
+    }
+
+    /** Set one signal value. Numeric values clamp; compass values wrap. */
+    set(id, value) {
+        this.#assertAlive();
+        const gauge = this.#gauges.get(id);
+        if (!gauge) {
+            throw new MultiGaugeError(`Unknown gauge: ${id}.`);
+        }
+        this.#stats.updatesReceived += 1;
+        const next = coerceValue(gauge, value);
+        if (!Object.is(next, gauge.value)) {
+            gauge.value = next;
+            this.#dynamicDirty = true;
+            this.#schedule();
+        }
+        return this;
+    }
+
+    /** Set several signals; all changes are coalesced into one animation frame. */
+    update(values) {
+        this.#assertAlive();
+        for (const [id, value] of Object.entries(values)) {
+            this.set(id, value);
+        }
+        return this;
+    }
+
+    /** Add or update a marker by id. */
+    setMarker(gaugeId, markerId, value, options = {}) {
+        this.#assertAlive();
+        const gauge = this.#gauges.get(gaugeId);
+        if (!gauge) {
+            throw new MultiGaugeError(`Unknown gauge: ${gaugeId}.`);
+        }
+        setGaugeMarker(gauge, markerId, value, options);
+        this.#invalidate(true);
+        return this;
+    }
+
+    move(id, row, col) {
+        this.#assertAlive();
+        const result = this.#layout.move(id, row, col);
+        if (result) {
+            this.#invalidate(true);
+        }
+        return Boolean(result);
+    }
+
+    resize(id, rowSpan, colSpan) {
+        this.#assertAlive();
+        const result = this.#layout.resize(id, rowSpan, colSpan);
+        if (result) {
+            this.#invalidate(true);
+        }
+        return Boolean(result);
+    }
+
+    maximize(id) {
+        this.#assertAlive();
+        this.#layout.maximize(id);
+        this.#invalidate(true);
+        return this;
+    }
+
+    minimize(id) {
+        this.#assertAlive();
+        const result = this.#layout.minimize(id);
+        if (result) {
+            this.#invalidate(true);
+        }
+        return Boolean(result);
+    }
+
+    restoreGauge(id) {
+        this.#assertAlive();
+        const result = this.#layout.restore(id);
+        if (result) {
+            this.#invalidate(true);
+        }
+        return Boolean(result);
+    }
+
+    /** Enable or disable direct layout manipulation. Enabled by default. */
+    setEditing(enabled) {
+        this.#assertAlive();
+        if (enabled && !this.#editor) {
+            this.#editor = new GridEditor(this.#canvas, this.#layout, {
+                preview: (entries) => this.#setLayoutPreview(entries),
+                commit: () => this.#finishLayoutPreview(),
+                cancel: () => this.#finishLayoutPreview()
+            });
+            this.#refreshEditor();
+        } else if (!enabled && this.#editor) {
+            this.#editor.destroy();
+            this.#editor = null;
+        }
+        return this;
+    }
+
+    /** Return clean JSON-compatible public state. */
+    serialize() {
+        this.#assertAlive();
+        return {
+            version: 1,
+            grid: this.#layout.config,
+            accent: this.#accent,
+            theme: { ...this.#theme },
+            header: this.#header ? {
+                ...this.#header,
+                icon: this.#header.icon instanceof URL ? this.#header.icon.href : this.#header.icon
+            } : null,
+            gauges: [...this.#gauges.values()].map((gauge) => serializeGauge(gauge, this.#layout.get(gauge.id)))
+        };
+    }
+
+    /** Atomically replace public configuration from serialized state. */
+    restore(state) {
+        this.#assertAlive();
+        if (!state || !Array.isArray(state.gauges)) {
+            throw new MultiGaugeError('Invalid serialized MultiGauge state.');
+        }
+        const layout = new GridLayout(state.grid);
+        const gauges = new Map();
+        for (const input of state.gauges) {
+            const gauge = normalizeGauge(input);
+            if (gauges.has(gauge.id)) {
+                throw new MultiGaugeError(`Gauge id already exists: ${gauge.id}.`);
+            }
+            layout.add(gauge.id, gauge);
+            gauges.set(gauge.id, gauge);
+        }
+        this.#layout = layout;
+        this.#previewEntries = undefined;
+        this.#gauges = gauges;
+        this.#accent = state.accent ?? '#00eaff';
+        this.#theme = resolveTheme(state.theme, this.#accent);
+        this.#header = state.header ? { ...state.header } : null;
+        if (this.#editor) {
+            this.#editor.destroy();
+            this.#editor = null;
+            this.setEditing(true);
+        }
+        this.#invalidate(true);
+        return this;
+    }
+
+    /** Lightweight counters intended for demos and diagnostics. */
+    getStats() {
+        return {
+            ...this.#stats,
+            ...this.#renderer.stats,
+            runtimeGeneration: this.#runtime.generation
+        };
+    }
+
+    destroy() {
+        if (this.#destroyed) {
+            return;
+        }
+        this.#destroyed = true;
+        if (this.#frame !== undefined) {
+            cancelAnimationFrame(this.#frame);
+        }
+        this.#resizeObserver?.disconnect();
+        this.#editor?.destroy();
+        this.#renderer.destroy();
+        this.#gauges.clear();
+    }
+
+    #initialize() {
+        const resize = () => {
+            const style = getComputedStyle(this.#canvas);
+            const horizontalPadding = (Number.parseFloat(style.paddingLeft) || 0)
+                + (Number.parseFloat(style.paddingRight) || 0);
+            const verticalPadding = (Number.parseFloat(style.paddingTop) || 0)
+                + (Number.parseFloat(style.paddingBottom) || 0);
+            this.#width = Math.max(1, this.#canvas.clientWidth - horizontalPadding
+                || this.#canvas.width || 1);
+            this.#height = Math.max(1, this.#canvas.clientHeight - verticalPadding
+                || this.#canvas.height || 1);
+            if (this.#renderer.resize(this.#width, this.#height)) {
+                this.#invalidate(true);
+            }
+        };
+        if (typeof ResizeObserver === 'function') {
+            this.#resizeObserver = new ResizeObserver(resize);
+            this.#resizeObserver.observe(this.#canvas);
+        }
+        resize();
+        this.setEditing(true);
+        this.#invalidate(true);
+    }
+
+    #addNow(configuration) {
+        const gauge = normalizeGauge(configuration);
+        if (this.#gauges.has(gauge.id)) {
+            throw new MultiGaugeError(`Gauge id already exists: ${gauge.id}.`);
+        }
+        this.#layout.add(gauge.id, gauge);
+        this.#gauges.set(gauge.id, gauge);
+        return gauge;
+    }
+
+    #invalidate(all) {
+        if (this.#destroyed) {
+            return;
+        }
+        this.#staticDirty ||= all;
+        this.#dynamicDirty = true;
+        this.#schedule();
+    }
+
+    #schedule() {
+        if (this.#frame !== undefined) {
+            this.#stats.rendersCoalesced += 1;
+            return;
+        }
+        this.#frame = requestAnimationFrame(() => {
+            this.#frame = undefined;
+            this.#render();
+        });
+    }
+
+    #render() {
+        if (this.#destroyed || (!this.#staticDirty && !this.#dynamicDirty)) {
+            return;
+        }
+        this.#panelLayout = layoutPanel({
+            width: this.#width,
+            height: this.#height,
+            hasHeader: Boolean(this.#header)
+        });
+        const previewing = Boolean(this.#previewEntries);
+        const rectangles = this.#previewEntries
+            ? this.#layout.rectangles(this.#panelLayout.gridRect, this.#previewEntries)
+            : this.#layout.rectangles(this.#panelLayout.gridRect);
+        const refreshEditor = this.#staticDirty && !previewing;
+        let gauges = [...this.#gauges.values()];
+        const maximized = gauges.find((gauge) => this.#layout.get(gauge.id)?.maximized);
+        if (maximized) {
+            gauges = [maximized];
+        }
+        if (this.#staticDirty) {
+            this.#renderer.rebuildStatic(gauges, rectangles, this.#header, this.#theme, this.#panelLayout);
+        }
+        if (this.#dynamicDirty) {
+            this.#renderer.updateDynamic(gauges, this.#theme);
+        }
+        this.#renderer.render(this.#theme);
+        this.#staticDirty = false;
+        this.#dynamicDirty = false;
+        if (refreshEditor) {
+            this.#refreshEditor(rectangles);
+        }
+    }
+
+    #setLayoutPreview(entries) {
+        this.#previewEntries = entries;
+        this.#invalidate(true);
+    }
+
+    #finishLayoutPreview() {
+        this.#previewEntries = undefined;
+        this.#invalidate(true);
+    }
+
+    #refreshEditor(rectangles) {
+        if (!this.#editor) {
+            return;
+        }
+        this.#panelLayout = layoutPanel({
+            width: this.#width,
+            height: this.#height,
+            hasHeader: Boolean(this.#header)
+        });
+        const actualRectangles = rectangles ?? this.#layout.rectangles(this.#panelLayout.gridRect);
+        this.#editor.refresh(actualRectangles, this.#panelLayout);
+    }
+
+    #assertAlive() {
+        if (this.#destroyed) {
+            throw new MultiGaugeError('This MultiGauge has been destroyed.');
+        }
+    }
+}

package/src/assets/fonts/LICENSE.txt

@@ -0,0 +1,92 @@
+Copyright (c) 2016 The Inter Project Authors (https://github.com/rsms/inter)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION AND CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

package/src/errors.js

@@ -0,0 +1,7 @@
+/** An error caused by invalid MultiGauge usage or an unavailable GPU. */
+export class MultiGaugeError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'MultiGaugeError';
+    }
+}