@netforge/engine 0.0.0-stage → 0.2.0

package/dist/game/threats.d.ts

@@ -0,0 +1,23 @@
+import type { EnemyTypeDef } from "@netforge/engine-sim";
+/** One warning on the ground. Lanes run from (x, z) along (dx, dz) for `len` m with half width `r`. */
+export interface ThreatShape {
+    readonly kind: "circle" | "lane" | "aura";
+    readonly x: number;
+    readonly z: number;
+    readonly r: number;
+    readonly dx?: number;
+    readonly dz?: number;
+    readonly len?: number;
+    /** 0 when it appears, 1 when it lands. */
+    readonly progress: number;
+    /** True for an enemy shot in flight (a small moving circle). */
+    readonly shot?: boolean;
+}
+/** Lane length for an enemy type's telegraphed lane. */
+export declare function laneLength(def: EnemyTypeDef | undefined): number;
+/**
+ * The warning an entity shows now, or null. `kind`, `flags`, `type` and
+ * `level` are its snapshot fields; (x, z) its position, (vx, vz) its
+ * velocity (shots).
+ */
+export declare function threatOf(enemyTypes: readonly EnemyTypeDef[], kind: number, flags: number, type: number, level: number, x: number, z: number, vx?: number, vz?: number): ThreatShape | null;

package/dist/game/threats.js

@@ -0,0 +1,49 @@
+/**
+ * Telegraphs as shapes on the ground: what an attack about to land covers.
+ * One reader for the client's decals and the playtest bots' dodging, so
+ * what players see is exactly what the bots react to.
+ */
+import { decodeTelegraph, EntityFlag, EntityKind, ROLE_DEFAULTS, Telegraph } from "@netforge/engine-sim";
+/** Boss dash lane length, m (engine-sim roles.ts BOSS.dash.length). */
+const BOSS_DASH = 11;
+/** Lane length for an enemy type's telegraphed lane. */
+export function laneLength(def) {
+    if (!def)
+        return 6;
+    if (def.pattern)
+        return BOSS_DASH;
+    // An aim line shows the direction, not the whole flight: 5 m is enough to read and dodge.
+    if (def.ai === "ranged")
+        return Math.min(5, (def.attack?.range ?? ROLE_DEFAULTS.ranged.range) * 1.6);
+    const C = ROLE_DEFAULTS.charger;
+    return def.speed * (def.attack?.speed ?? C.speed) * C.act + def.radius;
+}
+/**
+ * The warning an entity shows now, or null. `kind`, `flags`, `type` and
+ * `level` are its snapshot fields; (x, z) its position, (vx, vz) its
+ * velocity (shots).
+ */
+export function threatOf(enemyTypes, kind, flags, type, level, x, z, vx = 0, vz = 0) {
+    if (kind === EntityKind.Projectile) {
+        if ((flags & EntityFlag.Hostile) === 0)
+            return null;
+        if ((flags & EntityFlag.Elite) !== 0) {
+            const t = decodeTelegraph(level);
+            return { kind: "circle", x, z, r: t.radius, progress: t.progress };
+        }
+        return { kind: "circle", x: x + vx * 0.3, z: z + vz * 0.3, r: 0.6, progress: 1, shot: true };
+    }
+    if (kind !== EntityKind.Enemy || level === 0 || (flags & EntityFlag.Dead) !== 0)
+        return null;
+    const t = decodeTelegraph(level);
+    const def = enemyTypes[type];
+    if (t.kind === Telegraph.Circle)
+        return { kind: "circle", x, z, r: t.radius, progress: t.progress };
+    if (t.kind === Telegraph.Aura)
+        return { kind: "aura", x, z, r: t.radius, progress: t.progress };
+    if (t.kind === Telegraph.Lane) {
+        const width = (def?.radius ?? 0.4) + 0.3;
+        return { kind: "lane", x, z, r: width, dx: Math.cos(t.angle), dz: Math.sin(t.angle), len: laneLength(def), progress: t.progress };
+    }
+    return null;
+}

package/dist/game/view.d.ts

