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

package/src/bridge/filePreviewKind.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest'
+import {
+  entrySupportsFilePreview,
+  isPluginExcludedPreviewKind,
+  previewKindForEntry,
+} from './filePreviewKind.js'
+
+describe('filePreviewKind', () => {
+  it('detects previewable entries', () => {
+    expect(
+      entrySupportsFilePreview({
+        path: '/tmp/a.png',
+        name: 'a.png',
+        extension: '.png',
+        kind: 'image',
+        isDirectory: false,
+      }),
+    ).toBe(true)
+    expect(
+      entrySupportsFilePreview({
+        path: '/tmp/a.bin',
+        name: 'a.bin',
+        extension: '.bin',
+        kind: 'other',
+        isDirectory: false,
+      }),
+    ).toBe(false)
+  })
+
+  it('excludes pdf from plugin inline preview', () => {
+    expect(isPluginExcludedPreviewKind('pdf')).toBe(true)
+    expect(isPluginExcludedPreviewKind('image')).toBe(false)
+    expect(
+      previewKindForEntry({
+        path: '/tmp/a.pdf',
+        name: 'a.pdf',
+        extension: '.pdf',
+        kind: 'pdf',
+        isDirectory: false,
+      }),
+    ).toBe('pdf')
+  })
+})

package/src/bridge/filePreviewKind.ts

@@ -0,0 +1,76 @@
+import type { PlatformFileKind, PlatformFilePreviewEntry } from './types.js'
+
+const PREVIEWABLE_TEXT_KINDS = new Set<PlatformFileKind>([
+  'html',
+  'markdown',
+  'text',
+  'data',
+  'code',
+])
+
+const IMAGE_EXTENSIONS = new Set(['png', 'jpg', 'jpeg', 'gif', 'webp', 'svg'])
+const VIDEO_EXTENSIONS = new Set(['mp4', 'mov', 'webm', 'ogv'])
+const AUDIO_EXTENSIONS = new Set(['mp3', 'm4a', 'wav', 'ogg'])
+const PDF_EXTENSIONS = new Set(['pdf'])
+
+export type FilePreviewKind =
+  | 'folder'
+  | 'image'
+  | 'video'
+  | 'audio'
+  | 'pdf'
+  | 'text'
+  | 'other'
+
+export function previewKindForEntry(
+  entry: PlatformFilePreviewEntry,
+): FilePreviewKind {
+  if (entry.isDirectory) return 'folder'
+
+  const extension = entry.extension.toLowerCase().replace(/^\./, '')
+  if (entry.kind === 'image' || IMAGE_EXTENSIONS.has(extension)) return 'image'
+  if (entry.kind === 'video' || VIDEO_EXTENSIONS.has(extension)) return 'video'
+  if (entry.kind === 'audio' || AUDIO_EXTENSIONS.has(extension)) return 'audio'
+  if (entry.kind === 'pdf' || PDF_EXTENSIONS.has(extension)) return 'pdf'
+  if (PREVIEWABLE_TEXT_KINDS.has(entry.kind)) return 'text'
+
+  return 'other'
+}
+
+export function shouldFetchTextPreview(
+  entry: PlatformFilePreviewEntry,
+): boolean {
+  return previewKindForEntry(entry) === 'text'
+}
+
+export function shouldFetchPreviewUrl(
+  entry: PlatformFilePreviewEntry,
+): boolean {
+  const kind = previewKindForEntry(entry)
+  return (
+    kind === 'image' || kind === 'video' || kind === 'audio' || kind === 'pdf'
+  )
+}
+
+/** Kinds with any inline preview surface in `PlatformFilePreview`. */
+export function isPlatformFilePreviewKind(kind: FilePreviewKind): boolean {
+  return kind !== 'folder' && kind !== 'other'
+}
+
+export function entrySupportsFilePreview(
+  entry: PlatformFilePreviewEntry,
+): boolean {
+  if (entry.isDirectory) return false
+  return isPlatformFilePreviewKind(previewKindForEntry(entry))
+}
+
+/**
+ * PDF uses an iframe — blocked inside nested plugin iframes.
+ * Inspector shows a hint; full PDF opens in a shell tab.
+ */
+export const PLATFORM_FILE_PREVIEW_PLUGIN_EXCLUDE_KINDS: readonly FilePreviewKind[] =
+  ['pdf']
+
+export function isPluginExcludedPreviewKind(kind: FilePreviewKind): boolean {
+  return PLATFORM_FILE_PREVIEW_PLUGIN_EXCLUDE_KINDS.includes(kind)
+}

