lecodes-cli 0.18.2 → 0.19.2

package/runtime/sdk/runtime/fetch.ts

@@ -1,77 +0,0 @@
-// HTTP via the host. `fetch` is async (host streams the body), `fetchLocal` reads a preloaded asset
-// synchronously. Ported from worker/src/fetch.ts over the same _creatorUtils bridge.
-
-export type FetchOptions = {
-  body?: any
-  method?: string
-  headers?: Record<string, string>
-  useOnce?: boolean
-  onProgress?: (progress: { loaded: number, total?: number }) => void
-}
-
-export interface FetchResponse {
-  readonly status: number
-  json<T = any>(): T
-  text(): string
-  dispose(): void
-}
-
-class FetchResponseImpl implements FetchResponse {
-  readonly status: number
-  private readonly _id: number
-  constructor(id: number, status: number) {
-    this._id = id
-    this.status = status
-  }
-  json<T = any>(): T {
-    return _creatorUtils.fetchToJson(this._id)
-  }
-  text(): string {
-    return _creatorUtils.fetchToText(this._id)
-  }
-  dispose(): void {
-    _creatorUtils.disposeFetch(this._id)
-  }
-}
-
-export const fetch = (url: string, options: FetchOptions = {}): Promise<FetchResponse> =>
-  new Promise<FetchResponse>((resolve, reject) => {
-    _creatorUtils.fetch(url, options, (systemId, statusCode) => {
-      resolve(new FetchResponseImpl(systemId, statusCode))
-    }, reject)
-  })
-
-export const fetchLocal = (path: string): FetchResponse =>
-  new FetchResponseImpl(_creatorUtils.fetchLocal(path), 200)
-
-/** A handle to a picked / fetched file (see openFilePicker). */
-export class File {
-  /** @internal host buffer handle. `_`-prefixed because hosts read it off the raw object —
-   *  same key `FetchResponse` carries, so both are accepted anywhere a buffer is expected
-   *  (FormData entries, `UIImage` src, `Texture.load`, `share`). */
-  readonly _id: number
-  readonly name: string
-  readonly size: number
-  constructor(systemId: number, name: string, size: number) {
-    this._id = systemId
-    this.name = name
-    this.size = size
-  }
-}
-
-type FormDataValue = string | number | boolean | File | FetchResponse
-
-export class FormData {
-  // Host-facing: hosts walk `_entries` and treat any object value carrying `_id` as binary
-  // (the buffer id), everything else as a text field. See viewer-lite utils/fetch.ts,
-  // creator-pkg creatorUtilsHandler.cpp, iOS Fetch.swift buildMultipartBody.
-  private _entries: [string, FormDataValue, filename?: string][] = []
-
-  append(name: string, value: FormDataValue, filename?: string): void {
-    this._entries.push([ name, value, filename ?? (typeof value === "object" ? (value as any).name : undefined) ])
-  }
-  delete(name: string): void {
-    const index = this._entries.findIndex((i) => i[0] === name)
-    if (index >= 0) this._entries.splice(index, 1)
-  }
-}

package/runtime/sdk/runtime/files.ts

@@ -1,23 +0,0 @@
-// Native file picker. Ported from worker/src/utils/openFilePicker.ts; resolves to File handle(s)
-// (see runtime/fetch.ts) that can be appended to a FormData and uploaded.
-
-import { File } from "./fetch"
-
-type OpenFilePickerOptions = { accept?: string }
-
-export function openFilePicker(options?: OpenFilePickerOptions & { multiple?: false }): Promise<File | null>
-export function openFilePicker(options: OpenFilePickerOptions & { multiple: true }): Promise<File[]>
-export function openFilePicker(
-  options: OpenFilePickerOptions & { multiple?: boolean } = {},
-): Promise<File | File[] | null> {
-  return new Promise((resolve, reject) => {
-    _creatorUtils.openFilePicker((resp) => {
-      if (!resp || resp.length === 0) {
-        resolve(options.multiple ? [] : null)
-        return
-      }
-      if (options.multiple) resolve(resp.map((i: any) => new File(i[0], i[1], i[2])))
-      else resolve(new File(resp[0][0], resp[0][1], resp[0][2]))
-    }, reject, !!options.multiple, options.accept)
-  })
-}

package/runtime/sdk/runtime/input.ts