@@ -0,0 +1,47 @@
+/**
+ * What a player can see: the ground footprint of a template's camera, as
+ * the sim's view radii (engine-sim ViewRules). The spawn director spawns
+ * just outside it, straggler recycling measures against it, and the
+ * playtest counts enemies inside it as "on screen".
+ *
+ * The footprint is the camera's screen rectangle projected onto the ground
+ * plane: a trapezoid, short toward the camera and long away from it. The
+ * union over the screen shapes a template supports (landscape monitors,
+ * portrait phones) is what "off screen" must clear.
+ */
+/** A fixed top-down follow camera (yaw 0: it sits on +z and looks toward -z). */
+export interface CameraView {
+    /** Distance from the focus point, m. */
+    readonly distance: number;
+    /** Elevation angle above the ground, radians. */
+    readonly pitch: number;
+    /** Vertical field of view, degrees. */
+    readonly fov: number;
+    /** Width / height of the screen. */
+    readonly aspect: number;
+    /** Height of the focus point above the ground, m. */
+    readonly focusHeight?: number;
+}
+/**
+ * EMBERWATCH's camera (client/scene.ts: distance 17 landscape, 24 portrait,
+ * fov 50, pitch 0.98, focus 0.5 m up) on a 16:9 and a 21:9 monitor and a
+ * 9:19.5 phone. Change these with the scene's rig. (Round 1 playtest: 20%
+ * closer than the first cut's 21 and 30, so the hero reads.)
+ */
+export declare const SURVIVOR_VIEWS: readonly CameraView[];
+/**
+ * The dungeon crawl's camera (template-dungeon client/scene.ts: distance 13
+ * landscape, 18 portrait, fov 50, pitch 1.02): closer than the field's, so
+ * a room fills the screen and the next one is out of sight.
+ */
+export declare const DUNGEON_VIEWS: readonly CameraView[];
+/** The camera views a template's client draws with (the spawn director and the playtest's "on screen" use them). */
+export declare function viewsFor(template: string): readonly CameraView[];
+/** The four ground corners of the camera's view, relative to the focus point's ground position [x, z]. */
+export declare function footprint(v: CameraView): [number, number][];
+/** View radii (engine-sim ViewRules) for the union of several camera views, at `n` evenly spaced headings. */
+export declare function viewRadii(views: readonly CameraView[], n?: number): number[];
+/** Radius at a heading of a radii table (linear between samples). */
+export declare function radiusAt(radii: readonly number[], a: number): number;
+/** True when (dx, dz) from a player is inside a radii table. */
+export declare function insideView(radii: readonly number[], dx: number, dz: number): boolean;

package/dist/game/view.js