package/src/bridge/fs.d.mts

@@ -0,0 +1,41 @@
+import type {
+  PlatformFilePreviewUrlResult,
+  PlatformFileReadBinaryResult,
+  PlatformFileReadPreviewResult,
+} from './types.js'
+
+export declare const PLATFORM_FILE_TEXT_PREVIEW_MAX_BYTES: number
+export declare const PLATFORM_FILE_BINARY_PREVIEW_MAX_BYTES: number
+
+export declare function readPlatformFilePreview(
+  path: string,
+  maxBytes?: number,
+): Promise<PlatformFileReadPreviewResult>
+
+export declare function readPlatformFileBinary(
+  path: string,
+  maxBytes?: number,
+): Promise<PlatformFileReadBinaryResult>
+
+export declare function readPlatformFilePreviewUrl(
+  path: string,
+): Promise<PlatformFilePreviewUrlResult>
+
+export declare function dataUrlFromFileBinary(
+  result: PlatformFileReadBinaryResult,
+): string
+
+export declare function readPlatformFileBinaryDataUrl(
+  path: string,
+  maxBytes?: number,
+): Promise<string>
+
+export declare function writePlatformFileBinary(
+  path: string,
+  base64: string,
+): Promise<{ ok: true }>
+
+export declare function createPlatformFolder(
+  parentPath: string,
+  name: string,
+): Promise<{ path: string }>

package/src/bridge/fs.mjs

@@ -0,0 +1,82 @@
+import { bridge } from './client.mjs'
+import { PLATFORM_BRIDGE_METHODS } from './methods.mjs'
+
+/** Default text preview cap — matches shell `readPlatformFilePreview`. */
+export const PLATFORM_FILE_TEXT_PREVIEW_MAX_BYTES = 64 * 1024
+
+/** Default binary preview cap for legacy inline image reads. Prefer `fs.previewUrl`. */
+export const PLATFORM_FILE_BINARY_PREVIEW_MAX_BYTES = 5 * 1024 * 1024
+
+/**
+ * @param {string} path
+ * @returns {Promise<import('./types.ts').PlatformFilePreviewUrlResult>}
+ */
+export async function readPlatformFilePreviewUrl(path) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.FS_PREVIEW_URL, [{ path }])
+}
+
+/**
+ * @param {string} path
+ * @param {number | undefined} maxBytes
+ * @returns {Promise<import('./types.ts').PlatformFileReadPreviewResult>}
+ */
+export async function readPlatformFilePreview(path, maxBytes) {
+  const request = maxBytes === undefined ? { path } : { path, maxBytes }
+  return bridge.call(PLATFORM_BRIDGE_METHODS.FS_READ_PREVIEW, [request])
+}
+
+/**
+ * @param {string} path
+ * @param {number | undefined} maxBytes
+ * @returns {Promise<import('./types.ts').PlatformFileReadBinaryResult>}
+ */
+export async function readPlatformFileBinary(path, maxBytes) {
+  const request = maxBytes === undefined ? { path } : { path, maxBytes }
+  return bridge.call(PLATFORM_BRIDGE_METHODS.FS_READ_BINARY, [request])
+}
+
+/**
+ * @param {import('./types.ts').PlatformFileReadBinaryResult} result
+ * @returns {string}
+ */
+export function dataUrlFromFileBinary(result) {
+  return `data:${result.mimeType};base64,${result.base64}`
+}
+
+/**
+ * Read file bytes via bridge and return an inline data URL (non-React).
+ * Default cap matches asset thumbnails and legacy inline image reads.
+ *
+ * @param {string} path
+ * @param {number | undefined} maxBytes
+ * @returns {Promise<string>}
+ */
+export async function readPlatformFileBinaryDataUrl(path, maxBytes) {
+  const result = await readPlatformFileBinary(
+    path,
+    maxBytes ?? PLATFORM_FILE_BINARY_PREVIEW_MAX_BYTES,
+  )
+  return dataUrlFromFileBinary(result)
+}
+
+/**
+ * @param {string} path
+ * @param {string} base64
+ * @returns {Promise<{ ok: true }>}
+ */
+export async function writePlatformFileBinary(path, base64) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.FS_WRITE_BINARY, [
+    { path, base64 },
+  ])
+}
+
+/**
+ * @param {string} parentPath
+ * @param {string} name
+ * @returns {Promise<{ path: string }>}
+ */
+export async function createPlatformFolder(parentPath, name) {
+  return bridge.call(PLATFORM_BRIDGE_METHODS.FS_CREATE_FOLDER, [
+    { parentPath, name },
+  ])
+}