@@ -1,175 +0,0 @@
-// Keyboard / mouse / gamepad input behind one `Input` global (docs/input-plan.md).
-//
-// Two kinds of signal, two shapes of API:
-//   - BUTTONS — anything that goes down and up: keyboard keys, mouse buttons, gamepad buttons. One
-//     code vocabulary ('KeyW', 'MouseLeft', 'GamepadSouth'), one held-poll (`Input.key`) and one
-//     event pair (`Input.on('keydown' | 'keyup')`). A mouse button IS a key.
-//   - CONTINUOUS — mouse motion/wheel, sticks, triggers: polled every frame (`Input.mouse.delta`,
-//     `Input.gamepad(0).axis('leftX')`), never events.
-// Bindings ("jump = Space | GamepadSouth") are app code: compare `e.code`, OR a few `Input.key`s.
-// Hosts report physical state only (`_creatorUtils.inputKey/inputRead/registerInputEvent`).
-
-/** Continuous channel ids — the `_creatorUtils.inputRead` contract (bridges.d.ts). */
-export const InputChannel = {
-  MouseX: 0, MouseY: 1, MouseDX: 2, MouseDY: 3, WheelX: 4, WheelY: 5, PointerLocked: 6,
-  GamepadCount: 7,
-  GamepadBase: 16, GamepadStride: 16,
-  PadConnected: 0, PadLeftX: 1, PadLeftY: 2, PadRightX: 3, PadRightY: 4, PadLeftTrigger: 5, PadRightTrigger: 6,
-} as const
-
-export type InputEventName = "keydown" | "keyup" | "gamepadconnected" | "gamepaddisconnected"
-
-/** `keydown` / `keyup` payload. `code` is the same string `Input.key()` takes. */
-export interface InputKeyEvent {
-  readonly type: "keydown" | "keyup"
-  /** Button code: KeyboardEvent.code ('KeyW', 'Space'), 'MouseLeft|Right|Middle|Back|Forward', or
-   *  'GamepadSouth|East|West|North|L1|R1|L2|R2|Select|Start|L3|R3|Up|Down|Left|Right'. */
-  readonly code: string
-  /** Which device: 'keyboard' | 'mouse' | 'gamepad'. */
-  readonly source: "keyboard" | "mouse" | "gamepad"
-  /** Pad index (0..3) for gamepad buttons, undefined otherwise. */
-  readonly gamepad?: number
-  /** OS auto-repeat keydown (key still held) — ignore for one-shot actions. */
-  readonly repeat: boolean
-}
-
-export interface InputGamepadEvent {
-  readonly type: "gamepadconnected" | "gamepaddisconnected"
-  readonly gamepad: number
-}
-
-type Listener<E> = (e: E) => void
-type InputEventMap = {
-  keydown: InputKeyEvent
-  keyup: InputKeyEvent
-  gamepadconnected: InputGamepadEvent
-  gamepaddisconnected: InputGamepadEvent
-}
-
-const listeners: { [K in InputEventName]?: Listener<InputEventMap[K]>[] } = {}
-let hostListenerInstalled = false
-
-const sourceOf = (code: string): InputKeyEvent["source"] =>
-  code.startsWith("Mouse") ? "mouse" : code.startsWith("Gamepad") ? "gamepad" : "keyboard"
-
-const emit = <K extends InputEventName>(name: K, e: InputEventMap[K]) => {
-  const list = listeners[name]
-  if (!list || list.length === 0) return
-  for (const fn of [...list]) fn(e as any)
-}
-
-// One fan-out for the host channel and the test/host `_emit` seam.
-const deliver = (kind: number, code: string, gamepad: number, repeat: number) => {
-  if (kind === 0 || kind === 1) {
-    const src = sourceOf(code)
-    emit(kind === 0 ? "keydown" : "keyup", {
-      type: kind === 0 ? "keydown" : "keyup", code, source: src,
-      gamepad: src === "gamepad" && gamepad >= 0 ? gamepad : undefined, repeat: repeat !== 0,
-    })
-  } else if (kind === 2 || kind === 3) {
-    emit(kind === 2 ? "gamepadconnected" : "gamepaddisconnected",
-         { type: kind === 2 ? "gamepadconnected" : "gamepaddisconnected", gamepad })
-  }
-}
-
-// Lazily claim the host's single listener slot (never at module scope — chisel drops top-level
-// side effects, and a host without the channel simply never fires).
-const ensureHostListener = () => {
-  if (hostListenerInstalled) return
-  hostListenerInstalled = true
-  _creatorUtils.registerInputEvent?.(deliver)
-}
-
-const read = (channel: number): number => _creatorUtils.inputRead?.(channel) ?? 0
-
-/** Mouse state — polled. Position is the cursor inside the viewport in logical px; `delta` is the
- *  motion during the previous frame (raw where the OS offers it) and keeps counting while locked —
- *  that's FPS look. Hosts without a mouse report zeros. */
-export const mouse = {
-  get position(): { x: number, y: number } { return { x: read(InputChannel.MouseX), y: read(InputChannel.MouseY) } },
-  get delta(): { x: number, y: number } { return { x: read(InputChannel.MouseDX), y: read(InputChannel.MouseDY) } },
-  /** Wheel notches during the previous frame (+y = wheel toward you / scroll down). */
-  get wheel(): { x: number, y: number } { return { x: read(InputChannel.WheelX), y: read(InputChannel.WheelY) } },
-  /** Pointer lock: cursor hidden + confined, `delta` keeps flowing. Web grants it only from a user
-   *  gesture (call it in a 'keydown' handler for MouseLeft); hosts drop it on focus loss and
-   *  re-acquire on focus. Escape does NOT unlock by itself on native hosts — call `unlock()`. */
-  get locked(): boolean { return read(InputChannel.PointerLocked) !== 0 },
-  lock(): boolean { return _creatorUtils.inputSetPointerLock?.(true) ?? false },
-  unlock(): void { _creatorUtils.inputSetPointerLock?.(false) },
-}
-
-export type GamepadAxisName = "leftX" | "leftY" | "rightX" | "rightY" | "leftTrigger" | "rightTrigger"
-const PAD_AXIS: Record<GamepadAxisName, number> = {
-  leftX: InputChannel.PadLeftX, leftY: InputChannel.PadLeftY, rightX: InputChannel.PadRightX,
-  rightY: InputChannel.PadRightY, leftTrigger: InputChannel.PadLeftTrigger, rightTrigger: InputChannel.PadRightTrigger,
-}
-
-export interface GamepadState {
-  readonly index: number
-  readonly connected: boolean
-  /** Stick axes −1..1 (+Y = down, like the web Gamepad API), triggers 0..1. `deadzone` (default
-   *  0.15) zeroes small stick drift — pass 0 for the raw value. */
-  axis(name: GamepadAxisName, deadzone?: number): number
-  /** Held? Same as `Input.key(code, index)`. */
-  button(code: string): boolean
-}
-
-const padCache: GamepadState[] = []
-const gamepadAt = (index: number): GamepadState => {
-  let g = padCache[index]
-  if (!g) {
-    const base = InputChannel.GamepadBase + InputChannel.GamepadStride * index
-    g = padCache[index] = {
-      index,
-      get connected() { return read(base + InputChannel.PadConnected) !== 0 },
-      axis(name, deadzone = 0.15) {
-        const v = read(base + PAD_AXIS[name])
-        return deadzone > 0 && Math.abs(v) < deadzone ? 0 : v
-      },
-      button(code) { return _creatorUtils.inputKey(code, index) },
-    }
-  }
-  return g
-}
-
-export const Input = {
-  /**
-   * Is a button held? `code` is the physical key (`KeyboardEvent.code`: 'ArrowRight', 'KeyW',
-   * 'Space'), a mouse button ('MouseLeft', 'MouseRight', 'MouseMiddle') or a gamepad button
-   * ('GamepadSouth' = A/Cross, 'GamepadR2' = right trigger as a button …). Poll inside setLoop for
-   * frame-independent movement. `gamepad` scopes a Gamepad* code to one pad; omitted = any pad.
-   */
-  key(code: string, gamepad?: number): boolean {
-    return _creatorUtils.inputKey(code, gamepad)
-  },
-
-  /** Listen for a discrete input moment. `keydown`/`keyup` cover EVERY button — keyboard, mouse,
-   *  gamepad — filter on `e.code`. Use these for one-shot actions (jump, shoot, charge-release);
-   *  `Input.key` for continuous ones (walk). */
-  on<K extends InputEventName>(name: K, listener: Listener<InputEventMap[K]>): void {
-    ensureHostListener()
-    const list = (listeners[name] ??= []) as Listener<InputEventMap[K]>[]
-    if (!list.includes(listener)) list.push(listener)
-  },
-  off<K extends InputEventName>(name: K, listener: Listener<InputEventMap[K]>): void {
-    const list = listeners[name] as Listener<InputEventMap[K]>[] | undefined
-    if (!list) return
-    const i = list.indexOf(listener)
-    if (i >= 0) list.splice(i, 1)
-  },
-
-  mouse,
-
-  /** Gamepad `index` (0..3). Always returns an object — check `.connected`. */
-  gamepad(index = 0): GamepadState { return gamepadAt(index) },
-  /** Indices of the currently connected gamepads. */
-  gamepads(): number[] {
-    const out: number[] = []
-    const n = read(InputChannel.GamepadCount)
-    for (let i = 0; i < 4 && out.length < n; i++) if (gamepadAt(i).connected) out.push(i)
-    return out
-  },
-
-  /** @internal — hosts/tests: deliver an event exactly as the host listener would. */
-  _emit(kind: number, code: string, gamepad: number, repeat: number): void { deliver(kind, code, gamepad, repeat) },
-}