@@ -0,0 +1,123 @@
+/**
+ * What a player can see: the ground footprint of a template's camera, as
+ * the sim's view radii (engine-sim ViewRules). The spawn director spawns
+ * just outside it, straggler recycling measures against it, and the
+ * playtest counts enemies inside it as "on screen".
+ *
+ * The footprint is the camera's screen rectangle projected onto the ground
+ * plane: a trapezoid, short toward the camera and long away from it. The
+ * union over the screen shapes a template supports (landscape monitors,
+ * portrait phones) is what "off screen" must clear.
+ */
+/**
+ * EMBERWATCH's camera (client/scene.ts: distance 17 landscape, 24 portrait,
+ * fov 50, pitch 0.98, focus 0.5 m up) on a 16:9 and a 21:9 monitor and a
+ * 9:19.5 phone. Change these with the scene's rig. (Round 1 playtest: 20%
+ * closer than the first cut's 21 and 30, so the hero reads.)
+ */
+export const SURVIVOR_VIEWS = [
+    { distance: 17, pitch: 0.98, fov: 50, aspect: 16 / 9, focusHeight: 0.5 },
+    { distance: 17, pitch: 0.98, fov: 50, aspect: 21 / 9, focusHeight: 0.5 },
+    { distance: 24, pitch: 0.98, fov: 50, aspect: 9 / 19.5, focusHeight: 0.5 },
+];
+/**
+ * The dungeon crawl's camera (template-dungeon client/scene.ts: distance 13
+ * landscape, 18 portrait, fov 50, pitch 1.02): closer than the field's, so
+ * a room fills the screen and the next one is out of sight.
+ */
+export const DUNGEON_VIEWS = [
+    { distance: 13, pitch: 1.02, fov: 50, aspect: 16 / 9, focusHeight: 0.5 },
+    { distance: 13, pitch: 1.02, fov: 50, aspect: 21 / 9, focusHeight: 0.5 },
+    { distance: 18, pitch: 1.02, fov: 50, aspect: 9 / 19.5, focusHeight: 0.5 },
+];
+/** The camera views a template's client draws with (the spawn director and the playtest's "on screen" use them). */
+export function viewsFor(template) {
+    return template === "dungeon" ? DUNGEON_VIEWS : SURVIVOR_VIEWS;
+}
+/** Farthest a footprint may reach (the camera can see the horizon on very flat pitches), m. */
+const HORIZON = 80;
+/** The four ground corners of the camera's view, relative to the focus point's ground position [x, z]. */
+export function footprint(v) {
+    const h = v.focusHeight ?? 0;
+    const s = Math.sin(v.pitch);
+    const c = Math.cos(v.pitch);
+    const cy = h + s * v.distance;
+    const cz = c * v.distance;
+    const t = Math.tan(((v.fov / 2) * Math.PI) / 180);
+    const out = [];
+    for (const [nx, ny] of [
+        [-1, 1],
+        [1, 1],
+        [1, -1],
+        [-1, -1],
+    ]) {
+        // dir = forward + nx * tan * aspect * right + ny * tan * up, with
+        // forward (0, -s, -c), right (1, 0, 0), up (0, c, -s).
+        const dx = nx * t * v.aspect;
+        const dy = -s + ny * t * c;
+        const dz = -c - ny * t * s;
+        if (dy < -1e-6) {
+            const k = cy / -dy;
+            const gx = dx * k;
+            const gz = cz + dz * k;
+            const len = Math.hypot(gx, gz);
+            if (len <= HORIZON) {
+                out.push([gx, gz]);
+                continue;
+            }
+        }
+        // Above the horizon (or very far): clamp along the ray's ground direction.
+        const len = Math.hypot(dx, dz) || 1;
+        out.push([(dx / len) * HORIZON, cz + (dz / len) * HORIZON]);
+    }
+    return out;
+}
+/** Distance from the origin to the edge of a convex polygon along heading `a` (radians from +x toward +z). */
+function exitDistance(poly, a) {
+    const ux = Math.cos(a);
+    const uz = Math.sin(a);
+    let best = 0;
+    for (let i = 0; i < poly.length; i++) {
+        const p = poly[i];
+        const q = poly[(i + 1) % poly.length];
+        const ex = q[0] - p[0];
+        const ez = q[1] - p[1];
+        const den = ux * ez - uz * ex;
+        if (Math.abs(den) < 1e-9)
+            continue;
+        const t = (p[0] * ez - p[1] * ex) / den;
+        const s = (p[0] * uz - p[1] * ux) / den;
+        if (t > 0 && s >= -1e-9 && s <= 1 + 1e-9)
+            best = Math.max(best, t);
+    }
+    return best;
+}
+/** View radii (engine-sim ViewRules) for the union of several camera views, at `n` evenly spaced headings. */
+export function viewRadii(views, n = 32) {
+    const polys = views.map(footprint);
+    const out = [];
+    for (let i = 0; i < n; i++) {
+        const a = (i / n) * Math.PI * 2;
+        let r = 0;
+        for (const p of polys)
+            r = Math.max(r, exitDistance(p, a));
+        out.push(Math.round(Math.max(4, r) * 100) / 100);
+    }
+    return out;
+}
+/** Radius at a heading of a radii table (linear between samples). */
+export function radiusAt(radii, a) {
+    const n = radii.length;
+    let t = (a / (Math.PI * 2)) * n;
+    t = ((t % n) + n) % n;
+    const i = Math.floor(t);
+    const f = t - i;
+    const r0 = radii[i % n] ?? 0;
+    const r1 = radii[(i + 1) % n] ?? 0;
+    return r0 + (r1 - r0) * f;
+}
+/** True when (dx, dz) from a player is inside a radii table. */
+export function insideView(radii, dx, dz) {
+    const r = radiusAt(radii, Math.atan2(dz, dx));
+    return dx * dx + dz * dz < r * r;
+}

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @netforge/engine: the API a game is written against.
+ *
+ * This entry point is all a generated game may import. It is declarative
+ * and typed (Zod-validated): game, prefab, system, earn, store, and the
+ * headless test harness. Rendering, input, netcode and physics are not
+ * reachable from here; they live in "@netforge/engine/runtime", which
+ * templates and the Launcher shell use and game code does not.
+ */
+export { dungeon, dungeonSchema } from "./api/dungeon.js";
+export type { DungeonLayout, DungeonRoom, DungeonSpec } from "./api/dungeon.js";
+export { game, prefab, weapon, upgrade, system, director, earn, store, keeper, achievement, mission, title, economy, metaUpgrade, STAKE_REASON, POT_REASON } from "./api/registry.js";
+export type { EdgeSide, GameManifest, PlayerView, SpawnEdgeOptions, SpawnRingOptions, SystemContext, SystemSetup } from "./api/registry.js";
+export { GameDefinitionError, TEMPLATES, STYLES, AI_BEHAVIOURS, WEAPON_KINDS, STAT_KINDS, LOOK_PRESETS, PARTICLE_PRESETS, DECAL_PRESETS, SOUND_CUES, TITLE_STATS, META_STATS, META_MAX_PER_STAT, META_MAX_TOTAL, META_MAX_LEVELS, META_MAX_UPGRADES, META_MIN_GROWTH, STAKE_MAX_MULTIPLE, STAKE_MAX_COINS, } from "./api/schemas.js";
+export type { AssetId, Curve, CurveInput, DirectorDef, DirectorInput, DecalPreset, FeelDef, LookDef, LookInput, LookPreset, ParticlePreset, SoundCue, EarnRuleDef, KeeperDef, KeeperInput, AchievementDef, AchievementInput, MissionDef, MissionInput, TitleDef, TitleInput, TitleStat, EarnRuleInput, EarnStakeDef, EarnStakeInput, EarnPotDef, EarnPotInput, GameDef, GameInput, PrefabDef, PrefabInput, SkuDef, SkuInput, SkuGrant, EconomyDef, EconomyInput, MetaUpgradeDef, MetaUpgradeInput, MetaStat, Style, Template, UpgradeDef, UpgradeInput, WeaponDef, WeaponInput, } from "./api/schemas.js";
+export { towerBoard, tower, waves, TOWER_KINDS, TOWER_STATS } from "./api/tower.js";
+export { saltFlat, plant, PLANT_KINDS, IDLE_STATS, IDLE_MIN_SHIFT, IDLE_MAX_TEND } from "./api/idle.js";
+export type { SaltFlatDef, SaltFlatInput, PlantDef, PlantInput } from "./api/idle.js";
+export { marsh, creature, move, ELEMENTS, MOVE_EFFECTS, COLLECTOR_STATS } from "./api/collector.js";
+export type { MarshDef, MarshInput, CreatureDef, CreatureInput, MoveDef, MoveInput, Element } from "./api/collector.js";
+export type { TowerBoardDef, TowerBoardInput, TowerDef, TowerInput, WavesDef, WavesInput } from "./api/tower.js";
+export { card, cardTable, CARD_STATS, EFFECT_KINDS, EFFECT_TARGETS } from "./api/cards.js";
+export type { CardDef, CardInput, CardTableDef, CardTableInput } from "./api/cards.js";
+export { APPEARANCE_PARTS, appearanceSchema } from "./api/appearance.js";
+export type { AppearanceDef, AppearanceInput, AppearancePart } from "./api/appearance.js";
+export type { FunMetrics, HarnessAssertion, HarnessOptions, HarnessReport } from "./api/harness.js";
+import { runHarness } from "./api/harness.js";
+/** `engine.test.run({ ticks, bots, assert })`: the headless playtest (§12). */
+export declare const engine: {
+    readonly test: {
+        readonly run: typeof runHarness;
+    };
+};

