lecodes-cli 0.18.2 → 0.19.2

package/runtime/sdk/math/vec.ts

@@ -1,255 +0,0 @@
-// Fluent 2D / 3D vectors — the SDK's user-facing vector math (no gl-matrix, no out-params, no imports).
-//
-// Design (see PLAN.md): a vector is a *mutable little struct* — `v.x = 3`, `v.set(x, y, z)` mutate in
-// place — but every *method* is PURE: `a.add(b)` returns a NEW vector and never touches `a`. So chains
-// (`dir.normalize().scale(s)`) can't clobber their source, and the immutable-method style is the most
-// amenable to a future escape-analysis / scalar-replacement compiler pass. Backing is plain number
-// fields (not a Float32Array), which the optimizer can trivially scalar-replace.
-//
-// "Never wrap away the metal": vectors expose `.x/.y/.z`, are iterable (`const [x, y] = v`, `[...v]`),
-// and every method / constructor accepts a raw tuple just as well as a wrapper. Reads off a `*Like`
-// input go through the `cx/cy/cz` helpers below, which work uniformly on a wrapper (`.x`) or an
-// array-like (`[0]`), so callers can always pass `[0, 1, 0]` where a vector is expected.
-
-export type Vec2Like = Vec2 | readonly [number, number] | number[] | Float32Array
-export type Vec3Like = Vec3 | readonly [number, number, number] | number[] | Float32Array
-
-/** Read the x / first component of any vector-like (wrapper, tuple, or typed array). `?? ` is safe on
- *  0 and NaN — it only falls through on `undefined` (i.e. a non-wrapper that has no `.x`). */
-export const cx = (v: { x?: number } | ArrayLike<number>): number => (v as { x?: number }).x ?? (v as ArrayLike<number>)[0]
-export const cy = (v: { y?: number } | ArrayLike<number>): number => (v as { y?: number }).y ?? (v as ArrayLike<number>)[1]
-export const cz = (v: { z?: number } | ArrayLike<number>): number => (v as { z?: number }).z ?? (v as ArrayLike<number>)[2]
-
-/** Relative-epsilon compare (matches gl-matrix's `equals`), so the oracle tests agree to the bit. */
-const approx = (a: number, b: number, eps: number): boolean => Math.abs(a - b) <= eps * Math.max(1, Math.abs(a), Math.abs(b))
-
-// ---------------------------------------------------------------------------------------------------
-// Vec2
-// ---------------------------------------------------------------------------------------------------
-
-export class Vec2 {
-  x: number
-  y: number
-
-  constructor(x: number | Vec2Like = 0, y = 0) {
-    if (typeof x === "number") { this.x = x; this.y = y }
-    else { this.x = cx(x); this.y = cy(x) }
-  }
-
-  // --- mutation (the only methods that change `this`) ---
-  /** Mutate the components in place. Returns `this`. */
-  set(x: number, y: number): this { this.x = x; this.y = y; return this }
-  /** Copy another vector's components into this one. Returns `this`. */
-  copy(v: Vec2Like): this { this.x = cx(v); this.y = cy(v); return this }
-
-  // --- pure arithmetic (each returns a NEW Vec2) ---
-  add(v: Vec2Like): Vec2 { return new Vec2(this.x + cx(v), this.y + cy(v)) }
-  sub(v: Vec2Like): Vec2 { return new Vec2(this.x - cx(v), this.y - cy(v)) }
-  mul(v: Vec2Like): Vec2 { return new Vec2(this.x * cx(v), this.y * cy(v)) }
-  div(v: Vec2Like): Vec2 { return new Vec2(this.x / cx(v), this.y / cy(v)) }
-  scale(s: number): Vec2 { return new Vec2(this.x * s, this.y * s) }
-  /** `this + v * s` (fused multiply-add). */
-  scaleAndAdd(v: Vec2Like, s: number): Vec2 { return new Vec2(this.x + cx(v) * s, this.y + cy(v) * s) }
-  negate(): Vec2 { return new Vec2(-this.x, -this.y) }
-
-  // --- products / measures ---
-  dot(v: Vec2Like): number { return this.x * cx(v) + this.y * cy(v) }
-  /** 2D cross product → the scalar z of the 3D cross (signed parallelogram area). */
-  cross(v: Vec2Like): number { return this.x * cy(v) - this.y * cx(v) }
-  length(): number { return Math.hypot(this.x, this.y) }
-  lengthSq(): number { return this.x * this.x + this.y * this.y }
-  distanceTo(v: Vec2Like): number { return Math.hypot(this.x - cx(v), this.y - cy(v)) }
-  distanceSqTo(v: Vec2Like): number { const dx = this.x - cx(v), dy = this.y - cy(v); return dx * dx + dy * dy }
-
-  normalize(): Vec2 {
-    const l = Math.hypot(this.x, this.y)
-    return l === 0 ? new Vec2(0, 0) : new Vec2(this.x / l, this.y / l)
-  }
-  lerp(v: Vec2Like, t: number): Vec2 { return new Vec2(this.x + (cx(v) - this.x) * t, this.y + (cy(v) - this.y) * t) }
-  clamp(min: Vec2Like, max: Vec2Like): Vec2 {
-    return new Vec2(clampN(this.x, cx(min), cx(max)), clampN(this.y, cy(min), cy(max)))
-  }
-  min(v: Vec2Like): Vec2 { return new Vec2(Math.min(this.x, cx(v)), Math.min(this.y, cy(v))) }
-  max(v: Vec2Like): Vec2 { return new Vec2(Math.max(this.x, cx(v)), Math.max(this.y, cy(v))) }
-  /** Left-hand perpendicular: (-y, x), a 90° CCW turn. */
-  perp(): Vec2 { return new Vec2(-this.y, this.x) }
-  /** Rotate by `rad` (CCW) around `origin` (default 0). */
-  rotate(rad: number, origin: Vec2Like = ZERO2): Vec2 {
-    const ox = cx(origin), oy = cy(origin)
-    const c = Math.cos(rad), s = Math.sin(rad)
-    const dx = this.x - ox, dy = this.y - oy
-    return new Vec2(ox + dx * c - dy * s, oy + dx * s + dy * c)
-  }
-  /** The vector's heading in radians: `atan2(y, x)`. */
-  heading(): number { return Math.atan2(this.y, this.x) }
-  /** Angle (radians) between this and `v`. */
-  angle(v: Vec2Like): number {
-    const mag = Math.sqrt(this.lengthSq() * (cx(v) * cx(v) + cy(v) * cy(v)))
-    return mag === 0 ? 0 : Math.acos(clampN(this.dot(v) / mag, -1, 1))
-  }
-
-  withX(x: number): Vec2 { return new Vec2(x, this.y) }
-  withY(y: number): Vec2 { return new Vec2(this.x, y) }
-
-  // --- interop ---
-  equals(v: Vec2Like, eps = 1e-6): boolean { return approx(this.x, cx(v), eps) && approx(this.y, cy(v), eps) }
-  clone(): Vec2 { return new Vec2(this.x, this.y) }
-  toArray(): [number, number] { return [ this.x, this.y ] }
-  *[Symbol.iterator](): Iterator<number> { yield this.x; yield this.y }
-
-  static from(v: Vec2Like): Vec2 { return new Vec2(cx(v), cy(v)) }
-  static get zero(): Vec2 { return new Vec2(0, 0) }
-  static get one(): Vec2 { return new Vec2(1, 1) }
-  static get up(): Vec2 { return new Vec2(0, 1) }
-  static get down(): Vec2 { return new Vec2(0, -1) }
-  static get left(): Vec2 { return new Vec2(-1, 0) }
-  static get right(): Vec2 { return new Vec2(1, 0) }
-}
-
-// ---------------------------------------------------------------------------------------------------
-// Vec3
-// ---------------------------------------------------------------------------------------------------
-
-export class Vec3 {
-  x: number
-  y: number
-  z: number
-
-  constructor(x: number | Vec3Like = 0, y = 0, z = 0) {
-    if (typeof x === "number") { this.x = x; this.y = y; this.z = z }
-    else { this.x = cx(x); this.y = cy(x); this.z = cz(x) }
-  }
-
-  // --- mutation ---
-  set(x: number, y: number, z: number): this { this.x = x; this.y = y; this.z = z; return this }
-  copy(v: Vec3Like): this { this.x = cx(v); this.y = cy(v); this.z = cz(v); return this }
-
-  // --- pure arithmetic ---
-  add(v: Vec3Like): Vec3 { return new Vec3(this.x + cx(v), this.y + cy(v), this.z + cz(v)) }
-  sub(v: Vec3Like): Vec3 { return new Vec3(this.x - cx(v), this.y - cy(v), this.z - cz(v)) }
-  mul(v: Vec3Like): Vec3 { return new Vec3(this.x * cx(v), this.y * cy(v), this.z * cz(v)) }
-  div(v: Vec3Like): Vec3 { return new Vec3(this.x / cx(v), this.y / cy(v), this.z / cz(v)) }
-  scale(s: number): Vec3 { return new Vec3(this.x * s, this.y * s, this.z * s) }
-  /** `this + v * s` (fused multiply-add). */
-  scaleAndAdd(v: Vec3Like, s: number): Vec3 { return new Vec3(this.x + cx(v) * s, this.y + cy(v) * s, this.z + cz(v) * s) }
-  negate(): Vec3 { return new Vec3(-this.x, -this.y, -this.z) }
-
-  // --- products / measures ---
-  dot(v: Vec3Like): number { return this.x * cx(v) + this.y * cy(v) + this.z * cz(v) }
-  cross(v: Vec3Like): Vec3 {
-    const bx = cx(v), by = cy(v), bz = cz(v)
-    return new Vec3(this.y * bz - this.z * by, this.z * bx - this.x * bz, this.x * by - this.y * bx)
-  }
-  length(): number { return Math.hypot(this.x, this.y, this.z) }
-  lengthSq(): number { return this.x * this.x + this.y * this.y + this.z * this.z }
-  distanceTo(v: Vec3Like): number { return Math.hypot(this.x - cx(v), this.y - cy(v), this.z - cz(v)) }
-  distanceSqTo(v: Vec3Like): number {
-    const dx = this.x - cx(v), dy = this.y - cy(v), dz = this.z - cz(v)
-    return dx * dx + dy * dy + dz * dz
-  }
-
-  normalize(): Vec3 {
-    const l = Math.hypot(this.x, this.y, this.z)
-    return l === 0 ? new Vec3(0, 0, 0) : new Vec3(this.x / l, this.y / l, this.z / l)
-  }
-  lerp(v: Vec3Like, t: number): Vec3 {
-    return new Vec3(this.x + (cx(v) - this.x) * t, this.y + (cy(v) - this.y) * t, this.z + (cz(v) - this.z) * t)
-  }
-  clamp(min: Vec3Like, max: Vec3Like): Vec3 {
-    return new Vec3(clampN(this.x, cx(min), cx(max)), clampN(this.y, cy(min), cy(max)), clampN(this.z, cz(min), cz(max)))
-  }
-  min(v: Vec3Like): Vec3 { return new Vec3(Math.min(this.x, cx(v)), Math.min(this.y, cy(v)), Math.min(this.z, cz(v))) }
-  max(v: Vec3Like): Vec3 { return new Vec3(Math.max(this.x, cx(v)), Math.max(this.y, cy(v)), Math.max(this.z, cz(v))) }
-  /** Reflect this vector about a (unit) `normal`: `v - 2·(v·n)·n`. */
-  reflect(normal: Vec3Like): Vec3 {
-    const d = 2 * this.dot(normal)
-    return new Vec3(this.x - d * cx(normal), this.y - d * cy(normal), this.z - d * cz(normal))
-  }
-  /** Vector projection of this onto `onto`. */
-  project(onto: Vec3Like): Vec3 {
-    const ox = cx(onto), oy = cy(onto), oz = cz(onto)
-    const denom = ox * ox + oy * oy + oz * oz
-    if (denom === 0) return new Vec3(0, 0, 0)
-    const k = this.dot(onto) / denom
-    return new Vec3(ox * k, oy * k, oz * k)
-  }
-  /** Angle (radians) between this and `v`. */
-  angle(v: Vec3Like): number {
-    const bx = cx(v), by = cy(v), bz = cz(v)
-    const mag = Math.sqrt(this.lengthSq() * (bx * bx + by * by + bz * bz))
-    return mag === 0 ? 0 : Math.acos(clampN(this.dot(v) / mag, -1, 1))
-  }
-
-  // --- rotation ---
-  /** Rotate this point around the X axis through `origin` (default 0) by `rad`. */
-  rotateX(rad: number, origin: Vec3Like = ZERO3): Vec3 {
-    const ox = cx(origin), oy = cy(origin), oz = cz(origin)
-    const py = this.y - oy, pz = this.z - oz, c = Math.cos(rad), s = Math.sin(rad)
-    return new Vec3(this.x, oy + py * c - pz * s, oz + py * s + pz * c)
-  }
-  rotateY(rad: number, origin: Vec3Like = ZERO3): Vec3 {
-    const ox = cx(origin), oy = cy(origin), oz = cz(origin)
-    const px = this.x - ox, pz = this.z - oz, c = Math.cos(rad), s = Math.sin(rad)
-    return new Vec3(ox + pz * s + px * c, this.y, oz + pz * c - px * s)
-  }
-  rotateZ(rad: number, origin: Vec3Like = ZERO3): Vec3 {
-    const ox = cx(origin), oy = cy(origin), oz = cz(origin)
-    const px = this.x - ox, py = this.y - oy, c = Math.cos(rad), s = Math.sin(rad)
-    return new Vec3(ox + px * c - py * s, oy + px * s + py * c, this.z)
-  }
-  /** Rotate this vector by a quaternion (x, y, z, w). Accepts a `Quat` or a raw `[x,y,z,w]`. */
-  rotate(q: ArrayLike<number> | { x: number, y: number, z: number, w: number }): Vec3 {
-    const qx = cx(q as Vec3Like), qy = cy(q as Vec3Like), qz = cz(q as Vec3Like)
-    const qw = (q as { w?: number }).w ?? (q as ArrayLike<number>)[3]
-    const vx = this.x, vy = this.y, vz = this.z
-    // t = 2 * (q.xyz × v)
-    let tx = qy * vz - qz * vy, ty = qz * vx - qx * vz, tz = qx * vy - qy * vx
-    tx += tx; ty += ty; tz += tz
-    // v + w·t + q.xyz × t
-    return new Vec3(
-      vx + qw * tx + qy * tz - qz * ty,
-      vy + qw * ty + qz * tx - qx * tz,
-      vz + qw * tz + qx * ty - qy * tx,
-    )
-  }
-  /** Transform this point by a column-major mat4 (a `Mat4`, its `.m`, or a raw length-16 array),
-   *  applying translation and the perspective divide. */
-  transform(m: ArrayLike<number> | { m: ArrayLike<number> }): Vec3 {
-    const a = (m as { m?: ArrayLike<number> }).m ?? (m as ArrayLike<number>)
-    const x = this.x, y = this.y, z = this.z
-    let w = a[3] * x + a[7] * y + a[11] * z + a[15]
-    w = w || 1
-    return new Vec3(
-      (a[0] * x + a[4] * y + a[8] * z + a[12]) / w,
-      (a[1] * x + a[5] * y + a[9] * z + a[13]) / w,
-      (a[2] * x + a[6] * y + a[10] * z + a[14]) / w,
-    )
-  }
-
-  withX(x: number): Vec3 { return new Vec3(x, this.y, this.z) }
-  withY(y: number): Vec3 { return new Vec3(this.x, y, this.z) }
-  withZ(z: number): Vec3 { return new Vec3(this.x, this.y, z) }
-
-  // --- interop ---
-  equals(v: Vec3Like, eps = 1e-6): boolean {
-    return approx(this.x, cx(v), eps) && approx(this.y, cy(v), eps) && approx(this.z, cz(v), eps)
-  }
-  clone(): Vec3 { return new Vec3(this.x, this.y, this.z) }
-  toArray(): [number, number, number] { return [ this.x, this.y, this.z ] }
-  *[Symbol.iterator](): Iterator<number> { yield this.x; yield this.y; yield this.z }
-
-  static from(v: Vec3Like): Vec3 { return new Vec3(cx(v), cy(v), cz(v)) }
-  static get zero(): Vec3 { return new Vec3(0, 0, 0) }
-  static get one(): Vec3 { return new Vec3(1, 1, 1) }
-  static get up(): Vec3 { return new Vec3(0, 1, 0) }
-  static get down(): Vec3 { return new Vec3(0, -1, 0) }
-  static get left(): Vec3 { return new Vec3(-1, 0, 0) }
-  static get right(): Vec3 { return new Vec3(1, 0, 0) }
-  /** Forward is −Z (the engine's cameras look down −Z; `node.forward` is −Z at identity). */
-  static get forward(): Vec3 { return new Vec3(0, 0, -1) }
-  static get back(): Vec3 { return new Vec3(0, 0, 1) }
-}
-
-const clampN = (v: number, lo: number, hi: number): number => (v < lo ? lo : v > hi ? hi : v)
-const ZERO2 = new Vec2(0, 0)
-const ZERO3 = new Vec3(0, 0, 0)

