@jgengine/shell 0.8.0 → 0.9.0

package/dist/cartridge.js

@@ -0,0 +1,245 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState, useSyncExternalStore } from "react";
+import { useFrame } from "@react-three/fiber";
+import { createCartridge } from "@jgengine/core/cartridge/runtime";
+import { WASD_KEYBINDS, leveled } from "@jgengine/core/cartridge/spec";
+import { validateCartridge } from "@jgengine/core/cartridge/validate";
+import { HudCanvas, HudPanel, useHudLayout } from "@jgengine/react";
+import { useAbilitySlots, useEntityStat } from "@jgengine/react/hooks";
+import { useGameContext } from "@jgengine/react/provider";
+import { defineGame } from "./defineGame.js";
+function useTick(intervalMs) {
+    const [, setTick] = useState(0);
+    useEffect(() => {
+        const id = window.setInterval(() => setTick((value) => value + 1), intervalMs);
+        return () => window.clearInterval(id);
+    }, [intervalMs]);
+}
+function useRunPhase(ctx, runtime) {
+    const run = runtime.run(ctx);
+    useSyncExternalStore(run.subscribe, () => `${run.phase}:${run.pendingOffers?.map((offer) => offer.id).join(",") ?? ""}`);
+}
+function winSeconds(config) {
+    return config.rules.win?.kind === "survive" ? config.rules.win.seconds : null;
+}
+function VitalItem({ config, item }) {
+    const ctx = useGameContext();
+    const value = useEntityStat(ctx.player.userId, item.stat);
+    if (value === null)
+        return null;
+    return _jsx(config.panels.Vital, { value: value, label: item.label, tone: item.tone, width: item.width });
+}
+function XpItem({ config, item }) {
+    const ctx = useGameContext();
+    const xp = useEntityStat(ctx.player.userId, "xp");
+    const level = useEntityStat(ctx.player.userId, "level");
+    if (xp === null)
+        return null;
+    const fraction = (xp.current - xp.min) / Math.max(1, xp.max - xp.min);
+    return _jsx(config.panels.Xp, { fraction: fraction, level: level?.current, width: item.width });
+}
+function TimerItem({ config, runtime, item, }) {
+    const ctx = useGameContext();
+    const target = winSeconds(config);
+    const elapsed = runtime.run(ctx).playingSeconds;
+    const seconds = target === null ? elapsed : Math.max(0, target - elapsed);
+    return _jsx(config.panels.Timer, { seconds: seconds, label: item.label });
+}
+function ScoreItem({ config, runtime, item, }) {
+    const ctx = useGameContext();
+    return _jsx(config.panels.Score, { value: runtime.run(ctx).kills, label: item.label, digits: item.digits });
+}
+function AbilityBarItem({ config, runtime, item, }) {
+    const ctx = useGameContext();
+    const slots = useAbilitySlots(runtime.weaponKit(ctx));
+    return (_jsx(config.panels.AbilityBar, { slots: slots.map((slot) => ({
+            id: slot.id,
+            icon: item.icons[slot.id] ?? slot.id,
+            state: slot.state,
+            cooldownFraction: slot.cooldownFraction,
+            justCast: slot.justCast,
+        })) }));
+}
+function PanelItems({ config, runtime, items, }) {
+    return (_jsx(_Fragment, { children: items.map((item, index) => {
+            switch (item.kind) {
+                case "vital":
+                    return _jsx(VitalItem, { config: config, item: item }, index);
+                case "xp":
+                    return _jsx(XpItem, { config: config, item: item }, index);
+                case "timer":
+                    return _jsx(TimerItem, { config: config, runtime: runtime, item: item }, index);
+                case "score":
+                    return _jsx(ScoreItem, { config: config, runtime: runtime, item: item }, index);
+                case "abilityBar":
+                    return _jsx(AbilityBarItem, { config: config, runtime: runtime, item: item }, index);
+                case "component":
+                    return _jsx(item.Component, {}, index);
+            }
+        }) }));
+}
+function WinScreenHost({ config, runtime }) {
+    const ctx = useGameContext();
+    const level = useEntityStat(ctx.player.userId, "level");
+    const win = config.screens.win;
+    if (win === undefined)
+        return null;
+    const run = runtime.run(ctx);
+    const lines = win.lines.map((line) => ({
+        label: line.label,
+        accent: line.accent,
+        value: "value" in line ? line.value : line.source === "kills" ? run.kills : (level?.current ?? 1),
+    }));
+    return _jsx(config.panels.WinScreen, { title: win.title, lines: lines });
+}
+function DraftModalHost({ config, runtime }) {
+    const ctx = useGameContext();
+    const offers = runtime.run(ctx).pendingOffers;
+    if (offers === null)
+        return null;
+    return _jsx(config.panels.DraftModal, { offers: offers, choose: (id) => runtime.chooseUpgrade(ctx, id) });
+}
+function CartridgeUI({ config, runtime }) {
+    const ctx = useGameContext();
+    const layout = useHudLayout({ storageKey: config.hud.storageKey ?? config.name });
+    useRunPhase(ctx, runtime);
+    useTick(200);
+    const run = runtime.run(ctx);
+    return (_jsxs("div", { style: { ...config.theme, display: "contents" }, children: [run.phase === "start" && (_jsx(config.panels.StartScreen, { title: config.screens.start?.title ?? config.name, subtitle: config.screens.start?.subtitle, buttonLabel: config.screens.start?.buttonLabel, begin: () => runtime.begin(ctx) })), run.phase === "countdown" && _jsx(config.panels.Countdown, { seconds: Math.ceil(run.countdownRemaining) }), run.phase === "lost" && config.screens.lose !== undefined && (_jsx(config.panels.LoseScreen, { title: config.screens.lose.title, subtitle: config.screens.lose.subtitle })), run.phase === "won" && _jsx(WinScreenHost, { config: config, runtime: runtime }), run.phase === "playing" && (_jsxs(HudCanvas, { layout: layout, children: [_jsx(DraftModalHost, { config: config, runtime: runtime }), config.hud.panels.map((panel) => (_jsx(HudPanel, { id: panel.id, anchor: panel.anchor, inset: panel.inset, style: panel.items.length > 1
+                            ? { display: "flex", flexDirection: "column", alignItems: "center", gap: 6 }
+                            : undefined, children: _jsx(PanelItems, { config: config, runtime: runtime, items: panel.items }) }, panel.id)))] }))] }));
+}
+const MAX_BOLTS = 10;
+const MAX_PULSES = 6;
+function hideMesh(mesh) {
+    if (mesh !== null)
+        mesh.visible = false;
+}
+function BoltPool({ runtime, weaponId, weapon, }) {
+    const ctx = useGameContext();
+    const refs = useRef(new Array(MAX_BOLTS).fill(null));
+    useFrame(() => {
+        const run = runtime.run(ctx);
+        const now = ctx.time.now();
+        const bolts = run.bolts.filter((bolt) => bolt.weaponId === weaponId);
+        for (let i = 0; i < MAX_BOLTS; i += 1) {
+            const mesh = refs.current[i];
+            const bolt = bolts[i];
+            if (mesh === null)
+                continue;
+            if (bolt === undefined) {
+                hideMesh(mesh);
+                continue;
+            }
+            const t = Math.min(1, Math.max(0, (now - bolt.firedAt) / bolt.travelSeconds));
+            mesh.visible = true;
+            mesh.position.set(bolt.origin[0] + (bolt.target[0] - bolt.origin[0]) * t, bolt.origin[1] + 0.9, bolt.origin[2] + (bolt.target[2] - bolt.origin[2]) * t);
+        }
+    });
+    return (_jsx(_Fragment, { children: Array.from({ length: MAX_BOLTS }, (_, i) => (_jsxs("mesh", { ref: (mesh) => {
+                refs.current[i] = mesh;
+            }, visible: false, children: [_jsx("sphereGeometry", { args: [0.16, 8, 8] }), _jsx("meshStandardMaterial", { color: weapon.fxColor ?? "#8be9f0", emissive: weapon.fxEmissive ?? weapon.fxColor ?? "#8be9f0", emissiveIntensity: 1.6 })] }, i))) }));
+}
+function PulsePool({ runtime, weaponId, weapon, }) {
+    const ctx = useGameContext();
+    const refs = useRef(new Array(MAX_PULSES).fill(null));
+    useFrame(() => {
+        const run = runtime.run(ctx);
+        const now = ctx.time.now();
+        const pulses = run.pulses.filter((pulse) => pulse.weaponId === weaponId);
+        for (let i = 0; i < MAX_PULSES; i += 1) {
+            const mesh = refs.current[i];
+            const pulse = pulses[i];
+            if (mesh === null)
+                continue;
+            if (pulse === undefined) {
+                hideMesh(mesh);
+                continue;
+            }
+            const t = Math.min(1, Math.max(0, (now - pulse.firedAt) / pulse.durationSeconds));
+            const radius = Math.max(0.01, pulse.maxRadius * t);
+            mesh.visible = true;
+            mesh.position.set(pulse.at[0], pulse.at[1] + 0.05, pulse.at[2]);
+            mesh.scale.set(radius, radius, radius);
+            const material = mesh.material;
+            if (!Array.isArray(material))
+                material.opacity = 0.55 * (1 - t);
+        }
+    });
+    return (_jsx(_Fragment, { children: Array.from({ length: MAX_PULSES }, (_, i) => (_jsxs("mesh", { ref: (mesh) => {
+                refs.current[i] = mesh;
+            }, rotation: [-Math.PI / 2, 0, 0], visible: false, children: [_jsx("ringGeometry", { args: [0.85, 1, 48] }), _jsx("meshBasicMaterial", { color: weapon.fxColor ?? "#a566d9", transparent: true, opacity: 0.5 })] }, i))) }));
+}
+function OrbitPool({ runtime, weaponId, weapon, }) {
+    const ctx = useGameContext();
+    const maxBlades = Math.ceil(leveled(weapon.blades, weapon.maxLevel));
+    const groupRef = useRef(null);
+    const refs = useRef(new Array(maxBlades).fill(null));
+    useFrame(() => {
+        const run = runtime.run(ctx);
+        const player = ctx.scene.entity.get(ctx.player.userId);
+        if (player === null || run.phase !== "playing") {
+            if (groupRef.current !== null)
+                groupRef.current.visible = false;
+            return;
+        }
+        const level = run.weaponLevel(weaponId);
+        const blades = leveled(weapon.blades, level);
+        const radius = leveled(weapon.radius, level);
+        const angle = ctx.time.now() * weapon.angularSpeed;
+        if (groupRef.current !== null)
+            groupRef.current.visible = true;
+        for (let i = 0; i < maxBlades; i += 1) {
+            const mesh = refs.current[i];
+            if (mesh === null)
+                continue;
+            if (i >= blades) {
+                hideMesh(mesh);
+                continue;
+            }
+            const theta = angle + (i * Math.PI * 2) / blades;
+            mesh.visible = true;
+            mesh.position.set(player.position[0] + Math.cos(theta) * radius, player.position[1] + 0.55, player.position[2] + Math.sin(theta) * radius);
+        }
+    });
+    return (_jsx("group", { ref: groupRef, children: Array.from({ length: maxBlades }, (_, i) => (_jsxs("mesh", { ref: (mesh) => {
+                refs.current[i] = mesh;
+            }, visible: false, children: [_jsx("boxGeometry", { args: [0.32, 0.08, 0.14] }), _jsx("meshStandardMaterial", { color: weapon.fxColor ?? "#dfe9ea", emissive: weapon.fxEmissive ?? weapon.fxColor ?? "#dfe9ea", emissiveIntensity: 0.8 })] }, i))) }));
+}
+function CartridgeFxOverlay({ config, runtime }) {
+    return (_jsx("group", { children: Object.entries(config.weapons).map(([weaponId, weapon]) => {
+            if (weapon.kind === "projectile") {
+                return _jsx(BoltPool, { runtime: runtime, weaponId: weaponId, weapon: weapon }, weaponId);
+            }
+            if (weapon.kind === "pulse") {
+                return _jsx(PulsePool, { runtime: runtime, weaponId: weaponId, weapon: weapon }, weaponId);
+            }
+            if (weapon.kind === "orbit") {
+                return _jsx(OrbitPool, { runtime: runtime, weaponId: weaponId, weapon: weapon }, weaponId);
+            }
+            return null;
+        }) }));
+}
+export function cartridge(config) {
+    const problems = validateCartridge(config);
+    if (problems.length > 0) {
+        throw new Error(`cartridge "${config.name}": invalid spec:\n${problems.map((p) => `  - ${p}`).join("\n")}`);
+    }
+    const runtime = createCartridge(config);
+    return defineGame({
+        name: config.name,
+        assets: config.assets,
+        world: config.world,
+        physics: config.physics,
+        input: config.input ?? WASD_KEYBINDS,
+        save: config.save ?? "none",
+        content: runtime.content,
+        loop: runtime.loop,
+        GameUI: () => _jsx(CartridgeUI, { config: config, runtime: runtime }),
+        WorldOverlay: () => _jsx(CartridgeFxOverlay, { config: config, runtime: runtime }),
+        camera: config.camera,
+        entitySprites: config.entitySprites,
+        worldItem: config.worldItem,
+        settings: config.settings,
+    });
+}