package/dist/index.js

@@ -0,0 +1,24 @@
+/**
+ * @netforge/engine: the API a game is written against.
+ *
+ * This entry point is all a generated game may import. It is declarative
+ * and typed (Zod-validated): game, prefab, system, earn, store, and the
+ * headless test harness. Rendering, input, netcode and physics are not
+ * reachable from here; they live in "@netforge/engine/runtime", which
+ * templates and the Launcher shell use and game code does not.
+ */
+export { dungeon, dungeonSchema } from "./api/dungeon.js";
+export { game, prefab, weapon, upgrade, system, director, earn, store, keeper, achievement, mission, title, economy, metaUpgrade, STAKE_REASON, POT_REASON } from "./api/registry.js";
+export { GameDefinitionError, TEMPLATES, STYLES, AI_BEHAVIOURS, WEAPON_KINDS, STAT_KINDS, LOOK_PRESETS, PARTICLE_PRESETS, DECAL_PRESETS, SOUND_CUES, TITLE_STATS, META_STATS, META_MAX_PER_STAT, META_MAX_TOTAL, META_MAX_LEVELS, META_MAX_UPGRADES, META_MIN_GROWTH, STAKE_MAX_MULTIPLE, STAKE_MAX_COINS, } from "./api/schemas.js";
+// Board genres (rules/): each template's own declarations.
+export { towerBoard, tower, waves, TOWER_KINDS, TOWER_STATS } from "./api/tower.js";
+export { saltFlat, plant, PLANT_KINDS, IDLE_STATS, IDLE_MIN_SHIFT, IDLE_MAX_TEND } from "./api/idle.js";
+export { marsh, creature, move, ELEMENTS, MOVE_EFFECTS, COLLECTOR_STATS } from "./api/collector.js";
+export { card, cardTable, CARD_STATS, EFFECT_KINDS, EFFECT_TARGETS } from "./api/cards.js";
+// Asset library: model appearances.
+export { APPEARANCE_PARTS, appearanceSchema } from "./api/appearance.js";
+import { runHarness } from "./api/harness.js";
+/** `engine.test.run({ ticks, bots, assert })`: the headless playtest (§12). */
+export const engine = {
+    test: { run: runHarness },
+};

