lecodes-sdk 1.1.0 → 2.0.0

package/dist/types/runtime/app.d.ts

@@ -17,6 +17,10 @@ type AppEventMap = {
     keyboard: (height: number, duration: number) => void;
 };
 export declare 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: string;
     /** Current lifecycle state. `"background"` while the app is not the foreground app / the tab is
      *  hidden. `"active"` on hosts that don't track it. */
     readonly state: AppState;
@@ -47,12 +51,12 @@ export declare const app: {
     quit(): void;
     /** 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")
@@ -60,6 +64,9 @@ export declare const app: {
      *  ```
      *
      *  Replaces the previous handler; pass `null` to remove. */
+    onBack(callback: (() => void) | null): void;
+    /** @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;
     addEventListener<E extends keyof AppEventMap>(event: E, callback: AppEventMap[E]): void;
     removeEventListener<E extends keyof AppEventMap>(event: E, callback: AppEventMap[E]): void;

package/dist/types/runtime/fetch.d.ts

@@ -12,6 +12,8 @@ export interface FetchResponse {
     readonly status: number;
     json<T = any>(): T;
     text(): string;
+    /** @deprecated A no-op: the body is freed with the response's handle (owned handles). Apps written
+     *  against the pre-owned SDK still call it after `text()` / `json()`; remove the call. */
     dispose(): void;
 }
 export declare const fetch: (url: string, options?: FetchOptions) => Promise<FetchResponse>;

package/dist/types/runtime/input.d.ts

