@openforge-app/plugin-sdk 0.1.0 → 0.2.3

package/dist/testing/frontendContributionFake.d.ts

@@ -0,0 +1,36 @@
+import { type TaskBrowserSurfaceState } from '../browserSurfaces';
+import type { FrontendOpenForgeAPI } from '../types';
+import { type TestingRegistryServices } from './support';
+import type { TestingInjectionPointContribution, TestingTaskStartPrefixProviderContribution, TestingSettingsSectionContribution, TestingTaskPaneTabContribution, TestingTaskUISectionContribution, TestingViewContribution } from './contracts';
+type TestingFrontendContributionApi = Pick<FrontendOpenForgeAPI, 'browserSurfaces' | 'taskLinks' | 'views' | 'taskUI' | 'taskPane' | 'settings' | 'backend' | 'injectionPoints' | 'taskStart'>;
+export declare class TestingFrontendContributionFake {
+    private readonly services;
+    private readonly invokeBackendMethod;
+    private readonly views;
+    private readonly taskPaneTabs;
+    private readonly taskUISections;
+    private readonly settingsSections;
+    private readonly injectionPoints;
+    private readonly taskStartPrefixProviders;
+    private readonly browserSurfaces;
+    private taskLinkHandler;
+    private api;
+    constructor(services: TestingRegistryServices, invokeBackendMethod: (method: string, payload?: unknown) => Promise<unknown>);
+    createApi(): TestingFrontendContributionApi;
+    setBrowserSurfaceState(taskId: string, id: string, patch: Partial<TaskBrowserSurfaceState>): void;
+    getSnapshot(): {
+        views: TestingViewContribution[];
+        taskPaneTabs: TestingTaskPaneTabContribution[];
+        taskUISections: TestingTaskUISectionContribution[];
+        settingsSections: TestingSettingsSectionContribution[];
+        injectionPoints: TestingInjectionPointContribution[];
+        taskStartPrefixProviders: TestingTaskStartPrefixProviderContribution[];
+    };
+    private registerView;
+    private registerTaskPaneTab;
+    private registerTaskUISection;
+    private registerSettingsSection;
+    private registerTaskStartPrefixProvider;
+    private registerInjectionPoint;
+}
+export {};

package/dist/testing/frontendContributionFake.js

