@openforge-app/plugin-sdk 0.1.0 → 0.2.3

package/dist/fileIcons.js

@@ -0,0 +1,84 @@
+export const DEFAULT_FILE_ICON = 'file';
+export const DEFAULT_FOLDER_ICON = 'folder';
+export const DEFAULT_FOLDER_OPEN_ICON = 'folder-open';
+// Lowercased extension (no leading dot) -> Material icon base name.
+// Only names that exist in vscode-material-icons/generated/icons are used.
+const EXTENSION_ICONS = {
+    ts: 'typescript', mts: 'typescript', cts: 'typescript',
+    tsx: 'react_ts',
+    js: 'javascript', mjs: 'javascript', cjs: 'javascript',
+    jsx: 'react',
+    json: 'json', jsonc: 'json',
+    yaml: 'yaml', yml: 'yaml',
+    md: 'markdown', markdown: 'markdown', mdx: 'markdown',
+    css: 'css', less: 'css',
+    scss: 'sass', sass: 'sass',
+    html: 'html', htm: 'html',
+    svelte: 'svelte',
+    vue: 'vue',
+    rs: 'rust',
+    py: 'python',
+    rb: 'ruby',
+    go: 'go',
+    java: 'java',
+    kt: 'kotlin', kts: 'kotlin',
+    swift: 'swift',
+    c: 'c',
+    h: 'h', hpp: 'h', hh: 'h',
+    cc: 'cpp', cpp: 'cpp', cxx: 'cpp',
+    cs: 'csharp',
+    php: 'php',
+    sh: 'console', bash: 'console', zsh: 'console', fish: 'console',
+    sql: 'database',
+    graphql: 'graphql', gql: 'graphql',
+    xml: 'xml',
+    svg: 'svg',
+    png: 'image', jpg: 'image', jpeg: 'image', gif: 'image',
+    webp: 'image', bmp: 'image', ico: 'image', avif: 'image',
+    pdf: 'pdf',
+    zip: 'zip', tar: 'zip', gz: 'zip', tgz: 'zip', rar: 'zip', '7z': 'zip',
+    lock: 'lock',
+    toml: 'settings',
+    txt: 'document', log: 'document',
+    env: 'tune',
+};
+// Exact lowercased filename -> Material icon base name (takes precedence over extension).
+const FILENAME_ICONS = {
+    'package.json': 'nodejs',
+    'package-lock.json': 'lock',
+    'pnpm-lock.yaml': 'lock',
+    'yarn.lock': 'lock',
+    dockerfile: 'docker',
+    '.dockerignore': 'docker',
+    '.gitignore': 'git',
+    '.gitattributes': 'git',
+    '.gitmodules': 'git',
+    '.npmrc': 'npm',
+    '.npmignore': 'npm',
+};
+export function getFileIconName(filename) {
+    const base = (filename.split('/').pop() ?? filename).toLowerCase();
+    if (base in FILENAME_ICONS)
+        return FILENAME_ICONS[base];
+    if (base.endsWith('.d.ts'))
+        return 'typescript-def';
+    if (base === 'readme' || /^readme\.[^.]+$/.test(base))
+        return 'readme';
+    if (base === '.env' || base.startsWith('.env.'))
+        return 'tune';
+    const ext = base.includes('.') ? (base.split('.').pop() ?? '') : '';
+    return EXTENSION_ICONS[ext] ?? DEFAULT_FILE_ICON;
+}
+export function getFolderIconName(open) {
+    return open ? DEFAULT_FOLDER_OPEN_ICON : DEFAULT_FOLDER_ICON;
+}
+export const BUNDLED_ICON_NAMES = Object.freeze(Array.from(new Set([
+    DEFAULT_FILE_ICON,
+    DEFAULT_FOLDER_ICON,
+    DEFAULT_FOLDER_OPEN_ICON,
+    'typescript-def',
+    'readme',
+    'tune',
+    ...Object.values(EXTENSION_ICONS),
+    ...Object.values(FILENAME_ICONS),
+])).sort());

package/dist/frontend.d.ts