@@ -1,4 +1,4 @@
-/** Continuous channel ids — the `_creatorUtils.inputRead` contract (bridges.d.ts). */
+/** Continuous channel ids — the `_creatorInput.read` contract (sdk/src/bridges/input.d.ts). */
 export declare const InputChannel: {
     readonly MouseX: 0;
     readonly MouseY: 1;
@@ -82,6 +82,13 @@ export interface GamepadState {
     axis(name: GamepadAxisName, deadzone?: number): number;
     /** Held? Same as `Input.key(code, index)`. */
     button(code: string): boolean;
+    /** Rumble: `strong` = the heavy low-frequency motor, `weak` = the light high-frequency one, both
+     *  0..1, for `durationMs` (default 200, hosts cap at 5000). A new call replaces the running
+     *  effect. The host stops the motors by itself — after the duration, on focus loss and when the
+     *  project is swapped — so there is nothing to clean up. False when the pad or host has no motors. */
+    rumble(strong: number, weak?: number, durationMs?: number): boolean;
+    /** Stop the running rumble now. */
+    stopRumble(): void;
 }
 export declare const Input: {
     /**

package/dist/types/runtime/media.d.ts

@@ -7,15 +7,14 @@ type MediaEvents = {
     completed: () => void;
 };
 declare abstract class MediaPlayer extends Emitter<MediaEvents> {
-    protected _id: number;
     protected _src: string;
     private _playing;
     private _loop;
     private _volume;
-    private _disposed;
-    private _assertAlive;
     play(): void;
     pause(): void;
+    /** Pause and rewind to the start. */
+    stop(): void;
     get playing(): boolean;
     set playing(value: boolean);
     get volume(): number;
@@ -27,12 +26,9 @@ declare abstract class MediaPlayer extends Emitter<MediaEvents> {
     set time(value: number);
     /** Total media length in seconds (0 until metadata has loaded). */
     get duration(): number;
-    /** True once {@link dispose} has been called; the player is unusable afterwards. */
-    get disposed(): boolean;
-    /**
-     * Release the underlying host media resource (decoder, network, buffers) immediately and detach
-     * all listeners. Idempotent. Any further use of the player throws.
-     */
+    /** @deprecated There is nothing to dispose — a player the app stops referencing is released by
+     *  the runtime (a playing one at its end). Kept as `stop()` so old code still silences the player;
+     *  call `stop()` / `pause()` instead. */
     dispose(): void;
 }
 export declare class AudioPlayer extends MediaPlayer {
@@ -40,7 +36,7 @@ export declare class AudioPlayer extends MediaPlayer {
 }
 export declare class VideoPlayer extends MediaPlayer {
     constructor(src?: string);
-    /** A 3D Texture that samples this video (e.g. for a Material.video()). */
+    /** A 3D Texture that samples this video (e.g. for a Material.video()). Owned by the player. */
     get texture(): Texture;
 }
 export {};

package/dist/types/runtime/misc.d.ts

@@ -1,3 +1,4 @@
+import type { ColorInput } from "../core/color";
 /** Show a transient toast notification. */
 export declare const toast: (msg: string) => void;
 /** Open `url` in the system browser / external handler (fire-and-forget, like `share`). Silent
@@ -5,7 +6,9 @@ export declare const toast: (msg: string) => void;
 export declare const openURL: (url: string) => void;
 export type SvgSourceValue = {
     readonly svg: string;
-    tintColor: string | null;
+    /** The source-level tint (a mask recolor under the `tintColor` style, which wins): any color, or
+     *  a theme `var(--…)`. */
+    tintColor: ColorInput | null;
 };
 /** Wrap raw SVG XML so it can be used as an image source. */
 export declare const SvgSource: (svg: string) => SvgSourceValue;

package/dist/types/runtime/net.d.ts

@@ -7,8 +7,9 @@ type SocketEvents = {
 };
 export declare class WebSocket extends Emitter<SocketEvents> {
     private _id;
-    constructor(url: string, headers?: Record<string, string>);
-    send(message: string | ArrayBuffer): void;
+    constructor(url: string);
+    /** Send a text frame. */
+    send(message: string): void;
     close(): void;
     private _onMessage;
 }

package/dist/types/runtime/touch.d.ts

@@ -54,3 +54,35 @@ export declare class LongPressEvent<T = any> {
     /** Capture subsequent moves/end for this pointer — drag the element after the hold. */
     track(handler: TrackHandler): void;
 }
+/** What a hover `track()` takes: the cursor's moves inside the element (only delivered when
+ *  `onMove` is present — otherwise the host never crosses into JS for them), `onEnd` when it
+ *  leaves (with the last position), `onCancel` when the element went away underneath it. No
+ *  `claim`: a hover competes with nothing. */
+export interface HoverTrackHandler {
+    onMove?(pos: {
+        clientX: number;
+        clientY: number;
+        deltaX: number;
+        deltaY: number;
+    }): void;
+    onEnd?(pos: {
+        clientX: number;
+        clientY: number;
+        deltaX: number;
+        deltaY: number;
+    }): void;
+    onCancel?(): void;
+}
+/** Delivered to a `UIButton` `onMouseEnter` handler when a mouse cursor (no button) enters the
+ *  button. There is no separate leave event: `ev.track({ onEnd })` follows this hover to its end,
+ *  `onMove` follows the cursor inside — the visual state itself is the reserved `$hovered` class.
+ *  Touch never produces one. */
+export declare class MouseEnterEvent<T = any> {
+    readonly type = "mouseenter";
+    readonly clientX: number;
+    readonly clientY: number;
+    target: T;
+    constructor(clientX: number, clientY: number);
+    /** Follow this hover: moves inside the element, its end (the cursor left), its cancel. */
+    track(handler: HoverTrackHandler): void;
+}

package/dist/types/scene/defineScene.d.ts

@@ -1,4 +1,3 @@
-import { type With } from "../core/Aspect";
 import { use, ref, make, type AspectEntry, type MakeEntry as SharedMakeEntry } from "./grammar";
 import type { Vec3Like } from "../math/vec";
 import { Scene, type SceneOptions } from "../gl/Scene";
@@ -11,6 +10,7 @@ import { type TerrainLayer, type TerrainRegion, type TerrainOptions } from "../g
 import { Light, type SunOptions } from "../gl/Light";
 import { type MaterialDef } from "./material";
 import type { CapsuleOptions, CylinderOptions, PlaneOptions, SphereOptions } from "../gl/Geometry";
+import { GizmoBuffer } from "./gizmos";
 export type MeshDef = {
     kind: "box";
     size?: Vec3Like | number;
@@ -152,7 +152,7 @@ export type SceneCameraDef = CameraProjectionDef & {
     /** Point the camera looks at. */
     target?: Vec3Like;
 };
-/** `env.lightmap` — the level's baked lighting (packages/creator-bake): the files `lecodes lightmap bake`
+/** `env.lightmap` — the level's baked lighting (engines/bake): the files `lecodes lightmap bake`
  *  writes. Absent = real-time only. */
 export type SceneLightmapDef = {
     /** `asset('./assets/lightmap/level.bake')` */
@@ -274,6 +274,8 @@ export type ModelPartRow = {
  *  not parts, skipped. Filtering BEFORE segment math keeps `name[i]` indices stable no matter
  *  what defs are parented in. */
 export declare const modelPartRows: (root: Node) => ModelPartRow[];
+/** Where a def node attaches: its `mount` part when it resolves, else the parent itself. */
+export declare const attachHost: (parent: Node, def: SceneNodeDef, path: string) => Node;
 /** The static verdict for one node def (the editor's "Baked lighting" switch shows the same rule).
  *  Children of a mover are movers too — buildNodes carries that down, this is the node's own verdict. */
 export declare const isLightmapStatic: (def: SceneNodeDef) => boolean;
@@ -283,6 +285,45 @@ export declare const applyEditorPose: (node: Node, pose: {
     clip?: string;
     time?: number;
 } | undefined) => void;
+/** Edit mode: otherwise-invisible nodes (empties, `camera:` nodes) get an ANCHORED gizmo marker —
+ *  an axis cross / a frustum in the node's local frame (scene/gizmos.ts) — so they show and pick
+ *  in the viewport. Never scene content: nothing renders in Filament, nothing outlines, and the
+ *  engine follows the node live, so the buffer is filled once and lives on the node
+ *  (`_editorMarker`) — `sceneEditor.gizmos()` reads it off the handle's own def nodes, so a removed
+ *  node's marker goes with its record and prefab / instance internals (not selectable) draw none. */
+export declare const addEditorMarker: (node: Node, def: SceneNodeDef) => void;
+/** fov / near / far from a camera block onto the live camera. The build path leaves an empty block
+ *  alone (a host may run with its own configured fov); `reset` — the editor's live patch — fills
+ *  omitted keys with the defaults instead, so clearing a field in the inspector takes effect. */
+export declare const applyCameraProjection: (scene: Scene, def: CameraProjectionDef, reset?: boolean) => void;
+export declare const foreignRuns: Map<Node, EditorRun[]>;
+/** One live editor-run aspect instance (edit mode only). */
+export type EditorRun = {
+    /** Absolute path of the host def node (re-keyed on rename/reparent). */
+    hostPath: string;
+    node: Node;
+    /** Index within the def's `aspects` array — the doc's aspect index addresses it. */
+    index: number;
+    inst: {
+        rebuild?(): void | Promise<void>;
+    };
+    /** Async rebuild() supersession counter (see safeRebuild). */
+    generation: number;
+    /** Mutable props snapshot — `sceneEditor.setProp` updates it and re-derives `deps`. Holds the
+     *  DOC-LITERAL `$ref` strings (never resolved paths): the inspector's doc-sync compares these
+     *  against the file's props, so rewriting them would re-fire on every render. */
+    props: Record<string, unknown>;
+    /** ABSOLUTE paths the ref() props resolved to — a change to any of them (or anything inside
+     *  their subtrees) re-runs rebuild(). Re-derived after every structural change. */
+    deps: Set<string>;
+    /** Editor lines drawn by the last rebuild() (`Gizmos.*` calls — see scene/gizmos.ts). */
+    gizmos: GizmoBuffer;
+};
+/** Re-assign every ref-carrying prop from the CURRENT nodes map — a live patch replaces node
+ *  instances, so a generator's resolved fields would otherwise point at destroyed nodes. */
+export declare const assignRefProps: (run: EditorRun, nodes: Record<string, Node>) => void;
+/** EditorRun.index for a node's make() run (aspect runs use their array index, always >= 0). */
+export declare const MAKE_INDEX = -1;
 export declare class SceneHandle<D extends SceneDef = SceneDef> {
     readonly def: D;
     private _loading?;

package/dist/types/scene/editor.d.ts

@@ -0,0 +1,52 @@
+import { type AspectClassInfo } from "../core/fields";
+import { InspectorUI, type InspectorEvent, type InspectorWidget } from "../core/InspectorUI";
+import type { Material } from "../gl/Material";
+import type { Node } from "../gl/Node";
+import { type ModelPartRow, type SceneHandle, type SceneNodeDef } from "./defineScene";
+import { GizmoBuffer, type GizmoBatch } from "./gizmos";
+type Handle = SceneHandle<any>;
+export declare const sceneEditor: {
+    patchNode: (handle: Handle, path: string, def: SceneNodeDef | null) => Promise<Node | null>;
+    renameNode: (handle: Handle, path: string, newName: string) => string | null;
+    reparentNode: (handle: Handle, path: string, newParentPath: string | null) => string | null;
+    nodeChanged: (handle: Handle, path: string) => void;
+    modelParts: (handle: Handle, path: string) => Promise<ModelPartRow[]>;
+    describeAspects: (handle: Handle) => AspectClassInfo[];
+    setProp: (handle: Handle, hostPath: string, index: number, key: string, value: unknown) => boolean;
+    setMakeArg: (handle: Handle, hostPath: string, key: string, value: unknown) => boolean;
+    gizmos: (handle: Handle) => {
+        version: number;
+        batches: GizmoBatch[];
+    };
+    inspectorRender: (handle: Handle, hostPath: string, index: number, props: Record<string, unknown>, event?: InspectorEvent) => InspectorWidget[] | null;
+    /** The preview pose of a model node (`editor: { clip, time }`) — idempotent; no clip = the rest pose. */
+    applyPose: (node: Node, pose: {
+        clip?: string;
+        time?: number;
+    } | undefined) => void;
+    isLocked: (node: Node) => boolean;
+    setLocked: (node: Node, locked: boolean) => void;
+    /** Assign a material def to one slot of a node (a material asset handle, an inline def, a shader). */
+    assignMaterial: (node: Node, slot: number, def: import("./material").MaterialDef) => Promise<Material>;
+    /** One parameter into a live material: a value, or a texture URL that loads in. */
+    setMaterialParam: (material: Material, name: string, value: import("./material").MaterialParamValue | null) => Promise<void>;
+    isBuiltinMaterial: (material: Material) => boolean;
+    forgetMaterial: (node: Node, slot: number) => void;
+    GizmoBuffer: typeof GizmoBuffer;
+    withGizmoScope: <T>(buffer: GizmoBuffer, fn: () => T) => T;
+    runCard: (ui: InspectorUI, render: (ui: InspectorUI) => void, event?: InspectorEvent) => InspectorWidget[];
+    /** The registry `registerEditorWindow` / `registerEditorTool` fill (`*.editor.ts` files). */
+    plugins: {
+        windows: {
+            title: string;
+            render: import("./editorPlugins").EditorWindowFn;
+        }[];
+        tools: {
+            name: string;
+            hooks: import("./editorPlugins").EditorToolHooks;
+        }[];
+    };
+};
+/** The contract of an editor's in-world half with the SDK — the type of the `__sceneEditor` global. */
+export type SceneEditorApi = typeof sceneEditor;
+export {};

package/dist/types/scene/gizmos.d.ts

@@ -1,3 +1,4 @@
+import { type ColorInput } from "../core/color";
 import { type Mat4Like } from "../math/mat4";
 import type { Vec3Like } from "../math/vec";
 /** The anchor of a gizmo call: any object with an engine entity id (a `Node`). */
@@ -5,8 +6,9 @@ export type GizmoAnchor = {
     readonly id: number;
 };
 export type GizmoStyle = {
-    /** CSS hex color (`#rgb` / `#rrggbb`); default a neutral light gray. */
-    color?: string;
+    /** Any color (a CSS color string, `0xRRGGBB`, `[r, g, b(, a)]`; its alpha multiplies `alpha`);
+     *  default a neutral light gray. */
+    color?: ColorInput;
     /** 0..1, default 1. */
     alpha?: number;
     /** Anchor: points are in this node's LOCAL frame (scale ignored); the lines follow the node
@@ -14,8 +16,9 @@ export type GizmoStyle = {
      *  selected. Omit for world-space lines (not pickable). */
     node?: GizmoAnchor | null;
 };
-/** One color batch of LINES (flat `[x,y,z, x,y,z]` per segment) — what a host hands the engine.
- *  With `entityId` the segments are in that entity's local frame (see GizmoStyle.node). */
+/** One color batch of LINES (flat `[x,y,z, x,y,z]` per segment) — what a host hands the engine
+ *  (`color` a CSS color string, '#rrggbbaa' from here). With `entityId` the segments are in that
+ *  entity's local frame (see GizmoStyle.node). */
 export type GizmoBatch = {
     color: string;
     alpha: number;

package/dist/types/ui/NativeView.d.ts

@@ -1,4 +1,4 @@
-import { type PresentOptions } from "./presentable";
+import { type DismissOptions, type PresentOptions } from "./presentable";
 import { type BaseStyle, type DrawableStyle, type ElementStyle, type UIElementBase } from "./UINode";
 export type UINativeViewStyle = ElementStyle & DrawableStyle;
 /** An instance of a host-registered platform view (map, QR scanner, camera preview, …) —
@@ -13,15 +13,15 @@ export interface NativeView extends UIElementBase<UINativeViewStyle, DrawableSty
     /** Show fullscreen as the current destination (see Presentable). */
     open(options?: PresentOptions): void;
     /** Dismiss if this is the visible destination. */
-    close(): void;
+    close(options?: DismissOptions): void;
     /** Became the visible destination. */
     onOpen(callback: () => void): this;
     /** Stopped being the visible destination. */
     onClose(callback: () => void): this;
     /** Hardware/system back while current. */
-    onBackPressed(callback: () => void): this;
+    onBack(callback: () => void): this;
     /** Invoke a method on the native view (`map.call("setCenter", [lng, lat])`). Args and the
-     *  result are JSON-serialized. Rejects if the host has no such view/method. */
+     *  result are plain data (and Uint8Array). Rejects if the host has no such view/method. */
     call(method: string, ...args: any[]): Promise<any>;
     /** Subscribe to an event the native view emits (`map.on("markerTap", cb)`). */
     on(event: string, callback: (data?: any) => void): this;
@@ -35,4 +35,6 @@ export declare const NativeView: {
     (name: string, params?: object): NativeView;
     /** Whether this host registered a `registerView` factory under `name`. */
     isSupported(name: string): boolean;
+    /** The contract version of the host's view `name`: 0 when it has none, 1 for one written by hand. */
+    version(name: string): number;
 };

package/dist/types/ui/UI.d.ts

@@ -18,7 +18,7 @@ export { UIVirtualizedList } from './UIVirtualizedList';
 export { Router } from './router';
 export { NativeView, type UINativeViewStyle } from './NativeView';
 export { Presentable } from './presentable';
-export type { PresentOptions, Transition, TransitionName, TransitionSpec, TransitionTransform } from './presentable';
+export type { DismissOptions, PresentOptions, Transition, TransitionName, TransitionPose, TransitionSpec } from './presentable';
 export { __uiMap } from './UINode';
 export { __UIColumn, __UIRow, __UIBox } from './UIContainer';
 export { __UIButton } from './UIButton';

package/dist/types/ui/UIBottomSheet.d.ts

@@ -14,11 +14,11 @@ export type UIBottomSheetStyle = UIModalStyle;
  * modal machinery.
  *
  * ```ts
- * const actions = UIBottomSheet({ bgColor: "#1c1c1e", borderRadius: 16 }, [rows])   // content-sized
+ * const actions = UIBottomSheet(rows).style({ bgColor: "#1c1c1e", borderRadius: 16 })   // content-sized
  *
- * const mapSheet = UIBottomSheet({ bgColor: "#1c1c1e", borderRadius: 16 }, [results])
+ * const mapSheet = UIBottomSheet(results).style({ bgColor: "#1c1c1e", borderRadius: 16 })
  *   .detents([0.3, 0.6, 1])
- *   .onDetentChange(i => map.setPadding(...))
+ *   .onDetent(i => map.setPadding(...))
  * ```
  */
 export interface UIBottomSheet extends UIWidget {
@@ -26,12 +26,12 @@ export interface UIBottomSheet extends UIWidget {
      *  the last (highest) detent; set this before `show()`. Without a `detents()` call the sheet
      *  is CONTENT-SIZED instead — one position, as tall as its children (up to the screen). */
     detents(list: number[]): this;
-    /** Snap to a detent (animated). Clamped to the detents range; fires `onDetentChange`. */
+    /** Snap to a detent (animated). Clamped to the detents range; fires `onDetent`. */
     setDetent(index: number): void;
     /** Current detent index. */
     readonly detent: number;
     /** Fires on every settle: a finger snap on native hosts, or a `setDetent()` call. */
-    onDetentChange(callback: (index: number) => void): this;
+    onDetent(callback: (index: number) => void): this;
     /** Mount and slide in to the current detent. No-op while already open. */
     show(): void;
     /** Slide out, fade the scrim, then unmount. No-op while closed. */
@@ -49,16 +49,12 @@ export interface UIBottomSheet extends UIWidget {
 export declare class BottomSheetElement extends ModalElement {
     _detents: number[];
     _detent: number;
-    /** Host-facing (the `sl`/`otl` contract): hosts read `dtl` at mount and call it with the
-     *  settled detent index for GESTURE settles only — programmatic `setDetent` fires JS-side.
-     *  `-1` = dragged below the lowest detent while dismissible. */
-    readonly dtl: any[];
     readonly _detentListeners: ((index: number) => void)[];
     constructor(style: UIBottomSheetStyle, children: UINodeChild[] | ChildrenFn);
     detents(list: number[]): this;
     get detent(): number;
     setDetent(index: number): void;
-    onDetentChange(callback: (index: number) => void): this;
+    onDetent(callback: (index: number) => void): this;
     show(): void;
     hide(): void;
     dismissible(enabled: boolean): this;
@@ -67,5 +63,3 @@ export declare class BottomSheetElement extends ModalElement {
  *  `.detents([...])` for snap positions. Same argument forms as `UIColumn`. */
 export declare function UIBottomSheet(...children: UIChildArg[]): UIBottomSheet;
 export declare function UIBottomSheet(children: UINodeChild[] | ChildrenFn): UIBottomSheet;
-/** @deprecated Style as the first argument is legacy — use chained `.style({...})`. */
-export declare function UIBottomSheet(style: UIBottomSheetStyle, children?: UINodeChild[] | ChildrenFn): UIBottomSheet;

package/dist/types/ui/UIButton.d.ts

@@ -1,17 +1,11 @@
-import type { ClickEvent as ClickEventType, TouchStartEvent as TouchStartEventType, LongPressEvent as LongPressEventType } from "../runtime/touch";
-import { type ElementStyle, type ContainerStyle, type DrawableStyle, type UIChildArg, type UIContainerBase, type UINodeChild, type ChildrenFn, type BaseStyle, type Color, type LayerEasing } from "./UINode";
+import type { ClickEvent as ClickEventType, TouchStartEvent as TouchStartEventType, LongPressEvent as LongPressEventType, MouseEnterEvent as MouseEnterEventType } from "../runtime/touch";
+import { type ElementStyle, type ContainerStyle, type DrawableStyle, type UIChildArg, type UIContainerBase, type UINodeChild, type ChildrenFn, type BaseStyle, type Color } from "./UINode";
 export type UIButtonStyle = ElementStyle & DrawableStyle & ContainerStyle & {
     rippleColor?: Color | "default";
 };
-/** A tappable container — row + centered children by default. Press feedback via the `onPressed`
- *  style block, the `$pressed` class, or `rippleColor`. */
-export interface UIButton extends UIContainerBase<UIButtonStyle & {
-    onPressed?: UIButtonStyle & {
-        duration?: number;
-        delay?: number;
-        easing?: LayerEasing;
-    };
-}, DrawableStyle & BaseStyle> {
+/** A tappable container — row + centered children by default. Press feedback via the `$pressed`
+ *  class block or `rippleColor`. */
+export interface UIButton extends UIContainerBase<UIButtonStyle, DrawableStyle & BaseStyle> {
     readonly type: "button";
     /** Fired on a completed tap/click. */
     onClick(callback: (ev: ClickEventType<UIButton>) => void): this;
@@ -21,12 +15,16 @@ export interface UIButton extends UIContainerBase<UIButtonStyle & {
      *  `ev.track(...)` the rest of the gesture (like `onTouchStart`), so a hold can flow straight into
      *  dragging the element. A handled long-press suppresses the click that would follow the release. */
     onLongPress(callback: (ev: LongPressEventType<UIButton>) => void): this;
+    /** Fired when a mouse cursor (no button) enters the button — desktop / web; touch never fires it.
+     *  There is no leave event: `ev.track({ onMove, onEnd, onCancel })` follows the hover to its
+     *  end. The visual state is the reserved `$hovered` class (cascades like `$pressed`). */
+    onMouseEnter(callback: (ev: MouseEnterEventType<UIButton>) => void): this;
     /** Is a finger currently down on the button? */
-    isPressed(): boolean;
+    readonly isPressed: boolean;
+    /** Is a mouse cursor currently over the button (the topmost interactive node under it)? */
+    readonly isHovered: boolean;
 }
 /** Create a button (row + centered by default — the icon+label shape). Same argument forms as
  *  `UIColumn`; attach behavior with `.onClick(...)`. */
 export declare function UIButton(...children: UIChildArg[]): UIButton;
 export declare function UIButton(children: UINodeChild[] | ChildrenFn): UIButton;
-/** @deprecated Style as the first argument is legacy — use chained `.style({...})`. */
-export declare function UIButton(style: UIButtonStyle, children?: UINodeChild[] | ChildrenFn): UIButton;

package/dist/types/ui/UIContainer.d.ts

@@ -10,8 +10,6 @@ export declare const __UIBox: (children: UINodeChild[] | ChildrenFn) => UIBox;
  *  entries are skipped; a lone function makes the children reactive. */
 export declare function UIColumn(...children: UIChildArg[]): UIColumn;
 export declare function UIColumn(children: UINodeChild[] | ChildrenFn): UIColumn;
-/** @deprecated Style as the first argument is legacy — use chained `.style({...})`. */
-export declare function UIColumn(style: UIContainerStyle, children?: UINodeChild[] | ChildrenFn): UIColumn;
 /** A horizontal flex container — children flow left to right. */
 export interface UIRow extends UIContainerBase<UIContainerStyle> {
     readonly type: "row";
@@ -19,8 +17,6 @@ export interface UIRow extends UIContainerBase<UIContainerStyle> {
 /** Create a horizontal flex container (same argument forms as `UIColumn`). */
 export declare function UIRow(...children: UIChildArg[]): UIRow;
 export declare function UIRow(children: UINodeChild[] | ChildrenFn): UIRow;
-/** @deprecated Style as the first argument is legacy — use chained `.style({...})`. */
-export declare function UIRow(style: UIContainerStyle, children?: UINodeChild[] | ChildrenFn): UIRow;
 /** A centering container — `justifyContent`/`alignItems` default to center. */
 export interface UIBox extends UIContainerBase<UIContainerStyle> {
     readonly type: "box";
@@ -29,5 +25,3 @@ export interface UIBox extends UIContainerBase<UIContainerStyle> {
  *  avatars, empty states). Same argument forms as `UIColumn`. */
 export declare function UIBox(...children: UIChildArg[]): UIBox;
 export declare function UIBox(children: UINodeChild[] | ChildrenFn): UIBox;
-/** @deprecated Style as the first argument is legacy — use chained `.style({...})`. */
-export declare function UIBox(style: UIContainerStyle, children?: UINodeChild[] | ChildrenFn): UIBox;

package/dist/types/ui/UIImage.d.ts

@@ -9,8 +9,7 @@ export type UIImageStyle = ElementStyle & {
     objectFit?: "cover" | "contain" | "fill";
     tintColor?: Color;
 };
-/** A baked Canvas surface as an image source. The UI backend resolves it to a UI texture — see
- *  docs/canvas-contract.md ("Pending"). */
+/** A baked Canvas surface as an image source. The UI backend resolves it to a UI texture. */
 export type CanvasImageSource = {
     canvasSurface: number;
 };
@@ -41,5 +40,3 @@ export interface UIImage extends UIElementBase<UIImageStyle> {
 }
 /** Create an image element from a source (see {@link ImageSource}). */
 export declare function UIImage(src: ImageSource): UIImage;
-/** @deprecated Style as the first argument is legacy — use chained `.style({...})`. */
-export declare function UIImage(style: UIImageStyle, src: ImageSource): UIImage;

package/dist/types/ui/UIInput.d.ts

@@ -1,4 +1,4 @@
-import { type ElementStyle, type DrawableStyle, type TextStyle, type Color, type BaseStyle, type UIElementBase, type LayerEasing } from "./UINode";
+import { type ElementStyle, type DrawableStyle, type TextStyle, type Color, type BaseStyle, type UIElementBase } from "./UINode";
 type InputStyle = {
     placeholder?: string;
     placeholderColor?: Color;
@@ -47,20 +47,10 @@ type SubmitStyle = {
 };
 /** A single-line text input. Keyboard/picker kind via the `type` style, return-key behavior via
  *  `enterKey` + `onSubmit`; keyboard policy on `keyboardShrink`/`keyboardDismiss`. */
-export interface UIInput extends UIElementBase<UIInputStyle & SubmitStyle & {
-    onFocused?: UIInputStyle & {
-        duration?: number;
-        delay?: number;
-        easing?: LayerEasing;
-    };
-}, DrawableStyle & BaseStyle> {
+export interface UIInput extends UIElementBase<UIInputStyle & SubmitStyle, DrawableStyle & BaseStyle> {
     readonly type: "input";
-    /**
-     * The field's text. Writable at any time — set it BEFORE the screen opens to pre-fill a form
-     * (settings, edit-profile); the value is stashed on the node and applied when the host builds
-     * it. Reads return the live text while the screen is open, and the last value you set while it
-     * isn't. The user's typing is not preserved across close/open (use `keepAlive()` for that).
-     */
+    /** The field's text. Writable at any time; reads return the live text (the host owns the field
+     *  while the user types — IME composition, paste, the maxLength clamp, date/time canonicalization). */
     value: string;
     /** The text changed — fires on every user edit. */
     onChange(callback: (value: string) => void): UIInput;
@@ -70,21 +60,15 @@ export interface UIInput extends UIElementBase<UIInputStyle & SubmitStyle & {
     onBlur(callback: () => void): UIInput;
     /** The keyboard's return key was pressed. `value` is the current text. See `enterKey`. */
     onSubmit(callback: (value: string) => void): UIInput;
-    /** Focus the input (opens the keyboard). No-op before mount. */
+    /** Focus the input (opens the keyboard). */
     focus(): void;
     /** Release focus (dismisses the keyboard when this input held it). */
     blur(): void;
 }
 /** A multi-line text field — see the {@link UITextArea} factory for the auto-grow contract. */
-export interface UITextArea extends UIElementBase<UIInputStyle & {
-    onFocused?: UIInputStyle & {
-        duration?: number;
-        delay?: number;
-        easing?: LayerEasing;
-    };
-}, DrawableStyle & BaseStyle> {
+export interface UITextArea extends UIElementBase<UIInputStyle, DrawableStyle & BaseStyle> {
     readonly type: "textarea";
-    /** The field's text — same contract as {@link UIInput.value}: settable before mount to pre-fill. */
+    /** The field's text — same contract as {@link UIInput.value}. */
     value: string;
     /** The text changed — fires on every user edit. */
     onChange(callback: (value: string) => void): UITextArea;
@@ -92,7 +76,7 @@ export interface UITextArea extends UIElementBase<UIInputStyle & {
     onFocus(callback: () => void): UITextArea;
     /** Lost focus. */
     onBlur(callback: () => void): UITextArea;
-    /** Focus the text area (opens the keyboard). No-op before mount. */
+    /** Focus the text area (opens the keyboard). */
     focus(): void;
     /** Release focus (dismisses the keyboard when this text area held it). */
     blur(): void;

package/dist/types/ui/UIModal.d.ts

@@ -66,5 +66,3 @@ export declare class ModalElement extends WidgetElement {
  *  `show()`/`hide()`. Same argument forms as `UIColumn`. */
 export declare function UIModal(...children: UIChildArg[]): UIModal;
 export declare function UIModal(children: UINodeChild[] | ChildrenFn): UIModal;
-/** @deprecated Style as the first argument is legacy — use chained `.style({...})`. */
-export declare function UIModal(style: UIModalStyle, children?: UINodeChild[] | ChildrenFn): UIModal;