lecodes-sdk 1.1.0 → 2.0.0

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

@@ -6,8 +6,9 @@ import type { WarpOptions } from "./Warp";
 import type { Node } from "../Node";
 /** How fast the character wants to go: the gait picks its clips and its speed. */
 export type Gait = "walk" | "run" | "sprint";
-/** What the engine shows: the idle, a start, the gait loop, a turn while moving, a stop, or a turn on the spot. */
-export type LocomotionState = "idle" | "start" | "move" | "turn" | "stop" | "spin";
+/** What the engine shows: the idle, a start, the gait loop, a turn while moving, a stop, a turn on the spot —
+ *  an ACTION (`act()`): a one-shot that owns the body until it hands over — or the STRAFE blend (`move({ strafe })`). */
+export type LocomotionState = "idle" | "start" | "move" | "turn" | "stop" | "spin" | "action" | "strafe";
 /** Who moves the body:
  *  `'hybrid'` (the default) — the clip's own recorded motion moves it; while the gait loop shows it
  *    is ADJUSTED toward what the simulation wants by at most `tuning.adjust` metres a second, and a
@@ -42,6 +43,10 @@ export type LocomotionSet = {
     turns?: LocomotionClip[];
     /** turns on the spot — what a facing still owed by a standing body plays */
     spins?: LocomotionClip[];