package/runtime/sdk/plugins/camera.ts

@@ -1,81 +0,0 @@
-// CameraView — the device camera (live preview + still capture) as a Presentable. A typed wrapper
-// over the `NativeView("camera")` capability (docs/navigation-presentable-plan.md): open it
-// fullscreen (`await camera.open()`), push it (`Router.push(camera)`), or embed it among a
-// screen's children as a live preview node. `takePhoto()` returns a `File` (a host buffer
-// handle) — use it as a texture (`Texture2D.load(file)`), upload it (`FormData`), or `share` it.
-//
-// Host-OPTIONAL: it exists where the host registers a "camera" view (Android; web can via
-// `_creatorUI._registerView`) — gate on `CameraView.isSupported`. Opening prepares first (camera
-// permission) while the current destination stays visible — the same contract as ARScene/QRScanner.
-//
-// The pre-Presentable `_creatorUtils.camera*` bridges are gone from the ABI (2026-07-15): hosts
-// keep their implementations only to serve previously compiled bundles.
-
-import { File } from "../runtime/fetch"
-import { _navEpoch, type PresentOptions } from "../ui/presentable"
-import { NativeView, NativeViewElement } from "../ui/NativeView"
-import { _requestCameraPermission } from "./permission"
-
-export type CameraFacing = "front" | "back"
-
-export interface CameraView extends NativeView {
-  /** Request camera permission, then present the preview. The current destination stays visible
-   *  until the camera is ready; rejects if 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 back camera while the preview is live. */
-  setFacingMode(facingMode: CameraFacing): Promise<void>
-}
-
-class CameraViewElement extends NativeViewElement {
-  constructor(options: { facingMode?: CameraFacing } = {}) {
-    super("camera", { facingMode: options.facingMode ?? "back" })
-  }
-
-  /** @internal prepare-then-present: permission before the swap (see Presentable._prepare). */
-  async _prepare(): Promise<void> {
-    const epoch = _navEpoch()
-    await _requestCameraPermission()
-    if (_navEpoch() !== epoch) {
-      throw new Error("CameraView.open() superseded: another destination was opened while preparing")
-    }
-  }
-
-  override async open(options?: PresentOptions): Promise<void> {
-    // Fail before prompting for the camera — see QRScanner.
-    if (!NativeView.isSupported("camera")) {
-      throw new Error("CameraView isn't available on this host — it needs a registered \"camera\" view.")
-    }
-    await this._prepare()
-    super.open(options)
-  }
-
-  async takePhoto(): Promise<File> {
-    const photo = await this.call("takePhoto")
-    return new File(photo.systemId, photo.name, photo.size)
-  }
-
-  async setFacingMode(facingMode: CameraFacing): Promise<void> {
-    await this.call("setFacingMode", facingMode)
-  }
-}
-
-/**
- * Create a camera view (default: the back camera). `CameraView.isSupported` reports whether this
- * host has a camera capability — check it before offering the feature.
- */
-// PURE IIFE so an app that never uses the camera tree-shakes the whole plugin away (see NativeView).
-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 => NativeView.isSupported("camera"),
-  })
-  return factory as any
-})()