@@ -0,0 +1,195 @@
+import { createTestingBrowserSurfaces } from '../browserSurfacesTesting';
+import { isAllowedBrowserSurfaceUrl } from '../browserSurfaces';
+import { assertFunction, assertTitle, createDisposable, } from './support';
+export class TestingFrontendContributionFake {
+    services;
+    invokeBackendMethod;
+    views = new Map();
+    taskPaneTabs = new Map();
+    taskUISections = new Map();
+    settingsSections = new Map();
+    injectionPoints = new Map();
+    taskStartPrefixProviders = new Map();
+    browserSurfaces;
+    taskLinkHandler = null;
+    api = null;
+    constructor(services, invokeBackendMethod) {
+        this.services = services;
+        this.invokeBackendMethod = invokeBackendMethod;
+        this.browserSurfaces = createTestingBrowserSurfaces(services.calls);
+    }
+    createApi() {
+        if (this.api)
+            return this.api;
+        const api = {
+            browserSurfaces: this.browserSurfaces.api,
+            taskLinks: {
+                open: async (request) => {
+                    this.services.calls.taskLinkOpenRequests.push(request);
+                    if (!isAllowedBrowserSurfaceUrl(request.url)) {
+                        throw new Error('Task links must use a valid HTTP(S) URL');
+                    }
+                    if (this.taskLinkHandler === null) {
+                        this.services.calls.openUrl.push(request.url);
+                        return;
+                    }
+                    const result = await this.taskLinkHandler(request);
+                    if (result === 'declined') {
+                        this.services.calls.openUrl.push(request.url);
+                        return;
+                    }
+                    if (result !== 'handled') {
+                        throw new Error(`Task link handler returned an invalid result: ${String(result)}`);
+                    }
+                },
+                registerHandler: (handler) => {
+                    if (this.taskLinkHandler !== null) {
+                        throw new Error('A Task link handler is already registered');
+                    }
+                    this.taskLinkHandler = handler;
+                    return createDisposable(() => {
+                        if (this.taskLinkHandler === handler)
+                            this.taskLinkHandler = null;
+                    });
+                },
+            },
+            views: {
+                register: (registration) => this.registerView(registration),
+            },
+            taskUI: {
+                registerTab: (registration) => this.registerTaskPaneTab(registration),
+                registerSection: (registration) => this.registerTaskUISection(registration),
+            },
+            taskPane: {
+                registerTab: (registration) => this.registerTaskPaneTab(registration),
+            },
+            settings: {
+                registerSection: (registration) => this.registerSettingsSection(registration),
+            },
+            backend: {
+                state: 'ready',
+                whenReady: async () => undefined,
+                onReady: (handler) => {
+                    handler();
+                    return createDisposable(() => undefined);
+                },
+                invoke: async (method, payload) => this.invokeBackendMethod(method, payload),
+            },
+            injectionPoints: {
+                register: (registration) => this.registerInjectionPoint(registration),
+            },
+            taskStart: {
+                registerPrefixProvider: (registration) => this.registerTaskStartPrefixProvider(registration),
+            },
+        };
+        this.api = api;
+        return api;
+    }
+    setBrowserSurfaceState(taskId, id, patch) {
+        this.browserSurfaces.setState(taskId, id, patch);
+    }
+    getSnapshot() {
+        return {
+            views: Array.from(this.views.values()),
+            taskPaneTabs: Array.from(this.taskPaneTabs.values()),
+            taskUISections: Array.from(this.taskUISections.values()),
+            settingsSections: Array.from(this.settingsSections.values()),
+            injectionPoints: Array.from(this.injectionPoints.values()),
+            taskStartPrefixProviders: Array.from(this.taskStartPrefixProviders.values()).sort((left, right) => left.order - right.order || left.id.localeCompare(right.id)),
+        };
+    }
+    registerView(registration) {
+        const qualifiedId = this.services.localQualifiedId('views', registration.id);
+        assertTitle('views', registration.title);
+        assertFunction('views', 'component', registration.component);
+        this.services.claims.claim('views', qualifiedId);
+        const contribution = {
+            ...registration,
+            id: registration.id.trim(),
+            title: registration.title.trim(),
+            qualifiedId,
+            pluginId: this.services.pluginId,
+            projectId: this.services.projectId,
+        };
+        this.views.set(qualifiedId, contribution);
+        return createDisposable(() => {
+            this.views.delete(qualifiedId);
+            this.services.claims.release('views', qualifiedId);
+        });
+    }
+    registerTaskPaneTab(registration) {
+        const qualifiedId = this.services.localQualifiedId('taskPane', registration.id);
+        assertTitle('taskPane', registration.title);
+        assertFunction('taskPane', 'component', registration.component);
+        this.services.claims.claim('taskPane', qualifiedId);
+        const contribution = {
+            ...registration,
+            id: registration.id.trim(),
+            title: registration.title.trim(),
+            qualifiedId,
+            pluginId: this.services.pluginId,
+            projectId: this.services.projectId,
+        };
+        this.taskPaneTabs.set(qualifiedId, contribution);
+        return createDisposable(() => {
+            this.taskPaneTabs.delete(qualifiedId);
+            this.services.claims.release('taskPane', qualifiedId);
+        });
+    }
+    registerTaskUISection(registration) {
+        const qualifiedId = this.services.localQualifiedId('taskUI', registration.id);
+        assertFunction('taskUI', 'component', registration.component);
+        this.services.claims.claim('taskUI', qualifiedId);
+        const contribution = {
+            ...registration,
+            id: registration.id.trim(),
+            qualifiedId,
+            pluginId: this.services.pluginId,
+            projectId: this.services.projectId,
+        };
+        this.taskUISections.set(qualifiedId, contribution);
+        return createDisposable(() => {
+            this.taskUISections.delete(qualifiedId);
+            this.services.claims.release('taskUI', qualifiedId);
+        });
+    }
+    registerSettingsSection(registration) {
+        const qualifiedId = this.services.localQualifiedId('settings', registration.id);
+        assertTitle('settings', registration.title);
+        assertFunction('settings', 'component', registration.component);
+        this.services.claims.claim('settings', qualifiedId);
+        const contribution = {
+            ...registration,
+            id: registration.id.trim(),
+            title: registration.title.trim(),
+            qualifiedId,
+            pluginId: this.services.pluginId,
+            projectId: this.services.projectId,
+        };
+        this.settingsSections.set(qualifiedId, contribution);
+        return createDisposable(() => {
+            this.settingsSections.delete(qualifiedId);
+            this.services.claims.release('settings', qualifiedId);
+        });
+    }
+    registerTaskStartPrefixProvider(registration) {
+        this.taskStartPrefixProviders.set(registration.id, {
+            id: registration.id,
+            title: registration.title,
+            order: registration.order ?? 0,
+            provide: (context) => registration.provide(context),
+        });
+        return createDisposable(() => {
+            this.taskStartPrefixProviders.delete(registration.id);
+        });
+    }
+    registerInjectionPoint(registration) {
+        this.injectionPoints.set(registration.id, {
+            id: registration.id,
+            location: registration.location,
+        });
+        return createDisposable(() => {
+            this.injectionPoints.delete(registration.id);
+        });
+    }
+}

