lecodes-sdk 0.19.0

package/dist/types/inject.d.ts

@@ -0,0 +1,123 @@
+export { Mathf } from "./math/Mathf";
+export { Vec2, Vec3 } from "./math/vec";
+export { Quat } from "./math/quat";
+export { Mat4 } from "./math/mat4";
+export { Color } from "./core/color";
+export { Aspect, System, type With, type SystemHost } from "./core/Aspect";
+export { type EventMap } from "./core/events";
+export { Time } from "./core/time";
+export { StateMachine, defineStates, type StateDef, type StatesDef, type StateGuard, type StateHandler, type StateMachineEvents } from "./core/StateMachine";
+export { InspectorUI } from "./core/InspectorUI";
+export { signal, computed, effect, type Signal, type Computed } from "./core/signals";
+export { __compWrite, __compOp, type CompAxis, type CompWriter } from "./core/compWrite";
+export { Canvas, Bitmap } from "./canvas/Canvas";
+export { toast, openURL, SvgSource } from "./runtime/misc";
+export { app, type AppState, type OrientationLock } from "./runtime/app";
+export { clipboard } from "./runtime/clipboard";
+export { date, type DateValue, type DateInput, type Unit, type Locale } from "./runtime/datetime";
+export { fetch, fetchLocal, FormData, File, type FetchResponse } from "./runtime/fetch";
+export { localStorage } from "./runtime/storage";
+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 } from "./net";
+export { __rpc, __channel, __serverOnly, RpcError, type ClientChannel } from "./runtime/rpc";
+export { AudioPlayer, VideoPlayer } from "./runtime/media";
+export { openFilePicker, files, type FileData } from "./runtime/files";
+export { share } from "./runtime/share";
+export { ClickEvent, TouchStartEvent, LongPressEvent } from "./runtime/touch";
+export { Scene2D } from "./g2/Scene2D";
+export { Node2D } from "./g2/Node2D";
+export { Camera2D } from "./g2/Camera2D";
+export { Sprite } from "./g2/Sprite";
+export { SpriteAnimation } from "./g2/SpriteAnimation";
+export { Shape2D } from "./g2/Shape2D";
+export { Physics2D } from "./g2/Physics2D";
+export { Trigger2D } from "./g2/Trigger2D";
+export { CharacterController2D } from "./g2/CharacterController2D";
+export { OneWay2D } from "./g2/OneWay2D";
+export { PhysicsGroup2D } from "./g2/groups2d";
+export { Tilemap } from "./g2/Tilemap";
+export { Texture2D } from "./g2/Texture2D";
+export { SpriteSheet, defineSpriteSheet } from "./g2/SpriteSheet";
+export type { SpriteSheetDef, SheetSprite, SpriteMakeOptions } from "./g2/SpriteSheet";
+export { Tileset, defineTileset, Autotile2D } from "./g2/Tileset";
+export { rawCell, isRawCell, rawIndex } from "./g2/autotile";
+export { rot90, rot180, rot270, flipX, packTile, tileIndex, tileTurns, tileFlip, tileOriented } from "./g2/autotile";
+export type { TilesetDef, TileMaterial, PatchMaterial, PathMaterial, PatchSlots, EdgeSlot, FillBlock, BlockEntry, TileBlock, TilePart, } from "./g2/autotile";
+export { defineScene2d, Scene2dHandle } from "./g2/defineScene2d";
+export type { Scene2dDef, Scene2dNodeDef, Scene2dEnv, SpriteSourceDef, TilemapSourceDef, Camera2dNodeDef, LoadedScene2d } from "./g2/defineScene2d";
+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 { UINode, UINodeChild } from "./ui/UINode";
+export { theme, type ThemeValues, type ThemeAccessors } from "./ui/theme";
+export { animate, animateMat4, stopAnimation, pauseAnimation, resumeAnimation } from "./animate/animate";
+export { cubicBezier } from "./animate/bezier";
+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 { Push, type PushPayload, type PushStatus, type PushRegisterOptions, type PushEvent } from "./plugins/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 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 type { GizmoStyle, GizmoAnchor } from "./scene/gizmos";
+export { MoveTo, FollowPath, Spin, LookAt, PlayAnimation } from "./gl/scenarios";
+export { registerEditorWindow, registerEditorTool, __editorPlugins } from "./scene/editorPlugins";
+export type { EditorApi, EditorRayHit, EditorToolHooks, EditorWindowFn } from "./scene/editorPlugins";
+export { Scene, ARScene, VRScene } from "./gl/Scene";
+export { Node } from "./gl/Node";
+export { Mesh } from "./gl/Mesh";
+export { Model } from "./gl/Model";
+export { Shape } from "./gl/Shape";
+export { Physics } from "./gl/Physics";
+export { Trigger } from "./gl/Trigger";
+export { CharacterController } from "./gl/CharacterController";
+export { Vehicle } from "./gl/Vehicle";
+export type { DriveLayout, DifferentialMode, EngineConfig, SteeringConfig, AeroConfig } from "./gl/Vehicle";
+export { Wheel } from "./gl/Wheel";
+export { Ragdoll } from "./gl/Ragdoll";
+export type { RagdollPart, RagdollHinge } from "./gl/Ragdoll";
+export type { TireCurve, WheelSuspension, WheelTire, WheelVisual } from "./gl/Wheel";
+export { Gearbox } from "./gl/Gearbox";
+export { AnimationClip } from "./gl/animation/AnimationClip";
+export type { ClipDef, ClipTrackDef, ClipKey } from "./gl/animation/AnimationClip";
+export { Animator } from "./gl/animation/Animator";
+export type { WarpOptions, FeetOptions, FootState } from "./gl/animation/Animator";
+export { Playback } from "./gl/animation/Playback";
+export { Loop } from "./gl/animation/Loop";
+export { Layer } from "./gl/animation/Layer";
+export type { PlayOptions, StopOptions, LayerOptions, LoopOptions, LoopDef, BlendPosition, ActiveClip } from "./gl/animation/core";
+export { IK } from "./gl/IK";
+export type { IKTwoBone, IKLookAt } from "./gl/IK";
+export { Light } from "./gl/Light";
+export { Lightmap } from "./gl/Lightmap";
+export { Terrain } from "./gl/Terrain";
+export type { TerrainOptions, TerrainLayer, TerrainRegion, ConformOptions, RibbonOptions, AutoPaintRules, SculptOptions, TerrainHit, TerrainSnapshot } from "./gl/Terrain";
+export { NavMesh, NavCrowd } from "./gl/NavMesh";
+export type { NavMeshLoadOptions, NavMeshInfo, NavPath, NavQueryOptions, NavRaycastHit, NavAgentSize } from "./gl/NavMesh";
+export { NavAgent } from "./gl/NavAgent";
+export type { NavAgentState, NavAgentAvoidance, NavAgentDrive, NavAgentEvents } from "./gl/NavAgent";
+export { Locomotion } from "./gl/Locomotion";
+export type { LocomotionSet, LocomotionClip, LocomotionTuning, LocomotionState, LocomotionEvents, Displacement, Gait } from "./gl/Locomotion";
+export { Material } from "./gl/Material";
+export { Geometry } from "./gl/Geometry";
+export { InstancedMesh } from "./gl/InstancedMesh";
+export type { InstanceTransform } from "./gl/InstancedMesh";
+export { Texture } from "./gl/Texture";
+export { Camera } from "./gl/Camera";
+export { Ray } from "./gl/Ray";
+export { Plane } from "./gl/Plane";
+export { Noise } from "./gl/Noise";
+export { Particles, Trail, curve, colorCurve } from "./gl/Particles";

