lecodes-sdk 2.2.11 → 2.2.13

package/dist/global.d.ts

@@ -651,7 +651,9 @@ declare global {
   type UserLocationOptions = SDK.UserLocationOptions
   type VRScene = SDK.VRScene
   type Vec2 = SDK.Vec2
+  type Vec2Like = SDK.Vec2Like
   type Vec3 = SDK.Vec3
+  type Vec3Like = SDK.Vec3Like
   type Vehicle = SDK.Vehicle
   type VideoPlayer = SDK.VideoPlayer
   type Voice = SDK.Voice

package/dist/host.d.ts

@@ -6,8 +6,11 @@
 import type { SvgSource } from "./types/runtime/misc"
 
 declare global {
-  function setTimeout(handler: (...args: any[]) => void, timeout?: number): number
-  function setInterval(handler: (...args: any[]) => void, timeout?: number): number
+  /** As in the browser, but the delay is REQUIRED (the native runtime throws without it) and no
+   *  extra argument reaches the handler. Timers tick with the frame on every native host: one
+   *  frame is the resolution. */
+  function setTimeout(handler: () => void, timeout: number): number
+  function setInterval(handler: () => void, timeout: number): number
   function clearTimeout(id: number): void
   function clearInterval(id: number): void
   /** Per-frame loop, driven by the host (viewer RAF / desktop runTick). `dt` is **seconds** since
@@ -38,6 +41,9 @@ declare global {
   /** Compile-time macro: `asset('./logo.svg')` yields the file as an SVG image source — for
    *  `UIImage(...)` and `bgImage`. */
   function asset(path: `${string}.svg`): SvgSource
+  /** Compile-time macro: `asset('./levels.csv')` yields a text file's TEXT (.txt, .csv, .md, .css,
+   *  .html, .xml, .yml — it ships inside the bundle). Parse it yourself. */
+  function asset(path: `${string}.${"txt" | "csv" | "md" | "css" | "html" | "xml" | "yml" | "yaml"}`): string
   /** Compile-time macro: `asset('./hero.png')` is desugared by the bundler into the module import
    *  for that resource. The file must exist — a path that resolves to nothing fails the compile
    *  (`asset not found: ./hero.png (main.ts:3)`); there is no runtime fallback. Calls inside

package/dist/types/core/Aspect.d.ts

@@ -36,6 +36,11 @@ export declare abstract class AspectHost<E extends EventMap = EventMap> extends
      *  child-management `add`/`remove` semantics some node kinds expose. */
     removeAspect<A extends Aspect<any, any, any>>(ctor: AspectCtor<A>): this;
 }
+/** What a scene needs to carry systems: Scene and Scene2D implement it over the helpers below. Public
+ *  (never stripped from the public types: the `System` type names it). */
+export type SystemHost = {
+    readonly _systems: Map<Function, Aspect<any, any, any>>;
+};
 /**
  * Base for everything you attach. `K` = accessor name (extracted by chisel for the runtime). `P` =
  * the target node kind: `this.node` is typed to it, AND attaching to a wrong node is a compile error.

package/dist/types/g2/Physics2D.d.ts

@@ -97,8 +97,9 @@ export declare class Physics2D extends Aspect<"physics", Node2D> {
     static get gravity(): Vec2;
     static set gravity(g: Vec2Like);
     private static _gravity;
-    /** Whether this build has physics support (CREATOR_2D_PHYSICS). NOTE: this reports the BUILD, not
-     *  the world — there is nothing else to guard, since the world creates itself. */
+    /** Whether this host has 2D physics (a 2D engine built with CREATOR_2D_PHYSICS). False, never a
+     *  throw, where there is no 2D engine at all (Web Lite, a 3d / core engine variant). It reports
+     *  the build, not the world — there is nothing else to guard, since the world creates itself. */
     static get supported(): boolean;
     /** Render interpolation of body transforms between the fixed 60 Hz steps (global; default on). Turn
      *  off to save per-frame transform writes when you have many moving bodies / don't need >60 Hz

package/dist/types/g2/Scene2D.d.ts

@@ -30,6 +30,9 @@ export declare class Scene2D implements Presentable {
     readonly camera: Camera2D;
     private static _active;
     static get active(): Scene2D | null;
+    /** Whether this host has the 2D engine. False on Web Lite (UI and 3D only) and in a 3d / core
+     *  engine variant of an app built with `lecodes app`; there `new Scene2D()` throws. */
+    static get supported(): boolean;
     readonly _touchStartListeners: Array<(ev: TouchStartEvent<Node2D | null>) => void>;
     /** Texture filter to (re)assert on open(); the sampler is global, so each scene reclaims it. */
     private readonly _filter?;
@@ -47,6 +50,9 @@ export declare class Scene2D implements Presentable {
     removeEventListener(channel: "click" | "touchstart", callback: (ev: any) => void): void;
     add(...nodes: Node2D[]): this;
     remove(...nodes: Node2D[]): this;
+    /** class → instance, the authoritative store (named accessors mirror this). Kept in the public
+     *  types: it is what makes a Scene2D a `SystemHost` there. */
+    readonly _systems: Map<Function, Aspect<any, any, any>>;
     /** Attach (and configure) a system, or reconfigure it if already present. Returns the scene typed
      *  as now-having it (`scene.system(Hud).hud`). A 3D `System<'x'>` (target Scene) is rejected here. */
     system<Self extends TargetOf<A>, A extends Aspect<any, any, any>>(this: Self, ctor: AspectCtor<A>, opts?: Partial<A>): Self & FieldOf<A>;

package/dist/types/gl/Scene.d.ts

@@ -157,6 +157,9 @@ export declare class Scene implements Presentable {
     set postProcessing(_: never);
     private static _active;
     static get active(): Scene | null;
+    /** Whether this host has the 3D engine. False where the bundle was marked `gl: disable` (no scene
+     *  created anywhere in it) and in a 2d / core engine variant; there `new Scene()` throws. */
+    static get supported(): boolean;
     constructor(options?: SceneOptions);
     /** Runtime form of `renderScale` / `dynamicResolution` (a graphics-settings menu). `renderScale`
      *  0.25–1; older hosts without the method ignore it. */
@@ -199,6 +202,9 @@ export declare class Scene implements Presentable {
     setStencil(enabled: boolean): void;
     add(...list: Node[]): this;
     remove(...list: Node[]): this;
+    /** class → instance, the authoritative store (named accessors mirror this). Kept in the public
+     *  types: it is what makes a Scene a `SystemHost` there. */
+    readonly _systems: Map<Function, Aspect<any, any, any>>;
     /** Attach (and configure) a system, or reconfigure it if already present. Returns the scene typed
      *  as now-having it (`scene.system(Hud).hud`). A `System<'x', Scene2D>` is rejected here. */
     system<Self extends TargetOf<A>, A extends Aspect<any, any, any>>(this: Self, ctor: AspectCtor<A>, opts?: Partial<A>): Self & FieldOf<A>;

package/dist/types/gl/Texture.d.ts

@@ -1,4 +1,5 @@
 import { type FetchResponse, type File } from "../runtime/fetch";
+import type { Canvas } from "../canvas/Canvas";
 /** `Texture.load` options. */
 export type TextureLoadOptions = {
     /** `true` (default): colour, stored sRGB. `false`: data (normal map, mask, heightmap) — kept linear. */
@@ -30,13 +31,7 @@ export declare class Texture {
     /** Vertical wrap mode (V). */
     wrapT: number;
     constructor(width: number, height: number, id: Handle | number);
-    static fromCanvas(canvas: {
-        _bakeSurface(): number;
-        width: number;
-        height: number;
-        pixelRatio: number;
-        _tex3dId: number;
-    }): Texture;
+    static fromCanvas(canvas: Canvas): Texture;
     /** A texture from raw pixels: `channels` (1–4, default 4) UBYTE per pixel, row-major, `width ×
      *  height × channels` bytes; `srgb` (default true for colour) picks the sRGB internal format —
      *  pass false for data (a heightmap, a mask). No mips. Throws on a host without the call. */

package/dist/types/gl/animation/DynamicBone.d.ts

@@ -48,6 +48,9 @@ export declare class DynamicBoneCollider extends Aspect<"dynamicBoneCollider", N
 }
 export declare class DynamicBone extends Aspect<"dynamicBone", Node> {
     static readonly aspect = "dynamicBone";
+    /** Whether this host simulates dynamic bones. False, never a throw, on Web Lite and in headless
+     *  tests; there the aspect attaches, warns once, and `chain` stays empty. */
+    static get supported(): boolean;
     /** Only these bones (by name) join the chain — the root always does, a bone left out takes its
      *  subtree with it. Default: the root's whole subtree. */
     bones?: string[];

package/dist/types/gl/animation/Locomotion.d.ts

@@ -179,6 +179,9 @@ export type LocomotionEvents = {
 };
 export declare class Locomotion extends Aspect<"loco", Node, LocomotionEvents> {
     static readonly aspect = "loco";
+    /** Whether this host runs the locomotion selector. False, never a throw, on Web Lite and in
+     *  headless tests; there the aspect attaches, warns once, and the body stays `'idle'`. */
+    static get supported(): boolean;
     /** The animator whose clips are shown. Default: the first one on this node or under it (a Model
      *  child), which is the usual character — a capsule node with the model inside. */
     animator?: Animator;

package/dist/types/gl/physics/Physics.d.ts

@@ -85,7 +85,8 @@ export declare class Physics extends Aspect<"physics", Node> implements CompWrit
     applyImpulseAt(v: Vec3Like, point: Vec3Like): this;
     /** Configure gravity / limits. Call once before creating bodies. */
     static configure(config?: PhysicsConfig): void;
-    /** Whether this build has physics support (CREATOR_GL_PHYSICS). */
+    /** Whether this host has 3D physics (an engine built with CREATOR_GL_PHYSICS). False, never a
+     *  throw, where there is no 3D engine at all. */
     static get supported(): boolean;
     /** Closest pickable body hit by the ray from `origin` along `dir` (up to `maxDist`), or null. */
     static raycast(origin: Vec3Like, dir: Vec3Like, maxDist?: number): RayHit | null;

package/dist/types/gl/physics/Ragdoll.d.ts

@@ -60,6 +60,10 @@ export interface RagdollHitOptions {
 }
 export declare class Ragdoll extends Aspect<"ragdoll", Node> {
     static readonly aspect = "ragdoll";
+    /** Whether this host can drop a body: 3D physics with ragdoll parts. False, never a throw,
+     *  without physics or on an older host. A host that has it can still refuse the parts
+     *  (`activate()` returns false). */
+    static get supported(): boolean;
     /** The parts: `'humanoid'` (default) finds the standard bones by name; a list places bodies on any
      *  bones — parents before children. */
     parts: RagdollPart[] | "humanoid";

package/dist/types/gl/vehicle/Vehicle.d.ts

@@ -127,6 +127,10 @@ export interface AeroConfig {
 }
 export declare class Vehicle extends Aspect<"vehicle", Node> {
     static readonly aspect = "vehicle";
+    /** Whether this host can drive a car: 3D physics with the vehicle model. False, never a throw,
+     *  without physics or on an older host. A host that has it can still refuse a car's settings
+     *  (`id` stays 0, with a warning). */
+    static get supported(): boolean;
     /** Chassis mass in kg (default 1200). Wheels are massless in this model. */
     mass: number;
     /** Centre of mass height in chassis space (metres, negative = lower). Left out, it drops to halfway

package/dist/types/inject.d.ts

@@ -1,5 +1,5 @@
 export { Mathf } from "./math/Mathf";
-export { Vec2, Vec3 } from "./math/vec";
+export { Vec2, Vec3, type Vec2Like, type Vec3Like } from "./math/vec";
 export { Quat } from "./math/quat";
 export { Mat4 } from "./math/mat4";
 export { Color } from "./core/color";

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

@@ -43,8 +43,10 @@ export declare const app: {
     sdkVersion: string;
     /** The INSTALLED app: the store build this bundle runs in. After an over-the-air update the code
      *  is newer than the binary, so a feature that needs native support added in a later store build
-     *  (a plugin, an SDK method) branches on `app.host.sdk` / `app.host.build` — and on `typeof` of
-     *  the method itself, which is the final word. Minor and patch of the SDK never gate anything. */
+     *  (a plugin, an SDK method) branches on `app.host.sdk` / `app.host.build` — and on the feature's
+     *  own check (`Push.isSupported`, `Physics.supported`), which is the final word. Not `typeof` of
+     *  the global: every SDK wrapper is compiled into the bundle, so `typeof Push` is "object" on a
+     *  host without the plugin. Minor and patch of the SDK never gate anything. */
     readonly host: AppHost;
     /** The RUNNING code: what the compiler stamped into this bundle's header. `updatedAt` is the
      *  compile time — what the updater compares before replacing a bundle (an older one never

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

@@ -12,6 +12,9 @@ export interface FetchResponse {
     readonly status: number;
     json<T = any>(): T;
     text(): string;
+    /** The body's bytes, a copy — a binary format of your own (`asset('./levels/1.bin')`), parsed in
+     *  code with a DataView. Synchronous, like `text()`. */
+    bytes(): Uint8Array;
     /** @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;

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

@@ -1,5 +1,10 @@
-export declare const localStorage: {
+declare const methods: {
     getItem(key: string): string | null;
     setItem(key: string, value: string): void;
     removeItem(key: string): void;
 };
+export type LocalStorage = typeof methods & {
+    [key: string]: any;
+};
+export declare const localStorage: LocalStorage;
+export {};

package/dist/types/server/db/marci/query.d.ts

@@ -188,7 +188,13 @@ export type AggregateResult<TModel, T> = (T extends {
     max: (F extends keyof TModel ? TModel[F] : never) | null;
 } : {});
 declare const __op: unique symbol;
-export type Op<T> = PromiseLike<T> & {
+/** What a query or an op offers of a promise: `then`, `catch`, `finally` — the runtime object has
+ *  all three (`op()` / the collection builder below), so `db.x.insert(…).catch(…)` type-checks. */
+export type Settles<T> = PromiseLike<T> & {
+    catch<R = never>(onRejected?: ((reason: any) => R | PromiseLike<R>) | null): Promise<T | R>;
+    finally(onFinally?: (() => void) | null): Promise<T>;
+};
+export type Op<T> = Settles<T> & {
     readonly [__op]: T;
 };
 export type MarciOp = {
@@ -251,7 +257,7 @@ export type IdArg<I> = I | BareId<I>;
  * it to `$transaction` batches it; placing it in another query's select makes it a sub-select. `Sel` is the
  * projection: id + scalars until `select(...)` sets a shape.
  */
-export interface Query<T extends ModelTypes, Sel = T["scalars"]> extends PromiseLike<Rows<T, Sel>[]> {
+export interface Query<T extends ModelTypes, Sel = T["scalars"]> extends Settles<Rows<T, Sel>[]> {
     readonly [__op]: Rows<T, Sel>[];
     readonly [__sub]: T["name"];
     readonly [__sel]: Effective<T, Sel>;

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

@@ -1,6 +1,6 @@
 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 & {
+import { type ElementStyle, type ContainerStyle, type DrawableStyle, type TextStyle, type UIChildArg, type UIContainerBase, type UINodeChild, type ChildrenFn, type BaseStyle, type Color } from "./UINode";
+export type UIButtonStyle = ElementStyle & DrawableStyle & ContainerStyle & TextStyle & {
     rippleColor?: Color | "default";
 };
 /** A tappable container — row + centered children by default. Press feedback via the `$pressed`

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

@@ -1,5 +1,7 @@
-import { type ChildrenFn, type ContainerStyle, type DrawableStyle, type ElementStyle, type UIChildArg, type UIContainerBase, type UINodeChild } from "./UINode";
-export type UIContainerStyle = ElementStyle & DrawableStyle & ContainerStyle;
+import { type ChildrenFn, type ContainerStyle, type DrawableStyle, type ElementStyle, type TextStyle, type UIChildArg, type UIContainerBase, type UINodeChild } from "./UINode";
+/** A container's style: its box and layout, plus the text props (`color`, `fontSize`, `textWrap` …)
+ *  the texts inside inherit from it. */
+export type UIContainerStyle = ElementStyle & DrawableStyle & ContainerStyle & TextStyle;
 /** A vertical flex container — children stack top to bottom. */
 export interface UIColumn extends UIContainerBase<UIContainerStyle> {
     readonly type: "column";

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

@@ -73,7 +73,7 @@ export type DrawableStyle = {
 };
 /** Flex-layout props of a container (how it lays out its children). */
 export type ContainerStyle = {
-    flexDirection?: "row" | "column";
+    flexDirection?: "row" | "column" | "row-reverse" | "column-reverse";
     justifyContent?: "flex-start" | "center" | "flex-end" | "space-between" | "space-evenly";
     alignItems?: "flex-start" | "center" | "flex-end" | "stretch";
     gap?: UIValue;

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

@@ -1,8 +1,8 @@
 import { TouchStartEvent } from "../runtime/touch";
 import { type DismissOptions, type PresentOptions } from "./presentable";
-import { ContainerElement, type BaseStyle, type ContainerStyle, type DrawableStyle, type PaddingStyle, type UIChildArg, type UIContainerBase, type UINodeChild, type ChildrenFn } from "./UINode";
+import { ContainerElement, type BaseStyle, type ContainerStyle, type DrawableStyle, type PaddingStyle, type TextStyle, type UIChildArg, type UIContainerBase, type UINodeChild, type ChildrenFn } from "./UINode";
 import { type WidgetHost, type WidgetSet } from "./UILayer";
-export type UIScreenStyle = ContainerStyle & DrawableStyle & PaddingStyle & BaseStyle;
+export type UIScreenStyle = ContainerStyle & DrawableStyle & PaddingStyle & BaseStyle & TextStyle;
 /** A screen — the root the router/host mounts, sized to its slot. A screen NEVER scrolls: it is
  *  fixed chrome (header, tab bar) plus, when the content overflows, one `UIScrollable` body child
  *  (`flexGrow: 1`). Scroll events and pull-to-refresh live on the scroll containers

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

@@ -9,8 +9,9 @@ export type UIVideoStyle = ElementStyle & DrawableStyle & {
  *  fullscreen-presentable (`open()`), with seamless promotion between the two. */
 export interface UIVideo extends UIElementBase<UIVideoStyle, DrawableStyle & BaseStyle> {
     readonly type: "video";
-    /** The player driving this surface (playback control lives on it). */
-    player: VideoPlayer;
+    /** The player driving this surface (playback control lives on it). Read-only: a surface is made
+     *  for its player (`UIVideo(player)`). */
+    readonly player: VideoPlayer;
     /** Show fullscreen as the current destination. Promotion: if this video is mounted in a screen,
      *  the SAME native player moves fullscreen — playback uninterrupted; a pop moves it back. */
     open(options?: PresentOptions): void;

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

@@ -23,7 +23,7 @@ export type PopOptions = {
  *  the router until `restore()`. */
 type Router = {
     /** The top of the router stack (not necessarily what's on screen — see `Presentable.current`). */
-    get current(): Presentable;
+    get current(): Presentable | null;
     /** Mount the router with `homePage` as the stack root — the app's navigation entry point. */
     init(homePage: Presentable, opts?: RouterOptions): void;
     /** Push a destination onto the stack — a `UIScreen`, a `Scene`, a `Scene2D`, a `NativeView`,

package/dist/types/version.d.ts

@@ -1,4 +1,4 @@
-export declare const SDK_VERSION = "2.2.11";
+export declare const SDK_VERSION = "2.2.13";
 /** The major of a semver string, or null when it is not one. */
 export declare const sdkMajor: (version: string | null | undefined) => number | null;
 /** The `// sdk: <version>` line of a compiled bundle's header (sdk/src/compile/header.ts), read from