lecodes-sdk 1.1.0 → 2.0.0

package/src/net/replication.ts

@@ -407,7 +407,7 @@ const sendSnapshots = (): void => {
 
 // ---- client: snapshots in, inputs out, the clock, interpolation, correction ----------------------------
 
-const rttTicks = (): number => (bridge()?.clientInfo(0)[1] ?? 0) / TICK_MS
+const rttTicks = (): number => (bridge()?.clientInfo(0)?.rtt ?? 0) / TICK_MS
 
 const onClientBinary = (channel: number, data: ArrayBuffer): void => {
   if (data.byteLength < 12) return

package/src/plugin.ts

@@ -0,0 +1,191 @@
+// `lecodes-sdk/plugin` — the one entry a PLUGIN imports the SDK through (docs/plans/plugins-plan.md).
+// Two readers:
+//   - a plugin's `contract.d.ts`: the channel markers and the precise value types the generator maps
+//     to Swift / Kotlin;
+//   - its `sdk/` wrapper, generated (`<id>.gen.ts`) and hand-written (`<id>.ts`): the two channel
+//     bases and the few SDK internals a wrapper needs.
+//
+// A contract describes the WIRE of one channel, never the app-facing API: three interfaces per
+// channel — the methods (it extends a marker), the params, the events.
+
+import { File as HostFile } from "./runtime/fetch"
+import { ServiceClient } from "./runtime/service"
+import { NativeView, NativeViewElement } from "./ui/NativeView"
+import { _navEpoch } from "./ui/presentable"
+import { _requestCameraPermission } from "./plugins/permission"
+
+export type { PresentOptions } from "./ui/presentable"
+export type { NativeView } from "./ui/NativeView"
+export type { FetchResponse } from "./runtime/fetch"
+
+// ---- the contract's vocabulary ---------------------------------------------------------------------
+
+/** Signed 32-bit integer on the wire. */
+export type i32 = number
+/** Double on the wire — also every integer that can leave 32 bits (a millisecond time stamp). */
+export type f64 = number
+
+/** Bytes that STAY in the host's buffer table: the native half hands over its bytes + a name, the
+ *  app gets the SDK's `File` handle (a texture source, a `FormData` value, a share) and the bytes
+ *  never enter the JS heap. For bytes the app must read itself, a contract says `Uint8Array`. */
+export type File = HostFile
+
+/** Any JSON value, opaque to the generator (GeoJSON, a developer's own payload): it crosses as is
+ *  and the native half receives the platform's untyped value. */
+export type Json = null | boolean | number | string | Json[] | { [key: string]: Json }
+
+declare const channel: unique symbol
+
+/** Marks a contract interface as a NativeView channel. `Name` is what the halves register under
+ *  (`registerView(name)`); `Params` is what a factory receives; `Events` maps an event's name to
+ *  its payload (`void` = no payload). */
+export interface View<Name extends string, Params extends object = {}, Events extends object = {}> {
+  readonly [channel]?: { kind: "view", name: Name, params: Params, events: Events }
+}
+
+/** Marks a contract interface as a headless Service channel — see {@link View}. */
+export interface Service<Name extends string, Params extends object = {}, Events extends object = {}> {
+  readonly [channel]?: { kind: "service", name: Name, params: Params, events: Events }
+}
+
+// ---- the wrapper's bases ---------------------------------------------------------------------------
+
+/** A listener of the event `K`: no argument for a `void` payload. */
+export type Listener<Events, K extends keyof Events> = Events[K] extends void ? () => void : (payload: Events[K]) => void
+
+/** A method the host's half is too old for (`@since`): refused HERE, by what it needs, before the
+ *  half is asked. `version` = the half's contract version (0 = the host has none: the channel's own
+ *  "not supported" speaks then). */
+const tooOld = (iface: string, name: string, method: string, since: number, version: number): Error | null =>
+  since > 1 && version > 0 && version < since
+    ? new Error(`${iface}.${method} needs the "${name}" plugin at contract version ${since} — this host's is ${version}`)
+    : null
+
+/** An optional argument the caller left out is ABSENT on the wire, not a null in its place. */
+const present = (args: any[]): any[] => {
+  let n = args.length
+  while (n > 0 && args[n - 1] === undefined) n--
+  return n === args.length ? args : args.slice(0, n)
+}
+
+/** What an event's payload is read with when it is not on the wire what it is for the app (it
+ *  holds a File): by the event's name. */
+export type EventReaders = { [event: string]: (wire: any) => any }
+
+/** The listeners of the events that have a reader: the app's callback → the one that reads first,
+ *  so `off` finds what `on` registered. */
+class Readers {
+  private readonly wrapped = new Map<string, Map<Function, (data?: any) => void>>()
+  private readonly readers: EventReaders | undefined
+  constructor(readers: EventReaders | undefined) { this.readers = readers }
+
+  on(event: string, callback: (data?: any) => void): (data?: any) => void {
+    const read = this.readers?.[event]
+    if (!read) return callback
+    let byCallback = this.wrapped.get(event)
+    if (!byCallback) this.wrapped.set(event, byCallback = new Map())
+    let listener = byCallback.get(callback)
+    if (!listener) byCallback.set(callback, listener = (wire?: any) => callback(read(wire)))
+    return listener
+  }
+  off(event: string, callback: (data?: any) => void): (data?: any) => void {
+    const byCallback = this.wrapped.get(event)
+    const listener = byCallback?.get(callback)
+    if (!listener) return callback
+    byCallback!.delete(callback)
+    return listener
+  }
+}
+
+/** The element of a view plugin: a `NativeView` whose events are the contract's. Generated wrappers
+ *  extend it (`<Name>Base`); a hand-written one extends that, or this when its API is not the wire's. */
+export class ViewChannel<Events extends object = {}> extends NativeViewElement {
+  /** @internal The contract interface's name, for messages. */
+  readonly _iface: string
+  private readonly _readers: Readers
+
+  constructor(iface: string, name: string, params: object, readers?: EventReaders) {
+    super(name, params)
+    this._iface = iface
+    this._readers = new Readers(readers)
+  }
+
+  /** Whether this host registered a view under `name` — at contract version `since` or later, when
+   *  one is given (a method's `@since`). */
+  static supports(name: string, since = 1): boolean { return since <= 1 ? NativeView.isSupported(name) : NativeView.version(name) >= since }
+
+  override on<K extends keyof Events & string>(event: K, callback: Listener<Events, K>): this {
+    return super.on(event, this._readers.on(event, callback as (data?: any) => void))
+  }
+  override off<K extends keyof Events & string>(event: K, callback: Listener<Events, K>): this {
+    return super.off(event, this._readers.off(event, callback as (data?: any) => void))
+  }
+
+  /** @internal One call over the wire — what the generated functions are made of. */
+  _call(method: string, args: any[], since = 1): Promise<any> {
+    const old = since > 1 ? tooOld(this._iface, this.viewName, method, since, NativeView.version(this.viewName)) : null
+    return old ? Promise.reject(old) : this._channelSend(method, present(args))
+  }
+}
+
+/** The client of a service plugin: a session that opens on the first call, with the contract's
+ *  events. The service twin of {@link ViewChannel}. */
+export class ServiceChannel<Events extends object = {}> extends ServiceClient {
+  /** @internal */
+  readonly _iface: string
+  private readonly _readers: Readers
+
+  constructor(iface: string, name: string, params: object = {}, readers?: EventReaders) {
+    super(name, params)
+    this._iface = iface
+    this._readers = new Readers(readers)
+  }
+
+  /** Whether this host registered a service under `name` — at contract version `since` or later,
+   *  when one is given (a method's `@since`). */
+  static supports(name: string, since = 1): boolean { return since <= 1 ? ServiceClient.isSupported(name) : ServiceClient.version(name) >= since }
+
+  override on<K extends keyof Events & string>(event: K, callback: Listener<Events, K>): this {
+    return super.on(event, this._readers.on(event, callback as (data?: any) => void))
+  }
+  override off<K extends keyof Events & string>(event: K, callback: Listener<Events, K>): this {
+    return super.off(event, this._readers.off(event, callback as (data?: any) => void))
+  }
+
+  /** @internal */
+  _call(method: string, args: any[], since = 1): Promise<any> {
+    const old = since > 1 ? tooOld(this._iface, this.serviceName, method, since, ServiceClient.version(this.serviceName)) : null
+    return old ? Promise.reject(old) : this._channelSend(method, present(args))
+  }
+}
+
+// ---- what a wrapper reads off the wire -------------------------------------------------------------
+
+/** @internal A `File` of the contract as it crosses: the host buffer's id, the name, the size. */
+export const _toFile = (wire: { systemId: number, name: string, size: number }): File =>
+  new HostFile(wire.systemId, wire.name, wire.size)
+
+/** @internal …and the other way: a File the app hands a half. The bytes stay where they are — the
+ *  half reads them out of the host's buffer table. */
+export const _fromFile = (file: File): { systemId: number, name: string, size: number } =>
+  ({ systemId: file._h.id, name: file.name, size: file.size })
+
+// ---- for the hand-written part ---------------------------------------------------------------------
+
+/** The text of a host buffer — what a bundled `asset()` is in a shell compile (`"id:N"`): the host
+ *  already holds the bytes. Empty when there is no such buffer. */
+export const bufferText = (systemId: number): string => _creatorFetch.toText(systemId)
+
+/** Prepare-then-present for a view that needs the camera: fail before any prompt on a host without
+ *  the view, ask for the permission while the current destination stays visible, give up when
+ *  another navigation superseded this one. Resolves when the view may open. */
+export const prepareCamera = async (view: ViewChannel<any>): Promise<void> => {
+  if (!NativeView.isSupported(view.viewName)) {
+    throw new Error(`${view._iface} isn't available on this host — it needs a registered "${view.viewName}" view.`)
+  }
+  const epoch = _navEpoch()
+  await _requestCameraPermission()
+  if (_navEpoch() !== epoch) {
+    throw new Error(`${view._iface}.open() superseded: another destination was opened while preparing`)
+  }
+}

package/src/plugins/gen/camera/contract.d.ts

@@ -0,0 +1,27 @@
+// GENERATED by scripts/vendor-plugins.ts from lecodes-plugins/plugins/camera/contract.d.ts — do not edit here.
+// Change it in the plugin repo and run `bun run vendor:plugins`; `bun run check:plugins` fails when this copy is stale.
+// camera — a live camera preview with still capture.
+// The contract of the WIRE: what the app-facing `CameraView` (sdk/) and the halves (ios/, android/,
+// web/) agree on. The generator reads this file; nothing else describes the channel.
+
+import type { File, View } from "../../../plugin"
+
+export type Facing = "front" | "back"
+
+export interface CameraParams {
+  /** Default "back". */
+  facingMode?: Facing
+}
+
+export interface CameraEvents {
+  /** The preview could not start or stopped (no camera, the stream was refused). */
+  error: { message: string }
+}
+
+export interface CameraView extends View<"camera", CameraParams, CameraEvents> {
+  /** Capture a still frame as a JPEG.
+   *  @rejects failed */
+  takePhoto(): Promise<File>
+  /** Switch the camera while the preview is live. */
+  setFacingMode(mode: Facing): Promise<void>
+}

package/src/plugins/gen/camera/sdk/camera.gen.ts

@@ -0,0 +1,46 @@
+// GENERATED by scripts/vendor-plugins.ts from lecodes-plugins/plugins/camera/sdk/camera.gen.ts — do not edit here.
+// Change it in the plugin repo and run `bun run vendor:plugins`; `bun run check:plugins` fails when this copy is stale.
+// GENERATED by `lecodes plugin gen` from contract.d.ts — do not edit.
+// camera: the view "camera", contract version 1.
+
+import { ViewChannel, _toFile, type File } from "../../../../plugin"
+import type { CameraEvents, CameraParams, Facing } from "../contract"
+
+/** What the halves register under. */
+export const NAME = "camera"
+/** The contract's version: the highest `@since` of its members. */
+export const VERSION = 1
+
+// ---- the wire, call by call ----------------------------------------------------------------------
+
+/** Capture a still frame as a JPEG.
+ *  Rejects with "failed". */
+export const takePhoto = (view: ViewChannel<CameraEvents>): Promise<File> =>
+  view._call("takePhoto", []).then((w: any) => _toFile(w))
+
+/** Switch the camera while the preview is live. */
+export const setFacingMode = (view: ViewChannel<CameraEvents>, mode: Facing): Promise<void> =>
+  view._call("setFacingMode", [mode])
+
+// ---- what the host's half has --------------------------------------------------------------------
+
+/** A method of the contract. */
+export type Method = "takePhoto" | "setFacingMode"
+
+/** Whether this host has the view "camera" — and, given a method, a half new enough for it
+ *  (a method added after the first version of the contract is tagged `@since`). */
+export const supports = (method?: Method): boolean =>
+  ViewChannel.supports(NAME)   // every method is of version 1
+
+// ---- the element ----------------------------------------------------------------------------------
+
+/** The view "camera" with the wire's methods as its own. */
+export class CameraViewBase extends ViewChannel<CameraEvents> {
+  constructor(params: CameraParams = {}) { super("CameraView", NAME, params) }
+
+  /** Capture a still frame as a JPEG.
+   *  Rejects with "failed". */
+  takePhoto(): Promise<File> { return takePhoto(this) }
+  /** Switch the camera while the preview is live. */
+  setFacingMode(mode: Facing): Promise<void> { return setFacingMode(this, mode) }
+}

package/src/plugins/gen/camera/sdk/camera.ts

@@ -0,0 +1,57 @@
+// GENERATED by scripts/vendor-plugins.ts from lecodes-plugins/plugins/camera/sdk/camera.ts — do not edit here.
+// Change it in the plugin repo and run `bun run vendor:plugins`; `bun run check:plugins` fails when this copy is stale.
+// CameraView — the device camera (a live preview + still capture) as a view the app opens
+// fullscreen (`await camera.open()`), pushes (`Router.push(camera)`) or embeds among a screen's
+// children. `takePhoto()` returns a `File`: a texture source, a `FormData` value, a share.
+//
+// Hand-written over the generated wire for ONE reason: the permission is asked BEFORE the view is
+// presented, while the current destination stays visible.
+
+import { prepareCamera, type File, type NativeView, type PresentOptions } from "../../../../plugin"
+import { CameraViewBase, NAME } from "./camera.gen"
+import type { Facing } from "../contract"
+
+export type CameraFacing = Facing
+
+export interface CameraView extends NativeView {
+  /** Request the camera permission, then present the preview. The current destination stays
+   *  visible until the camera is ready; rejects if the permission is denied, the host has no
+   *  camera, or another navigation superseded this one. */
+  open(options?: PresentOptions): Promise<void>
+  /** Capture a still frame as an image `File` (host-encoded). */
+  takePhoto(): Promise<File>
+  /** Switch between the front and the back camera while the preview is live. */
+  setFacingMode(facingMode: CameraFacing): Promise<void>
+}
+
+class CameraViewElement extends CameraViewBase {
+  constructor(options: { facingMode?: CameraFacing } = {}) {
+    super({ facingMode: options.facingMode ?? "back" })
+  }
+
+  /** @internal prepare-then-present (see Presentable._prepare). */
+  _prepare(): Promise<void> { return prepareCamera(this) }
+
+  override async open(options?: PresentOptions): Promise<void> {
+    await this._prepare()
+    super.open(options)
+  }
+}
+
+/**
+ * Create a camera view (default: the back camera). `CameraView.isSupported` reports whether this
+ * host has the capability — check it before offering the feature.
+ */
+// PURE IIFE so an app that never uses the camera tree-shakes the whole plugin away.
+export const CameraView: {
+  (options?: { facingMode?: CameraFacing }): CameraView
+  /** Whether this host registered a "camera" view. */
+  readonly isSupported: boolean
+} = /*#__PURE__*/ (() => {
+  const factory = (options?: { facingMode?: CameraFacing }): CameraView =>
+    new CameraViewElement(options) as unknown as CameraView
+  Object.defineProperty(factory, "isSupported", {
+    get: (): boolean => CameraViewBase.supports(NAME),
+  })
+  return factory as any
+})()

package/src/plugins/gen/geolocation/contract.d.ts

@@ -0,0 +1,50 @@
+// GENERATED by scripts/vendor-plugins.ts from lecodes-plugins/plugins/geolocation/contract.d.ts — do not edit here.
+// Change it in the plugin repo and run `bun run vendor:plugins`; `bun run check:plugins` fails when this copy is stale.
+// geolocation — the device position.
+// The wire has ONE watch per session (startWatch / stopWatch + the `position` event); the
+// app-facing `Geolocation.watch(callback)` fans it out to its subscribers in sdk/.
+//
+// A session opens without a prompt. The OS permission prompt belongs to the first call that needs
+// the position.
+
+import type { Service, f64 } from "../../../plugin"
+
+export interface GeoOptions {
+  /** Prefer the precise (GPS) provider — slower first fix, more battery. Default false. */
+  highAccuracy?: boolean
+  /** getCurrent only: reject with "timeout" when no fix arrives in this many ms. */
+  timeout?: f64
+}
+
+export interface GeoPosition {
+  latitude: f64
+  longitude: f64
+  /** Horizontal accuracy radius, meters. */
+  accuracy: f64
+  /** Meters above sea level; null when the provider does not know. */
+  altitude: f64 | null
+  /** Direction of travel, degrees clockwise from north; null when stationary or unknown. */
+  heading: f64 | null
+  /** Ground speed, m/s; null when unknown. */
+  speed: f64 | null
+  /** When the fix was taken, ms since the epoch. */
+  timestamp: f64
+}
+
+export interface GeolocationParams {}
+
+export interface GeolocationEvents {
+  /** A fix of the live watch. */
+  position: GeoPosition
+}
+
+export interface Geolocation extends Service<"geolocation", GeolocationParams, GeolocationEvents> {
+  /** One fix.
+   *  @rejects denied unavailable timeout */
+  getCurrent(options?: GeoOptions): Promise<GeoPosition>
+  /** Start the session's watch; resolves once it is live (permission granted, provider started).
+   *  A second call while watching resolves at once and keeps the first call's options.
+   *  @rejects denied unavailable */
+  startWatch(options?: GeoOptions): Promise<void>
+  stopWatch(): Promise<void>
+}

package/src/plugins/gen/geolocation/sdk/geolocation.gen.ts

@@ -0,0 +1,54 @@
+// GENERATED by scripts/vendor-plugins.ts from lecodes-plugins/plugins/geolocation/sdk/geolocation.gen.ts — do not edit here.
+// Change it in the plugin repo and run `bun run vendor:plugins`; `bun run check:plugins` fails when this copy is stale.
+// GENERATED by `lecodes plugin gen` from contract.d.ts — do not edit.
+// geolocation: the service "geolocation", contract version 1.
+
+import { ServiceChannel } from "../../../../plugin"
+import type { GeoOptions, GeoPosition, GeolocationEvents, GeolocationParams } from "../contract"
+
+/** What the halves register under. */
+export const NAME = "geolocation"
+/** The contract's version: the highest `@since` of its members. */
+export const VERSION = 1
+
+// ---- the wire, call by call ----------------------------------------------------------------------
+
+/** One fix.
+ *  Rejects with "denied" / "unavailable" / "timeout". */
+export const getCurrent = (service: ServiceChannel<GeolocationEvents>, options?: GeoOptions): Promise<GeoPosition> =>
+  service._call("getCurrent", [options])
+
+/** Start the session's watch; resolves once it is live (permission granted, provider started).
+ *  A second call while watching resolves at once and keeps the first call's options.
+ *  Rejects with "denied" / "unavailable". */
+export const startWatch = (service: ServiceChannel<GeolocationEvents>, options?: GeoOptions): Promise<void> =>
+  service._call("startWatch", [options])
+
+export const stopWatch = (service: ServiceChannel<GeolocationEvents>): Promise<void> =>
+  service._call("stopWatch", [])
+
+// ---- what the host's half has --------------------------------------------------------------------
+
+/** A method of the contract. */
+export type Method = "getCurrent" | "startWatch" | "stopWatch"
+
+/** Whether this host has the service "geolocation" — and, given a method, a half new enough for it
+ *  (a method added after the first version of the contract is tagged `@since`). */
+export const supports = (method?: Method): boolean =>
+  ServiceChannel.supports(NAME)   // every method is of version 1
+
+// ---- the client -----------------------------------------------------------------------------------
+
+/** The service "geolocation" with the wire's methods as its own. */
+export class GeolocationBase extends ServiceChannel<GeolocationEvents> {
+  constructor(params: GeolocationParams = {}) { super("Geolocation", NAME, params) }
+
+  /** One fix.
+   *  Rejects with "denied" / "unavailable" / "timeout". */
+  getCurrent(options?: GeoOptions): Promise<GeoPosition> { return getCurrent(this, options) }
+  /** Start the session's watch; resolves once it is live (permission granted, provider started).
+   *  A second call while watching resolves at once and keeps the first call's options.
+   *  Rejects with "denied" / "unavailable". */
+  startWatch(options?: GeoOptions): Promise<void> { return startWatch(this, options) }
+  stopWatch(): Promise<void> { return stopWatch(this) }
+}

package/src/plugins/{geolocation.ts → gen/geolocation/sdk/geolocation.ts}

@@ -1,39 +1,18 @@
-// Geolocation — the device position as a typed service plugin (docs/service-channel-plan.md).
-// A wrapper over the host-registered "geolocation" service, exactly like QRScanner wraps the
-// "qrScanner" NativeView — except services have no UI surface, so there is nothing to present:
-// just `getCurrent()` and `watch()`.
+// GENERATED by scripts/vendor-plugins.ts from lecodes-plugins/plugins/geolocation/sdk/geolocation.ts — do not edit here.
+// Change it in the plugin repo and run `bun run vendor:plugins`; `bun run check:plugins` fails when this copy is stale.
+// Geolocation — the device position: `getCurrent()` and `watch()`.
 //
-// Host-OPTIONAL, like every plugin: it exists where the host registered a "geolocation" service
-// (web hosts do out of the box; Android via MainActivity) — gate on `Geolocation.isSupported`.
-// The OS permission prompt happens on the first call that needs it (host-side); denial is a
-// rejection. Both methods reject immediately on unsupported hosts, BEFORE any permission path.
+// Hand-written over the generated wire because the public API is not the wire's: the wire has ONE
+// watch per session (startWatch / stopWatch + the `position` event), the app gets `watch(callback)`
+// — any number of subscribers on that one watch, each with its own `stop()`.
 //
-// Service contract ("geolocation"): calls `getCurrent(options) → GeoPosition`,
-// `startWatch(options)` (resolves once watching), `stopWatch()`; event `position` → GeoPosition.
+// The OS permission prompt happens on the first call that needs it (host-side); a denial is a
+// rejection. Both methods reject on a host without the service BEFORE any permission path.
 
-import { ServiceClient } from "../runtime/service"
+import { GeolocationBase, NAME } from "./geolocation.gen"
+import type { GeoOptions, GeoPosition } from "../contract"
 
-export interface GeoPosition {
-  latitude: number
-  longitude: number
-  /** Horizontal accuracy radius, meters. */
-  accuracy: number
-  /** Meters above sea level, or null when the provider doesn't know. */
-  altitude: number | null
-  /** Direction of travel in degrees clockwise from north, or null when stationary/unknown. */
-  heading: number | null
-  /** Ground speed in m/s, or null when unknown. */
-  speed: number | null
-  /** When this fix was taken, ms epoch. */
-  timestamp: number
-}
-
-export interface GeoOptions {
-  /** Prefer the precise (GPS) provider — slower first fix, more battery. Default false. */
-  highAccuracy?: boolean
-  /** getCurrent only: reject with "timeout" if no fix arrives in this many ms. */
-  timeout?: number
-}
+export type { GeoOptions, GeoPosition }
 
 /** A live `Geolocation.watch()` subscription — `stop()` it when the screen goes away. */
 export interface GeoWatch {
@@ -44,7 +23,7 @@ export interface GeoWatch {
  * The device position. `Geolocation.isSupported` reports whether this host registered the
  * service — check it before offering location features.
  */
-// PURE IIFE so an app that never uses location tree-shakes the whole plugin away (see NativeView).
+// PURE IIFE so an app that never uses location tree-shakes the whole plugin away.
 export const Geolocation: {
   /** Whether this host registered a "geolocation" service. */
   readonly isSupported: boolean
@@ -56,18 +35,18 @@ export const Geolocation: {
    *  subscriber; the options of the watch that starts it win. Always `stop()` when done. */
   watch(callback: (position: GeoPosition) => void, options?: GeoOptions): Promise<GeoWatch>
 } = /*#__PURE__*/ (() => {
-  let client: ServiceClient | null = null
-  const service = (): ServiceClient => client ??= new ServiceClient("geolocation")
+  let client: GeolocationBase | null = null
+  const service = (): GeolocationBase => client ??= new GeolocationBase()
 
-  // Watch state: one host watch fans out to N subscribers (SDK-side), the last stop() releases it.
+  // Watch state: one host watch fans out to N subscribers, the last stop() releases it.
   const watchers: ((position: GeoPosition) => void)[] = []
   let positionHooked = false
   let startPromise: Promise<void> | null = null
 
   const assertSupported = (): void => {
     // Fail before the host is touched — a permission dialog for a feature that can't exist
-    // would be worse than the error (same ordering rule as QRScanner.open).
-    if (!ServiceClient.isSupported("geolocation")) {
+    // would be worse than the error.
+    if (!GeolocationBase.supports(NAME)) {
       throw new Error('Geolocation isn\'t available on this host — it needs a registered "geolocation" service.')
     }
   }
@@ -77,26 +56,26 @@ export const Geolocation: {
     if (i >= 0) watchers.splice(i, 1)
     if (watchers.length === 0 && startPromise !== null) {
       startPromise = null
-      service().call("stopWatch").catch(() => {})
+      service().stopWatch().catch(() => {})
     }
   }
 
   const geolocation = {
     async getCurrent(options?: GeoOptions): Promise<GeoPosition> {
       assertSupported()
-      return await service().call("getCurrent", options ?? {})
+      return await service().getCurrent(options ?? {})
     },
 
     async watch(callback: (position: GeoPosition) => void, options?: GeoOptions): Promise<GeoWatch> {
       assertSupported()
       if (!positionHooked) {
         positionHooked = true
-        service().on("position", (position?: GeoPosition) => {
+        service().on("position", position => {
           if (position) for (const cb of [...watchers]) cb(position)
         })
       }
       watchers.push(callback)
-      startPromise ??= service().call("startWatch", options ?? {})
+      startPromise ??= service().startWatch(options ?? {})
       try {
         await startPromise
       } catch (e) {
@@ -117,7 +96,7 @@ export const Geolocation: {
     },
   }
   Object.defineProperty(geolocation, "isSupported", {
-    get: (): boolean => ServiceClient.isSupported("geolocation"),
+    get: (): boolean => GeolocationBase.supports(NAME),
   })
   return geolocation as any
 })()