lecodes-sdk 1.2.0 → 2.0.0

package/src/ui/UIText.ts

@@ -1,5 +1,6 @@
 import { createBinding } from "../core/signals"
 import { Element, type BaseStyle, type DrawableStyle, type ElementStyle, type TextStyle, type UIElementBase } from "./UINode"
+import { tree } from "./tree"
 
 export type UITextStyle = ElementStyle & TextStyle & DrawableStyle
 
@@ -11,19 +12,17 @@ export interface UIText extends UIElementBase<UITextStyle, DrawableStyle & BaseS
 }
 
 export class TextElement extends Element<"text"> {
-  private _text: string
+  private _text = ""
   constructor(style: any, text: string | (() => string)) {
     super("text", style)
     if (typeof text === "function") {
-      // Reactive content: re-runs when a signal `text()` read changes; the setter routes to
-      // _creatorUI.updateNode when mounted and just keeps _text current when not.
-      this._text = ""
+      // Reactive content: re-runs when a signal `text()` read changes.
       createBinding(this, "#text", () => {
         const value = text()
         if (value !== this._text) this.text = value
       })
     } else {
-      this._text = text
+      this.text = text
     }
   }
   get text(): string {
@@ -31,21 +30,12 @@ export class TextElement extends Element<"text"> {
   }
   set text(value) {
     this._text = value
-    if (this._id !== 0) {
-      _creatorUI.updateNode(this._id, "text", value)
-    }
+    if (this._h.id !== 0) tree().setString(this._h.id, "text", value)
   }
 }
 
 /** Create a text label — a string, or `() => string` for reactive text that re-renders when a
  *  signal it read changes. */
-export function UIText(text: string | (() => string)): UIText;
-/** @deprecated Style as the first argument is legacy — use chained `.style({...})`. */
-export function UIText(style: UITextStyle, text: string | (() => string)): UIText;
-export function UIText(...args: [string | (() => string)] | [UITextStyle, string | (() => string)]): UIText {
-  if (args.length === 1) {
-    return new TextElement({}, args[0])
-  } else {
-    return new TextElement(args[0], args[1])
-  }
+export function UIText(text: string | (() => string)): UIText {
+  return new TextElement({}, text)
 }

package/src/ui/UIVideo.ts

@@ -1,6 +1,8 @@
 import type { VideoPlayer } from "../runtime/media"
-import { _bumpNavEpoch, _navSupported, _setCurrent, Presentable, type PresentOptions } from "./presentable"
+import { _bumpNavEpoch, _setCurrent, Presentable, type DestTuple, type DismissOptions, type PresentOptions } from "./presentable"
+import { _transitionId, TRANSITION_NONE } from "./transitions"
 import { Element, type BaseStyle, type DrawableStyle, type ElementStyle, type UIElementBase } from "./UINode"
+import { TREE_DEST_VIDEO, TREE_FLAG_BACK, pin, tree } from "./tree"
 
 export type UIVideoStyle = ElementStyle & DrawableStyle & { objectFit?: "cover" | "contain" | "fill" }
 
@@ -15,22 +17,23 @@ export interface UIVideo extends UIElementBase<UIVideoStyle, DrawableStyle & Bas
    *  the SAME native player moves fullscreen — playback uninterrupted; a pop moves it back. */
   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
+  /** @internal The destination tuple (Presentable). */
+  _dest(): DestTuple
 }
 
 class VideoElement extends Element<"video"> implements Presentable {
-  private _playerId: number
   private _player: VideoPlayer
   constructor(style: any, player: VideoPlayer) {
     super("video", style)
     this._player = player
-    this._playerId = (player as any)._id
+    tree().setInt(this._h.id, "playerId", (player as any)._h.id)
   }
 
   get player() {
@@ -40,25 +43,21 @@ class VideoElement extends Element<"video"> implements Presentable {
   // ---- Presentable (docs/navigation-presentable-plan.md) ----
   readonly ol: (() => void)[] = []
   readonly cl: (() => void)[] = []
-  _backButtonCallback?: () => void
-  private _vd?: object
+  private _backButtonCallback?: () => void
 
-  /** @internal wire descriptor — type "videoView" (distinct from the "video" node type). */
-  _viewDesc(): object {
-    return this._vd ??= { type: "videoView", node: this, _p: this }
-  }
+  /** @internal */
+  _dest(): DestTuple { return [TREE_DEST_VIDEO, this._h.id, "", ""] }
 
   open(options?: PresentOptions): void {
-    if (!_navSupported()) {
-      throw new Error("Fullscreen video is not supported on this host (requires _creatorUI.openView)")
-    }
+    if (this._h.id === 0) return
     _bumpNavEpoch()
-    _creatorUI.openView!(this._viewDesc(), options?.transition ?? "none")
+    pin(this)
+    tree().open(TREE_DEST_VIDEO, this._h.id, "", "", _transitionId(options?.transition, TRANSITION_NONE))
     _setCurrent(this)
   }
-  close(): void {
+  close(options?: DismissOptions): void {
     _bumpNavEpoch()
-    if (_navSupported()) _creatorUI.closeView!()
+    tree().close(TREE_DEST_VIDEO, this._h.id, _transitionId(options?.transition, TRANSITION_NONE))
     if (Presentable.current === this) _setCurrent(null)
   }
   onOpen(callback: () => void): this {
@@ -69,20 +68,24 @@ class VideoElement extends Element<"video"> implements Presentable {
     this.cl.push(callback)
     return this
   }
-  onBackPressed(callback: () => void): this {
+  onBack(callback: () => void): this {
     this._backButtonCallback = callback
+    this._addFlags(TREE_FLAG_BACK)
     return this
   }
+  /** @internal */
+  _emitOpen(): void { for (const cb of this.ol.slice()) cb() }
+  /** @internal */
+  _emitClose(): void { for (const cb of this.cl.slice()) cb() }
+  /** @internal */
+  _emitBack(): boolean {
+    if (!this._backButtonCallback) return false
+    this._backButtonCallback()
+    return true
+  }
 }
 
 /** Create a video node showing `player`'s output. */
-export function UIVideo(player: VideoPlayer): UIVideo
-/** @deprecated Style as the first argument is legacy — use chained `.style({...})`. */
-export function UIVideo(style: UIVideoStyle, player: VideoPlayer): UIVideo
-export function UIVideo(...args: [VideoPlayer] | [UIVideoStyle, VideoPlayer]): UIVideo {
-    if (args.length === 1) {
-    return new VideoElement({}, args[0])
-  } else {
-    return new VideoElement(args[0], args[1])
-  }
+export function UIVideo(player: VideoPlayer): UIVideo {
+  return new VideoElement({}, player)
 }

package/src/ui/UIVirtualizedList.ts

@@ -1,4 +1,5 @@
 import { Element, type Color, type DrawableStyle, type ElementStyle, type UIElementBase, type UINodeChild } from "./UINode"
+import { TREE_FLAG_REFRESH, TREE_FLAG_SCROLL, TREE_FLAG_VLIST_END, TREE_FLAG_VLIST_START, pin, tree, unpin } from "./tree"
 
 export type UIVirtualizedListStyle = DrawableStyle & ElementStyle & {
   /** Tint of the native pull-to-refresh spinner (pairs with `onRefresh`). */
@@ -30,11 +31,11 @@ export interface VListConfig<T> {
 export interface UIVirtualizedList<T = unknown> extends UIElementBase<UIVirtualizedListStyle> {
     readonly type: "vlist"
 
-    /** Replace the data wholesale — vanished keys are unmounted by the host's window sync. */
+    /** Replace the data wholesale — vanished keys are unmounted by the window sync. */
     setData(items: T[]): this
     /** Append items to the end (auto-scrolls when `inverted` and resting at the bottom). */
     append(...items: T[]): this
-    /** Insert at the start WITHOUT a scroll jump (the host compensates the offset). */
+    /** Insert at the start WITHOUT a scroll jump (the runtime compensates the offset). */
     prepend(...items: T[]): this
     /** Update items with the same keys: mounted ones re-render; the cached height persists until
      *  re-measured. */
@@ -56,37 +57,31 @@ export interface UIVirtualizedList<T = unknown> extends UIElementBase<UIVirtuali
 
     /** Scroll position changed (px from the start edge). */
     onScroll(callback: (scrollPosition: number) => void): this
-    /** Pull-to-refresh: the spinner stays until the returned promise settles. Attach BEFORE the
-     *  node mounts (hosts read it at creation). Native hosts only — no-op on web. */
+    /** Pull-to-refresh: the spinner stays until the returned promise settles. */
     onRefresh(callback: () => void | Promise<void>): this
     /** Fires within `thresholdPx` of the content's bottom edge — once, re-armed after leaving the
-     *  edge (host-side latch). Infinite-scroll loading. */
+     *  edge (a runtime-side latch). Infinite-scroll loading. */
     onEndReached(thresholdPx: number, callback: () => void): this
     /** Same, for the top edge — chat history loading. */
     onStartReached(thresholdPx: number, callback: () => void): this
 }
 
 export class VListElement<T> extends Element<"vlist"> implements UIVirtualizedList<T> {
+    private readonly sl: ((scrollPosition: number) => void)[] = []     // scroll
+    private readonly erl: (() => void)[] = []                          // endReached
+    private readonly strl: (() => void)[] = []                         // startReached
+    private _refreshCallback?: () => void | Promise<void>
 
-    // --- read by native side in createUINode (copyProperty / copyNodePtr) ---
-    _overscan: number
-    _inverted: boolean
-    _keys: string[] = [] 
-    _estimates: number[] = [] 
-    _endThreshold = 0
-    _startThreshold = 0
-
-    // --- списки слушателей, нативка забирает через copyPropertyListPtr ---
-    protected sl: ((scrollPosition: number) => void)[] = []     // scroll
-    protected erl: (() => void)[] = []                          // endReached
-    protected strl: (() => void)[] = []                         // startReached
-
-    // --- приватное состояние JS-стороны ---
     private items = new Map<string, T>()
-    private mounted = new Map<string, UINodeChild>()
+    private mounted = new Map<string, any>()
     private keyOf: (item: T) => string
     private renderItem: (item: T) => UINodeChild
     private estimate: (item: T) => number
+    private readonly _overscan: number
+    private readonly _inverted: boolean
+    private _endThreshold = 0
+    private _startThreshold = 0
+    private _inited = false
 
     constructor(config: VListConfig<T>) {
         // flexShrink: 1 default (SDK-owned, same as UIScrollable): an explicit height/flexBasis
@@ -102,8 +97,12 @@ export class VListElement<T> extends Element<"vlist"> implements UIVirtualizedLi
         this._inverted = config.inverted ?? false
     }
 
-    private get isAttached(): boolean {
-        return !!this._id && this._id !== 0
+    // The runtime's list state is created on the first data write — after the app had its chance to
+    // set the edge thresholds (onEndReached / onStartReached come before setData in practice).
+    private _ensure(): void {
+        if (this._inited || this._h.id === 0) return
+        this._inited = true
+        tree().vlistInit(this._h.id, this._overscan, this._inverted, this._startThreshold, this._endThreshold)
     }
 
     private register(items: T[]): [string[], number[]] {
@@ -123,14 +122,12 @@ export class VListElement<T> extends Element<"vlist"> implements UIVirtualizedLi
         const prevMounted = [...this.mounted.keys()]
         this.items.clear()
         const [keys, estimates] = this.register(items)
-        this._keys = keys
-        this._estimates = estimates
-        if (this.isAttached) {
-            _creatorUI.vlistSetKeys(this, keys, estimates)
-
+        this._ensure()
+        if (this._h.id !== 0) {
+            tree().vlistSetKeys(this._h.id, keys, estimates)
             for (const k of prevMounted) {
                 if (this.mounted.has(k) && this.items.get(k) !== prevItems.get(k)) {
-                    _creatorUI.vlistInvalidate(this, k)
+                    tree().vlistInvalidate(this._h.id, k)
                 }
             }
         }
@@ -139,21 +136,15 @@ export class VListElement<T> extends Element<"vlist"> implements UIVirtualizedLi
 
     append(...items: T[]): this {
         const [keys, estimates] = this.register(items)
-        this._keys.push(...keys)
-        this._estimates.push(...estimates)
-        if (this.isAttached) {
-            _creatorUI.vlistInsertKeys(this, -1, keys, estimates)
-        }
+        this._ensure()
+        if (this._h.id !== 0) tree().vlistInsertKeys(this._h.id, -1, keys, estimates)
         return this
     }
 
     prepend(...items: T[]): this {
         const [keys, estimates] = this.register(items)
-        this._keys.unshift(...keys)
-        this._estimates.unshift(...estimates)
-        if (this.isAttached) {
-            _creatorUI.vlistInsertKeys(this, 0, keys, estimates)
-        }
+        this._ensure()
+        if (this._h.id !== 0) tree().vlistInsertKeys(this._h.id, 0, keys, estimates)
         return this
     }
 
@@ -162,74 +153,82 @@ export class VListElement<T> extends Element<"vlist"> implements UIVirtualizedLi
             const k = this.keyOf(item)
             if (!this.items.has(k)) continue
             this.items.set(k, item)
-            if (this.isAttached && this.mounted.has(k)) {
-                _creatorUI.vlistInvalidate(this, k)
-            }
+            if (this._h.id !== 0 && this.mounted.has(k)) tree().vlistInvalidate(this._h.id, k)
         }
         return this
     }
 
     removeByKey(...keys: string[]): this {
+        const gone: string[] = []
         for (const k of keys) {
             if (!this.items.delete(k)) continue
-            const i = this._keys.indexOf(k)
-            if (i >= 0) { this._keys.splice(i, 1); this._estimates.splice(i, 1) }
-        }
-        if (this.isAttached) {
-            _creatorUI.vlistRemoveKeys(this, keys)
+            gone.push(k)
         }
+        if (this._h.id !== 0 && gone.length > 0) tree().vlistRemoveKeys(this._h.id, gone)
         return this
     }
 
     get itemCount(): number { return this.items.size }
     getItem(key: string): T | undefined { return this.items.get(key) }
 
-    // --- команды: офсеты и позиции знает только нативка (префикс-суммы) ---
+    // --- commands: offsets and positions are the runtime's (prefix sums) ---
     scrollTo(offset: number, animated = true): void {
-        _creatorUI.command(this, "scrollTo", offset, animated)
+        if (this._h.id !== 0) tree().vlistScrollTo(this._h.id, offset, animated)
     }
     scrollToKey(key: string, animated = true): void {
-        _creatorUI.command(this, "scrollToKey", key, animated)
+        if (this._h.id !== 0) tree().vlistScrollToKey(this._h.id, key, animated)
     }
     scrollToEnd(animated = true): void {
-        _creatorUI.command(this, "scrollToEnd", animated)
+        if (this._h.id !== 0) tree().vlistScrollToEnd(this._h.id, animated)
     }
 
     onScroll(callback: (scrollPosition: number) => void): this {
         this.sl.push(callback)
+        this._addFlags(TREE_FLAG_SCROLL)
         return this
     }
-    // Читается нативкой при маунте (тот же контракт, что у UIScrollable).
-    declare _refreshCallback: any
     onRefresh(callback: () => void | Promise<void>): this {
         this._refreshCallback = callback
+        this._addFlags(TREE_FLAG_REFRESH)
         return this
     }
     onEndReached(thresholdPx: number, callback: () => void): this {
         this._endThreshold = thresholdPx
         this.erl.push(callback)
+        this._addFlags(TREE_FLAG_VLIST_END)
         return this
     }
     onStartReached(thresholdPx: number, callback: () => void): this {
         this._startThreshold = thresholdPx
         this.strl.push(callback)
+        this._addFlags(TREE_FLAG_VLIST_START)
         return this
     }
 
-    /** @internal The one host→JS callback (via jsPtr, like button). Fires ONLY when the window
-     *  crossed a boundary — not per scroll frame. Order: unmounts first (the host already tore the
-     *  subtrees down and zeroed _id; only JS refs are cleaned here), then mounts. */
+    /** @internal */
+    _emitScroll(position: number): void { for (const cb of this.sl.slice()) cb(position) }
+    /** @internal */
+    _emitRefresh(): unknown { return this._refreshCallback?.() }
+    /** @internal */
+    _emitEdge(end: boolean): void { for (const cb of (end ? this.erl : this.strl).slice()) cb() }
+
+    /** @internal The runtime's window sync (synchronous). Order: unmounts first (the runtime already
+     *  detached those subtrees — they are plain roots again and go with their elements), then mounts:
+     *  each rendered subtree is handed to the runtime under its key on this same stack. */
     _syncWindow(unmountKeys: string[], mountKeys: string[]): void {
         for (const k of unmountKeys) {
+            const node = this.mounted.get(k)
             this.mounted.delete(k)
+            if (node) unpin(node._h.id)
         }
         for (const k of mountKeys) {
             const item = this.items.get(k)
             if (item === undefined) continue
-            const node = this.renderItem(item)
+            const node: any = this.renderItem(item)
+            if (!node || node._h.id === 0) continue
             this.mounted.set(k, node)
-            // createUINode в detached yoga root + измерение (width, NaN) + кэш высоты
-            _creatorUI.vlistMount(this, k, node)
+            pin(node)
+            tree().vlistMount(this._h.id, k, node._h.id)
         }
     }
 }
@@ -238,4 +237,4 @@ export class VListElement<T> extends Element<"vlist"> implements UIVirtualizedLi
  *  then feed it via `setData`/`append`/`prepend`. Give it a size (`flexGrow: 1` as a screen body). */
 export function UIVirtualizedList<T>(config: VListConfig<T>): UIVirtualizedList<T> {
     return new VListElement<T>(config)
-}
+}

package/src/ui/UIWidget.ts

@@ -1,6 +1,7 @@
 import { TouchStartEvent } from "../runtime/touch"
-import { _descOf, _navSupported, Presentable } from "./presentable"
+import { Presentable } from "./presentable"
 import { ContainerElement, buildUI, type BaseStyle, type Color, type ContainerStyle, type DrawableStyle, type PaddingStyle, type PositionStyle, type UIChildArg, type UIContainerBase, type UINodeChild, type ChildrenFn } from "./UINode"
+import { TREE_DEST_NONE, TREE_FLAG_BACK, TREE_FLAG_INTERACTIVE, TREE_FLAG_OVERLAY_TAP, pin, tree, unpin } from "./tree"
 
 
 export type UIWidgetStyle = ContainerStyle & DrawableStyle & PaddingStyle & BaseStyle & PositionStyle & {
@@ -23,8 +24,7 @@ export interface UIWidget extends UIContainerBase<UIWidgetStyle, DrawableStyle &
    * (= back to a global overlay). Set it while the widget is hidden. The widget is always its own
    * overlay root mounted into the owner's page view — it never becomes a child of the owner, so it
    * stays topmost and its updates never trigger the owner's relayout. Works with a `UIScreen` that
-   * is a page inside a `UIPager`: the widget mounts into that tab and rides its swipe. (Web shows
-   * and hides it with the owner but does not yet ride the transition.)
+   * is a page inside a `UIPager`: the widget mounts into that tab and rides its swipe.
    */
   attachTo(owner: Presentable | null): this,
 
@@ -37,13 +37,16 @@ export interface UIWidget extends UIContainerBase<UIWidgetStyle, DrawableStyle &
   hide(): void,
 
   /** Mounted right now (`show()` ran, `hide()` hasn't). */
-  readonly isShow: boolean,
+  readonly isShown: boolean,
 
   /** Touch began on the widget; `ev.track(...)` takes over the rest of the gesture. */
   onTouchStart(callback: (ev: TouchStartEvent<UIWidget>) => void): this,
   /** Tap on the overlay layer (requires an `overlayColor`). */
   onOverlayTap(callback: () => void): this,
   /** Hardware/system back while the widget is shown. */
+  onBack(callback: () => void): this
+  /** @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): this
 }
 
@@ -51,6 +54,7 @@ export interface UIWidget extends UIContainerBase<UIWidgetStyle, DrawableStyle &
 export class WidgetElement extends ContainerElement<"widget"> {
   scrollable = false as const
   _owner?: Presentable
+  private _shown = false
   constructor(type: "widget", style: UIWidgetStyle, children: UINodeChild[] | ChildrenFn) {
     // Widgets are absolutely positioned in device coordinates — in the constructor (not the
     // factory) so subclasses like ModalElement inherit it.
@@ -65,27 +69,33 @@ export class WidgetElement extends ContainerElement<"widget"> {
     // content) — never a child of the owner, so it stays topmost, its updates never relayout the
     // owner, and it doesn't pollute the owner's children. `attachTo(owner)` just tells the host
     // which page view to mount that root into; ownerless widgets are global overlays.
-    if (this._owner && _navSupported()) {
-      _creatorUI.showWidget(this, _descOf(this._owner))
+    if (this._h.id === 0 || this._shown) return
+    this._shown = true
+    pin(this)
+    if (this._owner) {
+      const [kind, id] = this._owner._dest()
+      tree().showWidget(this._h.id, kind, id)
     } else {
-      // Unattached (or legacy host): global overlay above navigation.
-      _creatorUI.showWidget(this)
+      tree().showWidget(this._h.id, TREE_DEST_NONE, 0)
     }
   }
   hide(): void {
-    _creatorUI.hideWidget(this)
+    if (this._h.id === 0 || !this._shown) return
+    this._shown = false
+    tree().hideWidget(this._h.id)
+    unpin(this._h.id)
   }
-  get isShow(): boolean {
-    return this._id !== 0
+  get isShown(): boolean {
+    return this._shown
   }
 
-  _interactive = false
   readonly touchStartListeners: any[] = []
   onTouchStart (callback: any): this {
-    this._interactive = true
     this.touchStartListeners.push(callback)
+    this._addFlags(TREE_FLAG_INTERACTIVE)
     return this
   }
+  /** @internal */
   _emitTouchStart(pointerId: number, clientX: number, clientY: number): any {
     const touchEvent = new TouchStartEvent(clientX, clientY, pointerId)
     touchEvent.target = this
@@ -100,14 +110,26 @@ export class WidgetElement extends ContainerElement<"widget"> {
   readonly otl: (() => void)[] = []
   onOverlayTap(callback: () => void): this {
     this.otl.push(callback)
+    this._addFlags(TREE_FLAG_OVERLAY_TAP)
     return this
   }
+  /** @internal */
+  _emitOverlayTap(): void { for (const cb of this.otl.slice()) cb() }
 
-  _backButtonCallback?: () => void
-  onBackPressed(callback: any): this {
+  private _backButtonCallback?: () => void
+  onBack(callback: any): this {
     this._backButtonCallback = callback
+    this._addFlags(TREE_FLAG_BACK)
     return this
   }
+  /** @deprecated see the interface */
+  onBackPressed(callback: any): this { return this.onBack(callback) }
+  /** @internal the runtime's back chain: true = handled. */
+  _emitBack(): boolean {
+    if (!this._backButtonCallback) return false
+    this._backButtonCallback()
+    return true
+  }
 }
 
 
@@ -120,8 +142,6 @@ export const __UIWidget = (children: UINodeChild[] | ChildrenFn): UIWidget => ma
  *  (`top`/`left`/`bottom`/`right`), then `show()`/`hide()`. */
 export function UIWidget(...children: UIChildArg[]): UIWidget;
 export function UIWidget(children: UINodeChild[] | ChildrenFn): UIWidget;
-/** @deprecated Style as the first argument is legacy — use chained `.style({...})`. */
-export function UIWidget(style: UIWidgetStyle, children?: UINodeChild[] | ChildrenFn): UIWidget;
 export function UIWidget(...args: any[]): UIWidget {
   return buildUI(args, null, makeWidget)
-}
+}

package/src/ui/colorKeys.gen.ts

@@ -0,0 +1,37 @@
+// AUTO-GENERATED from engines/ui/properties.mjs — DO NOT EDIT. Regenerate: bun run gen:ui-props
+//
+// The UI style keys that carry a color (engines/ui/properties.mjs). The SDK sends colors to the
+// core as '#rrggbbaa' strings only: the UI core rejects a NUMBER on a color property (a warning,
+// the write dropped) and parses strings with AnyCanvas's CSS parser (the SDK's twin: canvas/gen).
+
+/** The keys whose value IS a color — every color property with its aliases: normalize the value
+ *  to '#rrggbbaa'. Pass-throughs: null / undefined (a reset), any string containing "var(" (the
+ *  core resolves theme vars), rippleColor's "default" (a core keyword). */
+export const COLOR_KEYS: ReadonlySet<string> = new Set([
+  "color",
+  "backgroundColor",
+  "bgColor",
+  "borderColor",
+  "borderTopColor",
+  "borderRightColor",
+  "borderBottomColor",
+  "borderLeftColor",
+  "placeholderColor",
+  "refreshControlColor",
+  "tintColor",
+  "rippleColor",
+  "overlayColor",
+])
+
+/** The shorthands that expand into a color property. A color is only ONE of their value forms:
+ *  never normalize the value whole — "2px solid red", a gradient or an image path go to the core
+ *  raw (its shorthand parsers read the colors inside with the same grammar), a number on
+ *  `border*` is a WIDTH; only a number / color array on `background` is a color. */
+export const COLOR_SHORTHAND_KEYS: ReadonlySet<string> = new Set([
+  "background",
+  "border",
+  "borderTop",
+  "borderRight",
+  "borderBottom",
+  "borderLeft",
+])

package/src/ui/fonts.ts

@@ -8,6 +8,6 @@ type FontOptions = {
  *  dynamic escape hatch. */
 export async function registerFont (fontFamily: string, url: string, options: FontOptions = {}): Promise<void> {
   return new Promise<void>((res, rej) => {
-    _creatorUI.registerFont(fontFamily, url, options, res, rej)
+    _creatorTree.registerFont(fontFamily, url, options.weight ?? 400, options.style === "italic" ? 2 : 0, res, rej)
   })
-}
+}