@godscene/shared 1.7.11

package/dist/types/img/canvas-fallback.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Canvas-based fallback for image processing when Photon WASM fails to load.
+ * Provides a compatible API with Photon for browser environments.
+ */
+/**
+ * Canvas-based image class that mimics PhotonImage API
+ */
+export declare class CanvasImage {
+    private canvas;
+    private ctx;
+    private _width;
+    private _height;
+    constructor(canvas: HTMLCanvasElement);
+    get_width(): number;
+    get_height(): number;
+    get_raw_pixels(): Uint8Array;
+    get_bytes_jpeg(quality: number): Uint8Array;
+    free(): void;
+    _getCanvas(): HTMLCanvasElement;
+    _getContext(): CanvasRenderingContext2D;
+    /**
+     * Create a CanvasImage from a base64 string
+     */
+    static new_from_base64(base64Body: string): Promise<CanvasImage>;
+    /**
+     * Create a CanvasImage from a byte array (async version)
+     */
+    static new_from_byteslice(bytes: BlobPart): Promise<CanvasImage>;
+}
+/**
+ * Sampling filter enum (compatible with Photon)
+ */
+export declare const CanvasSamplingFilter: {
+    readonly Nearest: "nearest";
+    readonly Triangle: "triangle";
+    readonly CatmullRom: "catmullrom";
+    readonly Gaussian: "gaussian";
+    readonly Lanczos3: "lanczos3";
+};
+/**
+ * RGBA color class (compatible with Photon)
+ */
+export declare class CanvasRgba {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+    constructor(r: number, g: number, b: number, a: number);
+}
+/**
+ * Resize an image
+ */
+export declare function canvasResize(image: CanvasImage, newWidth: number, newHeight: number, _filter: string): CanvasImage;
+/**
+ * Crop an image
+ */
+export declare function canvasCrop(image: CanvasImage, x1: number, y1: number, x2: number, y2: number): CanvasImage;
+/**
+ * Add padding to the right of an image
+ */
+export declare function canvasPaddingRight(image: CanvasImage, padding: number, color: CanvasRgba): CanvasImage;
+/**
+ * Add padding to the bottom of an image
+ */
+export declare function canvasPaddingBottom(image: CanvasImage, padding: number, color: CanvasRgba): CanvasImage;
+/**
+ * Add uniform padding to an image
+ */
+export declare function canvasPaddingUniform(image: CanvasImage, padding: number, color: CanvasRgba): CanvasImage;
+/**
+ * Add padding to the left of an image
+ */
+export declare function canvasPaddingLeft(image: CanvasImage, padding: number, color: CanvasRgba): CanvasImage;
+/**
+ * Add padding to the top of an image
+ */
+export declare function canvasPaddingTop(image: CanvasImage, padding: number, color: CanvasRgba): CanvasImage;
+/**
+ * Watermark an image (overlay one image on another)
+ */
+export declare function canvasWatermark(base: CanvasImage, overlay: CanvasImage, x: number, y: number): CanvasImage;
+/**
+ * Create and return the canvas fallback module with Photon-compatible API
+ */
+export declare function createCanvasFallbackModule(): {
+    PhotonImage: typeof CanvasImage;
+    SamplingFilter: {
+        readonly Nearest: "nearest";
+        readonly Triangle: "triangle";
+        readonly CatmullRom: "catmullrom";
+        readonly Gaussian: "gaussian";
+        readonly Lanczos3: "lanczos3";
+    };
+    resize: typeof canvasResize;
+    crop: typeof canvasCrop;
+    open_image: () => never;
+    base64_to_image: typeof CanvasImage.new_from_base64;
+    padding_uniform: typeof canvasPaddingUniform;
+    padding_left: typeof canvasPaddingLeft;
+    padding_right: typeof canvasPaddingRight;
+    padding_top: typeof canvasPaddingTop;
+    padding_bottom: typeof canvasPaddingBottom;
+    watermark: typeof canvasWatermark;
+    Rgba: typeof CanvasRgba;
+};

package/dist/types/img/get-photon.d.ts