@@ -1,7 +1,10 @@
-import type { CommandDescriptor, CommandRegistry, CommandRegistration, CommandShortcutMetadata, Disposable, FrontendBackendBridge, FrontendOpenForgeAPI, FrontendPlugin, FrontendPluginContext, FrontendSettingsRegistry, FrontendTaskPaneRegistry, FrontendViewRegistry, NavigationAPI, OpenForgeContextSnapshot, OpenForgeNavigationRequest, OpenForgeNavigationSnapshot, PluginSettingsSectionProps, PluginSettingsSectionRegistration, PluginStorageScope, PluginTaskPaneProps, PluginTaskPaneTabRegistration, PluginViewProps, PluginViewRegistration } from './types';
+import type { BrowserSurfaceCapture, BrowserSurfaceFeedbackSelection, BrowserSurfaceVisualFeedback, BrowserSurfaceRegion, BrowserSurfaceErrorCode, BrowserSurfaceNavigationError, BrowserSurfacesAPI, GetOrCreateBrowserSurfaceRequest, TaskBrowserSurfaceController, TaskBrowserSurfaceState } from './browserSurfaces';
+import type { CommandDescriptor, CommandRegistry, CommandRegistration, CommandShortcutMetadata, ComposeTaskRequest, ComposeTaskResult, Disposable, FrontendBackendBridge, FrontendOpenForgeAPI, FrontendPlugin, FrontendPluginContext, FrontendSettingsRegistry, FrontendTaskPaneRegistry, FrontendInjectionPointRegistry, FrontendTaskStartRegistry, FrontendTaskUIRegistry, FrontendViewRegistry, InjectionPointLocation, NavigationAPI, OpenForgeContextSnapshot, OpenForgeNavigationRequest, OpenForgeNavigationSnapshot, TaskLinkHandler, TaskLinkHandlerResult, TaskLinkOpenRequest, TaskLinksAPI, PluginIcon, PluginInjectionPointProps, PluginInjectionPointRegistration, PluginSettingsSectionProps, PluginSettingsSectionRegistration, PluginSettingsSectionScope, PluginStorageScope, PluginSvgIcon, PluginTaskPaneProps, PluginTaskPaneTabRegistration, PluginTaskUISectionProps, PluginTaskUISectionRegistration, PluginViewProps, PluginViewRegistration, TaskStartPrefixContext, TaskStartPrefixProviderRegistration, TerminalImageProtocol } from './types';
 export declare const OPENFORGE_FRONTEND_PLUGIN_MARKER = "__openforgeFrontendPlugin";
 export type MarkedFrontendPlugin<TPlugin extends FrontendPlugin = FrontendPlugin> = TPlugin & {
     readonly [OPENFORGE_FRONTEND_PLUGIN_MARKER]: true;
 };
 export declare function defineFrontendPlugin<const TPlugin extends FrontendPlugin>(plugin: TPlugin): MarkedFrontendPlugin<TPlugin>;
-export type { CommandDescriptor, CommandRegistry, CommandRegistration, CommandShortcutMetadata, Disposable, FrontendBackendBridge, FrontendOpenForgeAPI, FrontendPlugin, FrontendPluginContext, FrontendSettingsRegistry, FrontendTaskPaneRegistry, FrontendViewRegistry, NavigationAPI, OpenForgeContextSnapshot, OpenForgeNavigationRequest, OpenForgeNavigationSnapshot, PluginSettingsSectionProps, PluginSettingsSectionRegistration, PluginStorageScope, PluginTaskPaneProps, PluginTaskPaneTabRegistration, PluginViewProps, PluginViewRegistration, };
+export { BrowserSurfaceError, isAllowedBrowserSurfaceUrl } from './browserSurfaces';
+export type { BrowserSurfaceCapture, BrowserSurfaceFeedbackSelection, BrowserSurfaceVisualFeedback, BrowserSurfaceRegion, BrowserSurfaceErrorCode, BrowserSurfaceNavigationError, BrowserSurfacesAPI, GetOrCreateBrowserSurfaceRequest, TaskBrowserSurfaceController, TaskBrowserSurfaceState, };
+export type { CommandDescriptor, CommandRegistry, CommandRegistration, CommandShortcutMetadata, ComposeTaskRequest, ComposeTaskResult, Disposable, FrontendBackendBridge, FrontendOpenForgeAPI, FrontendPlugin, FrontendPluginContext, FrontendSettingsRegistry, FrontendTaskPaneRegistry, FrontendInjectionPointRegistry, FrontendTaskStartRegistry, FrontendTaskUIRegistry, FrontendViewRegistry, InjectionPointLocation, NavigationAPI, OpenForgeContextSnapshot, OpenForgeNavigationRequest, OpenForgeNavigationSnapshot, TaskLinkHandler, TaskLinkHandlerResult, TaskLinkOpenRequest, TaskLinksAPI, PluginIcon, PluginInjectionPointProps, PluginInjectionPointRegistration, PluginSettingsSectionProps, PluginSettingsSectionRegistration, PluginSettingsSectionScope, PluginStorageScope, PluginSvgIcon, PluginTaskPaneProps, PluginTaskPaneTabRegistration, PluginTaskUISectionProps, PluginTaskUISectionRegistration, PluginViewProps, PluginViewRegistration, TaskStartPrefixContext, TaskStartPrefixProviderRegistration, TerminalImageProtocol, };

package/dist/frontend.js

@@ -7,3 +7,4 @@ export function defineFrontendPlugin(plugin) {
     });
     return plugin;
 }
+export { BrowserSurfaceError, isAllowedBrowserSurfaceUrl } from './browserSurfaces';

package/dist/index.d.ts