package/dist/testing/registryFake.d.ts

@@ -0,0 +1,40 @@
+import type { TaskBrowserSurfaceState } from '../browserSurfaces';
+import type { BackendPlugin, BackendPluginContext, FrontendPlugin, FrontendPluginContext, OpenForgePackageMetadata, PluginStorage } from '../types';
+import type { MockBackendOpenForgeAPI, MockFrontendOpenForgeAPI, TestingOpenForgeApiCalls, TestingOpenForgeApiOptions, TestingOpenForgeRegistrySnapshot } from './contracts';
+import { TestingSubscriptionSink } from './support';
+export declare class TestingOpenForgeRegistryFake {
+    readonly pluginId: string;
+    readonly projectId: string | null;
+    readonly taskId: string | null;
+    readonly viewId: string;
+    readonly packageMetadata: OpenForgePackageMetadata;
+    readonly calls: TestingOpenForgeApiCalls;
+    readonly storage: PluginStorage;
+    readonly frontendSubscriptions: TestingSubscriptionSink;
+    readonly backendSubscriptions: TestingSubscriptionSink;
+    private readonly services;
+    private readonly commonApi;
+    private readonly frontendContributions;
+    private readonly backendServices;
+    private cachedFrontendApi;
+    private cachedBackendApi;
+    constructor(options?: TestingOpenForgeApiOptions);
+    get frontendApi(): MockFrontendOpenForgeAPI;
+    get backendApi(): MockBackendOpenForgeAPI;
+    get snapshot(): TestingOpenForgeRegistrySnapshot;
+    createFrontendApi(): MockFrontendOpenForgeAPI;
+    createBackendApi(): MockBackendOpenForgeAPI;
+    createFrontendContext(): FrontendPluginContext;
+    createBackendContext(): BackendPluginContext;
+    activateFrontend(plugin: FrontendPlugin): Promise<void>;
+    activateBackend(plugin: BackendPlugin): Promise<void>;
+    setBrowserSurfaceState(taskId: string, id: string, patch: Partial<TaskBrowserSurfaceState>): void;
+    disposeAll(): Promise<void>;
+    getSnapshot(): TestingOpenForgeRegistrySnapshot;
+    private createContext;
+}
+export declare function createOpenForgeRegistryFake(options?: TestingOpenForgeApiOptions): TestingOpenForgeRegistryFake;
+export declare function createMockOpenForgeApi(options?: TestingOpenForgeApiOptions): MockFrontendOpenForgeAPI;
+export declare function createMockFrontendOpenForgeApi(options?: TestingOpenForgeApiOptions): MockFrontendOpenForgeAPI;
+export declare function createMockBackendOpenForgeApi(options?: TestingOpenForgeApiOptions): MockBackendOpenForgeAPI;
+export declare function createMockPluginContext(options?: TestingOpenForgeApiOptions): FrontendPluginContext;

