@puredesktop/puredesktop-ui-bridge 1.0.0-beta.1

package/src/bridge/agents.mjs

@@ -0,0 +1,233 @@
+import { bridge } from './client.mjs'
+import { PLATFORM_BRIDGE_EVENTS } from './events.mjs'
+import { PLATFORM_BRIDGE_METHODS } from './methods.mjs'
+
+/**
+ * Agent session + run bridge SDK for plugin iframes.
+ * Requires `agents` permission in plugin.json.
+ *
+ * Host handlers wire in shell phase S8; constants and client are stable for app authors.
+ */
+
+/** @param {import('./agentTypes.js').PlatformCreateAgentSessionRequest} request */
+export async function createAgentSession(request) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.AGENTS_SESSIONS_CREATE, [request])
+}
+
+/** @param {import('./agentTypes.js').PlatformListAgentSessionsRequest} request */
+export async function listAgentSessions(request) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.AGENTS_SESSIONS_LIST, [request])
+}
+
+/** @param {import('./agentTypes.js').PlatformReadAgentSessionRequest} request */
+export async function readAgentSession(request) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.AGENTS_SESSIONS_READ, [request])
+}
+
+/** @param {import('./agentTypes.js').PlatformUpdateAgentSessionRequest} request */
+export async function updateAgentSession(request) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.AGENTS_SESSIONS_UPDATE, [request])
+}
+
+/** @param {import('./agentTypes.js').PlatformReadAgentSessionRequest} request */
+export async function deleteAgentSession(request) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.AGENTS_SESSIONS_DELETE, [request])
+}
+
+/**
+ * Send a user message on a session; shell drives the run until awaiting user,
+ * manual pending tools, or terminal state.
+ * @param {import('./agentTypes.js').PlatformSendAgentSessionMessageRequest} request
+ * @returns {Promise<import('./agentTypes.js').PlatformAgentSessionDriveResult>}
+ */
+export async function sendAgentSessionMessage(request) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.AGENTS_SESSION_SEND_MESSAGE, [
+    request,
+  ])
+}
+
+/**
+ * Approve manual pending tools and continue the run.
+ * @param {import('./agentTypes.js').PlatformAgentSessionDriveRequest} request
+ * @returns {Promise<import('./agentTypes.js').PlatformAgentSessionDriveResult | null>}
+ */
+export async function approveAgentSessionTools(request) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.AGENTS_SESSION_APPROVE_TOOLS, [
+    request,
+  ])
+}
+
+/**
+ * Reject manual pending tools and continue the run.
+ * @param {import('./agentTypes.js').PlatformRejectAgentSessionToolsRequest} request
+ * @returns {Promise<import('./agentTypes.js').PlatformAgentSessionDriveResult | null>}
+ */
+export async function rejectAgentSessionTools(request) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.AGENTS_SESSION_REJECT_TOOLS, [
+    request,
+  ])
+}
+
+/**
+ * Auto-approve policy-approved pending tools (e.g. after loading a session).
+ * @param {import('./agentTypes.js').PlatformAgentSessionDriveRequest} request
+ * @returns {Promise<import('./agentTypes.js').PlatformAgentSessionDriveResult | null>}
+ */
+export async function advanceAgentSessionPending(request) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.AGENTS_SESSION_ADVANCE_PENDING, [
+    request,
+  ])
+}
+
+/**
+ * Stop the in-flight turn for a session and persist interrupted state.
+ * @param {import('./agentTypes.js').PlatformInterruptAgentSessionRequest} request
+ * @returns {Promise<import('./agentTypes.js').PlatformAgentSessionDriveResult>}
+ */
+export async function interruptAgentSession(request) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.AGENTS_SESSION_INTERRUPT, [request])
+}
+
+/**
+ * Subscribe to streaming agent run events for this plugin tab.
+ * Payload shape matches shell `AgentRunEventIpcPayload` (runId, seq, type, …).
+ *
+ * @param {(payload: import('./agentTypes.js').PlatformAgentRunEvent) => void} listener
+ * @returns {() => void}
+ */
+export function onAgentRunEvent(listener) {
+  return bridge.onEvent(PLATFORM_BRIDGE_EVENTS.AGENT_RUN_EVENT, listener)
+}
+
+/**
+ * Materialize a run for an existing session and send the first user message.
+ * Returns the run snapshot (state 'ready'); drive it with callAgentRunModel
+ * and resolveAgentRunToolCalls until 'awaiting_user'.
+ *
+ * @param {import('./agentTypes.js').PlatformStartAgentRunRequest} request
+ * @returns {Promise<import('./agentTypes.js').PlatformAgentRunSnapshot>}
+ */
+export async function startAgentRun(request) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.AGENTS_RUN_START, [request])
+}
+
+/**
+ * @param {import('./agentTypes.js').PlatformCallAgentModelRequest} request
+ * @returns {Promise<import('./agentTypes.js').PlatformAgentRunSnapshot>}
+ */
+export async function callAgentRunModel(request) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.AGENTS_RUN_CALL_MODEL, [request])
+}
+
+/**
+ * Route policy-approved pending tool calls to their registered app tabs and
+ * resolve them. Tools still pending afterwards need user approval in the
+ * agent drawer.
+ *
+ * @param {import('./agentTypes.js').PlatformResolveAgentToolCallsRequest} request
+ * @returns {Promise<import('./agentTypes.js').PlatformAgentRunSnapshot>}
+ */
+export async function resolveAgentRunToolCalls(request) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.AGENTS_RUN_RESOLVE_TOOL_CALLS, [
+    request,
+  ])
+}
+
+/**
+ * @param {import('./agentTypes.js').PlatformSendAgentRunMessageRequest} request
+ * @returns {Promise<import('./agentTypes.js').PlatformAgentRunSnapshot>}
+ */
+export async function sendAgentRunMessage(request) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.AGENTS_RUN_SEND, [request])
+}
+
+/**
+ * @param {import('./agentTypes.js').PlatformReadAgentRunContextRequest} request
+ * @returns {Promise<import('./agentTypes.js').PlatformAgentRunContext>}
+ */
+export async function readAgentRunContext(request) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.AGENTS_RUN_READ_CONTEXT, [request])
+}
+
+/**
+ * Credential-filtered catalog entries for model menus (configured booleans only).
+ * @param {import('./agentTypes.js').PlatformReadAgentLlmMenuOptionsRequest} [request]
+ * @returns {Promise<import('./agentTypes.js').PlatformAgentLlmMenuOption[]>}
+ */
+export async function readAgentLlmMenuOptions(request = {}) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.AGENTS_LLM_MENU_OPTIONS, [request])
+}
+
+/**
+ * @returns {Promise<import('./agentTypes.js').PlatformLocalModelRuntimeStatus>}
+ */
+export async function readLocalModelsStatus() {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.AGENTS_LOCAL_MODELS_STATUS, [])
+}
+
+/**
+ * Register tool short names implemented by this tab (after bridge ready).
+ * @param {{ tools: string[] }} request
+ */
+export async function registerAgentTools(request) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.AGENTS_TOOLS_REGISTER, [request])
+}
+
+/**
+ * Handle host-initiated tool invocations for this tab.
+ * @param {(payload: {
+ *   invokeId: string
+ *   toolCallId: string
+ *   name: string
+ *   shortName: string
+ *   arguments: Record<string, unknown>
+ * }) => Promise<{ toolCallId: string, content: string, isError?: boolean }>} handler
+ */
+export function onAgentToolInvoke(handler) {
+  return bridge.onEvent(PLATFORM_BRIDGE_EVENTS.AGENT_TOOL_INVOKE, payload => {
+    void (async () => {
+      if (!payload || typeof payload !== 'object') return
+      const invokeId = payload.invokeId
+      const toolCallId = payload.toolCallId
+      const name = payload.name
+      const shortName = payload.shortName
+      if (
+        typeof invokeId !== 'string' ||
+        typeof toolCallId !== 'string' ||
+        typeof name !== 'string' ||
+        typeof shortName !== 'string'
+      ) {
+        return
+      }
+      try {
+        const result = await handler({
+          invokeId,
+          toolCallId,
+          name,
+          shortName,
+          arguments:
+            payload.arguments && typeof payload.arguments === 'object'
+              ? payload.arguments
+              : {},
+        })
+        await bridge.call(PLATFORM_BRIDGE_METHODS.AGENTS_TOOLS_COMPLETE, [
+          {
+            invokeId,
+            toolCallId: result.toolCallId ?? toolCallId,
+            content: result.content,
+            isError: result.isError,
+          },
+        ])
+      } catch (error) {
+        await bridge.call(PLATFORM_BRIDGE_METHODS.AGENTS_TOOLS_COMPLETE, [
+          {
+            invokeId,
+            toolCallId,
+            content: error instanceof Error ? error.message : String(error),
+            isError: true,
+          },
+        ])
+      }
+    })()
+  })
+}