@@ -0,0 +1,19 @@
+export default function getPhoton(): Promise<{
+    PhotonImage: typeof import('@silvia-odwyer/photon-node').PhotonImage;
+    SamplingFilter: typeof import('@silvia-odwyer/photon-node').SamplingFilter;
+    resize: typeof import('@silvia-odwyer/photon-node').resize;
+    crop: typeof import('@silvia-odwyer/photon-node').crop;
+    open_image: typeof import('@silvia-odwyer/photon-node').open_image;
+    base64_to_image: typeof import('@silvia-odwyer/photon-node').base64_to_image;
+    padding_uniform: typeof import('@silvia-odwyer/photon-node').padding_uniform;
+    padding_left: typeof import('@silvia-odwyer/photon-node').padding_left;
+    padding_right: typeof import('@silvia-odwyer/photon-node').padding_right;
+    padding_top: typeof import('@silvia-odwyer/photon-node').padding_top;
+    padding_bottom: typeof import('@silvia-odwyer/photon-node').padding_bottom;
+    watermark: typeof import('@silvia-odwyer/photon-node').watermark;
+    Rgba: typeof import('@silvia-odwyer/photon-node').Rgba;
+}>;
+/**
+ * Check if we're using the Canvas fallback instead of Photon
+ */
+export declare function isUsingCanvasFallback(): boolean;

package/dist/types/img/get-sharp.d.ts

@@ -0,0 +1,3 @@
+type TSharpModule = typeof import('sharp');
+export default function getSharp(): Promise<TSharpModule>;
+export {};

package/dist/types/img/index.d.ts

@@ -0,0 +1,3 @@
+export { imageInfoOfBase64, isValidPNGImageBuffer, isValidJPEGImageBuffer, isValidImageBuffer, validateScreenshotBuffer, type ValidateScreenshotBufferOptions, } from './info';
+export { resizeAndConvertImgBuffer, resizeImgBase64, zoomForGPT4o, saveBase64Image, paddingToMatchBlockByBase64, cropByRect, scaleImage, localImg2Base64, httpImg2Base64, preProcessImageUrl, parseBase64, createImgBase64ByFormat, } from './transform';
+export { processImageElementInfo, compositeElementInfoImg, annotateRects, } from './box-select';

package/dist/types/img/info.d.ts

@@ -0,0 +1,34 @@
+import type { Size } from '../types';
+export interface ImageInfo extends Size {
+}
+/**
+ * Retrieves the dimensions of an image from a base64-encoded string
+ *
+ * @param imageBase64 - The base64-encoded image data
+ * @returns A Promise that resolves to an object containing the width and height of the image
+ * @throws Error if the image data is invalid
+ */
+export declare function imageInfoOfBase64(imageBase64: string): Promise<ImageInfo>;
+/**
+ * Check if the Buffer is a valid PNG image
+ * @param buffer The Buffer to check
+ * @returns true if the Buffer is a valid PNG image, otherwise false
+ */
+export declare function isValidPNGImageBuffer(buffer: Buffer): boolean;
+/**
+ * Check if the Buffer is a valid JPEG image
+ * @param buffer The Buffer to check
+ * @returns true if the Buffer is a valid JPEG image, otherwise false
+ */
+export declare function isValidJPEGImageBuffer(buffer: Buffer): boolean;
+/**
+ * Check if the Buffer is a valid image (PNG or JPEG)
+ * @param buffer The Buffer to check
+ * @returns true if the Buffer is a valid PNG or JPEG image, otherwise false
+ */
+export declare function isValidImageBuffer(buffer: Buffer): boolean;
+export interface ValidateScreenshotBufferOptions {
+    label: string;
+    minBufferSize?: number;
+}
+export declare function validateScreenshotBuffer(screenshotBuffer: Buffer | undefined, { label, minBufferSize }: ValidateScreenshotBufferOptions): asserts screenshotBuffer is Buffer;

package/dist/types/img/transform.d.ts

