@jgengine/shell 0.19.0 → 0.22.0

package/dist/devtools/DevtoolsOverlay.js

@@ -1,14 +1,9 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useFrame, useThree } from "@react-three/fiber";
 import { useEffect, useRef, useState, useSyncExternalStore } from "react";
-import { devtools, instrumentLatency, } from "@jgengine/core/devtools/devtools";
-import { fallbackSeamsSnapshot } from "@jgengine/core/devtools/fallbackSeams";
-import { textureErrorsSnapshot } from "@jgengine/core/devtools/textureErrors";
-import { MOVEMENT_TUNING } from "@jgengine/core/movement/movementModel";
+import { devtools, } from "@jgengine/core/devtools/devtools";
 import { heavyModels } from "../render/modelLoad.js";
-import { collisionDebug } from "./collisionDebug.js";
-import { readStoredOverrides } from "./devtoolsOverrides.js";
-import { diagnose } from "./perfDiagnose.js";
+import { buildLeanReport } from "./devtoolsReports.js";
 import { PerfPanel } from "./PerfPanel.js";
 import { LogsPanel } from "./LogsPanel.js";
 import { NetPanel } from "./NetPanel.js";
@@ -17,20 +12,12 @@ import { ColPanel } from "./ColPanel.js";
 import { TunePanel } from "./TunePanel.js";
 export { applyStoredDevtoolsOverrides, persistDevtoolsOverrides } from "./devtoolsOverrides.js";
 const REFRESH_MS = 250;