@@ -1,8 +1,10 @@
+export { BrowserSurfaceError, isAllowedBrowserSurfaceUrl } from './browserSurfaces';
+export type { BrowserSurfaceCapture, BrowserSurfaceFeedbackSelection, BrowserSurfaceVisualFeedback, BrowserSurfaceRegion, BrowserSurfaceErrorCode, BrowserSurfaceNavigationError, BrowserSurfacesAPI, GetOrCreateBrowserSurfaceRequest, TaskBrowserSurfaceController, TaskBrowserSurfaceState, } from './browserSurfaces';
 export { OPENFORGE_PACKAGE_METADATA_SCHEMA, OPENFORGE_PLUGIN_CAPABILITIES, isOpenForgePackageMetadata, isPluginPackageMetadata, isSupportedOpenForgeApiVersion, validateOpenForgePackageMetadata, validatePluginPackageMetadata, } from './manifest';
 export { createMemoryPluginStorage, createMockBackendOpenForgeApi, createMockFrontendOpenForgeApi, createMockOpenForgeApi, createMockPluginContext, createOpenForgeRegistryFake, createTestingCalls, TestingOpenForgeRegistryFake, TestingSubscriptionSink, } from './testing';
-export { MAX_SUPPORTED_API_VERSION, MIN_SUPPORTED_API_VERSION, OPENFORGE_PLUGIN_API_VERSION, SUPPORTED_OPENFORGE_API_VERSIONS, isPluginViewKey, makePluginViewKey, parsePluginViewKey, } from './types';
-export type { AttentionAPI, BackendReadyState, CommandDescriptor, CommandRegistry, CommandRegistration, CommandShortcutMetadata, ConfigureStartPromptContributionRequest, CreateTaskRequest, Disposable, FileSystemAPI, ImplementationRun, JsonObject, JsonPrimitive, JsonSchema, JsonValue, MaybePromise, KeyValueConfigAPI, NotificationRequest, NavigationAPI, NotificationsAPI, OpenForgeCommonAPI, OpenForgeContextSnapshot, OpenForgeNavigationRequest, OpenForgeNavigationSnapshot, OpenForgePackageMetadata, OpenForgePluginCapability, OpenForgePluginContext, OpenForgePluginPackageJson, PluginComponentLoader, PluginComponentModule, PluginEntry, PluginSettingsSectionProps, PluginState, PluginTaskPaneProps, PluginViewProps, PluginStorage, PluginStorageScope, PluginViewKey, ProjectsAPI, ShellAPI, ShellResizeRequest, ShellSessionRequest, ShellSpawnRequest, ShellWriteRequest, StartPromptContribution, StartTaskImplementationRequest, SubscriptionSink, SupportedOpenForgeApiVersion, SystemAPI, TasksAPI, ValidationError, } from './types';
-export type { MockBackendOpenForgeAPI, MockFrontendOpenForgeAPI, TestingBackgroundServiceContribution, TestingBackendMethodContribution, TestingCommandContribution, TestingContributionBase, TestingEventListenerContribution, TestingOpenForgeApiCalls, TestingOpenForgeApiOptions, TestingOpenForgeRegistrySnapshot, TestingRuntimeKind, TestingRuntimeScope, TestingSettingsSectionContribution, TestingTaskPaneTabContribution, TestingViewContribution, } from './testing';
+export { TaskFollowUpError, MAX_SUPPORTED_API_VERSION, MIN_SUPPORTED_API_VERSION, OPENFORGE_PLUGIN_API_VERSION, SUPPORTED_OPENFORGE_API_VERSIONS, isPluginViewKey, makePluginViewKey, parsePluginViewKey, } from './types';
+export type { AgentCommandDescriptor, AgentCommandMetadata, AgentCommandRuntime, AttentionAPI, BackendReadyState, CommandDescriptor, CommandRegistry, CommandRegistration, CommandShortcutMetadata, ComposeTaskRequest, ComposeTaskResult, ConfigureStartPromptContributionRequest, CreateTaskRequest, Disposable, FileSystemAPI, ImplementationRun, InjectionPointLocation, JsonObject, JsonPrimitive, JsonSchema, JsonValue, MaybePromise, KeyValueConfigAPI, NotificationRequest, NavigationAPI, NotificationsAPI, OpenForgeCommonAPI, OpenForgeContextSnapshot, OpenForgeNavigationRequest, OpenForgeNavigationSnapshot, OpenForgePackageMetadata, OpenForgePluginCapability, OpenForgePluginContext, OpenForgePluginPackageJson, PluginCommandInvocationContext, PluginCommandInvocationSource, PluginComponentLoader, PluginComponentModule, PluginEntry, PluginIcon, PluginInjectionPointProps, PluginSettingsSectionProps, PluginState, PluginSvgIcon, PluginTaskPaneProps, PluginTaskUISectionProps, PluginViewProps, PluginStorage, PluginStorageScope, PluginViewKey, ProjectsAPI, ShellAPI, ShellResizeRequest, TaskStartPrefixContext, TaskStartPrefixProviderRegistration, TerminalImageProtocol, ShellSessionRequest, ShellSpawnRequest, ShellWriteRequest, StartPromptContribution, SendTaskFollowUpRequest, StartTaskImplementationRequest, TaskFollowUpDisposition, TaskFollowUpErrorCode, TaskFollowUpReceipt, SubscriptionSink, SupportedOpenForgeApiVersion, SystemAPI, TaskLinkHandler, TaskLinkHandlerResult, TaskLinkOpenRequest, TaskLinksAPI, TasksAPI, ValidationError, } from './types';
+export type { MockBackendOpenForgeAPI, MockFrontendOpenForgeAPI, TestingBackgroundServiceContribution, TestingBackendMethodContribution, TestingCommandContribution, TestingContributionBase, TestingEventListenerContribution, TestingOpenForgeApiCalls, TestingOpenForgeApiOptions, TestingOpenForgeRegistrySnapshot, TestingRuntimeKind, TestingRuntimeScope, TestingSettingsSectionContribution, TestingTaskPaneTabContribution, TestingTaskUISectionContribution, TestingViewContribution, } from './testing';
 export { parseStrictFiniteNumber } from './numberParsing';
 export { buildProjectFileTree, flattenVisibleProjectFileTree, formatProjectFileTreeSize, getProjectFileTreeDepth, getProjectFileTreeItemAccessibility, getProjectFileTreeKeyboardAction, getProjectFileTreeParentPath, hasProjectFileTreeShortcutModifier, projectFileTreePathToId, } from './projectFileTree';
 export type { ProjectFileTreeEntry, ProjectFileTreeItemAccessibility, ProjectFileTreeKeyboardAction, ProjectFileTreeNode, } from './projectFileTree';

