@rhizomatics/signalk-esl-plugin 0.3.0

package/dist/render/binding.d.ts

@@ -0,0 +1,53 @@
+import { TemplateContext } from './types';
+declare const SOURCES: readonly ["signalk", "resources"];
+type Source = (typeof SOURCES)[number];
+/**
+ * Parsed form of a `<desc>`'s `key=value,key=value` content - see `parseBinding` for the grammar.
+ */
+export interface Binding {
+    source: Source;
+    /** `'self'` (default) or any other literal SignalK context as shown in the Data Browser, e.g. `vessels.urn:mrn:imo:mmsi:232345678`. */
+    context: string;
+    /** Required when `source === 'resources'` - the Resources API resource type, e.g. `tides`, `waypoints`. */
+    resource?: string;
+    path: string;
+    /** A named formatter (see `./formatters.ts`), or `'raw'` to suppress automatic unit conversion (see `renderBinding`). */
+    format?: string;
+    /** Explicit unit-preferences category (e.g. `depth`, `speed`, `temperature`) for a numeric value with no path metadata of its own, e.g. a `source=resources` value - see `../unitCategories.ts`. */
+    category?: string;
+    round?: number;
+}
+/**
+ * Parses a `<desc>` element's text content into a `Binding`, e.g.
+ * `source=resources,resource=tides,path=extremes.[0].level,category=depth,round=2` or, using the
+ * defaults (`source=signalk,context=self`), plain `path=navigation.speedOverGround` (auto-converts via
+ * that path's own metadata - see `renderBinding`). A bare path with no `key=value` pairs at all, e.g.
+ * `environment.forecast.description`, is shorthand for `path=environment.forecast.description`
+ * (source/context still default to signalk/self) - SignalK paths never contain `=`, so its absence
+ * unambiguously signals this shorthand.
+ */
+export declare function parseBinding(desc: string): Binding;
+/**
+ * Parses every `<text>` element's `<desc>` binding out of raw SVG source - lets a caller discover what
+ * data a template needs before fetching anything, with no separate config declaring it (see
+ * `assembleRawContext` in repaintScheduler.ts).
+ */
+export declare function findBindings(svgSource: string): Binding[];
+/** Resolves a parsed `Binding` against the render context assembled by `assembleRawContext`. */
+export declare function resolveBinding(binding: Binding, context: TemplateContext): unknown;
+/**
+ * Resolves a binding and renders it to text exactly as `SvgRenderer` does for a `<desc>` - shared so
+ * the CLI's `field`/`fields` commands show the same thing a real render would.
+ *
+ * Precedence for a numeric value:
+ * 1. An explicit named `format=` (anything other than `raw`) - `local_time`/`utc_offset`/`position`.
+ * 2. An explicit `category=` - for values with no path metadata of their own, e.g. a `source=resources`
+ *    value.
+ * 3. Otherwise, a `signalk`-sourced value auto-converts to its path's own preferred display unit (from
+ *    `context.pathMeta`) by default - `format=raw` opts out of this step only.
+ * 4. Falls through to `round=` (`toFixed`), `JSON.stringify` for an unformatted object/array value
+ *    (e.g. a path that resolved to a whole sub-tree rather than a leaf) instead of the useless
+ *    `String(value)` -> `"[object Object]"`, else `String`.
+ */
+export declare function renderBinding(binding: Binding, context: TemplateContext): string;
+export {};

