@jgengine/shell 0.10.0 → 0.12.0

package/dist/devtools/agentBridge.js

@@ -0,0 +1,266 @@
+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";
+async function saveScene(editorHost) {
+    const endpoint = getSaveEndpoint();
+    if (endpoint === null)
+        return { ok: false, error: "no save endpoint — save_scene only works in the dev runner" };
+    const exported = editorHost.handle({ method: "export_document" });
+    const json = exported?.result?.json;
+    if (exported?.ok !== true || typeof json !== "string") {
+        return { ok: false, error: "export_document failed" };
+    }
+    try {
+        const response = await fetch(endpoint.url, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ kind: "editor-document", gameId: editorHost.gameId, json }),
+        });
+        const saved = (await response.json());
+        return saved.ok ? { ok: true, path: saved.path } : { ok: false, error: saved.error ?? "save failed" };
+    }
+    catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+function canvasPanels() {
+    return listActiveHudLayouts().map((layout, index) => {
+        const state = layout.getState();
+        return {
+            layout: index,
+            editing: state.editing,
+            locked: state.locked,
+            panels: Object.values(state.panels).map((panel) => ({
+                id: panel.id,
+                anchor: panel.placement.anchor,
+                dx: panel.placement.dx,
+                dy: panel.placement.dy,
+                width: panel.width,
+                height: panel.height,
+                visible: panel.visible,
+                type: panel.type,
+                moved: panel.moved,
+            })),
+        };
+    });
+}
+function writeUiPanelDocument(id, panel) {
+    const host = window.__jgengineEditorHost;
+    if (host === undefined)
+        return false;
+    host.handle({
+        method: "dispatch",
+        command: { type: "setUiPanel", id, patch: panel },
+    });
+    return true;
+}
+function panelLayoutSnapshot(placement, extras) {
+    return {
+        anchor: placement.anchor,
+        dx: placement.dx,
+        dy: placement.dy,
+        ...(extras?.width === undefined ? {} : { width: extras.width }),
+        ...(extras?.height === undefined ? {} : { height: extras.height }),
+        ...(extras?.visible === undefined ? {} : { visible: extras.visible }),
+        ...(extras?.type === undefined ? {} : { type: extras.type }),
+    };
+}
+/**
+ * @internal
+ * Headless control plane spanning the F2 chord family: debug mode (F2+D),
+ * canvas mode (F2+C), and editor mode (F2+E). Installed on every
+ * GamePlayerShell mount as `window.__jgengineAgent`; unknown verbs delegate
+ * to the editor host when one is live, so a single RPC surface covers all
+ * three modes for `bun run drive --rpc`.
+ */
+export function installAgentBridge(options) {
+    const { playable, devtoolsEnabled, isDevtoolsOpen, setDevtoolsOpen } = options;
+    const handle = (request) => {
+        const method = typeof request?.method === "string" ? request.method : "";
+        switch (method) {
+            case "agent_status":
+                return {
+                    ok: true,
+                    game: playable.game.name,
+                    modes: {
+                        debug: { available: devtoolsEnabled, open: isDevtoolsOpen(), chord: "F2+D" },
+                        canvas: { available: listActiveHudLayouts().length > 0, chord: "F2+C" },
+                        editor: {
+                            available: window.__jgengineEditorHost !== undefined || window.__jgengineSummonEditor !== undefined,
+                            live: window.__jgengineEditorHost !== undefined,
+                            chord: "F2+E",
+                        },
+                    },
+                };
+            case "debug_open": {
+                if (!devtoolsEnabled)
+                    return { ok: false, error: "devtools disabled for this game" };
+                const open = typeof request.open === "boolean" ? request.open : !isDevtoolsOpen();
+                setDevtoolsOpen(open);
+                return { ok: true, open };
+            }
+            case "debug_snapshot":
+                return { ok: true, snapshot: buildLeanReport(playable) };
+            case "debug_report":
+                return { ok: true, report: buildFullReport(playable) };
+            case "debug_perf_reset":
+                devtools.frame.reset();
+                return { ok: true };
+            case "canvas_state":
+                return { ok: true, layouts: canvasPanels() };
+            case "canvas_set_editing": {
+                const editing = request.editing === true;
+                const layouts = listActiveHudLayouts();
+                if (layouts.length === 0)
+                    return { ok: false, error: "no HudCanvas mounted" };
+                for (const layout of layouts)
+                    layout.setEditing(editing);
+                return { ok: true, editing };
+            }
+            case "canvas_move_panel": {
+                const id = typeof request.id === "string" ? request.id : "";
+                const anchor = request.anchor;
+                const dx = typeof request.dx === "number" ? request.dx : 0;
+                const dy = typeof request.dy === "number" ? request.dy : 0;
+                if (id === "" || !isHudAnchor(anchor)) {
+                    return { ok: false, error: "canvas_move_panel needs { id, anchor } (dx/dy optional px offsets)" };
+                }
+                const placement = { anchor, dx, dy };
+                for (const layout of listActiveHudLayouts()) {
+                    const existing = layout.getState().panels[id];
+                    if (existing === undefined)
+                        continue;
+                    layout.hydrate(JSON.stringify({
+                        v: 2,
+                        panels: {
+                            [id]: {
+                                ...placement,
+                                ...(existing.width === undefined ? {} : { width: existing.width }),
+                                ...(existing.height === undefined ? {} : { height: existing.height }),
+                                ...(existing.visible === false ? { visible: false } : {}),
+                                ...(existing.type === undefined ? {} : { type: existing.type }),
+                            },
+                        },
+                    }));
+                    const panel = layout.getState().panels[id];
+                    const uiPanel = panelLayoutSnapshot(panel.placement, {
+                        width: panel.width,
+                        height: panel.height,
+                        visible: panel.visible,
+                        type: panel.type,
+                    });
+                    const document = writeUiPanelDocument(id, uiPanel);
+                    return { ok: true, id, placement: panel.placement, panel: uiPanel, document };
+                }
+                return { ok: false, error: `no HUD panel "${id}" — canvas_state lists ids` };
+            }
+            case "canvas_resize_panel": {
+                const id = typeof request.id === "string" ? request.id : "";
+                if (id === "") {
+                    return { ok: false, error: "canvas_resize_panel needs { id, width?/height? or dw?/dh? }" };
+                }
+                for (const layout of listActiveHudLayouts()) {
+                    const existing = layout.getState().panels[id];
+                    if (existing === undefined)
+                        continue;
+                    const resize = resolvePanelResize(existing.type);
+                    const current = {
+                        width: existing.width ?? (typeof request.width === "number" ? request.width : 100),
+                        height: existing.height ?? (typeof request.height === "number" ? request.height : 40),
+                    };
+                    let next = current;
+                    if (typeof request.width === "number" || typeof request.height === "number") {
+                        const absolute = {
+                            width: typeof request.width === "number" ? request.width : current.width,
+                            height: typeof request.height === "number" ? request.height : current.height,
+                        };
+                        next = resizePanelSize(current, { dw: absolute.width - current.width, dh: absolute.height - current.height }, "both", resize);
+                    }
+                    else {
+                        const dw = typeof request.dw === "number" ? request.dw : 0;
+                        const dh = typeof request.dh === "number" ? request.dh : 0;
+                        next = resizePanelSize(current, { dw, dh }, resize.axes, resize);
+                    }
+                    layout.hydrate(JSON.stringify({
+                        v: 2,
+                        panels: {
+                            [id]: {
+                                anchor: existing.placement.anchor,
+                                dx: existing.placement.dx,
+                                dy: existing.placement.dy,
+                                width: next.width,
+                                height: next.height,
+                                ...(existing.visible === false ? { visible: false } : {}),
+                                ...(existing.type === undefined ? {} : { type: existing.type }),
+                            },
+                        },
+                    }));
+                    const panel = layout.getState().panels[id];
+                    const uiPanel = panelLayoutSnapshot(panel.placement, {
+                        width: panel.width,
+                        height: panel.height,
+                        visible: panel.visible,
+                        type: panel.type,
+                    });
+                    const document = writeUiPanelDocument(id, uiPanel);
+                    return { ok: true, id, size: next, panel: uiPanel, document };
+                }
+                return { ok: false, error: `no HUD panel "${id}" — canvas_state lists ids` };
+            }
+            case "canvas_list_panel_types":
+                return {
+                    ok: true,
+                    types: listHudPanelTypes().map((def) => ({
+                        id: def.id,
+                        label: def.label,
+                        resize: def.resize,
+                        minWidth: def.minWidth,
+                        maxWidth: def.maxWidth,
+                        minHeight: def.minHeight,
+                        maxHeight: def.maxHeight,
+                        hasSchema: def.schema !== undefined,
+                    })),
+                };
+            case "canvas_reset": {
+                const id = typeof request.id === "string" ? request.id : undefined;
+                const layouts = listActiveHudLayouts();
+                if (layouts.length === 0)
+                    return { ok: false, error: "no HudCanvas mounted" };
+                for (const layout of layouts)
+                    layout.reset(id);
+                return { ok: true };
+            }
+            case "editor_summon": {
+                if (window.__jgengineEditorHost !== undefined)
+                    return { ok: true, live: true };
+                if (window.__jgengineSummonEditor === undefined) {
+                    return { ok: false, error: "no editor summoner on this page — open with ?mode=editor" };
+                }
+                window.__jgengineSummonEditor();
+                return { ok: true, live: false };
+            }
+            case "save_scene": {
+                const editorHost = window.__jgengineEditorHost;
+                if (editorHost === undefined)
+                    return { ok: false, error: "no live editor — editor_summon or mode=editor first" };
+                return saveScene(editorHost);
+            }
+            default: {
+                const editorHost = window.__jgengineEditorHost;
+                if (editorHost !== undefined)
+                    return editorHost.handle(request);
+                return {
+                    ok: false,
+                    error: `unknown method "${method}" and no live editor — editor verbs need mode=editor or editor_summon first`,
+                };
+            }
+        }
+    };
+    window.__jgengineAgent = { handle };
+    return () => {
+        if (window.__jgengineAgent?.handle === handle)
+            delete window.__jgengineAgent;
+    };
+}