package/runtime/sdk/plugins/geolocation.ts

@@ -1,123 +0,0 @@
-// 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()`.
-//
-// 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.
-//
-// Service contract ("geolocation"): calls `getCurrent(options) → GeoPosition`,
-// `startWatch(options)` (resolves once watching), `stopWatch()`; event `position` → GeoPosition.
-
-import { ServiceClient } from "../runtime/service"
-
-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
-}
-
-/** A live `Geolocation.watch()` subscription — `stop()` it when the screen goes away. */
-export interface GeoWatch {
-  stop(): void
-}
-
-/**
- * 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).
-export const Geolocation: {
-  /** Whether this host registered a "geolocation" service. */
-  readonly isSupported: boolean
-  /** One position fix. Prompts for permission on first use; rejects on denial ("denied"), no
-   *  provider ("unavailable"), or `options.timeout` elapsing ("timeout"). */
-  getCurrent(options?: GeoOptions): Promise<GeoPosition>
-  /** Continuous updates. Resolves once watching (permission granted + provider started) — so a
-   *  denial is a rejection, never a silently dead callback. One host watch serves every
-   *  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")
-
-  // Watch state: one host watch fans out to N subscribers (SDK-side), 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")) {
-      throw new Error('Geolocation isn\'t available on this host — it needs a registered "geolocation" service.')
-    }
-  }
-
-  const removeWatcher = (callback: (position: GeoPosition) => void): void => {
-    const i = watchers.indexOf(callback)
-    if (i >= 0) watchers.splice(i, 1)
-    if (watchers.length === 0 && startPromise !== null) {
-      startPromise = null
-      service().call("stopWatch").catch(() => {})
-    }
-  }
-
-  const geolocation = {
-    async getCurrent(options?: GeoOptions): Promise<GeoPosition> {
-      assertSupported()
-      return await service().call("getCurrent", options ?? {})
-    },
-
-    async watch(callback: (position: GeoPosition) => void, options?: GeoOptions): Promise<GeoWatch> {
-      assertSupported()
-      if (!positionHooked) {
-        positionHooked = true
-        service().on("position", (position?: GeoPosition) => {
-          if (position) for (const cb of [...watchers]) cb(position)
-        })
-      }
-      watchers.push(callback)
-      startPromise ??= service().call("startWatch", options ?? {})
-      try {
-        await startPromise
-      } catch (e) {
-        // The watch never started — unwind without the stopWatch a live watch would need.
-        const i = watchers.indexOf(callback)
-        if (i >= 0) watchers.splice(i, 1)
-        if (watchers.length === 0) startPromise = null
-        throw e
-      }
-      let stopped = false
-      return {
-        stop(): void {
-          if (stopped) return
-          stopped = true
-          removeWatcher(callback)
-        },
-      }
-    },
-  }
-  Object.defineProperty(geolocation, "isSupported", {
-    get: (): boolean => ServiceClient.isSupported("geolocation"),
-  })
-  return geolocation as any
-})()

package/runtime/sdk/plugins/oauth.ts

@@ -1,61 +0,0 @@
-// OAuth — native provider sign-in as a typed service plugin (docs/backend-plan.md §3.4). The
-// browser broker (`auth.oauth.url()` on the server + `openURL` in the app) works everywhere; on
-// hosts that ship a provider SDK (Yandex LoginSDK, VK ID, Sign in with Apple, Google Sign-In) the
-// user shouldn't leave the app — the host registers an "oauth" service that runs the native sheet
-// and hands back the provider's CREDENTIAL. The app then calls its own endpoint, which does
-// `auth.oauth.signIn(provider, credential)`: the server verifies the credential with the provider
-// (audience = the platform's app ids) and binds the device session. No token is ever trusted
-// client-side; the credential is opaque to the app.
-//
-// Host-OPTIONAL — gate on `OAuth.isSupported(provider)`; fall back to the browser broker otherwise.
-//
-// Service contract ("oauth"): call `signIn(provider) → OAuthCredential` (rejects "cancelled" /
-// "unavailable"), call `providers() → string[]` (which providers this host has SDKs for).
-
-import { ServiceClient } from "../runtime/service"
-
-export type OAuthProviderName = "google" | "apple" | "yandex" | "vk"
-
-/** What a native provider SDK yields — pass it verbatim to your endpoint / `auth.oauth.signIn`. */
-export type OAuthCredential = {
-  provider: OAuthProviderName
-  /** OAuth access token (Yandex, VK ID). */
-  accessToken?: string
-  /** OpenID identity token (Google, Apple). */
-  idToken?: string
-  /** Apple only sends the name once, on the first sign-in — forward it so the server can store it. */
-  name?: string
-  email?: string
-}
-
-/**
- * Native provider sign-in. `OAuth.isSupported` reports whether this host registered the service;
- * `OAuth.providers()` which providers it has SDKs for. Otherwise open `auth.oauth.url(provider)` (server)
- * with `openURL` — the browser broker.
- */
-// PURE IIFE so an app that never uses it tree-shakes the plugin away (see Geolocation).
-export const OAuth: {
-  /** Whether this host registered an "oauth" service. */
-  readonly isSupported: boolean
-  /** The providers this host can sign in with natively. */
-  providers(): Promise<OAuthProviderName[]>
-  /** Run the provider's native sheet; resolves with the credential for `auth.oauth.signIn`. Rejects "cancelled" / "unavailable". */
-  signIn(provider: OAuthProviderName): Promise<OAuthCredential>
-} = /*#__PURE__*/ (() => {
-  let client: ServiceClient | null = null
-  const service = (): ServiceClient => client ??= new ServiceClient("oauth")
-  const assertSupported = (): void => {
-    if (!ServiceClient.isSupported("oauth")) {
-      throw new Error("OAuth isn't available on this host — it needs a registered \"oauth\" service; open auth.oauth.url(provider) in the browser instead.")
-    }
-  }
-  return {
-    get isSupported() { return ServiceClient.isSupported("oauth") },
-    providers: async () => { assertSupported(); const p = await service().call("providers"); return Array.isArray(p) ? p : [] },
-    signIn: async (provider) => {
-      assertSupported()
-      const r = await service().call("signIn", provider)
-      return { provider, ...(r ?? {}) }
-    },
-  }
-})()