package/dist/render/binding.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBinding = parseBinding;
+exports.findBindings = findBindings;
+exports.resolveBinding = resolveBinding;
+exports.renderBinding = renderBinding;
+const xmldom_1 = require("@xmldom/xmldom");
+const formatters_1 = require("./formatters");
+const SOURCES = ['signalk', 'resources'];
+const KNOWN_KEYS = new Set(['source', 'context', 'resource', 'path', 'format', 'category', 'round']);
+/**
+ * Parses a `<desc>` element's text content into a `Binding`, e.g.
+ * `source=resources,resource=tides,path=extremes.[0].level,category=depth,round=2` or, using the
+ * defaults (`source=signalk,context=self`), plain `path=navigation.speedOverGround` (auto-converts via
+ * that path's own metadata - see `renderBinding`). A bare path with no `key=value` pairs at all, e.g.
+ * `environment.forecast.description`, is shorthand for `path=environment.forecast.description`
+ * (source/context still default to signalk/self) - SignalK paths never contain `=`, so its absence
+ * unambiguously signals this shorthand.
+ */
+function parseBinding(desc) {
+    const trimmedDesc = desc.trim();
+    if (trimmedDesc && !trimmedDesc.includes('=')) {
+        return { source: 'signalk', context: 'self', path: trimmedDesc };
+    }
+    const fields = {};
+    for (const pair of desc.split(',')) {
+        const trimmed = pair.trim();
+        if (!trimmed)
+            continue;
+        const eq = trimmed.indexOf('=');
+        if (eq < 0) {
+            throw new Error(`invalid binding "${desc}" - expected "key=value" pairs, got "${trimmed}"`);
+        }
+        const key = trimmed.slice(0, eq).trim();
+        if (!KNOWN_KEYS.has(key)) {
+            throw new Error(`invalid binding "${desc}" - unknown key "${key}"`);
+        }
+        fields[key] = trimmed.slice(eq + 1).trim();
+    }
+    const source = (fields.source ?? 'signalk');
+    if (!SOURCES.includes(source)) {
+        throw new Error(`invalid binding "${desc}" - unknown source "${source}"`);
+    }
+    const context = fields.context ?? 'self';
+    if (source === 'resources' && !fields.resource) {
+        throw new Error(`invalid binding "${desc}" - source=resources requires a "resource" key`);
+    }
+    if (!fields.path) {
+        throw new Error(`invalid binding "${desc}" - missing required "path" key`);
+    }
+    return {
+        source,
+        context,
+        resource: fields.resource,
+        path: fields.path,
+        format: fields.format,
+        category: fields.category,
+        round: fields.round !== undefined ? Number(fields.round) : undefined,
+    };
+}
+/**
+ * Parses every `<text>` element's `<desc>` binding out of raw SVG source - lets a caller discover what
+ * data a template needs before fetching anything, with no separate config declaring it (see
+ * `assembleRawContext` in repaintScheduler.ts).
+ */
+function findBindings(svgSource) {
+    const doc = new xmldom_1.DOMParser().parseFromString(svgSource, 'image/svg+xml');
+    const elements = doc.getElementsByTagName('text');
+    const bindings = [];
+    for (let i = 0; i < elements.length; i++) {
+        const desc = elements.item(i)?.getElementsByTagName('desc').item(0);
+        if (desc?.textContent) {
+            bindings.push(parseBinding(desc.textContent));
+        }
+    }
+    return bindings;
+}
+/** Supports both `a.[0].b` and `a[0].b` array index notation, matching `setAtPath` in repaintScheduler.ts. */
+function getAtPath(obj, path) {
+    const segments = path
+        .replace(/\[(\d+)\]/g, '.$1')
+        .split('.')
+        .filter((segment) => segment.length > 0);
+    let node = obj;
+    for (const segment of segments) {
+        if (node === null || typeof node !== 'object')
+            return undefined;
+        node = node[segment];
+    }
+    return node;
+}
+/** Resolves a parsed `Binding` against the render context assembled by `assembleRawContext`. */
+function resolveBinding(binding, context) {
+    if (binding.source === 'signalk') {
+        const signalk = context.signalk;
+        const vessel = signalk?.[binding.context];
+        if (vessel === undefined) {
+            throw new Error(`binding references context "${binding.context}" which is not present in the render context`);
+        }
+        return getAtPath(vessel, binding.path);
+    }
+    const resources = context.resources;
+    const resource = resources?.[binding.resource];
+    if (resource === undefined) {
+        throw new Error(`binding references resource "${binding.resource}" which is not present in the render context`);
+    }
+    return getAtPath(resource, binding.path);
+}
+/**
+ * Looks up a `signalk`-sourced binding's path in `context.pathMeta` - a flat `{ [context]:
+ * { [dottedPath]: { displayUnits } } }` map (see `../pathMeta.ts`), matching the flat shape
+ * `GET .../vessels/<context>/meta` itself returns, unlike `context.signalk`'s nested tree. Unlike
+ * `resolveBinding`, never throws - metadata is always best-effort (a `source=resources` binding, a
+ * path with no metadata, or a server unreachable at `signalkApiUrl` all resolve to "no metadata"
+ * rather than an error).
+ */
+function resolveDisplayUnits(binding, context) {
+    if (binding.source !== 'signalk')
+        return undefined;
+    const pathMeta = context.pathMeta;
+    return pathMeta?.[binding.context]?.[binding.path]?.displayUnits;
+}
+/**
+ * Looks up an explicit `category=` binding's resolved conversion info from `context.categories` (built
+ * by `fetchCategoryDisplayUnits` in `../unitCategories.ts`) - same throw-on-missing pattern as
+ * `resolveBinding`'s context/resource lookups, since naming a category is a declared dependency.
+ */
+function resolveCategoryDisplayUnits(binding, context) {
+    const categories = context.categories;
+    const displayUnits = categories?.[binding.category];
+    if (!displayUnits) {
+        throw new Error(`binding references category "${binding.category}" which is not present in the render context`);
+    }
+    return displayUnits;
+}
+/**
+ * Resolves a binding and renders it to text exactly as `SvgRenderer` does for a `<desc>` - shared so
+ * the CLI's `field`/`fields` commands show the same thing a real render would.
+ *
+ * Precedence for a numeric value:
+ * 1. An explicit named `format=` (anything other than `raw`) - `local_time`/`utc_offset`/`position`.
+ * 2. An explicit `category=` - for values with no path metadata of their own, e.g. a `source=resources`
+ *    value.
+ * 3. Otherwise, a `signalk`-sourced value auto-converts to its path's own preferred display unit (from
+ *    `context.pathMeta`) by default - `format=raw` opts out of this step only.
+ * 4. Falls through to `round=` (`toFixed`), `JSON.stringify` for an unformatted object/array value
+ *    (e.g. a path that resolved to a whole sub-tree rather than a leaf) instead of the useless
+ *    `String(value)` -> `"[object Object]"`, else `String`.
+ */
+function renderBinding(binding, context) {
+    const value = resolveBinding(binding, context);
+    if (binding.format && binding.format !== 'raw')
+        return (0, formatters_1.applyFormat)(binding.format, value, context, binding.round);
+    if (typeof value === 'number') {
+        if (binding.category)
+            return (0, formatters_1.formatDisplayUnits)(value, resolveCategoryDisplayUnits(binding, context), binding.round);
+        const displayUnits = binding.format === 'raw' ? undefined : resolveDisplayUnits(binding, context);
+        if (displayUnits)
+            return (0, formatters_1.formatDisplayUnits)(value, displayUnits, binding.round);
+        if (binding.round !== undefined)
+            return value.toFixed(binding.round);
+    }
+    if (value === null || value === undefined)
+        return '';
+    if (typeof value === 'object')
+        return JSON.stringify(value);
+    return String(value);
+}