package/src/bridge/agents.ts

@@ -0,0 +1,62 @@
+export {
+  advanceAgentSessionPending,
+  approveAgentSessionTools,
+  callAgentRunModel,
+  createAgentSession,
+  deleteAgentSession,
+  interruptAgentSession,
+  listAgentSessions,
+  onAgentRunEvent,
+  onAgentToolInvoke,
+  readAgentLlmMenuOptions,
+  readAgentRunContext,
+  readAgentSession,
+  readLocalModelsStatus,
+  registerAgentTools,
+  rejectAgentSessionTools,
+  resolveAgentRunToolCalls,
+  sendAgentRunMessage,
+  sendAgentSessionMessage,
+  startAgentRun,
+  updateAgentSession,
+} from './agents.mjs'
+export type {
+  PlatformAgentMessage,
+  PlatformAgentMessageAttachment,
+  PlatformAgentImageAttachment,
+  PlatformAgentSessionConfig,
+  PlatformAgentSessionConfigPatch,
+  PlatformAgentSessionMetadata,
+  PlatformAgentSessionRecord,
+  PlatformAgentSessionScope,
+  PlatformAgentSessionSnapshot,
+  PlatformAgentSessionSummary,
+  PlatformAgentSessionToolPolicy,
+  PlatformAgentUiRunState,
+  PlatformAgentUiToolCall,
+  PlatformCreateAgentSessionRequest,
+  PlatformListAgentSessionsRequest,
+  PlatformReadAgentSessionRequest,
+  PlatformUpdateAgentSessionRequest,
+} from './agentTypes.js'
+
+export type {
+  PlatformAgentRunEvent,
+  PlatformAgentRunSnapshot,
+  PlatformAgentRunContext,
+  PlatformAgentRunUsage,
+  PlatformAgentLlmMenuOption,
+  PlatformCallAgentModelRequest,
+  PlatformInterruptAgentSessionRequest,
+  PlatformReadAgentLlmMenuOptionsRequest,
+  PlatformReadAgentRunContextRequest,
+  PlatformResolveAgentToolCallsRequest,
+  PlatformSendAgentRunMessageRequest,
+  PlatformStartAgentRunRequest,
+  PlatformAgentSessionDriveRequest,
+  PlatformAgentSessionDriveResult,
+  PlatformRejectAgentSessionToolsRequest,
+  PlatformSendAgentSessionMessageRequest,
+  PlatformLocalModelRuntimeStatus,
+  PlatformToolResolution,
+} from './agentTypes.js'