package/runtime/sdk/plugins/permission.ts

@@ -1,7 +0,0 @@
-// Camera permission, host-gated: hosts expose it as `_creatorUtils.requestCamera`. Hosts without
-// that bridge resolve immediately — their view factory prompts on its own (e.g. getUserMedia on
-// the web). Shared by ARScene.prepare, QRScanner and CameraView.
-export const _requestCameraPermission = (): Promise<void> =>
-  typeof _creatorUtils.requestCamera === "function"
-    ? new Promise<void>((res, rej) => _creatorUtils.requestCamera!(res, rej))
-    : Promise.resolve()

package/runtime/sdk/plugins/push.ts

@@ -1,132 +0,0 @@
-// Push — remote notifications as a typed service plugin (docs/push-plan.md). A wrapper over
-// the host-registered "push" service, the Geolocation recipe applied to notifications: the
-// host owns the OS token, the permission prompt, and the platform registration with the
-// le.codes backend; the app only ever sees the opaque project-scoped ADDRESS (never the raw
-// APNs/FCM token) plus payloads.
-//
-// Host-OPTIONAL, like every plugin — gate on `Push.isSupported`. The OS permission prompt
-// happens inside `register()` (the first call that needs it, host-side); `getStatus()` and
-// `getLaunch()` never prompt. On hosts without the service every method rejects immediately,
-// BEFORE any permission path.
-//
-// The app is not running when a push arrives — display is host/OS work. The JS world sees
-// exactly three delivery paths:
-//   - event "message": arrived while this app was foregrounded (the host suppresses the banner)
-//   - event "tap":     tapped while the world was alive (warm)
-//   - getLaunch():     the notification that cold-started this world (stable pull, or null)
-// A payload's `url` additionally rides the app-lifecycle deep-link path (`app.launchUrl` /
-// the "url" event), so apps that already route links get notification routing for free.
-//
-// Service contract ("push"): calls `getStatus() → PushStatus`, `register({user?}) → {address}`
-// (rejects "denied"/"unavailable"), `unregister()`, `getLaunch() → PushPayload|null`;
-// events `message`/`tap` → PushPayload. An OPEN SESSION is the host's delivery pipe for the
-// events — addEventListener opens one eagerly (cheap by the channel contract: no prompt, no I/O).
-
-import { ServiceClient } from "../runtime/service"
-
-/** A delivered notification, as the app sees it. */
-export interface PushPayload {
-  title: string
-  body?: string
-  /** Deep link — also delivered through `app.launchUrl` / the app "url" event. */
-  url?: string
-  /** The developer's own JSON, ≤ 2 KB serialized. */
-  data?: Record<string, any>
-  badge?: number
-}
-
-export interface PushStatus {
-  /** OS notification permission for the host app. "prompt" = not asked yet. */
-  permission: "granted" | "denied" | "prompt"
-  /** Whether this device already holds a registration (an address) for this app. */
-  registered: boolean
-}
-
-export interface PushRegisterOptions {
-  /** Your app's OWN user id ("external user id"): lets your server send to `users: ["u42"]`
-   *  instead of storing addresses, fanning out to all the user's devices. CLIENT-ASSERTED and
-   *  unverified — never target sensitive content by user. The registration reflects the latest
-   *  `register()` call, so registering without `user` clears it (logout). */
-  user?: string
-}
-
-export type PushEvent = "message" | "tap"
-
-/**
- * Remote push notifications. `Push.isSupported` reports whether this host registered the
- * service — check it before offering notification features.
- */
-// PURE IIFE so an app that never uses push tree-shakes the whole plugin away (see Geolocation).
-export const Push: {
-  /** Whether this host registered a "push" service. */
-  readonly isSupported: boolean
-  /** Permission + registration state. Never prompts. */
-  getStatus(): Promise<PushStatus>
-  /** Ask for permission (first time) and register this device → the opaque address your server
-   *  targets. Idempotent — safe to call every launch; rejects "denied" / "unavailable". */
-  register(options?: PushRegisterOptions): Promise<{ address: string }>
-  /** Remove this device's registration (the address stops receiving). */
-  unregister(): Promise<void>
-  /** The notification that cold-started this app run, or null. Stable across calls. */
-  getLaunch(): Promise<PushPayload | null>
-  /** "message" = received while the app is open; "tap" = the user tapped one while it ran. */
-  addEventListener(event: PushEvent, callback: (payload: PushPayload) => void): void
-  removeEventListener(event: PushEvent, callback: (payload: PushPayload) => void): void
-} = /*#__PURE__*/ (() => {
-  let client: ServiceClient | null = null
-  const service = (): ServiceClient => client ??= new ServiceClient("push")
-
-  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/Geolocation).
-    if (!ServiceClient.isSupported("push")) {
-      throw new Error('Push isn\'t available on this host — it needs a registered "push" service.')
-    }
-  }
-
-  // ServiceClient.on only records listeners; events need a live session to arrive on. Poke the
-  // host with the prompt-free getStatus once so a listener-only app (already registered on a
-  // previous run) still hears warm taps.
-  let pipeOpened = false
-  const ensurePipe = (): void => {
-    if (pipeOpened || !ServiceClient.isSupported("push")) return
-    pipeOpened = true
-    service().call("getStatus").catch(() => { pipeOpened = false })
-  }
-
-  const push = {
-    async getStatus(): Promise<PushStatus> {
-      assertSupported()
-      return await service().call("getStatus")
-    },
-
-    async register(options?: PushRegisterOptions): Promise<{ address: string }> {
-      assertSupported()
-      return await service().call("register", options ?? {})
-    },
-
-    async unregister(): Promise<void> {
-      assertSupported()
-      await service().call("unregister")
-    },
-
-    async getLaunch(): Promise<PushPayload | null> {
-      assertSupported()
-      return (await service().call("getLaunch")) ?? null
-    },
-
-    addEventListener(event: PushEvent, callback: (payload: PushPayload) => void): void {
-      // Recording on an unsupported host is a silent no-op (the events just never fire),
-      // like app/device listeners — only the promise-returning methods reject loudly.
-      service().on(event, callback as (data?: any) => void)
-      ensurePipe()
-    },
-    removeEventListener(event: PushEvent, callback: (payload: PushPayload) => void): void {
-      service().off(event, callback as (data?: any) => void)
-    },
-  }
-  Object.defineProperty(push, "isSupported", {
-    get: (): boolean => ServiceClient.isSupported("push"),
-  })
-  return push as any
-})()