package/dist/render/fonts.d.ts

@@ -0,0 +1,9 @@
+/**
+ * One font per CSS generic family bucket (monospace/sans-serif/serif), bundled so rendering
+ * doesn't depend on the host having any fonts installed - resvg-wasm cannot see host fonts at
+ * all (see project memory). Must be .woff2 - resvg-wasm silently fails to render .woff.
+ * resvg auto-classifies each loaded font from its own metadata; there's no proven way to
+ * control which one wins if two loaded fonts share a generic bucket, so keep this to one per
+ * bucket rather than adding e.g. bold variants here.
+ */
+export declare const DEFAULT_FONT_PATHS: string[];

package/dist/render/fonts.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_FONT_PATHS = void 0;
+/**
+ * One font per CSS generic family bucket (monospace/sans-serif/serif), bundled so rendering
+ * doesn't depend on the host having any fonts installed - resvg-wasm cannot see host fonts at
+ * all (see project memory). Must be .woff2 - resvg-wasm silently fails to render .woff.
+ * resvg auto-classifies each loaded font from its own metadata; there's no proven way to
+ * control which one wins if two loaded fonts share a generic bucket, so keep this to one per
+ * bucket rather than adding e.g. bold variants here.
+ */
+exports.DEFAULT_FONT_PATHS = [
+    require.resolve('@fontsource/jetbrains-mono/files/jetbrains-mono-latin-400-normal.woff2'),
+    require.resolve('@fontsource/roboto/files/roboto-latin-400-normal.woff2'),
+    require.resolve('@fontsource/playfair-display/files/playfair-display-latin-400-normal.woff2'),
+];

package/dist/render/formatters.d.ts