package/dist/index.js

@@ -1,6 +1,7 @@
+export { BrowserSurfaceError, isAllowedBrowserSurfaceUrl } from './browserSurfaces';
 export { OPENFORGE_PACKAGE_METADATA_SCHEMA, OPENFORGE_PLUGIN_CAPABILITIES, isOpenForgePackageMetadata, isPluginPackageMetadata, isSupportedOpenForgeApiVersion, validateOpenForgePackageMetadata, validatePluginPackageMetadata, } from './manifest';
 export { createMemoryPluginStorage, createMockBackendOpenForgeApi, createMockFrontendOpenForgeApi, createMockOpenForgeApi, createMockPluginContext, createOpenForgeRegistryFake, createTestingCalls, TestingOpenForgeRegistryFake, TestingSubscriptionSink, } from './testing';
-export { MAX_SUPPORTED_API_VERSION, MIN_SUPPORTED_API_VERSION, OPENFORGE_PLUGIN_API_VERSION, SUPPORTED_OPENFORGE_API_VERSIONS, isPluginViewKey, makePluginViewKey, parsePluginViewKey, } from './types';
+export { TaskFollowUpError, MAX_SUPPORTED_API_VERSION, MIN_SUPPORTED_API_VERSION, OPENFORGE_PLUGIN_API_VERSION, SUPPORTED_OPENFORGE_API_VERSIONS, isPluginViewKey, makePluginViewKey, parsePluginViewKey, } from './types';
 export { parseStrictFiniteNumber } from './numberParsing';
 export { buildProjectFileTree, flattenVisibleProjectFileTree, formatProjectFileTreeSize, getProjectFileTreeDepth, getProjectFileTreeItemAccessibility, getProjectFileTreeKeyboardAction, getProjectFileTreeParentPath, hasProjectFileTreeShortcutModifier, projectFileTreePathToId, } from './projectFileTree';
 export { canMergePullRequest, getMergeReadiness, hasMergeConflicts, isClosedUnmergedPullRequest, isMergedPullRequest, isQueuedForMerge, isReadyToMerge, parseCheckRuns, preservePullRequestState, splitCheckRuns, } from './domain';

package/dist/manifest.d.ts

