@hachej/boring-workspace 0.1.17 → 0.1.20

package/dist/{bootstrapServer-BreQ9QBc.d.ts → createInMemoryBridge-BDxDzihm.d.ts}

@@ -1,8 +1,6 @@
-import { U as UiBridge, A as AgentTool } from './agent-tool-DEtfQPVB.js';
 import { PiPackageSource, RuntimeProvisioningContribution } from '@hachej/boring-agent/server';
 import { FastifyPluginAsync } from 'fastify';
-
-declare function createInMemoryBridge(): UiBridge;
+import { A as AgentTool, U as UiBridge } from './ui-bridge-Gfh1MMgl.js';
 
 interface WorkspaceServerPlugin {
     id: string;
@@ -13,6 +11,12 @@ interface WorkspaceServerPlugin {
      * resource loader without asking Pi packages to export Boring adapters.
      */
     piPackages?: PiPackageSource[];
+    /**
+     * Native pi extension entrypoints contributed by this plugin.
+     * Passed to DefaultResourceLoader.additionalExtensionPaths so pi owns jiti
+     * loading and ctx.reload() re-imports fresh source.
+     */
+    extensionPaths?: string[];
     systemPrompt?: string;
     agentTools?: AgentTool[];
     provisioning?: RuntimeProvisioningContribution;
@@ -20,31 +24,9 @@ interface WorkspaceServerPlugin {
     /** UI state keys owned by this plugin that browser state PUTs must not overwrite. */
     preservedUiStateKeys?: string[];
 }
-declare class ServerPluginError extends Error {
-    constructor(message: string);
-}
 declare function validateServerPlugin(plugin: WorkspaceServerPlugin): void;
 declare function defineServerPlugin<T extends WorkspaceServerPlugin>(plugin: T): T;
 
-interface ComposeServerPluginsOptions {
-    id: string;
-    label?: string;
-    plugins: WorkspaceServerPlugin[];
-    piPackages?: PiPackageSource[];
-    systemPrompt?: string;
-    agentTools?: AgentTool[];
-    provisioning?: RuntimeProvisioningContribution;
-    routes?: FastifyPluginAsync;
-    preservedUiStateKeys?: string[];
-}
-/**
- * Compose a server plugin from smaller server plugin fragments. Child
- * contributions are concatenated before parent contributions. Composed routes
- * are registered without extra Fastify options; use an explicit routes plugin
- * when a child needs scoped registration options.
- */
-declare function composeServerPlugins(options: ComposeServerPluginsOptions): WorkspaceServerPlugin;
-
 interface ServerBootstrapOptions {
     plugins?: WorkspaceServerPlugin[];
     defaults?: WorkspaceServerPlugin[];
@@ -62,6 +44,7 @@ interface ServerBootstrapResult {
     registered: string[];
     systemPromptAppend: string;
     piPackages: PiPackageSource[];
+    extensionPaths: string[];
     agentTools: AgentTool[];
     provisioningContributions: WorkspaceProvisioningContribution[];
     routeContributions: WorkspaceRouteContribution[];
@@ -69,4 +52,6 @@ interface ServerBootstrapResult {
 }
 declare function bootstrapServer(options: ServerBootstrapOptions): ServerBootstrapResult;
 
-export { type ComposeServerPluginsOptions as C, type ServerBootstrapOptions as S, type WorkspaceServerPlugin as W, type WorkspaceProvisioningContribution as a, type WorkspaceRouteContribution as b, createInMemoryBridge as c, composeServerPlugins as d, defineServerPlugin as e, type ServerBootstrapResult as f, ServerPluginError as g, bootstrapServer as h, validateServerPlugin as v };
+declare function createInMemoryBridge(): UiBridge;
+
+export { type ServerBootstrapOptions as S, type WorkspaceServerPlugin as W, type WorkspaceProvisioningContribution as a, type WorkspaceRouteContribution as b, createInMemoryBridge as c, type ServerBootstrapResult as d, bootstrapServer as e, defineServerPlugin as f, validateServerPlugin as v };

package/dist/manifest-CyNNdfYz.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Canonical package.json plugin shape for boring-ui workspace packages.
+ *
+ * Browser-safe: no node:* imports, no fs, no path.
+ *
+ * A plugin package has one package boundary and two namespaces:
+ * - `pi`: agent/Pi runtime contributions (extensions, skills, prompt, Pi packages)
+ * - `boring`: workspace/UI package discovery (front/server entrypoints and labels)
+ */
+interface BoringPackageBoringField {
+    /** Browser entry that default-exports a BoringFrontFactory. */
+    front?: string;
+    /** Workspace/UI support server entry. Set false to disable convention lookup. */
+    server?: string | false;
+    label?: string;
+}
+interface BoringPackagePiSourceObject {
+    source: string;
+    extensions?: string[];
+    skills?: string[];
+    themes?: string[];
+    prompts?: string[];
+}
+type BoringPackagePiSource = string | BoringPackagePiSourceObject;
+interface BoringPackagePiField {
+    /** Native Pi extension entrypoints, relative to the package root. */
+    extensions?: string[];
+    /** Skill directories/files, relative to the package root. */
+    skills?: string[];
+    /** Additional Pi package sources to inject into Pi settings. */
+    packages?: BoringPackagePiSource[];
+    /** Agent context injected by the boring Pi extension. Prefer skills for large docs. */
+    systemPrompt?: string;
+}
+interface BoringPluginPackageJson {
+    name?: string;
+    version?: string;
+    boring?: BoringPackageBoringField;
+    pi?: BoringPackagePiField;
+}
+type BoringPluginManifestErrorCode = "INVALID_ID" | "INVALID_VERSION" | "INVALID_FIELD" | "INVALID_PATH" | "MISSING_REQUIRED_FIELD";
+interface BoringPluginManifestIssue {
+    code: BoringPluginManifestErrorCode;
+    field: string;
+    message: string;
+}
+type BoringPluginManifestValidationResult = {
+    valid: true;
+    packageJson: BoringPluginPackageJson;
+} | {
+    valid: false;
+    issues: BoringPluginManifestIssue[];
+};
+declare function isValidBoringPluginId(id: string): boolean;
+declare function isSafePluginRelativePath(value: string): boolean;
+declare function validateBoringPluginManifest(raw: unknown): BoringPluginManifestValidationResult;
+
+export { type BoringPackageBoringField as B, type BoringPackagePiField as a, type BoringPackagePiSource as b, type BoringPackagePiSourceObject as c, type BoringPluginManifestErrorCode as d, type BoringPluginManifestIssue as e, type BoringPluginManifestValidationResult as f, type BoringPluginPackageJson as g, isValidBoringPluginId as h, isSafePluginRelativePath as i, validateBoringPluginManifest as v };

package/dist/plugin.d.ts

@@ -0,0 +1,199 @@
+import { ComponentType, ReactNode } from 'react';
+import { P as PaneProps, a as PanelConfig, S as SurfaceOpenRequest, c as SurfacePanelResolution } from './surface-COYagY2m.js';
+export { W as WORKSPACE_OPEN_PATH_SURFACE_KIND } from './surface-COYagY2m.js';
+export { B as BoringPackageBoringField, a as BoringPackagePiField, b as BoringPackagePiSource, c as BoringPackagePiSourceObject, d as BoringPluginManifestErrorCode, e as BoringPluginManifestIssue, f as BoringPluginManifestValidationResult, g as BoringPluginPackageJson, i as isSafePluginRelativePath, h as isValidBoringPluginId, v as validateBoringPluginManifest } from './manifest-CyNNdfYz.js';
+import 'dockview-react';
+
+type CatalogBadge = {
+    /** 1–4 char mono code rendered as a chip. */
+    code: string;
+    tooltip?: string;
+};
+type CatalogRow = {
+    id: string;
+    title: string;
+    subtitle?: string;
+    group?: string;
+    leading?: CatalogBadge;
+    trailing?: CatalogBadge[];
+    meta?: string;
+};
+type CatalogFacetValue = {
+    value: string;
+    count: number;
+};
+type CatalogFacets = Record<string, CatalogFacetValue[]>;
+type CatalogSearchArgs = {
+    query: string;
+    filters: Record<string, string[]>;
+    group?: {
+        key: string;
+        value: string;
+    };
+    limit: number;
+    offset: number;
+    signal?: AbortSignal;
+};
+type CatalogSearchResult = {
+    items: CatalogRow[];
+    total: number;
+    hasMore: boolean;
+};
+type CatalogFacetsArgs = {
+    filters: Record<string, string[]>;
+    signal?: AbortSignal;
+};
+type CatalogAdapter = {
+    search(args: CatalogSearchArgs): Promise<CatalogSearchResult>;
+    fetchFacets?(args: CatalogFacetsArgs): Promise<CatalogFacets>;
+};
+type PluginBinding = ComponentType<unknown>;
+interface PluginProviderProps {
+    apiBaseUrl: string;
+    authHeaders?: Record<string, string>;
+    onAuthError?: (statusCode: number) => void;
+    apiTimeout?: number;
+    children: ReactNode;
+}
+type PluginProvider = ComponentType<PluginProviderProps>;
+interface CatalogConfig {
+    id: string;
+    label: string;
+    adapter: CatalogAdapter;
+    onSelect: (row: CatalogRow) => void;
+    pluginId?: string;
+}
+interface LeftTabParams {
+    rootDir?: string;
+    query?: string;
+    searchQuery?: string;
+    bridge?: unknown;
+    chromeless?: boolean;
+}
+
+interface BoringFrontPanelRegistration<T = unknown> {
+    id: string;
+    component: ComponentType<PaneProps<T>> | (() => Promise<{
+        default: ComponentType<PaneProps<T>>;
+    }>);
+    label?: string;
+    icon?: ComponentType<{
+        className?: string;
+    }>;
+    placement?: string;
+    requiresCapabilities?: string[];
+    essential?: boolean;
+    lazy?: boolean;
+    chromeless?: boolean;
+    source?: string;
+}
+interface BoringFrontPanelCommandRegistration {
+    id: string;
+    title: string;
+    panelId?: string;
+    run?: () => void;
+    keywords?: string[];
+    shortcut?: string;
+    when?: () => boolean;
+}
+interface BoringFrontLeftTabRegistration<T = LeftTabParams> {
+    id: string;
+    title: string;
+    panelId: string;
+    icon?: ComponentType<{
+        className?: string;
+    }>;
+    component?: PanelConfig<T>["component"];
+    lazy?: boolean;
+    chromeless?: boolean;
+    requiresCapabilities?: string[];
+    source?: string;
+}
+interface BoringFrontProviderRegistration {
+    id: string;
+    component: PluginProvider;
+}
+interface BoringFrontBindingRegistration {
+    id: string;
+    component: PluginBinding;
+}
+interface BoringFrontSurfaceResolverRegistration {
+    id?: string;
+    kind: string;
+    source?: string;
+    resolve: (request: SurfaceOpenRequest) => SurfacePanelResolution | null | undefined;
+}
+interface BoringFrontAPI {
+    registerProvider(registration: BoringFrontProviderRegistration): void;
+    registerBinding(registration: BoringFrontBindingRegistration): void;
+    registerCatalog(registration: CatalogConfig): void;
+    registerPanel<T = unknown>(registration: BoringFrontPanelRegistration<T>): void;
+    registerPanelCommand(registration: BoringFrontPanelCommandRegistration): void;
+    registerLeftTab<T = LeftTabParams>(registration: BoringFrontLeftTabRegistration<T>): void;
+    registerSurfaceResolver(registration: BoringFrontSurfaceResolverRegistration): void;
+}
+type BoringFrontFactory = (api: BoringFrontAPI) => void | Promise<void>;
+type BoringFrontSetup = (api: BoringFrontAPI) => void;
+type RejectAsyncSetup<C> = C extends {
+    setup?: infer Setup;
+} ? Setup extends (...args: any[]) => infer Return ? Extract<Return, PromiseLike<unknown>> extends never ? unknown : never : unknown : unknown;
+/**
+ * A `BoringFrontFactory` that carries its own plugin id (and optional
+ * label) as static properties. Produced by `definePlugin({ ... })` and used
+ * directly by `WorkspaceProvider.plugins`.
+ */
+type BoringFrontFactoryWithId = BoringFrontFactory & {
+    pluginId: string;
+    pluginLabel?: string;
+};
+/**
+ * Declarative plugin config — the canonical shape for `definePlugin`.
+ */
+interface DefinePluginConfig {
+    id: string;
+    label?: string;
+    panels?: ReadonlyArray<BoringFrontPanelRegistration<any>>;
+    commands?: ReadonlyArray<BoringFrontPanelCommandRegistration>;
+    leftTabs?: ReadonlyArray<BoringFrontLeftTabRegistration<any>>;
+    surfaceResolvers?: ReadonlyArray<BoringFrontSurfaceResolverRegistration>;
+    providers?: ReadonlyArray<BoringFrontProviderRegistration>;
+    bindings?: ReadonlyArray<BoringFrontBindingRegistration>;
+    catalogs?: ReadonlyArray<CatalogConfig>;
+    /**
+     * Escape hatch for registrations that can't be expressed declaratively.
+     * Called LAST, after every declarative field has been registered.
+     */
+    setup?: BoringFrontSetup;
+}
+/**
+ * Define a boring-ui plugin. Takes a single declarative config object and
+ * returns a branded front factory.
+ *
+ * Older positional signatures are not supported. The `setup` field is
+ * synchronous so statically composed plugins cannot return a Promise during
+ * provider bootstrap.
+ */
+declare function definePlugin<const Config extends DefinePluginConfig>(config: Config & RejectAsyncSetup<Config>): BoringFrontFactoryWithId;
+interface CapturedBoringFrontRegistrations {
+    providers: BoringFrontProviderRegistration[];
+    bindings: BoringFrontBindingRegistration[];
+    catalogs: CatalogConfig[];
+    panels: BoringFrontPanelRegistration<any>[];
+    panelCommands: BoringFrontPanelCommandRegistration[];
+    leftTabs: BoringFrontLeftTabRegistration<any>[];
+    surfaceResolvers: BoringFrontSurfaceResolverRegistration[];
+}
+interface CapturedFrontPlugin {
+    id: string;
+    label?: string;
+    registrations: CapturedBoringFrontRegistrations;
+}
+interface CapturingBoringFrontAPIHandle extends BoringFrontAPI {
+    flush(): CapturedBoringFrontRegistrations;
+}
+declare function createCapturingBoringFrontAPI(options?: {
+    pluginId?: string;
+}): CapturingBoringFrontAPIHandle;
+declare function captureFrontPlugin(plugin: BoringFrontFactoryWithId): CapturedFrontPlugin;
+
+export { type BoringFrontAPI, type BoringFrontBindingRegistration, type BoringFrontFactory, type BoringFrontFactoryWithId, type BoringFrontLeftTabRegistration, type BoringFrontPanelCommandRegistration, type BoringFrontPanelRegistration, type BoringFrontProviderRegistration, type BoringFrontSetup, type BoringFrontSurfaceResolverRegistration, type CapturedBoringFrontRegistrations, type CapturedFrontPlugin, type CapturingBoringFrontAPIHandle, type DefinePluginConfig, PaneProps, captureFrontPlugin, createCapturingBoringFrontAPI, definePlugin };

package/dist/plugin.js

@@ -0,0 +1,300 @@
+// src/shared/plugins/errors.ts
+var PluginError = class extends Error {
+  constructor(kind, message) {
+    super(message);
+    this.kind = kind;
+    this.name = "PluginError";
+  }
+  kind;
+};
+
+// src/shared/plugins/frontFactory.ts
+function definePlugin(config) {
+  if (typeof config !== "object" || config === null) {
+    if (typeof config === "string" || typeof config === "function") {
+      throw new Error(
+        "definePlugin now takes a single declarative config object: definePlugin({ id, label?, panels, commands, leftTabs, surfaceResolvers, setup? }). The legacy positional form was removed \u2014 use the new shape."
+      );
+    }
+    throw new Error("definePlugin: expected a config object");
+  }
+  if (typeof config.id !== "string" || config.id.length === 0) {
+    throw new Error("definePlugin: `id` is required and must be a non-empty string");
+  }
+  const factory = (api) => {
+    for (const panel of config.panels ?? []) api.registerPanel(panel);
+    for (const command of config.commands ?? []) api.registerPanelCommand(command);
+    for (const tab of config.leftTabs ?? []) api.registerLeftTab(tab);
+    for (const resolver of config.surfaceResolvers ?? []) api.registerSurfaceResolver(resolver);
+    for (const provider of config.providers ?? []) api.registerProvider(provider);
+    for (const binding of config.bindings ?? []) api.registerBinding(binding);
+    for (const catalog of config.catalogs ?? []) api.registerCatalog(catalog);
+    if (config.setup) config.setup(api);
+    return void 0;
+  };
+  return brandFactoryWithPluginId(config.id, factory, { label: config.label });
+}
+function brandFactoryWithPluginId(id, factory, options) {
+  const existing = factory.pluginId;
+  if (existing !== void 0 && existing !== id) {
+    throw new Error(`definePlugin: factory already branded as "${existing}", cannot rebrand as "${id}"`);
+  }
+  const wrapper = ((api) => factory(api));
+  Object.defineProperty(wrapper, "pluginId", { value: id, enumerable: true });
+  if (options.label !== void 0) {
+    Object.defineProperty(wrapper, "pluginLabel", { value: options.label, enumerable: true });
+  }
+  return wrapper;
+}
+function clone(items) {
+  return [...items];
+}
+function createCapturingBoringFrontAPI(options = {}) {
+  const providers = [];
+  const bindings = [];
+  const catalogs = [];
+  const panels = [];
+  const panelCommands = [];
+  const leftTabs = [];
+  const surfaceResolvers = [];
+  const seen = /* @__PURE__ */ new Map();
+  const claim = (kind, id) => {
+    const key = `${kind}:${id}`;
+    const prior = seen.get(key);
+    if (prior !== void 0) {
+      const owner = options.pluginId ?? "<plugin>";
+      throw new PluginError(
+        "duplicate-id",
+        `plugin "${owner}" registers ${kind} "${id}" twice (first as ${prior}, then again). If you are composing kits, two of them are registering the same id \u2014 namespace one of them.`
+      );
+    }
+    seen.set(key, `${kind} "${id}"`);
+  };
+  return {
+    registerProvider(registration) {
+      claim("provider", registration.id);
+      providers.push(registration);
+    },
+    registerBinding(registration) {
+      claim("binding", registration.id);
+      bindings.push(registration);
+    },
+    registerCatalog(registration) {
+      claim("catalog", registration.id);
+      catalogs.push(registration);
+    },
+    registerPanel(registration) {
+      claim("panel", registration.id);
+      panels.push(registration);
+    },
+    registerPanelCommand(registration) {
+      claim("command", registration.id);
+      panelCommands.push(registration);
+    },
+    registerLeftTab(registration) {
+      claim("left-tab", registration.id);
+      leftTabs.push(registration);
+    },
+    registerSurfaceResolver(registration) {
+      const id = registration.id ?? `${options.pluginId ?? "anon"}:${registration.kind}`;
+      claim("surface-resolver", id);
+      if (registration.id === void 0) {
+        ;
+        registration.id = id;
+      }
+      surfaceResolvers.push(registration);
+    },
+    flush() {
+      return {
+        providers: clone(providers),
+        bindings: clone(bindings),
+        catalogs: clone(catalogs),
+        panels: clone(panels),
+        panelCommands: clone(panelCommands),
+        leftTabs: clone(leftTabs),
+        surfaceResolvers: clone(surfaceResolvers)
+      };
+    }
+  };
+}
+function captureFrontPlugin(plugin) {
+  if (typeof plugin !== "function" || typeof plugin.pluginId !== "string" || plugin.pluginId.length === 0) {
+    throw new Error(
+      "WorkspaceProvider.plugins accepts plugins created by definePlugin({ id, ... }). Received a front plugin without a pluginId."
+    );
+  }
+  const api = createCapturingBoringFrontAPI({ pluginId: plugin.pluginId });
+  const result = plugin(api);
+  if (result && typeof result.then === "function") {
+    throw new Error(`captureFrontPlugin(${plugin.pluginId}) requires a synchronous factory`);
+  }
+  return {
+    id: plugin.pluginId,
+    ...plugin.pluginLabel !== void 0 ? { label: plugin.pluginLabel } : {},
+    registrations: api.flush()
+  };
+}
+
+// src/shared/plugins/manifest.ts
+var SEMVER_RE = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+var PLUGIN_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._:-]*$/;
+function isValidBoringPluginId(id) {
+  return typeof id === "string" && id.length > 0 && PLUGIN_ID_RE.test(id);
+}
+function isSafePluginRelativePath(value) {
+  return typeof value === "string" && value.length > 0 && value !== "." && !value.includes("\0") && !value.includes("\\") && !value.startsWith("/") && !value.startsWith("//") && !/^[A-Za-z]:[\\/]/.test(value) && !value.split("/").includes("..");
+}
+function issue(code, field, message) {
+  return { code, field, message };
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function validateStringArray(issues, value, field, pathLike) {
+  if (value === void 0) return;
+  if (!Array.isArray(value)) {
+    issues.push(issue("INVALID_FIELD", field, `${field} must be an array`));
+    return;
+  }
+  value.forEach((entry, index) => {
+    const itemField = `${field}[${index}]`;
+    if (typeof entry !== "string" || entry.length === 0) {
+      issues.push(issue("INVALID_FIELD", itemField, `${itemField} must be a non-empty string`));
+      return;
+    }
+    if (pathLike && !isSafePluginRelativePath(entry)) {
+      issues.push(issue("INVALID_PATH", itemField, `${itemField} must be a safe relative path`));
+    }
+  });
+}
+var REMOVED_BORING_UI_FIELDS = ["outputs", "panels", "commands", "leftTabs", "surfaceResolvers", "providers", "bindings", "catalogs"];
+function validateBoringField(issues, boring) {
+  if (boring === void 0) return void 0;
+  if (!isRecord(boring)) {
+    issues.push(issue("INVALID_FIELD", "boring", "boring must be an object when provided"));
+    return void 0;
+  }
+  for (const field of REMOVED_BORING_UI_FIELDS) {
+    if (boring[field] !== void 0) {
+      issues.push(issue(
+        "INVALID_FIELD",
+        `boring.${field}`,
+        `boring.${field} is not supported; declare front contributions in boring.front via definePlugin({ ... })`
+      ));
+    }
+  }
+  if (boring.id !== void 0) {
+    issues.push(issue("INVALID_FIELD", "boring.id", "boring.id is not supported; package discovery identity comes from package.json#name"));
+  }
+  const front = boring.front;
+  if (front !== void 0 && (typeof front !== "string" || !isSafePluginRelativePath(front))) {
+    issues.push(issue("INVALID_PATH", "boring.front", "boring.front must be a safe relative path"));
+  }
+  const server = boring.server;
+  if (server !== void 0 && server !== false && (typeof server !== "string" || !isSafePluginRelativePath(server))) {
+    issues.push(issue("INVALID_PATH", "boring.server", "boring.server must be a safe relative path or false"));
+  }
+  if (boring.label !== void 0 && typeof boring.label !== "string") {
+    issues.push(issue("INVALID_FIELD", "boring.label", "boring.label must be a string when provided"));
+  }
+  return {
+    ...typeof boring.front === "string" ? { front: boring.front } : {},
+    ...typeof boring.server === "string" || boring.server === false ? { server: boring.server } : {},
+    ...typeof boring.label === "string" ? { label: boring.label } : {}
+  };
+}
+var REMOTE_PI_PACKAGE_PREFIXES = ["npm:", "git:", "github:", "http:", "https:", "ssh:"];
+function isRemotePiPackageSource(value) {
+  return REMOTE_PI_PACKAGE_PREFIXES.some((prefix) => value.startsWith(prefix));
+}
+function isSafePiPackageSource(value) {
+  if (value.length === 0) return false;
+  if (isRemotePiPackageSource(value)) return true;
+  const path = value.startsWith("file:") ? value.slice("file:".length) : value;
+  if (path === "." || path === "./") return true;
+  const normalized = path.startsWith("./") ? path.slice(2) : path;
+  return isSafePluginRelativePath(normalized);
+}
+function validatePiPackages(issues, value) {
+  if (value === void 0) return;
+  if (!Array.isArray(value)) {
+    issues.push(issue("INVALID_FIELD", "pi.packages", "pi.packages must be an array when provided"));
+    return;
+  }
+  value.forEach((entry, index) => {
+    const field = `pi.packages[${index}]`;
+    if (typeof entry === "string") {
+      if (!isSafePiPackageSource(entry)) {
+        issues.push(issue("INVALID_PATH", field, `${field} must be a safe package source`));
+      }
+      return;
+    }
+    if (!isRecord(entry)) {
+      issues.push(issue("INVALID_FIELD", field, `${field} must be a string or package source object`));
+      return;
+    }
+    if (typeof entry.source !== "string" || entry.source.length === 0) {
+      issues.push(issue("INVALID_FIELD", `${field}.source`, `${field}.source must be a non-empty string`));
+    } else if (!isSafePiPackageSource(entry.source)) {
+      issues.push(issue("INVALID_PATH", `${field}.source`, `${field}.source must be a safe package source`));
+    }
+  });
+}
+function validatePiField(issues, pi) {
+  if (pi === void 0) return void 0;
+  if (!isRecord(pi)) {
+    issues.push(issue("INVALID_FIELD", "pi", "pi must be an object when provided"));
+    return void 0;
+  }
+  validateStringArray(issues, pi.extensions, "pi.extensions", true);
+  validateStringArray(issues, pi.skills, "pi.skills", true);
+  validatePiPackages(issues, pi.packages);
+  if (pi.systemPrompt !== void 0 && typeof pi.systemPrompt !== "string") {
+    issues.push(issue("INVALID_FIELD", "pi.systemPrompt", "pi.systemPrompt must be a string when provided"));
+  }
+  return pi;
+}
+function validateBoringPluginManifest(raw) {
+  const issues = [];
+  if (!isRecord(raw)) {
+    return {
+      valid: false,
+      issues: [issue("INVALID_FIELD", "<root>", "package.json manifest must be an object")]
+    };
+  }
+  if (raw.name !== void 0 && typeof raw.name !== "string") {
+    issues.push(issue("INVALID_FIELD", "name", "name must be a string when provided"));
+  }
+  if (raw.version !== void 0 && typeof raw.version !== "string") {
+    issues.push(issue("INVALID_VERSION", "version", "version must be a string when provided"));
+  } else if (typeof raw.version === "string" && raw.version.length > 0 && !SEMVER_RE.test(raw.version)) {
+    issues.push(issue("INVALID_VERSION", "version", "version must be a valid semver string"));
+  }
+  const boring = validateBoringField(issues, raw.boring);
+  const pi = validatePiField(issues, raw.pi);
+  if (!boring && !pi) {
+    issues.push(issue("MISSING_REQUIRED_FIELD", "boring|pi", "package.json must include boring and/or pi plugin metadata"));
+  }
+  if (issues.length > 0) return { valid: false, issues };
+  return {
+    valid: true,
+    packageJson: {
+      ...typeof raw.name === "string" ? { name: raw.name } : {},
+      ...typeof raw.version === "string" ? { version: raw.version } : {},
+      ...boring ? { boring } : {},
+      ...pi ? { pi } : {}
+    }
+  };
+}
+
+// src/shared/types/surface.ts
+var WORKSPACE_OPEN_PATH_SURFACE_KIND = "workspace.open.path";
+export {
+  WORKSPACE_OPEN_PATH_SURFACE_KIND,
+  captureFrontPlugin,
+  createCapturingBoringFrontAPI,
+  definePlugin,
+  isSafePluginRelativePath,
+  isValidBoringPluginId,
+  validateBoringPluginManifest
+};