package/dist/types/math/Mathf.d.ts

@@ -0,0 +1,39 @@
+export type Damper<T extends number | number[]> = ((target: T, dt: number) => T) & {
+    /** Snap the damper's internal current value (e.g. on teleport). */
+    setValue(value: T): void;
+};
+declare function smoothDamp(initial: number, smoothTime: number, maxSpeed?: number): Damper<number>;
+declare function smoothDamp(initial: number[], smoothTime: number, maxSpeed?: number): Damper<number[]>;
+export declare const Mathf: {
+    PI: number;
+    TAU: number;
+    EPSILON: number;
+    DEG2RAD: number;
+    RAD2DEG: number;
+    deg2rad: (deg: number) => number;
+    rad2deg: (rad: number) => number;
+    clamp: (v: number, min: number, max: number) => number;
+    clamp01: (v: number) => number;
+    lerp: (a: number, b: number, t: number) => number;
+    inverseLerp: (a: number, b: number, v: number) => number;
+    remap: (v: number, inMin: number, inMax: number, outMin: number, outMax: number) => number;
+    /** Move `a` toward `b` by at most `maxDelta`. */
+    moveTowards: (a: number, b: number, maxDelta: number) => number;
+    /** Frame-rate-independent exponential approach (good default: lambda 5..15). */
+    damp: (a: number, b: number, lambda: number, dt: number) => number;
+    sign: (x: number) => number;
+    /** Loop a value into [0, length). */
+    repeat: (t: number, length: number) => number;
+    /** Ping-pong a value in [0, length]. */
+    pingPong: (t: number, length: number) => number;
+    random: (min?: number, max?: number) => number;
+    randomInt: (min: number, max: number) => number;
+    /**
+     * Critically-damped follow (Unity SmoothDamp). Returns a stateful damper you call every frame:
+     *   const d = Mathf.smoothDamp([x, y], 0.15)
+     *   pos = d(targetPos, dt)
+     * Works on a number or a numeric array (vec2 / vec3).
+     */
+    smoothDamp: typeof smoothDamp;
+};
+export {};