@@ -0,0 +1,18 @@
+import { TemplateContext } from './types';
+/**
+ * Matches `displayUnits` on a path's own metadata (`app.getMetadata(path).displayUnits` in the live
+ * plugin, the `.../meta` tree over HTTP in the CLI) - SignalK's per-path unit-preference info, fully
+ * resolved (formula/symbol ready to use), unlike the global `/signalk/v1/unitpreferences/active`
+ * endpoint which only gives a bare `targetUnit` name with no conversion math at all.
+ */
+export interface DisplayUnits {
+    category: string;
+    targetUnit: string;
+    formula?: string;
+    symbol?: string;
+    displayFormat?: string;
+}
+/** Converts a base-SI value (always what SignalK paths deliver) to its metadata's preferred display unit and formats it with the unit's symbol, e.g. 3.42 -> "11.2ft". */
+export declare function formatDisplayUnits(value: number, displayUnits: DisplayUnits, round: number | undefined): string;
+/** Applies a named `format=` formatter to a resolved binding value. */
+export declare function applyFormat(name: string, value: unknown, context: TemplateContext, round: number | undefined): string;

package/dist/render/formatters.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatDisplayUnits = formatDisplayUnits;
+exports.applyFormat = applyFormat;
+const luxon_1 = require("luxon");
+const mathjs_1 = require("mathjs");
+/** Converts a base-SI value (always what SignalK paths deliver) to its metadata's preferred display unit and formats it with the unit's symbol, e.g. 3.42 -> "11.2ft". */
+function formatDisplayUnits(value, displayUnits, round) {
+    const converted = displayUnits.formula ? Number((0, mathjs_1.evaluate)(displayUnits.formula, { value })) : value;
+    const decimals = round ?? (displayUnits.displayFormat?.includes('.') ? displayUnits.displayFormat.split('.')[1].length : 0);
+    const symbol = displayUnits.symbol ?? displayUnits.targetUnit;
+    return `${converted.toFixed(decimals)}${symbol}`;
+}
+/**
+ * The local vessel's timezone (`signalk.self.environment.time.timezoneRegion`), regardless of which
+ * vessel's value is being formatted - the display's own clock/locale is what matters, not the data
+ * source's. Falls back to UTC when unset.
+ */
+function selfTimezone(context) {
+    const signalk = context.signalk;
+    const self = signalk?.self;
+    const environment = self?.environment;
+    return environment?.time?.timezoneRegion || 'utc';
+}
+/**
+ * Shows the explicit IANA zone name rather than an abbreviation (e.g. "BST") - UK tide tables are
+ * officially published in GMT, so the basis for the displayed time must be unambiguous rather than
+ * just locally styled.
+ */
+function formatLocalTime(value, context) {
+    if (typeof value !== 'string')
+        return '';
+    const dt = luxon_1.DateTime.fromISO(value, { zone: 'utc' }).setZone(selfTimezone(context));
+    return dt.isValid ? dt.toFormat('HH:mm') : '';
+}
+/** e.g. "27 Jun" - day of month (no leading zero) and abbreviated month name, in the local vessel's timezone. */
+function formatDayMonth(value, context) {
+    if (typeof value !== 'string')
+        return '';
+    const dt = luxon_1.DateTime.fromISO(value, { zone: 'utc' }).setZone(selfTimezone(context));
+    return dt.isValid ? dt.toFormat('d MMM') : '';
+}
+/**
+ * IANA region names are ambiguous about DST (e.g. "Europe/London" is UTC+00:00 in winter, UTC+01:00
+ * in summer); show the numeric offset actually in effect.
+ */
+function formatUtcOffset(value) {
+    if (typeof value !== 'string' || !value)
+        return '';
+    const dt = luxon_1.DateTime.now().setZone(value);
+    return dt.isValid ? `UTC${dt.toFormat('ZZ')}` : '';
+}
+function formatPosition(value, round) {
+    const position = value;
+    if (typeof position?.latitude !== 'number' || typeof position?.longitude !== 'number')
+        return '';
+    const decimals = round ?? 4;
+    const lat = Math.abs(position.latitude).toFixed(decimals);
+    const lon = Math.abs(position.longitude).toFixed(decimals);
+    const latHemisphere = position.latitude >= 0 ? 'N' : 'S';
+    const lonHemisphere = position.longitude >= 0 ? 'E' : 'W';
+    return `${lat}°${latHemisphere} ${lon}°${lonHemisphere}`;
+}
+/** Applies a named `format=` formatter to a resolved binding value. */
+function applyFormat(name, value, context, round) {
+    switch (name) {
+        case 'local_time':
+            return formatLocalTime(value, context);
+        case 'day_mon':
+            return formatDayMonth(value, context);
+        case 'utc_offset':
+            return formatUtcOffset(value);
+        case 'position':
+            return formatPosition(value, round);
+        default:
+            throw new Error(`unknown format "${name}"`);
+    }
+}