@@ -0,0 +1,98 @@
+import { Buffer } from 'node:buffer';
+import type { PhotonImage as PhotonImageType } from '@silvia-odwyer/photon-node';
+import type { Rect } from '../types';
+/**
+ * Saves a Base64-encoded image to a file
+ *
+ * @param options - An object containing the Base64-encoded image data and the output file path
+ * @param options.base64Data - The Base64-encoded image data
+ * @param options.outputPath - The path where the image will be saved
+ * @throws Error if there is an error during the saving process
+ */
+export declare function saveBase64Image(options: {
+    base64Data: string;
+    outputPath: string;
+}): Promise<void>;
+/**
+ * Resizes an image from Buffer, maybe return a new format
+ * - If the image is Resized, the returned format will be jpg.
+ * - If the image is not Resized, it will return to its original format.
+ * @returns { buffer: resized buffer, format: the new format}
+ */
+export declare function resizeAndConvertImgBuffer(inputFormat: string, inputData: Buffer, newSize: {
+    width: number;
+    height: number;
+}): Promise<{
+    buffer: Buffer;
+    format: string;
+}>;
+export declare const createImgBase64ByFormat: (format: string, body: string) => string;
+export declare function resizeImgBase64(inputBase64: string, newSize: {
+    width: number;
+    height: number;
+}): Promise<string>;
+/**
+ * Calculates new dimensions for an image while maintaining its aspect ratio.
+ *
+ * This function is designed to resize an image to fit within a specified maximum width and height
+ * while maintaining the original aspect ratio. If the original width or height exceeds the maximum
+ * dimensions, the image will be scaled down to fit.
+ *
+ * @param {number} originalWidth - The original width of the image.
+ * @param {number} originalHeight - The original height of the image.
+ * @returns {Object} An object containing the new width and height.
+ * @throws {Error} Throws an error if the width or height is not a positive number.
+ */
+export declare function zoomForGPT4o(originalWidth: number, originalHeight: number): {
+    width: number;
+    height: number;
+};
+export declare function photonFromBase64(base64: string): Promise<PhotonImageType>;
+export declare function paddingToMatchBlock(image: PhotonImageType, blockSize?: number): Promise<{
+    width: number;
+    height: number;
+    image: PhotonImageType;
+}>;
+export declare function paddingToMatchBlockByBase64(imageBase64: string, blockSize?: number): Promise<{
+    width: number;
+    height: number;
+    imageBase64: string;
+}>;
+export declare function cropByRect(imageBase64: string, rect: Rect, paddingImage: boolean): Promise<{
+    width: number;
+    height: number;
+    imageBase64: string;
+}>;
+export declare function photonToBase64(image: PhotonImageType, quality?: number): Promise<string>;
+export declare const httpImg2Base64: (url: string) => Promise<string>;
+/**
+ * Convert image file to base64 string
+ * Because this method is synchronous, the npm package `sharp` cannot be used to detect the file type.
+ * TODO: convert to webp to reduce base64 size.
+ */
+export declare const localImg2Base64: (imgPath: string, withoutHeader?: boolean) => string;
+/**
+ * PreProcess image url to ensure image is accessible to LLM.
+ * @param url - The url of the image, it can be a http url or a base64 string or a file path
+ * @param convertHttpImage2Base64 - Whether to convert http image to base64, if true, the http image will be converted to base64, otherwise, the http image will be returned as is
+ * @returns The base64 string of the image (when convertHttpImage2Base64 is true or url is a file path) or the http image url
+ */
+export declare const preProcessImageUrl: (url: string, convertHttpImage2Base64: boolean) => Promise<string>;
+/**
+ * parse base64 string to get mimeType and body
+ */
+export declare const parseBase64: (fullBase64String: string) => {
+    mimeType: string;
+    body: string;
+};
+/**
+ * Scales an image by a specified factor using Sharp or Photon
+ * @param imageBase64 - Base64 encoded image
+ * @param scale - Scale factor (e.g., 2 for 2x, 1.5 for 1.5x)
+ * @returns Scaled image with new dimensions
+ */
+export declare function scaleImage(imageBase64: string, scale: number): Promise<{
+    width: number;
+    height: number;
+    imageBase64: string;
+}>;

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/types/key-alias-utils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Internal-only helpers for CLI/MCP argument key aliasing.
+ * Not re-exported from the package entry point — keep consumers within
+ * `cli/` and `mcp/`.
+ */
+export declare function kebabToCamel(str: string): string;
+export declare function camelToKebab(str: string): string;
+export declare function getKeyAliases(key: string): string[];
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/types/logger.d.ts

@@ -0,0 +1,5 @@
+export type DebugFunction = (...args: unknown[]) => void;
+export declare function getDebug(topic: string, options?: {
+    console?: boolean;
+}): DebugFunction;
+export declare function enableDebug(topic: string): void;

