@mearl/client 2.20.6 → 2.22.0

package/dist/{officialPluginInstaller.js → plugins/officialPluginInstaller.js}

@@ -1,11 +1,9 @@
 import { closeSync, mkdirSync, openSync, rmSync, statSync, writeFileSync } from 'node:fs';
-import { createRequire } from 'node:module';
+import { CLIENT_VERSION } from '../runtimePaths.js';
 import { join } from 'node:path';
 import { spawn } from 'node:child_process';
 import { findOfficialPlugin } from './officialPluginCatalog.js';
 import { findPluginRegistration, pluginDirectory } from './pluginRegistry.js';
-const require = createRequire(import.meta.url);
-const CLIENT_VERSION = require('../package.json').version;
 const INSTALL_TIMEOUT_MS = 180_000;
 const INSTALL_LOCK_STALE_MS = 5 * 60_000;
 const MAX_INSTALL_OUTPUT = 1024 * 1024;

package/dist/{pluginPageBundle.js → plugins/pluginPageBundle.js}

@@ -29,9 +29,7 @@ const PAGE_BRIDGE_SCRIPT = String.raw `(() => {
   let port = null;
   let requestSequence = 0;
   const pending = new Map();
-  const pageEventListeners = new Map();
   const contextListeners = new Set();
-  let subscriptionSequence = 0;
   let resolveReady;
   const ready = new Promise(resolve => { resolveReady = resolve; });
 
@@ -87,17 +85,24 @@ const PAGE_BRIDGE_SCRIPT = String.raw `(() => {
   };
 
   const subscribe = async (source, target, listener) => {
-    if (source !== 'page' || !target || !Number.isSafeInteger(target.tabId) || target.tabId < 0 ||
-        typeof target.runtimeId !== 'string' || !/^[a-z][a-z0-9-]{0,63}$/.test(target.runtimeId) ||
-        typeof listener !== 'function') throw new Error('Invalid event subscription');
-    const subscriptionId = String(++subscriptionSequence);
-    pageEventListeners.set(subscriptionId, listener);
-    try { await requestHost('subscribe', { source, target, subscriptionId }); }
-    catch (error) { pageEventListeners.delete(subscriptionId); throw error; }
-    return () => {
-      if (!pageEventListeners.delete(subscriptionId)) return;
-      void requestHost('unsubscribe', { subscriptionId }).catch(() => {});
+    if (source !== 'page' || !target || typeof target.instanceId !== 'string' ||
+        !/^pi_[0-9a-f-]{36}$/i.test(target.instanceId) || typeof listener !== 'function') throw new Error('Invalid page event subscription');
+    let stopped = false, timer, cursor = target.cursor ?? 0;
+    const poll = async (waitMs = 0) => {
+      let delay = 0;
+      try {
+        const page = await invoke('host.page.events', { instanceId: target.instanceId, cursor, waitMs });
+        if (stopped) return;
+        const metadata = { url: page.instance.target.url, instance: page.instance, gap: page.gap };
+        if (page.gap) listener({ type: 'resync' }, metadata);
+        for (const event of page.events) { if (stopped) return; listener(event, metadata); }
+        cursor = page.nextCursor;
+        if (page.instance.state !== 'active') return;
+      } catch (error) { if (stopped) return; delay = 500; listener({ type: 'connection-error', error: { message: error.message } }); }
+      if (!stopped) timer = setTimeout(() => { void poll(25000); }, delay);
     };
+    await poll();
+    return () => { stopped = true; clearTimeout(timer); };
   };
 
   const handleExternalLinkClick = event => {
@@ -404,7 +409,62 @@ const PAGE_BRIDGE_SCRIPT = String.raw `(() => {
     if (context) listener(context);
     return () => contextListeners.delete(listener);
   };
-  const api = { invoke, subscribe, onContextChange, ready: async () => { await ready; return context; }, runAgentTask, setAgentGuides, setAgentPanelVisible, setQueryParam };
+  const readTaskResult = async taskId => {
+    const task = await invoke('host.task.get', { taskId });
+    const reference = task.result;
+    if (task.state !== 'success' || !reference || !Number.isSafeInteger(reference.bytes) ||
+        reference.bytes < 1 || reference.bytes > 64 * 1024 * 1024 ||
+        !Number.isSafeInteger(reference.chunks) || reference.chunks < 1 || reference.chunks > 1024 ||
+        !/^[a-f0-9]{64}$/.test(reference.sha256)) throw new Error('Invalid task result reference');
+    const data = new Uint8Array(reference.bytes);
+    let offset = 0;
+    for (let index = 0; index < reference.chunks; index++) {
+      const chunk = await invoke('host.task.result', { taskId, index });
+      if (chunk.taskId !== taskId || chunk.index !== index || chunk.sha256 !== reference.sha256 ||
+          chunk.bytes !== reference.bytes || chunk.chunks !== reference.chunks) throw new Error('Task result chunk identity mismatch');
+      const binary = atob(chunk.data);
+      if (offset + binary.length > data.length) throw new Error('Task result size mismatch');
+      for (let i = 0; i < binary.length; i++) data[offset++] = binary.charCodeAt(i);
+    }
+    const hash = Array.from(new Uint8Array(await crypto.subtle.digest('SHA-256', data)),
+      value => value.toString(16).padStart(2, '0')).join('');
+    if (offset !== reference.bytes || hash !== reference.sha256) throw new Error('Task result integrity check failed');
+    return JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(data)).value;
+  };
+  const waitTask = async (taskId, options = {}) => {
+    if (options.timeoutMs !== undefined && (!Number.isSafeInteger(options.timeoutMs) || options.timeoutMs < 1)) throw new Error('Invalid task wait timeout');
+    const deadline = options.timeoutMs === undefined ? Infinity : Date.now() + options.timeoutMs;
+    let cursor = 0, lastSequence = -1;
+    for (;;) {
+      options.signal?.throwIfAborted();
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) throw Object.assign(new Error('Waiting for the task timed out; execution continues'), { code: 'PLUGIN_TASK_WAIT_TIMEOUT' });
+      let page;
+      try {
+        page = await invoke('host.task.events', { taskId, cursor, waitMs: Math.min(1000, remaining) });
+        options.onConnectionChange?.(false);
+      } catch (error) { options.onConnectionChange?.(true); throw error; }
+      options.signal?.throwIfAborted();
+      const task = page.task;
+      cursor = page.nextCursor;
+      if (task.progress && task.sequence !== lastSequence) options.onProgress?.(task.progress, task);
+      lastSequence = task.sequence;
+      if (task.state === 'success') return readTaskResult(taskId);
+      if (!['queued', 'running', 'cancelling'].includes(task.state))
+        throw Object.assign(new Error(task.error?.message || 'Plugin task ended with ' + task.state), { code: task.error?.code });
+    }
+  };
+  const listTasks = async (options = {}) => {
+    const tasks = [];
+    let cursor;
+    do {
+      const page = await invoke('host.task.list', { activeOnly: options.activeOnly !== false, ...(cursor ? { cursor } : {}) });
+      tasks.push(...page.tasks);
+      cursor = page.nextCursor;
+    } while (cursor);
+    return { tasks };
+  };
+  const api = { invoke, subscribe, readTaskResult, waitTask, listTasks, onContextChange, ready: async () => { await ready; return context; }, runAgentTask, setAgentGuides, setAgentPanelVisible, setQueryParam };
   const ui = globalThis.__mearlToolboxUi;
   if (ui !== undefined) {
     if (!ui || typeof ui !== 'object' || ui.runtime !== 'preact') {
@@ -448,10 +508,7 @@ const PAGE_BRIDGE_SCRIPT = String.raw `(() => {
     port = nextPort;
     port.onmessage = responseEvent => {
       const response = responseEvent.data;
-      if (response?.type === 'event' && typeof response.subscriptionId === 'string') {
-        pageEventListeners.get(response.subscriptionId)?.(response.event, response.metadata);
-        return;
-      }
+
       if (response?.type === 'context') {
         applyContext(response.context);
         return;

package/dist/{pluginRegistry.d.ts → plugins/pluginRegistry.d.ts}

@@ -1,4 +1,4 @@
-import { type AppProfileContribution } from './generated-app-profile-definition.js';
+import { type AppProfileContribution } from '../generated/app-profile-definition.js';
 export declare class PluginError extends Error {
     readonly code: string;
     constructor(code: string, message: string);
@@ -8,9 +8,6 @@ export interface PluginToolboxSandboxPage {
     runtime?: 'preact';
     entry: string;
     commands: string[];
-    lifecycle?: {
-        onNavigation: string;
-    };
 }
 export interface PluginToolboxLocale {
     title?: string;
@@ -38,6 +35,7 @@ export interface PluginPageBundleRegistration {
 }
 export interface PluginRegistration {
     entry: string;
+    hasPublicCommands?: boolean;
     description?: string;
     managedBy?: string;
     toolbox?: PluginToolboxContribution;
@@ -52,6 +50,7 @@ export interface PluginRegistration {
 }
 export declare function pluginRegistrationNeedsRefresh(registration: PluginRegistration, includePage?: boolean): boolean;
 export interface PluginRegistrationOptions {
+    hasPublicCommands?: boolean;
     managedBy?: string;
     toolbox?: PluginToolboxContribution;
     appProfiles?: AppProfileContribution;

package/dist/{pluginRegistry.js → plugins/pluginRegistry.js}

@@ -1,9 +1,10 @@
-import { validateAppProfileContribution, } from './generated-app-profile-definition.js';
+import { validateAppProfileContribution, } from '../generated/app-profile-definition.js';
 import { randomUUID } from 'node:crypto';
+import { parseToolboxIcon } from '../generated/toolbox-icon.js';
 import { closeSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, rmSync, statSync, writeFileSync, } from 'node:fs';
 import { homedir } from 'node:os';
 import { isAbsolute, join, resolve } from 'node:path';
-import { COMMAND_MAP } from './commands.js';
+import { COMMAND_MAP } from '../commands.js';
 import { buildPluginPageBundle, PLUGIN_PAGE_CHUNK_BYTES, PLUGIN_PAGE_RUNTIME_HASH, } from './pluginPageBundle.js';
 import { pluginFileVersion } from './pluginSource.js';
 const RESERVED_NAMES = new Set([
@@ -134,8 +135,8 @@ export function normalizePluginToolboxContribution(value) {
     if (description && description.length > 240) {
         throw new Error('toolbox.description 不能超过 240 个字符');
     }
-    if (icon && (!/^[a-z][a-z0-9-]*$/.test(icon) || icon.length > 40)) {
-        throw new Error('toolbox.icon 必须是短横线命名的图标名称');
+    if (icon && !parseToolboxIcon(icon)) {
+        throw new Error('toolbox.icon 必须是图标名称、SVG、图片 Data URL 或 HTTP(S) 图片地址，最多 32768 个字符');
     }
     let locales;
     if (candidate.locales !== undefined) {
@@ -209,17 +210,8 @@ export function normalizePluginToolboxContribution(value) {
         entry: pageEntry,
         commands,
     };
-    if (pageCandidate.lifecycle !== undefined) {
-        const lifecycle = pageCandidate.lifecycle;
-        if (!lifecycle ||
-            typeof lifecycle !== 'object' ||
-            Array.isArray(lifecycle) ||
-            typeof lifecycle.onNavigation !== 'string' ||
-            !commands.includes(lifecycle.onNavigation)) {
-            throw new Error('toolbox.page.lifecycle.onNavigation 必须是 page.commands 中的命令名称');
-        }
-        page.lifecycle = { onNavigation: lifecycle.onNavigation };
-    }
+    if ('lifecycle' in pageCandidate)
+        throw new Error('toolbox.page.lifecycle is unsupported; declare pageRuntime and activation rules');
     let agent;
     if (candidate.agent !== undefined) {
         if (!candidate.agent || typeof candidate.agent !== 'object' || Array.isArray(candidate.agent)) {
@@ -309,6 +301,9 @@ export function registerPlugin(name, target, description, options = {}) {
     }
     const record = {
         entry,
+        ...(options.hasPublicCommands !== undefined
+            ? { hasPublicCommands: options.hasPublicCommands }
+            : {}),
         source: {
             entry: entryVersion,
             ...(options.profileSources ? { profiles: options.profileSources } : {}),
@@ -339,6 +334,7 @@ export function unregisterPlugin(name) {
     const file = join(pluginDirectory(), `${name}.json`);
     try {
         rmSync(file);
+        rmSync(join(pluginDirectory(), '.host', 'installations', `${name}.json`), { force: true });
         removePluginPageBundles(name);
         return true;
     }
@@ -365,6 +361,8 @@ export function findPluginRegistration(name) {
         const record = JSON.parse(content);
         if (typeof record?.entry !== 'string' || !isAbsolute(record.entry))
             throw new Error('invalid entry');
+        if (record.hasPublicCommands !== undefined && typeof record.hasPublicCommands !== 'boolean')
+            throw new Error('invalid public commands');
         const description = typeof record.description === 'string' && record.description.trim()
             ? record.description.trim()
             : undefined;
@@ -396,6 +394,9 @@ export function findPluginRegistration(name) {
         }
         return {
             entry: record.entry,
+            ...(record.hasPublicCommands !== undefined
+                ? { hasPublicCommands: record.hasPublicCommands }
+                : {}),
             ...(description ? { description } : {}),
             ...(managedBy ? { managedBy } : {}),
             ...(toolbox ? { toolbox } : {}),

package/dist/plugins/pluginTaskProtocol.d.ts

@@ -0,0 +1,47 @@
+import type { PluginExecutionError, PluginInvocationSource } from '../generated/plugin-execution.js';
+import type { PluginOptions } from './sdk/plugin.js';
+export interface PluginTaskScope {
+    access: 'public' | 'toolbox' | 'runtime';
+    plugin?: string;
+    source: PluginInvocationSource;
+    bridge: 'service' | 'caller';
+    scopeId?: string;
+}
+export interface PluginTaskStartRequest {
+    plugin: string;
+    command: string;
+    kind?: 'command' | 'model';
+    input: Record<string, unknown>;
+    cwd: string;
+    environment: Record<string, string>;
+    options: PluginOptions;
+    executionTimeoutMs?: number;
+    idempotencyKey?: string;
+}
+export interface PluginTaskResumeRequest {
+    taskId: string;
+    environment: Record<string, string>;
+    revision?: 'original' | 'current';
+}
+export type PluginTaskWireMessage = {
+    type: 'request';
+    id: number;
+    method: string;
+    input: Record<string, unknown>;
+} | {
+    type: 'response';
+    id: number;
+    result?: unknown;
+    error?: PluginExecutionError;
+} | {
+    type: 'invoke';
+    id: number;
+    action: string;
+    payload: Record<string, unknown>;
+    options: PluginOptions;
+} | {
+    type: 'invoke-result';
+    id: number;
+    result?: unknown;
+    error?: PluginExecutionError;
+};

package/dist/plugins/pluginTaskProtocol.js

@@ -0,0 +1 @@
+export {};

package/dist/plugins/pluginTaskWire.d.ts

@@ -0,0 +1,4 @@
+import type { Socket } from 'node:net';
+import type { PluginTaskWireMessage } from './pluginTaskProtocol.js';
+export declare function readPluginTaskMessages(socket: Socket, receive: (message: PluginTaskWireMessage) => void): void;
+export declare function writePluginTaskMessage(socket: Socket, message: PluginTaskWireMessage): Promise<void>;

package/dist/plugins/pluginTaskWire.js

@@ -0,0 +1,42 @@
+import { StringDecoder } from 'node:string_decoder';
+const MAX_MESSAGE_BYTES = 96 * 1024 * 1024;
+export function readPluginTaskMessages(socket, receive) {
+    const decoder = new StringDecoder('utf8');
+    let buffer = '';
+    socket.on('data', chunk => {
+        try {
+            buffer += decoder.write(chunk);
+            let end;
+            while ((end = buffer.indexOf('\n')) >= 0) {
+                const line = buffer.slice(0, end);
+                buffer = buffer.slice(end + 1);
+                if (Buffer.byteLength(line) > MAX_MESSAGE_BYTES)
+                    throw new Error('Plugin host message is too large');
+                const message = JSON.parse(line);
+                if (!message || typeof message !== 'object' || !Number.isSafeInteger(message.id))
+                    throw new Error('Invalid plugin host message');
+                receive(message);
+            }
+            if (Buffer.byteLength(buffer) > MAX_MESSAGE_BYTES)
+                throw new Error('Plugin host message buffer exceeded its limit');
+        }
+        catch (error) {
+            socket.destroy(error instanceof Error ? error : new Error(String(error)));
+        }
+    });
+}
+export function writePluginTaskMessage(socket, message) {
+    return new Promise((resolve, reject) => {
+        try {
+            const text = JSON.stringify(message) + '\n';
+            if (Buffer.byteLength(text) > MAX_MESSAGE_BYTES)
+                throw new Error('Plugin host message is too large');
+            if (socket.destroyed)
+                throw new Error('Plugin host connection is closed');
+            socket.write(text, error => (error ? reject(error) : resolve()));
+        }
+        catch (error) {
+            reject(error);
+        }
+    });
+}

package/dist/plugins/runtime/pluginCommandWorker.d.ts

@@ -0,0 +1,2 @@
+import type { PluginWorkerRequest } from './pluginExecutorProtocol.js';
+export declare function handlePluginWorkerMessage(message: PluginWorkerRequest): void;

package/dist/plugins/runtime/pluginCommandWorker.js

@@ -0,0 +1,174 @@
+import { pluginRecoverySignature } from '../sdk/pluginRecoveryDefinition.js';
+import { loadPlugin, findPluginRegistration, invokeRegisteredPlugin, invokeRegisteredToolboxPlugin, invokeRegisteredRuntimePlugin, invokeRegisteredRecoveryPlugin, } from '../sdk/plugin.js';
+import { pluginFileVersion } from '../pluginSource.js';
+import { MAX_PLUGIN_RESULT_BYTES, pluginExecutionError, serializePluginExecutionError, } from './pluginExecutorProtocol.js';
+const controller = new AbortController();
+const pending = new Map();
+let sequence = 0;
+let started = false;
+let completed = false;
+function send(event) {
+    return new Promise((resolve, reject) => {
+        if (!process.connected || !process.send) {
+            reject(new Error('Plugin executor disconnected'));
+            return;
+        }
+        process.send(event, error => (error ? reject(error) : resolve()));
+    });
+}
+async function run(message) {
+    try {
+        const registration = message.registration ?? findPluginRegistration(message.plugin);
+        if (registration?.entry !== message.entry ||
+            pluginFileVersion(message.entry) !== message.entryVersion)
+            throw Object.assign(new Error('Plugin source changed before execution'), {
+                code: 'PLUGIN_SOURCE_CHANGED',
+            });
+        const invokePlugin = message.recovery
+            ? invokeRegisteredRecoveryPlugin
+            : message.access === 'runtime'
+                ? invokeRegisteredRuntimePlugin
+                : message.access === 'toolbox'
+                    ? invokeRegisteredToolboxPlugin
+                    : invokeRegisteredPlugin;
+        const declaration = message.describe
+            ? await loadPlugin(message.entry, {
+                options: {},
+                progress: () => { },
+                invoke: async () => {
+                    throw new Error('Host actions are unavailable during runtime declaration');
+                },
+            }, message.plugin)
+            : undefined;
+        const migration = message.migration
+            ? await loadPlugin(message.entry, {
+                options: {},
+                signal: controller.signal,
+                progress: () => { },
+                invoke: async () => {
+                    throw Object.assign(new Error('Checkpoint migration cannot invoke host actions or plugins'), { code: 'PLUGIN_CHECKPOINT_MIGRATION_HOST_CALL' });
+                },
+            }, message.plugin)
+            : undefined;
+        if (migration) {
+            const definitions = migration.taskRecovery?.commands;
+            const definition = definitions && Object.hasOwn(definitions, message.invocation.command)
+                ? definitions[message.invocation.command]
+                : undefined;
+            if (!definition ||
+                !message.expectedRecovery ||
+                pluginRecoverySignature(definition) !== message.expectedRecovery)
+                throw Object.assign(new Error('Migration declaration differs from the admitted target format'), { code: 'PLUGIN_RECOVERY_DECLARATION_CHANGED' });
+        }
+        const value = migration
+            ? await migration.runMigration(message.invocation)
+            : declaration
+                ? {
+                    pageRuntime: declaration.pageRuntime,
+                    stateStorage: declaration.stateStorage,
+                    taskRecovery: declaration.taskRecovery,
+                }
+                : message.model
+                    ? await (await import('@mearl/agent-runtime/codex')).runCodexModel(message.model, {
+                        signal: controller.signal,
+                        cwd: process.cwd(),
+                        onDiagnostic: metadata => {
+                            void send({ type: 'diagnostic', metadata }).catch(() => process.exit(1));
+                        },
+                        onDelta: (delta, index, metadata) => {
+                            void send({
+                                type: 'progress',
+                                progress: {
+                                    message: 'model.delta',
+                                    data: { delta, index, ...metadata, partial: true },
+                                },
+                            }).catch(() => process.exit(1));
+                        },
+                    })
+                    : await invokePlugin(message.plugin, message.invocation, {
+                        invocation: Object.freeze({
+                            ...message.identity,
+                            host: Object.freeze(message.identity.host),
+                        }),
+                        ...(message.registration
+                            ? {
+                                resolveRegistration: (name) => name === message.plugin
+                                    ? message.registration
+                                    : findPluginRegistration(name),
+                            }
+                            : {}),
+                        invoke: (action, payload = {}, options = {}, onProgress) => {
+                            controller.signal.throwIfAborted();
+                            const id = ++sequence;
+                            return new Promise((resolve, reject) => {
+                                pending.set(id, { resolve, reject, onProgress });
+                                void send({
+                                    type: 'invoke',
+                                    id,
+                                    action,
+                                    payload,
+                                    options,
+                                    ...(onProgress ? { stream: true } : {}),
+                                }).catch(error => {
+                                    pending.delete(id);
+                                    reject(error);
+                                });
+                            });
+                        },
+                    }, {
+                        ...message.options,
+                        signal: controller.signal,
+                        source: message.identity.source,
+                        onProgress: progress => {
+                            void send({ type: 'progress', progress }).catch(() => process.exit(1));
+                        },
+                    });
+        // Business results use a separate lossless channel; diagnostics never supply the result.
+        const json = JSON.stringify({ value });
+        if (Buffer.byteLength(json) > (message.migration ? 64 * 1024 : MAX_PLUGIN_RESULT_BYTES))
+            throw Object.assign(new Error('Plugin result exceeds the execution result limit'), {
+                code: 'PLUGIN_RESULT_TOO_LARGE',
+            });
+        await send({ type: 'result', json });
+        completed = true;
+    }
+    catch (error) {
+        await send({ type: 'error', error: serializePluginExecutionError(error) }).catch(() => { });
+        completed = true;
+    }
+}
+export function handlePluginWorkerMessage(message) {
+    if (message.type === 'start') {
+        if (started)
+            return;
+        started = true;
+        void run(message);
+    }
+    else if (message.type === 'cancel') {
+        if (completed)
+            return;
+        const error = pluginExecutionError(message.error);
+        controller.abort(error);
+        for (const request of pending.values())
+            request.reject(error);
+        pending.clear();
+    }
+    else if (message.type === 'invoke-progress') {
+        const request = pending.get(message.id);
+        try {
+            request?.onProgress?.(message.progress);
+        }
+        catch (error) {
+            pending.delete(message.id);
+            request?.reject(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    else if (message.type === 'response') {
+        const request = pending.get(message.id);
+        pending.delete(message.id);
+        if (message.error)
+            request?.reject(pluginExecutionError(message.error));
+        else
+            request?.resolve(message.result);
+    }
+}

package/dist/plugins/runtime/pluginDiagnostics.d.ts

@@ -0,0 +1,26 @@
+import type { PluginModelDiagnostic } from '../../generated/plugin-models.js';
+import type { PluginDiagnosticFailure, PluginDiagnosticOptions, PluginDiagnosticPage, PluginDiagnosticPageBinding, PluginDiagnosticReport } from '../../generated/plugin-diagnostics.js';
+import type { PluginTaskRecord } from './pluginTaskStore.js';
+import type { PluginTaskScope } from '../pluginTaskProtocol.js';
+import type { PluginExecutionHost } from '../../generated/plugin-execution.js';
+export declare const MAX_PLUGIN_DIAGNOSTIC_BYTES: number;
+export declare function normalizeDiagnosticOptions(value: unknown): PluginDiagnosticOptions;
+export declare function diagnosticFailure(value: {
+    code?: string;
+    message?: string;
+} | undefined, options: PluginDiagnosticOptions): PluginDiagnosticFailure | undefined;
+/** A worker can publish only this small operational vocabulary. */
+export declare function normalizeModelDiagnostic(value: unknown, previous?: PluginModelDiagnostic): PluginModelDiagnostic;
+export declare function diagnosticBinding(value: {
+    instanceId: string;
+    target: {
+        browserSessionId: string;
+        tabId: number;
+        frameId: string | number;
+        documentId: string;
+    };
+}): PluginDiagnosticPageBinding;
+export declare function buildDiagnosticReport(host: PluginExecutionHost, scope: PluginTaskScope, options: PluginDiagnosticOptions, scan: {
+    records: PluginTaskRecord[];
+    limited: boolean;
+}, snapshots: PluginDiagnosticPage[]): PluginDiagnosticReport;