package/dist/types/math/mat4.d.ts

@@ -0,0 +1,66 @@
+import { Vec3, type Vec3Like } from "./vec";
+import { Quat, type QuatLike, type EulerOrder } from "./quat";
+export type Mat4Like = Mat4 | number[] | Float32Array | readonly number[];
+export declare class Mat4 {
+    /** The raw column-major elements (length 16). Public on purpose — read/write directly when you want
+     *  the metal: `mat.m[12] += vx * dt`. The fluent methods never mutate it (they return a new Mat4). */
+    m: number[];
+    constructor(src?: Mat4Like);
+    set(values: ArrayLike<number>): this;
+    copy(src: Mat4Like): this;
+    /** `this · b` (apply `b` first in local space, then `this`). */
+    mul(b: Mat4Like): Mat4;
+    /** `b · this` — multiply on the other side (apply `this` first, then `b`). */
+    premul(b: Mat4Like): Mat4;
+    invert(): Mat4;
+    transpose(): Mat4;
+    determinant(): number;
+    /** `this · translate(v)`. */
+    translate(v: Vec3Like): Mat4;
+    /** `this · scale(v)`. Accepts a vector or a uniform scalar. */
+    scale(v: Vec3Like | number): Mat4;
+    /** `this · rotate(axis, rad)`. */
+    rotate(rad: number, axis: Vec3Like): Mat4;
+    rotateX(rad: number): Mat4;
+    rotateY(rad: number): Mat4;
+    rotateZ(rad: number): Mat4;
+    /** Transform a point (applies translation + perspective divide). */
+    transformPoint(v: Vec3Like): Vec3;
+    /** Transform a direction (rotation/scale only — no translation, no divide). */
+    transformDirection(v: Vec3Like): Vec3;
+    get position(): Vec3;
+    get scaling(): Vec3;
+    get rotation(): Quat;
+    get eulerAngles(): Vec3;
+    toEuler(order?: EulerOrder): Vec3;
+    /** `{ position, rotation, scale }` in one shot. */
+    decompose(): {
+        position: Vec3;
+        rotation: Quat;
+        scale: Vec3;
+    };
+    /** Column basis vectors (the local X / Y / Z axes in world space). */
+    get basisX(): Vec3;
+    get basisY(): Vec3;
+    get basisZ(): Vec3;
+    clone(): Mat4;
+    toArray(): number[];
+    toFloat32Array(): Float32Array;
+    equals(b: Mat4Like, eps?: number): boolean;
+    static identity(): Mat4;
+    static from(src: Mat4Like): Mat4;
+    /** Translation · Rotation · Scale into one matrix. `scale` defaults to 1 and accepts a scalar. */
+    static compose(position: Vec3Like, rotation: QuatLike, scale?: Vec3Like | number): Mat4;
+    static fromQuat(q: QuatLike): Mat4;
+    static fromTranslation(v: Vec3Like): Mat4;
+    static fromScale(v: Vec3Like | number): Mat4;
+    static fromEuler(x: number, y: number, z: number, order?: EulerOrder): Mat4;
+    /** A view matrix that looks from `eye` toward `center` with `up`. */
+    static lookAt(eye: Vec3Like, center: Vec3Like, up?: Vec3Like): Mat4;
+    /** A world matrix that places something at `eye` oriented to look at `target`. */
+    static targetTo(eye: Vec3Like, target: Vec3Like, up?: Vec3Like): Mat4;
+    /** Perspective projection (WebGL/OpenGL clip, NDC z ∈ [−1, 1]). `fovy` is in RADIANS. */
+    static perspective(fovy: number, aspect: number, near: number, far: number): Mat4;
+    /** Orthographic projection (WebGL/OpenGL clip, NDC z ∈ [−1, 1]). */
+    static ortho(left: number, right: number, bottom: number, top: number, near: number, far: number): Mat4;
+}