package/src/bridge/appSettings.d.mts

@@ -0,0 +1,9 @@
+import type { PlatformAppSettingsUpdateRequest } from './types.js'
+
+export function getPlatformAppSettings(
+  appSlug: string,
+): Promise<Record<string, unknown>>
+
+export function updatePlatformAppSettings(
+  request: PlatformAppSettingsUpdateRequest,
+): Promise<Record<string, unknown>>

package/src/bridge/appSettings.mjs

@@ -0,0 +1,18 @@
+import { bridge } from './client.mjs'
+import { PLATFORM_BRIDGE_METHODS } from './methods.mjs'
+
+/**
+ * @param {string} appSlug
+ * @returns {Promise<Record<string, unknown>>}
+ */
+export async function getPlatformAppSettings(appSlug) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.SETTINGS_APP_GET, [appSlug])
+}
+
+/**
+ * @param {import('./types.ts').PlatformAppSettingsUpdateRequest} request
+ * @returns {Promise<Record<string, unknown>>}
+ */
+export async function updatePlatformAppSettings(request) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.SETTINGS_APP_UPDATE, [request])
+}

package/src/bridge/appSettings.ts

@@ -0,0 +1,4 @@
+export {
+  getPlatformAppSettings,
+  updatePlatformAppSettings,
+} from './appSettings.mjs'