package/dist/defineGame.js

@@ -10,7 +10,7 @@ function worldBackdrop(feature) {
 }
 const emptyUi = () => null;
 export function defineGame(config) {
-    const { content, loop, GameUI, environment, camera, multiplayer, WorldOverlay, renderEntity, renderObject, entitySprites, entityModels, objectModels, hotbarSelection, prompts, pointer, touch, worldHealthBars, audio, entitySounds, objectSounds, worldItem, collision, movement, lighting, backdrop, shadows, presentation, objectStyles, devtools, ...engineFields } = config;
+    const { content, loop, GameUI, environment, camera, multiplayer, WorldOverlay, renderEntity, renderObject, entitySprites, entityModels, objectModels, hotbarSelection, prompts, pointer, touch, orientation, worldHealthBars, audio, entitySounds, objectSounds, worldItem, collision, movement, lighting, backdrop, shadows, presentation, objectStyles, devtools, ...engineFields } = config;
     const game = defineEngineGame({ ...engineFields, multiplayer: multiplayer ?? offline() });
     return {
         game,
@@ -34,6 +34,7 @@ export function defineGame(config) {
         prompts,
         pointer,
         touch,
+        orientation,
         worldHealthBars,
         audio,
         entitySounds,

package/dist/devtools/CollisionDebugWorld.d.ts

@@ -0,0 +1,5 @@
+/**
+ * World-space collision debugger. Performs zero scene scans and zero raycasts
+ * when every layer is off. Mount only when shell devtools are enabled.
+ */
+export declare function CollisionDebugWorld(): import("react").JSX.Element | null;

package/dist/devtools/CollisionDebugWorld.js

@@ -0,0 +1,180 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Html, Line } from "@react-three/drei";
+import { useFrame } from "@react-three/fiber";
+import { useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import * as THREE from "three";
+import { useGameContext } from "@jgengine/react/provider";
+import { aimProbeNeeded, anyCollisionLayerOn, colliderScanNeeded, collisionDebug, projectileListenNeeded, } from "./collisionDebug.js";
+import { AIM_DAMAGE_COLOR, AIM_LASER_COLOR, AIM_MISS_COLOR, AIM_SOLID_COLOR, BODY_WIRE_COLOR, collectDebugShapes, computeAimLaser, HITBOX_WIRE_COLOR, muzzleMarkerFromOrigin, PROJECTILE_PATH_COLOR, } from "./collisionDebugMath.js";
+function useCollisionDebugState() {
+    return useSyncExternalStore(collisionDebug.subscribe, () => collisionDebug.getState(), () => collisionDebug.getState());
+}
+function WireSphere({ center, radius, color, label, }) {
+    return (_jsxs("group", { position: [center[0], center[1], center[2]], children: [_jsxs("mesh", { children: [_jsx("sphereGeometry", { args: [radius, 16, 12] }), _jsx("meshBasicMaterial", { color: color, wireframe: true, transparent: true, opacity: 0.85, depthTest: false })] }), _jsx(Html, { center: true, distanceFactor: 14, zIndexRange: [25, 0], style: { pointerEvents: "none" }, children: _jsx("span", { className: "rounded bg-black/70 px-1 text-[9px] font-medium text-white/90", children: label }) })] }));
+}
+function WireAabb({ center, halfExtents, rotationY, color, label, }) {
+    return (_jsxs("group", { position: [center[0], center[1], center[2]], rotation: [0, rotationY, 0], children: [_jsxs("mesh", { children: [_jsx("boxGeometry", { args: [halfExtents[0] * 2, halfExtents[1] * 2, halfExtents[2] * 2] }), _jsx("meshBasicMaterial", { color: color, wireframe: true, transparent: true, opacity: 0.85, depthTest: false })] }), _jsx(Html, { position: [0, halfExtents[1] + 0.15, 0], center: true, distanceFactor: 14, zIndexRange: [25, 0], style: { pointerEvents: "none" }, children: _jsx("span", { className: "rounded bg-black/70 px-1 text-[9px] font-medium text-white/90", children: label }) })] }));
+}
+function ColliderShapeMesh({ entry }) {
+    const color = entry.style === "hitbox" ? HITBOX_WIRE_COLOR : BODY_WIRE_COLOR;
+    if (entry.shape.kind === "sphere") {
+        return (_jsx(WireSphere, { center: entry.shape.center, radius: entry.shape.radius, color: color, label: entry.label }));
+    }
+    return (_jsx(WireAabb, { center: entry.shape.center, halfExtents: entry.shape.halfExtents, rotationY: entry.rotationY, color: color, label: entry.label }));
+}
+function endpointColor(kind) {
+    if (kind === "damage")
+        return AIM_DAMAGE_COLOR;
+    if (kind === "solid")
+        return AIM_SOLID_COLOR;
+    return AIM_MISS_COLOR;
+}
+function AimEndpointMark({ point, kind, }) {
+    const color = endpointColor(kind);
+    if (kind === "damage") {
+        const s = 0.14;
+        return (_jsxs("group", { position: [point[0], point[1], point[2]], children: [_jsx(Line, { points: [
+                        new THREE.Vector3(-s, -s, 0),
+                        new THREE.Vector3(s, s, 0),
+                    ], color: color, lineWidth: 2, depthTest: false }), _jsx(Line, { points: [
+                        new THREE.Vector3(-s, s, 0),
+                        new THREE.Vector3(s, -s, 0),
+                    ], color: color, lineWidth: 2, depthTest: false })] }));
+    }
+    if (kind === "solid") {
+        return (_jsxs("mesh", { position: [point[0], point[1], point[2]], children: [_jsx("sphereGeometry", { args: [0.1, 12, 10] }), _jsx("meshBasicMaterial", { color: color, wireframe: true, depthTest: false })] }));
+    }
+    return (_jsxs("mesh", { position: [point[0], point[1], point[2]], children: [_jsx("sphereGeometry", { args: [0.06, 8, 8] }), _jsx("meshBasicMaterial", { color: color, transparent: true, opacity: 0.55, depthTest: false })] }));
+}
+function MuzzleMark({ origin }) {
+    const mark = muzzleMarkerFromOrigin([origin[0], origin[1], origin[2]]);
+    return (_jsxs("mesh", { position: [mark.center[0], mark.center[1], mark.center[2]], children: [_jsx("sphereGeometry", { args: [mark.radius, 12, 10] }), _jsx("meshBasicMaterial", { color: mark.color, depthTest: false })] }));
+}
+function collectFromContext(ctx, layers) {
+    return collectDebugShapes({
+        layers,
+        entities: ctx.scene.entity.list().map((entity) => ({
+            id: entity.id,
+            position: entity.position,
+            rotationY: entity.rotationY,
+            name: entity.name,
+        })),
+        objects: ctx.scene.object.list().map((object) => ({
+            instanceId: object.instanceId,
+            catalogId: object.catalogId,
+            position: object.position,
+            rotationY: object.rotationY,
+        })),
+        entityCollidersOf: (id) => ctx.scene.entity.collidersOf(id),
+        objectCollidersOf: (id) => ctx.scene.object.collidersOf(id),
+        objectHalfExtentsOf: (catalogId) => {
+            for (const object of ctx.scene.object.list()) {
+                if (object.catalogId !== catalogId)
+                    continue;
+                const half = ctx.scene.object.catalog(object.instanceId)?.halfExtents;
+                if (half === undefined)
+                    return null;
+                return [half[0], half[1], half[2]];
+            }
+            return null;
+        },
+    });
+}
+/**
+ * World-space collision debugger. Performs zero scene scans and zero raycasts
+ * when every layer is off. Mount only when shell devtools are enabled.
+ */
+export function CollisionDebugWorld() {
+    const ctx = useGameContext();
+    const state = useCollisionDebugState();
+    const [shapes, setShapes] = useState([]);
+    const [laser, setLaser] = useState(null);
+    const frameCounter = useRef(0);
+    useEffect(() => {
+        if (!projectileListenNeeded(state.layers))
+            return;
+        return ctx.game.events.on("projectile.settled", (event) => {
+            collisionDebug.pushProjectileTrace({
+                origin: event.origin,
+                at: event.at,
+                hit: event.hit,
+                nowMs: performance.now(),
+            });
+        });
+    }, [ctx, state.layers.projectiles, state.layers.muzzles]);
+    useFrame(() => {
+        if (!anyCollisionLayerOn(state.layers)) {
+            if (shapes.length > 0)
+                setShapes([]);
+            if (laser !== null)
+                setLaser(null);
+            return;
+        }
+        frameCounter.current += 1;
+        const now = performance.now();
+        if (projectileListenNeeded(state.layers)) {
+            collisionDebug.pruneProjectileTraces(now);
+        }
+        if (colliderScanNeeded(state.layers) && frameCounter.current % 2 === 0) {
+            setShapes(collectFromContext(ctx, state.layers));
+        }
+        else if (!colliderScanNeeded(state.layers) && shapes.length > 0) {
+            setShapes([]);
+        }
+        if (aimProbeNeeded(state.layers)) {
+            const probe = collisionDebug.getAimProbe();
+            if (probe === null) {
+                if (laser !== null)
+                    setLaser(null);
+            }
+            else {
+                const next = computeAimLaser({
+                    layers: state.layers,
+                    sceneRaycast: {
+                        raycast: (input) => ctx.scene.raycast(input),
+                        raycastAll: (input) => [...ctx.scene.raycastAll(input)],
+                    },
+                    positionOf: (id) => ctx.scene.entity.get(id)?.position,
+                    rotationYOf: (id) => ctx.scene.entity.get(id)?.rotationY,
+                    from: probe.from,
+                    aim: probe.aim,
+                    originPolicy: probe.originPolicy,
+                    maxDistance: probe.maxDistance ?? 100,
+                });
+                setLaser(next);
+            }
+        }
+        else if (laser !== null) {
+            setLaser(null);
+        }
+    });
+    const projectilePoints = useMemo(() => {
+        if (!state.layers.projectiles)
+            return [];
+        return state.projectileTraces.map((trace) => ({
+            id: trace.id,
+            points: [
+                new THREE.Vector3(trace.origin[0], trace.origin[1], trace.origin[2]),
+                new THREE.Vector3(trace.at[0], trace.at[1], trace.at[2]),
+            ],
+        }));
+    }, [state.layers.projectiles, state.projectileTraces]);
+    const muzzleOrigins = useMemo(() => {
+        if (!state.layers.muzzles)
+            return [];
+        const origins = state.projectileTraces.map((trace) => ({
+            id: trace.id,
+            origin: trace.origin,
+        }));
+        if (laser !== null && state.layers.aimLaser) {
+            origins.push({ id: -1, origin: laser.origin });
+        }
+        return origins;
+    }, [state.layers.muzzles, state.layers.aimLaser, state.projectileTraces, laser]);
+    if (!anyCollisionLayerOn(state.layers))
+        return null;
+    return (_jsxs("group", { children: [shapes.map((entry) => (_jsx(ColliderShapeMesh, { entry: entry }, entry.key))), projectilePoints.map((path) => (_jsx(Line, { points: path.points, color: PROJECTILE_PATH_COLOR, lineWidth: 2, transparent: true, opacity: 0.9, depthTest: false }, path.id))), muzzleOrigins.map((entry) => (_jsx(MuzzleMark, { origin: entry.origin }, `muzzle-${entry.id}`))), laser !== null ? (_jsxs(_Fragment, { children: [_jsx(Line, { points: [
+                            new THREE.Vector3(laser.origin[0], laser.origin[1], laser.origin[2]),
+                            new THREE.Vector3(laser.end[0], laser.end[1], laser.end[2]),
+                        ], color: AIM_LASER_COLOR, lineWidth: 1.5, transparent: true, opacity: 0.95, depthTest: false }), _jsx(AimEndpointMark, { point: laser.end, kind: laser.kind })] })) : null] }));
+}

package/dist/devtools/DevtoolsOverlay.d.ts

@@ -1,4 +1,4 @@
-import { type DevtoolsOverrides } from "@jgengine/core/devtools/devtools";
+import { type DevtoolsOverrides, type DevtoolsSnapshot } from "@jgengine/core/devtools/devtools";
 import type { GameContext } from "@jgengine/core/runtime/gameContext";
 import type { ShellMultiplayer } from "../multiplayer.js";
 import type { PlayableGame } from "../registry.js";
@@ -6,6 +6,70 @@ export declare function persistDevtoolsOverrides(gameName: string): DevtoolsOver
 export declare function applyStoredDevtoolsOverrides(gameName: string): void;
 export declare function withDevtoolsLatency(multiplayer: ShellMultiplayer): ShellMultiplayer;
 export declare function DevtoolsRendererProbe(): null;
+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/devtools").RenderSample | null;
+    latency: import("@jgengine/core/devtools/devtools").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/devtools").RenderSample | null;
+    }[];
+    probes: Record<string, unknown>;
+    logs: import("@jgengine/core/devtools/devtools").DevtoolsLogEntry[] | undefined;
+    controls: {
+        name: string;
+        value: unknown;
+        initial: unknown;
+    }[] | undefined;
+    discovered: {
+        id: string;
+        value: unknown;
+    }[] | undefined;
+    discoveredCount: number;
+};
+export declare function buildFullReport(playable: PlayableGame): DevtoolsSnapshot & {
+    game: string;
+};
 export declare function DevtoolsOverlay({ open, ctx, playable, multiplayer, }: {
     open: boolean;
     ctx: GameContext;