package/src/bridge/fs.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from 'vitest'
+import { dataUrlFromFileBinary } from './fs.mjs'
+
+describe('dataUrlFromFileBinary', () => {
+  it('builds a data URL from bridge binary result', () => {
+    expect(
+      dataUrlFromFileBinary({
+        path: '/tmp/image.png',
+        mimeType: 'image/png',
+        base64: 'abc123',
+        truncated: false,
+        byteLength: 3,
+      }),
+    ).toBe('data:image/png;base64,abc123')
+  })
+})

package/src/bridge/fs.ts

@@ -0,0 +1,10 @@
+export {
+  dataUrlFromFileBinary,
+  readPlatformFileBinary,
+  readPlatformFileBinaryDataUrl,
+  readPlatformFilePreview,
+  readPlatformFilePreviewUrl,
+  writePlatformFileBinary,
+  PLATFORM_FILE_BINARY_PREVIEW_MAX_BYTES,
+  PLATFORM_FILE_TEXT_PREVIEW_MAX_BYTES,
+} from './fs.mjs'

package/src/bridge/index.ts

@@ -0,0 +1,12 @@
+export type { PlatformBridgeEventName } from './events.mjs'
+export type {
+  PlatformFileKind,
+  PlatformAppManifest,
+  PlatformShellManifest,
+  PlatformBridgeReadyMeta,
+  PlatformBridgeViewportBinding,
+  PlatformThemeBridgePayload,
+  ResourceOpenEvent,
+  PlatformBridgeEventHandler,
+  PlatformBridgeClient,
+} from './types.js'

package/src/bridge/inlinePreview.d.mts

@@ -0,0 +1,35 @@
+export type InlineAssetPreviewKind = 'mermaid' | 'table' | 'math'
+
+export interface InlineAssetPreviewResult {
+  html: string
+  error?: string
+}
+
+export declare function extractMermaidSourceFromHtml(html: string): string
+
+export interface ExpandMermaidBlocksOptions {
+  theme?: 'default' | 'dark'
+  /** Wrapper div class around rendered SVG. Default `platform-print-mermaid`. */
+  wrapperClass?: string
+}
+
+export declare function expandMermaidBlocksForPrint(
+  html: string,
+  options?: ExpandMermaidBlocksOptions,
+): Promise<string>
+
+export declare function sanitizeInlineTableHtml(source: string): string
+
+export declare function renderMermaidPreviewSvg(
+  sourceCode: string,
+  options?: { theme?: 'default' | 'dark' },
+): Promise<string>
+
+export declare function renderMathPreviewHtml(
+  sourceCode: string,
+): Promise<string>
+
+export declare function renderInlineAssetPreview(
+  kind: InlineAssetPreviewKind,
+  sourceCode: string,
+): Promise<InlineAssetPreviewResult>

package/src/bridge/inlinePreview.mjs