package/dist/types/math/quat.d.ts

@@ -0,0 +1,53 @@
+import { Vec3, type Vec3Like } from "./vec";
+export type QuatLike = Quat | readonly [number, number, number, number] | number[] | Float32Array;
+export type EulerOrder = "XYZ" | "YXZ" | "ZXY" | "ZYX" | "YZX" | "XZY";
+/** Read the w / 4th component of any quaternion-like (wrapper `.w`, or array-like `[3]`). */
+export declare const cw: (q: {
+    w?: number;
+} | ArrayLike<number>) => number;
+export declare class Quat {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+    constructor(x?: number | QuatLike, y?: number, z?: number, w?: number);
+    set(x: number, y: number, z: number, w: number): this;
+    copy(q: QuatLike): this;
+    /** Hamilton product `this ⊗ b` (apply `b` first, then `this`). */
+    mul(b: QuatLike): Quat;
+    normalize(): Quat;
+    conjugate(): Quat;
+    /** Inverse rotation. For a unit quaternion this equals `conjugate()`. */
+    invert(): Quat;
+    dot(b: QuatLike): number;
+    /** Spherical interpolation toward `b` by `t ∈ [0, 1]`. */
+    slerp(b: QuatLike, t: number): Quat;
+    /** Angular distance (radians) between two unit quaternions. */
+    angle(b: QuatLike): number;
+    /** Rotate a vector by this quaternion → a new `Vec3`. */
+    rotateVec3(v: Vec3Like): Vec3;
+    /** Extract euler angles (DEGREES) in the given order. */
+    toEuler(order?: EulerOrder): Vec3;
+    equals(b: QuatLike, eps?: number): boolean;
+    /** True if the two unit quaternions represent the same rotation (±q are equal). */
+    sameRotation(b: QuatLike, eps?: number): boolean;
+    clone(): Quat;
+    toArray(): [number, number, number, number];
+    [Symbol.iterator](): Iterator<number>;
+    static from(q: QuatLike): Quat;
+    static get identity(): Quat;
+    /** From euler angles in DEGREES (default order "YXZ"). Inverts `toEuler`. */
+    static fromEuler(x: number, y: number, z: number, order?: EulerOrder): Quat;
+    /** From a rotation `axis` and an angle in RADIANS. The axis is normalized for you. */
+    static fromAxisAngle(axis: Vec3Like, rad: number): Quat;
+    /** The shortest rotation that takes direction `a` onto direction `b`. */
+    static fromTo(a: Vec3Like, b: Vec3Like): Quat;
+    /** A rotation whose forward (−Z) points along `forward`, with `up` as the reference up axis. */
+    static lookRotation(forward: Vec3Like, up?: Vec3Like): Quat;
+}
+/** Quaternion from a column-major rotation matrix (≥3×3, indices 0,1,2,4,5,6,8,9,10). gl-matrix's
+ *  `getRotation` algorithm — the exact inverse of building a matrix from a quaternion. */
+export declare const quatFromColMajor: (m: ArrayLike<number>) => Quat;
+/** Euler angles (DEGREES) from a column-major rotation matrix, standard three.js extraction.
+ *  Element naming follows the column-major layout: mRC = m[(C-1)*4 + (R-1)]. */
+export declare const eulerFromColMajor: (m: ArrayLike<number>, order?: EulerOrder) => Vec3;

package/dist/types/math/vec.d.ts