package/runtime/sdk/runtime/media.ts

@@ -1,111 +0,0 @@
-// Audio / video playback over the host. Ported from worker/src/MediaPlayer.ts, with the listener
-// boilerplate folded into the shared Emitter. VideoPlayer.texture (a 3D Texture) is wired in Phase 4
-// when the Texture type exists — see gl/.
-//
-// The host no longer routes end-of-playback events back by id through a Registry: each player hands
-// the host a `_finished` callback at creation time. The host holds the JS closure directly — valid
-// on every backend (web JS, Android quickjs, iOS JavaScriptCore) — and invokes it when a play-through
-// completes, so there is no id table to keep in sync.
-
-import { Emitter } from "../core/events"
-import { Texture } from "../gl/Texture"
-
-type MediaEvents = {
-  /** Fired at each loop boundary while `loop` is true. */
-  loopReached: () => void
-  /** Fired once when playback reaches the end while `loop` is false. */
-  completed: () => void
-}
-
-abstract class MediaPlayer extends Emitter<MediaEvents> {
-  protected _id = -1
-  protected _src = ""
-  private _playing = false
-  private _loop = false
-  private _volume = 1
-  private _disposed = false
-
-  // Every host-touching operation runs through this so a disposed player can never address a freed
-  // (and possibly reused) host slot.
-  private _assertAlive(): void {
-    if (this._disposed) throw new Error("MediaPlayer has been disposed")
-  }
-
-  play(): void { this.playing = true }
-  pause(): void { this.playing = false }
-
-  get playing(): boolean { return this._playing }
-  set playing(value: boolean) {
-    this._assertAlive()
-    this._playing = value
-    _creatorUtils.updateMediaPlayerPlaying(this._id, value)
-  }
-
-  get volume(): number { return this._volume }
-  set volume(value: number) {
-    this._assertAlive()
-    this._volume = value
-    _creatorUtils.updateMediaPlayerVolume(this._id, value)
-  }
-
-  get loop(): boolean { return this._loop }
-  set loop(value: boolean) {
-    this._assertAlive()
-    this._loop = value
-    _creatorUtils.updateMediaPlayerLoop(this._id, value)
-  }
-
-  /** Current playback position, in seconds. Settable to seek. */
-  get time(): number { this._assertAlive(); return _creatorUtils.getMediaPlayerTime(this._id) }
-  set time(value: number) { this._assertAlive(); _creatorUtils.setMediaPlayerTime(this._id, value) }
-
-  /** Total media length in seconds (0 until metadata has loaded). */
-  get duration(): number { this._assertAlive(); return _creatorUtils.getMediaPlayerDuration(this._id) }
-
-  /** True once {@link dispose} has been called; the player is unusable afterwards. */
-  get disposed(): boolean { return this._disposed }
-
-  /**
-   * Release the underlying host media resource (decoder, network, buffers) immediately and detach
-   * all listeners. Idempotent. Any further use of the player throws.
-   */
-  dispose(): void {
-    if (this._disposed) return
-    this._disposed = true
-    this._playing = false
-    this.clearListeners()
-    _creatorUtils.removeMediaPlayer(this._id)
-  }
-
-  /** @internal — the host calls this when a play-through finishes. */
-  protected _finished(): void {
-    if (this._disposed) return
-    if (this._loop) {
-      this.dispatch("loopReached")
-    } else {
-      this._playing = false
-      this.dispatch("completed")
-    }
-  }
-}
-
-export class AudioPlayer extends MediaPlayer {
-  constructor(src?: string) {
-    super()
-    this._src = src ?? ""
-    this._id = _creatorUtils.createAudioPlayer(this._src, () => this._finished())
-  }
-}
-
-export class VideoPlayer extends MediaPlayer {
-  constructor(src?: string) {
-    super()
-    this._src = src ?? ""
-    this._id = _creatorUtils.createVideoPlayer(this._src, () => this._finished())
-  }
-
-  /** A 3D Texture that samples this video (e.g. for a Material.video()). */
-  get texture(): Texture {
-    return new Texture(0, 0, _creator.createMediaPlayerTexture(this._id))
-  }
-}