package/src/bridge/applyThemeFromHost.d.mts

@@ -0,0 +1,7 @@
+import type { PlatformThemeBridgePayload } from './types.js'
+
+export declare const PLATFORM_THEME_STYLE_ID: 'platform-theme-vars-embedded'
+
+export function applyThemeFromHost(
+  payload: PlatformThemeBridgePayload | null | undefined,
+): void

package/src/bridge/applyThemeFromHost.mjs

@@ -0,0 +1,33 @@
+/** Injected into plugin iframe documents (cross-origin safe via bridge). */
+import { injectAppFrameDocumentStyles } from '../theme/utils/appFrameDocumentStyles.mjs'
+
+export const PLATFORM_THEME_STYLE_ID = 'platform-theme-vars-embedded'
+
+/**
+ * @param {{ mode?: string, css?: string } | null | undefined} payload
+ */
+export function applyThemeFromHost(payload) {
+  if (!payload || typeof payload.css !== 'string' || !payload.css.trim()) return
+
+  let el = document.getElementById(PLATFORM_THEME_STYLE_ID)
+  if (!el) {
+    el = document.createElement('style')
+    el.id = PLATFORM_THEME_STYLE_ID
+    document.head.appendChild(el)
+  }
+  el.textContent = payload.css
+
+  const root = document.documentElement
+  if (typeof payload.mode === 'string') {
+    root.dataset.platformTheme = payload.mode
+  }
+
+  const paletteId = payload.surfacePaletteId
+  if (typeof paletteId === 'string' && paletteId.trim()) {
+    root.dataset.platformSurfacePalette = paletteId.trim()
+  } else {
+    delete root.dataset.platformSurfacePalette
+  }
+
+  injectAppFrameDocumentStyles()
+}

package/src/bridge/assets.d.mts

@@ -0,0 +1,66 @@
+import type {
+  PlatformAssetContext,
+  PlatformAssetDeleteRequest,
+  PlatformAssetGetContextRequest,
+  PlatformAssetListScopedRequest,
+  PlatformAssetReferenceSwapRequest,
+  PlatformAssetReferenceSwapScopedRequest,
+  PlatformAssetReferenceSwapResult,
+  PlatformAssetSelection,
+  PlatformAssetSourceUpdateRequest,
+  PlatformAssetSourceUpdateScopedRequest,
+  PlatformAssetSummary,
+  PlatformAssetTransformRequest,
+  PlatformAssetUpdateRequest,
+  PlatformAssetVersionCreateRequest,
+} from './types.js'
+
+export declare function listCollectionAssets(
+  collectionPath: string,
+): Promise<PlatformAssetSummary[]>
+
+export declare function listScopedCollectionAssets(
+  request: PlatformAssetListScopedRequest,
+): Promise<PlatformAssetSummary[]>
+
+export declare function deleteCollectionAsset(
+  request: PlatformAssetDeleteRequest,
+): Promise<boolean>
+
+export declare function updateCollectionAsset(
+  request: PlatformAssetUpdateRequest,
+): Promise<PlatformAssetSummary>
+
+export declare function updateCollectionAssetSource(
+  request: PlatformAssetSourceUpdateRequest,
+): Promise<PlatformAssetSummary>
+
+export declare function updateCollectionAssetSourceScoped(
+  request: PlatformAssetSourceUpdateScopedRequest,
+): Promise<PlatformAssetSummary>
+
+export declare function getSelectedCollectionAsset(): Promise<PlatformAssetSelection | null>
+
+export declare function setSelectedCollectionAsset(
+  selection: PlatformAssetSelection | null,
+): Promise<boolean>
+
+export declare function createCollectionAssetVersion(
+  request: PlatformAssetVersionCreateRequest,
+): Promise<PlatformAssetSummary>
+
+export declare function swapCollectionAssetReferences(
+  request: PlatformAssetReferenceSwapRequest,
+): Promise<PlatformAssetReferenceSwapResult>
+
+export declare function swapCollectionAssetReferencesScoped(
+  request: PlatformAssetReferenceSwapScopedRequest,
+): Promise<PlatformAssetReferenceSwapResult>
+
+export declare function transformCollectionAsset(
+  request: PlatformAssetTransformRequest,
+): Promise<PlatformAssetSummary>
+
+export declare function getCollectionAssetContext(
+  request: PlatformAssetGetContextRequest,
+): Promise<PlatformAssetContext | null>