package/dist/testing/registryFake.js

@@ -0,0 +1,124 @@
+import { TestingBackendServicesFake } from './backendServicesFake';
+import { TestingCommonApiFake } from './commonApiFake';
+import { TestingFrontendContributionFake } from './frontendContributionFake';
+import { TestingRegistryServices, TestingSubscriptionSink, } from './support';
+export class TestingOpenForgeRegistryFake {
+    pluginId;
+    projectId;
+    taskId;
+    viewId;
+    packageMetadata;
+    calls;
+    storage;
+    frontendSubscriptions = new TestingSubscriptionSink();
+    backendSubscriptions = new TestingSubscriptionSink();
+    services;
+    commonApi;
+    frontendContributions;
+    backendServices;
+    cachedFrontendApi = null;
+    cachedBackendApi = null;
+    constructor(options = {}) {
+        this.services = new TestingRegistryServices(options);
+        this.pluginId = this.services.pluginId;
+        this.projectId = this.services.projectId;
+        this.taskId = this.services.taskId;
+        this.viewId = this.services.viewId;
+        this.packageMetadata = this.services.packageMetadata;
+        this.calls = this.services.calls;
+        this.storage = this.services.storage;
+        this.commonApi = new TestingCommonApiFake(this.services);
+        this.backendServices = new TestingBackendServicesFake(this.services);
+        this.frontendContributions = new TestingFrontendContributionFake(this.services, (method, payload) => this.backendServices.invokeMethod(method, payload));
+    }
+    get frontendApi() {
+        return this.createFrontendApi();
+    }
+    get backendApi() {
+        return this.createBackendApi();
+    }
+    get snapshot() {
+        return this.getSnapshot();
+    }
+    createFrontendApi() {
+        if (this.cachedFrontendApi)
+            return this.cachedFrontendApi;
+        const api = {
+            ...this.commonApi.createApi(),
+            ...this.frontendContributions.createApi(),
+            __testing: {
+                calls: this.calls,
+                registry: this,
+            },
+        };
+        this.cachedFrontendApi = api;
+        return api;
+    }
+    createBackendApi() {
+        if (this.cachedBackendApi)
+            return this.cachedBackendApi;
+        const api = {
+            ...this.commonApi.createApi(),
+            ...this.backendServices.createApi(),
+            __testing: {
+                calls: this.calls,
+                registry: this,
+            },
+        };
+        this.cachedBackendApi = api;
+        return api;
+    }
+    createFrontendContext() {
+        return this.createContext(this.frontendSubscriptions);
+    }
+    createBackendContext() {
+        return this.createContext(this.backendSubscriptions);
+    }
+    async activateFrontend(plugin) {
+        await plugin.activate(this.frontendApi, this.createFrontendContext());
+    }
+    async activateBackend(plugin) {
+        const existingServices = this.backendServices.captureBackgroundServiceIds();
+        await plugin.activate(this.backendApi, this.createBackendContext());
+        await this.backendServices.startNewBackgroundServices(existingServices);
+    }
+    setBrowserSurfaceState(taskId, id, patch) {
+        this.frontendContributions.setBrowserSurfaceState(taskId, id, patch);
+    }
+    async disposeAll() {
+        await this.backendSubscriptions.disposeAll();
+        await this.frontendSubscriptions.disposeAll();
+    }
+    getSnapshot() {
+        return {
+            pluginId: this.pluginId,
+            projectId: this.projectId,
+            ...this.frontendContributions.getSnapshot(),
+            ...this.commonApi.getSnapshot(),
+            ...this.backendServices.getSnapshot(),
+        };
+    }
+    createContext(subscriptions) {
+        return {
+            pluginId: this.pluginId,
+            apiVersion: 1,
+            packageMetadata: this.packageMetadata,
+            subscriptions,
+        };
+    }
+}
+export function createOpenForgeRegistryFake(options = {}) {
+    return new TestingOpenForgeRegistryFake(options);
+}
+export function createMockOpenForgeApi(options = {}) {
+    return createMockFrontendOpenForgeApi(options);
+}
+export function createMockFrontendOpenForgeApi(options = {}) {
+    return createOpenForgeRegistryFake(options).frontendApi;
+}
+export function createMockBackendOpenForgeApi(options = {}) {
+    return createOpenForgeRegistryFake(options).backendApi;
+}
+export function createMockPluginContext(options = {}) {
+    return createOpenForgeRegistryFake(options).createFrontendContext();
+}