package/dist/types/mcp/base-server.d.ts

@@ -0,0 +1,93 @@
+import type { ParseArgsConfig } from 'node:util';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { IMidsceneTools } from './types';
+export interface BaseMCPServerConfig {
+    name: string;
+    version: string;
+    description: string;
+}
+export interface HttpLaunchOptions {
+    port: number;
+    host?: string;
+}
+export interface LaunchMCPServerResult {
+    /**
+     * The MCP server port (for HTTP mode)
+     */
+    port?: number;
+    /**
+     * The server host (for HTTP mode)
+     */
+    host?: string;
+    /**
+     * Function to gracefully shutdown the MCP server
+     */
+    close: () => Promise<void>;
+}
+/**
+ * CLI argument configuration for MCP servers
+ */
+export declare const CLI_ARGS_CONFIG: ParseArgsConfig['options'];
+export interface CLIArgs {
+    mode?: string;
+    port?: string;
+    host?: string;
+}
+/**
+ * Launch an MCP server based on CLI arguments
+ * Shared helper to reduce duplication across platform CLI entry points
+ */
+export declare function launchMCPServer(server: BaseMCPServer, args: CLIArgs): Promise<LaunchMCPServerResult>;
+/**
+ * Base MCP Server class with programmatic launch() API
+ * Each platform extends this to provide their own tools manager
+ */
+export declare abstract class BaseMCPServer {
+    protected mcpServer: McpServer;
+    protected toolsManager?: IMidsceneTools;
+    protected config: BaseMCPServerConfig;
+    protected providedToolsManager?: IMidsceneTools;
+    constructor(config: BaseMCPServerConfig, toolsManager?: IMidsceneTools);
+    /**
+     * Platform-specific: create tools manager instance
+     * This is only called if no tools manager was provided in constructor
+     */
+    protected abstract createToolsManager(): IMidsceneTools;
+    /**
+     * Initialize tools manager and attach to MCP server
+     */
+    private initializeToolsManager;
+    /**
+     * Perform cleanup on shutdown
+     */
+    private performCleanup;
+    /**
+     * Initialize and launch the MCP server with stdio transport
+     */
+    launch(): Promise<LaunchMCPServerResult>;
+    /**
+     * Launch MCP server with HTTP transport
+     * Supports stateful sessions for web applications and service integration
+     */
+    launchHttp(options: HttpLaunchOptions): Promise<LaunchMCPServerResult>;
+    /**
+     * Create a new HTTP session with transport
+     */
+    private createHttpSession;
+    /**
+     * Start periodic session cleanup for inactive sessions
+     */
+    private startSessionCleanup;
+    /**
+     * Setup shutdown handlers for HTTP server
+     */
+    private setupHttpShutdownHandlers;
+    /**
+     * Get the underlying MCP server instance
+     */
+    getServer(): McpServer;
+    /**
+     * Get the tools manager instance
+     */
+    getToolsManager(): IMidsceneTools | undefined;
+}

package/dist/types/mcp/base-tools.d.ts