package/dist/render/png.d.ts

@@ -0,0 +1,3 @@
+import { Bitmap } from './types';
+/** Encodes a common Bitmap as PNG bytes, for previewing templates without a physical device. */
+export declare function bitmapToPng(bitmap: Bitmap): Buffer;

package/dist/render/png.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bitmapToPng = bitmapToPng;
+const pngjs_1 = require("pngjs");
+/** Encodes a common Bitmap as PNG bytes, for previewing templates without a physical device. */
+function bitmapToPng(bitmap) {
+    const png = new pngjs_1.PNG({ width: bitmap.width, height: bitmap.height });
+    png.data = Buffer.from(bitmap.data);
+    return pngjs_1.PNG.sync.write(png);
+}

package/dist/render/svgRenderer.d.ts

@@ -0,0 +1,32 @@
+import { Bitmap, Renderer, TemplateContext } from './types';
+/**
+ * Renders an SVG+binding template to a common RGBA bitmap.
+ *
+ * Binding model: a `<text>` element with a `<desc>` child has that child's
+ * content parsed as a flat `key=value,key=value` binding against the render
+ * context and substituted in as the element's text, e.g.
+ * `<desc>source=resources,resource=tides,path=extremes.[0].time,format=local_time</desc>`
+ * (see `./binding.ts` for the grammar and `./formatters.ts` for the `format=` registry).
+ * The `<text>` element's own visible content is left untouched in the source
+ * file - it's just a placeholder so the template looks sane while laying it
+ * out in an SVG editor - and is only overwritten in the in-memory copy used
+ * for this render. `<text>` elements with no `<desc>` are left as static text.
+ * Scoped to `<text>` rather than all elements with an id - setting `textContent`
+ * on a structural element (e.g. the root `<svg>`) wipes its children, and
+ * `getElementsByTagName` is a live NodeList, so that previously truncated the
+ * whole tree and rendered blank.
+ *
+ * resvg-wasm cannot see the host's installed fonts (`loadSystemFonts`/`fontFiles`
+ * are silently no-ops under plain Node) - it only renders text if given font
+ * bytes directly via `fontBuffers`, read from disk by us. Without at least one
+ * font path configured, all text elements render as nothing, with no error.
+ * Defaults to the bundled monospace/sans-serif/serif trio (see ./fonts.ts) so
+ * templates can use plain CSS generic font-family keywords.
+ */
+export declare class SvgRenderer implements Renderer {
+    private readonly fontPaths;
+    private fontBuffers?;
+    constructor(fontPaths?: string[]);
+    private loadFontBuffers;
+    render(svgTemplatePath: string, context: TemplateContext, width: number, height: number): Promise<Bitmap>;
+}

