lecodes-sdk 1.1.0 → 2.0.0

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

@@ -0,0 +1,105 @@
+// GENERATED by scripts/vendor-plugins.ts from lecodes-plugins/plugins/push/sdk/push.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.
+// Push — remote notifications. The host owns the OS token, the permission prompt and the
+// registration with the le.codes relay; the app only ever sees the opaque project-scoped ADDRESS
+// (never the raw APNs / FCM token) plus payloads.
+//
+// Hand-written over the generated wire because the public API is a module singleton with
+// `addEventListener`, and a listener must OPEN the session: events arrive on a live one only.
+//
+// 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.
+//
+// The OS permission prompt happens inside `register()`; `getStatus()` and `getLaunch()` never
+// prompt. On a host without the service every method rejects at once, BEFORE any permission path.
+
+import { NAME, PushBase } from "./push.gen"
+import type { PushEvents, PushPayload, PushRegisterOptions, PushRegistration, PushStatus } from "../contract"
+
+export type { PushPayload, PushRegisterOptions, PushStatus }
+
+export type PushEvent = keyof PushEvents
+
+/**
+ * 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.
+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<PushRegistration>
+  /** 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: PushBase | null = null
+  const service = (): PushBase => client ??= new PushBase()
+
+  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.
+    if (!PushBase.supports(NAME)) {
+      throw new Error('Push isn\'t available on this host — it needs a registered "push" service.')
+    }
+  }
+
+  // `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 || !PushBase.supports(NAME)) return
+    pipeOpened = true
+    service().getStatus().catch(() => { pipeOpened = false })
+  }
+
+  const push = {
+    async getStatus(): Promise<PushStatus> {
+      assertSupported()
+      return await service().getStatus()
+    },
+
+    async register(options?: PushRegisterOptions): Promise<PushRegistration> {
+      assertSupported()
+      return await service().register(options ?? {})
+    },
+
+    async unregister(): Promise<void> {
+      assertSupported()
+      await service().unregister()
+    },
+
+    async getLaunch(): Promise<PushPayload | null> {
+      assertSupported()
+      return (await service().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)
+      ensurePipe()
+    },
+    removeEventListener(event: PushEvent, callback: (payload: PushPayload) => void): void {
+      service().off(event, callback)
+    },
+  }
+  Object.defineProperty(push, "isSupported", {
+    get: (): boolean => PushBase.supports(NAME),
+  })
+  return push as any
+})()

package/src/plugins/gen/qr-scanner/contract.d.ts

@@ -0,0 +1,16 @@
+// GENERATED by scripts/vendor-plugins.ts from lecodes-plugins/plugins/qr-scanner/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.
+// qr-scanner — a camera view that decodes QR codes.
+// A view with events only: the app opens / embeds it and listens.
+
+import type { View } from "../../../plugin"
+
+export interface QRScannerParams {}
+
+export interface QRScannerEvents {
+  /** One per decoded camera frame: the payload, or null for a frame with no readable code (it
+   *  repeats while the user aims). The same code may be reported more than once. */
+  scan: { data: string | null }
+}
+
+export interface QRScanner extends View<"qrScanner", QRScannerParams, QRScannerEvents> {}

package/src/plugins/gen/qr-scanner/sdk/qr-scanner.gen.ts

@@ -0,0 +1,29 @@
+// GENERATED by scripts/vendor-plugins.ts from lecodes-plugins/plugins/qr-scanner/sdk/qr-scanner.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.
+// qr-scanner: the view "qrScanner", contract version 1.
+
+import { ViewChannel } from "../../../../plugin"
+import type { QRScannerEvents, QRScannerParams } from "../contract"
+
+/** What the halves register under. */
+export const NAME = "qrScanner"
+/** The contract's version: the highest `@since` of its members. */
+export const VERSION = 1
+
+// ---- what the host's half has --------------------------------------------------------------------
+
+/** A method of the contract. */
+export type Method = never
+
+/** Whether this host has the view "qrScanner" — 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 "qrScanner" with the wire's methods as its own. */
+export class QRScannerBase extends ViewChannel<QRScannerEvents> {
+  constructor(params: QRScannerParams = {}) { super("QRScanner", NAME, params) }
+}

package/src/plugins/gen/qr-scanner/sdk/qr-scanner.ts

