@openforge-app/plugin-sdk 0.1.0 → 0.2.3

package/dist/svelteHostRuntimeContract.mjs

@@ -26,6 +26,22 @@ export const OPENFORGE_HOST_RUNTIME_SVELTE_SPECIFIERS = Object.freeze(
   SVELTE_HOST_RUNTIME_MODULES.map(module => module.specifier),
 )
 
+const OPENFORGE_HOST_RUNTIME_SVELTE_MODULE_SET = new Set(OPENFORGE_HOST_RUNTIME_SVELTE_SPECIFIERS)
+
+/**
+ * True for the Svelte host-runtime specifiers the HOST renderer build must externalize.
+ *
+ * Externalizing these makes the host emit bare `svelte` / `svelte/internal/client` imports
+ * that resolve through the injected renderer import map to `plugin://host-runtime/svelte`
+ * — the same Svelte instance external plugins load. Host + plugins then share ONE Svelte
+ * instance, so mounting an external plugin component from the host tree no longer throws
+ * `effect_orphan`. Deliberately Svelte-only: once Svelte is external, host-bundled
+ * terminal-runtime resolves Svelte to the shared instance too, so nothing wider is needed.
+ */
+export function isOpenForgeHostRuntimeSvelteExternal(id) {
+  return OPENFORGE_HOST_RUNTIME_SVELTE_MODULE_SET.has(id)
+}
+
 export const SVELTE_HOST_RUNTIME_IMPORTS = Object.freeze(Object.fromEntries(
   SVELTE_HOST_RUNTIME_MODULES.map(module => [module.specifier, `${HOST_RUNTIME_SVELTE_BASE_URL}${module.assetPath}`]),
 ))

package/dist/testing/backendServicesFake.d.ts

@@ -0,0 +1,19 @@
+import type { BackendOpenForgeAPI } from '../types';
+import { type TestingRegistryServices } from './support';
+import type { TestingBackendMethodContribution, TestingBackgroundServiceContribution } from './contracts';
+export declare class TestingBackendServicesFake {
+    private readonly services;
+    private readonly backendMethods;
+    private readonly backgroundServices;
+    constructor(services: TestingRegistryServices);
+    createApi(): Pick<BackendOpenForgeAPI, 'backend' | 'background'>;
+    getSnapshot(): {
+        backendMethods: TestingBackendMethodContribution[];
+        backgroundServices: TestingBackgroundServiceContribution[];
+    };
+    captureBackgroundServiceIds(): Set<string>;
+    startNewBackgroundServices(existingServices: Set<string>): Promise<void>;
+    invokeMethod<TOutput>(method: string, payload?: unknown): Promise<TOutput>;
+    private registerBackendMethod;
+    private registerBackgroundService;
+}

package/dist/testing/backendServicesFake.js

@@ -0,0 +1,87 @@
+import { assertFunction, createDisposable } from './support';
+export class TestingBackendServicesFake {
+    services;
+    backendMethods = new Map();
+    backgroundServices = new Map();
+    constructor(services) {
+        this.services = services;
+    }
+    createApi() {
+        return {
+            backend: {
+                registerMethod: (method, registration) => this.registerBackendMethod(method, registration),
+            },
+            background: {
+                register: (registration) => this.registerBackgroundService(registration),
+            },
+        };
+    }
+    getSnapshot() {
+        return {
+            backendMethods: Array.from(this.backendMethods.values()),
+            backgroundServices: Array.from(this.backgroundServices.values()),
+        };
+    }
+    captureBackgroundServiceIds() {
+        return new Set(this.backgroundServices.keys());
+    }
+    async startNewBackgroundServices(existingServices) {
+        for (const [key, service] of this.backgroundServices.entries()) {
+            if (existingServices.has(key) || service.started)
+                continue;
+            await service.start();
+            service.started = true;
+        }
+    }
+    async invokeMethod(method, payload) {
+        const qualifiedId = this.services.localQualifiedId('backend', method);
+        this.services.calls.backendInvocations.push({ method, qualifiedId, payload });
+        const contribution = this.backendMethods.get(qualifiedId);
+        if (!contribution) {
+            throw new Error(`Backend method is not registered: ${qualifiedId}`);
+        }
+        return await contribution.registration.handler(payload);
+    }
+    registerBackendMethod(method, registration) {
+        const qualifiedId = this.services.localQualifiedId('backend', method);
+        assertFunction('backend', 'handler', registration.handler);
+        this.services.claims.claim('backend', qualifiedId);
+        const contribution = {
+            id: method.trim(),
+            qualifiedId,
+            pluginId: this.services.pluginId,
+            projectId: this.services.projectId,
+            registration,
+        };
+        this.backendMethods.set(qualifiedId, contribution);
+        return createDisposable(() => {
+            this.backendMethods.delete(qualifiedId);
+            this.services.claims.release('backend', qualifiedId);
+        });
+    }
+    registerBackgroundService(registration) {
+        const qualifiedId = this.services.localQualifiedId('background', registration.id);
+        if (registration.scope !== 'global' && registration.scope !== 'project' && registration.scope !== 'task') {
+            throw new Error('background registration requires scope to be global, project, or task');
+        }
+        assertFunction('background', 'start', registration.start);
+        this.services.claims.claim('background', qualifiedId);
+        const contribution = {
+            ...registration,
+            id: registration.id.trim(),
+            qualifiedId,
+            pluginId: this.services.pluginId,
+            projectId: this.services.projectId,
+            started: false,
+        };
+        this.backgroundServices.set(qualifiedId, contribution);
+        return createDisposable(async () => {
+            this.backgroundServices.delete(qualifiedId);
+            this.services.claims.release('background', qualifiedId);
+            if (contribution.started) {
+                await contribution.stop?.();
+                contribution.started = false;
+            }
+        });
+    }
+}