+    /** the STRAFE set: the same gait recorded forward, backward, to either side and on the diagonals — the members of
+     *  the directional blend `move(dir, { face, strafe: true })` shows. `angle` = the way a take travels in the body's
+     *  frame (degrees, + = left); left out, the engine reads it off the take's root. */
+    strafes?: LocomotionClip[];
 };
 /** The tuning. Times are seconds, speeds m/s, angles degrees. */
 export type LocomotionTuning = {
@@ -199,6 +204,8 @@ export declare class Locomotion extends Aspect<"loco", Node, LocomotionEvents> {
     private _mag;
     private _gait;
     private _seq;
+    private _act;
+    private _strafe;
     private readonly _in;
     private readonly _out;
     private readonly _names;
@@ -225,11 +232,60 @@ export declare class Locomotion extends Aspect<"loco", Node, LocomotionEvents> {
     /** State the movement intent for this frame: a world direction (its length is the stick's pull,
      *  clamped to 1) and the gait. `null` = no movement — the body stops, but it keeps facing where it
      *  was last asked to, and turns there on the spot if it still owes the turn.
-     *  `face` states a facing of its own (aiming, strafing, a camera-relative shooter). */
+     *  `face` states a facing of its own (aiming, a camera-relative shooter) — and with `strafe: true` the body MOVES
+     *  where the direction points while it faces there: the loop becomes the directional blend of `set.strafes` (a
+     *  guard, a lock-on), the facing is steered standing too, state `'strafe'`. Stated every frame like the rest. */
     move(direction: Vec3Like | null | undefined, options?: {
         gait?: Gait;
         face?: Vec3Like;
+        strafe?: boolean;
     }): void;
+    /** Play an ACTION: a one-shot that OWNS the body the way a start or a stop does — a roll, a backstep, a lunging
+     *  attack. Its recording moves the body alone (in every displacement mode but `'data'`, where the host does),
+     *  the steering and the selector stand by, and when it hands over the usual rules carry on: a direction held
+     *  starts (or, still carrying speed, runs on), nothing held stands.
+     *
+     *  `direction` is where its TRAVEL must go, world (`Vec3`, or a heading in degrees, 0 = +Z, + = toward +X). A
+     *  clip travels some way relative to the body — forward, left, back; measured off its own root, or `angle`
+     *  (degrees, + = left) — and the body is turned by what is left between that and `direction`, over `turn`
+     *  seconds (default 0.12), so the travel lands exactly where it was pointed. Which clip to play is yours to
+     *  pick: the one whose travel is nearest the direction IN THE BODY'S FRAME (`direction − facing`) leaves the
+     *  least to turn. Left out = it plays where the body faces.
+     *
+     *  `at` enters the clip that many seconds in (a wind-up skipped), `rate` plays it faster or slower (its metres
+     *  stay, the time changes), `travel` takes only that share of its recorded travel (an attack aimed at a target:
+     *  0.3 to stop at the blade's length from one that is close, 1.3 to reach one a step too far — the pose is
+     *  untouched, so keep it to a fast step; `{ share, at, after }` takes another share from clip time `at` on: a
+     *  swing's take travels on after its cut, into a body that stands at the blade's length), `dash` THROWS the body
+     *  `distance` metres along the action's direction on top of that, inside `time` seconds (default 0.12) from its first
+     *  step, eased out — the gap to a target closed in the wind-up, the blow struck from where it lands (scaling a take's
+     *  own step is a slide stretched over the whole swing), `fade` is the transition into it and `out` the one out of it (default: the tuning's
+     *  `blend`; an action ends in ITS stance, not the idle's, and a longer way out is what hides that), and `exit` is the
+     *  clip time from which a MOVE intent may take over — the cancel window: along the way the body faces at once, a
+     *  heading that needs a turn as soon as the body has slowed to where a start can answer; with nothing asked for it plays out, to
+     *  its end (an action ends in its own recovery, at rest), and the body then STANDS THE WAY THE ACTION LEFT IT:
+     *  the facing intent that outlives a released key is not a demand after an action — no turn on the spot.
+     *  WHEN an action may be asked for (out of another one, out of a start) is the caller's rule: this cuts into
+     *  whatever shows. `state` reads `'action'` while it does. False = no such clip. */
+    act(clip: string, options?: {
+        direction?: Vec3Like | number;
+        angle?: number;
+        turn?: number;
+        at?: number;
+        exit?: number;
+        fade?: number;
+        out?: number;
+        rate?: number;
+        travel?: number | {
+            share: number;
+            at: number;
+            after: number;
+        };
+        dash?: {
+            distance: number;
+            time?: number;
+        };
+    }): boolean;
     /** Face this way without moving — the facing intent on its own (`Vec3`, or a heading in degrees,
      *  0 = +Z, + = toward +X). A standing body turns to it on the spot. */
     face(direction: Vec3Like | number): void;

package/dist/types/gl/terrain/Terrain.d.ts

@@ -176,6 +176,14 @@ export declare class Terrain {
     heightAt(x: number, z: number): number;
     /** The drawn triangle's normal at a local (x, z) (unit Vec3, +Y up). */
     normalAt(x: number, z: number): Vec3;
+    /** The LAYER WEIGHTS at a local (x, z) — what the splat shader blends there: the control map read bilinearly
+     *  between its samples and normalised to sum 1 (`[1, 0, 0, 0]` where the map is empty, as the shader has
+     *  it). Index = the layer's in `layers`. Outside the grid the edge answers. This is how a game asks WHAT the
+     *  ground is under a point — footprints in the sand and none on the cobble, a footstep sound per layer, dust
+     *  by surface — and the blend is already in the numbers, so a transition is a fade and not a line. */
+    weightsAt(x: number, z: number): [number, number, number, number];
+    /** The heaviest layer's index at a local (x, z) — `weightsAt` when only "which one" is asked. */
+    layerAt(x: number, z: number): number;
     /** The smooth (vertex) normal at integer sample (ix, iz). */
     sampleNormal(ix: number, iz: number): Vec3;
     /** Extent in local metres: `[width, depth]`. */

package/dist/types/inject.d.ts

@@ -29,7 +29,7 @@ export { Bus, REVERB_PRESETS, type ReverbPreset, type ReverbParams, type EchoPar
 export { audio, type PlaySoundOptions, type SpatialOptions, type Rolloff, type AudioStats } from "./audio/audio";
 export { openFilePicker, files, type FileData } from "./runtime/files";
 export { share } from "./runtime/share";
-export { ClickEvent, TouchStartEvent, LongPressEvent } from "./runtime/touch";
+export { ClickEvent, TouchStartEvent, LongPressEvent, MouseEnterEvent } from "./runtime/touch";
 export { Scene2D } from "./g2/Scene2D";
 export { Node2D } from "./g2/Node2D";
 export { Camera2D } from "./g2/Camera2D";
@@ -55,7 +55,7 @@ export { cells, encodeCells, type CellsData } from "./g2/cells";
 export { CameraFollow } from "./g2/scenarios2d";
 export { UIScreen, type UIScreenStyle, UIRow, UIColumn, UIBox, type UIContainerStyle, UIText, type UITextStyle, UIButton, type UIButtonStyle, UIImage, type UIImageStyle, UIVideo, type UIVideoStyle, UIInput, UITextArea, type UIInputStyle, UIScrollable, type UIScrollableStyle, UIPager, type UIPagerStyle, UITabs, type UITabDef, defineTabs, type TabDef, type TabsHandle, UIWidget, type UIWidgetStyle, UIModal, type UIModalStyle, UIBottomSheet, type UIBottomSheetStyle, UIPopover, type UIPopoverStyle, UISpacer, type UISpacerStyle, UIVirtualizedList, Router, NativeView, type UINativeViewStyle, registerFont, __uiMap, __UIColumn, __UIRow, __UIBox, __UIButton, __UIScreen, __UIScrollable, __UIWidget, } from "./ui/UI";
 export { Presentable } from "./ui/UI";
-export type { PresentOptions, Transition, TransitionName, TransitionSpec, TransitionTransform } from "./ui/UI";
+export type { DismissOptions, PresentOptions, Transition, TransitionName, TransitionPose, TransitionSpec } from "./ui/UI";
 export type { UINode, UINodeChild } from "./ui/UINode";
 export { theme, type ThemeValues, type ThemeAccessors } from "./ui/theme";
 export { animate, type AnimateOptions, type AnimateValue, type AnimateOut } from "./animate/tween/animateValue";
@@ -65,25 +65,25 @@ export { type Animation } from "./animate/tween/Animation";
 export { type TweenMeta } from "./animate/tween/spec";
 export { type EasingInput } from "./animate/tween/easing";
 export { easeIn, easeOut, easeInOut } from "./animate/easings";
-export { QRScanner } from "./plugins/qr";
-export { CameraView, type CameraFacing } from "./plugins/camera";
-export { Geolocation, type GeoPosition, type GeoOptions, type GeoWatch } from "./plugins/geolocation";
-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/map";
-export { Push, type PushPayload, type PushStatus, type PushRegisterOptions, type PushEvent } from "./plugins/push";
+export { QRScanner } from "./plugins/gen/qr-scanner/sdk/qr-scanner";
+export { CameraView, type CameraFacing } from "./plugins/gen/camera/sdk/camera";
+export { Geolocation, type GeoPosition, type GeoOptions, type GeoWatch } from "./plugins/gen/geolocation/sdk/geolocation";
+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 { OAuth, type OAuthCredential, type OAuthProviderName } from "./plugins/oauth";
 export { Service } from "./plugins/service";
-export { defineScene, use, ref, make, SceneHandle, applyEditorPose as __applyEditorPose } from "./scene/defineScene";
-export { defineMaterial, MaterialHandle, assignMaterialDef as __assignMaterialDef, applyMaterialParam as __applyMaterialParam, } from "./scene/material";
+export { defineScene, use, ref, make, SceneHandle } from "./scene/defineScene";
+export { defineMaterial, MaterialHandle } from "./scene/material";
 export type { MaterialData, MaterialParamValue, ShaderMaterialDef, LitMaterialDef, UnlitMaterialDef } from "./scene/material";
 export type { SceneDef, SceneNodeDef, MeshDef, LightDef, MaterialDef, CameraNodeDef, AspectEntry, MakeEntry, LoadedScene, SceneInstance } from "./scene/defineScene";
 export { CameraPlace } from "./gl/CameraPlace";
 export { Level } from "./scene/level";
 export type { LevelSpot, LevelBuild, LevelCollider, LevelLineOptions, LevelGridOptions, LevelRingOptions, LevelScatterOptions, LevelPlaceOptions } from "./scene/level";
 export type { FieldMeta } from "./core/fields";
-export { Gizmos, GizmoBuffer as __GizmoBuffer, withGizmoScope as __withGizmoScope } from "./scene/gizmos";
+export { Gizmos } from "./scene/gizmos";
 export type { GizmoStyle, GizmoAnchor } from "./scene/gizmos";
 export { MoveTo, FollowPath, Spin, LookAt, PlayAnimation } from "./gl/scenarios";
-export { registerEditorWindow, registerEditorTool, __editorPlugins } from "./scene/editorPlugins";
+export { registerEditorWindow, registerEditorTool } from "./scene/editorPlugins";
 export type { EditorApi, EditorRayHit, EditorToolHooks, EditorWindowFn } from "./scene/editorPlugins";
 export { Scene, ARScene, VRScene } from "./gl/Scene";
 export { Node } from "./gl/Node";

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

@@ -0,0 +1 @@
+export { sceneEditor as __sceneEditor, type SceneEditorApi } from "./scene/editor";

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

@@ -25,6 +25,13 @@ export type NetLaunch = {
     port: number;
     maxClients: number;
 };
+/** Link statistics (`player.rtt` / `player.loss` read them): the bridge's `NetStats`. */
+export type NetStats = {
+    rtt: number;
+    loss: number;
+    sentKbps: number;
+    receivedKbps: number;
+};
 export declare const CH_RELIABLE = 0;
 export declare const CH_UNRELIABLE = 1;
 export declare const PROTO = 2;

package/dist/types/plugin.d.ts

@@ -0,0 +1,76 @@
+import { File as HostFile } from "./runtime/fetch";
+import { ServiceClient } from "./runtime/service";
+import { NativeViewElement } from "./ui/NativeView";
+export type { PresentOptions } from "./ui/presentable";
+export type { NativeView } from "./ui/NativeView";
+export type { FetchResponse } from "./runtime/fetch";
+/** 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). */
+export type f64 = number;
+/** Bytes that STAY in the host's buffer table: the native half hands over its bytes + a name, the
+ *  app gets the SDK's `File` handle (a texture source, a `FormData` value, a share) and the bytes
+ *  never enter the JS heap. For bytes the app must read itself, a contract says `Uint8Array`. */
+export type File = HostFile;
+/** Any JSON value, opaque to the generator (GeoJSON, a developer's own payload): it crosses as is
+ *  and the native half receives the platform's untyped value. */
+export type Json = null | boolean | number | string | Json[] | {
+    [key: string]: Json;
+};
+declare const channel: unique symbol;
+/** Marks a contract interface as a NativeView channel. `Name` is what the halves register under
+ *  (`registerView(name)`); `Params` is what a factory receives; `Events` maps an event's name to
+ *  its payload (`void` = no payload). */
+export interface View<Name extends string, Params extends object = {}, Events extends object = {}> {
+    readonly [channel]?: {
+        kind: "view";
+        name: Name;
+        params: Params;
+        events: Events;
+    };
+}
+/** Marks a contract interface as a headless Service channel — see {@link View}. */
+export interface Service<Name extends string, Params extends object = {}, Events extends object = {}> {
+    readonly [channel]?: {
+        kind: "service";
+        name: Name;
+        params: Params;
+        events: Events;
+    };
+}
+/** A listener of the event `K`: no argument for a `void` payload. */
+export type Listener<Events, K extends keyof Events> = Events[K] extends void ? () => void : (payload: Events[K]) => void;
+/** What an event's payload is read with when it is not on the wire what it is for the app (it
+ *  holds a File): by the event's name. */
+export type EventReaders = {
+    [event: string]: (wire: any) => any;
+};
+/** The element of a view plugin: a `NativeView` whose events are the contract's. Generated wrappers
+ *  extend it (`<Name>Base`); a hand-written one extends that, or this when its API is not the wire's. */
+export declare class ViewChannel<Events extends object = {}> extends NativeViewElement {
+    private readonly _readers;
+    constructor(iface: string, name: string, params: object, readers?: EventReaders);
+    /** Whether this host registered a view under `name` — at contract version `since` or later, when
+     *  one is given (a method's `@since`). */
+    static supports(name: string, since?: number): boolean;
+    on<K extends keyof Events & string>(event: K, callback: Listener<Events, K>): this;
+    off<K extends keyof Events & string>(event: K, callback: Listener<Events, K>): this;
+}
+/** The client of a service plugin: a session that opens on the first call, with the contract's
+ *  events. The service twin of {@link ViewChannel}. */
+export declare class ServiceChannel<Events extends object = {}> extends ServiceClient {
+    private readonly _readers;
+    constructor(iface: string, name: string, params?: object, readers?: EventReaders);
+    /** Whether this host registered a service under `name` — at contract version `since` or later,
+     *  when one is given (a method's `@since`). */
+    static supports(name: string, since?: number): boolean;
+    on<K extends keyof Events & string>(event: K, callback: Listener<Events, K>): this;
+    off<K extends keyof Events & string>(event: K, callback: Listener<Events, K>): this;
+}
+/** The text of a host buffer — what a bundled `asset()` is in a shell compile (`"id:N"`): the host
+ *  already holds the bytes. Empty when there is no such buffer. */
+export declare const bufferText: (systemId: number) => string;
+/** Prepare-then-present for a view that needs the camera: fail before any prompt on a host without
+ *  the view, ask for the permission while the current destination stays visible, give up when
+ *  another navigation superseded this one. Resolves when the view may open. */
+export declare const prepareCamera: (view: ViewChannel<any>) => Promise<void>;

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

@@ -0,0 +1,24 @@
+import { type File, type NativeView, type PresentOptions } from "../../../../plugin";
+import type { Facing } from "../contract";
+export type CameraFacing = Facing;
+export interface CameraView extends NativeView {
+    /** Request the camera permission, then present the preview. The current destination stays
+     *  visible until the camera is ready; rejects if the permission is denied, the host has no
+     *  camera, or another navigation superseded this one. */
+    open(options?: PresentOptions): Promise<void>;
+    /** Capture a still frame as an image `File` (host-encoded). */
+    takePhoto(): Promise<File>;
+    /** Switch between the front and the back camera while the preview is live. */
+    setFacingMode(facingMode: CameraFacing): Promise<void>;
+}
+/**
+ * Create a camera view (default: the back camera). `CameraView.isSupported` reports whether this
+ * host has the capability — check it before offering the feature.
+ */
+export declare const CameraView: {
+    (options?: {
+        facingMode?: CameraFacing;
+    }): CameraView;
+    /** Whether this host registered a "camera" view. */
+    readonly isSupported: boolean;
+};

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

@@ -0,0 +1,25 @@
+import { ViewChannel, type File } from "../../../../plugin";
+import type { CameraEvents, CameraParams, Facing } from "../contract";
+/** What the halves register under. */
+export declare const NAME = "camera";
+/** The contract's version: the highest `@since` of its members. */
+export declare const VERSION = 1;
+/** Capture a still frame as a JPEG.
+ *  Rejects with "failed". */
+export declare const takePhoto: (view: ViewChannel<CameraEvents>) => Promise<File>;
+/** Switch the camera while the preview is live. */
+export declare const setFacingMode: (view: ViewChannel<CameraEvents>, mode: Facing) => Promise<void>;
+/** A method of the contract. */
+export type Method = "takePhoto" | "setFacingMode";
+/** Whether this host has the view "camera" — 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;
+/** The view "camera" with the wire's methods as its own. */
+export declare class CameraViewBase extends ViewChannel<CameraEvents> {
+    constructor(params?: CameraParams);
+    /** Capture a still frame as a JPEG.
+     *  Rejects with "failed". */
+    takePhoto(): Promise<File>;
+    /** Switch the camera while the preview is live. */
+    setFacingMode(mode: Facing): Promise<void>;
+}

package/dist/types/plugins/{geolocation.d.ts → gen/geolocation/sdk/geolocation.d.ts}

@@ -1,23 +1,5 @@
-export interface GeoPosition {
-    latitude: number;
-    longitude: number;
-    /** Horizontal accuracy radius, meters. */
-    accuracy: number;
-    /** Meters above sea level, or null when the provider doesn't know. */
-    altitude: number | null;
-    /** Direction of travel in degrees clockwise from north, or null when stationary/unknown. */
-    heading: number | null;
-    /** Ground speed in m/s, or null when unknown. */
-    speed: number | null;
-    /** When this fix was taken, ms epoch. */
-    timestamp: number;
-}
-export interface GeoOptions {
-    /** Prefer the precise (GPS) provider — slower first fix, more battery. Default false. */
-    highAccuracy?: boolean;
-    /** getCurrent only: reject with "timeout" if no fix arrives in this many ms. */
-    timeout?: number;
-}
+import type { GeoOptions, GeoPosition } from "../contract";
+export type { GeoOptions, GeoPosition };
 /** A live `Geolocation.watch()` subscription — `stop()` it when the screen goes away. */
 export interface GeoWatch {
     stop(): void;

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

@@ -0,0 +1,31 @@
+import { ServiceChannel } from "../../../../plugin";
+import type { GeoOptions, GeoPosition, GeolocationEvents, GeolocationParams } from "../contract";
+/** What the halves register under. */
+export declare const NAME = "geolocation";
+/** The contract's version: the highest `@since` of its members. */
+export declare const VERSION = 1;
+/** One fix.
+ *  Rejects with "denied" / "unavailable" / "timeout". */
+export declare const getCurrent: (service: ServiceChannel<GeolocationEvents>, options?: GeoOptions) => Promise<GeoPosition>;
+/** Start the session's watch; resolves once it is live (permission granted, provider started).
+ *  A second call while watching resolves at once and keeps the first call's options.
+ *  Rejects with "denied" / "unavailable". */
+export declare const startWatch: (service: ServiceChannel<GeolocationEvents>, options?: GeoOptions) => Promise<void>;
+export declare const stopWatch: (service: ServiceChannel<GeolocationEvents>) => Promise<void>;
+/** A method of the contract. */
+export type Method = "getCurrent" | "startWatch" | "stopWatch";
+/** Whether this host has the service "geolocation" — 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;
+/** The service "geolocation" with the wire's methods as its own. */
+export declare class GeolocationBase extends ServiceChannel<GeolocationEvents> {
+    constructor(params?: GeolocationParams);
+    /** One fix.
+     *  Rejects with "denied" / "unavailable" / "timeout". */
+    getCurrent(options?: GeoOptions): Promise<GeoPosition>;
+    /** Start the session's watch; resolves once it is live (permission granted, provider started).
+     *  A second call while watching resolves at once and keeps the first call's options.
+     *  Rejects with "denied" / "unavailable". */
+    startWatch(options?: GeoOptions): Promise<void>;
+    stopWatch(): Promise<void>;
+}

package/dist/types/plugins/{map.d.ts → gen/map/sdk/map.d.ts}

@@ -1,5 +1,10 @@
-import { NativeView } from "../ui/NativeView";
-import type { FetchResponse } from "../runtime/fetch";
+import { type FetchResponse, type NativeView } from "../../../../plugin";
+import type { LngLat, MapCamera, MapCameraMove, MapFitOptions, MapPadding, MapParams, MapUserLocationOptions } from "../contract";
+export type { LngLat, MapCamera };
+export type CameraMove = MapCameraMove;
+export type FitOptions = MapFitOptions;
+export type MapPaddingValues = MapPadding;
+export type UserLocationOptions = MapUserLocationOptions;
 /** The ready-made styles a map falls back on — [OpenFreeMap](https://openfreemap.org): OSM data,
  *  no key, no registration, no request limits, commercial use allowed, and the whole stack is
  *  open-source if you'd rather self-host. `liberty` is the default. Credit them (and OSM) in your
@@ -27,32 +32,12 @@ export type MapStyleName = "liberty" | "bright" | "positron" | "dark" | "fiord";
  * relative urls until its `publicUrl` is configured.
  */
 export type MapStyle = MapStyleName | (string & {}) | FetchResponse | object;
-/** `[longitude, latitude]` — GeoJSON order, the same as the style, the tiles and your data. */
-export type LngLat = [number, number];
-export interface MapCamera {
-    center: LngLat;
-    zoom: number;
-    /** Degrees clockwise from north. */
-    bearing: number;
-    /** Degrees from the vertical. */
-    pitch: number;
-}
-export interface MapOptions {
+export interface MapOptions extends Omit<MapParams, "style" | "styleJson"> {
     /** The MapLibre style: a ready-made name (`"liberty"` — the default, `"positron"`, …), a URL,
      *  a style bundled with the app (`asset("./style.json")`), an already-read file
      *  (`fetchLocal("style.json")`, `await fetch(url)`) or the style object itself — see
      *  {@link MapStyle}. */
     style?: MapStyle;
-    center?: LngLat;
-    zoom?: number;
-    minZoom?: number;
-    maxZoom?: number;
-    bearing?: number;
-    pitch?: number;
-    /** Two-finger rotate gesture (default true). */
-    rotate?: boolean;
-    /** Two-finger tilt gesture (default false — most city maps stay flat). */
-    tilt?: boolean;
 }
 /** A tap on the map itself — not on a feature of a managed layer. */
 export interface MapTap {
@@ -60,26 +45,6 @@ export interface MapTap {
     /** View-space point, px. */
     point: [number, number];
 }
-export interface CameraMove {
-    zoom?: number;
-    bearing?: number;
-    pitch?: number;
-    /** Animation length, ms (flyTo only; default 600). */
-    duration?: number;
-}
-export interface MapPaddingValues {
-    top?: number | string;
-    left?: number | string;
-    bottom?: number | string;
-    right?: number | string;
-}
-export interface FitOptions {
-    /** Px around the points, or per edge. Added to the view padding set by `setPadding`. */
-    padding?: number | MapPaddingValues;
-    maxZoom?: number;
-    /** Default true. */
-    animate?: boolean;
-}
 /** One marker. `id` comes back in `onTap`; `icon` names an image of the style's sprite; `color` /
  *  `title` feed the default layers; extra keys become feature properties. */
 export interface MarkerItem {
@@ -111,12 +76,6 @@ export interface LineLayerOptions {
     /** 0–1 (default 1). */
     opacity?: number;
 }
-export interface UserLocationOptions {
-    /** Horizontal accuracy radius, meters — drawn as the halo around the dot. */
-    accuracy?: number | null;
-    /** Degrees clockwise from north — drawn as the direction wedge; null hides it. */
-    heading?: number | null;
-}
 export interface MarkerLayer {
     readonly name: string;
     /** Replace the layer's markers. */
@@ -165,7 +124,7 @@ export interface MapView extends NativeView {
 }
 /**
  * Create a map view. `MapView.isSupported` reports whether this host registered a "map" view —
- * check it before offering the feature (web, headless and shells without the plugin have none).
+ * check it before offering the feature.
  */
 export declare const MapView: {
     (options?: MapOptions): MapView;

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

@@ -0,0 +1,53 @@
+import { ViewChannel, type Json } from "../../../../plugin";
+import type { LngLat, MapCamera, MapCameraMove, MapEvents, MapFitOptions, MapLayerKind, MapLayerOptions, MapPadding, MapParams, MapUserLocationOptions } from "../contract";
+/** What the halves register under. */
+export declare const NAME = "map";
+/** The contract's version: the highest `@since` of its members. */
+export declare const VERSION = 1;
+/** Make sure the GeoJSON source `source` exists. A source the style declares is used as is (its
+ *  layers draw, only data flows); otherwise the half creates it with the default layers of `kind`.
+ *  Rejects with "notReady". */
+export declare const ensureLayer: (view: ViewChannel<MapEvents>, source: string, kind: MapLayerKind, options?: MapLayerOptions) => Promise<void>;
+export declare const removeLayer: (view: ViewChannel<MapEvents>, source: string) => Promise<void>;
+/** Replace the data of a GeoJSON source: a Feature or a FeatureCollection.
+ *  Rejects with "notReady". */
+export declare const setData: (view: ViewChannel<MapEvents>, source: string, geojson: Json) => Promise<void>;
+export declare const flyTo: (view: ViewChannel<MapEvents>, center: LngLat, options?: MapCameraMove) => Promise<void>;
+export declare const jumpTo: (view: ViewChannel<MapEvents>, center: LngLat, options?: MapCameraMove) => Promise<void>;
+/** Fit the camera to the points.
+ *  Rejects with "noPoints". */
+export declare const fitPoints: (view: ViewChannel<MapEvents>, points: LngLat[], options?: MapFitOptions) => Promise<void>;
+/** The part of the view covered by the app's UI; camera moves center inside the rest. */
+export declare const setPadding: (view: ViewChannel<MapEvents>, padding: MapPadding) => Promise<void>;
+/** Rejects with "notReady". */
+export declare const getCamera: (view: ViewChannel<MapEvents>) => Promise<MapCamera>;
+/** Move the user puck; null hides it. */
+export declare const setUserLocation: (view: ViewChannel<MapEvents>, lngLat: LngLat | null, options?: MapUserLocationOptions) => Promise<void>;
+/** A method of the contract. */
+export type Method = "ensureLayer" | "removeLayer" | "setData" | "flyTo" | "jumpTo" | "fitPoints" | "setPadding" | "getCamera" | "setUserLocation";
+/** Whether this host has the view "map" — 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;
+/** The view "map" with the wire's methods as its own. */
+export declare class MapViewBase extends ViewChannel<MapEvents> {
+    constructor(params?: MapParams);
+    /** Make sure the GeoJSON source `source` exists. A source the style declares is used as is (its
+     *  layers draw, only data flows); otherwise the half creates it with the default layers of `kind`.
+     *  Rejects with "notReady". */
+    ensureLayer(source: string, kind: MapLayerKind, options?: MapLayerOptions): Promise<void>;
+    removeLayer(source: string): Promise<void>;
+    /** Replace the data of a GeoJSON source: a Feature or a FeatureCollection.
+     *  Rejects with "notReady". */
+    setData(source: string, geojson: Json): Promise<void>;
+    flyTo(center: LngLat, options?: MapCameraMove): Promise<void>;
+    jumpTo(center: LngLat, options?: MapCameraMove): Promise<void>;
+    /** Fit the camera to the points.
+     *  Rejects with "noPoints". */
+    fitPoints(points: LngLat[], options?: MapFitOptions): Promise<void>;
+    /** The part of the view covered by the app's UI; camera moves center inside the rest. */
+    setPadding(padding: MapPadding): Promise<void>;
+    /** Rejects with "notReady". */
+    getCamera(): Promise<MapCamera>;
+    /** Move the user puck; null hides it. */
+    setUserLocation(lngLat: LngLat | null, options?: MapUserLocationOptions): Promise<void>;
+}

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

@@ -0,0 +1,23 @@
+import type { PushEvents, PushPayload, PushRegisterOptions, PushRegistration, PushStatus } from "../contract";
+export type { PushPayload, PushRegisterOptions, PushStatus };
+export type PushEvent = keyof PushEvents;
+/**
+ * Remote push notifications. `Push.isSupported` reports whether this host registered the
+ * service — check it before offering notification features.
+ */
+export declare const Push: {
+    /** Whether this host registered a "push" service. */
+    readonly isSupported: boolean;
+    /** Permission + registration state. Never prompts. */
+    getStatus(): Promise<PushStatus>;
+    /** Ask for permission (first time) and register this device → the opaque address your server
+     *  targets. Idempotent — safe to call every launch; rejects "denied" / "unavailable". */
+    register(options?: PushRegisterOptions): Promise<PushRegistration>;
+    /** Remove this device's registration (the address stops receiving). */
+    unregister(): Promise<void>;
+    /** The notification that cold-started this app run, or null. Stable across calls. */
+    getLaunch(): Promise<PushPayload | null>;
+    /** "message" = received while the app is open; "tap" = the user tapped one while it ran. */
+    addEventListener(event: PushEvent, callback: (payload: PushPayload) => void): void;
+    removeEventListener(event: PushEvent, callback: (payload: PushPayload) => void): void;
+};

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

@@ -0,0 +1,35 @@
+import { ServiceChannel } from "../../../../plugin";
+import type { PushEvents, 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;
+/** 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.
+ *  Rejects with "denied" / "unavailable". */
+export declare const register: (service: ServiceChannel<PushEvents>, options?: PushRegisterOptions) => Promise<PushRegistration>;
+/** Remove this device's registration.
+ *  Rejects with "unavailable". */
+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>;
+/** A method of the contract. */
+export type Method = "getStatus" | "register" | "unregister" | "getLaunch";
+/** 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;
+/** The service "push" with the wire's methods as its own. */
+export declare class PushBase extends ServiceChannel<PushEvents> {
+    constructor(params?: PushParams);
+    /** Permission + registration state. Never prompts. */
+    getStatus(): Promise<PushStatus>;
+    /** Ask for the permission (the first time) and register this device. Idempotent.
+     *  Rejects with "denied" / "unavailable". */
+    register(options?: PushRegisterOptions): Promise<PushRegistration>;
+    /** Remove this device's registration.
+     *  Rejects with "unavailable". */
+    unregister(): Promise<void>;
+    /** The notification that cold-started this world, or null. Stable across calls. */
+    getLaunch(): Promise<PushPayload | null>;
+}

package/dist/types/plugins/{qr.d.ts → gen/qr-scanner/sdk/qr-scanner.d.ts}

@@ -1,11 +1,10 @@
-import { type PresentOptions } from "../ui/presentable";
-import { NativeView } from "../ui/NativeView";
+import { type NativeView, type PresentOptions } from "../../../../plugin";
 export interface QRScanner extends NativeView {
     /** Fires per decoded camera frame: the decoded string, or `null` for a frame with no readable
      *  code (expect those repeatedly while the user aims). The same code can be reported more than
      *  once — `close()` or debounce once you have what you need. */
     onScan(callback: (data: string | null) => void): this;
-    /** Request camera permission, then present the scanner. The current destination (and its
+    /** Request the camera permission, then present the scanner. The current destination (and its
      *  loading state) stays visible until the scanner is ready; rejects if the camera is denied,
      *  the host can't scan, or another navigation superseded this one. */
     open(options?: PresentOptions): Promise<void>;

package/dist/types/plugins/gen/qr-scanner/sdk/qr-scanner.gen.d.ts

@@ -0,0 +1,15 @@
+import { ViewChannel } from "../../../../plugin";
+import type { QRScannerEvents, QRScannerParams } from "../contract";
+/** What the halves register under. */
+export declare const NAME = "qrScanner";
+/** The contract's version: the highest `@since` of its members. */
+export declare const VERSION = 1;
+/** A method of the contract. */
+export type Method = never;
+/** Whether this host has the view "qrScanner" — and, given a method, a half new enough for it
+ *  (a method added after the first version of the contract is tagged `@since`). */
+export declare const supports: (method?: Method) => boolean;
+/** The view "qrScanner" with the wire's methods as its own. */
+export declare class QRScannerBase extends ViewChannel<QRScannerEvents> {
+    constructor(params?: QRScannerParams);
+}