package/dist/net/bits.d.ts

@@ -0,0 +1,33 @@
+export declare class BitWriter {
+    private buf;
+    private bitPos;
+    constructor(initialBytes?: number);
+    /** Writes the low `bits` bits of `value` (0 <= bits <= 32). */
+    writeBits(value: number, bits: number): void;
+    writeBool(b: boolean): void;
+    /** Signed integer in `bits` bits using zigzag encoding. */
+    writeSigned(value: number, bits: number): void;
+    /**
+     * Unsigned varint in 4-bit groups with a continuation bit (5 bits per
+     * group). Small counts (entity counts, id gaps) cost 5 bits, not 16.
+     */
+    writeVarUint(value: number): void;
+    get bitLength(): number;
+    finish(): Uint8Array;
+    private ensure;
+}
+export declare class BitReader {
+    private readonly buf;
+    private bitPos;
+    private readonly totalBits;
+    constructor(buf: Uint8Array);
+    readBits(bits: number): number;
+    readBool(): boolean;
+    readSigned(bits: number): number;
+    readVarUint(): number;
+    get remainingBits(): number;
+}
+export declare function zigzag(n: number): number;
+export declare function unzigzag(z: number): number;
+/** Bits needed for a zigzagged signed value of magnitude up to `maxAbs`. */
+export declare function bitsForSigned(maxAbs: number): number;

package/dist/net/bits.js

