@openforge-app/plugin-sdk 0.1.0

package/dist/types.d.ts

@@ -0,0 +1,350 @@
+import type { Component } from 'svelte';
+import type { AgentSession, FileContent, FileEntry, Project, ProjectAttention, Task, TaskWorkspaceInfo, WritableBoardStatus } from './domain';
+export type SupportedOpenForgeApiVersion = 1;
+export declare const SUPPORTED_OPENFORGE_API_VERSIONS: readonly [1, ...1[]];
+export declare const OPENFORGE_PLUGIN_API_VERSION: SupportedOpenForgeApiVersion;
+export declare const MIN_SUPPORTED_API_VERSION: SupportedOpenForgeApiVersion;
+export declare const MAX_SUPPORTED_API_VERSION: SupportedOpenForgeApiVersion;
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonObject | JsonValue[];
+export interface JsonObject {
+    [key: string]: JsonValue;
+}
+export type JsonSchema = Record<string, unknown>;
+export type MaybePromise<T> = T | Promise<T>;
+export interface ValidationError {
+    path: string;
+    message: string;
+}
+export type OpenForgePluginCapability = 'commands' | 'events' | 'views' | 'taskPane' | 'settings' | 'background' | 'backend' | 'storage' | 'context' | 'navigation' | 'tasks' | 'projects' | 'fs' | 'shell' | 'notifications' | 'attention' | 'system.openUrl' | 'config' | 'projectConfig';
+export interface OpenForgePackageMetadata {
+    id: string;
+    apiVersion: SupportedOpenForgeApiVersion;
+    displayName: string;
+    description: string;
+    icon?: string;
+    frontend?: string;
+    backend?: string;
+    requires?: OpenForgePluginCapability[];
+}
+export interface OpenForgePluginPackageJson {
+    name: string;
+    version: string;
+    peerDependencies?: Record<string, string>;
+    openforge: OpenForgePackageMetadata;
+}
+export type PluginState = 'installed' | 'active' | 'error' | 'disabled';
+export interface PluginEntry {
+    metadata: OpenForgePackageMetadata;
+    state: PluginState;
+    error: string | null;
+    installPath?: string;
+    isBuiltin?: boolean;
+}
+export interface Disposable {
+    dispose(): void | Promise<void>;
+}
+export interface SubscriptionSink {
+    add(subscription: Disposable | (() => void)): void;
+}
+export interface OpenForgeContextSnapshot {
+    pluginId: string;
+    projectId: string | null;
+    taskId?: string | null;
+}
+export interface OpenForgeNavigationSnapshot {
+    activeProjectId: string | null;
+    currentView: string;
+    selectedTaskId: string | null;
+}
+export interface OpenForgeNavigationRequest {
+    viewId?: string;
+    projectId?: string | null;
+    taskId?: string | null;
+}
+export interface NavigationAPI {
+    get(): OpenForgeNavigationSnapshot;
+    navigate(request: OpenForgeNavigationRequest): Promise<OpenForgeNavigationSnapshot>;
+}
+export interface OpenForgePluginContext {
+    pluginId: string;
+    apiVersion: SupportedOpenForgeApiVersion;
+    packageMetadata: OpenForgePackageMetadata;
+    subscriptions: SubscriptionSink;
+}
+export type FrontendPluginContext = OpenForgePluginContext;
+export type BackendPluginContext = OpenForgePluginContext;
+export interface PluginStorageScope {
+    get<T extends JsonValue = JsonValue>(key: string): Promise<T | null>;
+    set<T extends JsonValue = JsonValue>(key: string, value: T): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+export interface PluginStorage {
+    readonly global: PluginStorageScope;
+    project(projectId: string): PluginStorageScope;
+    task(taskId: string): PluginStorageScope;
+}
+export type CommandShortcutMetadata = string | {
+    key: string;
+    scope?: 'global' | 'project' | 'task';
+    when?: string;
+};
+export interface CommandRegistration<TInput = unknown, TOutput = unknown> {
+    id: string;
+    title: string;
+    icon?: string;
+    shortcut?: CommandShortcutMetadata;
+    /** Whether this command should appear in user-facing discovery surfaces such as the Command Palette. Defaults to true. */
+    discoverable?: boolean;
+    input?: JsonSchema;
+    output?: JsonSchema;
+    handler(input: TInput): MaybePromise<TOutput>;
+}
+export interface CommandDescriptor {
+    id: string;
+    qualifiedId: string;
+    pluginId: string;
+    projectId: string | null;
+    title: string;
+    icon?: string;
+    shortcut?: CommandShortcutMetadata;
+    discoverable: boolean;
+    input?: JsonSchema;
+    output?: JsonSchema;
+}
+export interface CommandRegistry {
+    register<TInput = unknown, TOutput = unknown>(registration: CommandRegistration<TInput, TOutput>): Disposable;
+    invoke<TOutput = unknown>(id: string, payload?: unknown): Promise<TOutput>;
+    invokeGlobal<TOutput = unknown>(qualifiedId: string, payload?: unknown): Promise<TOutput>;
+    list(): Promise<CommandDescriptor[]>;
+}
+export type EventHandler<TPayload = unknown> = (payload: TPayload) => void;
+export interface EventRegistry {
+    on<TPayload = unknown>(event: string, handler: EventHandler<TPayload>): Disposable;
+    onGlobal<TPayload = unknown>(qualifiedEvent: string, handler: EventHandler<TPayload>): Disposable;
+    emit<TPayload = unknown>(event: string, payload: TPayload): Promise<void>;
+    emitGlobal<TPayload = unknown>(qualifiedEvent: string, payload: TPayload): Promise<void>;
+}
+export type PluginComponent<Props extends Record<string, unknown> = Record<string, unknown>> = Component<Props>;
+export type PluginComponentModule<Props extends Record<string, unknown> = Record<string, unknown>> = {
+    default: PluginComponent<Props>;
+};
+export type PluginComponentLoader<Props extends Record<string, unknown> = Record<string, unknown>> = () => MaybePromise<PluginComponent<Props> | PluginComponentModule<Props>>;
+export interface PluginViewProps extends Record<string, unknown> {
+    api: FrontendOpenForgeAPI;
+    context: OpenForgeContextSnapshot;
+}
+export interface PluginTaskPaneProps extends Record<string, unknown> {
+    api: FrontendOpenForgeAPI;
+    context: OpenForgeContextSnapshot;
+    taskId: string;
+    projectId: string | null;
+}
+export interface PluginSettingsSectionProps extends Record<string, unknown> {
+    api: FrontendOpenForgeAPI;
+    context: OpenForgeContextSnapshot;
+}
+export interface PluginViewRegistration {
+    id: string;
+    title: string;
+    icon: string;
+    /**
+     * Where the host surfaces the view's nav entry. `'rail'` (default) places it on
+     * the icon rail; `'sidebar'` places it in the left projects sidebar. Either way
+     * the view itself is registered and routable by its key.
+     */
+    placement: 'rail' | 'sidebar';
+    order?: number;
+    shortcut?: string;
+    component: PluginComponentLoader<PluginViewProps> | PluginComponent<PluginViewProps>;
+}
+export interface PluginTaskPaneTabRegistration {
+    id: string;
+    title: string;
+    icon?: string;
+    order?: number;
+    component: PluginComponentLoader<PluginTaskPaneProps> | PluginComponent<PluginTaskPaneProps>;
+}
+export interface PluginSettingsSectionRegistration {
+    id: string;
+    title: string;
+    order?: number;
+    component: PluginComponentLoader<PluginSettingsSectionProps> | PluginComponent<PluginSettingsSectionProps>;
+}
+export interface FrontendViewRegistry {
+    register(registration: PluginViewRegistration): Disposable;
+}
+export interface FrontendTaskPaneRegistry {
+    registerTab(registration: PluginTaskPaneTabRegistration): Disposable;
+}
+export interface FrontendSettingsRegistry {
+    registerSection(registration: PluginSettingsSectionRegistration): Disposable;
+}
+export type BackendReadyState = 'missing' | 'starting' | 'ready' | 'error';
+export interface FrontendBackendBridge {
+    readonly state: BackendReadyState;
+    whenReady(): Promise<void>;
+    onReady(handler: () => void): Disposable;
+    invoke<TOutput = unknown>(method: string, payload?: unknown): Promise<TOutput>;
+}
+export interface BackendMethodRegistration<TInput = unknown, TOutput = unknown> {
+    input?: JsonSchema;
+    output?: JsonSchema;
+    handler(input: TInput): MaybePromise<TOutput>;
+}
+export interface BackendMethodRegistry {
+    registerMethod<TInput = unknown, TOutput = unknown>(method: string, registration: BackendMethodRegistration<TInput, TOutput>): Disposable;
+}
+export interface BackgroundServiceRegistration {
+    id: string;
+    scope: 'global' | 'project' | 'task';
+    start(): MaybePromise<void>;
+    stop?(): MaybePromise<void>;
+}
+export interface BackgroundServiceRegistry {
+    register(registration: BackgroundServiceRegistration): Disposable;
+}
+export interface ProjectScopedFileRequest {
+    projectId: string;
+    path: string;
+}
+export interface FileSystemAPI {
+    readDir(request: {
+        projectId: string;
+        path?: string | null;
+    }): Promise<FileEntry[]>;
+    readFile(request: ProjectScopedFileRequest): Promise<FileContent>;
+    writeFile(request: ProjectScopedFileRequest & {
+        content: string;
+    }): Promise<void>;
+    searchFiles(request: {
+        projectId: string;
+        query: string;
+        limit?: number;
+    }): Promise<string[]>;
+}
+export interface ShellSessionRequest {
+    taskId: string;
+    terminalIndex: number;
+}
+export interface ShellSpawnRequest extends ShellSessionRequest {
+    cwd: string;
+    cols: number;
+    rows: number;
+}
+export interface ShellWriteRequest extends ShellSessionRequest {
+    data: string;
+}
+export interface ShellResizeRequest extends ShellSessionRequest {
+    cols: number;
+    rows: number;
+}
+export interface ShellAPI {
+    spawn(request: ShellSpawnRequest): Promise<number>;
+    write(request: ShellWriteRequest): Promise<void>;
+    resize(request: ShellResizeRequest): Promise<void>;
+    kill(request: ShellSessionRequest): Promise<void>;
+    getBuffer(request: ShellSessionRequest): Promise<string | null>;
+}
+export interface CreateTaskRequest {
+    initialPrompt: string;
+    projectId: string;
+    dependsOn?: string[];
+    labelNames?: string[];
+}
+export interface StartPromptContribution {
+    id: string;
+    enabled: boolean;
+    /** Prompt text injected before OpenForge's task prompt. The host substitutes {{taskId}} and {{task_id}}. */
+    content: string;
+    /** Lower values are injected first. Defaults to 0. */
+    order?: number;
+}
+export interface ConfigureStartPromptContributionRequest extends StartPromptContribution {
+    projectId: string;
+}
+export interface StartTaskImplementationRequest {
+    taskId: string;
+}
+export interface ImplementationRun {
+    taskId: string;
+    sessionId: string;
+    workspacePath: string;
+}
+export interface TasksAPI {
+    list(request?: {
+        projectId?: string | null;
+    }): Promise<Task[]>;
+    get(taskId: string): Promise<Task>;
+    create(request: CreateTaskRequest): Promise<Task>;
+    updateSummary(taskId: string, summary: string): Promise<void>;
+    updateStatus(taskId: string, status: WritableBoardStatus): Promise<void>;
+    listStartPromptContributions(projectId: string): Promise<StartPromptContribution[]>;
+    configureStartPromptContribution(request: ConfigureStartPromptContributionRequest): Promise<StartPromptContribution[]>;
+    startImplementation(request: StartTaskImplementationRequest): Promise<ImplementationRun>;
+    getWorkspace(taskId: string): Promise<TaskWorkspaceInfo | null>;
+    getLatestSession(taskId: string): Promise<AgentSession | null>;
+}
+export interface ProjectsAPI {
+    list(): Promise<Project[]>;
+    get(projectId: string): Promise<Project | null>;
+}
+export type NotificationRequest = {
+    title: string;
+    body?: string;
+    [key: string]: JsonValue | undefined;
+};
+export interface NotificationsAPI {
+    notify(request: NotificationRequest): Promise<void>;
+}
+export interface AttentionAPI {
+    listProjects(): Promise<ProjectAttention[]>;
+}
+export interface SystemAPI {
+    openUrl(url: string): Promise<void>;
+}
+export interface KeyValueConfigAPI {
+    get<T extends JsonValue = JsonValue>(key: string, projectId?: string): Promise<T | null>;
+    set<T extends JsonValue = JsonValue>(key: string, value: T, projectId?: string): Promise<void>;
+}
+export interface OpenForgeCommonAPI {
+    commands: CommandRegistry;
+    events: EventRegistry;
+    storage: PluginStorage;
+    context: {
+        getSnapshot(): OpenForgeContextSnapshot;
+    };
+    tasks: TasksAPI;
+    projects: ProjectsAPI;
+    fs: FileSystemAPI;
+    shell: ShellAPI;
+    notifications: NotificationsAPI;
+    attention: AttentionAPI;
+    system: SystemAPI;
+    config: KeyValueConfigAPI;
+    projectConfig: KeyValueConfigAPI;
+}
+export interface FrontendOpenForgeAPI extends OpenForgeCommonAPI {
+    navigation: NavigationAPI;
+    views: FrontendViewRegistry;
+    taskPane: FrontendTaskPaneRegistry;
+    settings: FrontendSettingsRegistry;
+    backend: FrontendBackendBridge;
+}
+export interface BackendOpenForgeAPI extends OpenForgeCommonAPI {
+    backend: BackendMethodRegistry;
+    background: BackgroundServiceRegistry;
+}
+export interface FrontendPlugin {
+    activate(openforge: FrontendOpenForgeAPI, context: FrontendPluginContext): MaybePromise<void>;
+}
+export interface BackendPlugin {
+    activate(openforge: BackendOpenForgeAPI, context: BackendPluginContext): MaybePromise<void>;
+}
+export type PluginViewKey = `plugin:${string}:${string}`;
+export declare function makePluginViewKey(pluginId: string, viewId: string): PluginViewKey;
+export declare function isPluginViewKey(value: string): value is PluginViewKey;
+export declare function parsePluginViewKey(key: PluginViewKey): {
+    pluginId: string;
+    viewId: string;
+};

package/dist/types.js

@@ -0,0 +1,22 @@
+import packageMetadataSchemaData from './openforgePackageMetadataSchema.json';
+function readSupportedOpenForgeApiVersions() {
+    const versions = packageMetadataSchemaData.properties.apiVersion.enum;
+    if (!Array.isArray(versions) || versions.length === 0 || !versions.every((version) => typeof version === 'number' && Number.isInteger(version))) {
+        throw new Error('openforgePackageMetadataSchema.json properties.apiVersion.enum must contain at least one integer');
+    }
+    return [...versions];
+}
+export const SUPPORTED_OPENFORGE_API_VERSIONS = Object.freeze(readSupportedOpenForgeApiVersions());
+export const OPENFORGE_PLUGIN_API_VERSION = SUPPORTED_OPENFORGE_API_VERSIONS[0];
+export const MIN_SUPPORTED_API_VERSION = Math.min(...SUPPORTED_OPENFORGE_API_VERSIONS);
+export const MAX_SUPPORTED_API_VERSION = Math.max(...SUPPORTED_OPENFORGE_API_VERSIONS);
+export function makePluginViewKey(pluginId, viewId) {
+    return `plugin:${pluginId}:${viewId}`;
+}
+export function isPluginViewKey(value) {
+    return value.startsWith('plugin:') && value.match(/^plugin:[^:]+:[^:]+$/) !== null;
+}
+export function parsePluginViewKey(key) {
+    const parts = key.split(':');
+    return { pluginId: parts[1], viewId: parts[2] };
+}

package/dist/ui/MarkdownContent.svelte

@@ -0,0 +1,30 @@
+<script lang="ts">
+  import { renderMarkdownHtml } from '../markdown'
+
+  interface Props {
+    content: string
+    imageBaseUrl?: string | null
+    onOpenUrl?: (url: string) => void | Promise<void>
+  }
+
+  let { content, imageBaseUrl = null, onOpenUrl }: Props = $props()
+
+  let html = $derived(renderMarkdownHtml(content, { imageBaseUrl }))
+
+  function handleClick(e: MouseEvent) {
+    if (!(e.target instanceof Element)) return
+
+    const anchor = e.target.closest('a')
+    if (anchor?.href) {
+      e.preventDefault()
+      if (onOpenUrl) {
+        void onOpenUrl(anchor.href)
+      }
+    }
+  }
+</script>
+
+<!-- svelte-ignore a11y_click_events_have_key_events -->
+<div role="presentation" class="markdown-body" onclick={handleClick}>
+  {@html html}
+</div>

package/dist/ui/ResizablePanel.svelte

@@ -0,0 +1,146 @@
+<script lang="ts">
+  import type { Snippet } from 'svelte'
+  import { parseStrictFiniteNumber } from '../numberParsing'
+
+  interface Props {
+    storageKey: string
+    defaultWidth: number
+    minWidth?: number
+    maxWidth?: number
+    side?: 'left' | 'right'
+    children?: Snippet
+  }
+
+  let {
+    storageKey,
+    defaultWidth,
+    minWidth = 120,
+    maxWidth = 600,
+    side = 'left',
+    children,
+  }: Props = $props()
+
+  let panelEl = $state<HTMLElement | null>(null)
+
+  function clamp(value: number): number {
+    return Math.max(minWidth, Math.min(maxWidth, value))
+  }
+
+  function loadWidth(): number {
+    try {
+      const stored = localStorage.getItem(`resizable-panel:${storageKey}`)
+      if (stored !== null) {
+        const parsed = parseStrictFiniteNumber(stored)
+        if (parsed !== null) return clamp(parsed)
+      }
+    } catch { /* localStorage unavailable */ }
+    return defaultWidth
+  }
+
+  function saveWidth(w: number) {
+    try {
+      localStorage.setItem(`resizable-panel:${storageKey}`, String(w))
+    } catch { /* localStorage unavailable */ }
+  }
+
+  function clearWidth() {
+    try {
+      localStorage.removeItem(`resizable-panel:${storageKey}`)
+    } catch { /* localStorage unavailable */ }
+  }
+
+  let width = $state(loadWidth())
+  let isDragging = $state(false)
+
+  function onMouseDown(e: MouseEvent) {
+    e.preventDefault()
+    isDragging = true
+
+    const startX = e.clientX
+    const startWidth = width
+    const rect = panelEl?.getBoundingClientRect()
+    if (!rect) return
+
+    function onMouseMove(e: MouseEvent) {
+      const delta = side === 'left'
+        ? e.clientX - startX
+        : startX - e.clientX
+      width = clamp(startWidth + delta)
+    }
+
+    function onMouseUp() {
+      isDragging = false
+      saveWidth(width)
+      document.removeEventListener('mousemove', onMouseMove)
+      document.removeEventListener('mouseup', onMouseUp)
+    }
+
+    document.addEventListener('mousemove', onMouseMove)
+    document.addEventListener('mouseup', onMouseUp)
+  }
+
+  function onDblClick() {
+    width = defaultWidth
+    clearWidth()
+  }
+
+  function onKeyDown(e: KeyboardEvent) {
+    let delta = 0
+    if (e.key === 'ArrowRight') {
+      delta = side === 'left' ? 10 : -10
+    } else if (e.key === 'ArrowLeft') {
+      delta = side === 'left' ? -10 : 10
+    } else if (e.key === 'Enter' || e.key === ' ') {
+      e.preventDefault()
+      onDblClick()
+      return
+    }
+
+    if (delta !== 0) {
+      e.preventDefault()
+      width = clamp(width + delta)
+      saveWidth(width)
+    }
+  }
+</script>
+
+<div
+  data-testid="resizable-panel"
+  class="relative flex shrink-0 h-full overflow-hidden"
+  style="width: {width}px"
+  bind:this={panelEl}
+>
+  {#if side === 'right'}
+    <!-- svelte-ignore a11y_no_noninteractive_tabindex -->
+    <!-- svelte-ignore a11y_no_noninteractive_element_interactions -->
+    <div
+      data-testid="resize-handle"
+      class="absolute left-0 top-0 bottom-0 z-10 w-1 hover:bg-primary/30 transition-colors {isDragging ? 'bg-primary/40' : ''} focus-visible:bg-primary/40 focus-visible:outline-none"
+      style="cursor: col-resize"
+      role="separator"
+      aria-orientation="vertical"
+      tabindex="0"
+      onmousedown={onMouseDown}
+      ondblclick={onDblClick}
+      onkeydown={onKeyDown}
+    ></div>
+  {/if}
+  <div class="flex-1 overflow-hidden">
+    {@render children?.()}
+  </div>
+  {#if side === 'left'}
+    <!-- svelte-ignore a11y_no_noninteractive_tabindex -->
+    <!-- svelte-ignore a11y_no_noninteractive_element_interactions -->
+    <div
+      data-testid="resize-handle"
+      class="absolute right-0 top-0 bottom-0 z-10 w-1 hover:bg-primary/30 transition-colors {isDragging ? 'bg-primary/40' : ''} focus-visible:bg-primary/40 focus-visible:outline-none"
+      style="cursor: col-resize"
+      role="separator"
+      aria-orientation="vertical"
+      tabindex="0"
+      onmousedown={onMouseDown}
+      ondblclick={onDblClick}
+      onkeydown={onKeyDown}
+    ></div>
+  {/if}
+</div>

package/dist/vite.d.ts

@@ -0,0 +1,15 @@
+export declare const OPENFORGE_HOST_RUNTIME_SVELTE_SPECIFIERS: readonly string[];
+export declare const OPENFORGE_HOST_SHARED_SVELTE_IMPORTS: readonly string[];
+export declare const OPENFORGE_HOST_SHARED_TERMINAL_RUNTIME_IMPORTS: readonly string[];
+export type OpenForgeHostRuntimeSvelteSpecifier = typeof OPENFORGE_HOST_RUNTIME_SVELTE_SPECIFIERS[number];
+export type OpenForgeHostSharedSvelteImport = OpenForgeHostRuntimeSvelteSpecifier;
+export type OpenForgeHostSharedTerminalRuntimeImport = typeof OPENFORGE_HOST_SHARED_TERMINAL_RUNTIME_IMPORTS[number];
+export declare function isOpenForgeHostRuntimeExternal(id: string): boolean;
+export declare const openforgePluginViteExternals: typeof isOpenForgeHostRuntimeExternal;
+export type OpenForgePluginSdkSourceAlias = Readonly<{
+    find: string;
+    replacement: string;
+}>;
+export type OpenForgePluginSdkSourceAliasRecord = Readonly<Record<string, string>>;
+export declare function createOpenForgePluginSdkSourceAliases(repoRoot: URL | string): OpenForgePluginSdkSourceAlias[];
+export declare function createOpenForgePluginSdkSourceAliasRecord(repoRoot: URL | string): OpenForgePluginSdkSourceAliasRecord;

package/dist/vite.js

@@ -0,0 +1,78 @@
+/**
+ * Svelte browser/runtime entrypoints that OpenForge frontend plugin bundles must
+ * share with the host renderer. The Electron renderer import map and packaged
+ * plugin://host-runtime assets are derived from the same host-runtime contract.
+ */
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { OPENFORGE_HOST_RUNTIME_SVELTE_SPECIFIERS as HOST_RUNTIME_SVELTE_SPECIFIERS } from './svelteHostRuntimeContract.mjs';
+export const OPENFORGE_HOST_RUNTIME_SVELTE_SPECIFIERS = HOST_RUNTIME_SVELTE_SPECIFIERS;
+export const OPENFORGE_HOST_SHARED_SVELTE_IMPORTS = OPENFORGE_HOST_RUNTIME_SVELTE_SPECIFIERS;
+export const OPENFORGE_HOST_SHARED_TERMINAL_RUNTIME_IMPORTS = Object.freeze([
+    '@openforge-app/terminal-runtime',
+    '@openforge-app/terminal-runtime/terminalRuntime',
+    '@openforge-app/terminal-runtime/terminalOptions',
+    '@openforge-app/terminal-runtime/theme',
+    '@openforge-app/terminal-runtime/shortcuts',
+    '@openforge-app/terminal-runtime/shortcutController',
+    '@openforge-app/terminal-runtime/TerminalTabsShell',
+]);
+const OPENFORGE_HOST_RUNTIME_MODULES = new Set([
+    ...OPENFORGE_HOST_RUNTIME_SVELTE_SPECIFIERS,
+    ...OPENFORGE_HOST_SHARED_TERMINAL_RUNTIME_IMPORTS,
+]);
+export function isOpenForgeHostRuntimeExternal(id) {
+    return OPENFORGE_HOST_RUNTIME_MODULES.has(id);
+}
+export const openforgePluginViteExternals = isOpenForgeHostRuntimeExternal;
+const OPENFORGE_PLUGIN_SDK_SOURCE_ENTRYPOINTS = Object.freeze([
+    ['@openforge-app/plugin-sdk/frontend', 'packages/plugin-sdk/src/frontend.ts'],
+    ['@openforge-app/plugin-sdk/backend', 'packages/plugin-sdk/src/backend.ts'],
+    ['@openforge-app/plugin-sdk/testing', 'packages/plugin-sdk/src/testing.ts'],
+    ['@openforge-app/plugin-sdk/vite', 'packages/plugin-sdk/src/vite.ts'],
+    ['@openforge-app/plugin-sdk/domain', 'packages/plugin-sdk/src/domain.ts'],
+    ['@openforge-app/plugin-sdk/prStatusPresentation', 'packages/plugin-sdk/src/prStatusPresentation.ts'],
+    ['@openforge-app/plugin-sdk/markdown', 'packages/plugin-sdk/src/markdown.ts'],
+    ['@openforge-app/plugin-sdk/numberParsing', 'packages/plugin-sdk/src/numberParsing.ts'],
+    ['@openforge-app/plugin-sdk/projectFileTree', 'packages/plugin-sdk/src/projectFileTree.ts'],
+    ['@openforge-app/plugin-sdk/sanitize', 'packages/plugin-sdk/src/sanitize.ts'],
+    ['@openforge-app/plugin-sdk/ui/MarkdownContent.svelte', 'packages/plugin-sdk/src/ui/MarkdownContent.svelte'],
+    ['@openforge-app/plugin-sdk/ui/ResizablePanel.svelte', 'packages/plugin-sdk/src/ui/ResizablePanel.svelte'],
+    ['@openforge-app/plugin-sdk', 'packages/plugin-sdk/src/index.ts'],
+]);
+function repoRootUrl(repoRoot) {
+    if (repoRoot instanceof URL) {
+        return new URL(repoRoot.href.endsWith('/') ? repoRoot.href : `${repoRoot.href}/`);
+    }
+    if (isUrlString(repoRoot)) {
+        return new URL(repoRoot.endsWith('/') ? repoRoot : `${repoRoot}/`);
+    }
+    return pathToFileURL(hasTrailingPathSeparator(repoRoot) ? repoRoot : `${repoRoot}/`);
+}
+function isUrlString(value) {
+    return /^[a-z][a-z\d+.-]*:\/\//i.test(value) || /^file:/i.test(value);
+}
+function hasTrailingPathSeparator(value) {
+    return value.endsWith('/') || value.endsWith('\\');
+}
+function sourceAliasReplacement(sourceUrl) {
+    if (sourceUrl.protocol === 'file:') {
+        return fileURLToPath(sourceUrl);
+    }
+    return sourceUrl.pathname;
+}
+function createOpenForgePluginSdkSourceAliasEntries(repoRoot) {
+    const rootUrl = repoRootUrl(repoRoot);
+    return OPENFORGE_PLUGIN_SDK_SOURCE_ENTRYPOINTS.map(([find, sourcePath]) => [
+        find,
+        sourceAliasReplacement(new URL(sourcePath, rootUrl)),
+    ]);
+}
+export function createOpenForgePluginSdkSourceAliases(repoRoot) {
+    return createOpenForgePluginSdkSourceAliasEntries(repoRoot).map(([find, replacement]) => ({
+        find,
+        replacement,
+    }));
+}
+export function createOpenForgePluginSdkSourceAliasRecord(repoRoot) {
+    return Object.fromEntries(createOpenForgePluginSdkSourceAliasEntries(repoRoot));
+}