@medeo-plugin/sdk 0.7.0 → 0.9.0

package/dist/generated.d.ts

@@ -7,7 +7,7 @@ export type Permission = "storage" | "creation_open" | {
     "file_full_access": Array<string>;
 } | {
     "network": Array<string>;
-} | "agent_api" | "clipboard_read" | "clipboard_write" | "screen_capture" | "camera" | "microphone" | "system_audio" | "applications" | "global_shortcuts" | "notifications" | "tray" | "app_windows" | "accessibility" | "input_method" | {
+} | "agent_api" | "clipboard_read" | "clipboard_write" | "screen_capture" | "camera" | "microphone" | "system_audio" | "applications" | "global_shortcuts" | "notifications" | "tray" | "app_windows" | "accessibility" | "window_management" | "input_method" | {
     "external_open": Array<string>;
 } | {
     "browser_view": Array<string>;
@@ -157,6 +157,28 @@ export type PackageSignature = {
     signature: string;
     index: string;
 };
+export type About = {
+    /**
+     * Display name of the author, at most 80 characters. Official packages show Medeo.
+     */
+    author?: string;
+    /**
+     * SPDX license expression, at most 64 characters.
+     */
+    license?: string;
+    /**
+     * Project website.
+     */
+    homepage?: string;
+    /**
+     * Source repository.
+     */
+    repository?: string;
+    /**
+     * Where users report problems.
+     */
+    bugs?: string;
+};
 export type PackageInfo = {
     manifest: Manifest;
     digest: string;
@@ -171,6 +193,11 @@ export type PackageInfo = {
      * shown at install and in the developer log, never a reason to refuse.
      */
     warnings?: Array<string>;
+    /**
+     * The package's signed `about.json` (author, license, links), when valid.
+     * Older Medeo ignore the file, so declaring it never blocks installation.
+     */
+    about?: About;
 };
 export type CapabilityDescriptor = {
     permission: string;

package/dist/index.d.ts

@@ -13,7 +13,7 @@ export interface PluginAPI {
     post(message: unknown): Promise<void>;
     onMessage(callback: (message: unknown) => void): () => void;
     invoke(method: MethodName, args?: Record<string, unknown>): Promise<unknown>;
-    run(command: string): Promise<unknown>;
+    run(command: string, args?: JsonValue): Promise<unknown>;
 }
 declare global {
     var medeoPlugin: PluginAPI;
@@ -57,7 +57,7 @@ export declare const creation: {
     open: () => Promise<unknown>;
 };
 export declare const commands: {
-    run: (command: string) => Promise<unknown>;
+    run: <T = unknown>(command: string, args?: JsonValue) => Promise<T>;
 };
 export interface Disposable {
     dispose(): unknown;
@@ -68,7 +68,7 @@ export interface PluginContext {
     subscriptions: Disposable[];
     /** Register a handler for each command the manifest declares; all must be registered when `activate` returns. */
     commands: {
-        register(id: string, handler: () => unknown | Promise<unknown>): Disposable;
+        register(id: string, handler: (args?: JsonValue) => unknown | Promise<unknown>): Disposable;
     };
     /** `runtime: "node"` only: the installed, verified package directory (read-only). */
     extensionPath?: string;
@@ -193,7 +193,13 @@ export declare const shortcuts: {
 /** `panel: true` (macOS): a frameless window floating over every app and Space that does not
  * activate Medeo — the app the user was in keeps focus — opened at the pointer and hidden (not
  * closed) when it loses focus; opening it again moves it to the pointer. `hide` keeps a window
- * and its page alive for the next `open`/`focus`. */
+ * and its page alive for the next `open`/`focus`.
+ * `overlay: true` (macOS, needs `window_management` too): a transparent, shadowless panel covering
+ * the whole display under the pointer (menu bar included), above full-screen apps — for previews
+ * and radial menus. It takes keyboard focus without activating Medeo, hides when it loses focus,
+ * and each `open` moves it to the pointer's display; `width`/`height` are ignored. The page's
+ * `window.screenX/screenY` is the display's top-left in the same global points as
+ * `windowManagement`. `panel` and `overlay` are exclusive. */
 export declare const appWindows: {
     open: (options: {
         id: string;
@@ -202,6 +208,7 @@ export declare const appWindows: {
         width: number;
         height: number;
         panel?: boolean;
+        overlay?: boolean;
     }) => Promise<unknown>;
     close: (id: string) => Promise<unknown>;
     focus: (id: string) => Promise<unknown>;
@@ -435,6 +442,7 @@ export interface NetworkRequest {
     body?: string;
     body_base64?: string;
     timeout_ms?: number;
+    stream?: boolean;
 }
 export interface NetworkJob {
     id: string;
@@ -443,6 +451,7 @@ export interface NetworkJob {
     http_status?: number | null;
     headers?: [string, string][];
     error?: string | null;
+    stream?: boolean;
 }
 export interface NetworkChunk {
     data_base64: string;
@@ -454,6 +463,12 @@ export interface NetworkOrigin {
     declared: boolean;
     allowed: boolean;
 }
+export interface NetworkServerEvent {
+    data: string;
+    event: string;
+    id: string;
+    retry?: number;
+}
 export declare const network: {
     origins: () => Promise<NetworkOrigin[]>;
     requestOrigin: (origin: string, reason: string) => Promise<{
@@ -470,6 +485,14 @@ export declare const network: {
     }>;
     /** Resolves once the response has fully arrived; the job stays readable until released. */
     settled(id: string): Promise<NetworkJob>;
+    /** Single consumer for a stream:true job. Break/throw/abort cancels and releases it. */
+    bytes(id: string, signal?: AbortSignal): AsyncGenerator<Uint8Array>;
+    /** Incremental UTF-8 decoder, including code points split across HTTP chunks. */
+    textStream(id: string, signal?: AbortSignal): AsyncGenerator<string>;
+    /** SSE framing only: no automatic reconnect/retry or Last-Event-ID requests. */
+    sse(id: string, signal?: AbortSignal): AsyncGenerator<NetworkServerEvent>;
+    /** Explicitly dispose a stream that was never iterated (or has another owner). */
+    dispose(id: string): Promise<void>;
     text(id: string): Promise<string>;
 };
 /** Workspace operations use current directory references and asynchronous jobs. */
@@ -785,6 +808,61 @@ export declare const accessibility: {
     }>>;
     insertText: (focus: string, text: string) => Promise<NativeOperation<unknown>>;
 };
+/** A rectangle in global points: origin at the top-left of the main display, y grows downwards
+ * (displays left of or above the main one have negative coordinates). */
+export interface WindowFrame {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** The frontmost window of another app. `id` stays the same for the same window while it lives. */
+export interface ManagedWindow {
+    id: string;
+    title: string;
+    application: string;
+    bundle_id: string;
+    frame: WindowFrame;
+    resizable: boolean;
+    fullscreen: boolean;
+    minimized: boolean;
+    standard: boolean;
+}
+/** `visible_frame` excludes the menu bar and the Dock. `id` is the display number for this session,
+ * `uuid` survives restarts and reconnecting. The first entry is the main display. */
+export interface ManagedScreen {
+    id: string;
+    uuid: string;
+    name: string;
+    primary: boolean;
+    scale: number;
+    frame: WindowFrame;
+    visible_frame: WindowFrame;
+}
+/** Window management (macOS, permission `window_management`, OS Accessibility). All calls are
+ * operations: `operations.wait(await windowManagement.focused())`. `request` opens the system
+ * prompt and is window-only; the others work in the worker too. `focused` never returns a Medeo window:
+ * when Medeo is in front (a plugin's own page) it is the window of the app right behind it, and `null`
+ * when there is none or the frontmost app has no window; `set_frame` reports the frame the app
+ * actually accepted (apps may clamp sizes) and fails with `resource_missing` once the window is gone. */
+export declare const windowManagement: {
+    status: () => Promise<NativeOperation<{
+        authorization: "granted" | "denied";
+    }>>;
+    request: () => Promise<NativeOperation<{
+        authorization: "granted" | "denied";
+    }>>;
+    focused: () => Promise<NativeOperation<ManagedWindow | null>>;
+    setFrame: (id: string, frame: WindowFrame) => Promise<NativeOperation<{
+        frame: WindowFrame;
+        resized: boolean;
+    }>>;
+    screens: () => Promise<NativeOperation<ManagedScreen[]>>;
+    pointer: () => Promise<NativeOperation<{
+        x: number;
+        y: number;
+    }>>;
+};
 export declare const browserView: {
     open: (id: string, url: string, width?: number, height?: number) => Promise<unknown>;
     state: (id: string) => Promise<unknown>;

package/dist/index.js

@@ -39,7 +39,7 @@ export const storage = {
     set: (key, value) => globalThis.medeoPlugin.invoke('storage.set', { key, value }),
 };
 export const creation = { open: () => globalThis.medeoPlugin.invoke('creation.open') };
-export const commands = { run: (command) => globalThis.medeoPlugin.run(command) };
+export const commands = { run: (command, args) => globalThis.medeoPlugin.run(command, args) };
 export function definePlugin(definition) {
     return { deactivate: () => undefined, ...definition };
 }
@@ -88,7 +88,13 @@ export const shortcuts = { list: () => globalThis.medeoPlugin.invoke('shortcuts.
 /** `panel: true` (macOS): a frameless window floating over every app and Space that does not
  * activate Medeo — the app the user was in keeps focus — opened at the pointer and hidden (not
  * closed) when it loses focus; opening it again moves it to the pointer. `hide` keeps a window
- * and its page alive for the next `open`/`focus`. */
+ * and its page alive for the next `open`/`focus`.
+ * `overlay: true` (macOS, needs `window_management` too): a transparent, shadowless panel covering
+ * the whole display under the pointer (menu bar included), above full-screen apps — for previews
+ * and radial menus. It takes keyboard focus without activating Medeo, hides when it loses focus,
+ * and each `open` moves it to the pointer's display; `width`/`height` are ignored. The page's
+ * `window.screenX/screenY` is the display's top-left in the same global points as
+ * `windowManagement`. `panel` and `overlay` are exclusive. */
 export const appWindows = { open: (options) => globalThis.medeoPlugin.invoke('windows.open', options), close: (id) => globalThis.medeoPlugin.invoke('windows.close', { id }), focus: (id) => globalThis.medeoPlugin.invoke('windows.focus', { id }), hide: (id) => globalThis.medeoPlugin.invoke('windows.hide', { id }), list: () => globalThis.medeoPlugin.invoke('windows.list') };
 export const tray = { set: (title, items, options = {}) => globalThis.medeoPlugin.invoke('tray.set', { title, items, ...options }), remove: () => globalThis.medeoPlugin.invoke('tray.remove'), events: () => globalThis.medeoPlugin.invoke('tray.events') };
 export const external = { open: (url) => globalThis.medeoPlugin.invoke('external.open', { url }) };
@@ -168,6 +174,121 @@ export const network = {
         await change.promise;
         change.off();
     } },
+    /** Single consumer for a stream:true job. Break/throw/abort cancels and releases it. */
+    async *bytes(id, signal) {
+        let offset = 0;
+        let abortCleanup;
+        const abort = () => { abortCleanup = network.dispose(id); void abortCleanup.catch(() => { }); };
+        signal?.addEventListener('abort', abort, { once: true });
+        try {
+            for (;;) {
+                let wake;
+                const changed = new Promise(resolve => { wake = resolve; });
+                const off = events.on(event => { if (event.type === 'operation' && event.id === id)
+                    wake(); });
+                signal?.addEventListener('abort', wake, { once: true });
+                try {
+                    if (signal?.aborted)
+                        throw new Error('network_cancelled');
+                    const state = await network.state(id);
+                    if (state.status === 'failed' || state.status === 'cancelled')
+                        throw new Error(state.error ?? state.status);
+                    const part = await network.read(id, offset);
+                    offset = part.next_offset;
+                    if (signal?.aborted)
+                        throw new Error('network_cancelled');
+                    if (part.data_base64)
+                        yield Uint8Array.from(atob(part.data_base64), c => c.charCodeAt(0));
+                    if (part.eof)
+                        return;
+                    if (!part.data_base64)
+                        await changed;
+                }
+                finally {
+                    off();
+                    signal?.removeEventListener('abort', wake);
+                }
+            }
+        }
+        finally {
+            signal?.removeEventListener('abort', abort);
+            await (abortCleanup ?? network.dispose(id));
+        }
+    },
+    /** Incremental UTF-8 decoder, including code points split across HTTP chunks. */
+    async *textStream(id, signal) {
+        const decoder = new TextDecoder();
+        for await (const bytes of network.bytes(id, signal)) {
+            const text = decoder.decode(bytes, { stream: true });
+            if (text)
+                yield text;
+        }
+        const tail = decoder.decode();
+        if (tail)
+            yield tail;
+    },
+    /** SSE framing only: no automatic reconnect/retry or Last-Event-ID requests. */
+    async *sse(id, signal) {
+        let pending = '', data = [], event = '', lastId = '', retry, size = 0, skipLf = false;
+        for await (const text of network.textStream(id, signal)) {
+            pending += skipLf && text.startsWith('\n') ? text.slice(1) : text;
+            skipLf = false;
+            for (;;) {
+                const at = pending.search(/[\r\n]/);
+                if (at < 0)
+                    break;
+                skipLf = pending[at] === '\r' && at === pending.length - 1;
+                const line = pending.slice(0, at);
+                pending = pending.slice(at + (pending[at] === '\r' && pending[at + 1] === '\n' ? 2 : 1));
+                size += line.length;
+                if (size > 262144)
+                    throw new Error('network_sse_event_too_large');
+                if (!line) {
+                    if (data.length)
+                        yield { data: data.join('\n'), event: event || 'message', id: lastId, ...(retry === undefined ? {} : { retry }) };
+                    data = [];
+                    event = '';
+                    size = 0;
+                    continue;
+                }
+                if (line.startsWith(':'))
+                    continue;
+                const colon = line.indexOf(':');
+                const field = colon < 0 ? line : line.slice(0, colon);
+                let value = colon < 0 ? '' : line.slice(colon + 1);
+                if (value.startsWith(' '))
+                    value = value.slice(1);
+                if (field === 'data')
+                    data.push(value);
+                else if (field === 'event')
+                    event = value;
+                else if (field === 'id' && !value.includes('\0'))
+                    lastId = value;
+                else if (field === 'retry' && /^\d+$/.test(value) && Number.isSafeInteger(Number(value)))
+                    retry = Number(value);
+            }
+            if (size + pending.length > 262144)
+                throw new Error('network_sse_event_too_large');
+        }
+        // SSE requires a blank line to dispatch; incomplete final events are discarded.
+    },
+    /** Explicitly dispose a stream that was never iterated (or has another owner). */
+    async dispose(id) {
+        const ignoreMissing = (error) => { if (!/^(operation_missing|network_job_missing|permission_denied)$/.test(error instanceof Error ? error.message : String(error)))
+            throw error; };
+        try {
+            await network.cancel(id);
+        }
+        catch (error) {
+            ignoreMissing(error);
+        }
+        try {
+            await network.release(id);
+        }
+        catch (error) {
+            ignoreMissing(error);
+        }
+    },
     async text(id) {
         const decoder = new TextDecoder();
         let offset = 0, text = '';
@@ -299,6 +420,20 @@ function mediaProvider(kind) {
 }
 export const camera = mediaProvider('camera'), microphone = mediaProvider('microphone'), systemAudio = mediaProvider('system_audio');
 export const accessibility = { status: () => nativeCall('accessibility.status'), request: () => nativeCall('accessibility.request'), windows: () => nativeCall('accessibility.windows'), focus: (id) => nativeCall('accessibility.focus', { id }), selectedText: (id) => nativeCall('accessibility.selected_text', { id }), insertText: (focus, text) => nativeCall('accessibility.insert_text', { id: focus, text }) };
+/** Window management (macOS, permission `window_management`, OS Accessibility). All calls are
+ * operations: `operations.wait(await windowManagement.focused())`. `request` opens the system
+ * prompt and is window-only; the others work in the worker too. `focused` never returns a Medeo window:
+ * when Medeo is in front (a plugin's own page) it is the window of the app right behind it, and `null`
+ * when there is none or the frontmost app has no window; `set_frame` reports the frame the app
+ * actually accepted (apps may clamp sizes) and fails with `resource_missing` once the window is gone. */
+export const windowManagement = {
+    status: () => nativeCall('window_management.status'),
+    request: () => nativeCall('window_management.request'),
+    focused: () => nativeCall('window_management.focused'),
+    setFrame: (id, frame) => nativeCall('window_management.set_frame', { id, x: frame.x, y: frame.y, width: frame.width, height: frame.height }),
+    screens: () => nativeCall('window_management.screens'),
+    pointer: () => nativeCall('window_management.pointer'),
+};
 export const browserView = { open: (id, url, width = 1000, height = 720) => capabilities.invoke('browser.open', { id, url, width, height }), state: (id) => capabilities.invoke('browser.state', { id }), close: (id) => capabilities.invoke('browser.close', { id }) };
 export const printing = { print: (text) => capabilities.invoke('printing.print', { text }) };
 export const processes = { start: (executable, args = [], timeoutMs = 60000) => nativeCall('process.start', { executable, arguments: args, timeout_ms: timeoutMs }), state: (id) => nativeCall('process.state', { id }), write: (id, text) => nativeCall('process.write', { id, text }), stop: (id) => nativeCall('process.stop', { id }) };

package/dist/react.d.ts

@@ -0,0 +1,46 @@
+/** React is only imported by the optional @medeo-plugin/sdk/ui/react entry. */
+import { type ReactNode } from 'react';
+import { type CardOptions, type PillOptions, type ToggleOptions, type SegmentedOptions, type ListOptions } from './ui.js';
+export { uiStyles, installStyles } from './ui/styles.js';
+export type { CardOptions, PillOptions, ToggleOptions, SegmentedOptions, ListOptions, Segment } from './ui.js';
+/** Call once near your root. SSR-safe; style installation is idempotent. */
+export declare function useUIStyles(): void;
+export declare function Card({ title, description, testid, children }: CardOptions & {
+    children?: ReactNode;
+}): import("react").DetailedReactHTMLElement<{
+    className: string;
+    'data-testid': string;
+    'aria-label': string;
+}, HTMLElement>;
+export declare function Pill({ label, tone, testid }: PillOptions): import("react").DetailedReactHTMLElement<{
+    className: string;
+    'data-testid': string;
+    'data-tone': "error" | "neutral" | "info";
+}, HTMLElement>;
+/** Controlled: update checked in onChange. Native input supplies name and Space handling. */
+export declare function Toggle({ label, checked, disabled, onChange, testid }: ToggleOptions): import("react").DetailedReactHTMLElement<{
+    className: string;
+    'data-testid': string;
+}, HTMLElement>;
+/** Controlled radio group with a single tab stop and arrow/Home/End navigation. */
+export declare function Segmented<T extends string>({ label, value, options, disabled, onChange, testid }: SegmentedOptions<T>): import("react").DetailedReactHTMLElement<{
+    className: string;
+    role: "radiogroup";
+    'aria-label': string;
+    'data-testid': string;
+}, HTMLElement>;
+export declare function List({ label, testid, items }: ListOptions & {
+    items: readonly {
+        key: string;
+        content: ReactNode;
+    }[];
+}): import("react").DetailedReactHTMLElement<{
+    className: string;
+    'data-testid': string;
+    'aria-label': string;
+}, HTMLElement>;
+export declare function EmptyState({ title, description, testid }: CardOptions): import("react").DetailedReactHTMLElement<{
+    className: string;
+    'data-testid': string;
+    'aria-label': string;
+}, HTMLElement>;

package/dist/react.js

@@ -0,0 +1,44 @@
+/** React is only imported by the optional @medeo-plugin/sdk/ui/react entry. */
+import { createElement as h, useEffect } from 'react';
+import { segmentTarget, segmentTabIndex } from './ui.js';
+import { installStyles } from './ui/styles.js';
+export { uiStyles, installStyles } from './ui/styles.js';
+/** Call once near your root. SSR-safe; style installation is idempotent. */
+export function useUIStyles() { useEffect(() => { installStyles(); }, []); }
+export function Card({ title, description, testid, children }) {
+    return h('section', { className: 'medeo-ui medeo-card', 'data-testid': testid, 'aria-label': title }, h('h2', { 'data-testid': `${testid}.title` }, title), description !== undefined && h('p', { className: 'medeo-description' }, description), children);
+}
+export function Pill({ label, tone = 'info', testid }) {
+    return h('span', { className: 'medeo-ui medeo-pill', 'data-testid': testid, 'data-tone': tone }, label);
+}
+/** Controlled: update checked in onChange. Native input supplies name and Space handling. */
+export function Toggle({ label, checked, disabled, onChange, testid }) {
+    return h('label', { className: 'medeo-ui medeo-toggle', 'data-testid': `${testid}.root` }, h('input', { type: 'checkbox', role: 'switch', checked, disabled, 'data-testid': testid, onChange: (event) => onChange(event.currentTarget.checked) }), h('span', null, label));
+}
+/** Controlled radio group with a single tab stop and arrow/Home/End navigation. */
+export function Segmented({ label, value, options, disabled, onChange, testid }) {
+    return h('div', { className: 'medeo-ui medeo-segmented', role: 'radiogroup', 'aria-label': label, 'data-testid': testid }, options.map((option, index) => h('button', {
+        key: option.value, type: 'button', role: 'radio', 'aria-checked': option.value === value,
+        'data-testid': `${testid}.${index}`, disabled: disabled || option.disabled,
+        tabIndex: disabled ? -1 : segmentTabIndex(options, value, index),
+        onClick: () => { if (!disabled && !option.disabled)
+            onChange(option.value); },
+        onKeyDown: (event) => {
+            if (disabled)
+                return;
+            const group = event.currentTarget.parentElement;
+            const target = segmentTarget(options, index, event.key, getComputedStyle(group).direction === 'rtl');
+            if (target === undefined)
+                return;
+            event.preventDefault();
+            group.children[target].focus();
+            onChange(options[target].value);
+        },
+    }, option.label)));
+}
+export function List({ label, testid, items }) {
+    return h('ul', { className: 'medeo-ui medeo-list', 'data-testid': testid, 'aria-label': label }, items.map(item => h('li', { key: item.key, 'data-testid': `${testid}.${item.key}` }, item.content)));
+}
+export function EmptyState({ title, description, testid }) {
+    return h('section', { className: 'medeo-ui medeo-empty', 'data-testid': testid, 'aria-label': title }, h('h2', null, title), description !== undefined && h('p', { className: 'medeo-description' }, description));
+}

package/dist/registry.d.ts

@@ -713,6 +713,48 @@ export declare const METHODS: {
         readonly confirm: false;
         readonly adapter: "host";
     };
+    readonly "window_management.status": {
+        readonly permission: "window_management";
+        readonly provider: "medeo.system-services";
+        readonly ui: false;
+        readonly confirm: false;
+        readonly adapter: "host";
+    };
+    readonly "window_management.request": {
+        readonly permission: "window_management";
+        readonly provider: "medeo.system-services";
+        readonly ui: true;
+        readonly confirm: false;
+        readonly adapter: "host";
+    };
+    readonly "window_management.focused": {
+        readonly permission: "window_management";
+        readonly provider: "medeo.system-services";
+        readonly ui: false;
+        readonly confirm: false;
+        readonly adapter: "host";
+    };
+    readonly "window_management.set_frame": {
+        readonly permission: "window_management";
+        readonly provider: "medeo.system-services";
+        readonly ui: false;
+        readonly confirm: false;
+        readonly adapter: "host";
+    };
+    readonly "window_management.screens": {
+        readonly permission: "window_management";
+        readonly provider: "medeo.system-services";
+        readonly ui: false;
+        readonly confirm: false;
+        readonly adapter: "host";
+    };
+    readonly "window_management.pointer": {
+        readonly permission: "window_management";
+        readonly provider: "medeo.system-services";
+        readonly ui: false;
+        readonly confirm: false;
+        readonly adapter: "host";
+    };
     readonly "input_method.status": {
         readonly permission: "input_method";
         readonly provider: "medeo.input-method";

package/dist/registry.js

@@ -102,6 +102,12 @@ export const METHODS = {
     "accessibility.focus": { permission: "accessibility", provider: "medeo.system-services", ui: true, confirm: false, adapter: "host" },
     "accessibility.selected_text": { permission: "accessibility", provider: "medeo.system-services", ui: true, confirm: false, adapter: "host" },
     "accessibility.insert_text": { permission: "accessibility", provider: "medeo.system-services", ui: true, confirm: false, adapter: "host" },
+    "window_management.status": { permission: "window_management", provider: "medeo.system-services", ui: false, confirm: false, adapter: "host" },
+    "window_management.request": { permission: "window_management", provider: "medeo.system-services", ui: true, confirm: false, adapter: "host" },
+    "window_management.focused": { permission: "window_management", provider: "medeo.system-services", ui: false, confirm: false, adapter: "host" },
+    "window_management.set_frame": { permission: "window_management", provider: "medeo.system-services", ui: false, confirm: false, adapter: "host" },
+    "window_management.screens": { permission: "window_management", provider: "medeo.system-services", ui: false, confirm: false, adapter: "host" },
+    "window_management.pointer": { permission: "window_management", provider: "medeo.system-services", ui: false, confirm: false, adapter: "host" },
     "input_method.status": { permission: "input_method", provider: "medeo.input-method", ui: false, confirm: false, adapter: "host" },
     "input_method.configure": { permission: "input_method", provider: "medeo.input-method", ui: false, confirm: false, adapter: "host" },
     "input_method.enable": { permission: "input_method", provider: "medeo.input-method", ui: true, confirm: false, adapter: "host" },

package/dist/rpc.d.ts

@@ -0,0 +1,28 @@
+import { type Disposable } from './index.ts';
+/** A transport is injectable for offline tests; the default is this plugin's own channel. */
+export interface RpcTransport {
+    post(message: unknown): Promise<void>;
+    onMessage(listener: (message: unknown) => void): () => void;
+}
+export interface RpcOptions {
+    transport?: RpcTransport;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+type Handler = (...args: any[]) => unknown;
+export type WorkerApiClient<T> = {
+    [K in keyof T]: T[K] extends (...args: infer A) => infer R ? (...args: A) => Promise<Awaited<R>> : never;
+} & {
+    $dispose(): void;
+};
+/** Register in activate, then push the returned disposable into context.subscriptions.
+ * Requests only reach this plugin's worker; this is not a cross-plugin service API.
+ */
+export declare function defineWorkerApi<T extends {
+    [K in keyof T]: Handler;
+}>(handlers: T, options?: Pick<RpcOptions, 'transport'>): Disposable;
+/** Create once per window, dispose on unmount. Timeout/disposal cancels waiting,
+ * not a worker side effect that already started. All arguments/results are JSON.
+ */
+export declare function useWorkerApi<T>(options?: RpcOptions): WorkerApiClient<T>;
+export {};