package/dist/render/svgRenderer.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SvgRenderer = void 0;
+const promises_1 = require("fs/promises");
+const xmldom_1 = require("@xmldom/xmldom");
+const resvg_wasm_1 = require("@resvg/resvg-wasm");
+const binding_1 = require("./binding");
+const fonts_1 = require("./fonts");
+let wasmReady;
+function ensureWasmInitialized() {
+    if (!wasmReady) {
+        wasmReady = (0, promises_1.readFile)(require.resolve('@resvg/resvg-wasm/index_bg.wasm')).then((buffer) => (0, resvg_wasm_1.initWasm)(buffer));
+    }
+    return wasmReady;
+}
+/**
+ * Renders an SVG+binding template to a common RGBA bitmap.
+ *
+ * Binding model: a `<text>` element with a `<desc>` child has that child's
+ * content parsed as a flat `key=value,key=value` binding against the render
+ * context and substituted in as the element's text, e.g.
+ * `<desc>source=resources,resource=tides,path=extremes.[0].time,format=local_time</desc>`
+ * (see `./binding.ts` for the grammar and `./formatters.ts` for the `format=` registry).
+ * The `<text>` element's own visible content is left untouched in the source
+ * file - it's just a placeholder so the template looks sane while laying it
+ * out in an SVG editor - and is only overwritten in the in-memory copy used
+ * for this render. `<text>` elements with no `<desc>` are left as static text.
+ * Scoped to `<text>` rather than all elements with an id - setting `textContent`
+ * on a structural element (e.g. the root `<svg>`) wipes its children, and
+ * `getElementsByTagName` is a live NodeList, so that previously truncated the
+ * whole tree and rendered blank.
+ *
+ * resvg-wasm cannot see the host's installed fonts (`loadSystemFonts`/`fontFiles`
+ * are silently no-ops under plain Node) - it only renders text if given font
+ * bytes directly via `fontBuffers`, read from disk by us. Without at least one
+ * font path configured, all text elements render as nothing, with no error.
+ * Defaults to the bundled monospace/sans-serif/serif trio (see ./fonts.ts) so
+ * templates can use plain CSS generic font-family keywords.
+ */
+class SvgRenderer {
+    constructor(fontPaths = fonts_1.DEFAULT_FONT_PATHS) {
+        this.fontPaths = fontPaths;
+        if (fontPaths.length === 0) {
+            throw new Error('SvgRenderer requires at least one font path - resvg-wasm cannot use host system fonts');
+        }
+    }
+    loadFontBuffers() {
+        if (!this.fontBuffers) {
+            this.fontBuffers = Promise.all(this.fontPaths.map(async (path) => new Uint8Array(await (0, promises_1.readFile)(path))));
+        }
+        return this.fontBuffers;
+    }
+    async render(svgTemplatePath, context, width, height) {
+        const [, fontBuffers] = await Promise.all([ensureWasmInitialized(), this.loadFontBuffers()]);
+        const svgSource = await (0, promises_1.readFile)(svgTemplatePath, 'utf-8');
+        const doc = new xmldom_1.DOMParser().parseFromString(svgSource, 'image/svg+xml');
+        const elements = doc.getElementsByTagName('text');
+        for (let i = 0; i < elements.length; i++) {
+            const element = elements.item(i);
+            if (!element)
+                continue;
+            const descElement = element.getElementsByTagName('desc').item(0);
+            if (!descElement)
+                continue;
+            const binding = (0, binding_1.parseBinding)(descElement.textContent ?? '');
+            element.textContent = (0, binding_1.renderBinding)(binding, context);
+        }
+        const svgOutput = new xmldom_1.XMLSerializer().serializeToString(doc);
+        const resvg = new resvg_wasm_1.Resvg(svgOutput, {
+            fitTo: { mode: 'width', value: width },
+            font: { fontBuffers },
+        });
+        const rendered = resvg.render();
+        if (rendered.width !== width || rendered.height !== height) {
+            throw new Error(`rendered size ${rendered.width}x${rendered.height} does not match requested ${width}x${height} - check the template's width/height/viewBox`);
+        }
+        return { width: rendered.width, height: rendered.height, data: rendered.pixels };
+    }
+}
+exports.SvgRenderer = SvgRenderer;

package/dist/render/types.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Common raster output produced by the SVG renderer, before any
+ * vendor-specific colour quantisation or bit-packing is applied.
+ */
+export interface Bitmap {
+    width: number;
+    height: number;
+    /** RGBA, 4 bytes per pixel, row-major, top-left origin */
+    data: Uint8Array;
+}
+/**
+ * Render context a template's `<desc>` bindings resolve against - see `./binding.ts`. Shaped as
+ * `{ signalk: { self: {...}, [vesselContext]: {...} }, resources: { [resourceName]: ... },
+ * pathMeta: { [context]: { [dottedPath]: { displayUnits } } }, categories: { [categoryName]:
+ * DisplayUnits } }` by `assembleRawContext` in repaintScheduler.ts, fetched fresh from a template's own
+ * bindings every repaint - no separate config declares what a template needs. `pathMeta` is flat
+ * (dotted-path keyed, matching `GET .../vessels/<context>/meta`'s own shape), unlike `signalk`'s nested
+ * tree - it backs automatic unit conversion for a `signalk`-sourced numeric value (`format=raw` opts
+ * out). `categories` backs an explicit `category=` binding, for a value with no path metadata of its
+ * own (see `../unitCategories.ts`). `meta` (unrelated, plugin-injected) holds the repaint timestamp -
+ * see `considerRepaint`.
+ */
+export type TemplateContext = Record<string, unknown>;
+export interface Renderer {
+    render(svgTemplatePath: string, context: TemplateContext, width: number, height: number): Promise<Bitmap>;
+}

package/dist/render/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/repaintScheduler.d.ts

@@ -0,0 +1,6 @@
+import { ServerAPI } from '@signalk/server-api';
+import { PluginConfig } from './config';
+export interface RepaintScheduler {
+    stop(): void;
+}
+export declare function startRepaintScheduler(app: ServerAPI, config: PluginConfig): RepaintScheduler;