@@ -0,0 +1,99 @@
+/**
+ * Framework-agnostic inline asset preview (mermaid / math / table HTML).
+ * Mermaid rendering lives in `@purescience/platform-editor/mermaidPreview`.
+ */
+
+import {
+  expandMermaidBlocksForPrint,
+  extractMermaidSourceFromHtml,
+  renderMermaidPreviewSvg,
+} from '@purescience/platform-editor/mermaidPreview'
+
+export {
+  expandMermaidBlocksForPrint,
+  extractMermaidSourceFromHtml,
+  renderMermaidPreviewSvg,
+}
+
+/** @typedef {'mermaid' | 'table' | 'math'} InlineAssetPreviewKind */
+
+function escapeHtml(value) {
+  return value
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;')
+}
+
+/**
+ * @param {string} source
+ * @returns {string}
+ */
+export function sanitizeInlineTableHtml(source) {
+  const fallback = '<table><tbody><tr><td>Empty table</td></tr></tbody></table>'
+  const parser = new DOMParser()
+  const document = parser.parseFromString(
+    source.trim() || fallback,
+    'text/html',
+  )
+  document
+    .querySelectorAll('script, style, iframe, object, embed, link, meta')
+    .forEach(node => node.remove())
+  document.querySelectorAll('*').forEach(element => {
+    for (const attribute of Array.from(element.attributes)) {
+      const name = attribute.name.toLowerCase()
+      const value = attribute.value.trim().toLowerCase()
+      if (name.startsWith('on') || value.startsWith('javascript:')) {
+        element.removeAttribute(attribute.name)
+      }
+    }
+  })
+  const table = document.body.querySelector('table')
+  return (
+    table?.outerHTML ??
+    `<pre>${escapeHtml(source.trim() || 'Empty table')}</pre>`
+  )
+}
+
+/**
+ * @param {string} sourceCode
+ * @returns {Promise<string>}
+ */
+export async function renderMathPreviewHtml(sourceCode) {
+  const katex = await import('katex')
+  return katex.renderToString(sourceCode.trim() || '\\text{Empty equation}', {
+    displayMode: true,
+    throwOnError: false,
+  })
+}
+
+/**
+ * @typedef {{ html: string, error?: string }} InlineAssetPreviewResult
+ */
+
+/**
+ * @param {InlineAssetPreviewKind} kind
+ * @param {string} sourceCode
+ * @returns {Promise<InlineAssetPreviewResult>}
+ */
+export async function renderInlineAssetPreview(kind, sourceCode) {
+  const trimmed = sourceCode.trim()
+
+  try {
+    if (kind === 'mermaid') {
+      return { html: await renderMermaidPreviewSvg(trimmed) }
+    }
+
+    if (kind === 'math') {
+      return { html: await renderMathPreviewHtml(trimmed) }
+    }
+
+    return { html: sanitizeInlineTableHtml(trimmed) }
+  } catch (error) {
+    return {
+      html: '',
+      error: error instanceof Error ? error.message : 'Preview failed.',
+    }
+  }
+}

package/src/bridge/inlinePreview.test.ts

@@ -0,0 +1,56 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mermaidRender = vi.hoisted(() => vi.fn())
+
+vi.mock('mermaid', () => ({
+  default: {
+    initialize: vi.fn(),
+    render: mermaidRender,
+  },
+}))
+
+import {
+  expandMermaidBlocksForPrint,
+  extractMermaidSourceFromHtml,
+} from './inlinePreview.mjs'
+
+describe('inlinePreview mermaid HTML helpers', () => {
+  beforeEach(() => {
+    mermaidRender.mockReset()
+    mermaidRender.mockResolvedValue({
+      svg: '<svg data-testid="mermaid"></svg>',
+    })
+  })
+
+  it('extractMermaidSourceFromHtml preserves arrow syntax', () => {
+    const html =
+      '<figure data-type="mermaid"><pre><code class="language-mermaid">flowchart TD\n  A --> B</code></pre></figure>'
+
+    expect(extractMermaidSourceFromHtml(html)).toBe('flowchart TD\n  A --> B')
+  })
+
+  it('expandMermaidBlocksForPrint replaces blocks with SVG wrapper', async () => {
+    const html =
+      '<figure data-type="mermaid"><pre><code class="language-mermaid">flowchart TD\n  A --> B</code></pre></figure>'
+
+    const expanded = await expandMermaidBlocksForPrint(html, {
+      theme: 'default',
+    })
+
+    expect(mermaidRender).toHaveBeenCalled()
+    expect(expanded).toContain('platform-print-mermaid')
+    expect(expanded).toContain('<svg data-testid="mermaid"></svg>')
+    expect(expanded).not.toContain('language-mermaid')
+  })
+
+  it('expandMermaidBlocksForPrint accepts custom wrapper class', async () => {
+    const html =
+      '<figure data-type="mermaid"><pre><code class="language-mermaid">graph LR; A-->B</code></pre></figure>'
+
+    const expanded = await expandMermaidBlocksForPrint(html, {
+      wrapperClass: 'writer-print-mermaid',
+    })
+
+    expect(expanded).toContain('writer-print-mermaid')
+  })
+})

package/src/bridge/inlinePreview.ts

