signalk-livedepth-plugin 0.2.1 → 0.3.2

package/public/js/renderer.js

@@ -0,0 +1,1159 @@
+// node_modules/signalk-plotterext-bus/dist/chunk-4JN5YUOC.js
+var BUS_ID = "plotterExt/1";
+var RPC_ERRORS = {
+  PARSE_ERROR: -32700,
+  INVALID_REQUEST: -32600,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603,
+  HOST_ERROR: -32e3,
+  TIMEOUT: -32001,
+  CONNECTION_CLOSED: -32002
+};
+var RpcError = class _RpcError extends Error {
+  code;
+  data;
+  constructor(message, opts = {}) {
+    super(message);
+    this.name = "RpcError";
+    this.code = opts.code ?? RPC_ERRORS.HOST_ERROR;
+    const data = { ...opts.data ?? {} };
+    if (opts.reason !== void 0) data.reason = opts.reason;
+    this.data = Object.keys(data).length > 0 ? data : void 0;
+  }
+  get reason() {
+    return typeof this.data?.reason === "string" ? this.data.reason : void 0;
+  }
+  toErrorObject() {
+    return {
+      code: this.code,
+      message: this.message,
+      ...this.data ? { data: this.data } : {}
+    };
+  }
+  static fromErrorObject(err) {
+    return new _RpcError(err.message, { code: err.code, data: err.data });
+  }
+  /** Normalize any thrown value into an RpcError suitable for the wire. */
+  static from(err) {
+    if (err instanceof _RpcError) return err;
+    if (err instanceof Error) {
+      return new _RpcError(err.message, { code: RPC_ERRORS.INTERNAL_ERROR });
+    }
+    return new _RpcError(String(err), { code: RPC_ERRORS.INTERNAL_ERROR });
+  }
+};
+var EVENT_READY = "bus.ready";
+var EVENT_HANDSHAKE = "bus.handshake";
+function matchesPattern(pattern, name) {
+  if (pattern === name) return true;
+  return match(pattern.split("."), 0, name.split("."), 0);
+}
+function match(p, pi, n, ni) {
+  while (pi < p.length) {
+    const seg = p[pi];
+    if (seg === "**") {
+      if (pi === p.length - 1) return true;
+      for (let skip = ni; skip <= n.length; skip++) {
+        if (match(p, pi + 1, n, skip)) return true;
+      }
+      return false;
+    }
+    if (ni >= n.length) return false;
+    if (seg !== "*" && seg !== n[ni]) return false;
+    pi++;
+    ni++;
+  }
+  return ni === n.length;
+}
+function matchesAny(patterns, name) {
+  for (const pattern of patterns) {
+    if (matchesPattern(pattern, name)) return true;
+  }
+  return false;
+}
+function wrap(msg) {
+  return { bus: BUS_ID, msg };
+}
+function unwrap(data) {
+  if (typeof data !== "object" || data === null) return null;
+  const env = data;
+  if (env.bus !== BUS_ID) return null;
+  return isJsonRpcMessage(env.msg) ? env.msg : null;
+}
+function isJsonRpcMessage(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const m = v;
+  if (m.jsonrpc !== "2.0") return false;
+  if (typeof m.method === "string") {
+    return m.id === void 0 || typeof m.id === "string" || typeof m.id === "number";
+  }
+  const idOk = typeof m.id === "string" || typeof m.id === "number" || m.id === null;
+  if (!idOk) return false;
+  const hasResult = "result" in m;
+  const err = m.error;
+  const hasError = typeof err === "object" && err !== null && typeof err.code === "number" && typeof err.message === "string";
+  return hasResult ? !("error" in m) : hasError;
+}
+function isRequest(msg) {
+  return "method" in msg && "id" in msg && msg.id !== void 0;
+}
+function isNotification(msg) {
+  return "method" in msg && (!("id" in msg) || msg.id === void 0);
+}
+function isResponse(msg) {
+  return !("method" in msg);
+}
+function windowPort(peer, opts = {}) {
+  const listenWindow = opts.listenWindow ?? globalThis;
+  const origin = opts.origin ?? listenWindow.location?.origin ?? "*";
+  return {
+    post(data, transfer) {
+      if (transfer?.length) {
+        peer.postMessage(data, { targetOrigin: origin, transfer });
+      } else {
+        peer.postMessage(data, origin);
+      }
+    },
+    listen(handler) {
+      const fn = (ev) => {
+        if (ev.source !== peer) return;
+        if (origin !== "*" && ev.origin !== origin) return;
+        handler(ev.data);
+      };
+      listenWindow.addEventListener("message", fn);
+      return () => listenWindow.removeEventListener("message", fn);
+    }
+  };
+}
+var DEFAULT_CALL_TIMEOUT_MS = 1e4;
+var BusEndpoint = class {
+  callTimeoutMs;
+  port;
+  unlisten;
+  onError;
+  pending = /* @__PURE__ */ new Map();
+  methods = /* @__PURE__ */ new Map();
+  eventHandlers = /* @__PURE__ */ new Set();
+  idPrefix = Math.random().toString(36).slice(2, 8);
+  seq = 0;
+  closed = false;
+  constructor(opts) {
+    this.port = opts.port;
+    this.callTimeoutMs = opts.callTimeoutMs ?? DEFAULT_CALL_TIMEOUT_MS;
+    this.onError = opts.onError ?? ((err) => console.warn("[plotterext-bus]", err));
+    this.unlisten = this.port.listen((data) => this.onData(data));
+  }
+  registerMethod(name, handler) {
+    this.methods.set(name, handler);
+  }
+  unregisterMethod(name) {
+    this.methods.delete(name);
+  }
+  /**
+   * Handle incoming notifications whose names match any of the wildcard
+   * patterns. Returns an unsubscribe function. This is local dispatch only;
+   * telling the peer which events to forward is a separate concern
+   * (`events.subscribe`).
+   */
+  onEvent(patterns, fn) {
+    const entry = { patterns, fn };
+    this.eventHandlers.add(entry);
+    return () => this.eventHandlers.delete(entry);
+  }
+  /**
+   * Send a notification (an event) to the peer. `opts.transfer` moves the
+   * listed objects instead of copying them.
+   */
+  notify(method, params, opts = {}) {
+    this.send(
+      { jsonrpc: "2.0", method, ...params !== void 0 ? { params } : {} },
+      opts.transfer
+    );
+  }
+  /**
+   * Call a method on the peer; resolves with its result. `opts.transfer`
+   * moves the listed objects (e.g. an `ImageBitmap` inside `params`) instead
+   * of copying them.
+   */
+  call(method, params, opts = {}) {
+    if (this.closed) {
+      return Promise.reject(
+        new RpcError("Bus endpoint is closed", {
+          code: RPC_ERRORS.CONNECTION_CLOSED,
+          reason: "CLOSED"
+        })
+      );
+    }
+    const id = `${this.idPrefix}-${++this.seq}`;
+    const timeoutMs = opts.timeoutMs ?? this.callTimeoutMs;
+    return new Promise((resolve, reject) => {
+      const timer2 = timeoutMs > 0 ? setTimeout(() => {
+        this.pending.delete(id);
+        reject(
+          new RpcError(`Call timed out after ${timeoutMs}ms: ${method}`, {
+            code: RPC_ERRORS.TIMEOUT,
+            reason: "TIMEOUT"
+          })
+        );
+      }, timeoutMs) : null;
+      this.pending.set(id, { resolve, reject, timer: timer2 });
+      this.send(
+        {
+          jsonrpc: "2.0",
+          id,
+          method,
+          ...params !== void 0 ? { params } : {}
+        },
+        opts.transfer
+      );
+    });
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.unlisten();
+    for (const [, p] of this.pending) {
+      if (p.timer) clearTimeout(p.timer);
+      p.reject(
+        new RpcError("Bus endpoint closed", {
+          code: RPC_ERRORS.CONNECTION_CLOSED,
+          reason: "CLOSED"
+        })
+      );
+    }
+    this.pending.clear();
+    this.eventHandlers.clear();
+  }
+  send(msg, transfer) {
+    if (this.closed) return;
+    this.port.post(wrap(msg), transfer);
+  }
+  onData(data) {
+    const msg = unwrap(data);
+    if (!msg) return;
+    if (isResponse(msg)) {
+      this.onResponse(msg);
+    } else if (isRequest(msg)) {
+      void this.onRequest(msg);
+    } else if (isNotification(msg)) {
+      this.onNotification(msg.method, msg.params);
+    }
+  }
+  onResponse(msg) {
+    if (msg.id === null) return;
+    const p = this.pending.get(msg.id);
+    if (!p) return;
+    this.pending.delete(msg.id);
+    if (p.timer) clearTimeout(p.timer);
+    if ("error" in msg) {
+      p.reject(RpcError.fromErrorObject(msg.error));
+    } else {
+      p.resolve(msg.result);
+    }
+  }
+  async onRequest(msg) {
+    const handler = this.methods.get(msg.method);
+    if (!handler) {
+      this.send({
+        jsonrpc: "2.0",
+        id: msg.id,
+        error: {
+          code: RPC_ERRORS.METHOD_NOT_FOUND,
+          message: `Method not found: ${msg.method}`
+        }
+      });
+      return;
+    }
+    try {
+      const result = await handler(msg.params, { endpoint: this });
+      this.send({
+        jsonrpc: "2.0",
+        id: msg.id,
+        result: result === void 0 ? null : result
+      });
+    } catch (err) {
+      this.send({
+        jsonrpc: "2.0",
+        id: msg.id,
+        error: RpcError.from(err).toErrorObject()
+      });
+    }
+  }
+  onNotification(name, params) {
+    for (const entry of [...this.eventHandlers]) {
+      if (matchesAny(entry.patterns, name)) {
+        try {
+          entry.fn(name, params);
+        } catch (err) {
+          this.onError(err);
+        }
+      }
+    }
+  }
+};
+
+// node_modules/signalk-plotterext-bus/dist/chunk-N42ZRM4R.js
+var ExtensionClient = class {
+  handshake;
+  endpoint;
+  constructor(endpoint, handshake) {
+    this.endpoint = endpoint;
+    this.handshake = handshake;
+  }
+  get context() {
+    return this.handshake.context;
+  }
+  get apiVersion() {
+    return this.handshake.apiVersion;
+  }
+  get capabilities() {
+    return this.handshake.capabilities;
+  }
+  hasCapability(id) {
+    return this.handshake.capabilities.includes(id);
+  }
+  /**
+   * Call a host API method. `opts.transfer` moves the listed objects instead
+   * of copying them — only `overlay.frame` needs it in this version.
+   */
+  call(method, params, opts) {
+    return this.endpoint.call(method, params, opts);
+  }
+  /** Send a notification to the host. */
+  notify(method, params) {
+    this.endpoint.notify(method, params);
+  }
+  /**
+   * Subscribe to host events matching wildcard patterns. Registers both the
+   * host-side forwarding subscription and local dispatch; the returned
+   * function tears down both.
+   */
+  async subscribe(patterns, handler) {
+    const off = this.endpoint.onEvent(patterns, handler);
+    let subscriptionId;
+    try {
+      const result = await this.call("events.subscribe", { patterns });
+      subscriptionId = result.subscriptionId;
+    } catch (err) {
+      off();
+      throw err;
+    }
+    return async () => {
+      off();
+      await this.call("events.unsubscribe", { subscriptionId }).catch(() => {
+      });
+    };
+  }
+  /**
+   * Publish an event onto the bus (capability `events.publish`). The host
+   * delivers it to every context in `scope` whose subscriptions match —
+   * including this one — exactly as it delivers host events. `scope` defaults
+   * to `'all'` (any extension); `'extension'` keeps it to this extension's own
+   * contexts. Resolves once the host has delivered it; there is no reply.
+   */
+  async publish(topic, params, scope) {
+    await this.call("events.publish", {
+      topic,
+      ...params !== void 0 ? { params } : {},
+      ...scope ? { scope } : {}
+    });
+  }
+  /** Host-persisted key/value state (see spec: State Storage). */
+  state = {
+    get: async (keys, scope) => {
+      const result = await this.call("state.get", {
+        ...scope ? { scope } : {},
+        ...keys ? { keys } : {}
+      });
+      return result.values ?? {};
+    },
+    set: async (values, scope) => {
+      await this.call("state.set", {
+        ...scope ? { scope } : {},
+        values
+      });
+    }
+  };
+  /** Signal K data relayed by the host (capabilities signalk.stream / .put). */
+  signalk = {
+    /**
+     * Subscribe to Signal K path values. The host publishes them as
+     * `sk.<path>` events; this helper hides the event-name mapping and
+     * establishes both the event-forwarding subscription and the host's
+     * upstream Signal K subscription.
+     */
+    subscribe: async (paths, handler) => {
+      const patterns = paths.map((p) => `sk.${p}`);
+      const offEvents = await this.subscribe(
+        patterns,
+        (_name, params) => handler(params)
+      );
+      let subscriptionId;
+      try {
+        const result = await this.call("signalk.subscribe", { paths });
+        subscriptionId = result.subscriptionId;
+      } catch (err) {
+        await offEvents();
+        throw err;
+      }
+      return async () => {
+        await offEvents();
+        await this.call("signalk.unsubscribe", { subscriptionId }).catch(
+          () => {
+          }
+        );
+      };
+    },
+    put: (path, value) => {
+      return this.call("signalk.put", { path, value });
+    }
+  };
+  /**
+   * The host's visible routes (capability `routes`). Thin **typed** wrappers over
+   * the host's `route.*` methods — each just delegates to `this.call(...)`, so a
+   * plain-JS extension can call `client.call('route.replace', …)` directly and a
+   * TypeScript extension gets the typed `client.route.replace(…)` sugar with no
+   * behavioural difference. Follow lifecycle + mutations by subscribing to
+   * `route.**` events (`RouteVisibleEvent` / `RouteDirtyEvent` / `RouteSavedEvent`
+   * / `RouteHiddenEvent`). Further operations (rename/point ops) extend this
+   * surface as the capability fills out.
+   */
+  route = {
+    list: async () => {
+      const result = await this.call("route.list");
+      return result.routes ?? [];
+    },
+    create: async (opts) => {
+      return await this.call("route.create", opts);
+    },
+    get: async (routeId) => {
+      return await this.call("route.get", { routeId });
+    },
+    replace: async (routeId, points) => {
+      return await this.call("route.replace", { routeId, points });
+    },
+    save: async (routeId, opts) => {
+      return await this.call("route.save", {
+        routeId,
+        ...opts ?? {}
+      });
+    },
+    show: async (ref) => {
+      return await this.call("route.show", { ref });
+    },
+    hide: async (routeId) => {
+      await this.call("route.hide", { routeId });
+    },
+    delete: async (routeId) => {
+      await this.call("route.delete", { routeId });
+    }
+  };
+  /**
+   * The host's chart layers (capability `charts`). Thin **typed** wrappers over
+   * the host's `chart.*` methods — a lightweight facade over the charts the host
+   * already manages: enumerate them, toggle visibility, opacity and stacking
+   * order (all batch). It does not create, add, or delete chart sources. Follow
+   * changes (from any origin, including the host's own chart controls) by
+   * subscribing to `chart.**` events (`ChartVisibilityEvent` / `ChartOpacityEvent`
+   * / `ChartOrderEvent` / `ChartTimeEvent`) and re-reading `chart.list` where
+   * needed. As with every wrapper, a plain-JS extension can call
+   * `client.call('chart.list', …)` directly with no behavioural difference.
+   */
+  chart = {
+    list: async () => {
+      const result = await this.call("chart.list");
+      return result.charts ?? [];
+    },
+    setVisibility: async (ids, visible) => {
+      await this.call("chart.setVisibility", { ids, visible });
+    },
+    setOpacity: async (ids, opacity) => {
+      await this.call("chart.setOpacity", { ids, opacity });
+    },
+    setOrder: async (order) => {
+      await this.call("chart.setOrder", { order });
+    },
+    /**
+     * Retarget time-varying charts to an ISO 8601 instant, or back to their
+     * live frame with `null` (sub-capability `charts.time`). Follow changes via
+     * the `chart.time` event (`ChartTimeEvent`).
+     */
+    setTime: async (ids, time) => {
+      await this.call("chart.setTime", { ids, time });
+    }
+  };
+  /**
+   * The host's night-vision display mode (capability `nightMode`). Read the
+   * current `{ enabled, auto }` state, change it, and follow changes by
+   * subscribing to the `nightMode.changed` event (`NightModeChangedEvent`).
+   * `set` expresses the three states the spec defines: force on
+   * (`{ enabled: true }`), force off (`{ enabled: false }`), follow the server
+   * (`{ auto: true }`); setting `enabled` implies `auto: false`. As with every
+   * wrapper, a plain-JS extension can call `client.call('nightMode.get' |
+   * 'nightMode.set', …)` directly with no behavioural difference.
+   */
+  nightMode = {
+    get: async () => {
+      return await this.call("nightMode.get");
+    },
+    set: async (state) => {
+      await this.call("nightMode.set", state);
+    }
+  };
+  /**
+   * Panel visibility (capability `panels.state`): the state of each of this
+   * extension's loaded panels. Follow changes with the `panel.state` event,
+   * which every context of the extension receives; subscribe first, then
+   * `list()`, so no change is missed. A plain-JS extension can call
+   * `client.call('ui.listPanels')` with no behavioural difference.
+   */
+  panels = {
+    list: async () => {
+      const r = await this.call("ui.listPanels");
+      return r.panels;
+    }
+  };
+  /**
+   * Image map overlays (capability `overlays.image`): map layers this
+   * extension's background runtime draws. The host asks for frames with the
+   * `overlay.request` event (`OverlayRequestEvent`) and reports visibility
+   * with `overlay.state` (`OverlayStateEvent`); the runtime answers each
+   * request with `frame()`, keeping one frame in flight. `frame()` transfers
+   * `image`, so the caller no longer owns it afterwards. A plain-JS extension
+   * can call `client.call('overlay.frame', params, { transfer: [image] })`
+   * with no behavioural difference.
+   */
+  overlays = {
+    list: async () => {
+      const r = await this.call("overlay.list");
+      return r.overlays;
+    },
+    setVisibility: async (ids, visible) => {
+      await this.call("overlay.setVisibility", { ids, visible });
+    },
+    setOpacity: async (ids, opacity) => {
+      await this.call("overlay.setOpacity", { ids, opacity });
+    },
+    frame: async (params) => {
+      return await this.call("overlay.frame", params, {
+        transfer: [params.image]
+      });
+    }
+  };
+  /**
+   * Floating windows (capability `windows`): show one of this extension's
+   * iframe panels in a window over the chart. Geometry is a request — read the
+   * actual `bounds` from the returned `WindowState`, and follow changes with
+   * the `window.bounds` / `window.state` / `window.closed` events. Windows
+   * belong to the extension, so any of its contexts may manage them; in a
+   * `window` context, `update` / `focus` / `close` default to the window
+   * itself when `windowId` is left out. A plain-JS extension can call
+   * `client.call('ui.openWindow', …)` and friends directly with no
+   * behavioural difference.
+   */
+  windows = {
+    open: async (params) => {
+      return await this.call("ui.openWindow", params);
+    },
+    update: async (params) => {
+      return await this.call("ui.updateWindow", params);
+    },
+    focus: async (windowId) => {
+      await this.call("ui.focusWindow", windowId === void 0 ? {} : { windowId });
+    },
+    close: async (windowId) => {
+      await this.call("ui.closeWindow", windowId === void 0 ? {} : { windowId });
+    },
+    list: async () => {
+      const r = await this.call("ui.listWindows");
+      return r.windows;
+    }
+  };
+  /**
+   * Apply a stored resource group to the host's display (capability
+   * `resourceGroups`). Resolves to `{ applied }` — the types the host made a
+   * best-effort attempt to carry out; a type it did not act on is omitted.
+   * Follow applies from any origin (including the user's own group picker) via
+   * the `resourceGroup.applied` event (`ResourceGroupAppliedEvent`). Group CRUD
+   * is not here: use the server's resources API (`/resources/groups`). A
+   * plain-JS extension can call `client.call('resourceGroup.apply', { id })`
+   * directly with no behavioural difference.
+   */
+  resourceGroup = {
+    apply: async (id) => {
+      return await this.call("resourceGroup.apply", {
+        id
+      });
+    }
+  };
+  /**
+   * The host's chart viewport (capability `map`). Read the current
+   * `{ center, zoom, bounds }`, drive it, and follow it by subscribing to the
+   * `map.view` event (`MapViewEvent`), which carries the same shape and fires
+   * once per settled pan/zoom. Seed with `getView` so a follower has a view
+   * before the first change. As with every wrapper, a plain-JS extension can
+   * call `client.call('map.getView' | 'map.center' | 'map.fitBounds', …)`
+   * directly with no behavioural difference.
+   */
+  map = {
+    getView: async () => {
+      return await this.call("map.getView");
+    },
+    center: async (position, zoom) => {
+      await this.call("map.center", {
+        position,
+        ...typeof zoom === "number" ? { zoom } : {}
+      });
+    },
+    /**
+     * Fit the chart to `[west, south, east, north]`. A box crossing the
+     * antimeridian may be given as `west > east` (the API's form) or unwrapped
+     * (`east` past 180); the host fits it the short way round.
+     */
+    fitBounds: async (bounds) => {
+      await this.call("map.fitBounds", { bounds });
+    }
+  };
+  close() {
+    this.endpoint.close();
+  }
+};
+function connectExtension(opts = {}) {
+  const port = opts.port ?? windowPort(globalThis.parent, {
+    origin: "*"
+  });
+  const endpoint = new BusEndpoint({
+    port,
+    callTimeoutMs: opts.callTimeoutMs,
+    onError: opts.onError
+  });
+  const readyParams = opts.id ? { id: opts.id } : void 0;
+  return new Promise((resolve, reject) => {
+    let done = false;
+    const off = endpoint.onEvent([EVENT_HANDSHAKE], (_name, params) => {
+      if (done) return;
+      done = true;
+      cleanup();
+      resolve(new ExtensionClient(endpoint, params));
+    });
+    const interval = setInterval(
+      () => endpoint.notify(EVENT_READY, readyParams),
+      opts.readyIntervalMs ?? 250
+    );
+    const timeout = setTimeout(() => {
+      if (done) return;
+      done = true;
+      cleanup();
+      endpoint.close();
+      reject(
+        new RpcError("Timed out waiting for host handshake", {
+          code: RPC_ERRORS.TIMEOUT,
+          reason: "HANDSHAKE_TIMEOUT"
+        })
+      );
+    }, opts.timeoutMs ?? 1e4);
+    const cleanup = () => {
+      off();
+      clearInterval(interval);
+      clearTimeout(timeout);
+    };
+    endpoint.notify(EVENT_READY, readyParams);
+  });
+}
+
+// src/web/shared/live-depth.ts
+function queryString(params) {
+  return Object.entries(params).filter(([, v]) => v !== void 0 && v !== "").map(([k, v]) => `${k}=${encodeURIComponent(String(v))}`).join("&");
+}
+var RAD = Math.PI / 180;
+var DEPTH_HISTORY_METHOD = "min";
+function historyValuesQuery(opts) {
+  return queryString({
+    context: opts.context,
+    paths: `navigation.position,${opts.depthPath}:${DEPTH_HISTORY_METHOD},navigation.headingTrue:average`,
+    from: new Date(opts.from).toISOString(),
+    to: new Date(opts.to).toISOString(),
+    resolution: opts.resolution
+  });
+}
+function toPosition(value) {
+  if (Array.isArray(value) && value.length >= 2) {
+    const [lon, lat] = value;
+    if (Number.isFinite(lon) && Number.isFinite(lat)) {
+      return [lon, lat];
+    }
+    return void 0;
+  }
+  if (value && typeof value === "object") {
+    const v = value;
+    if (typeof v.latitude === "number" && typeof v.longitude === "number") {
+      return [v.longitude, v.latitude];
+    }
+  }
+  return void 0;
+}
+function parseDepthSeries(result, depthPath2) {
+  const values = result?.values;
+  const data = result?.data;
+  if (!Array.isArray(values) || !Array.isArray(data)) {
+    return [];
+  }
+  const depthCol = values.findIndex((v) => v?.path === depthPath2);
+  if (depthCol < 0) {
+    return [];
+  }
+  const posCol = values.findIndex((v) => v?.path === "navigation.position");
+  const headingCol = values.findIndex(
+    (v) => v?.path === "navigation.headingTrue"
+  );
+  const rows = [];
+  for (const row of data) {
+    if (!Array.isArray(row)) {
+      continue;
+    }
+    const time = Date.parse(String(row[0]));
+    const depth = row[depthCol + 1];
+    if (!Number.isFinite(time) || typeof depth !== "number" || !Number.isFinite(depth) || depth < 0) {
+      continue;
+    }
+    const rec = { time, depth };
+    if (posCol >= 0) {
+      const position = toPosition(row[posCol + 1]);
+      if (position) {
+        rec.position = position;
+      }
+    }
+    if (headingCol >= 0) {
+      const heading = row[headingCol + 1];
+      if (typeof heading === "number" && Number.isFinite(heading)) {
+        rec.heading = heading;
+      }
+    }
+    rows.push(rec);
+  }
+  return rows;
+}
+
+// src/web/shared/settings.ts
+var DEFAULT_SETTINGS = {
+  enabled: true,
+  source: "history",
+  quality: "auto",
+  historyWindowHours: 1,
+  historyResolutionS: 0.1,
+  shadeLimitMetres: 10,
+  contourIntervalMetres: 1,
+  cellPx: 24,
+  mergeTolerance: 0.15,
+  maxDepthMetres: 100,
+  safetyDepthMetres: 3
+};
+var ENUM_VALUES = {
+  source: ["history", "tiles"],
+  quality: ["auto", "high", "balanced", "low"]
+};
+function mergeSettings(stored) {
+  const out = { ...DEFAULT_SETTINGS };
+  if (!stored) {
+    return out;
+  }
+  for (const key of Object.keys(
+    DEFAULT_SETTINGS
+  )) {
+    const value = stored[key];
+    if (typeof value !== typeof DEFAULT_SETTINGS[key]) {
+      continue;
+    }
+    const allowed = ENUM_VALUES[key];
+    if (allowed && !allowed.includes(value)) {
+      continue;
+    }
+    out[key] = value;
+  }
+  return out;
+}
+
+// src/tiles/core/grid.ts
+var TILE_SIZE = 256;
+var BASE_ZOOM = 20;
+var MIN_ZOOM = 4;
+var NODATA = 65535;
+var RECORD_BYTES = 5;
+var EARTH_RADIUS = 6378137;
+var ORIGIN_SHIFT = Math.PI * EARTH_RADIUS;
+var WORLD_WIDTH = 2 * ORIGIN_SHIFT;
+function decodeDepth(cm) {
+  return cm === NODATA ? NaN : cm / 100;
+}
+function decodeTile(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const cells = /* @__PURE__ */ new Map();
+  for (let o = 0; o + RECORD_BYTES <= view.byteLength; o += RECORD_BYTES) {
+    const cx = view.getUint8(o);
+    const cy = view.getUint8(o + 1);
+    const depth = view.getUint16(o + 2, true);
+    const count = view.getUint8(o + 4);
+    cells.set(cy * TILE_SIZE + cx, { depth, count });
+  }
+  return cells;
+}
+
+// src/tiles/core/tile-source.ts
+var RAD2 = Math.PI / 180;
+function zoomForCellSize(cellMetres, minZoom = MIN_ZOOM, baseZoom = BASE_ZOOM) {
+  if (!(cellMetres > 0)) return baseZoom;
+  const ideal = Math.ceil(
+    Math.log2(2 * Math.PI * 6378137 / (TILE_SIZE * cellMetres))
+  );
+  return Math.max(minZoom, Math.min(baseZoom, ideal));
+}
+function lonToTileX(lon, z) {
+  return (lon + 180) / 360 * Math.pow(2, z);
+}
+function latToTileY(lat, z) {
+  const clamped = Math.max(-85.05112878, Math.min(85.05112878, lat));
+  const latRad = clamped * RAD2;
+  return (1 - Math.log(Math.tan(latRad) + 1 / Math.cos(latRad)) / Math.PI) / 2 * Math.pow(2, z);
+}
+function tileRangeForBbox(bbox, z) {
+  const n = Math.pow(2, z);
+  if (bbox.length !== 4) {
+    return { xs: [], ys: [] };
+  }
+  const [west, south, east, north] = bbox;
+  const xStart = Math.floor(lonToTileX(west, z));
+  let xEnd = Math.floor(lonToTileX(east, z));
+  if (xEnd < xStart) {
+    xEnd += n;
+  }
+  const xCount = Math.min(n, xEnd - xStart + 1);
+  const xs = [];
+  for (let i = 0; i < xCount; i++) {
+    xs.push(((xStart + i) % n + n) % n);
+  }
+  const yStart = Math.max(0, Math.floor(latToTileY(north, z)));
+  const yEnd = Math.min(n - 1, Math.floor(latToTileY(south, z)));
+  const ys = [];
+  for (let y = yStart; y <= yEnd; y++) {
+    ys.push(y);
+  }
+  return { xs, ys };
+}
+function tileCellCentre(z, x, y, key) {
+  const n = Math.pow(2, z);
+  const cx = key % TILE_SIZE;
+  const cy = Math.floor(key / TILE_SIZE);
+  const fx = (x + (cx + 0.5) / TILE_SIZE) / n;
+  const fy = (y + (cy + 0.5) / TILE_SIZE) / n;
+  const lon = fx * 360 - 180;
+  const lat = Math.atan(Math.sinh(Math.PI * (1 - 2 * fy))) / RAD2;
+  return [lon, lat];
+}
+function cellsToSamples(z, x, y, cells) {
+  const samples = [];
+  for (const [key, cell] of cells) {
+    const depth = decodeDepth(cell.depth);
+    if (!Number.isFinite(depth)) continue;
+    const [lon, lat] = tileCellCentre(z, x, y, key);
+    samples.push({ lon, lat, depth });
+  }
+  return samples;
+}
+function decodeTileSamples(z, x, y, bytes) {
+  return cellsToSamples(z, x, y, decodeTile(bytes));
+}
+
+// src/tiles/core/correction.ts
+var EARTH_RADIUS_M = 6378137;
+var DEG_TO_RAD = Math.PI / 180;
+var RAD_TO_DEG = 180 / Math.PI;
+function correctToTransducer(position, heading, offset) {
+  if (heading === void 0 || !Number.isFinite(heading) || !offset.forward && !offset.starboard) {
+    return position;
+  }
+  const cos = Math.cos(heading);
+  const sin = Math.sin(heading);
+  const north = offset.forward * cos - offset.starboard * sin;
+  const east = offset.forward * sin + offset.starboard * cos;
+  const lat = position.lat + north / EARTH_RADIUS_M * RAD_TO_DEG;
+  const lon = position.lon + east / (EARTH_RADIUS_M * Math.cos(position.lat * DEG_TO_RAD)) * RAD_TO_DEG;
+  const wrapped = ((lon + 180) % 360 + 360) % 360 - 180;
+  return { lon: wrapped, lat };
+}
+
+// src/web/renderer.ts
+var PLUGIN_ID = "signalk-livedepth-plugin";
+var ASSET_BASE = `/plotterext/${PLUGIN_ID}`;
+var BATHY_BASE = `${ASSET_BASE}/bathymetry`;
+var DEBOUNCE_MS = 400;
+var POLL_MS = 15e3;
+var MAX_TILE_FETCHES = 24;
+var LIVE_FLUSH_MS = 300;
+var DEFAULT_DEPTH_PATH = "environment.depth.belowTransducer";
+var client = await connectExtension();
+var worker = new Worker(new URL("./render-worker.js", import.meta.url), {
+  type: "module"
+});
+var settings = { ...DEFAULT_SETTINGS };
+var transducer = null;
+var depthPath = DEFAULT_DEPTH_PATH;
+var vessel = {};
+var showFootprint = false;
+var baseSamples = [];
+var lastReq = null;
+var busy = false;
+var dirty = false;
+var rendering = null;
+var renderingLive = false;
+var liveInterval = 200;
+var lastLiveAt = 0;
+var perfScale = 0;
+var perfFrameMs = 0;
+var framesSeen = 0;
+var framesSince = Date.now();
+var timer;
+var pendingLive = [];
+var liveFlushTimer;
+async function loadSettings() {
+  try {
+    const values = await client.state.get();
+    settings = mergeSettings(values);
+  } catch {
+    settings = { ...DEFAULT_SETTINGS };
+  }
+  worker.postMessage({ type: "settings", settings });
+  if (settings.source === "tiles") {
+    startLive();
+  } else {
+    stopLive();
+  }
+  schedule();
+}
+async function loadMeta() {
+  try {
+    const res = await fetch(`${BATHY_BASE}/meta`, {
+      credentials: "same-origin"
+    });
+    if (!res.ok) return;
+    const meta = await res.json();
+    transducer = meta.transducer ?? null;
+    if (meta.depthPath) depthPath = meta.depthPath;
+    vessel = meta.vessel ?? {};
+    showFootprint = meta.debug?.vesselFootprint === true;
+    publishVessel();
+  } catch {
+  }
+}
+function correct(lon, lat, heading) {
+  return transducer ? correctToTransducer({ lon, lat }, heading, transducer) : { lon, lat };
+}
+async function loadUnits() {
+  try {
+    const res = await client.call("units.get");
+    if (res?.units?.depth) {
+      worker.postMessage({ type: "units", depth: res.units.depth });
+    }
+  } catch {
+  }
+}
+async function fetchHistory() {
+  const windowMs = settings.historyWindowHours * 36e5;
+  const to = Date.now();
+  const query = historyValuesQuery({
+    depthPath,
+    from: to - windowMs,
+    to,
+    resolution: Number(settings.historyResolutionS.toPrecision(3))
+  });
+  const res = await fetch(`/signalk/v2/api/history/values?${query}`, {
+    credentials: "same-origin"
+  });
+  if (!res.ok) return;
+  const rows = parseDepthSeries(await res.json(), depthPath);
+  const out = [];
+  for (const row of rows) {
+    if (!row.position) continue;
+    const { lon, lat } = correct(row.position[0], row.position[1], row.heading);
+    out.push({ lon, lat, depth: row.depth });
+  }
+  baseSamples = out;
+  publishBase();
+}
+async function fetchTiles(req) {
+  const cellMetres = Math.max(req.resolution, 0.01);
+  let zoom = zoomForCellSize(cellMetres, MIN_ZOOM, BASE_ZOOM);
+  while (zoom > MIN_ZOOM) {
+    const { xs: xs2, ys: ys2 } = tileRangeForBbox(req.bounds, zoom);
+    if (xs2.length * ys2.length <= MAX_TILE_FETCHES) break;
+    zoom--;
+  }
+  const { xs, ys } = tileRangeForBbox(req.bounds, zoom);
+  const out = [];
+  await Promise.all(
+    xs.flatMap(
+      (x) => ys.map(async (y) => {
+        try {
+          const res = await fetch(`${BATHY_BASE}/tiles/${zoom}/${x}/${y}`, {
+            credentials: "same-origin"
+          });
+          if (!res.ok) return;
+          const bytes = new Uint8Array(await res.arrayBuffer());
+          out.push(...decodeTileSamples(zoom, x, y, bytes));
+        } catch {
+        }
+      })
+    )
+  );
+  baseSamples = out;
+  publishBase();
+}
+function schedule() {
+  clearTimeout(timer);
+  timer = setTimeout(() => void refresh(), DEBOUNCE_MS);
+}
+async function refresh() {
+  if (!settings.enabled) return;
+  if (settings.source === "history") {
+    await fetchHistory();
+  } else if (lastReq) {
+    await fetchTiles(lastReq);
+  }
+}
+function publishBase() {
+  worker.postMessage({ type: "base", samples: baseSamples });
+  dirty = true;
+  if (lastReq) draw(true);
+}
+var liveUnsub;
+function startLive() {
+  if (settings.source !== "tiles" || liveUnsub) return;
+  void client.signalk.subscribe(
+    ["navigation.position", depthPath, "navigation.headingTrue"],
+    (ev) => {
+      if (ev.path === "navigation.position") {
+        const p = ev.value;
+        if (Array.isArray(p)) {
+          livePosition = [p[0], p[1]];
+        } else if (typeof p?.longitude === "number" && typeof p?.latitude === "number") {
+          livePosition = [p.longitude, p.latitude];
+        }
+      } else if (ev.path === depthPath && typeof ev.value === "number") {
+        liveDepth = ev.value;
+      } else if (ev.path === "navigation.headingTrue" && typeof ev.value === "number") {
+        liveHeading = ev.value;
+      }
+      publishVessel();
+      sampleLive();
+    }
+  ).then((un) => {
+    liveUnsub = un;
+  }).catch(() => {
+  });
+  clearInterval(liveFlushTimer);
+  liveFlushTimer = setInterval(flushLive, LIVE_FLUSH_MS);
+}
+function stopLive() {
+  clearInterval(liveFlushTimer);
+  liveFlushTimer = void 0;
+  void liveUnsub?.();
+  liveUnsub = void 0;
+}
+var livePosition = null;
+var liveDepth = null;
+var liveHeading;
+function publishVessel() {
+  if (!showFootprint) return;
+  worker.postMessage({
+    type: "vessel",
+    position: livePosition,
+    heading: liveHeading,
+    loa: vessel.loa,
+    beam: vessel.beam
+  });
+  dirty = true;
+  if (lastReq) draw(true);
+}
+function sampleLive() {
+  if (!livePosition || liveDepth === null) return;
+  const { lon, lat } = correct(livePosition[0], livePosition[1], liveHeading);
+  pendingLive.push({ lon, lat, depth: liveDepth });
+}
+function flushLive() {
+  if (pendingLive.length === 0) return;
+  const live = pendingLive;
+  pendingLive = [];
+  worker.postMessage({ type: "live", samples: live });
+  dirty = true;
+  if (lastReq) draw(true);
+}
+function draw(live = false) {
+  if (busy || !lastReq || !settings.enabled) return;
+  if (live && Date.now() - lastLiveAt < liveInterval) return;
+  busy = true;
+  rendering = lastReq;
+  renderingLive = live;
+  dirty = false;
+  worker.postMessage({ type: "render", req: rendering });
+}
+worker.onmessage = (e) => {
+  const msg = e.data;
+  if (msg.type === "perf") {
+    perfScale = msg.scale;
+    perfFrameMs = msg.frameMs;
+    return;
+  }
+  const req = rendering;
+  const live = renderingLive;
+  busy = false;
+  rendering = null;
+  if (msg.type !== "frame" || !req) {
+    return;
+  }
+  if (live) lastLiveAt = Date.now();
+  void client.overlays.frame({
+    overlayId: req.overlayId,
+    requestId: live ? void 0 : req.requestId,
+    extent: req.extent,
+    image: msg.image
+  }).catch(() => {
+  });
+  framesSeen++;
+  const now = Date.now();
+  if (now - framesSince >= 5e3) {
+    const fps = framesSeen * 1e3 / (now - framesSince);
+    console.info(
+      `[LiveDepth] ${fps.toFixed(1)} frames/s \xB7 render scale ${perfScale.toFixed(2)} \xB7 worker ${perfFrameMs.toFixed(1)} ms/frame`
+    );
+    framesSeen = 0;
+    framesSince = now;
+  }
+  if (dirty || lastReq !== req) draw(live);
+};
+await client.subscribe(["overlay.request"], (_name, payload) => {
+  const req = payload;
+  lastReq = req;
+  if (typeof req.liveInterval === "number" && req.liveInterval > 0) {
+    liveInterval = req.liveInterval;
+  }
+  if (settings.source === "tiles") schedule();
+  draw();
+});
+await client.subscribe(["overlay.state"], (_name, payload) => {
+  const state = payload;
+  if (!state.visible || state.suspended) {
+    worker.postMessage({ type: "release" });
+    stopLive();
+  } else {
+    startLive();
+    schedule();
+  }
+});
+await client.subscribe(["state.changed"], () => void loadSettings());
+await loadMeta();
+await loadSettings();
+await loadUnits();
+setInterval(() => {
+  if (settings.enabled && settings.source === "history") schedule();
+}, POLL_MS);
+//# sourceMappingURL=renderer.js.map