/** Write js/plugins/McpBridge.js and register it. Safe to re-run: it overwrites. */
export declare function installBridgePlugin(projectPath: string, opts?: {
    port?: number;
    telemetryInterval?: number;
}): Promise<{
    note: string;
    name: string;
    file: string;
    registered: boolean;
    enabled: boolean | undefined;
    pluginCount: number;
    replaced: boolean;
}>;
export declare function bridgeStart(projectPath: string, port?: number): Promise<{
    note: string;
    running: boolean;
    port: number | null;
    token: string | null;
    projectPath: string | null;
    clients: number;
    authenticatedClients: number;
    buffered: number;
    droppedFrames: number;
    startedAt: string | null;
    handshakeFile: string | null;
}>;
export declare function bridgeStop(): Promise<import("../bridge/bridge.js").BridgeStatus>;
export declare function bridgeStatus(): import("../bridge/bridge.js").BridgeStatus;
export declare function bridgeTelemetry(args?: {
    limit?: number;
    types?: string[];
    peek?: boolean;
}): {
    count: number;
    byType: Record<string, number>;
    frames: import("../bridge/protocol.js").StampedTelemetry[];
};
/**
 * Send one command to the game. Commands that produce an answer are awaited;
 * `wait: false` turns any of them into fire-and-forget.
 */
export declare function bridgeCommand(args: Record<string, unknown>): Promise<{
    sent: boolean;
    awaited: boolean;
    clients: number;
    reply?: undefined;
} | {
    sent: boolean;
    awaited: boolean;
    reply: ({
        type: "auth";
        token: string;
    } & {
        t: number;
    }) | ({
        type: "ready";
        engine: string;
        mvVersion: string;
        scene: string;
    } & {
        t: number;
    }) | ({
        type: "scene_change";
        from: string;
        to: string;
        mapId?: number;
    } & {
        t: number;
    }) | ({
        type: "player_state";
        mapId: number;
        x: number;
        y: number;
        direction: number;
        isMoving: boolean;
    } & {
        t: number;
    }) | ({
        type: "log";
        level: "info" | "warn" | "error";
        message: string;
    } & {
        t: number;
    }) | ({
        type: "exception";
        message: string;
        filename?: string;
        line?: number;
        col?: number;
        stack?: string;
    } & {
        t: number;
    }) | ({
        type: "interpreter_step";
        mapId: number;
        eventId: number;
        commandIndex: number;
        code: number;
        indent: number;
    } & {
        t: number;
    }) | ({
        type: "state_dump";
        requestId?: string;
        switches: Record<string, boolean>;
        variables: Record<string, number | string>;
        message?: {
            allText: string;
            index: number | null;
            length: number | null;
            paused: boolean;
            visible: boolean;
            charWidth: number | null;
            contentWidth: number | null;
            fontFace: string | null;
            fontSize: number | null;
        };
    } & {
        t: number;
    }) | ({
        type: "performance";
        fps: number;
        memoryMB: number;
    } & {
        t: number;
    }) | ({
        type: "screenshot_result";
        requestId: string;
        mimeType: string;
        base64: string;
    } & {
        t: number;
    }) | ({
        type: "recording_started";
        requestId: string;
        mimeType: string;
        fps: number;
    } & {
        t: number;
    }) | ({
        type: "recording_result";
        requestId: string;
        mimeType: string;
        base64: string;
        durationMs: number;
    } & {
        t: number;
    }) | ({
        type: "reload_complete";
        requestId?: string;
        target: string;
        mapId?: number;
        file?: string;
    } & {
        t: number;
    });
    clients?: undefined;
}>;
/**
 * Ask the game for a screenshot and write it to disk. Returns the path rather
 * than the base64 so the agent can hand it straight to `analyze_image` without
 * a megabyte of payload passing through the conversation.
 */
export declare function bridgeScreenshot(projectPath: string, args?: {
    timeoutMs?: number;
    name?: string;
}): Promise<{
    path: string;
    bytes: number;
    mimeType: string;
    name: string;
}>;
export declare function bridgeRecordVideo(projectPath: string, args: {
    action: 'start' | 'stop';
    name?: string;
    fps?: number;
    bitrateKbps?: number;
    timeoutMs?: number;
}): Promise<{
    recording: boolean;
    name: string;
    mimeType: string;
    fps: number;
    path?: undefined;
    bytes?: undefined;
    durationMs?: undefined;
} | {
    recording: boolean;
    path: string;
    bytes: number;
    mimeType: string;
    durationMs: number;
    name: string;
    fps?: undefined;
}>;