@@ -0,0 +1,129 @@
+export type Vec2Like = Vec2 | readonly [number, number] | number[] | Float32Array;
+export type Vec3Like = Vec3 | readonly [number, number, number] | number[] | Float32Array;
+/** Read the x / first component of any vector-like (wrapper, tuple, or typed array). `?? ` is safe on
+ *  0 and NaN — it only falls through on `undefined` (i.e. a non-wrapper that has no `.x`). */
+export declare const cx: (v: {
+    x?: number;
+} | ArrayLike<number>) => number;
+export declare const cy: (v: {
+    y?: number;
+} | ArrayLike<number>) => number;
+export declare const cz: (v: {
+    z?: number;
+} | ArrayLike<number>) => number;
+export declare class Vec2 {
+    x: number;
+    y: number;
+    constructor(x?: number | Vec2Like, y?: number);
+    /** Mutate the components in place. Returns `this`. */
+    set(x: number, y: number): this;
+    /** Copy another vector's components into this one. Returns `this`. */
+    copy(v: Vec2Like): this;
+    add(v: Vec2Like): Vec2;
+    sub(v: Vec2Like): Vec2;
+    mul(v: Vec2Like): Vec2;
+    div(v: Vec2Like): Vec2;
+    scale(s: number): Vec2;
+    /** `this + v * s` (fused multiply-add). */
+    scaleAndAdd(v: Vec2Like, s: number): Vec2;
+    negate(): Vec2;
+    dot(v: Vec2Like): number;
+    /** 2D cross product → the scalar z of the 3D cross (signed parallelogram area). */
+    cross(v: Vec2Like): number;
+    length(): number;
+    lengthSq(): number;
+    distanceTo(v: Vec2Like): number;
+    distanceSqTo(v: Vec2Like): number;
+    normalize(): Vec2;
+    lerp(v: Vec2Like, t: number): Vec2;
+    clamp(min: Vec2Like, max: Vec2Like): Vec2;
+    min(v: Vec2Like): Vec2;
+    max(v: Vec2Like): Vec2;
+    /** Left-hand perpendicular: (-y, x), a 90° CCW turn. */
+    perp(): Vec2;
+    /** Rotate by `rad` (CCW) around `origin` (default 0). */
+    rotate(rad: number, origin?: Vec2Like): Vec2;
+    /** The vector's heading in radians: `atan2(y, x)`. */
+    heading(): number;
+    /** Angle (radians) between this and `v`. */
+    angle(v: Vec2Like): number;
+    withX(x: number): Vec2;
+    withY(y: number): Vec2;
+    equals(v: Vec2Like, eps?: number): boolean;
+    clone(): Vec2;
+    toArray(): [number, number];
+    [Symbol.iterator](): Iterator<number>;
+    static from(v: Vec2Like): Vec2;
+    static get zero(): Vec2;
+    static get one(): Vec2;
+    static get up(): Vec2;
+    static get down(): Vec2;
+    static get left(): Vec2;
+    static get right(): Vec2;
+}
+export declare class Vec3 {
+    x: number;
+    y: number;
+    z: number;
+    constructor(x?: number | Vec3Like, y?: number, z?: number);
+    set(x: number, y: number, z: number): this;
+    copy(v: Vec3Like): this;
+    add(v: Vec3Like): Vec3;
+    sub(v: Vec3Like): Vec3;
+    mul(v: Vec3Like): Vec3;
+    div(v: Vec3Like): Vec3;
+    scale(s: number): Vec3;
+    /** `this + v * s` (fused multiply-add). */
+    scaleAndAdd(v: Vec3Like, s: number): Vec3;
+    negate(): Vec3;
+    dot(v: Vec3Like): number;
+    cross(v: Vec3Like): Vec3;
+    length(): number;
+    lengthSq(): number;
+    distanceTo(v: Vec3Like): number;
+    distanceSqTo(v: Vec3Like): number;
+    normalize(): Vec3;
+    lerp(v: Vec3Like, t: number): Vec3;
+    clamp(min: Vec3Like, max: Vec3Like): Vec3;
+    min(v: Vec3Like): Vec3;
+    max(v: Vec3Like): Vec3;
+    /** Reflect this vector about a (unit) `normal`: `v - 2·(v·n)·n`. */
+    reflect(normal: Vec3Like): Vec3;
+    /** Vector projection of this onto `onto`. */
+    project(onto: Vec3Like): Vec3;
+    /** Angle (radians) between this and `v`. */
+    angle(v: Vec3Like): number;
+    /** Rotate this point around the X axis through `origin` (default 0) by `rad`. */
+    rotateX(rad: number, origin?: Vec3Like): Vec3;
+    rotateY(rad: number, origin?: Vec3Like): Vec3;
+    rotateZ(rad: number, origin?: Vec3Like): Vec3;
+    /** Rotate this vector by a quaternion (x, y, z, w). Accepts a `Quat` or a raw `[x,y,z,w]`. */
+    rotate(q: ArrayLike<number> | {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    }): Vec3;
+    /** Transform this point by a column-major mat4 (a `Mat4`, its `.m`, or a raw length-16 array),
+     *  applying translation and the perspective divide. */
+    transform(m: ArrayLike<number> | {
+        m: ArrayLike<number>;
+    }): Vec3;
+    withX(x: number): Vec3;
+    withY(y: number): Vec3;
+    withZ(z: number): Vec3;
+    equals(v: Vec3Like, eps?: number): boolean;
+    clone(): Vec3;
+    toArray(): [number, number, number];
+    [Symbol.iterator](): Iterator<number>;
+    static from(v: Vec3Like): Vec3;
+    static get zero(): Vec3;
+    static get one(): Vec3;
+    static get up(): Vec3;
+    static get down(): Vec3;
+    static get left(): Vec3;
+    static get right(): Vec3;
+    /** Forward is −Z (the engine's cameras look down −Z; `node.forward` is −Z at identity). */
+    static get forward(): Vec3;
+    static get back(): Vec3;
+}

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