@@ -0,0 +1,135 @@
+// Bit-level writer and reader for snapshots and input packets.
+//
+// Values are written LSB-first into a growable byte buffer. Every field in a
+// snapshot is a fixed or schema-declared bit width, so nothing here allocates
+// per field; the buffer doubles when it runs out.
+export class BitWriter {
+    buf;
+    bitPos = 0;
+    constructor(initialBytes = 256) {
+        this.buf = new Uint8Array(initialBytes);
+    }
+    /** Writes the low `bits` bits of `value` (0 <= bits <= 32). */
+    writeBits(value, bits) {
+        if (bits <= 0)
+            return;
+        if (bits > 32)
+            throw new RangeError(`writeBits: ${bits} > 32`);
+        this.ensure(bits);
+        let v = bits === 32 ? value >>> 0 : (value >>> 0) % 2 ** bits;
+        let remaining = bits;
+        while (remaining > 0) {
+            const byteIndex = this.bitPos >>> 3;
+            const bitOffset = this.bitPos & 7;
+            const room = 8 - bitOffset;
+            const take = remaining < room ? remaining : room;
+            const chunk = v & ((1 << take) - 1);
+            this.buf[byteIndex] = (this.buf[byteIndex] ?? 0) | (chunk << bitOffset);
+            v = Math.floor(v / (1 << take));
+            remaining -= take;
+            this.bitPos += take;
+        }
+    }
+    writeBool(b) {
+        this.writeBits(b ? 1 : 0, 1);
+    }
+    /** Signed integer in `bits` bits using zigzag encoding. */
+    writeSigned(value, bits) {
+        this.writeBits(zigzag(value), bits);
+    }
+    /**
+     * Unsigned varint in 4-bit groups with a continuation bit (5 bits per
+     * group). Small counts (entity counts, id gaps) cost 5 bits, not 16.
+     */
+    writeVarUint(value) {
+        let v = value >>> 0;
+        do {
+            const group = v & 0xf;
+            v >>>= 4;
+            this.writeBits(group, 4);
+            this.writeBool(v !== 0);
+        } while (v !== 0);
+    }
+    get bitLength() {
+        return this.bitPos;
+    }
+    finish() {
+        return this.buf.slice(0, (this.bitPos + 7) >>> 3);
+    }
+    ensure(bits) {
+        const need = (this.bitPos + bits + 7) >>> 3;
+        if (need <= this.buf.length)
+            return;
+        let size = this.buf.length * 2;
+        while (size < need)
+            size *= 2;
+        const next = new Uint8Array(size);
+        next.set(this.buf);
+        this.buf = next;
+    }
+}
+export class BitReader {
+    buf;
+    bitPos = 0;
+    totalBits;
+    constructor(buf) {
+        this.buf = buf;
+        this.totalBits = buf.length * 8;
+    }
+    readBits(bits) {
+        if (bits <= 0)
+            return 0;
+        if (bits > 32)
+            throw new RangeError(`readBits: ${bits} > 32`);
+        if (this.bitPos + bits > this.totalBits)
+            throw new RangeError('readBits: past end of buffer');
+        let out = 0;
+        let shift = 0;
+        let remaining = bits;
+        while (remaining > 0) {
+            const byteIndex = this.bitPos >>> 3;
+            const bitOffset = this.bitPos & 7;
+            const room = 8 - bitOffset;
+            const take = remaining < room ? remaining : room;
+            const byte = this.buf[byteIndex] ?? 0;
+            const chunk = (byte >>> bitOffset) & ((1 << take) - 1);
+            out += chunk * 2 ** shift;
+            shift += take;
+            remaining -= take;
+            this.bitPos += take;
+        }
+        return out;
+    }
+    readBool() {
+        return this.readBits(1) === 1;
+    }
+    readSigned(bits) {
+        return unzigzag(this.readBits(bits));
+    }
+    readVarUint() {
+        let out = 0;
+        let shift = 0;
+        for (;;) {
+            const group = this.readBits(4);
+            out += group * 2 ** shift;
+            shift += 4;
+            if (!this.readBool())
+                return out;
+            if (shift > 32)
+                throw new RangeError('readVarUint: too long');
+        }
+    }
+    get remainingBits() {
+        return this.totalBits - this.bitPos;
+    }
+}
+export function zigzag(n) {
+    return n >= 0 ? n * 2 : -n * 2 - 1;
+}
+export function unzigzag(z) {
+    return z % 2 === 0 ? z / 2 : -(z + 1) / 2;
+}
+/** Bits needed for a zigzagged signed value of magnitude up to `maxAbs`. */
+export function bitsForSigned(maxAbs) {
+    return Math.max(1, Math.ceil(Math.log2(maxAbs * 2 + 2)));
+}

