lecodes-sdk 2.0.3 → 2.0.4

package/dist/global.d.ts

@@ -390,6 +390,7 @@ declare global {
   type NavPath = SDK.NavPath
   type NavQueryOptions = SDK.NavQueryOptions
   type NavRaycastHit = SDK.NavRaycastHit
+  type NetCorrection = SDK.NetCorrection
   type NetEntity<S extends object = any> = SDK.NetEntity<S>
   type NetEvents = SDK.NetEvents
   type NetInput<T extends object = any> = SDK.NetInput<T>

package/dist/types/inject.d.ts

@@ -20,7 +20,7 @@ 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 { 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, type ClientChannel } from "./runtime/rpc";
 export { AudioPlayer, VideoPlayer } from "./runtime/media";
 export { Sound, type SoundOptions } from "./audio/Sound";

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

@@ -3,6 +3,7 @@ export type Field = {
     key: string;
     kind: FieldKind;
     len: number;
+    step: boolean;
 };
 export type Layout = {
     fields: Field[];
@@ -11,7 +12,7 @@ export type Layout = {
     bytes: number;
     sig: string;
 };
-export declare const makeLayout: (defaults: Record<string, unknown>, what: string) => Layout;
+export declare const makeLayout: (defaults: Record<string, unknown>, what: string, discrete?: readonly 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
@@ -19,7 +20,7 @@ export declare const cloneDefaults: <T extends object>(defaults: T) => T;
 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. */
+/** `out = a + (b − a) · t` for the numeric fields; booleans and the discrete ones 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

@@ -34,7 +34,7 @@ export type NetStats = {
 };
 export declare const CH_RELIABLE = 0;
 export declare const CH_UNRELIABLE = 1;
-export declare const PROTO = 2;
+export declare const PROTO = 3;
 export declare const LOCAL_SLOT = -1;
 export declare const bridge: () => typeof _creatorNet | null;
 export declare class NetPlayer {
@@ -45,6 +45,9 @@ export declare class NetPlayer {
     /** 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;
+    /** Server: what this player's `Net.connect(…, { hello })` carried (the game's own: a build, a
+     *  token) — the value `Net.listen({ accept })` was asked about. Undefined everywhere else. */
+    hello: unknown;
     private _leave;
     constructor(id: number, name: string, slot: number);
     get isMe(): boolean;
@@ -72,6 +75,12 @@ export declare const state: {
     connectResolve: null | (() => void);
     connectReject: null | ((e: Error) => void);
     myName: string;
+    /** client: the game's own part of the `$hello` (`Net.connect(…, { hello })`), opaque to the SDK */
+    hello: unknown;
+    /** server: the game's say in the handshake (`Net.listen({ accept })`) — a reason refuses */
+    accept: null | ((hello: unknown, who: {
+        name: string;
+    }) => string | null | void);
 };
 export declare const hooks: {
     frameEarly: null | ((dt: number) => void);

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

@@ -1,7 +1,7 @@
 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";
+import { NetEntity, Replicated, stats, type NetCorrection, type NetInput, type NetKind, type NetTransform } from "./replication";
 export { NetPlayer, NetEntity, Replicated };
-export type { NetEvents, NetLaunch, NetMessage, NetRole, NetStatus, NetInput, NetKind, NetTransform };
+export type { NetEvents, NetLaunch, NetMessage, NetRole, NetStatus, NetInput, NetKind, NetTransform, NetCorrection };
 declare class NetImpl {
     get role(): NetRole;
     get status(): NetStatus;
@@ -19,21 +19,33 @@ declare class NetImpl {
     /** 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;
+    /** The server tick this machine is SHOWING the others at: on a client, its estimate of the server's
+     *  clock less the interpolation delay (fractional); `tick` everywhere else, where nothing is
+     *  interpolated. What a client names when it tells the server "as I saw it". */
+    get viewTick(): 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. */
+     *  server); on the dedicated exe (`Net.launch.role === "server"`) there is no local player.
+     *  `accept` is the game's say in the handshake: it is given what the client's `connect` passed as
+     *  `hello` and returns a reason to refuse (the client's `reject` event carries it), nothing to accept. */
     listen(opts?: {
         port?: number;
         maxClients?: number;
         name?: string;
         dedicated?: boolean;
+        accept?: (hello: unknown, who: {
+            name: string;
+        }) => string | null | void;
     }): boolean;
-    /** Connect to a host/server (`address` = "ip:port"). Resolves once the server welcomed us. */
+    /** Connect to a host/server (`address` = "ip:port"). Resolves once the server welcomed us.
+     *  `hello` = anything JSON the game wants the server to see before it lets us in (its
+     *  `Net.listen({ accept })`, then `player.hello`); the SDK only carries it. */
     connect(target: {
         address: string;
     }, opts?: {
         name?: string;
+        hello?: unknown;
     }): Promise<void>;
     /** Client → offline. Host/server → everyone is dropped, back to offline. */
     disconnect(): void;
@@ -62,10 +74,15 @@ declare class NetImpl {
     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 })`). */
+     *  client when the server spawns one (`new Node().aspect(Replicated, { kind, owner })`) — it may
+     *  be set later, `Kind.client = …`, where the client's code lives. `discrete` names the numeric
+     *  fields that are never interpolated (an index, a count); `correction` tunes how the owner's
+     *  prediction is brought back to the server's state (all in the game's own units). */
     kind<S extends object>(name: string, defaults: S, opts?: {
         transform?: NetTransform;
         client?: (rep: NetEntity<S>, scene: any) => any;
+        discrete?: readonly (keyof S & string)[];
+        correction?: Partial<NetCorrection>;
     }): NetKind<S>;
     /** Every replicated entity this machine knows. */
     get entities(): readonly NetEntity[];

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

@@ -5,6 +5,18 @@ import { Scene } from "../gl/Scene";
 import { type Layout } from "./codec";
 import { NetPlayer } from "./core";
 export type NetTransform = "pos" | "pos+rot" | "none";
+/** How an owner's prediction is brought back to the server's state. The SDK knows nothing of what
+ *  the entity is, so the defaults are neutral: every disagreement counts, none is a teleport. */
+export type NetCorrection = {
+    /** A vertical disagreement below this is ignored (world units). 0 = none ignored. A body that
+     *  snaps to a floor differs by a little between two machines, and lifting it by that feeds itself. */
+    deadbandY: number;
+    /** A disagreement of this much or more is a teleport: the body jumps and `correction` stays zero
+     *  (world units). Infinity = always smoothed. */
+    snap: number;
+    /** The decay time constant of the visual offset `correction` (seconds). 0 = no smoothing. */
+    tau: number;
+};
 /** The per-tick input layout: `const PlayerInput = Net.input({ moveX: 0, moveY: 0, jump: false })`. */
 export type NetInput<T extends object = any> = {
     readonly layout: Layout;
@@ -19,8 +31,10 @@ export type NetKind<S extends object = any> = {
     /** Which state fields the SDK samples on the server and applies to a client proxy: `pos` (a
      *  `pos: [x,y,z]` field), `pos+rot` (+ a `rot: [x,y,z,w]` quaternion field), or `none`. */
     readonly transform: NetTransform;
-    /** Births the client-side proxy on spawn; the SDK attaches `Replicated` to what it returns. */
-    readonly client?: (rep: NetEntity<S>, scene: Scene | null) => Node | void;
+    readonly correction: NetCorrection;
+    /** Births the client-side proxy on spawn; the SDK attaches `Replicated` to what it returns.
+     *  Assignable: a declaration both ends share may leave it to the client's own module. */
+    client?: (rep: NetEntity<S>, scene: Scene | null) => Node | void;
     readonly __t?: S;
 };
 /** Live counters (`Net.stats`): how the clocks and the prediction are doing. */
@@ -59,6 +73,9 @@ export declare class NetEntity<S extends object = any> {
     /** The owner's input for the tick being simulated — the ring entry on the server (the last one
      *  repeated when it is late), the local input on the owner / host / offline. */
     input<T extends object>(inp: NetInput<T>): T;
+    /** `input()` is an input the owner gave — false until the first one exists (the server before
+     *  the owner's first packet, the owner before its first `Net.setInput`), when it is the defaults. */
+    get hasInput(): boolean;
     /** Client: `state` was refreshed (a snapshot landed / the interpolation moved). */
     on(event: "state", cb: (s: S) => void): this;
     off(event: "state", cb: (s: S) => void): this;
@@ -66,10 +83,13 @@ export declare class NetEntity<S extends object = any> {
 export declare const declareKind: <S extends object>(name: string, defaults: S, opts?: {
     transform?: NetTransform;
     client?: NetKind<S>["client"];
+    discrete?: readonly string[];
+    correction?: Partial<NetCorrection>;
 }) => NetKind<S>;
 export declare const declareInput: <T extends object>(defaults: T) => NetInput<T>;
 export declare const setInput: <T extends object>(inp: NetInput<T>, values: Partial<T>) => void;
 export declare const currentTick: () => number;
+export declare const viewTick: () => number;
 export declare const allEntities: () => NetEntity[];
 export declare const entityById: (netId: number) => NetEntity | undefined;
 /**
@@ -97,5 +117,6 @@ export declare class Replicated extends Aspect<"replicated", Node> {
     get correction(): Vec3;
     /** The owner's input for the tick being simulated (see `NetEntity.input`). */
     input<T extends object>(inp: NetInput<T>): T;
+    get hasInput(): boolean;
 }
 export declare const installReplication: () => void;

package/dist/types/version.d.ts

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