package/runtime/sdk/runtime/misc.ts

@@ -1,16 +0,0 @@
-// Small platform globals that are real (not engine-specific). Grown in Phase 1.
-
-/** Show a transient toast notification. */
-export const toast = (msg: string): void => _creatorUI.toast(msg)
-
-/** Open `url` in the system browser / external handler (fire-and-forget, like `share`). Silent
- *  no-op on hosts without one (headless). */
-export const openURL = (url: string): void => _creatorUtils.openUrl?.(url)
-
-export type SvgSourceValue = {
-  readonly svg: string
-  tintColor: string | null
-}
-
-/** Wrap raw SVG XML so it can be used as an image source. */
-export const SvgSource = (svg: string): SvgSourceValue => ({ svg, tintColor: null })

package/runtime/sdk/runtime/net.ts

@@ -1,36 +0,0 @@
-// WebSocket over the host bridge. Same event surface as the browser's (open/message/close/error)
-// via the shared Emitter. Ported from worker/src/WebSocket.ts.
-
-import { Emitter } from "../core/events"
-
-type SocketEvents = {
-  open: () => void
-  message: (data: any) => void
-  close: (code?: number) => void
-  error: () => void
-}
-
-export class WebSocket extends Emitter<SocketEvents> {
-  private _id: number | null = null
-
-  constructor(url: string, headers?: Record<string, string>) {
-    super()
-    this._id = _creatorUtils.websocketOpen(url, (channel, data) => this._onMessage(channel, data), headers)
-  }
-
-  send(message: string | ArrayBuffer): void {
-    if (this._id !== null) _creatorUtils.websocketSend(this._id, message)
-  }
-
-  close(): void {
-    if (this._id !== null) {
-      _creatorUtils.websocketClose(this._id)
-      this._id = null
-    }
-  }
-
-  private _onMessage(channel: string, data: any): void {
-    if (data !== undefined && data !== null) this.dispatch(channel as keyof SocketEvents, data)
-    else this.dispatch(channel as keyof SocketEvents)
-  }
-}