package/dist/devtools/collisionDebug.d.ts

@@ -27,10 +27,15 @@ export interface CollisionDebugState {
     projectileTraceLifeMs: number;
 }
 export type CollisionDebugListener = () => void;
+/** @internal */
 export declare function createDefaultCollisionDebugState(): CollisionDebugState;
+/** @internal */
 export declare function anyCollisionLayerOn(layers: CollisionDebugLayers): boolean;
+/** @internal */
 export declare function colliderScanNeeded(layers: CollisionDebugLayers): boolean;
+/** @internal */
 export declare function projectileListenNeeded(layers: CollisionDebugLayers): boolean;
+/** @internal */
 export declare function aimProbeNeeded(layers: CollisionDebugLayers): boolean;
 export interface CollisionDebugController {
     getState(): CollisionDebugState;
@@ -53,5 +58,6 @@ export interface CollisionDebugController {
     /** True when any overlay work is scheduled. */
     isActive(): boolean;
 }
+/** @internal */
 export declare function createCollisionDebugController(initial?: CollisionDebugState): CollisionDebugController;
 export declare const collisionDebug: CollisionDebugController;

package/dist/devtools/collisionDebug.js

@@ -12,6 +12,7 @@ const DEFAULT_LAYERS = {
     muzzles: false,
     aimLaser: false,
 };
+/** @internal */
 export function createDefaultCollisionDebugState() {
     return {
         layers: { ...DEFAULT_LAYERS },
@@ -21,6 +22,7 @@ export function createDefaultCollisionDebugState() {
         projectileTraceLifeMs: 2500,
     };
 }
+/** @internal */
 export function anyCollisionLayerOn(layers) {
     return (layers.hitboxes ||
         layers.bodies ||
@@ -28,15 +30,19 @@ export function anyCollisionLayerOn(layers) {
         layers.muzzles ||
         layers.aimLaser);
 }
+/** @internal */
 export function colliderScanNeeded(layers) {
     return layers.hitboxes || layers.bodies;
 }
+/** @internal */
 export function projectileListenNeeded(layers) {
     return layers.projectiles || layers.muzzles;
 }
+/** @internal */
 export function aimProbeNeeded(layers) {
     return layers.aimLaser;
 }
+/** @internal */
 export function createCollisionDebugController(initial = createDefaultCollisionDebugState()) {
     let state = {
         ...initial,

package/dist/devtools/collisionDebugMath.d.ts

@@ -62,13 +62,17 @@ export interface CollectDebugShapesInput {
         shapes: number;
     };
 }
+/** @internal */
 export declare function classifyAimEndpoint(hit: Pick<SceneRaycastHit, "damageEligible"> | null | undefined): AimEndpointKind;
+/** @internal */
 export declare function pointAlongRay(origin: EntityPosition, direction: EntityPosition, distance: number): EntityPosition;
+/** @internal */
 export declare function shapeWorldCenter(collider: ResolvedCollider, position: EntityPosition, rotationY: number): EntityPosition;
 /**
  * Collects world-space collider wireframe entries for enabled layers.
  * Returns [] and performs no entity/object iteration when both hitbox/body layers are off.
- */
+  * @internal
+  */
 export declare function collectDebugShapes(input: CollectDebugShapesInput): DebugShapeEntry[];
 export interface ComputeAimLaserInput {
     layers: CollisionDebugLayers;
@@ -87,8 +91,10 @@ export interface ComputeAimLaserInput {
 /**
  * Builds the authoritative aim-laser segment using resolveShot + scene raycast
  * (same seam as projectile prediction/settlement). Zero queries when aimLaser is off.
- */
+  * @internal
+  */
 export declare function computeAimLaser(input: ComputeAimLaserInput): AimLaserDebug | null;
+/** @internal */
 export declare function muzzleMarkerFromOrigin(origin: EntityPosition): {
     center: EntityPosition;
     radius: number;

package/dist/devtools/collisionDebugMath.js

@@ -1,12 +1,14 @@
 import { colliderWorldCenter, defaultEntityColliders, defaultObjectColliders, resolveColliders, } from "@jgengine/core/scene/colliders";
 import { firstImpact, hitsUntilBlocked, } from "@jgengine/core/scene/sceneRaycast";
-import { resolveShot } from "@jgengine/core/combat/shotOrigin";
+import { convergeShot, resolveShot } from "@jgengine/core/combat/shotOrigin";
 import { aimProbeNeeded, colliderScanNeeded } from "./collisionDebug.js";
+/** @internal */
 export function classifyAimEndpoint(hit) {
     if (hit === null || hit === undefined)
         return "miss";
     return hit.damageEligible ? "damage" : "solid";
 }
+/** @internal */
 export function pointAlongRay(origin, direction, distance) {
     return [
         origin[0] + direction[0] * distance,
@@ -14,6 +16,7 @@ export function pointAlongRay(origin, direction, distance) {
         origin[2] + direction[2] * distance,
     ];
 }
+/** @internal */
 export function shapeWorldCenter(collider, position, rotationY) {
     return colliderWorldCenter(collider, position, rotationY);
 }
@@ -58,7 +61,8 @@ function pushResolved(out, targetKind, instanceId, catalogId, position, rotation
 /**
  * Collects world-space collider wireframe entries for enabled layers.
  * Returns [] and performs no entity/object iteration when both hitbox/body layers are off.
- */
+  * @internal
+  */
 export function collectDebugShapes(input) {
     if (!colliderScanNeeded(input.layers))
         return [];
@@ -83,16 +87,30 @@ export function collectDebugShapes(input) {
 /**
  * Builds the authoritative aim-laser segment using resolveShot + scene raycast
  * (same seam as projectile prediction/settlement). Zero queries when aimLaser is off.
- */
+  * @internal
+  */
 export function computeAimLaser(input) {
     if (!aimProbeNeeded(input.layers)) {
         return null;
     }
-    const resolved = resolveShot({
+    const shotDeps = {
         positionOf: input.positionOf,
         rotationYOf: input.rotationYOf,
         collidersOf: input.collidersOf,
-    }, input.from, input.aim, input.originPolicy ?? { kind: "eye" });
+    };
+    const policy = input.originPolicy ?? { kind: "converge" };
+    const resolved = policy.kind === "converge"
+        ? convergeShot(shotDeps, input.from, input.aim, input.maxDistance, (origin, direction) => {
+            input.counters !== undefined && (input.counters.queries += 1);
+            const sightHits = input.sceneRaycast.raycastAll({
+                origin,
+                direction,
+                maxDistance: input.maxDistance,
+                excludeInstanceIds: [input.from],
+            });
+            return hitsUntilBlocked(sightHits)[0]?.point ?? null;
+        }, policy.muzzle)
+        : resolveShot(shotDeps, input.from, input.aim, policy);
     if (resolved === null)
         return null;
     input.counters !== undefined && (input.counters.queries += 1);
@@ -117,6 +135,7 @@ export function computeAimLaser(input) {
         queryCount: 1,
     };
 }
+/** @internal */
 export function muzzleMarkerFromOrigin(origin) {
     return { center: origin, radius: 0.08, color: "#ef4444" };
 }

package/dist/devtools/devtoolsOverrides.d.ts

@@ -0,0 +1,6 @@
+import { type DevtoolsOverrides } from "@jgengine/core/devtools/devtools";
+export declare function readStoredOverrides(gameName: string): DevtoolsOverrides | null;
+/** @internal */
+export declare function persistDevtoolsOverrides(gameName: string): DevtoolsOverrides;
+/** @internal */
+export declare function applyStoredDevtoolsOverrides(gameName: string): void;

package/dist/devtools/devtoolsOverrides.js

@@ -0,0 +1,48 @@
+import { devtools, parseOverridesPayload } from "@jgengine/core/devtools/devtools";
+function overridesStorageKey(gameName) {
+    return `jg-devtools:${gameName}`;
+}
+export function readStoredOverrides(gameName) {
+    try {
+        const raw = localStorage.getItem(overridesStorageKey(gameName));
+        if (raw === null)
+            return null;
+        const parsed = parseOverridesPayload(JSON.parse(raw));
+        if (parsed.overrides === null) {
+            for (const message of parsed.diagnostics)
+                console.warn(`[jgengine:devtools] ${message}`);
+            return null;
+        }
+        for (const message of parsed.diagnostics)
+            console.info(`[jgengine:devtools] ${message}`);
+        return parsed.overrides;
+    }
+    catch {
+        return null;
+    }
+}
+/** @internal */
+export function persistDevtoolsOverrides(gameName) {
+    const overrides = devtools.overrides.export();
+    try {
+        localStorage.setItem(overridesStorageKey(gameName), JSON.stringify(overrides));
+    }
+    catch {
+        return overrides;
+    }
+    return overrides;
+}
+/** @internal */
+export function applyStoredDevtoolsOverrides(gameName) {
+    const stored = readStoredOverrides(gameName);
+    if (stored === null)
+        return;
+    const result = devtools.overrides.apply(stored);
+    if (result.applied === 0 && result.skipped.length === 0)
+        return;
+    console.info(`[jgengine:devtools] applied ${result.applied} stored override(s) for ${gameName}` +
+        (result.skipped.length > 0 ? ` · skipped ${result.skipped.length}` : ""));
+    for (const entry of result.skipped) {
+        console.warn(`[jgengine:devtools] skipped override ${entry.id}: ${entry.reason}`);
+    }
+}

package/dist/devtools/panelAtoms.d.ts

@@ -0,0 +1,9 @@
+export declare function ms(value: number): string;
+export declare function StatRow({ name, value, alert }: {
+    name: string;
+    value: string;
+    alert?: boolean;
+}): import("react").JSX.Element;
+export declare function SectionLabel({ children }: {
+    children: string;
+}): import("react").JSX.Element;

package/dist/devtools/panelAtoms.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export function ms(value) {
+    return `${value.toFixed(1)}ms`;
+}
+export function StatRow({ name, value, alert }) {
+    return (_jsxs("div", { className: "flex items-baseline justify-between gap-3", children: [_jsx("span", { className: "text-neutral-400", children: name }), _jsx("span", { className: `font-mono tabular-nums ${alert === true ? "text-red-400" : "text-neutral-100"}`, children: value })] }));
+}
+export function SectionLabel({ children }) {
+    return _jsx("div", { className: "text-[9px] font-semibold uppercase tracking-[0.14em] text-neutral-500", children: children });
+}

package/dist/devtools/perfDiagnose.d.ts

@@ -0,0 +1,2 @@
+import { devtools, type LongFrameEvent } from "@jgengine/core/devtools/devtools";
+export declare function diagnose(frame: NonNullable<ReturnType<typeof devtools.frame.stats>>, longs: readonly LongFrameEvent[]): string | null;

package/dist/devtools/perfDiagnose.js

@@ -0,0 +1,43 @@
+import { devtools, LONG_FRAME_MS } from "@jgengine/core/devtools/devtools";
+import { ms } from "./panelAtoms.js";
+const CULPRIT_HINTS = {
+    "outside-sim": "Cost is outside the sim driver — three.js render, React commit, GPU, GC, or tab throttle. Check the render sample: high draw calls/triangles mean scene cost (instancing, culling, terrain density); moderate counts with slow frames mean fill cost (dpr, AO/DOF passes, bloom) — try Quality low/medium.",
+    sim: "Sim is slow but no named phase stands out — wrap hot onTick work with measure(\"name\", fn).",
+    onTick: "Game loop.onTick is the hotspot — profile inside it with measure(\"physics\"|\"ai\"|…, fn).",
+    pose: "Shell movement / collision / voxel step is expensive.",
+    actions: "Input → command dispatch / hotbar / interact is expensive.",
+    presence: "Multiplayer pose sync is expensive.",
+    pickup: "Auto-pickup nearest scan is expensive.",
+    "time+input": "Clock advance or input publish is unexpectedly heavy.",
+};
+export function diagnose(frame, longs) {
+    if (frame.fps >= 55 && frame.longFrames === 0 && longs.length === 0)
+        return null;
+    const recent = longs.slice(-5);
+    const culpritCounts = new Map();
+    for (const event of recent) {
+        culpritCounts.set(event.culprit, (culpritCounts.get(event.culprit) ?? 0) + 1);
+    }
+    let topCulprit = null;
+    let topCount = 0;
+    for (const [name, count] of culpritCounts) {
+        if (count > topCount) {
+            topCulprit = name;
+            topCount = count;
+        }
+    }
+    if (topCulprit === null && frame.phases[0] !== undefined && frame.avgSimMs > 8) {
+        topCulprit = frame.phases[0].name;
+    }
+    if (topCulprit === null && frame.avgOutsideMs > frame.avgSimMs && frame.avgOutsideMs > 4) {
+        topCulprit = "outside-sim";
+    }
+    if (topCulprit === null) {
+        if (frame.p95FrameMs > LONG_FRAME_MS)
+            return `p95 ${ms(frame.p95FrameMs)} — hitching without a clear phase; check long-frame log as it fills.`;
+        return null;
+    }
+    const hint = CULPRIT_HINTS[topCulprit] ?? `Hotspot “${topCulprit}” — dig into that phase with measure() or reduce its work.`;
+    const countText = topCount > 0 ? ` (${topCount}/${recent.length || topCount} recent long frames)` : "";
+    return `${topCulprit}${countText}: ${hint}`;
+}

package/dist/diagnostics/RuntimeDiagnostics.d.ts

@@ -0,0 +1,36 @@
+import { Component, type ErrorInfo, type ReactNode } from "react";
+export interface RuntimeDiagnostic {
+    id: number;
+    phase: string;
+    message: string;
+    stack?: string;
+    componentStack?: string;
+    capturedAt: string;
+}
+export declare function logRuntimeError(error: unknown, phase: string, componentStack?: string): Omit<RuntimeDiagnostic, "id">;
+export declare class GameUiErrorBoundary extends Component<{
+    children: ReactNode;
+    onRuntimeError: (error: unknown, phase: string, componentStack?: string) => void;
+}, {
+    failed: boolean;
+}> {
+    state: {
+        failed: boolean;
+    };
+    static getDerivedStateFromError(): {
+        failed: boolean;
+    };
+    componentDidCatch(error: unknown, info: ErrorInfo): void;
+    render(): ReactNode;
+}
+/** Standalone error footer text (page, browser, engine) shared by every error surface. */
+export declare function errorReportContext(): string;
+/** "Copy error" + "File issue" buttons for any error surface. `report` is the full text to copy / prefill. */
+export declare function ErrorReportActions({ report, issueTitle }: {
+    report: string;
+    issueTitle: string;
+}): import("react").JSX.Element;
+export declare function DiagnosticOverlay({ diagnostics, gameName }: {
+    diagnostics: RuntimeDiagnostic[];
+    gameName: string;
+}): import("react").JSX.Element | null;