@@ -0,0 +1,25 @@
+export type FieldKind = 0 | 1 | 2;
+export type Field = {
+    key: string;
+    kind: FieldKind;
+    len: number;
+};
+export type Layout = {
+    fields: Field[];
+    floats: number;
+    bools: number;
+    bytes: number;
+    sig: string;
+};
+export declare const makeLayout: (defaults: Record<string, unknown>, what: string) => Layout;
+/** A fresh state object shaped like the defaults (arrays copied, never shared). */
+export declare const cloneDefaults: <T extends object>(defaults: T) => T;
+/** Copy the layout's fields from `from` into `into` (array elements copied in place; unknown keys
+ *  ignored — a JSON spawn state or a partial `setInput`). */
+export declare const assignState: (layout: Layout, into: any, from: any) => void;
+export declare const packInto: (view: DataView, offset: number, layout: Layout, s: any) => number;
+export declare const unpackFrom: (view: DataView, offset: number, layout: Layout, into: any) => number;
+/** `out = a + (b − a) · t` for the numeric fields; booleans take `b`'s. */
+export declare const lerpState: (layout: Layout, a: any, b: any, t: number, out: any) => void;
+/** FNV-1a over a string → 8 hex chars. Enough to tell two bundles' schemas apart. */
+export declare const hashString: (s: string) => string;

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