package/runtime/sdk/runtime/rpc.ts

@@ -1,218 +0,0 @@
-/**
- * Client transport for the app backend (docs/backend-plan.md §3.2 / §3.3). The compiler replaces
- * every `*.server.ts` module in the client bundle with a stub whose exports are built by the three
- * globals below — user code never calls them; it imports the server function and calls it.
- *
- *   export const listNotes = __rpc("<serverUrl>", "notes.server.ts#listNotes")
- *   export const chat      = __channel("<serverUrl>", "chat.server.ts#chat")
- *   export const db        = __serverOnly("schema.server.ts#db")
- *
- * Wire (implemented by the runner):
- *   POST <serverUrl>/api/<id>   body {"args":[…]}, `authorization: Bearer <session>` when known
- *   → 200 {"ok":true,"result":…,"session"?:"…"} | {"ok":false,"status":n,"message":"…","session"?:"…"}
- *   WS   <serverUrl>/ws  frames: → {t:"hello",session} {t:"sub",id,ch,topic} {t:"unsub",id}
- *                                ← {t:"session",session} {t:"ok",id} {t:"err",id,status,message} {t:"ev",ch,topic,event,data}
- *   (`ev` is addressed by channel + topic, not by subscription id, so the server can fan one publish out
- *   to every socket of a topic natively; the client delivers it to each matching subscription.)
- *
- * The session token is transport-owned (cookie-like): stored under `lecodes.session:<serverUrl>` in
- * localStorage, sent on every call and on the socket, replaced whenever a response carries `session`.
- * User code never sees it — "am I logged in" is an endpoint (`me()`), see the plan.
- */
-
-import { fetch } from "./fetch"
-import { localStorage } from "./storage"
-import { WebSocket } from "./net"
-
-/** Rejection value of a failed endpoint call: `status` mirrors the server's `ApiError`
- *  (0 = the request itself failed: no network / no server). */
-export class RpcError extends Error {
-  readonly status: number
-  constructor(status: number, message: string) {
-    super(message)
-    this.name = "RpcError"
-    this.status = status
-  }
-}
-
-// ───────────────────────────── session token ─────────────────────────────
-
-const sessionKey = (serverUrl: string) => `lecodes.session:${serverUrl}`
-const getSession = (serverUrl: string): string | null => {
-  try { return localStorage.getItem(sessionKey(serverUrl)) } catch { return null }
-}
-const setSession = (serverUrl: string, token: string | null) => {
-  try {
-    if (token) localStorage.setItem(sessionKey(serverUrl), token)
-    else localStorage.removeItem(sessionKey(serverUrl))
-  } catch { /* storage-less host: the session lives for this run only */ }
-  sockets.get(serverUrl)?.onSessionChanged(token)
-}
-
-// ───────────────────────────── endpoints ─────────────────────────────
-
-const noServer = (id: string) => new RpcError(0, `Endpoint ${id}: the project has no deployed server (compile with serverUrl)`)
-
-/** Build the client proxy of endpoint `id`. Positional args travel as a JSON array. */
-export const __rpc = (serverUrl: string, id: string) => {
-  const call = async (...args: unknown[]): Promise<any> => {
-    if (!serverUrl) throw noServer(id)
-    const headers: Record<string, string> = { "content-type": "application/json" }
-    const session = getSession(serverUrl)
-    if (session) headers.authorization = `Bearer ${session}`
-    let res
-    try {
-      res = await fetch(`${serverUrl}/api/${encodeURIComponent(id)}`, { method: "POST", headers, body: JSON.stringify({ args }) })
-    } catch (e) {
-      throw new RpcError(0, `Endpoint ${id}: request failed (${(e as Error)?.message ?? e})`)
-    }
-    let body: any
-    try { body = res.json() } catch { body = null }
-    res.dispose()
-    if (body && typeof body === "object" && "session" in body) setSession(serverUrl, body.session ?? null)
-    if (body && body.ok === true) return body.result
-    if (body && body.ok === false) throw new RpcError(body.status ?? res.status, body.message ?? "")
-    throw new RpcError(res.status, `Endpoint ${id}: unexpected response (HTTP ${res.status})`)
-  }
-  return call
-}
-
-/** A server-only export (db, models, helpers) referenced from client code: any use throws. */
-export const __serverOnly = (id: string): any =>
-  new Proxy(function () {} as any, {
-    get: (_t, prop) => { if (prop === "then") return undefined; throw new RpcError(0, `${id} is server-only — it can't be used in client code`) },
-    apply: () => { throw new RpcError(0, `${id} is server-only — it can't be used in client code`) },
-  })
-
-// ───────────────────────────── channels ─────────────────────────────
-
-type Handlers = Record<string, ((payload: any) => void) | undefined> & {
-  /** The socket dropped and came back: subscriptions were re-sent, but events in between are lost — refetch. */
-  reconnect?: () => void
-  /** The subscription was refused (`onJoin` threw) or the socket can't connect. */
-  error?: (e: RpcError) => void
-}
-type Sub = { id: number, ch: string, topic: string, handlers: Handlers, ready: boolean }
-
-const BACKOFF_MS = [1000, 2000, 5000, 10000, 30000]
-
-/** One multiplexed socket per server URL, shared by every channel of the app. */
-class ChannelSocket {
-  private ws: WebSocket | null = null
-  private open = false
-  private subs = new Map<number, Sub>()
-  private nextId = 1
-  private attempts = 0
-  private timer: ReturnType<typeof setTimeout> | null = null
-  private closedByUs = false
-  private everOpened = false
-  private serverUrl: string
-
-  constructor(serverUrl: string) { this.serverUrl = serverUrl }
-
-  subscribe(ch: string, topic: string, handlers: Handlers): { close(): void } {
-    const sub: Sub = { id: this.nextId++, ch, topic, handlers, ready: false }
-    this.subs.set(sub.id, sub)
-    if (this.open) this.send({ t: "sub", id: sub.id, ch, topic })
-    else this.connect()
-    return {
-      close: () => {
-        if (!this.subs.delete(sub.id)) return
-        if (this.open) this.send({ t: "unsub", id: sub.id })
-        if (this.subs.size === 0) this.shutdown()
-      },
-    }
-  }
-
-  onSessionChanged(token: string | null) {
-    if (this.open) this.send({ t: "hello", session: token })
-  }
-
-  private connect() {
-    if (this.ws || this.timer !== null) return
-    this.closedByUs = false
-    const url = this.serverUrl.replace(/^http/, "ws") + "/ws"
-    const session = getSession(this.serverUrl)
-    const ws = new WebSocket(url, session ? { authorization: `Bearer ${session}` } : undefined)
-    this.ws = ws
-    ws.addEventListener("open", () => {
-      this.open = true
-      this.attempts = 0
-      this.send({ t: "hello", session: getSession(this.serverUrl) })
-      const reconnected = this.everOpened
-      this.everOpened = true
-      for (const sub of this.subs.values()) {
-        sub.ready = false
-        this.send({ t: "sub", id: sub.id, ch: sub.ch, topic: sub.topic })
-        if (reconnected) sub.handlers.reconnect?.()
-      }
-    })
-    ws.addEventListener("message", (data) => {
-      if (typeof data !== "string") return
-      let msg: any
-      try { msg = JSON.parse(data) } catch { return }
-      this.onFrame(msg)
-    })
-    const onDown = () => {
-      if (this.ws !== ws) return
-      this.ws = null
-      this.open = false
-      if (this.closedByUs || this.subs.size === 0) return
-      const delay = BACKOFF_MS[Math.min(this.attempts++, BACKOFF_MS.length - 1)]
-      this.timer = setTimeout(() => { this.timer = null; this.connect() }, delay)
-    }
-    ws.addEventListener("close", onDown)
-    ws.addEventListener("error", onDown)
-  }
-
-  private onFrame(msg: any) {
-    switch (msg?.t) {
-      case "session": setSession(this.serverUrl, msg.session ?? null); break
-      case "ok": { const s = this.subs.get(msg.id); if (s) s.ready = true; break }
-      case "err": {
-        const s = this.subs.get(msg.id)
-        if (!s) break
-        this.subs.delete(msg.id)
-        s.handlers.error?.(new RpcError(msg.status ?? 0, msg.message ?? "subscription refused"))
-        break
-      }
-      case "ev": {
-        for (const s of this.subs.values()) {
-          if (s.ch === msg.ch && s.topic === msg.topic) s.handlers[msg.event]?.(msg.data)
-        }
-        break
-      }
-    }
-  }
-
-  private send(frame: unknown) { this.ws?.send(JSON.stringify(frame)) }
-
-  private shutdown() {
-    this.closedByUs = true
-    if (this.timer !== null) { clearTimeout(this.timer); this.timer = null }
-    this.ws?.close()
-    this.ws = null
-    this.open = false
-    sockets.delete(this.serverUrl)
-  }
-}
-
-const sockets = new Map<string, ChannelSocket>()
-const socketFor = (serverUrl: string) => {
-  let s = sockets.get(serverUrl)
-  if (!s) { s = new ChannelSocket(serverUrl); sockets.set(serverUrl, s) }
-  return s
-}
-
-export interface ClientChannel<E extends Record<string, unknown> = Record<string, unknown>> {
-  /** Subscribe to `topic`; handlers are keyed by event name (+ `reconnect`/`error`). Returns `{ close }`. */
-  subscribe(topic: string, handlers: { [K in keyof E]?: (payload: E[K]) => void } & { reconnect?: () => void, error?: (e: RpcError) => void }): { close(): void }
-}
-
-/** Build the client proxy of channel `id`. */
-export const __channel = (serverUrl: string, id: string): ClientChannel<any> => ({
-  subscribe(topic, handlers) {
-    if (!serverUrl) throw noServer(id)
-    return socketFor(serverUrl).subscribe(id, topic, handlers as Handlers)
-  },
-})