lecodes-sdk 2.2.11 → 2.2.14

package/dist/global.d.ts

@@ -173,6 +173,8 @@ declare global {
   const __channel: typeof SDK.__channel
   const __compOp: typeof SDK.__compOp
   const __compWrite: typeof SDK.__compWrite
+  const __pushChannel: typeof SDK.__pushChannel
+  const __pushEnable: typeof SDK.__pushEnable
   const __rpc: typeof SDK.__rpc
   const __serverOnly: typeof SDK.__serverOnly
   const __uiMap: typeof SDK.__uiMap
@@ -478,10 +480,14 @@ declare global {
   type Point = SDK.Point
   type PresentOptions = SDK.PresentOptions
   type Presentable = SDK.Presentable
+  type PushChannel<D extends Record<string, unknown> | undefined = undefined> = SDK.PushChannel<D>
   type PushEvent = SDK.PushEvent
+  type PushMessage<D> = SDK.PushMessage<D>
+  type PushNotification<D> = SDK.PushNotification<D>
   type PushPayload = SDK.PushPayload
   type PushRegisterOptions = SDK.PushRegisterOptions
   type PushStatus = SDK.PushStatus
+  type PushTarget = SDK.PushTarget
   type QRScanner = SDK.QRScanner
   type Quat = SDK.Quat
   type RTCConfiguration = SDK.RTCConfiguration
@@ -651,7 +657,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
@@ -672,10 +680,15 @@ declare global {
   const channel: typeof SERVER.channel
   const defineDb: typeof SERVER.defineDb
   const model: typeof SERVER.model
+  const pushChannel: typeof SERVER.pushChannel
   const ref: typeof SERVER.ref
   const request: typeof SERVER.request
   const t: typeof SERVER.t
   type ApiError = SERVER.ApiError
+  type PushChannel<D extends Record<string, unknown> | undefined = undefined> = SERVER.PushChannel<D>
+  type PushMessage<D> = SERVER.PushMessage<D>
+  type PushNotification<D> = SERVER.PushNotification<D>
+  type PushTarget = SERVER.PushTarget
   type StoredFile = SERVER.StoredFile
   type StoredImage = SERVER.StoredImage
 }

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";
@@ -22,9 +22,10 @@ export { device, type HapticStyle, type MotionOptions } from "./runtime/device";
 export { Input, InputChannel, type InputKeyEvent, type InputGamepadEvent, type InputEventName, type GamepadState, type GamepadAxisName } from "./runtime/input";
 export { WebSocket } from "./runtime/net";
 export { Net, NetPlayer, Replicated, NetEntity, type NetMessage, type NetRole, type NetStatus, type NetEvents, type NetLaunch, type NetInput, type NetKind, type NetTransform, type NetCorrection } from "./net";
-export { __rpc, __channel, __serverOnly, RpcError } from "./runtime/rpc";
+export { __rpc, __channel, __pushChannel, __serverOnly, RpcError } from "./runtime/rpc";
 export { resource, action, dataOf, failureOf, type Loaded, type Failure, type Resource, type Action } from "./runtime/resource";
 export type { ChannelSubscription } from "./server/channel";
+export type { PushChannel, PushMessage, PushNotification, PushTarget } from "./server/pushChannel";
 export type { StoredFile, StoredImage } from "./server/files/models";
 export { AudioPlayer, VideoPlayer } from "./runtime/media";
 export { Sound, type SoundOptions } from "./audio/Sound";
@@ -76,7 +77,7 @@ export { ARScene, Anchor, ImageAnchor, ARPlane, type ARSceneOptions, type AROpen
 export { AudioRecorder, type AudioRecorderEvents, type RecorderState, type RecordOptions, type Recording, type EndReason } from "./plugins/gen/audio-recorder/sdk/audio-recorder";
 export { SpeechRecognizer, type SpeechRecognizerEvents, type SpeechOptions, type SpeechResult, type SpeechErrorCode } from "./plugins/gen/speech/sdk/speech";
 export { MapView, type MapOptions, type MapStyle, type MapStyleName, type MapCamera, type MapTap, type LngLat, type CameraMove, type FitOptions, type MapPaddingValues, type MarkerItem, type MarkerTap, type MarkerLayer, type MarkerLayerOptions, type LineLayer, type LineLayerOptions, type UserLocationOptions, } from "./plugins/gen/map/sdk/map";
-export { Push, type PushPayload, type PushStatus, type PushRegisterOptions, type PushEvent } from "./plugins/gen/push/sdk/push";
+export { Push, __pushEnable, type PushPayload, type PushStatus, type PushRegisterOptions, type PushEvent } from "./plugins/gen/push/sdk/push";
 export { Browser, WebView, type BrowserOpenOptions, type WebViewParams, type WebViewEvents } from "./plugins/gen/browser/sdk/browser";
 export { RTCPeerConnection, MediaStream, MediaStreamTrack, RTCDataChannel, RTCRtpSender, RTCRtpReceiver, RTCRtpTransceiver, RTCSessionDescription, RTCIceCandidate, RTCEventTarget, mediaDevices, RTCVideoView, type RTCConfiguration, type RTCVideoViewOptions, type MediaStreamConstraints, type RTCIceCandidateInit, type RTCPeerConnectionIceEvent, type RTCTrackEvent, type RTCDataChannelEvent, type RTCMessageEvent, type RTCErrorEvent, type RTCEvent, type RTCEventListener, } from "./plugins/gen/webrtc/sdk/webrtc";
 export { Service } from "./plugins/service";

package/dist/types/plugin.d.ts

@@ -23,6 +23,9 @@ export { Quat, type QuatLike } from "./math/quat";
 export { Mat4 } from "./math/mat4";
 export type { ClickEvent, TouchStartEvent } from "./runtime/touch";
 export type { DismissOptions } from "./ui/presentable";
+/** The seam the push plugin's wrapper installs its runtime on (src/runtime/pushSeam.ts): what the app's transport
+ *  reads the device's address from, registers through, and a push channel's handlers are kept by. */
+export { _pushRuntime, type PushRuntime } from "./runtime/pushSeam";
 /** Signed 32-bit integer on the wire. */
 export type i32 = number;
 /** Double on the wire — also every integer that can leave 32 bits (a millisecond time stamp). */

package/dist/types/plugins/gen/push/sdk/push.d.ts

@@ -4,6 +4,11 @@ export type PushEvent = keyof PushEvents;
 /**
  * Remote push notifications. `Push.isSupported` reports whether this host registered the
  * service — check it before offering notification features.
+ *
+ * A project with a backend needs none of this: its `pushChannel()` exports are heard with their
+ * own `onTap` / `onMessage`, and the device is registered when the server asks (after a sign-in).
+ * `Push` is for the rest — a permission asked at a moment of the app's choosing, and the
+ * notifications sent outside a channel (a push key, `lecodes pn send`).
  */
 export declare const Push: {
     /** Whether this host registered a "push" service. */
@@ -15,9 +20,11 @@ export declare const Push: {
     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. */
+    /** The notifications sent outside a push channel: "tap" = tapped (the one that started the app
+     *  too); "message" = arrived while the app is open (the app shows it, the host no banner). */
     addEventListener(event: PushEvent, callback: (payload: PushPayload) => void): void;
     removeEventListener(event: PushEvent, callback: (payload: PushPayload) => void): void;
 };
+/** Installs the push runtime for the SDK's transport and its push-channel proxies (lecodes-sdk/plugin
+ *  `_pushRuntime`). A line of every server stub of a project with push channels — never app code. */
+export declare const __pushEnable: () => void;

package/dist/types/plugins/gen/push/sdk/push.gen.d.ts

@@ -1,9 +1,9 @@
 import { ServiceChannel } from "../../../../plugin";
-import type { PushEvents, PushParams, PushPayload, PushRegisterOptions, PushRegistration, PushStatus } from "../contract";
+import type { PushEvents, PushHandled, PushParams, PushPayload, PushRegisterOptions, PushRegistration, PushStatus } from "../contract";
 /** What the halves register under. */
 export declare const NAME = "push";
 /** The contract's version: the highest `@since` of its members. */
-export declare const VERSION = 1;
+export declare const VERSION = 2;
 /** Permission + registration state. Never prompts. */
 export declare const getStatus: (service: ServiceChannel<PushEvents>) => Promise<PushStatus>;
 /** Ask for the permission (the first time) and register this device. Idempotent.
@@ -14,8 +14,12 @@ export declare const register: (service: ServiceChannel<PushEvents>, options?: P
 export declare const unregister: (service: ServiceChannel<PushEvents>) => Promise<void>;
 /** The notification that cold-started this world, or null. Stable across calls. */
 export declare const getLaunch: (service: ServiceChannel<PushEvents>) => Promise<PushPayload | null>;
+/** Which notifications the app handles itself in the foreground; the rest get the system banner.
+ *  Until it is called nothing is handled.
+ *  Contract version 2: an older half rejects the call — ask `supports("setMessageHandled")`. */
+export declare const setMessageHandled: (service: ServiceChannel<PushEvents>, handled: PushHandled) => Promise<void>;
 /** A method of the contract. */
-export type Method = "getStatus" | "register" | "unregister" | "getLaunch";
+export type Method = "getStatus" | "register" | "unregister" | "getLaunch" | "setMessageHandled";
 /** Whether this host has the service "push" — and, given a method, a half new enough for it
  *  (a method added after the first version of the contract is tagged `@since`). */
 export declare const supports: (method?: Method) => boolean;
@@ -32,4 +36,8 @@ export declare class PushBase extends ServiceChannel<PushEvents> {
     unregister(): Promise<void>;
     /** The notification that cold-started this world, or null. Stable across calls. */
     getLaunch(): Promise<PushPayload | null>;
+    /** Which notifications the app handles itself in the foreground; the rest get the system banner.
+     *  Until it is called nothing is handled.
+     *  Contract version 2: an older half rejects the call — ask `supports("setMessageHandled")`. */
+    setMessageHandled(handled: PushHandled): Promise<void>;
 }

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/pushSeam.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The seam between the app's transport (./rpc.ts) and the push plugin's wrapper (src/plugins/gen/push/sdk/push.ts).
+ *
+ * A push channel (`pushChannel()` of a *.server.ts file — src/server/pushChannel.ts) is heard in the app through
+ * the plugin: its taps and foreground arrivals come off the plugin's service. The transport, for its part, tells
+ * the server the device's address (the `x-lecodes-push` header of every call) and registers the device when the
+ * server asks for it (the envelope's `push: true`). Neither may import the wrapper: an app without push channels
+ * would then carry the plugin. So the wrapper installs itself here — `__pushEnable()`, a line the compiler puts at
+ * the top of every server stub of a project with push channels — and the transport reads what is installed.
+ */
+export type PushRuntime = {
+    /** This device's address for the app, once known (after a registration, or the status of an earlier one). */
+    address(): string | null;
+    /** The server asked this device to register: once per run, prompt-free when the permission was given,
+     *  nothing past a refusal. */
+    requestRegister(): void;
+    /** Hear the taps ("tap") or the foreground arrivals ("message") of one push channel, by its id. Returns the remover. */
+    on(kind: "tap" | "message", channel: string, handler: (payload: any) => void): () => void;
+};
+/** What the wrapper installed; null = the app has no push channels (or the plugin is not in the bundle). */
+export declare const _pushRuntime: {
+    current: PushRuntime | null;
+};

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

@@ -8,7 +8,8 @@
  *   export const db        = __serverOnly("schema.server.ts#db")
  *
  * Wire (implemented by the runner):
- *   POST <serverUrl>/api/<id>   body {"args":[…]}, `authorization: Bearer <session>` when known
+ *   POST <serverUrl>/api/<id>   body {"args":[…]}, `authorization: Bearer <session>` when known,
+ *                               `x-lecodes-push: <address>` once the device registered for notifications
  *                               — with a `File` among the arguments: multipart, the field `args` is
  *                               that JSON with `{"$file": <i>}` where the file stood, `file<i>` the files
  *   → 200 {"ok":true,"result":…,"session"?:"…"} | {"ok":false,"status":n,"message":"…","session"?:"…"}
@@ -38,3 +39,16 @@ export declare const __channel: (serverUrl: string, id: string) => {
     subscribe(...all: unknown[]): ChannelSubscription;
     publish(): never;
 };
+/**
+ * Build the client proxy of push channel `id` — what a `pushChannel()` export of a `*.server.ts` file is
+ * in the app (its type is the server's: src/server/pushChannel.ts). The notifications come off the push
+ * plugin, through the runtime its wrapper installed (`__pushEnable()`, the first line of the stubs of a
+ * project with push channels — ./pushSeam.ts): `onTap` hears this channel's taps (the one that started
+ * the app included), `onMessage` its arrivals while the app is in the foreground. On a host without the
+ * plugin a handler is recorded and never called, like the plugin's own listeners.
+ */
+export declare const __pushChannel: (serverUrl: string, id: string) => {
+    onTap: (handler: unknown) => ChannelSubscription;
+    onMessage: (handler: unknown) => ChannelSubscription;
+    send(): never;
+};

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/auth/models.d.ts

@@ -1,7 +1,8 @@
 /**
  * The two models sign-in adds to a database — `defineDb({...}).withAuth({ model: "User" })`:
  *
- *   Session   one device: the hash of its token, and the user it is signed in as (none = a guest)
+ *   Session   one device: the hash of its token, the user it is signed in as (none = a guest), and the
+ *             device's push address when it told one (what a push channel's `send` reaches the user by)
  *   Identity  one way a user signs in: `email:<address>` or `login:<name>` (with the password's hash
  *             when one is set) — several per user.
  *
@@ -85,6 +86,17 @@ export declare const sessionFields: (userModel: string) => {
         isId: false;
         model: "";
     }>;
+    /** The device's address at the platform's push relay (`x-lecodes-push` of its calls) — the session's own
+     *  secret, like the token: never read back by a project (../push/host.ts sends by it). */
+    pushAddress: import("../db").Field<string, {
+        kind: "scalar";
+        scalar: "string";
+        optional: true;
+        hasDefault: false;
+        array: false;
+        isId: false;
+        model: "";
+    }>;
     user: import("../db").Field<never, {
         kind: "one";
         scalar: "";

package/dist/types/server/auth/types.d.ts

@@ -11,6 +11,8 @@ import type { RequestContext } from "../context";
 export type AuthState = {
     sessionId: number;
     userId: number | null;
+    /** The push address of the device, as the session holds it after this request's header was read (null = none). */
+    pushAddress?: string | null;
     /** A token to hand back to the client in this response (a new guest session, or a rotation). */
     issuedToken?: string;
 };

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/server/inject.d.ts

@@ -1,6 +1,7 @@
 export { t, model, defineDb, ref } from "./db";
 export { ApiError } from "./errors";
 export { channel } from "./channel";
+export { pushChannel, type PushChannel, type PushMessage, type PushNotification, type PushTarget } from "./pushChannel";
 export { request } from "./context";
 export type { StoredFile, StoredImage } from "./files/models";
 /** The value an SVG source is to the client (`assetIcon(…)` compiles to `SvgSource(…)`): a shared module of

package/dist/types/server/pushChannel.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Push channels: the server's notifications to a person's devices — the twin of ./channel.ts for what
+ * reaches someone while the app is closed. One export types both sides:
+ *
+ *   export const orderShippedPushChannel = pushChannel<{ orderId: number }>()         // pushes.server.ts
+ *
+ *   await orderShippedPushChannel.send(order.owner, { title: "Order shipped", data: { orderId } })   // server
+ *
+ *   orderShippedPushChannel.onTap(({ data }) => Router.push(OrderScreen(data.orderId)))             // app
+ *   orderShippedPushChannel.onMessage(({ title }) => toast(title))
+ *
+ * `send` reaches every device the user is signed in on. The devices are the sessions of the project's db
+ * with sign-in (`defineDb(...).withAuth(...)`): a session carries the address of its device — the app's
+ * transport tells it with every call, and the server asks the device to register when a signed-in
+ * session has none (the first response after a sign-in; the OS asks the permission then) — and a
+ * sign-out leaves the device on a guest session, which no `send` reaches. A user with no device is zero
+ * sends, not an error. `send` needs no request: a timer may call it.
+ *
+ * The server holds no push key: the host sends through the platform (./push/host.ts), reached here over
+ * the `globalThis.__lecodesPushSend` seam (the compiled bundle carries its own SDK copy — ./context.ts).
+ * A channel's identity is its export (`<path>#<name>`), assigned when the bundle is loaded
+ * (`loadServerModules`), and it travels in the notification: the app's side hears each channel's own.
+ *
+ * In the app the export is another object — the proxy `__pushChannel` of src/runtime/rpc.ts — which is
+ * why `onTap` / `onMessage` here only throw.
+ */
+import type { ChannelSubscription } from "./channel";
+export type { ChannelSubscription };
+/** Whom a notification goes to: a user id, or a row that has one (`db.auth.requireUser().select({ id: true })`, a relation). */
+export type PushTarget = number | {
+    id: number;
+};
+/** What a notification shows, and what it carries for the app (`data`, the channel's type). */
+export type PushMessage<D> = {
+    /** Up to 200 characters. */
+    title: string;
+    /** The second line, up to 1000 characters. */
+    body?: string;
+    /** A link for the app to open on a tap (`onTap` gets it — it is not opened by itself). */
+    url?: string;
+    /** The number on the app's icon (iOS; 0 clears it). */
+    badge?: number;
+} & (undefined extends D ? {
+    data?: D;
+} : {
+    data: D;
+});
+/** A notification as the app receives it: what was sent, and the channel it came through. */
+export type PushNotification<D> = PushMessage<D> & {
+    channel: string;
+};
+export interface PushChannel<D extends Record<string, unknown> | undefined = undefined> {
+    /** Server: send `message` to every device `user` is signed in on (one id or several). Answers how many
+     *  devices it went to — none is 0, not an error. */
+    send(user: PushTarget | PushTarget[], message: PushMessage<D>): Promise<{
+        sent: number;
+    }>;
+    /** App: a notification of this channel was tapped — while the app ran, or to start it. Lives until `close()`. */
+    onTap(handler: (notification: PushNotification<D>) => void): ChannelSubscription;
+    /** App: a notification of this channel arrived while the app was in the foreground: the app shows it
+     *  (the host shows no banner); a channel without this handler gets the system banner. */
+    onMessage(handler: (notification: PushNotification<D>) => void): ChannelSubscription;
+}
+/** What the host reads of a push channel (src/server/runtime.ts). */
+export type PushChannelRecord = {
+    /** set by the runtime: `<path>#<export>` */
+    __id: string | null;
+    readonly __pushChannel: true;
+};
+/** The host's sender (./push/host.ts): the channel, the users' ids, the message → how many devices. */
+export type PushSender = (channelId: string, userIds: number[], message: PushMessage<any>) => Promise<{
+    sent: number;
+}>;
+/** Host hook (runner / local backend / test harness): where `send` delivers to. */
+export declare const setPushSender: (sender: PushSender | null) => void;
+/** The ids of `send`'s first argument, each once; throws on what is not a user. */
+export declare const pushTargetIds: (user: unknown) => number[];
+export declare const pushChannel: <D extends Record<string, unknown> | undefined = undefined>() => PushChannel<D>;
+export declare const isPushChannel: (v: unknown) => v is PushChannelRecord;

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;
@@ -138,7 +138,7 @@ export type ElementStyle = PaddingStyle & MarginStyle & BaseStyle & PositionStyl
     flex?: number | string;
     flexGrow?: number;
     flexShrink?: number;
-    flexBase?: UIValue | `${number}%` | "auto";
+    flexBasis?: UIValue | `${number}%` | "auto";
     alignSelf?: "flex-start" | "center" | "flex-end" | "stretch";
     display?: "none" | "flex";
 };