package/src/bridge/assets.mjs

@@ -0,0 +1,121 @@
+import { bridge } from './client.mjs'
+import { PLATFORM_BRIDGE_METHODS } from './methods.mjs'
+
+/**
+ * List file + inline assets for a writer workspace or `.document` package root.
+ * Requires `assets` permission in plugin.json.
+ *
+ * @param {string} collectionPath Absolute path to the collection root
+ * @returns {Promise<import('./types.js').PlatformAssetSummary[]>}
+ */
+export async function listCollectionAssets(collectionPath) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.ASSETS_LIST, [collectionPath])
+}
+
+/**
+ * List assets when the app supplies manifest-known document paths (e.g. book chapters).
+ * Requires `assets` permission in plugin.json.
+ *
+ * @param {import('./types.js').PlatformAssetListScopedRequest} request
+ * @returns {Promise<import('./types.js').PlatformAssetSummary[]>}
+ */
+export async function listScopedCollectionAssets(request) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.ASSETS_LIST_SCOPED, [request])
+}
+
+/**
+ * @param {import('./types.js').PlatformAssetDeleteRequest} request
+ * @returns {Promise<boolean>}
+ */
+export async function deleteCollectionAsset(request) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.ASSETS_DELETE, [request])
+}
+
+/**
+ * @param {import('./types.js').PlatformAssetUpdateRequest} request
+ * @returns {Promise<import('./types.js').PlatformAssetSummary>}
+ */
+export async function updateCollectionAsset(request) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.ASSETS_UPDATE, [request])
+}
+
+/**
+ * Update inline mermaid / table / math source in document HTML.
+ *
+ * @param {import('./types.js').PlatformAssetSourceUpdateRequest} request
+ * @returns {Promise<import('./types.js').PlatformAssetSummary>}
+ */
+export async function updateCollectionAssetSource(request) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.ASSETS_UPDATE_SOURCE, [request])
+}
+
+/**
+ * Update inline mermaid / table / math source when the app supplies document paths.
+ *
+ * @param {import('./types.js').PlatformAssetSourceUpdateScopedRequest} request
+ * @returns {Promise<import('./types.js').PlatformAssetSummary>}
+ */
+export async function updateCollectionAssetSourceScoped(request) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.ASSETS_UPDATE_SOURCE_SCOPED, [
+    request,
+  ])
+}
+
+/** @returns {Promise<import('./types.js').PlatformAssetSelection | null>} */
+export async function getSelectedCollectionAsset() {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.ASSETS_GET_SELECTED, [])
+}
+
+/**
+ * @param {import('./types.js').PlatformAssetSelection | null} selection
+ * @returns {Promise<boolean>}
+ */
+export async function setSelectedCollectionAsset(selection) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.ASSETS_SET_SELECTED, [selection])
+}
+
+/**
+ * @param {import('./types.js').PlatformAssetVersionCreateRequest} request
+ * @returns {Promise<import('./types.js').PlatformAssetSummary>}
+ */
+export async function createCollectionAssetVersion(request) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.ASSETS_CREATE_VERSION, [request])
+}
+
+/**
+ * @param {import('./types.js').PlatformAssetReferenceSwapRequest} request
+ * @returns {Promise<import('./types.js').PlatformAssetReferenceSwapResult>}
+ */
+export async function swapCollectionAssetReferences(request) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.ASSETS_SWAP_REFERENCES, [request])
+}
+
+/**
+ * Swap asset references when the app supplies document paths for collection scope.
+ *
+ * @param {import('./types.js').PlatformAssetReferenceSwapScopedRequest} request
+ * @returns {Promise<import('./types.js').PlatformAssetReferenceSwapResult>}
+ */
+export async function swapCollectionAssetReferencesScoped(request) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.ASSETS_SWAP_REFERENCES_SCOPED, [
+    request,
+  ])
+}
+
+/**
+ * Local quick-variant transform (filter / rotate / flip) → new version in lineage.
+ *
+ * @param {import('./types.js').PlatformAssetTransformRequest} request
+ * @returns {Promise<import('./types.js').PlatformAssetSummary>}
+ */
+export async function transformCollectionAsset(request) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.ASSETS_TRANSFORM, [request])
+}
+
+/**
+ * @param {import('./types.js').PlatformAssetGetContextRequest} request
+ * @returns {Promise<import('./types.js').PlatformAssetContext | null>}
+ */
+export async function getCollectionAssetContext(request) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.ASSETS_GET_CONTEXT, [request])
+}