package/dist/net/client.d.ts

@@ -0,0 +1,75 @@
+import { type InterpolatedEntity } from './interpolation.js';
+import { type EntityState } from './schema.js';
+import type { PlayerId, SimAdapter } from './sim-adapter.js';
+export interface NetClientOptions {
+    /** How far behind the server remote entities are drawn. Spec: ~100 ms. */
+    readonly interpDelayMs: number;
+    /** Server input-queue depth the client clock steers toward (one-input-per-tick sims). */
+    readonly inputBufferTarget?: number;
+    /**
+     * First input seq. A client rebuilt after a room rebase continues the old
+     * client's numbering (`nextSeq`), because the server's input queue ignores
+     * seqs it has already seen.
+     */
+    readonly firstSeq?: number;
+}
+export declare const DEFAULT_CLIENT: NetClientOptions;
+export interface ClientStats {
+    snapshots: number;
+    snapshotBytes: number;
+    inputPackets: number;
+    inputBytes: number;
+    baselineMisses: number;
+    staleSnapshots: number;
+}
+export declare class NetClient<W, I> {
+    private readonly sim;
+    readonly player: PlayerId;
+    readonly selfEntity: number;
+    private readonly send;
+    private readonly opts;
+    private readonly history;
+    private readonly interp;
+    private readonly clock;
+    private readonly predictor;
+    private latestTick;
+    private latestSelf;
+    private lastRenderMs;
+    private readonly tickMs;
+    /** Smoothed server input-queue depth from snapshot headers; null until reported. */
+    private serverBuffer;
+    readonly stats: ClientStats;
+    constructor(sim: SimAdapter<W, I>, player: PlayerId, selfEntity: number, send: (bytes: Uint8Array) => void, opts?: NetClientOptions);
+    /** The seq the next input gets; pass as `firstSeq` to a client that replaces this one. */
+    get nextSeq(): number;
+    receiveSnapshot(bytes: Uint8Array, nowMs: number): void;
+    /** Call once per sim tick with the sampled input. Sends the input packet. */
+    tick(input: I, nowMs: number): void;
+    /**
+     * Milliseconds until the next input tick. Equal to the sim tick when the
+     * server reports no input queue; otherwise up to 8% shorter when the
+     * server's queue for us runs below target (we are behind, so input would
+     * starve) and up to 8% longer when it runs above (added latency). This is
+     * the client clock adjustment for one-input-per-tick sims.
+     */
+    tickIntervalMs(): number;
+    /** Smoothed input-queue depth the server last reported, or null. */
+    get serverInputBuffer(): number | null;
+    /** Server tick (fractional) that remote entities are drawn at. */
+    renderTick(nowMs: number): number;
+    render(nowMs: number): {
+        self: EntityState | undefined;
+        others: InterpolatedEntity[];
+    };
+    /** The newest server state of our own entity (what prediction is ahead of). */
+    authoritativeSelf(): EntityState | undefined;
+    /** Our own entity drawn like a remote one (what you'd see with no prediction). */
+    interpolatedSelf(nowMs: number): InterpolatedEntity | undefined;
+    /** Exact predicted state (no smoothing). */
+    predicted(): EntityState | undefined;
+    get ready(): boolean;
+    get corrections(): number;
+    get lastCorrection(): number;
+    get pendingInputs(): number;
+    private toState;
+}