package/dist/testing/support.d.ts

@@ -0,0 +1,40 @@
+import type { AgentCommandMetadata, CommandDescriptor, Disposable, JsonValue, OpenForgeContextSnapshot, OpenForgeNavigationRequest, OpenForgeNavigationSnapshot, OpenForgePackageMetadata, PluginStorage, StartPromptContribution, SubscriptionSink } from '../types';
+import type { Task } from '../domain';
+import type { TestingCommandContribution, TestingMaybePromise, TestingOpenForgeApiCalls, TestingOpenForgeApiOptions, TestingRuntimeKind } from './contracts';
+export declare function createDisposable(dispose: () => TestingMaybePromise<void>): Disposable;
+export declare class TestingSubscriptionSink implements SubscriptionSink {
+    readonly subscriptions: Disposable[];
+    add(subscription: Disposable | (() => void)): void;
+    disposeAll(): Promise<void>;
+}
+export declare function createTestingCalls(): TestingOpenForgeApiCalls;
+export declare function createMemoryPluginStorage(calls?: TestingOpenForgeApiCalls): PluginStorage;
+export declare function commandDescriptor(command: TestingCommandContribution): CommandDescriptor;
+export declare function normalizeAgentCommandMetadata(metadata: unknown): AgentCommandMetadata | undefined;
+export declare function isJsonValue(value: unknown, seen?: Set<object>): value is JsonValue;
+export declare function assertLocalId(kind: TestingRuntimeKind, id: string): void;
+export declare function assertTitle(kind: TestingRuntimeKind, title: string): void;
+export declare function assertFunction(kind: TestingRuntimeKind, field: string, value: unknown): void;
+export declare class TestingContributionClaims {
+    private readonly ids;
+    claim(kind: TestingRuntimeKind, qualifiedId: string): void;
+    release(kind: TestingRuntimeKind, qualifiedId: string): void;
+    private key;
+}
+export declare class TestingRegistryServices {
+    readonly pluginId: string;
+    readonly projectId: string | null;
+    readonly taskId: string | null;
+    readonly viewId: string;
+    readonly packageMetadata: OpenForgePackageMetadata;
+    readonly calls: TestingOpenForgeApiCalls;
+    readonly storage: PluginStorage;
+    readonly config: Map<string, JsonValue>;
+    readonly seededTasks: Task[];
+    readonly claims: TestingContributionClaims;
+    constructor(options?: TestingOpenForgeApiOptions);
+    localQualifiedId(kind: TestingRuntimeKind, id: string): string;
+    getContextSnapshot(): OpenForgeContextSnapshot;
+    getNavigationSnapshot(overrides?: OpenForgeNavigationRequest): OpenForgeNavigationSnapshot;
+    startPromptContributions(projectId: string): StartPromptContribution[];
+}

package/dist/testing/support.js