package/src/bridge/catalog.d.mts

@@ -0,0 +1,5 @@
+import type { PlatformAppInstallState, ResourceOpenEvent } from './types.js'
+
+export function consumePendingCatalogOpen(): Promise<ResourceOpenEvent | null>
+
+export function isPluginAppInstalled(app: PlatformAppInstallState): boolean

package/src/bridge/catalog.mjs

@@ -0,0 +1,24 @@
+import { bridge } from './client.mjs'
+import { PLATFORM_BRIDGE_METHODS } from './methods.mjs'
+
+/**
+ * Cold-start: pull `catalog.open` intent after bridge + boot (path only; app reads via fs).
+ *
+ * @returns {Promise<import('./types.ts').ResourceOpenEvent | null>}
+ */
+export async function consumePendingCatalogOpen() {
+  const result = await bridge.call(
+    PLATFORM_BRIDGE_METHODS.CATALOG_CONSUME_PENDING_OPEN,
+  )
+  return result?.resource ?? null
+}
+
+/**
+ * Same rule as shell `isAppInstalled` in catalogAppState.ts.
+ *
+ * @param {import('./types.ts').PlatformAppInstallState} app
+ * @returns {boolean}
+ */
+export function isPluginAppInstalled(app) {
+  return Boolean(app.pluginRoot)
+}

package/src/bridge/catalog.ts

@@ -0,0 +1 @@
+export { consumePendingCatalogOpen, isPluginAppInstalled } from './catalog.mjs'

package/src/bridge/client.d.mts

@@ -0,0 +1,19 @@
+import type { PlatformBridgeClient } from './types.js'
+import type { PlatformBridgeEventName } from './events.mjs'
+import type { PlatformBridgeMethodName } from './methods.mjs'
+
+export declare const PLATFORM_BRIDGE_EVENTS: {
+  readonly RESOURCE_OPEN: 'resource.open'
+  readonly THEME_CHANGED: 'theme.changed'
+  readonly RENDER_PROGRESS: 'render.progress'
+  readonly DEBUG_TEST: 'debug.test'
+}
+
+export {
+  PLATFORM_BRIDGE_METHODS,
+  PLATFORM_BRIDGE_METHOD_PREFIXES,
+} from './methods.mjs'
+
+export const bridge: PlatformBridgeClient
+
+export type { PlatformBridgeEventName, PlatformBridgeMethodName }