@@ -0,0 +1,148 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { z } from 'zod';
+import { type CliReportSession } from './cli-report-session';
+import type { BaseAgent, BaseDevice, IMidsceneTools, ToolCliMetadata, ToolDefinition, ToolSchema } from './types';
+/**
+ * Declarative description of a platform's agent init args.
+ * Collapses the `extractAgentInitParam` / `sanitizeToolArgs` /
+ * `getAgentInitArgSchema` trio into a single data declaration.
+ */
+export interface InitArgSpec<TInitParam> {
+    /** Arg namespace, e.g. `android`, `ios`. */
+    namespace: string;
+    /** Zod shape describing the init args. Field names drive the MCP schema. */
+    shape: Record<string, z.ZodTypeAny>;
+    /**
+     * Optional CLI presentation hints. These affect `--help` output for
+     * single-platform CLIs but do not alter MCP/YAML protocol keys.
+     */
+    cli?: {
+        /** Prefer bare `--device-id`-style options in platform CLI help output. */
+        preferBareKeys?: boolean;
+        /** Override the displayed option name for specific init arg fields. */
+        preferredNames?: Record<string, string>;
+    };
+    /**
+     * Adapt extracted namespaced args into the concrete `TInitParam` passed to
+     * `ensureAgent`. Defaults to returning the raw extracted record.
+     */
+    adapt?: (extracted: Record<string, unknown> | undefined) => TInitParam | undefined;
+}
+/**
+ * Base class for platform-specific MCP tools.
+ * @typeParam TAgent - Platform-specific agent type.
+ * @typeParam TInitParam - Platform-specific init parameter consumed by
+ *   `ensureAgent`. Defaults to `undefined` for platforms that take no args.
+ */
+export declare abstract class BaseMidsceneTools<TAgent extends BaseAgent = BaseAgent, TInitParam = unknown> implements IMidsceneTools {
+    protected mcpServer?: McpServer;
+    protected agent?: TAgent;
+    protected toolDefinitions: ToolDefinition[];
+    /**
+     * Declarative init-arg spec. Subclasses that accept CLI/MCP init args should
+     * set this once and get `extractAgentInitParam` / `sanitizeToolArgs` /
+     * `getAgentInitArgSchema` auto-implemented.
+     *
+     * Declared with `declare` so that TS doesn't emit an `Object.defineProperty`
+     * for this field on the base constructor, which would otherwise overwrite
+     * a subclass field initializer under `useDefineForClassFields`.
+     */
+    protected readonly initArgSpec?: InitArgSpec<TInitParam>;
+    /**
+     * Ensure agent is initialized and ready for use.
+     * Must be implemented by subclasses to create platform-specific agent.
+     * @param initParam Optional initialization parameter (platform-specific, e.g., URL, device ID)
+     * @returns Promise resolving to initialized agent instance
+     * @throws Error if agent initialization fails
+     */
+    protected abstract ensureAgent(initParam?: TInitParam): Promise<TAgent>;
+    private getInitArgKeys;
+    /**
+     * Extract a platform-specific agent init parameter from CLI/MCP tool args.
+     */
+    protected extractAgentInitParam(args: Record<string, unknown>): TInitParam | undefined;
+    /**
+     * Remove platform-specific init args before dispatching a tool payload to the action itself.
+     */
+    protected sanitizeToolArgs(args: Record<string, unknown>): Record<string, unknown>;
+    /**
+     * Expose platform-specific init args on action/common tool schemas.
+     */
+    protected getAgentInitArgSchema(): ToolSchema;
+    /**
+     * Expose CLI-only metadata for platform init args so single-platform help can
+     * show ergonomic bare flags while the underlying schema stays namespaced.
+     * When `preferBareKeys` is enabled, single-platform CLIs only accept the
+     * bare spellings; namespaced dotted spellings remain available through the
+     * MCP/YAML schema instead of the platform CLI surface.
+     */
+    protected getAgentInitArgCliMetadata(): ToolCliMetadata | undefined;
+    /**
+     * Optional: prepare platform-specific tools (e.g., device connection)
+     */
+    protected preparePlatformTools(): ToolDefinition[];
+    protected getCliReportSessionName(): string | undefined;
+    protected createNewCliReportSession(targetIdentity?: string): CliReportSession | undefined;
+    protected commitCliReportSession(session?: CliReportSession): void;
+    protected readCliReportFileName(): string | undefined;
+    protected readCliReportAgentOptions(): {
+        reportFileName: string;
+        reportAttributes: Record<string, string>;
+    } | undefined;
+    /**
+     * Must be implemented by subclasses to create a temporary device instance
+     * This allows getting real actionSpace without connecting to device
+     */
+    protected abstract createTemporaryDevice(): BaseDevice;
+    /**
+     * Initialize all tools by querying actionSpace
+     * Uses two-layer fallback strategy:
+     * 1. Try to get actionSpace from connected agent (if available)
+     * 2. Create temporary device instance to read actionSpace (always succeeds)
+     */
+    initTools(): Promise<void>;
+    /**
+     * Attach to MCP server and register all tools
+     */
+    attachToServer(server: McpServer): void;
+    /**
+     * Cleanup method - destroy agent and release resources
+     */
+    destroy(): Promise<void>;
+    /**
+     * Get tool definitions
+     */
+    getToolDefinitions(): ToolDefinition[];
+    /**
+     * Set agent for the tools manager
+     */
+    setAgent(agent: TAgent): void;
+    /**
+     * Helper: Convert base64 screenshot to image content array
+     */
+    protected buildScreenshotContent(screenshot: string): {
+        type: "image";
+        data: string;
+        mimeType: string;
+    }[];
+    /**
+     * Helper: Build a simple text result for tool responses
+     */
+    protected buildTextResult(text: string): {
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    };
+    /**
+     * Create a disconnect handler for releasing platform resources
+     * @param platformName Human-readable platform name for the response message
+     * @returns Handler function that destroys the agent and returns appropriate response
+     */
+    protected createDisconnectHandler(platformName: string): () => Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+}