@@ -0,0 +1,13 @@
+export {
+  expandMermaidBlocksForPrint,
+  extractMermaidSourceFromHtml,
+  renderInlineAssetPreview,
+  renderMathPreviewHtml,
+  renderMermaidPreviewSvg,
+  sanitizeInlineTableHtml,
+} from './inlinePreview.mjs'
+export type {
+  ExpandMermaidBlocksOptions,
+  InlineAssetPreviewKind,
+  InlineAssetPreviewResult,
+} from './inlinePreview.d.mts'

package/src/bridge/methods.d.mts

@@ -0,0 +1,115 @@
+export declare const PLATFORM_BRIDGE_METHODS: {
+  readonly PING: 'ping'
+  readonly RUNTIME_VERSION: 'runtime.version'
+  readonly RUNTIME_PLATFORM: 'runtime.platform'
+  readonly CATALOG_MANIFEST: 'catalog.manifest'
+  readonly CATALOG_MATCH_APPS: 'catalog.matchApps'
+  readonly CATALOG_OPEN: 'catalog.open'
+  readonly WORKSPACE_OPEN_APP: 'workspace.openApp'
+  readonly WORKSPACE_OPEN_PALETTE: 'workspace.openPalette'
+  readonly SCHEDULER_REGISTER: 'scheduler.register'
+  readonly SCHEDULER_UNREGISTER: 'scheduler.unregister'
+  readonly CATALOG_CONSUME_PENDING_OPEN: 'catalog.consumePendingOpen'
+  readonly THEME_SET_SURFACE_PALETTE: 'theme.setSurfacePalette'
+  readonly WINDOW_START_SCREEN_CAPTURE: 'window.startScreenCapture'
+  readonly SETTINGS_PREFS_GET: 'settings.prefs.get'
+  readonly SETTINGS_PREFS_SET: 'settings.prefs.set'
+  readonly SETTINGS_APP_GET: 'settings.app.get'
+  readonly SETTINGS_APP_UPDATE: 'settings.app.update'
+  readonly STORAGE_READ_JSON: 'storage.readJson'
+  readonly STORAGE_WRITE_JSON: 'storage.writeJson'
+  readonly FS_LIST: 'fs.list'
+  readonly FS_READ_PREVIEW: 'fs.readPreview'
+  readonly FS_READ_BINARY: 'fs.readBinary'
+  readonly FS_PREVIEW_URL: 'fs.previewUrl'
+  readonly FS_CREATE_FOLDER: 'fs.createFolder'
+  readonly FS_RENAME: 'fs.rename'
+  readonly FS_DELETE: 'fs.delete'
+  readonly FS_READ: 'fs.read'
+  readonly FS_WRITE: 'fs.write'
+  readonly FS_WRITE_BINARY: 'fs.writeBinary'
+  readonly DIALOG_OPEN_FOLDER: 'dialog.openFolder'
+  readonly DIALOG_SAVE_FOLDER: 'dialog.saveFolder'
+  readonly DIALOG_OPEN_IMAGE: 'dialog.openImage'
+  readonly DIALOG_OPEN_FILE: 'dialog.openFile'
+  readonly OS_REVEAL: 'os.reveal'
+  readonly OS_OPEN_PATH: 'os.openPath'
+  readonly OS_TRASH: 'os.trash'
+  readonly RENDER_PRINT_HTML: 'render.printHtml'
+  readonly RENDER_PREPARE_PAGED_PREVIEW: 'render.preparePagedPreview'
+  readonly RENDER_CAPTURE_PAGED_SNAPSHOT: 'render.capturePagedSnapshot'
+  readonly RENDER_GET_PRINT_STYLESHEET: 'render.getPrintStylesheet'
+  readonly RENDER_CANCEL: 'render.cancel'
+  readonly WATCH_START: 'watch.start'
+  readonly WATCH_STOP: 'watch.stop'
+  readonly ASSETS_LIST: 'assets.list'
+  readonly ASSETS_LIST_SCOPED: 'assets.listScoped'
+  readonly ASSETS_DELETE: 'assets.delete'
+  readonly ASSETS_UPDATE: 'assets.update'
+  readonly ASSETS_UPDATE_SOURCE: 'assets.updateSource'
+  readonly ASSETS_UPDATE_SOURCE_SCOPED: 'assets.updateSourceScoped'
+  readonly ASSETS_GET_SELECTED: 'assets.getSelected'
+  readonly ASSETS_SET_SELECTED: 'assets.setSelected'
+  readonly ASSETS_CREATE_VERSION: 'assets.createVersion'
+  readonly ASSETS_SWAP_REFERENCES: 'assets.swapReferences'
+  readonly ASSETS_SWAP_REFERENCES_SCOPED: 'assets.swapReferencesScoped'
+  readonly ASSETS_TRANSFORM: 'assets.transform'
+  readonly ASSETS_GET_CONTEXT: 'assets.getContext'
+  readonly NETWORK_FETCH: 'network.fetch'
+  readonly OAUTH_LOOPBACK_AUTHORIZE: 'oauth.loopbackAuthorize'
+  readonly SECRETS_GET: 'secrets.get'
+  readonly SECRETS_SET: 'secrets.set'
+  readonly SECRETS_DELETE: 'secrets.delete'
+  readonly SECRETS_STATUS: 'secrets.status'
+  readonly DEBUG_EMIT_EVENT: 'debug.emitEvent'
+  readonly PLUGINS_INSTALL: 'plugins.install'
+  readonly CONTEXT_PUBLISH: 'context.publish'
+  readonly PEOPLE_SUGGEST: 'people.suggest'
+  readonly PEOPLE_RESEARCH: 'people.research'
+  readonly CREDENTIALS_STORAGE_STATUS: 'credentials.storageStatus'
+  readonly CREDENTIALS_LIST: 'credentials.list'
+  readonly CREDENTIALS_SET: 'credentials.set'
+  readonly CREDENTIALS_DELETE: 'credentials.delete'
+  readonly AGENTS_SESSIONS_CREATE: 'agents.sessions.create'
+  readonly AGENTS_SESSIONS_LIST: 'agents.sessions.list'
+  readonly AGENTS_SESSIONS_READ: 'agents.sessions.read'
+  readonly AGENTS_SESSIONS_UPDATE: 'agents.sessions.update'
+  readonly AGENTS_SESSIONS_DELETE: 'agents.sessions.delete'
+  readonly AGENTS_SESSION_SEND_MESSAGE: 'agents.session.sendMessage'
+  readonly AGENTS_SESSION_APPROVE_TOOLS: 'agents.session.approveTools'
+  readonly AGENTS_SESSION_REJECT_TOOLS: 'agents.session.rejectTools'
+  readonly AGENTS_SESSION_ADVANCE_PENDING: 'agents.session.advancePending'
+  readonly AGENTS_SESSION_INTERRUPT: 'agents.session.interrupt'
+  readonly AGENTS_RUN_START: 'agents.run.start'
+  readonly AGENTS_RUN_SEND: 'agents.run.send'
+  readonly AGENTS_RUN_CALL_MODEL: 'agents.run.callModel'
+  readonly AGENTS_RUN_RESOLVE_TOOL_CALLS: 'agents.run.resolveToolCalls'
+  readonly AGENTS_RUN_READ_CONTEXT: 'agents.run.readContext'
+  readonly AGENTS_LLM_MENU_OPTIONS: 'agents.llm.menuOptions'
+  readonly AGENTS_LOCAL_MODELS_STATUS: 'agents.localModels.status'
+  readonly AGENTS_TOOLS_REGISTER: 'agents.tools.register'
+  readonly AGENTS_TOOLS_COMPLETE: 'agents.tools.complete'
+}
+
+export declare const PLATFORM_BRIDGE_METHOD_PREFIXES: {
+  readonly RUNTIME: 'runtime.'
+  readonly THEME: 'theme.'
+  readonly WINDOW: 'window.'
+  readonly SETTINGS: 'settings.'
+  readonly STORAGE: 'storage.'
+  readonly FS: 'fs.'
+  readonly DIALOG: 'dialog.'
+  readonly OS: 'os.'
+  readonly RENDER: 'render.'
+  readonly WATCH: 'watch.'
+  readonly ASSETS: 'assets.'
+  readonly NETWORK: 'network.'
+  readonly OAUTH: 'oauth.'
+  readonly SECRETS: 'secrets.'
+  readonly AGENTS: 'agents.'
+  readonly PEOPLE: 'people.'
+  readonly DEBUG: 'debug.'
+}
+
+export type PlatformBridgeMethodName =
+  (typeof PLATFORM_BRIDGE_METHODS)[keyof typeof PLATFORM_BRIDGE_METHODS]