package/dist/testing/commonApiFake.d.ts

@@ -0,0 +1,22 @@
+import type { FrontendOpenForgeAPI, OpenForgeCommonAPI } from '../types';
+import { type TestingRegistryServices } from './support';
+import type { TestingCommandContribution, TestingEventListenerContribution } from './contracts';
+export type TestingCommonApi = OpenForgeCommonAPI & Pick<FrontendOpenForgeAPI, 'navigation'>;
+export declare class TestingCommonApiFake {
+    private readonly services;
+    private readonly commands;
+    private readonly eventListeners;
+    private readonly eventHandlers;
+    private eventListenerSequence;
+    constructor(services: TestingRegistryServices);
+    createApi(): TestingCommonApi;
+    getSnapshot(): {
+        commands: TestingCommandContribution[];
+        eventListeners: TestingEventListenerContribution[];
+    };
+    private registerCommand;
+    private registerEventListener;
+    private invokeCommand;
+    private invokeGlobalCommand;
+    private emitEvent;
+}

package/dist/testing/commonApiFake.js

@@ -0,0 +1,274 @@
+import { assertFunction, assertTitle, commandDescriptor, createDisposable, isJsonValue, normalizeAgentCommandMetadata, } from './support';
+export class TestingCommonApiFake {
+    services;
+    commands = new Map();
+    eventListeners = new Map();
+    eventHandlers = new Map();
+    eventListenerSequence = 0;
+    constructor(services) {
+        this.services = services;
+    }
+    createApi() {
+        const api = {
+            commands: {
+                register: (registration) => this.registerCommand(registration),
+                invoke: async (id, payload) => this.invokeCommand(id, payload),
+                invokeGlobal: async (qualifiedId, payload) => this.invokeGlobalCommand(qualifiedId, payload),
+                list: async () => Array.from(this.commands.values()).map(commandDescriptor),
+                listCatalog: async () => [],
+            },
+            events: {
+                on: (event, handler) => this.registerEventListener(event, handler, false),
+                onGlobal: (qualifiedEvent, handler) => this.registerEventListener(qualifiedEvent, handler, true),
+                emit: async (event, payload) => this.emitEvent(event, payload, false),
+                emitGlobal: async (qualifiedEvent, payload) => this.emitEvent(qualifiedEvent, payload, true),
+            },
+            storage: this.services.storage,
+            context: {
+                getSnapshot: () => this.services.getContextSnapshot(),
+            },
+            tasks: {
+                list: async (request) => {
+                    const projectId = request?.projectId ?? null;
+                    const includeDone = request?.includeDone ?? false;
+                    this.services.calls.taskListRequests.push({ projectId, includeDone });
+                    return this.services.seededTasks.filter((task) => {
+                        if (projectId !== null && task.project_id !== projectId)
+                            return false;
+                        if (!includeDone && task.status === 'done')
+                            return false;
+                        return true;
+                    });
+                },
+                get: async () => null,
+                create: async (request) => {
+                    this.services.calls.taskCreations.push(request);
+                    return {
+                        id: `mock-task-${this.services.calls.taskCreations.length}`,
+                        initial_prompt: request.initialPrompt,
+                        status: 'backlog',
+                        prompt: null,
+                        title: null,
+                        title_source: null,
+                        title_generated_at: null,
+                        agent: null,
+                        permission_mode: null,
+                        worktree_source: null,
+                        worktree_branch: null,
+                        source_ticket_url: null,
+                        depends_on: request.dependsOn ?? [],
+                        project_id: request.projectId,
+                        created_at: 0,
+                        updated_at: 0,
+                    };
+                },
+                // The fake stands in for the host dialog: it records the request and
+                // reports a created-but-not-started task, so consumers can assert what
+                // they asked for without a UI. Override per test for the other outcomes.
+                compose: async (request) => {
+                    this.services.calls.taskComposes.push(request);
+                    const task = await api.tasks.create({
+                        projectId: request.projectId,
+                        initialPrompt: request.initialPrompt,
+                    });
+                    return { task, started: false };
+                },
+                updateStatus: async (taskId, status) => {
+                    this.services.calls.taskStatusUpdates.push({ taskId, status });
+                },
+                listStartPromptContributions: async (projectId) => this.services.startPromptContributions(projectId),
+                configureStartPromptContribution: async (request) => {
+                    this.services.calls.startPromptContributionConfigurations.push(request);
+                    const contribution = { ...request, ownerPluginId: this.services.pluginId };
+                    const existing = this.services.startPromptContributions(request.projectId)
+                        .filter((entry) => entry.id !== request.id
+                        || (entry.ownerPluginId !== undefined && entry.ownerPluginId !== contribution.ownerPluginId));
+                    const next = [...existing, contribution].sort((a, b) => (a.order ?? 0) - (b.order ?? 0)
+                        || a.id.localeCompare(b.id)
+                        || (a.ownerPluginId ?? '').localeCompare(b.ownerPluginId ?? ''));
+                    this.services.config.set(`project:${request.projectId}:start_prompt_contributions`, next);
+                    return next;
+                },
+                startImplementation: async (request) => {
+                    this.services.calls.taskImplementationStarts.push(request);
+                    return {
+                        taskId: request.taskId,
+                        workspacePath: '/mock-workspace',
+                        sessionId: 'mock-session',
+                    };
+                },
+                sendFollowUp: async (request) => {
+                    this.services.calls.taskFollowUps.push(request);
+                    return {
+                        taskId: request.taskId,
+                        sessionId: 'mock-session',
+                        disposition: 'delivered',
+                    };
+                },
+                getWorkspace: async () => null,
+                getLatestSession: async () => null,
+            },
+            projects: {
+                list: async () => [],
+                get: async () => null,
+            },
+            fs: {
+                readDir: async () => [],
+                readFile: async () => ({ type: 'text', content: '', mimeType: null, size: 0 }),
+                writeFile: async (request) => {
+                    this.services.calls.fsWrites.push(request);
+                },
+                searchFiles: async () => [],
+            },
+            shell: {
+                spawn: async (request) => {
+                    this.services.calls.shellSpawns.push(request);
+                    return 0;
+                },
+                write: async (request) => {
+                    this.services.calls.shellWrites.push(request);
+                },
+                resize: async (request) => {
+                    this.services.calls.shellResizes.push(request);
+                },
+                kill: async (request) => {
+                    this.services.calls.shellKills.push(request);
+                },
+                getBuffer: async (request) => {
+                    this.services.calls.shellBuffers.push(request);
+                    return null;
+                },
+            },
+            notifications: {
+                notify: async (request) => {
+                    this.services.calls.notify.push(request);
+                },
+            },
+            attention: {
+                listProjects: async () => [],
+            },
+            system: {
+                openUrl: async (url) => {
+                    this.services.calls.openUrl.push(url);
+                },
+                writeClipboardText: async (text) => {
+                    this.services.calls.clipboardWrites.push(text);
+                },
+            },
+            navigation: {
+                get: () => this.services.getNavigationSnapshot(),
+                navigate: async (request) => {
+                    this.services.calls.navigationRequests.push(request);
+                    return this.services.getNavigationSnapshot(request);
+                },
+            },
+            config: {
+                get: async (key) => this.services.config.has(`global:${key}`)
+                    ? this.services.config.get(`global:${key}`)
+                    : null,
+                set: async (key, value) => {
+                    this.services.config.set(`global:${key}`, value);
+                    this.services.calls.configWrites.push({ key, value, projectId: null });
+                },
+            },
+            projectConfig: {
+                get: async (key, projectId = this.services.projectId ?? '') => this.services.config.has(`project:${projectId}:${key}`)
+                    ? this.services.config.get(`project:${projectId}:${key}`)
+                    : null,
+                set: async (key, value, projectId = this.services.projectId ?? '') => {
+                    this.services.config.set(`project:${projectId}:${key}`, value);
+                    this.services.calls.configWrites.push({ key, value, projectId });
+                },
+            },
+        };
+        return api;
+    }
+    getSnapshot() {
+        return {
+            commands: Array.from(this.commands.values()),
+            eventListeners: Array.from(this.eventListeners.values()),
+        };
+    }
+    registerCommand(registration) {
+        const qualifiedId = this.services.localQualifiedId('commands', registration.id);
+        assertTitle('commands', registration.title);
+        assertFunction('commands', 'handler', registration.handler);
+        const agent = normalizeAgentCommandMetadata(registration.agent);
+        if (agent && registration.input !== undefined && !isJsonValue(registration.input)) {
+            throw new Error('commands registration agent-facing input schema must be a JSON value');
+        }
+        if (agent && registration.output !== undefined && !isJsonValue(registration.output)) {
+            throw new Error('commands registration agent-facing output schema must be a JSON value');
+        }
+        this.services.claims.claim('commands', qualifiedId);
+        const contribution = {
+            ...registration,
+            agent,
+            id: registration.id.trim(),
+            title: registration.title.trim(),
+            qualifiedId,
+            pluginId: this.services.pluginId,
+            projectId: this.services.projectId,
+            handler: registration.handler,
+        };
+        this.commands.set(qualifiedId, contribution);
+        return createDisposable(() => {
+            this.commands.delete(qualifiedId);
+            this.services.claims.release('commands', qualifiedId);
+        });
+    }
+    registerEventListener(event, handler, global) {
+        const qualifiedId = global ? event : this.services.localQualifiedId('events', event);
+        if (qualifiedId.trim().length === 0) {
+            throw new Error('events registration requires a non-empty id');
+        }
+        assertFunction('events', 'handler', handler);
+        const handlers = this.eventHandlers.get(qualifiedId) ?? new Set();
+        handlers.add(handler);
+        this.eventHandlers.set(qualifiedId, handlers);
+        const listenerKey = `${qualifiedId}#${++this.eventListenerSequence}`;
+        const contribution = {
+            id: event,
+            qualifiedId,
+            pluginId: this.services.pluginId,
+            projectId: this.services.projectId,
+            handler,
+            global,
+        };
+        this.eventListeners.set(listenerKey, contribution);
+        return createDisposable(() => {
+            handlers.delete(handler);
+            if (handlers.size === 0)
+                this.eventHandlers.delete(qualifiedId);
+            this.eventListeners.delete(listenerKey);
+        });
+    }
+    async invokeCommand(id, payload) {
+        const qualifiedId = this.services.localQualifiedId('commands', id);
+        this.services.calls.commandInvocations.push({ id, qualifiedId, payload });
+        return this.invokeGlobalCommand(qualifiedId, payload);
+    }
+    async invokeGlobalCommand(qualifiedId, payload) {
+        this.services.calls.globalCommandInvocations.push({ qualifiedId, payload });
+        const command = this.commands.get(qualifiedId);
+        if (!command)
+            throw new Error(`Unknown command: ${qualifiedId}`);
+        return await command.handler(payload, {
+            taskId: null,
+            projectId: command.projectId,
+            source: 'plugin',
+        });
+    }
+    async emitEvent(event, payload, global) {
+        const qualifiedEvent = global ? event : this.services.localQualifiedId('events', event);
+        if (global) {
+            this.services.calls.emittedGlobalEvents.push({ qualifiedEvent, payload });
+        }
+        else {
+            this.services.calls.emittedEvents.push({ event, qualifiedEvent, payload });
+        }
+        for (const handler of Array.from(this.eventHandlers.get(qualifiedEvent) ?? [])) {
+            handler(payload);
+        }
+    }
+}