package/dist/types/mcp/chrome-path.d.ts

@@ -0,0 +1,2 @@
+export declare function getSystemChromePath(): string | undefined;
+export declare function resolveChromePath(): string;

package/dist/types/mcp/cli-report-session.d.ts

@@ -0,0 +1,12 @@
+export interface CliReportSession {
+    version: 1;
+    sessionName: string;
+    targetIdentity?: string;
+    reportFileName: string;
+    reportPath: string;
+    createdAt: number;
+}
+export declare function generateCliReportSession(sessionName: string, targetIdentity?: string): CliReportSession;
+export declare function writeCliReportSession(session: CliReportSession): void;
+export declare function createCliReportSession(sessionName: string, targetIdentity?: string): CliReportSession;
+export declare function readCliReportSession(sessionName: string): CliReportSession | undefined;

package/dist/types/mcp/error-formatter.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Extract a human-readable message from an unknown thrown value.
+ *
+ * Many SDK/transport layers reject with structured objects (e.g.
+ * `{ code, message }`, `{ error: { message } }`, `{ cause: { message } }`)
+ * rather than `Error` instances. `String(obj)` collapses those to
+ * `"[object Object]"`, which is useless for diagnostics. This helper walks
+ * the common shapes, falls back to `JSON.stringify`, and finally to
+ * `Object.prototype.toString.call` so that callers always get something
+ * actionable in logs and surfaced tool results.
+ */
+export declare function getErrorMessage(error: unknown): string;

package/dist/types/mcp/index.d.ts

@@ -0,0 +1,9 @@
+export * from './base-server';
+export * from './base-tools';
+export * from './init-arg-utils';
+export * from './error-formatter';
+export * from './tool-generator';
+export * from './types';
+export * from './inject-report-html-plugin';
+export * from './launcher-helper';
+export * from './chrome-path';

package/dist/types/mcp/init-arg-utils.d.ts

@@ -0,0 +1,13 @@
+import type { z } from 'zod';
+import type { ToolSchema } from './types';
+export declare function extractNamespacedArgs<TFieldName extends string, TArgs extends Record<string, unknown> = Record<string, unknown>>(args: Record<string, unknown>, namespace: string, keys: readonly TFieldName[]): TArgs | undefined;
+export declare function sanitizeNamespacedArgs(args: Record<string, unknown>, namespace: string, keys: readonly string[]): Record<string, unknown>;
+/**
+ * Build a flat MCP tool schema whose keys are dotted `"<namespace>.<field>"`.
+ *
+ * We intentionally stay flat (rather than `{ namespace: z.object({...}) }`) so
+ * that CLI (`--android.device-id`), MCP clients, and `--help` output all share
+ * the same spelling. `readNamespacedArg` understands all three input shapes:
+ * nested namespace object, dotted flat key, and bare key fallback.
+ */
+export declare function createNamespacedInitArgSchema(namespace: string, shape: Record<string, z.ZodTypeAny>): ToolSchema;

package/dist/types/mcp/inject-report-html-plugin.d.ts

@@ -0,0 +1,18 @@
+interface RslibPluginApi {
+    onAfterBuild: (callback: () => void) => void;
+}
+/**
+ * Rslib plugin to inject report HTML from @godscene/core dist into MCP bundle.
+ * This runs after build and reads the already-injected HTML from core.
+ *
+ * Prerequisites:
+ * - @godscene/report must be in devDependencies to ensure correct build order
+ * - @godscene/core dist must exist with injected HTML
+ *
+ * @param packageDir - The directory of the MCP package (use __dirname)
+ */
+export declare function injectReportHtmlFromCore(packageDir: string): {
+    name: string;
+    setup(api: RslibPluginApi): void;
+};
+export {};