@@ -0,0 +1,52 @@
+// GENERATED by scripts/vendor-plugins.ts from lecodes-plugins/plugins/qr-scanner/sdk/qr-scanner.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.
+// QRScanner — the host's camera QR scanner as a view the app opens fullscreen
+// (`await scanner.open()`), pushes (`Router.push(scanner)`) or embeds as a live preview.
+//
+// Hand-written over the generated wire for two things: `onScan` hands over the decoded string, not
+// the event's payload, and the permission is asked BEFORE the view is presented.
+
+import { prepareCamera, type NativeView, type PresentOptions } from "../../../../plugin"
+import { NAME, QRScannerBase } from "./qr-scanner.gen"
+
+export interface QRScanner extends NativeView {
+  /** Fires per decoded camera frame: the decoded string, or `null` for a frame with no readable
+   *  code (expect those repeatedly while the user aims). The same code can be reported more than
+   *  once — `close()` or debounce once you have what you need. */
+  onScan(callback: (data: string | null) => void): this
+  /** Request the camera permission, then present the scanner. The current destination (and its
+   *  loading state) stays visible until the scanner is ready; rejects if the camera is denied,
+   *  the host can't scan, or another navigation superseded this one. */
+  open(options?: PresentOptions): Promise<void>
+}
+
+class QRScannerElement extends QRScannerBase {
+  onScan(callback: (data: string | null) => void): this {
+    return this.on("scan", payload => callback(payload?.data ?? null))
+  }
+
+  /** @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 QR scanner view. `QRScanner.isSupported` reports whether this host can scan at all —
+ * check it before offering the feature.
+ */
+// PURE IIFE so an app that never scans tree-shakes the whole plugin away.
+export const QRScanner: {
+  (): QRScanner
+  /** Whether this host registered a "qrScanner" view. */
+  readonly isSupported: boolean
+} = /*#__PURE__*/ (() => {
+  const factory = (): QRScanner => new QRScannerElement() as unknown as QRScanner
+  Object.defineProperty(factory, "isSupported", {
+    get: (): boolean => QRScannerBase.supports(NAME),
+  })
+  return factory as any
+})()

package/src/plugins/permission.ts

@@ -1,7 +1,8 @@
-// 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
+// Camera permission, host-gated: hosts expose it as `_creatorDevice.requestCamera`. Hosts without
+// that slot 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))
+  typeof _creatorDevice.requestCamera === "function"
+    ? new Promise<void>((res, rej) => _creatorDevice.requestCamera!(res, rej))
     : Promise.resolve()

package/src/runtime/app.ts

@@ -2,7 +2,9 @@
 // "pause"/"resume", never Activity/Scene vocabulary — and the current values are synchronous pulls
 // so render-loop code can read them without subscribing.
 
+import { setAppBackHandler } from "../ui/tree"
 import { appEventsOn, appEventsOff, keyboardEventsOn, keyboardEventsOff } from "./appEvents"
+import { SDK_VERSION } from "../version"
 
 export type AppState = "active" | "background"
 
@@ -26,15 +28,19 @@ type AppEventMap = {
 }
 
 export const app = {
+  /** The SDK this app was compiled with (semver, e.g. `"2.0.0"`). Its major is the bundle ↔ runtime
+   *  contract: a host runs only bundles of its own major, and the launchers send it as `?sdk=` when
+   *  they fetch a published bundle — the platform keeps one bundle per major. */
+  sdkVersion: SDK_VERSION,
   /** Current lifecycle state. `"background"` while the app is not the foreground app / the tab is
    *  hidden. `"active"` on hosts that don't track it. */
   get state(): AppState {
-    return _creatorUtils.appState?.() === "background" ? "background" : "active"
+    return _creatorApp.state?.() === "background" ? "background" : "active"
   },
   /** The URL the app was (most recently) opened with — the deep link — or `null` for a plain
    *  launch. Warm links update it and fire the `"url"` event. */
   get launchUrl(): string | null {
-    return _creatorUtils.getLaunchUrl?.() ?? null
+    return _creatorApp.launchUrl?.() ?? null
   },
   /** On-screen keyboard height in logical px currently overlapping the app viewport, `0` when
    *  hidden. This is the RAW overlap, independent of the focused input's `keyboardShrink` policy —
@@ -42,7 +48,7 @@ export const app = {
    *  mode (`keyboardShrink: false`), e.g. a chat composer's `pb`. `0` on hosts without an
    *  on-screen keyboard. */
   get keyboardHeight(): number {
-    return _creatorUtils.keyboardHeight?.() ?? 0
+    return (typeof _creatorInput !== "undefined" ? _creatorInput.keyboardHeight?.() : undefined) ?? 0
   },
   /** Lock the screen orientation — `"landscape"` for a horizontal game (the device rotates to
    *  landscape right away and stays there whichever way it is held), `"portrait"` for upright
@@ -51,29 +57,29 @@ export const app = {
    *  ordinary resize — layouts reflow, a scene's viewport follows. Silent no-op on hosts
    *  without a rotatable screen (desktop, headless, web). */
   setOrientation(mode: OrientationLock): void {
-    _creatorUtils.setOrientation?.(mode)
+    _creatorApp.setOrientation?.(mode)
   },
   /** Re-run this app's bundle in a fresh world — the platform's `location.reload()`. Pass `url`
    *  to reboot with different launch arguments (the new run reads them via `app.launchUrl`),
    *  `null` to reboot with a cleared one, or omit it to replay the current one. No-op on hosts
    *  without world control (headless). */
   restart(url?: string | null): void {
-    _creatorUtils.restart?.(url)
+    _creatorApp.restart?.(url)
   },
   /** Leave this app. Inside the LeCodes viewer that returns to the launcher (the LeCodes home
    *  screen); a standalone-built app leaves to the platform instead — Android backgrounds it,
    *  iOS ignores the call (the platform forbids programmatic exit). */
   quit(): void {
-    _creatorUtils.quit?.()
+    _creatorApp.quit?.()
   },
   /** Global back-press fallback (Android back button/gesture — iOS has no system back). Fires
    *  only when nothing else consumed the press: no open widget/modal claimed it, the current
-   *  screen has no `onBackPressed`, every pager is at its tab root and the router is at its
+   *  screen has no `onBack`, every pager is at its tab root and the router is at its
    *  stack root. The place for app-wide policy — e.g. double-press-to-quit:
    *
    *  ```ts
    *  let armedAt = 0
-   *  app.onBackPressed(() => {
+   *  app.onBack(() => {
    *    if (Date.now() - armedAt < 2000) { app.quit(); return }
    *    armedAt = Date.now()
    *    toast("Press back again to exit")
@@ -81,8 +87,13 @@ export const app = {
    *  ```
    *
    *  Replaces the previous handler; pass `null` to remove. */
+  onBack(callback: (() => void) | null): void {
+    setAppBackHandler(callback ?? null)
+  },
+  /** @deprecated Renamed `onBack` (2026-09-26). An alias for the projects compiled before the
+   *  rename; removed with the release that recompiles them. */
   onBackPressed(callback: (() => void) | null): void {
-    _creatorUI._backButtonCallback = callback ?? undefined
+    setAppBackHandler(callback ?? null)
   },
   addEventListener<E extends keyof AppEventMap>(event: E, callback: AppEventMap[E]): void {
     if (event === "keyboard") {

package/src/runtime/appEvents.ts

@@ -1,8 +1,9 @@
-// The shared app-event dispatcher. The host exposes ONE registerAppEvent slot per JS world
+// The shared app-event dispatcher. The host exposes ONE `_creatorApp.registerEvent` slot per JS world
 // (docs/app-lifecycle-plan.md), so every SDK consumer (the `app` global's pause/resume/url, the
 // `device` global's online/offline) subscribes here and this module registers with the host once,
 // lazily on the first subscription — no top-level side effect, tree-shaking drops it when unused.
 
+
 type AppEventCallback = (data?: string) => void
 
 const listeners: Record<string, AppEventCallback[]> = {}
@@ -17,7 +18,7 @@ export const appEventsOn = (event: string, cb: AppEventCallback): void => {
   ;(listeners[event] ??= []).push(cb)
   if (!registered) {
     registered = true
-    _creatorUtils.registerAppEvent?.(dispatch)
+    _creatorApp.registerEvent?.(dispatch)
   }
 }
 
@@ -28,7 +29,7 @@ export const appEventsOff = (event: string, cb: AppEventCallback): void => {
   if (i >= 0) arr.splice(i, 1)
 }
 
-// The keyboard channel is a separate host slot (registerKeyboardEvent) — the registerAppEvent
+// The keyboard channel is a separate host slot (`_creatorInput.registerKeyboardEvent`) — the app-event
 // string channel can't carry the (height, duration) number pair. Same lazy single-slot pattern.
 
 type KeyboardCallback = (height: number, duration: number) => void
@@ -44,7 +45,7 @@ export const keyboardEventsOn = (cb: KeyboardCallback): void => {
   keyboardListeners.push(cb)
   if (!keyboardRegistered) {
     keyboardRegistered = true
-    _creatorUtils.registerKeyboardEvent?.(dispatchKeyboard)
+    if (typeof _creatorInput !== "undefined") _creatorInput.registerKeyboardEvent?.(dispatchKeyboard)
   }
 }
 

package/src/runtime/channel.ts

@@ -1,9 +1,11 @@
-// The JSON wire protocol shared by the two host plugin channels — NativeView
-// (`_creatorUI.viewCall`, see ui/NativeView.ts) and headless services
-// (`_creatorUtils.serviceCall`, see runtime/service.ts). One protocol, two transports:
-// `args`, results, and event payloads travel as JSON strings, and an absent/empty string
-// decodes to `undefined`. Typed plugins (QRScanner, CameraView, Geolocation) layer methods
-// over this — see src/plugins/.
+// The wire protocol shared by the two host plugin channels — NativeView
+// (`_creatorTree.viewCall`, see ui/NativeView.ts) and headless services
+// (`_creatorService.call`, see runtime/service.ts). One protocol, two transports: `args`, results
+// and event payloads travel as VALUES (`value` of bridges/types.d.ts — plain data and Uint8Array;
+// the runtime reads them once, the host gets its platform's own), and what a host leaves out
+// arrives as `undefined`. Only a view's / a service's PARAMS are JSON text: they are part of the
+// tree (a node's property, a destination). Typed plugins (QRScanner, CameraView, Geolocation)
+// layer methods over this — see src/plugins/.
 
 /** @internal event-name → listeners. NativeView exposes it as `nvl` (host contract). */
 export type ChannelListeners = Record<string, ((data?: any) => void)[]>
@@ -21,20 +23,21 @@ export const _channelOff = (listeners: ChannelListeners, event: string, callback
   if (i >= 0) list.splice(i, 1)
 }
 
-/** @internal deliver a host event: decode the JSON payload, fan out (copy-before-iterate). */
-export const _channelEmit = (listeners: ChannelListeners, event: string, dataJson?: string): void => {
+/** @internal deliver a host event: fan out (copy-before-iterate). */
+export const _channelEmit = (listeners: ChannelListeners, event: string, data?: unknown): void => {
   const list = listeners[event]
   if (!list || list.length === 0) return
-  const data = dataJson === undefined || dataJson === "" ? undefined : JSON.parse(dataJson)
   for (const cb of [...list]) cb(data)
 }
 
 type ChannelCallBridge = (
-  id: number, method: string, args: string,
-  onComplete: (result?: string) => void, onError: (err: string) => void,
+  id: number, method: string, args: unknown[],
+  onComplete: (result?: unknown) => void, onError: (err: string) => void,
 ) => void
 
-/** @internal one JSON call over a channel bridge.
+/** @internal one call over a channel bridge. An argument that cannot cross (a cycle, a typed array
+ *  that is not bytes) makes the bridge THROW: the promise rejects with it, the host never sees
+ *  the call.
  *
  *  Takes the HANDLER OBJECT plus the member name — never a plucked-off function reference. On
  *  Apple hosts the bridge members are JSExport-ed Objective-C/Swift methods, and JavaScriptCore
@@ -55,7 +58,7 @@ export const _channelCall = (
       rej(new Error(unsupportedError))
       return
     }
-    bridge.call(owner, id, method, JSON.stringify(args),
-      (result?: string) => res(result === undefined || result === "" ? undefined : JSON.parse(result)),
-      (err: string) => rej(new Error(err)))
+    // A host rejects with its message — as a string, or as the Error the runtime made of it (the
+    // Android host): the message is the same either way, never "Error: <message>".
+    bridge.call(owner, id, method, args, res, (err: unknown) => rej(typeof err === "string" ? new Error(err) : err))
   })

package/src/runtime/clipboard.ts

@@ -1,20 +1,21 @@
 // System clipboard (docs/app-lifecycle-plan.md). Write is fire-and-forget; read is async because
 // web gates it behind a permission prompt (native hosts complete synchronously).
 
+
 export const clipboard = {
   /** Put `text` on the system clipboard. Silent no-op on hosts without clipboard access. */
   write(text: string): void {
-    _creatorUtils.clipboardWrite?.(text)
+    _creatorDevice.clipboardWrite?.(text)
   },
   /** Read text from the system clipboard. Rejects when the platform has no clipboard access, the
    *  user denied it, or there is nothing readable. */
   read(): Promise<string> {
     return new Promise((resolve, reject) => {
-      if (typeof _creatorUtils.clipboardRead !== "function") {
+      if (typeof _creatorDevice.clipboardRead !== "function") {
         reject(new Error("Clipboard is not supported on this platform"))
         return
       }
-      _creatorUtils.clipboardRead(resolve, (err: string) => reject(new Error(err)))
+      _creatorDevice.clipboardRead(resolve, (err: string) => reject(new Error(err)))
     })
   },
 }

package/src/runtime/datetime.ts

@@ -15,6 +15,7 @@
 // Even before that pass lands, each method is a class method, so chisel's method-granular DCE drops
 // whichever ones a project doesn't use.
 
+
 export type Locale = "en" | "ru"
 export type DateInput = Date | number | string | DateValue
 export type Unit = "ms" | "second" | "minute" | "hour" | "day" | "week" | "month" | "year"
@@ -58,7 +59,7 @@ const DATA: Record<Locale, LocaleData> = { en: EN, ru: RU }
 
 const resolveLocale = (locale?: Locale): Locale => {
   if (locale) return locale === "ru" ? "ru" : "en"
-  const lang = typeof _creatorUtils !== "undefined" ? _creatorUtils.language : ""
+  const lang = typeof _creatorDevice !== "undefined" ? _creatorDevice.language : ""
   return lang && lang.toLowerCase().indexOf("ru") === 0 ? "ru" : "en"
 }
 

package/src/runtime/device.ts

@@ -1,6 +1,7 @@
 // Platform info + the host resize event. The resize listener registers with the host lazily on the
 // first subscription (no top-level side effect, so tree-shaking can drop this entirely if unused).
 
+import { ensureEmitter, onTreeResize } from "../ui/tree"
 import { Quat } from "../math/quat"
 import { Vec3 } from "../math/vec"
 import { appEventsOn, appEventsOff } from "./appEvents"
@@ -94,10 +95,10 @@ export const device = {
    *  mouse-look instead of on-screen sticks. It is not the OS name: a Mac reports `"desktop"`,
    *  like Windows and Linux do (the OS/version detail is host-side, not here). */
   get platform(): "web" | "android" | "ios" | "desktop" | string {
-    return _creatorUtils.platform
+    return _creatorDevice.platform
   },
   get language(): string {
-    return _creatorUtils.language
+    return _creatorDevice.language
   },
   /** Display device-pixel ratio (physical px per logical/CSS px): 1 on standard displays, 2–3 on
    *  retina / iOS. Bake a Canvas at this ratio for crisp output without hardcoding, e.g.
@@ -105,17 +106,17 @@ export const device = {
    *  renders at logical resolution, so on web this only helps UI canvases / is forward-looking for
    *  2D; on iOS (physical surface) it makes 2D canvases crisp. Falls back to 1 if the host omits it. */
   get pixelRatio(): number {
-    return _creatorUtils.pixelRatio || 1
+    return _creatorDevice.pixelRatio || 1
   },
   /** Current display width in logical px — the same value the "resize" event delivers, but readable at
    *  any time (not only inside the listener). 0 until the host has reported a size. */
   get width(): number {
-    return _creatorUI.getDisplaySize?.()?.[0] ?? 0
+    return _creatorTree.getDisplaySize()[0] ?? 0
   },
   /** Current display height in logical px — the same value the "resize" event delivers, readable at any
    *  time. 0 until the host has reported a size. */
   get height(): number {
-    return _creatorUI.getDisplaySize?.()?.[1] ?? 0
+    return _creatorTree.getDisplaySize()[1] ?? 0
   },
   /** Opt into the precise-touch system where the platform supports it. OFF by default. When on, fast
    *  strokes are sampled at the touch digitizer's full rate (iOS coalesced touches, ≈120–240 Hz) instead
@@ -123,14 +124,14 @@ export const device = {
    *  points and smoother lines. Leave it off for tap/button UIs. No-op on hosts without a coalesced-input
    *  concept (web already coalesces pointermove; headless). */
   setPreciseTouch(enabled: boolean): void {
-    _creatorUtils.setPreciseTouch?.(enabled)
+    _creatorDevice.setPreciseTouch?.(enabled)
   },
   /** Fire a one-shot haptic of the given semantic `style` (default `"medium"`) — a physical tap on
    *  supported hardware (iOS Taptic Engine, Android vibrator). Chosen by meaning, not duration, so it
    *  feels native on each platform; see {@link HapticStyle}. Host-gated: a silent no-op where there's
    *  no haptic hardware (iPad, older iPhones, web, headless). */
   vibrate(style: HapticStyle = "medium"): void {
-    _creatorUtils.vibrate?.(style)
+    _creatorDevice.vibrate?.(style)
   },
   /** Device-orientation sensor (gyro + accelerometer, fused) for tilt/steering and magic-window /
    *  360° panoramas. Poll `attitude` / `gravity` inside setLoop; they return the freshest fused
@@ -138,7 +139,7 @@ export const device = {
   motion: {
     /** Whether this device has the motion sensors at all (no gyro → false; iPad/older, web, headless). */
     get available(): boolean {
-      return _creatorUtils.motionAvailable?.() ?? false
+      return _creatorDevice.motionAvailable?.() ?? false
     },
     /** Whether updates are currently running (start succeeded and stop hasn't been called). */
     get enabled(): boolean {
@@ -148,18 +149,18 @@ export const device = {
      *  Async so a web host can await its permission prompt; native resolves immediately. */
     async start(options: MotionOptions = {}): Promise<boolean> {
       motionFrame = options.frame ?? "world"
-      motionEnabled = !!(await (_creatorUtils.motionStart?.(options.interval ?? 1 / 60) ?? false))
+      motionEnabled = !!(await (_creatorDevice.motionStart?.(options.interval ?? 1 / 60) ?? false))
       return motionEnabled
     },
     /** Stop sensor updates and release the sensor (battery). */
     stop(): void {
-      _creatorUtils.motionStop?.()
+      _creatorDevice.motionStop?.()
       motionEnabled = false
     },
     /** Capture the current heading as "forward" — a yaw-only recenter (pitch/roll stay gravity-
      *  referenced, so the horizon stays level). No-op in the "device" frame. */
     recenter(): void {
-      const s = _creatorUtils.getMotionSample?.()
+      const s = _creatorDevice.motionSample?.()
       if (!s || motionFrame === "device") { motionYawOffset = 0; return }
       const f = orientedAttitude(s).rotateVec3([0, 0, -1])   // world-space camera forward
       motionYawOffset = Math.atan2(-f.x, -f.z)               // heading about world up
@@ -168,7 +169,7 @@ export const device = {
      *  and screen-oriented, so `camera.quaternion = device.motion.attitude` is a complete magic-window
      *  / panorama camera. `Quat.identity` until the first sample arrives / when not running. */
     get attitude(): Quat {
-      const s = _creatorUtils.getMotionSample?.()
+      const s = _creatorDevice.motionSample?.()
       if (!s) return Quat.identity
       if (motionFrame === "device") return new Quat(s[0], s[1], s[2], s[3])
       const q = orientedAttitude(s)
@@ -178,7 +179,7 @@ export const device = {
      *  down, matching clientX/clientY), orientation-aware — a 2D game reads `gravity.x / gravity.y`.
      *  `(0,0,0)` when not running. */
     get gravity(): Vec3 {
-      const s = _creatorUtils.getMotionSample?.()
+      const s = _creatorDevice.motionSample?.()
       if (!s) return new Vec3(0, 0, 0)
       if (motionFrame === "device") return new Vec3(s[4], s[5], s[6])
       // Re-express the raw device-frame gravity in screen space: undo the interface roll (about the
@@ -250,7 +251,7 @@ export const device = {
    *  is sure there's no network. `true` on hosts that don't track it. Change events: `"online"` /
    *  `"offline"`. */
   get online(): boolean {
-    return _creatorUtils.isOnline?.() ?? true
+    return _creatorApp.isOnline?.() ?? true
   },
   addEventListener<E extends keyof DeviceEventMap>(channel: E, callback: DeviceEventMap[E]): void {
     if (channel === "online" || channel === "offline") {
@@ -269,7 +270,8 @@ export const device = {
     resizeListeners.push(callback as ResizeCallback)
     if (!resizeRegistered) {
       resizeRegistered = true
-      _creatorUI.registerResizeEvent(onResize)
+      ensureEmitter()
+      onTreeResize(onResize)
     }
   },
   removeEventListener<E extends keyof DeviceEventMap>(channel: E, callback: DeviceEventMap[E]): void {