package/dist/testing/contracts.d.ts

@@ -0,0 +1,231 @@
+import type { BrowserSurfaceVisualFeedback } from '../browserSurfaces';
+import type { TestingOpenForgeRegistryFake } from './registryFake';
+import type { BackendMethodRegistration, BackendOpenForgeAPI, BackgroundServiceRegistration, CommandRegistration, CommandShortcutMetadata, ComposeTaskRequest, ConfigureStartPromptContributionRequest, CreateTaskRequest, FrontendOpenForgeAPI, InjectionPointLocation, JsonValue, NotificationRequest, OpenForgeNavigationRequest, OpenForgePackageMetadata, PluginSettingsSectionRegistration, PluginStorage, PluginTaskPaneTabRegistration, PluginTaskUISectionRegistration, PluginViewRegistration, ShellSpawnRequest, SendTaskFollowUpRequest, StartTaskImplementationRequest, TaskLinkOpenRequest, TaskStartPrefixContext } from '../types';
+import type { Task } from '../domain';
+export type TestingRuntimeScope = 'global' | 'project' | 'task';
+export type TestingRuntimeKind = 'commands' | 'events' | 'views' | 'taskPane' | 'taskUI' | 'settings' | 'backend' | 'background';
+export type TestingMaybePromise<T> = T | Promise<T>;
+export type TestingCommandHandler = (payload?: unknown) => TestingMaybePromise<unknown>;
+export type TestingEventHandler = (payload: unknown) => void;
+export interface TestingOpenForgeApiOptions {
+    pluginId?: string;
+    projectId?: string | null;
+    taskId?: string | null;
+    /** The active view key reported by `navigation.get().currentView`. Defaults to `'board'`. */
+    viewId?: string;
+    packageMetadata?: OpenForgePackageMetadata;
+    storage?: PluginStorage;
+    /**
+     * Tasks returned by `tasks.list`. The mock filters them by the requested
+     * `projectId` (when given) and drops `done` tasks unless `includeDone: true`,
+     * mirroring the host capability. Defaults to an empty list.
+     */
+    tasks?: Task[];
+}
+export interface TestingOpenForgeApiCalls {
+    commandInvocations: Array<{
+        id: string;
+        qualifiedId: string;
+        payload: unknown;
+    }>;
+    globalCommandInvocations: Array<{
+        qualifiedId: string;
+        payload: unknown;
+    }>;
+    backendInvocations: Array<{
+        method: string;
+        qualifiedId: string;
+        payload: unknown;
+    }>;
+    emittedEvents: Array<{
+        event: string;
+        qualifiedEvent: string;
+        payload: unknown;
+    }>;
+    emittedGlobalEvents: Array<{
+        qualifiedEvent: string;
+        payload: unknown;
+    }>;
+    openUrl: string[];
+    clipboardWrites: string[];
+    taskLinkOpenRequests: TaskLinkOpenRequest[];
+    navigationRequests: OpenForgeNavigationRequest[];
+    notify: NotificationRequest[];
+    taskCreations: CreateTaskRequest[];
+    taskComposes: ComposeTaskRequest[];
+    startPromptContributionConfigurations: ConfigureStartPromptContributionRequest[];
+    taskImplementationStarts: StartTaskImplementationRequest[];
+    taskFollowUps: SendTaskFollowUpRequest[];
+    taskListRequests: Array<{
+        projectId: string | null;
+        includeDone: boolean;
+    }>;
+    taskStatusUpdates: Array<{
+        taskId: string;
+        status: string;
+    }>;
+    configWrites: Array<{
+        key: string;
+        value: JsonValue;
+        projectId: string | null;
+    }>;
+    fsWrites: Array<{
+        projectId: string;
+        path: string;
+        content: string;
+    }>;
+    shellSpawns: ShellSpawnRequest[];
+    shellWrites: Array<{
+        taskId: string;
+        terminalIndex: number;
+        data: string;
+    }>;
+    shellResizes: Array<{
+        taskId: string;
+        terminalIndex: number;
+        cols: number;
+        rows: number;
+    }>;
+    shellKills: Array<{
+        taskId: string;
+        terminalIndex: number;
+    }>;
+    shellBuffers: Array<{
+        taskId: string;
+        terminalIndex: number;
+    }>;
+    browserSurfaceGetOrCreate: Array<{
+        taskId: string;
+        id: string;
+        initialUrl?: string;
+    }>;
+    browserSurfaceAttachments: Array<{
+        taskId: string;
+        id: string;
+        element: HTMLElement;
+    }>;
+    browserSurfaceDetaches: Array<{
+        taskId: string;
+        id: string;
+    }>;
+    browserSurfaceDestroys: Array<{
+        taskId: string;
+        id: string;
+    }>;
+    browserSurfaceNavigations: Array<{
+        taskId: string;
+        id: string;
+        url: string;
+    }>;
+    browserSurfaceControls: Array<{
+        taskId: string;
+        id: string;
+        action: 'goBack' | 'goForward' | 'reload' | 'stop';
+    }>;
+    browserSurfaceSelections: Array<{
+        taskId: string;
+        id: string;
+    }>;
+    browserSurfaceFeedbackClears: Array<{
+        taskId: string;
+        id: string;
+    }>;
+    browserSurfaceFeedbackReplacements: Array<{
+        taskId: string;
+        id: string;
+        feedback: BrowserSurfaceVisualFeedback[];
+    }>;
+    browserSurfaceCaptureChecks: Array<{
+        taskId: string;
+        id: string;
+        artifactId: string;
+    }>;
+    browserSurfaceCaptures: Array<{
+        taskId: string;
+        id: string;
+    }>;
+    browserSurfaceCaptureDiscards: Array<{
+        taskId: string;
+        id: string;
+        artifactId: string;
+    }>;
+    browserSurfaceSessionResets: Array<Record<string, never>>;
+    storageGets: Array<{
+        scope: TestingRuntimeScope;
+        scopeId: string | null;
+        key: string;
+    }>;
+    storageSets: Array<{
+        scope: TestingRuntimeScope;
+        scopeId: string | null;
+        key: string;
+        value: JsonValue;
+    }>;
+    storageDeletes: Array<{
+        scope: TestingRuntimeScope;
+        scopeId: string | null;
+        key: string;
+    }>;
+}
+export interface TestingContributionBase {
+    id: string;
+    qualifiedId: string;
+    pluginId: string;
+    projectId: string | null;
+}
+export type TestingCommandContribution = TestingContributionBase & CommandRegistration & {
+    title: string;
+    icon?: string;
+    shortcut?: CommandShortcutMetadata;
+    handler: TestingCommandHandler;
+};
+export type TestingEventListenerContribution = TestingContributionBase & {
+    handler: TestingEventHandler;
+    global: boolean;
+};
+export type TestingViewContribution = TestingContributionBase & PluginViewRegistration;
+export type TestingTaskPaneTabContribution = TestingContributionBase & PluginTaskPaneTabRegistration;
+export type TestingTaskUISectionContribution = TestingContributionBase & PluginTaskUISectionRegistration;
+export type TestingSettingsSectionContribution = TestingContributionBase & PluginSettingsSectionRegistration;
+export type TestingBackendMethodContribution = TestingContributionBase & {
+    registration: BackendMethodRegistration;
+};
+export type TestingBackgroundServiceContribution = TestingContributionBase & BackgroundServiceRegistration & {
+    started: boolean;
+};
+export interface TestingInjectionPointContribution {
+    id: string;
+    location: InjectionPointLocation;
+}
+export interface TestingTaskStartPrefixProviderContribution {
+    id: string;
+    title: string;
+    order: number;
+    provide(context: TaskStartPrefixContext): TestingMaybePromise<string | null>;
+}
+export interface TestingOpenForgeRegistrySnapshot {
+    pluginId: string;
+    projectId: string | null;
+    views: TestingViewContribution[];
+    taskPaneTabs: TestingTaskPaneTabContribution[];
+    taskUISections: TestingTaskUISectionContribution[];
+    settingsSections: TestingSettingsSectionContribution[];
+    commands: TestingCommandContribution[];
+    eventListeners: TestingEventListenerContribution[];
+    backendMethods: TestingBackendMethodContribution[];
+    backgroundServices: TestingBackgroundServiceContribution[];
+    injectionPoints: TestingInjectionPointContribution[];
+    taskStartPrefixProviders: TestingTaskStartPrefixProviderContribution[];
+}
+export type MockFrontendOpenForgeAPI = FrontendOpenForgeAPI & {
+    readonly __testing: {
+        readonly calls: TestingOpenForgeApiCalls;
+        readonly registry: TestingOpenForgeRegistryFake;
+    };
+};
+export type MockBackendOpenForgeAPI = BackendOpenForgeAPI & {
+    readonly __testing: {
+        readonly calls: TestingOpenForgeApiCalls;
+        readonly registry: TestingOpenForgeRegistryFake;
+    };
+};

package/dist/testing/contracts.js

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