@@ -0,0 +1,242 @@
+export function createDisposable(dispose) {
+    let disposed = false;
+    return {
+        async dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            await dispose();
+        },
+    };
+}
+export class TestingSubscriptionSink {
+    subscriptions = [];
+    add(subscription) {
+        if (typeof subscription === 'function') {
+            this.subscriptions.push(createDisposable(subscription));
+            return;
+        }
+        if (!subscription || typeof subscription.dispose !== 'function') {
+            throw new Error('context.subscriptions.add requires a disposable or cleanup function');
+        }
+        this.subscriptions.push(subscription);
+    }
+    async disposeAll() {
+        const subscriptions = this.subscriptions.splice(0).reverse();
+        for (const subscription of subscriptions)
+            await subscription.dispose();
+    }
+}
+export function createTestingCalls() {
+    return {
+        commandInvocations: [],
+        globalCommandInvocations: [],
+        backendInvocations: [],
+        emittedEvents: [],
+        emittedGlobalEvents: [],
+        openUrl: [],
+        clipboardWrites: [],
+        taskLinkOpenRequests: [],
+        navigationRequests: [],
+        notify: [],
+        taskCreations: [],
+        taskComposes: [],
+        startPromptContributionConfigurations: [],
+        taskImplementationStarts: [],
+        taskFollowUps: [],
+        taskListRequests: [],
+        taskStatusUpdates: [],
+        configWrites: [],
+        fsWrites: [],
+        shellSpawns: [],
+        shellWrites: [],
+        shellResizes: [],
+        shellKills: [],
+        shellBuffers: [],
+        browserSurfaceGetOrCreate: [],
+        browserSurfaceAttachments: [],
+        browserSurfaceDetaches: [],
+        browserSurfaceDestroys: [],
+        browserSurfaceNavigations: [],
+        browserSurfaceControls: [],
+        browserSurfaceSelections: [],
+        browserSurfaceFeedbackClears: [],
+        browserSurfaceFeedbackReplacements: [],
+        browserSurfaceCaptureChecks: [],
+        browserSurfaceCaptures: [],
+        browserSurfaceCaptureDiscards: [],
+        browserSurfaceSessionResets: [],
+        storageGets: [],
+        storageSets: [],
+        storageDeletes: [],
+    };
+}
+export function createMemoryPluginStorage(calls = createTestingCalls()) {
+    const values = new Map();
+    function scope(scopeKind, scopeId) {
+        const prefix = `${scopeKind}:${scopeId ?? ''}:`;
+        return {
+            async get(key) {
+                calls.storageGets.push({ scope: scopeKind, scopeId, key });
+                return values.has(`${prefix}${key}`) ? values.get(`${prefix}${key}`) : null;
+            },
+            async set(key, value) {
+                values.set(`${prefix}${key}`, value);
+                calls.storageSets.push({ scope: scopeKind, scopeId, key, value });
+            },
+            async delete(key) {
+                values.delete(`${prefix}${key}`);
+                calls.storageDeletes.push({ scope: scopeKind, scopeId, key });
+            },
+        };
+    }
+    return {
+        global: scope('global', null),
+        project: (projectId) => scope('project', projectId),
+        task: (taskId) => scope('task', taskId),
+    };
+}
+export function commandDescriptor(command) {
+    return {
+        id: command.id,
+        qualifiedId: command.qualifiedId,
+        pluginId: command.pluginId,
+        projectId: command.projectId,
+        title: command.title,
+        icon: command.icon,
+        shortcut: command.shortcut,
+        discoverable: command.discoverable ?? true,
+        input: command.input,
+        output: command.output,
+    };
+}
+export function normalizeAgentCommandMetadata(metadata) {
+    if (metadata === undefined)
+        return undefined;
+    if (metadata === null || typeof metadata !== 'object' || Array.isArray(metadata)) {
+        throw new Error('commands registration agent metadata must be an object');
+    }
+    const candidate = metadata;
+    if (typeof candidate.description !== 'string' || candidate.description.trim().length === 0) {
+        throw new Error('commands registration agent metadata requires a non-empty description');
+    }
+    if (candidate.examples !== undefined && (!Array.isArray(candidate.examples) || !candidate.examples.every(example => isJsonValue(example)))) {
+        throw new Error('commands registration agent metadata examples must contain only JSON values');
+    }
+    if (candidate.discoverable !== undefined && typeof candidate.discoverable !== 'boolean') {
+        throw new Error('commands registration agent metadata discoverable must be a boolean');
+    }
+    return {
+        description: candidate.description.trim(),
+        examples: candidate.examples ? [...candidate.examples] : [],
+        discoverable: candidate.discoverable ?? true,
+    };
+}
+export function isJsonValue(value, seen = new Set()) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+        return true;
+    if (typeof value === 'number')
+        return Number.isFinite(value);
+    if (typeof value !== 'object')
+        return false;
+    if (seen.has(value))
+        return false;
+    seen.add(value);
+    const valid = Array.isArray(value)
+        ? value.every(entry => isJsonValue(entry, seen))
+        : Object.values(value).every(entry => isJsonValue(entry, seen));
+    seen.delete(value);
+    return valid;
+}
+export function assertLocalId(kind, id) {
+    if (typeof id !== 'string' || id.trim().length === 0) {
+        throw new Error(`${kind} registration requires a non-empty id`);
+    }
+    const trimmed = id.trim();
+    if (trimmed.startsWith('openforge.')) {
+        throw new Error(`${kind} registration cannot use openforge.* reserved namespace`);
+    }
+    if (trimmed.includes(':') || trimmed.startsWith('.') || trimmed.endsWith('.') || trimmed.includes('..')) {
+        throw new Error(`${kind} registration has invalid id "${trimmed}"`);
+    }
+}
+export function assertTitle(kind, title) {
+    if (typeof title !== 'string' || title.trim().length === 0) {
+        throw new Error(`${kind} registration requires a non-empty title`);
+    }
+}
+export function assertFunction(kind, field, value) {
+    if (typeof value !== 'function') {
+        throw new Error(`${kind} registration requires a ${field} function`);
+    }
+}
+export class TestingContributionClaims {
+    ids = new Set();
+    claim(kind, qualifiedId) {
+        const key = this.key(kind, qualifiedId);
+        if (this.ids.has(key)) {
+            throw new Error(`Duplicate runtime contribution id: ${qualifiedId}`);
+        }
+        this.ids.add(key);
+    }
+    release(kind, qualifiedId) {
+        this.ids.delete(this.key(kind, qualifiedId));
+    }
+    key(kind, qualifiedId) {
+        return kind === 'commands' ? `commands:${qualifiedId}` : `${kind}:${qualifiedId}`;
+    }
+}
+export class TestingRegistryServices {
+    pluginId;
+    projectId;
+    taskId;
+    viewId;
+    packageMetadata;
+    calls;
+    storage;
+    config = new Map();
+    seededTasks;
+    claims = new TestingContributionClaims();
+    constructor(options = {}) {
+        this.pluginId = options.pluginId ?? 'test-plugin';
+        this.projectId = options.projectId ?? null;
+        this.taskId = options.taskId ?? null;
+        this.viewId = options.viewId ?? 'board';
+        this.packageMetadata = options.packageMetadata ?? {
+            id: this.pluginId,
+            apiVersion: 1,
+            displayName: this.pluginId,
+            description: '',
+        };
+        this.calls = createTestingCalls();
+        this.storage = options.storage ?? createMemoryPluginStorage(this.calls);
+        this.seededTasks = options.tasks ?? [];
+    }
+    localQualifiedId(kind, id) {
+        assertLocalId(kind, id);
+        return `${this.pluginId}.${id.trim()}`;
+    }
+    getContextSnapshot() {
+        return {
+            pluginId: this.pluginId,
+            projectId: this.projectId,
+            ...(this.taskId === null ? {} : { taskId: this.taskId }),
+        };
+    }
+    getNavigationSnapshot(overrides = {}) {
+        return {
+            activeProjectId: overrides.projectId ?? this.projectId,
+            currentView: overrides.viewId ?? this.viewId,
+            selectedTaskId: overrides.taskId ?? this.taskId,
+        };
+    }
+    startPromptContributions(projectId) {
+        const raw = this.config.get(`project:${projectId}:start_prompt_contributions`);
+        return Array.isArray(raw)
+            ? raw.filter((entry) => Boolean(entry)
+                && typeof entry === 'object'
+                && typeof entry.id === 'string'
+                && typeof entry.content === 'string')
+            : [];
+    }
+}