@jgengine/shell 0.18.1 → 0.21.0

package/dist/devtools/agentBridge.js

@@ -2,7 +2,21 @@ 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
+ * `timeoutMs`. `editor_summon` awaits this so the next RPC verb in a `drive` batch finds the editor.
+ */
+export async function waitForEditorHost(isLive, timeoutMs = 15_000, intervalMs = 100, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))) {
+    for (let waited = 0;; waited += intervalMs) {
+        if (isLive())
+            return true;
+        if (waited >= timeoutMs)
+            return false;
+        await sleep(intervalMs);
+    }
+}
 async function saveScene(editorHost) {
     const endpoint = getSaveEndpoint();
     if (endpoint === null)
@@ -239,7 +253,7 @@ export function installAgentBridge(options) {
                     return { ok: false, error: "no editor summoner on this page — open with ?mode=editor" };
                 }
                 window.__jgengineSummonEditor();
-                return { ok: true, live: false };
+                return waitForEditorHost(() => window.__jgengineEditorHost !== undefined).then((live) => live ? { ok: true, live: true } : { ok: false, error: "editor did not mount within 15s" });
             }
             case "save_scene": {
                 const editorHost = window.__jgengineEditorHost;

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/diagnostics/FpsCounter.d.ts

@@ -0,0 +1,17 @@
+import { type ReactElement } from "react";
+/** Mutable frame tally shared between the in-Canvas probe and the DOM readout. */
+export interface FrameTally {
+    frames: number;
+}
+/** Counts rendered frames. Mount inside the Canvas. @internal */
+export declare function FpsProbe({ tally }: {
+    tally: FrameTally;
+}): null;
+/**
+ * Player-facing frames-per-second readout, sampled twice a second from rendered frames (not
+ * display refreshes), so it reflects the frame-rate limit and GPU load.
+ * @internal shell-internal; shown by the `graphics.showFps` setting.
+ */
+export declare function FpsCounter({ tally }: {
+    tally: FrameTally;
+}): ReactElement;

package/dist/diagnostics/FpsCounter.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useFrame } from "@react-three/fiber";
+import { useEffect, useRef } from "react";
+/** Counts rendered frames. Mount inside the Canvas. @internal */
+export function FpsProbe({ tally }) {
+    useFrame(() => {
+        tally.frames += 1;
+    });
+    return null;
+}
+/**
+ * Player-facing frames-per-second readout, sampled twice a second from rendered frames (not
+ * display refreshes), so it reflects the frame-rate limit and GPU load.
+ * @internal shell-internal; shown by the `graphics.showFps` setting.
+ */
+export function FpsCounter({ tally }) {
+    const label = useRef(null);
+    useEffect(() => {
+        let last = performance.now();
+        tally.frames = 0;
+        const timer = setInterval(() => {
+            const now = performance.now();
+            const fps = (tally.frames * 1000) / Math.max(1, now - last);
+            tally.frames = 0;
+            last = now;
+            if (label.current !== null)
+                label.current.textContent = `${fps < 10 ? fps.toFixed(1) : Math.round(fps)} FPS`;
+        }, 500);
+        return () => clearInterval(timer);
+    }, [tally]);
+    return (_jsx("div", { className: "pointer-events-none absolute bottom-1 right-1 z-50 rounded bg-black/60 px-2 py-0.5 font-mono text-xs tabular-nums text-emerald-300", children: _jsx("span", { ref: label, children: "-- FPS" }) }));
+}

package/dist/drivers/FrameDriver.js

@@ -6,6 +6,8 @@ import { pointerAimFor } from "../shellPointer.js";
 import { shellDrivesPlayerPose } from "../shellMovement.js";
 import { steerYaw } from "@jgengine/core/movement/steering";
 import { stepPlayerMovement, resolvePlayerMovementTuning } from "@jgengine/core/movement/playerMovement";
+import { localPlayers } from "@jgengine/core/runtime/localPlayers";
+import { seatCameraYaw } from "../camera/Viewports.js";
 import { isServerAuthoritative } from "@jgengine/core/runtime/adapter";
 import { resolveCommandSink } from "../commandSink.js";
 import { inputFramesEqual, resolveInputSink } from "../inputSink.js";