@@ -8,6 +8,24 @@ export declare const OPENFORGE_PACKAGE_METADATA_SCHEMA: {
     type: string;
     additionalProperties: boolean;
     required: string[];
+    dependentRequired: {
+        frontendStyles: string[];
+    };
+    allOf: {
+        if: {
+            properties: {
+                requires: {
+                    contains: {
+                        const: string;
+                    };
+                };
+            };
+            required: string[];
+        };
+        then: {
+            required: string[];
+        };
+    }[];
     properties: {
         id: {
             type: string;
@@ -36,6 +54,17 @@ export declare const OPENFORGE_PACKAGE_METADATA_SCHEMA: {
             minLength: number;
             description: string;
         };
+        frontendStyles: {
+            type: string;
+            minItems: number;
+            uniqueItems: boolean;
+            items: {
+                type: string;
+                minLength: number;
+                pattern: string;
+            };
+            description: string;
+        };
         backend: {
             type: string;
             minLength: number;

package/dist/manifest.js

@@ -27,6 +27,33 @@ function validateOptionalString(value, path) {
     }
     return [];
 }
+function validateFrontendStyles(value) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value)) {
+        return [{ path: 'frontendStyles', message: 'Must be an array' }];
+    }
+    const errors = [];
+    if (value.length === 0) {
+        errors.push({ path: 'frontendStyles', message: 'Must contain at least one stylesheet path' });
+    }
+    const seen = new Set();
+    value.forEach((item, index) => {
+        if (!isNonEmptyString(item)) {
+            errors.push({ path: `frontendStyles[${index}]`, message: 'Must be a non-empty string' });
+        }
+        else if (!item.endsWith('.css')) {
+            errors.push({ path: `frontendStyles[${index}]`, message: 'Must point to a built CSS artifact' });
+        }
+        else if (seen.has(item)) {
+            errors.push({ path: `frontendStyles[${index}]`, message: 'Duplicate stylesheet path' });
+        }
+        else {
+            seen.add(item);
+        }
+    });
+    return errors;
+}
 export function isSupportedOpenForgeApiVersion(apiVersion) {
     return typeof apiVersion === 'number'
         && Number.isInteger(apiVersion)
@@ -72,8 +99,18 @@ export function validateOpenForgePackageMetadata(data) {
     errors.push(...validateRequiredString(data.description, 'description'));
     errors.push(...validateOptionalString(data.icon, 'icon'));
     errors.push(...validateOptionalString(data.frontend, 'frontend'));
+    errors.push(...validateFrontendStyles(data.frontendStyles));
+    if (data.frontendStyles !== undefined && !isNonEmptyString(data.frontend)) {
+        errors.push({ path: 'frontendStyles', message: 'Requires a frontend entry' });
+    }
     errors.push(...validateOptionalString(data.backend, 'backend'));
     errors.push(...validateRequires(data.requires));
+    if (Array.isArray(data.requires) && data.requires.includes('browserSurfaces') && !isNonEmptyString(data.frontend)) {
+        errors.push({ path: 'requires', message: 'browserSurfaces capability requires a frontend entry' });
+    }
+    if (Array.isArray(data.requires) && data.requires.includes('taskLinks') && !isNonEmptyString(data.frontend)) {
+        errors.push({ path: 'requires', message: 'taskLinks capability requires a frontend entry' });
+    }
     if (data.contributes !== undefined) {
         errors.push({ path: 'contributes', message: 'Manifest contribution arrays are not supported; register contributions at runtime' });
     }

package/dist/markdown.d.ts

@@ -1,5 +1,9 @@
 export interface RenderMarkdownOptions {
     imageBaseUrl?: string | null;
+    markdownFilePath?: string | null;
+    deferRepositoryImages?: boolean;
 }
-export declare function resolveMarkdownImageSrc(src: string | null, imageBaseUrl: string | null | undefined): string | null;
+export declare function resolveMarkdownRepositoryPath(value: string | null, markdownFilePath: string): string | null;
+export declare function getMarkdownRepositoryLinkSuffix(value: string): string;
+export declare function resolveMarkdownImageSrc(src: string | null, imageBaseUrl: string | null | undefined, markdownFilePath?: string): string | null;
 export declare function renderMarkdownHtml(content: string, options?: RenderMarkdownOptions): string;

package/dist/markdown.js

@@ -1,7 +1,5 @@
 import { marked } from 'marked';
 import { sanitizeHtml } from './sanitize';
-const RELATIVE_PARENT_SEGMENT = /^\.\.\//;
-const RELATIVE_CURRENT_SEGMENT = /^\.\//;
 const markedOptions = {
     gfm: true,
     breaks: true,
@@ -9,39 +7,90 @@ const markedOptions = {
 function hasAbsoluteOrSpecialUrl(value) {
     return /^[a-z][a-z\d+.-]*:/i.test(value) || value.startsWith('//') || value.startsWith('#');
 }
-function normalizeRepoRelativeImagePath(value) {
-    let normalized = value.startsWith('/') ? value.slice(1) : value;
-    while (RELATIVE_CURRENT_SEGMENT.test(normalized)) {
-        normalized = normalized.replace(RELATIVE_CURRENT_SEGMENT, '');
+function decodeMarkdownPath(value) {
+    try {
+        return decodeURI(value);
     }
-    while (RELATIVE_PARENT_SEGMENT.test(normalized)) {
-        normalized = normalized.replace(RELATIVE_PARENT_SEGMENT, '');
+    catch {
+        return value;
     }
-    return normalized;
+}
+function splitMarkdownRepositoryReference(value) {
+    const suffixIndex = value.search(/[?#]/);
+    return suffixIndex < 0
+        ? { pathValue: value, suffix: '' }
+        : { pathValue: value.slice(0, suffixIndex), suffix: value.slice(suffixIndex) };
+}
+export function resolveMarkdownRepositoryPath(value, markdownFilePath) {
+    if (!value)
+        return null;
+    const trimmedValue = value.trim();
+    if (!trimmedValue || hasAbsoluteOrSpecialUrl(trimmedValue))
+        return null;
+    const { pathValue } = splitMarkdownRepositoryReference(trimmedValue);
+    if (!pathValue)
+        return null;
+    const repositoryPath = decodeMarkdownPath(pathValue);
+    if (repositoryPath.includes('\\'))
+        return null;
+    const markdownDirectory = markdownFilePath.split('/').slice(0, -1).join('/');
+    const candidate = repositoryPath.startsWith('/')
+        ? repositoryPath.slice(1)
+        : [markdownDirectory, repositoryPath].filter(Boolean).join('/');
+    const parts = [];
+    for (const segment of candidate.split('/')) {
+        if (!segment || segment === '.')
+            continue;
+        if (segment === '..') {
+            if (parts.length === 0)
+                return null;
+            parts.pop();
+        }
+        else {
+            parts.push(segment);
+        }
+    }
+    return parts.length > 0 ? parts.join('/') : null;
+}
+export function getMarkdownRepositoryLinkSuffix(value) {
+    return splitMarkdownRepositoryReference(value.trim()).suffix;
 }
 function withTrailingSlash(value) {
     return value.endsWith('/') ? value : `${value}/`;
 }
-export function resolveMarkdownImageSrc(src, imageBaseUrl) {
-    if (!src || !imageBaseUrl)
+export function resolveMarkdownImageSrc(src, imageBaseUrl, markdownFilePath = '') {
+    if (!imageBaseUrl)
         return null;
-    const trimmedSrc = src.trim();
-    if (!trimmedSrc || hasAbsoluteOrSpecialUrl(trimmedSrc))
+    const repositoryPath = resolveMarkdownRepositoryPath(src, markdownFilePath);
+    if (!repositoryPath)
         return null;
     try {
-        return new URL(normalizeRepoRelativeImagePath(trimmedSrc), withTrailingSlash(imageBaseUrl)).href;
+        return new URL(repositoryPath, withTrailingSlash(imageBaseUrl)).href;
     }
     catch {
         return null;
     }
 }
-function resolveMarkdownImageSources(html, imageBaseUrl) {
-    if (!imageBaseUrl || typeof document === 'undefined')
+function prepareMarkdownImageSources(html, options) {
+    if (typeof document === 'undefined' || (!options.imageBaseUrl && !options.deferRepositoryImages))
         return html;
     const template = document.createElement('template');
     template.innerHTML = html;
     for (const image of template.content.querySelectorAll('img[src]')) {
-        const resolvedSrc = resolveMarkdownImageSrc(image.getAttribute('src'), imageBaseUrl);
+        const source = image.getAttribute('src')?.trim() ?? '';
+        const shouldDefer = options.deferRepositoryImages && source.length > 0 && !hasAbsoluteOrSpecialUrl(source);
+        if (shouldDefer) {
+            image.removeAttribute('src');
+            const repositoryPath = resolveMarkdownRepositoryPath(source, options.markdownFilePath ?? '');
+            if (repositoryPath) {
+                image.setAttribute('data-markdown-repository-path', repositoryPath);
+            }
+            continue;
+        }
+        const repositoryPath = resolveMarkdownRepositoryPath(source, options.markdownFilePath ?? '');
+        if (!repositoryPath)
+            continue;
+        const resolvedSrc = resolveMarkdownImageSrc(repositoryPath, options.imageBaseUrl);
         if (resolvedSrc) {
             image.setAttribute('src', resolvedSrc);
         }
@@ -50,5 +99,5 @@ function resolveMarkdownImageSources(html, imageBaseUrl) {
 }
 export function renderMarkdownHtml(content, options = {}) {
     const rawHtml = marked.parse(content, markedOptions);
-    return sanitizeHtml(resolveMarkdownImageSources(rawHtml, options.imageBaseUrl));
+    return sanitizeHtml(prepareMarkdownImageSources(rawHtml, options));
 }

package/dist/openforgePackageMetadataSchema.json

@@ -6,6 +6,29 @@
     "type": "object",
     "additionalProperties": false,
     "required": ["id", "apiVersion", "displayName", "description"],
+    "dependentRequired": {
+        "frontendStyles": ["frontend"]
+    },
+    "allOf": [
+        {
+            "if": {
+                "properties": {
+                    "requires": { "contains": { "const": "browserSurfaces" } }
+                },
+                "required": ["requires"]
+            },
+            "then": { "required": ["frontend"] }
+        },
+        {
+            "if": {
+                "properties": {
+                    "requires": { "contains": { "const": "taskLinks" } }
+                },
+                "required": ["requires"]
+            },
+            "then": { "required": ["frontend"] }
+        }
+    ],
     "properties": {
         "id": {
             "type": "string",
@@ -34,6 +57,17 @@
             "minLength": 1,
             "description": "Path to the built frontend JavaScript entry artifact."
         },
+        "frontendStyles": {
+            "type": "array",
+            "minItems": 1,
+            "uniqueItems": true,
+            "items": {
+                "type": "string",
+                "minLength": 1,
+                "pattern": "\\.css$"
+            },
+            "description": "Paths to built frontend CSS artifacts. The renderer attaches them before importing the frontend entry and removes them when the plugin deactivates."
+        },
         "backend": {
             "type": "string",
             "minLength": 1,
@@ -47,7 +81,9 @@
                     "commands",
                     "events",
                     "views",
+                    "injectionPoints",
                     "taskPane",
+                    "taskStart",
                     "settings",
                     "background",
                     "backend",
@@ -61,8 +97,11 @@
                     "notifications",
                     "attention",
                     "system.openUrl",
+                    "system.writeClipboardText",
                     "config",
-                    "projectConfig"
+                    "projectConfig",
+                    "browserSurfaces",
+                    "taskLinks"
                 ]
             }
         }

package/dist/pluginIcons.d.ts

@@ -0,0 +1,7 @@
+import type { PluginIcon } from './types';
+export declare const MAX_PLUGIN_SVG_ICON_CHARACTERS = 10000;
+/**
+ * Validates and sanitizes a plugin icon before it crosses a host contribution boundary.
+ * Named icons are preserved so unsupported names can retain the host's existing fallback.
+ */
+export declare function sanitizePluginIcon(icon: unknown): PluginIcon;

package/dist/pluginIcons.js

@@ -0,0 +1,104 @@
+import DOMPurify from 'dompurify';
+export const MAX_PLUGIN_SVG_ICON_CHARACTERS = 10_000;
+const ALLOWED_SVG_TAGS = ['svg', 'g', 'path', 'rect', 'circle', 'ellipse', 'line', 'polyline', 'polygon'];
+const ALLOWED_SVG_ATTRIBUTES = [
+    'viewBox',
+    'd',
+    'fill',
+    'fill-rule',
+    'fill-opacity',
+    'stroke',
+    'stroke-width',
+    'stroke-linecap',
+    'stroke-linejoin',
+    'stroke-miterlimit',
+    'stroke-dasharray',
+    'stroke-dashoffset',
+    'stroke-opacity',
+    'opacity',
+    'transform',
+    'x',
+    'y',
+    'x1',
+    'y1',
+    'x2',
+    'y2',
+    'cx',
+    'cy',
+    'r',
+    'rx',
+    'ry',
+    'width',
+    'height',
+    'points',
+];
+const SAFE_PAINT_VALUE = /^(?:none|currentColor|transparent|#[0-9a-f]{3,8}|[a-z]+|(?:rgb|rgba|hsl|hsla)\([\d\s.,%+\-/]+\))$/iu;
+function isPluginSvgIcon(value) {
+    return value !== null
+        && typeof value === 'object'
+        && value.type === 'svg'
+        && typeof value.svg === 'string';
+}
+function parseSvgRoot(markup) {
+    const template = document.createElement('template');
+    template.innerHTML = markup.trim();
+    const children = template.content.children;
+    const root = children.item(0);
+    if (children.length !== 1 || !(root instanceof SVGSVGElement)) {
+        throw new TypeError('Custom plugin icons require exactly one <svg> root');
+    }
+    return root;
+}
+function hasValidViewBox(root) {
+    const values = root.getAttribute('viewBox')?.trim().split(/[\s,]+/u).map(Number) ?? [];
+    return values.length === 4
+        && values.every(Number.isFinite)
+        && (values[2] ?? 0) > 0
+        && (values[3] ?? 0) > 0;
+}
+function removeUnsafePaint(root) {
+    for (const element of [root, ...root.querySelectorAll('*')]) {
+        for (const attribute of ['fill', 'stroke']) {
+            const value = element.getAttribute(attribute);
+            if (value !== null && !SAFE_PAINT_VALUE.test(value.trim())) {
+                element.removeAttribute(attribute);
+            }
+        }
+    }
+}
+/**
+ * Validates and sanitizes a plugin icon before it crosses a host contribution boundary.
+ * Named icons are preserved so unsupported names can retain the host's existing fallback.
+ */
+export function sanitizePluginIcon(icon) {
+    if (typeof icon === 'string') {
+        if (icon.trim().length === 0) {
+            throw new TypeError('Plugin icon names must be non-empty');
+        }
+        return icon;
+    }
+    if (!isPluginSvgIcon(icon) || icon.svg.trim().length === 0) {
+        throw new TypeError('Plugin icons must be a non-empty name or { type: "svg", svg }');
+    }
+    if (icon.svg.length > MAX_PLUGIN_SVG_ICON_CHARACTERS) {
+        throw new TypeError(`Custom plugin icon SVG must not exceed ${MAX_PLUGIN_SVG_ICON_CHARACTERS.toLocaleString('en-US')} characters`);
+    }
+    const sanitizedMarkup = DOMPurify.sanitize(icon.svg, {
+        ALLOWED_TAGS: ALLOWED_SVG_TAGS,
+        ALLOWED_ATTR: ALLOWED_SVG_ATTRIBUTES,
+        ALLOW_ARIA_ATTR: false,
+        ALLOW_DATA_ATTR: false,
+        KEEP_CONTENT: false,
+    });
+    const root = parseSvgRoot(sanitizedMarkup);
+    if (!hasValidViewBox(root)) {
+        throw new TypeError('Custom plugin icons require a viewBox with positive width and height');
+    }
+    if (!root.querySelector('path, rect, circle, ellipse, line, polyline, polygon')) {
+        throw new TypeError('Custom plugin icons require visible geometry');
+    }
+    root.removeAttribute('width');
+    root.removeAttribute('height');
+    removeUnsafePaint(root);
+    return { type: 'svg', svg: root.outerHTML };
+}

package/dist/publicUiExports.d.mts

@@ -0,0 +1,16 @@
+export type OpenForgePluginSdkPublicUiExport = Readonly<{
+  componentName: string
+  packageSubpath: `./ui/${string}.svelte`
+  importSpecifier: `@openforge-app/plugin-sdk/ui/${string}.svelte`
+  sourcePath: `src/ui/${string}.svelte`
+  workspaceSourcePath: `packages/plugin-sdk/src/ui/${string}.svelte`
+  distPath: `./dist/ui/${string}.svelte`
+}>
+
+export const OPENFORGE_PLUGIN_SDK_PUBLIC_UI_EXPORTS: readonly OpenForgePluginSdkPublicUiExport[]
+
+export function createOpenForgePluginSdkPublicUiPackageExports(): Record<string, string>
+
+export function assertOpenForgePluginSdkPublicUiPackageExports(
+  packageExports: unknown,
+): asserts packageExports is Record<string, unknown>

package/dist/publicUiExports.mjs

@@ -0,0 +1,59 @@
+const PLUGIN_SDK_PACKAGE_NAME = '@openforge-app/plugin-sdk'
+
+const PUBLIC_UI_COMPONENT_NAMES = Object.freeze([
+  'Button',
+  'Checkbox',
+  'MarkdownContent',
+  'ResizablePanel',
+  'Modal',
+  'PluginPageHeader',
+  'PluginViewState',
+  'FileTypeIcon',
+])
+
+/**
+ * Canonical registrations for public Svelte components shipped by the plugin SDK.
+ * Package exports are validated against this list; asset copying, source aliases,
+ * root Vite aliases, and import-boundary fallbacks are derived from it.
+ */
+export const OPENFORGE_PLUGIN_SDK_PUBLIC_UI_EXPORTS = Object.freeze(
+  PUBLIC_UI_COMPONENT_NAMES.map((componentName) => Object.freeze({
+    componentName,
+    packageSubpath: `./ui/${componentName}.svelte`,
+    importSpecifier: `${PLUGIN_SDK_PACKAGE_NAME}/ui/${componentName}.svelte`,
+    sourcePath: `src/ui/${componentName}.svelte`,
+    workspaceSourcePath: `packages/plugin-sdk/src/ui/${componentName}.svelte`,
+    distPath: `./dist/ui/${componentName}.svelte`,
+  })),
+)
+
+export function createOpenForgePluginSdkPublicUiPackageExports() {
+  return Object.fromEntries(
+    OPENFORGE_PLUGIN_SDK_PUBLIC_UI_EXPORTS.map(({ packageSubpath, distPath }) => [packageSubpath, distPath]),
+  )
+}
+
+export function assertOpenForgePluginSdkPublicUiPackageExports(packageExports) {
+  if (!packageExports || typeof packageExports !== 'object' || Array.isArray(packageExports)) {
+    throw new Error('Plugin SDK package.json must define an exports object')
+  }
+
+  const expected = createOpenForgePluginSdkPublicUiPackageExports()
+  const actual = Object.fromEntries(
+    Object.entries(packageExports).filter(([subpath]) => subpath.startsWith('./ui/')),
+  )
+  const expectedEntries = Object.entries(expected)
+  const missingOrMismatched = expectedEntries
+    .filter(([subpath, distPath]) => actual[subpath] !== distPath)
+    .map(([subpath, distPath]) => `${subpath} -> ${distPath}`)
+  const unexpected = Object.keys(actual).filter((subpath) => !(subpath in expected))
+
+  if (missingOrMismatched.length === 0 && unexpected.length === 0) return
+
+  const details = [
+    missingOrMismatched.length > 0 ? `missing or mismatched: ${missingOrMismatched.join(', ')}` : null,
+    unexpected.length > 0 ? `not in the canonical manifest: ${unexpected.join(', ')}` : null,
+  ].filter(Boolean)
+
+  throw new Error(`Plugin SDK public UI exports drifted from the canonical manifest (${details.join('; ')})`)
+}

package/dist/svelteHostRuntimeContract.d.mts

@@ -6,6 +6,7 @@ export type SvelteHostRuntimeModule = Readonly<{
 
 export const SVELTE_HOST_RUNTIME_MODULES: readonly SvelteHostRuntimeModule[]
 export const OPENFORGE_HOST_RUNTIME_SVELTE_SPECIFIERS: readonly string[]
+export function isOpenForgeHostRuntimeSvelteExternal(id: string): boolean
 export const SVELTE_HOST_RUNTIME_IMPORTS: Readonly<Record<string, string>>
 export function svelteHostRuntimeImportUrl(specifier: string): string | null
 export function svelteHostRuntimeBuildEntries(): Record<string, string>