-/** @internal */
-export function withDevtoolsLatency(multiplayer) {
-    return {
-        ...multiplayer,
-        backend: {
-            ...instrumentLatency(multiplayer.backend, ["pushFeedEntry"]),
-            transport: instrumentLatency(multiplayer.backend.transport, ["joinServer", "leaveServer", "runCommand"]),
-        },
-    };
-}
+export { withDevtoolsLatency } from "./latencyInstrumentation.js";
 const RENDER_SAMPLE_MS = 500;
 const RENDER_PROBE_FRAME_PRIORITY = -10;
 /** @internal */
 export function DevtoolsRendererProbe() {
+    useEffect(() => devtools.probes.register("heavyModels", () => heavyModels()), []);
     const gl = useThree((state) => state.gl);
     const lastSampleAt = useRef(0);
     useEffect(() => {
@@ -66,166 +53,25 @@ const TABS = [
     { id: "net", label: "Net" },
     { id: "keys", label: "Keys" },
 ];
-function roundMs(value, digits = 1) {
-    const scale = 10 ** digits;
-    return Math.round(value * scale) / scale;
-}
-function compactLongFrame(event) {
-    return {
-        at: event.at,
-        frameMs: roundMs(event.frameMs),
-        simMs: roundMs(event.simMs),
-        outsideMs: roundMs(event.outsideMs),
-        culprit: event.culprit,
-        reason: event.reason,
-        phases: event.phases.slice(0, 4).map((phase) => ({
-            name: phase.name,
-            ms: roundMs(phase.ms),
-        })),
-        probes: event.probes,
-        render: event.render,
-    };
-}
-function summarizeLongFrames(events) {
-    if (events.length === 0)
-        return null;
-    const byCulprit = new Map();
-    let maxFrameMs = 0;
-    let maxDraws = 0;
-    let maxGeometries = 0;
-    for (const event of events) {
-        byCulprit.set(event.culprit, (byCulprit.get(event.culprit) ?? 0) + 1);
-        maxFrameMs = Math.max(maxFrameMs, event.frameMs);
-        if (event.render !== null) {
-            maxDraws = Math.max(maxDraws, event.render.drawCalls);
-            maxGeometries = Math.max(maxGeometries, event.render.geometries);
-        }
-    }
-    const culprits = [...byCulprit.entries()]
-        .sort((a, b) => b[1] - a[1])
-        .map(([culprit, count]) => ({ culprit, count }));
-    return {
-        count: events.length,
-        culprits,
-        maxFrameMs: roundMs(maxFrameMs),
-        maxDrawCalls: maxDraws > 0 ? maxDraws : undefined,
-        maxGeometries: maxGeometries > 0 ? maxGeometries : undefined,
-    };
-}
-/** @internal */
-export function buildLeanReport(playable) {
-    const snap = devtools.snapshot();
-    const frame = snap.frame;
-    const longs = snap.longFrames;
-    const why = frame !== null ? diagnose(frame, longs) : null;
-    const changedControls = snap.controls
-        .filter((control) => !Object.is(control.value, control.initial))
-        .map((control) => ({ name: control.name, value: control.value, initial: control.initial }));
-    const enabledDiscovered = snap.discovered
-        .filter((entry) => entry.enabled)
-        .map((entry) => ({ id: entry.id, value: entry.value }));
-    const hotLogs = snap.logs.filter((entry) => entry.level === "warn" || entry.level === "error").slice(-20);
-    return {
-        game: playable.game.name,
-        at: snap.at,
-        why,
-        frame: frame === null
-            ? null
-            : {
-                fps: roundMs(frame.fps, 1),
-                avgFrameMs: roundMs(frame.avgFrameMs),
-                p95FrameMs: roundMs(frame.p95FrameMs),
-                maxFrameMs: roundMs(frame.maxFrameMs),
-                avgSimMs: roundMs(frame.avgSimMs),
-                maxSimMs: roundMs(frame.maxSimMs),
-                avgOutsideMs: roundMs(frame.avgOutsideMs),
-                maxOutsideMs: roundMs(frame.maxOutsideMs),
-                longFrames: frame.longFrames,
-                samples: frame.samples,
-                phases: frame.phases.slice(0, 8).map((phase) => ({
-                    name: phase.name,
-                    avgMs: roundMs(phase.avgMs),
-                    maxMs: roundMs(phase.maxMs),
-                    pctOfSim: Math.round(phase.pctOfSim),
-                })),
-            },
-        render: snap.render,
-        latency: snap.latency,
-        longFrameSummary: summarizeLongFrames(longs),
-        longFrames: longs.slice(-6).map(compactLongFrame),
-        probes: snap.probes,
-        logs: hotLogs.length > 0 ? hotLogs : undefined,
-        controls: changedControls.length > 0 ? changedControls : undefined,
-        discovered: enabledDiscovered.length > 0 ? enabledDiscovered : undefined,
-        discoveredCount: snap.discovered.length,
-    };
-}
-/** @internal */
-export function buildFullReport(playable) {
-    return { game: playable.game.name, ...devtools.snapshot() };
-}
+export { buildLeanReport, buildFullReport } from "./devtoolsReports.js";
 /** @internal */
 export function DevtoolsOverlay({ open, ctx, playable, multiplayer, }) {
     const [tab, setTab] = useState("perf");
     const [, setTick] = useState(0);
     const [copied, setCopied] = useState(false);
     useSyncExternalStore(devtools.signal.subscribe, devtools.signal.version, devtools.signal.version);
-    useEffect(() => {
-        devtools.logs.captureConsole();
-        globalThis.__JG_DEVTOOLS = {
-            snapshot: () => buildLeanReport(playable),
-            snapshotFull: () => buildFullReport(playable),
-            controls: devtools.controls,
-            discover: devtools.discover,
-            frame: devtools.frame,
-            profile: devtools.profile,
-            collisionDebug,
-        };
-    }, [playable]);
-    useEffect(() => {
-        devtools.discover.scanTable("game", playable);
-        devtools.discover.scanTable("engine", { movement: MOVEMENT_TUNING });
-    }, [playable]);
-    useEffect(() => {
-        const stored = readStoredOverrides(playable.game.name);
-        if (stored === null)
-            return;
-        const appliedEnables = new Set();
-        const appliedValues = new Set();
-        const applyLateRegistrations = () => {
-            const discovered = new Map(devtools.discover.list().map((entry) => [entry.id, entry]));
-            const needEnable = stored.enabled.filter((id) => !appliedEnables.has(id) && discovered.get(id)?.enabled === false);
-            const needValue = Object.entries(stored.values).filter(([name]) => !appliedValues.has(name) && devtools.controls.get(name) !== null);
-            if (needEnable.length === 0 && needValue.length === 0)
-                return;
-            for (const id of needEnable)
-                appliedEnables.add(id);
-            for (const [name] of needValue)
-                appliedValues.add(name);
-            devtools.overrides.apply({ enabled: needEnable, values: Object.fromEntries(needValue) });
-        };
-        applyLateRegistrations();
-        return devtools.signal.subscribe(applyLateRegistrations);
-    }, [playable]);
-    useEffect(() => {
-        const disposers = [
-            devtools.probes.register("entities", () => ctx.scene.entity.list().length),
-            devtools.probes.register("objects", () => ctx.scene.object.list().length),
-            devtools.probes.register("fallbacks", () => fallbackSeamsSnapshot()),
-            devtools.probes.register("textureErrors", () => textureErrorsSnapshot()),
-            devtools.probes.register("heavyModels", () => heavyModels()),
-        ];
-        return () => {
-            for (const dispose of disposers)
-                dispose();
-        };
-    }, [ctx]);
     useEffect(() => {
         if (!open)
             return;
-        const interval = setInterval(() => setTick((current) => current + 1), REFRESH_MS);
-        return () => clearInterval(interval);
-    }, [open]);
+        let lastRefresh = 0;
+        return ctx.subscribe(() => {
+            const now = performance.now();
+            if (now - lastRefresh < REFRESH_MS)
+                return;
+            lastRefresh = now;
+            setTick((current) => current + 1);
+        });
+    }, [ctx, open]);
     if (!open)
         return null;
     const copyReport = () => {

package/dist/devtools/DevtoolsRuntime.d.ts

@@ -0,0 +1,7 @@
+import type { GameContext } from "@jgengine/core/runtime/gameContext";
+import type { PlayableGame } from "../registry.js";
+/** Keeps saved overrides and diagnostic registration live while the visual panel is closed. @internal */
+export declare function DevtoolsRuntime({ ctx, playable }: {
+    ctx: GameContext;
+    playable: PlayableGame;
+}): null;

package/dist/devtools/DevtoolsRuntime.js

@@ -0,0 +1,61 @@
+import { useEffect } from "react";
+import { devtools } from "@jgengine/core/devtools/devtools";
+import { fallbackSeamsSnapshot } from "@jgengine/core/devtools/fallbackSeams";
+import { textureErrorsSnapshot } from "@jgengine/core/devtools/textureErrors";
+import { MOVEMENT_TUNING } from "@jgengine/core/movement/movementModel";
+import { collisionDebug } from "./collisionDebug.js";
+import { readStoredOverrides } from "./devtoolsOverrides.js";
+import { buildLeanReport, buildFullReport } from "./devtoolsReports.js";
+/** Keeps saved overrides and diagnostic registration live while the visual panel is closed. @internal */
+export function DevtoolsRuntime({ ctx, playable }) {
+    useEffect(() => {
+        devtools.logs.captureConsole();
+        globalThis.__JG_DEVTOOLS = {
+            snapshot: () => buildLeanReport(playable),
+            snapshotFull: () => buildFullReport(playable),
+            controls: devtools.controls,
+            discover: devtools.discover,
+            frame: devtools.frame,
+            profile: devtools.profile,
+            collisionDebug,
+        };
+    }, [playable]);
+    useEffect(() => {
+        devtools.discover.scanTable("game", playable);
+        devtools.discover.scanTable("engine", { movement: MOVEMENT_TUNING });
+    }, [playable]);
+    useEffect(() => {
+        const stored = readStoredOverrides(playable.game.name);
+        if (stored === null)
+            return;
+        const appliedEnables = new Set();
+        const appliedValues = new Set();
+        const applyLateRegistrations = () => {
+            const discovered = new Map(devtools.discover.list().map((entry) => [entry.id, entry]));
+            const needEnable = stored.enabled.filter((id) => !appliedEnables.has(id) && discovered.get(id)?.enabled === false);
+            const needValue = Object.entries(stored.values).filter(([name]) => !appliedValues.has(name) && devtools.controls.get(name) !== null);
+            if (needEnable.length === 0 && needValue.length === 0)
+                return;
+            for (const id of needEnable)
+                appliedEnables.add(id);
+            for (const [name] of needValue)
+                appliedValues.add(name);
+            devtools.overrides.apply({ enabled: needEnable, values: Object.fromEntries(needValue) });
+        };
+        applyLateRegistrations();
+        return devtools.signal.subscribe(applyLateRegistrations);
+    }, [playable]);
+    useEffect(() => {
+        const disposers = [
+            devtools.probes.register("entities", () => ctx.scene.entity.list().length),
+            devtools.probes.register("objects", () => ctx.scene.object.list().length),
+            devtools.probes.register("fallbacks", () => fallbackSeamsSnapshot()),
+            devtools.probes.register("textureErrors", () => textureErrorsSnapshot()),
+        ];
+        return () => {
+            for (const dispose of disposers)
+                dispose();
+        };
+    }, [ctx]);
+    return null;
+}

package/dist/devtools/agentBridge.js

@@ -2,7 +2,7 @@ import { devtools } from "@jgengine/core/devtools/devtools";
 import { getSaveEndpoint } from "@jgengine/core/devtools/saveEndpoint";
 import { isHudAnchor, listActiveHudLayouts, } from "@jgengine/core/ui/hudLayout";
 import { listHudPanelTypes, resolvePanelResize, resizePanelSize, } from "@jgengine/core/ui/hudDocument";
-import { buildFullReport, buildLeanReport } from "./DevtoolsOverlay.js";
+import { buildFullReport, buildLeanReport } from "./devtoolsReports.js";
 /**
  * @internal
  * Resolves true once `isLive()` reports a mounted editor host, polling every `intervalMs` up to

package/dist/devtools/devtoolsReports.d.ts

@@ -0,0 +1,68 @@
+import { type DevtoolsSnapshot } from "@jgengine/core/devtools/devtools";
+import type { PlayableGame } from "../registry.js";
+/** @internal */
+export declare function buildLeanReport(playable: PlayableGame): {
+    game: string;
+    at: number;
+    why: string | null;
+    frame: {
+        fps: number;
+        avgFrameMs: number;
+        p95FrameMs: number;
+        maxFrameMs: number;
+        avgSimMs: number;
+        maxSimMs: number;
+        avgOutsideMs: number;
+        maxOutsideMs: number;
+        longFrames: number;
+        samples: number;
+        phases: {
+            name: string;
+            avgMs: number;
+            maxMs: number;
+            pctOfSim: number;
+        }[];
+    } | null;
+    render: import("@jgengine/core/devtools/types").RenderSample | null;
+    latency: import("@jgengine/core/devtools/types").LatencyStats | null;
+    longFrameSummary: {
+        count: number;
+        culprits: {
+            culprit: string;
+            count: number;
+        }[];
+        maxFrameMs: number;
+        maxDrawCalls: number | undefined;
+        maxGeometries: number | undefined;
+    } | null;
+    longFrames: {
+        at: number;
+        frameMs: number;
+        simMs: number;
+        outsideMs: number;
+        culprit: string;
+        reason: string;
+        phases: {
+            name: string;
+            ms: number;
+        }[];
+        probes: Record<string, unknown>;
+        render: import("@jgengine/core/devtools/types").RenderSample | null;
+    }[];
+    probes: Record<string, unknown>;
+    logs: import("@jgengine/core/devtools/types").DevtoolsLogEntry[] | undefined;
+    controls: {
+        name: string;
+        value: unknown;
+        initial: unknown;
+    }[] | undefined;
+    discovered: {
+        id: string;
+        value: unknown;
+    }[] | undefined;
+    discoveredCount: number;
+};
+/** @internal */
+export declare function buildFullReport(playable: PlayableGame): DevtoolsSnapshot & {
+    game: string;
+};

package/dist/devtools/devtoolsReports.js

@@ -0,0 +1,100 @@
+import { devtools } from "@jgengine/core/devtools/devtools";
+import { diagnose } from "./perfDiagnose.js";
+function roundMs(value, digits = 1) {
+    const scale = 10 ** digits;
+    return Math.round(value * scale) / scale;
+}
+function compactLongFrame(event) {
+    return {
+        at: event.at,
+        frameMs: roundMs(event.frameMs),
+        simMs: roundMs(event.simMs),
+        outsideMs: roundMs(event.outsideMs),
+        culprit: event.culprit,
+        reason: event.reason,
+        phases: event.phases.slice(0, 4).map((phase) => ({
+            name: phase.name,
+            ms: roundMs(phase.ms),
+        })),
+        probes: event.probes,
+        render: event.render,
+    };
+}
+function summarizeLongFrames(events) {
+    if (events.length === 0)
+        return null;
+    const byCulprit = new Map();
+    let maxFrameMs = 0;
+    let maxDraws = 0;
+    let maxGeometries = 0;
+    for (const event of events) {
+        byCulprit.set(event.culprit, (byCulprit.get(event.culprit) ?? 0) + 1);
+        maxFrameMs = Math.max(maxFrameMs, event.frameMs);
+        if (event.render !== null) {
+            maxDraws = Math.max(maxDraws, event.render.drawCalls);
+            maxGeometries = Math.max(maxGeometries, event.render.geometries);
+        }
+    }
+    const culprits = [...byCulprit.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .map(([culprit, count]) => ({ culprit, count }));
+    return {
+        count: events.length,
+        culprits,
+        maxFrameMs: roundMs(maxFrameMs),
+        maxDrawCalls: maxDraws > 0 ? maxDraws : undefined,
+        maxGeometries: maxGeometries > 0 ? maxGeometries : undefined,
+    };
+}
+/** @internal */
+export function buildLeanReport(playable) {
+    const snap = devtools.snapshot();
+    const frame = snap.frame;
+    const longs = snap.longFrames;
+    const why = frame !== null ? diagnose(frame, longs) : null;
+    const changedControls = snap.controls
+        .filter((control) => !Object.is(control.value, control.initial))
+        .map((control) => ({ name: control.name, value: control.value, initial: control.initial }));
+    const enabledDiscovered = snap.discovered
+        .filter((entry) => entry.enabled)
+        .map((entry) => ({ id: entry.id, value: entry.value }));
+    const hotLogs = snap.logs.filter((entry) => entry.level === "warn" || entry.level === "error").slice(-20);
+    return {
+        game: playable.game.name,
+        at: snap.at,
+        why,
+        frame: frame === null
+            ? null
+            : {
+                fps: roundMs(frame.fps, 1),
+                avgFrameMs: roundMs(frame.avgFrameMs),
+                p95FrameMs: roundMs(frame.p95FrameMs),
+                maxFrameMs: roundMs(frame.maxFrameMs),
+                avgSimMs: roundMs(frame.avgSimMs),
+                maxSimMs: roundMs(frame.maxSimMs),
+                avgOutsideMs: roundMs(frame.avgOutsideMs),
+                maxOutsideMs: roundMs(frame.maxOutsideMs),
+                longFrames: frame.longFrames,
+                samples: frame.samples,
+                phases: frame.phases.slice(0, 8).map((phase) => ({
+                    name: phase.name,
+                    avgMs: roundMs(phase.avgMs),
+                    maxMs: roundMs(phase.maxMs),
+                    pctOfSim: Math.round(phase.pctOfSim),
+                })),
+            },
+        render: snap.render,
+        latency: snap.latency,
+        longFrameSummary: summarizeLongFrames(longs),
+        longFrames: longs.slice(-6).map(compactLongFrame),
+        probes: snap.probes,
+        logs: hotLogs.length > 0 ? hotLogs : undefined,
+        controls: changedControls.length > 0 ? changedControls : undefined,
+        discovered: enabledDiscovered.length > 0 ? enabledDiscovered : undefined,
+        discoveredCount: snap.discovered.length,
+    };
+}
+/** @internal */
+export function buildFullReport(playable) {
+    return { game: playable.game.name, ...devtools.snapshot() };
+}

package/dist/devtools/latencyInstrumentation.d.ts

@@ -0,0 +1,3 @@
+import type { ShellMultiplayer } from "../multiplayer.js";
+/** @internal */
+export declare function withDevtoolsLatency(multiplayer: ShellMultiplayer): ShellMultiplayer;

package/dist/devtools/latencyInstrumentation.js

@@ -0,0 +1,11 @@
+import { instrumentLatency } from "@jgengine/core/devtools/devtools";
+/** @internal */
+export function withDevtoolsLatency(multiplayer) {
+    return {
+        ...multiplayer,
+        backend: {
+            ...instrumentLatency(multiplayer.backend, ["pushFeedEntry"]),
+            transport: instrumentLatency(multiplayer.backend.transport, ["joinServer", "leaveServer", "runCommand"]),
+        },
+    };
+}

package/dist/devtools/playtestProbe.d.ts

@@ -0,0 +1,4 @@
+type Probe = () => Record<string, number>;
+/** @internal Attach a live capture probe for one shell boot; cleanup retires retained readers. */
+export declare function attachPlaytestProbe(host: object, read: Probe): () => void;
+export {};

package/dist/devtools/playtestProbe.js

@@ -0,0 +1,22 @@
+/** @internal Attach a live capture probe for one shell boot; cleanup retires retained readers. */
+export function attachPlaytestProbe(host, read) {
+    const target = host;
+    let active = true;
+    const probe = () => {
+        if (!active)
+            return {};
+        try {
+            const value = read();
+            return value !== null && typeof value === "object" ? value : {};
+        }
+        catch {
+            return {};
+        }
+    };
+    target.__jgProbe = probe;
+    return () => {
+        active = false;
+        if (target.__jgProbe === probe)
+            delete target.__jgProbe;
+    };
+}

package/dist/drivers/FrameDriver.js

@@ -29,12 +29,12 @@ export function FrameDriver({ ctx, playable, tracker, yawRef, pitchRef, primaryC
     const repeatFiredAtRef = useRef(new Map());
     const slotActions = useMemo(() => findHotbarSlotActions(playable.game.input), [playable]);
     const hotbarId = useMemo(() => hotbarIdFor(playable), [playable]);
-    const movementTuning = useMemo(() => resolvePlayerMovementTuning({
-        collision: playable.collision,
-        movement: playable.movement,
-        physics: playable.game.physics,
-        world: playable.game.world,
-    }), [playable]);
+    const movementTuning = useMemo(() => ({ ...resolvePlayerMovementTuning({
+            collision: playable.collision,
+            movement: playable.movement,
+            physics: playable.game.physics,
+            world: playable.game.world,
+        }), authoritativeStep: true }), [playable]);
     const autoPickupRadius = useMemo(() => {
         const cfg = playable.worldItem?.autoPickup;
         if (cfg === undefined || cfg === false)
@@ -106,7 +106,7 @@ export function FrameDriver({ ctx, playable, tracker, yawRef, pitchRef, primaryC
             inputSink.send(frame);
         };
         if (gateRef.current || !playControlsActive(ctx)) {
-            ctx.input.publish(heldActionsFor(tracker, NO_ACTIONS));
+            ctx.input.publish(heldActionsFor(tracker, NO_ACTIONS), { reset: true });
             ctx.input.publishAnalog(null);
             sendInput();
             return;
@@ -115,7 +115,7 @@ export function FrameDriver({ ctx, playable, tracker, yawRef, pitchRef, primaryC
         try {
             let endPhase = devtools.profile.begin("time+input");
             const dt = Math.min(rawDt, 0.05);
-            ctx.input.publish(heldActionsFor(tracker, tracker.actions()));
+            ctx.input.publish(heldActionsFor(tracker, tracker.actions()), {});
             ctx.input.publishPointer(pointerAxisRef.current);
             ctx.input.publishAnalog(analogRef.current);
             sendInput();
@@ -124,32 +124,35 @@ export function FrameDriver({ ctx, playable, tracker, yawRef, pitchRef, primaryC
                 yawRef.current = steerYaw(yawRef.current, turnInput, TURN_SPEED, dt);
             endPhase();
             const playerId = ctx.player.possession.active(ctx.player.userId);
-            ctx.sim.advance(dt, (stepDt) => {
-                const gameDt = ctx.time.advance(stepDt);
-                ctx.sim.runStages("beforeMovement", stepDt);
+            ctx.sim.advance(dt, (stepDt, _tick, gameDt) => {
+                ctx.input.beginStep();
+                const movementDt = serverAuthoritative ? stepDt : gameDt;
+                if (!serverAuthoritative)
+                    ctx.sim.runStages("beforeMovement", stepDt);
                 const player = ctx.scene.entity.get(playerId);
                 // Server-authoritative sessions still run the deterministic local step as a prediction; the
                 // replicated pose is the confirmation that the transport reconciles on the next world diff.
-                if (player !== null && drivesPose) {
+                if (player !== null && drivesPose && movementDt > 0) {
                     const endPose = devtools.profile.begin("pose");
-                    stepPlayerMovement(ctx, ctx.player.userId, { held: ctx.input.held(), pointer: ctx.input.pointer(), analog: ctx.input.analog() }, stepDt, movementTuning, yawRef.current, pitchRef.current);
+                    stepPlayerMovement(ctx, ctx.player.userId, { held: ctx.input.held(), pointer: ctx.input.pointer(), analog: ctx.input.analog() }, movementDt, movementTuning, yawRef.current, pitchRef.current);
                     const predicted = ctx.scene.entity.get(playerId);
                     if (predicted !== null) {
-                        predictionRef.current.record({ held: ctx.input.held(), pointer: ctx.input.pointer(), analog: ctx.input.analog(), tick: ctx.sim.tick() }, stepDt, predicted.position);
+                        predictionRef.current.record({ held: ctx.input.held(), pointer: ctx.input.pointer(), analog: ctx.input.analog(), tick: ctx.sim.tick() }, movementDt, predicted.position);
                     }
                     endPose();
                 }
-                if (drivesPose && !serverAuthoritative) {
+                if (drivesPose && !serverAuthoritative && movementDt > 0) {
                     const table = localPlayers(ctx);
                     const seats = table.slots();
                     for (let index = 1; index < seats.length; index += 1) {
                         const seat = table.local(seats[index].slotId);
                         if (seat === null)
                             continue;
-                        stepPlayerMovement(ctx, seat.userId, { held: seat.input.held(), pointer: null, analog: seat.input.analog() }, stepDt, movementTuning, seatCameraYaw(ctx, seat.userId));
+                        stepPlayerMovement(ctx, seat.userId, { held: seat.input.held(), pointer: null, analog: seat.input.analog() }, movementDt, movementTuning, seatCameraYaw(ctx, seat.userId));
                     }
                 }
-                ctx.sim.runStages("afterMovement", stepDt);
+                if (!serverAuthoritative)
+                    ctx.sim.runStages("afterMovement", stepDt);
                 if (autoPickupRadius !== null && !serverAuthoritative) {
                     const endPickup = devtools.profile.begin("pickup");
                     const self = ctx.scene.entity.get(playerId);
@@ -166,18 +169,19 @@ export function FrameDriver({ ctx, playable, tracker, yawRef, pitchRef, primaryC
                     });
                     advanceBehaviors(ctx, gameDt);
                 }
-                ctx.sim.runStages("afterTick", stepDt);
-            });
+                if (!serverAuthoritative)
+                    ctx.sim.runStages("afterTick", stepDt);
+            }, { advanceTime: !serverAuthoritative });
             endPhase = devtools.profile.begin("actions");
             if (tracker.wasPressed("tabTarget")) {
                 if (ctx.game.commands.has("target.cycle"))
-                    ctx.game.commands.run("target.cycle", {});
+                    commandSink.run("target.cycle", {});
                 else
                     ctx.scene.entity.cycleTarget(playerId, { filter: "hostile" });
             }
             if (tracker.wasPressed("clearTarget")) {
                 if (ctx.game.commands.has("target.clear"))
-                    ctx.game.commands.run("target.clear", {});
+                    commandSink.run("target.clear", {});
                 else
                     ctx.scene.entity.setTarget(playerId, null);
             }

package/dist/drivers/HudOnlyDriver.d.ts

@@ -1,9 +1,14 @@
 import type { GameContext } from "@jgengine/core/runtime/gameContext";
 import type { PointerAxisState } from "@jgengine/core/input/pointerAxis";
 import type { ActionStateTracker } from "@jgengine/core/input/actionBindings";
+import type { ShellMultiplayer } from "../multiplayer.js";
 import type { PlayableGame } from "../registry.js";
-export declare function HudOnlyDriver({ ctx, playable, tracker, pointerAxisRef, gateRef, onRuntimeError, }: {
+export declare function HudOnlyDriver({ ctx, multiplayer, serverIdRef, playable, tracker, pointerAxisRef, gateRef, onRuntimeError, }: {
     ctx: GameContext;
+    multiplayer: ShellMultiplayer | null;
+    serverIdRef: {
+        current: string | null;
+    };
     playable: PlayableGame;
     tracker: ActionStateTracker<string>;
     pointerAxisRef: {