@@ -27,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)
@@ -57,7 +59,6 @@ export function FrameDriver({ ctx, playable, tracker, yawRef, pitchRef, primaryC
         }).send(frame),
     }), [multiplayer, serverAuthoritative, serverIdRef]);
     const lastSentInputRef = useRef(null);
-    const inputActions = useMemo(() => Object.keys(playable.game.input ?? {}), [playable]);
     const predictionRef = useRef(createPredictionBuffer({
         initial: [0, 0, 0],
         maxTicks: 120,
@@ -105,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;
@@ -114,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, inputActions));
+            ctx.input.publish(heldActionsFor(tracker, tracker.actions()), {});
             ctx.input.publishPointer(pointerAxisRef.current);
             ctx.input.publishAnalog(analogRef.current);
             sendInput();
@@ -123,22 +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();
                 }
-                ctx.sim.runStages("afterMovement", stepDt);
+                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() }, movementDt, movementTuning, seatCameraYaw(ctx, seat.userId));
+                    }
+                }
+                if (!serverAuthoritative)
+                    ctx.sim.runStages("afterMovement", stepDt);
                 if (autoPickupRadius !== null && !serverAuthoritative) {
                     const endPickup = devtools.profile.begin("pickup");
                     const self = ctx.scene.entity.get(playerId);
@@ -155,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/FrameRateLimiter.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Drives the Canvas at a capped frame rate. Mount only with `frameloop="never"`: it runs its
+ * own requestAnimationFrame loop and advances R3F on the refreshes `paceFrame` admits, so
+ * simulation, useFrame and rendering all run at the cap with correct deltas.
+ * @internal shell-internal; driven by the player's frame-rate limit setting.
+ */
+export declare function FrameRateLimiter({ fps }: {
+    fps: number;
+}): null;

package/dist/drivers/FrameRateLimiter.js

@@ -0,0 +1,39 @@
+import { useThree } from "@react-three/fiber";
+import { useEffect } from "react";
+import { paceFrame } from "@jgengine/core/settings/frameRateLimit";
+/**
+ * Drives the Canvas at a capped frame rate. Mount only with `frameloop="never"`: it runs its
+ * own requestAnimationFrame loop and advances R3F on the refreshes `paceFrame` admits, so
+ * simulation, useFrame and rendering all run at the cap with correct deltas.
+ * @internal shell-internal; driven by the player's frame-rate limit setting.
+ */
+export function FrameRateLimiter({ fps }) {
+    const advance = useThree((state) => state.advance);
+    const get = useThree((state) => state.get);
+    useEffect(() => {
+        if (fps <= 0)
+            return;
+        // R3F's "never" mode reads the timestamp as seconds on its own clock; continue that clock.
+        const base = get().clock.elapsedTime;
+        let start = null;
+        let anchor = 0;
+        let frame = requestAnimationFrame(function tick(now) {
+            frame = requestAnimationFrame(tick);
+            if (start === null) {
+                start = now;
+                anchor = now;
+            }
+            const next = paceFrame(now, anchor, fps);
+            if (next === null)
+                return;
+            anchor = next;
+            advance(base + (now - start) / 1000, true);
+        });
+        return () => {
+            cancelAnimationFrame(frame);
+            // Hand the clock back to R3F's own loop in milliseconds so its next delta is one frame.
+            get().clock.oldTime = performance.now();
+        };
+    }, [fps, advance, get]);
+    return 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: {

package/dist/drivers/HudOnlyDriver.js

@@ -3,12 +3,17 @@ import { dispatchBoundAction, heldActionsFor, shouldFireBoundAction } from "../b
 import { advanceBehaviors } from "@jgengine/core/scene/behaviorRuntime";
 import { playControlsActive } from "@jgengine/core/game/controlGate";
 import { devtools } from "@jgengine/core/devtools/devtools";
+import { isServerAuthoritative } from "@jgengine/core/runtime/adapter";
+import { resolveCommandSink } from "../commandSink.js";
+import { inputFramesEqual, resolveInputSink } from "../inputSink.js";
 import { EMPTY_RESERVED, NO_ACTIONS } from "../shellConstants.js";
-export function HudOnlyDriver({ ctx, playable, tracker, pointerAxisRef, gateRef, onRuntimeError, }) {
+export function HudOnlyDriver({ ctx, multiplayer, serverIdRef, playable, tracker, pointerAxisRef, gateRef, onRuntimeError, }) {
     const hasReportedTickError = useRef(false);
     const repeatFiredAtRef = useRef(new Map());
     const lastFrameRef = useRef(null);
     const inputActions = useMemo(() => Object.keys(playable.game.input ?? {}), [playable]);
+    const lastSentInputRef = useRef(null);
+    const serverAuthoritative = isServerAuthoritative(playable.game.multiplayer) && multiplayer !== null;
     useEffect(() => {
         let frameId;
         const tick = (now) => {
@@ -17,8 +22,19 @@ export function HudOnlyDriver({ ctx, playable, tracker, pointerAxisRef, gateRef,
             lastFrameRef.current = now;
             if (last === null)
                 return;
+            const sendInput = () => {
+                if (!serverAuthoritative || serverIdRef.current === null)
+                    return;
+                const frame = { held: ctx.input.held(), pointer: ctx.input.pointer(), analog: ctx.input.analog() };
+                if (lastSentInputRef.current !== null && inputFramesEqual(lastSentInputRef.current, frame))
+                    return;
+                lastSentInputRef.current = frame;
+                resolveInputSink({ serverAuthoritative, backend: multiplayer?.backend ?? null, serverId: serverIdRef.current }).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;
             }
             const rawDt = (now - last) / 1000;
@@ -26,26 +42,28 @@ export function HudOnlyDriver({ ctx, playable, tracker, pointerAxisRef, gateRef,
             try {
                 let endPhase = devtools.profile.begin("time+input");
                 const dt = Math.min(rawDt, 0.05);
-                ctx.input.publish(heldActionsFor(tracker, inputActions));
+                ctx.input.publish(heldActionsFor(tracker, tracker.actions()), {});
                 ctx.input.publishPointer(pointerAxisRef.current);
+                sendInput();
                 endPhase();
-                ctx.sim.advance(dt, (stepDt) => {
-                    const gameDt = ctx.time.advance(stepDt);
-                    ctx.sim.runStages("beforeMovement", stepDt);
-                    ctx.sim.runStages("afterMovement", stepDt);
-                    devtools.profile.measure("onTick", () => {
-                        playable.loop.onTick(ctx, gameDt);
+                if (!serverAuthoritative)
+                    ctx.sim.advance(dt, (stepDt, _tick, gameDt) => {
+                        ctx.input.beginStep();
+                        ctx.sim.runStages("beforeMovement", stepDt);
+                        ctx.sim.runStages("afterMovement", stepDt);
+                        devtools.profile.measure("onTick", () => {
+                            playable.loop.onTick(ctx, gameDt);
+                        });
+                        advanceBehaviors(ctx, gameDt);
+                        ctx.sim.runStages("afterTick", stepDt);
                     });
-                    advanceBehaviors(ctx, gameDt);
-                    ctx.sim.runStages("afterTick", stepDt);
-                });
                 endPhase = devtools.profile.begin("actions");
                 const nowMs = performance.now();
                 for (const action of inputActions) {
                     if (!shouldFireBoundAction(tracker, action, playable.game.input, repeatFiredAtRef.current, nowMs))
                         continue;
                     repeatFiredAtRef.current.set(action, nowMs);
-                    dispatchBoundAction(ctx, action, 0, 0, { yaw: 0, pitch: 0 }, EMPTY_RESERVED);
+                    dispatchBoundAction(ctx, action, 0, 0, { yaw: 0, pitch: 0 }, EMPTY_RESERVED, resolveCommandSink(ctx, { serverAuthoritative, backend: multiplayer?.backend ?? null, serverId: serverIdRef.current }));
                 }
                 tracker.endFrame();
                 endPhase();
@@ -60,6 +78,6 @@ export function HudOnlyDriver({ ctx, playable, tracker, pointerAxisRef, gateRef,
         };
         frameId = requestAnimationFrame(tick);
         return () => cancelAnimationFrame(frameId);
-    }, [ctx, playable, tracker, pointerAxisRef, gateRef, onRuntimeError, inputActions]);
+    }, [ctx, playable, tracker, pointerAxisRef, gateRef, onRuntimeError, inputActions, multiplayer, serverIdRef, serverAuthoritative]);
     return null;
 }

package/dist/environment/DayNightSky.js

@@ -2,7 +2,7 @@ import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-run
 import { useFrame } from "@react-three/fiber";
 import { useMemo, useRef } from "react";
 import * as THREE from "three";
-import { SkyDome } from "./Daylight.js";
+import { setSkyDomeColors, SkyDome, SunLight } from "./Daylight.js";
 import { daylightStateAt } from "./daylightCycle.js";
 const HEMI_GROUND = "#4c6b34";
 /**
@@ -22,22 +22,22 @@ export function DayNightSky({ cycle, radius, hazeStrength, sunGlowStrength, ligh
     const hemiRef = useRef(null);
     const initial = useMemo(() => cycle.sample(), [cycle]);
     const initialSun = useMemo(() => daylightStateAt(initial.dayFraction).sunPosition, [initial.dayFraction]);
+    const sunDirectionRef = useRef(initialSun);
     useFrame(() => {
         const sample = cycle.sample();
         const geometry = daylightStateAt(sample.dayFraction);
         const material = skyMaterialRef.current;
         if (material !== null) {
-            material.uniforms.topColor.value.set(sample.lightColor);
-            material.uniforms.bottomColor.value.set(sample.color);
+            setSkyDomeColors(material, sample.lightColor, sample.color);
             material.uniforms.uSunColor.value.set(sample.lightColor);
             material.uniforms.uSunDirection.value
                 .set(geometry.sunPosition[0], geometry.sunPosition[1], geometry.sunPosition[2])
                 .normalize();
             material.uniforms.uSunIntensity.value = sample.intensity;
         }
+        sunDirectionRef.current = geometry.sunPosition;
         const sun = sunRef.current;
         if (sun !== null) {
-            sun.position.set(geometry.sunPosition[0], geometry.sunPosition[1], geometry.sunPosition[2]);
             sun.intensity = sample.intensity * keyLightIntensity;
             sun.color.set(sample.lightColor);
         }
@@ -47,5 +47,5 @@ export function DayNightSky({ cycle, radius, hazeStrength, sunGlowStrength, ligh
             hemi.color.set(sample.lightColor);
         }
     });
-    return (_jsxs(_Fragment, { children: [_jsx(SkyDome, { topColor: initial.lightColor, horizonColor: initial.color, sunDirection: initialSun, sunColor: initial.lightColor, sunIntensity: initial.intensity, materialRef: skyMaterialRef, ...(radius === undefined ? {} : { radius }), ...(hazeStrength === undefined ? {} : { hazeStrength }), ...(sunGlowStrength === undefined ? {} : { sunGlowStrength }) }), lights ? (_jsxs(_Fragment, { children: [_jsx("hemisphereLight", { ref: hemiRef, args: [initial.lightColor, HEMI_GROUND, initial.intensity * ambientIntensity] }), _jsx("directionalLight", { ref: sunRef, position: initialSun, intensity: initial.intensity * keyLightIntensity, color: initial.lightColor, castShadow: true, "shadow-mapSize-width": 2048, "shadow-mapSize-height": 2048, "shadow-camera-left": -90, "shadow-camera-right": 90, "shadow-camera-top": 90, "shadow-camera-bottom": -90, "shadow-camera-near": 10, "shadow-camera-far": 520, "shadow-bias": -0.0004, "shadow-normalBias": 0.02 })] })) : null] }));
+    return (_jsxs(_Fragment, { children: [_jsx(SkyDome, { topColor: initial.lightColor, horizonColor: initial.color, sunDirection: initialSun, sunColor: initial.lightColor, sunIntensity: initial.intensity, materialRef: skyMaterialRef, ...(radius === undefined ? {} : { radius }), ...(hazeStrength === undefined ? {} : { hazeStrength }), ...(sunGlowStrength === undefined ? {} : { sunGlowStrength }) }), lights ? (_jsxs(_Fragment, { children: [_jsx("hemisphereLight", { ref: hemiRef, args: [initial.lightColor, HEMI_GROUND, initial.intensity * ambientIntensity] }), _jsx(SunLight, { direction: initialSun, directionRef: sunDirectionRef, lightRef: sunRef, intensity: initial.intensity * keyLightIntensity, color: initial.lightColor })] })) : null] }));
 }