@@ -0,0 +1,106 @@
+export type Listener = (...args: any[]) => void;
+export type NetRole = "offline" | "host" | "client" | "server";
+export type NetStatus = "idle" | "connecting" | "online" | "error";
+/** A typed message key: `const Fire = Net.message<{ dir: number[] }>("fire")`. The type lives in
+ *  TypeScript only; the payload is JSON. */
+export type NetMessage<T = unknown> = {
+    readonly name: string;
+    readonly unreliable: boolean;
+    readonly __t?: T;
+};
+export type NetEvents = {
+    /** Client: welcomed by the server. Host/server: listening. */
+    connect: () => void;
+    /** The connection ended (`reason` from the transport, e.g. "timed out", "kicked"). */
+    disconnect: (reason: string) => void;
+    /** The server refused us (`reason`: "full" | "version" | "schema" | a kick reason). */
+    reject: (reason: string) => void;
+    join: (player: NetPlayer) => void;
+    leave: (player: NetPlayer, reason: string) => void;
+    error: (message: string) => void;
+};
+export type NetLaunch = {
+    role: "server" | "client";
+    address: string;
+    port: number;
+    maxClients: number;
+};
+export declare const CH_RELIABLE = 0;
+export declare const CH_UNRELIABLE = 1;
+export declare const PROTO = 2;
+export declare const LOCAL_SLOT = -1;
+export declare const bridge: () => typeof _creatorNet | null;
+export declare class NetPlayer {
+    /** Session-unique id assigned by the server (1 = the host's own player when hosting). */
+    readonly id: number;
+    name: string;
+    readonly connectedAt: number;
+    /** A local bag for game facts (score, team, ready). NOT replicated — anything a client must see
+     *  goes through a message or replicated state. */
+    data: any;
+    private _leave;
+    constructor(id: number, name: string, slot: number);
+    get isMe(): boolean;
+    /** Round trip to this player in ms (server side) or to the server (our own player on a client). */
+    get rtt(): number;
+    get loss(): number;
+    /** Server → this player. */
+    send<T>(msg: NetMessage<T>, data: T): void;
+    kick(reason?: string): void;
+    on(event: "leave", cb: (player: NetPlayer, reason: string) => void): this;
+    off(event: "leave", cb: (player: NetPlayer, reason: string) => void): this;
+}
+export declare const state: {
+    role: NetRole;
+    status: NetStatus;
+    isServer: boolean;
+    isClient: boolean;
+    me: NetPlayer | null;
+    players: NetPlayer[];
+    nextId: number;
+    /** a session is up: the phase hooks are installed and pump every frame */
+    active: boolean;
+    events: Map<string, Listener[]>;
+    handlers: Map<string, Listener[]>;
+    connectResolve: null | (() => void);
+    connectReject: null | ((e: Error) => void);
+    myName: string;
+};
+export declare const hooks: {
+    frameEarly: null | ((dt: number) => void);
+    frameFixed: null | ((dt: number) => void);
+    frameLate: null | ((dt: number) => void);
+    /** client: extra `$hello` fields (schema hash) */
+    helloExtra: null | (() => Record<string, unknown>);
+    /** server: a reject reason for this `$hello`, or null to accept */
+    helloCheck: null | ((data: any) => string | null);
+    /** server: extra `$welcome` fields (tick, kind table) */
+    welcomeExtra: null | (() => Record<string, unknown>);
+    /** server: right after `$welcome` + `$join` went out — send the live entities to the newcomer */
+    afterWelcome: null | ((p: NetPlayer) => void);
+    /** client: the `$welcome` arrived (before the connect event) */
+    onWelcome: null | ((data: any) => void);
+    /** client: a reserved `$` message the roster does not know (spawn / despawn) */
+    clientReserved: null | ((name: string, data: any) => void);
+    /** binary payloads (channel 1): inputs on the server, snapshots on the client */
+    serverBinary: null | ((p: NetPlayer, channel: number, data: ArrayBuffer) => void);
+    clientBinary: null | ((channel: number, data: ArrayBuffer) => void);
+    /** server: a player is gone (after the leave event) */
+    playerLeft: null | ((p: NetPlayer) => void);
+    /** the session ends (before the state resets); `role` = the role we are leaving */
+    reset: null | ((role: NetRole) => void);
+};
+export declare const emit: (event: keyof NetEvents, ...args: any[]) => void;
+export declare const playerBySlot: (slot: number) => NetPlayer | undefined;
+export declare const addPlayer: (id: number, name: string, slot: number) => NetPlayer;
+export declare const removePlayer: (p: NetPlayer, reason: string) => void;
+export declare const ensureMe: () => NetPlayer;
+export declare const sendRaw: (slot: number, channel: number, payload: string | ArrayBuffer) => boolean;
+export declare const queueLocal: (fn: () => void) => void;
+export declare const dispatchMessage: (name: string, data: unknown, from: NetPlayer | null) => void;
+export declare const deliverTo: (p: NetPlayer, msg: NetMessage<any>, data: unknown) => void;
+export declare const broadcastRaw: (payload: string | ArrayBuffer, except: NetPlayer | null, channel?: number) => void;
+export declare const startPhases: () => void;
+export declare const stopPhases: () => void;
+export declare const resetToOffline: () => void;
+export declare const pump: () => void;

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

@@ -0,0 +1,80 @@
+import { NetPlayer, type NetEvents, type NetLaunch, type NetMessage, type NetRole, type NetStatus } from "./core";
+import { NetEntity, Replicated, stats, type NetInput, type NetKind, type NetTransform } from "./replication";
+export { NetPlayer, NetEntity, Replicated };
+export type { NetEvents, NetLaunch, NetMessage, NetRole, NetStatus, NetInput, NetKind, NetTransform };
+declare class NetImpl {
+    get role(): NetRole;
+    get status(): NetStatus;
+    get isServer(): boolean;
+    get isClient(): boolean;
+    /** True on hosts that ship the transport (desktop, the 3d/full Android variants, iOS). Web: false. */
+    get supported(): boolean;
+    /** What the exe was launched as (`--server --port N` / `--connect ADDR`), or null. */
+    get launch(): NetLaunch | null;
+    get me(): NetPlayer;
+    get players(): readonly NetPlayer[];
+    player(id: number): NetPlayer | undefined;
+    /** Our round trip to the server (client), 0 otherwise. */
+    get rtt(): number;
+    /** The simulation tick — one per fixed step (`updateFixed`). The server's is THE tick; a client
+     *  runs a few ticks ahead so its inputs arrive in time. */
+    get tick(): number;
+    /** Live counters: snapshots, input lead / `ahead`, corrections, missed inputs, bytes out. */
+    get stats(): typeof stats;
+    /** Start serving on `port`. From offline this makes us the host (a player who is also the
+     *  server); on the dedicated exe (`Net.launch.role === "server"`) there is no local player. */
+    listen(opts?: {
+        port?: number;
+        maxClients?: number;
+        name?: string;
+        dedicated?: boolean;
+    }): boolean;
+    /** Connect to a host/server (`address` = "ip:port"). Resolves once the server welcomed us. */
+    connect(target: {
+        address: string;
+    }, opts?: {
+        name?: string;
+    }): Promise<void>;
+    /** Client → offline. Host/server → everyone is dropped, back to offline. */
+    disconnect(): void;
+    /** Declare a message type once; the name is the wire id. `unreliable` = channel 1 (fire-and-forget). */
+    message<T = void>(name: string, opts?: {
+        unreliable?: boolean;
+    }): NetMessage<T>;
+    /** Client → server (offline / host: delivered in-process, `from` = our own player). */
+    send<T>(msg: NetMessage<T>, data: T): void;
+    /** Server → every player (incl. the host's own), minus `except`. */
+    broadcast<T>(msg: NetMessage<T>, data: T, opts?: {
+        except?: NetPlayer | null;
+    }): void;
+    /** Subscribe to a built-in event or to a message (`from` = the sending player on the server,
+     *  null on a client — the server sent it). Returns `Net` for chaining. */
+    on<K extends keyof NetEvents>(event: K, cb: NetEvents[K]): this;
+    on<T>(msg: NetMessage<T>, cb: (data: T, from: NetPlayer | null) => void): this;
+    off<K extends keyof NetEvents>(event: K, cb: NetEvents[K]): this;
+    off<T>(msg: NetMessage<T>, cb: (data: T, from: NetPlayer | null) => void): this;
+    /** The per-tick input layout (one per game): `const PlayerInput = Net.input({ moveX: 0, moveY: 0, jump: false })`.
+     *  Fields: number → f32, boolean → 1 bit, number[] → f32 × length. */
+    input<T extends object>(defaults: T): NetInput<T>;
+    /** Set this tick's input — from `updateFixed`, once per tick, on the machine that owns the player
+     *  (client / host / offline). The owner's sim reads it back through `rep.input(PlayerInput)`; a
+     *  client also ships it to the server for the same tick. */
+    setInput<T extends object>(inp: NetInput<T>, values: Partial<T>): void;
+    /** A replicated entity type: the defaults are the snapshot layout (same field rules as `input`),
+     *  `transform` tells the SDK which fields mirror the node's pose, `client` births the proxy on a
+     *  client when the server spawns one (`new Node().aspect(Replicated, { kind, owner })`). */
+    kind<S extends object>(name: string, defaults: S, opts?: {
+        transform?: NetTransform;
+        client?: (rep: NetEntity<S>, scene: any) => any;
+    }): NetKind<S>;
+    /** Every replicated entity this machine knows. */
+    get entities(): readonly NetEntity[];
+    entity(netId: number): NetEntity | undefined;
+    /** Dev only: yojimbo's network simulator on our side of the wire (latency/jitter in ms, loss in %). */
+    simulate(opts: {
+        latency?: number;
+        jitter?: number;
+        loss?: number;
+    }): void;
+}
+export declare const Net: NetImpl;