@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/manager-errors.d.ts

@@ -0,0 +1,89 @@
+import { St as StatusTypeId, _t as Status, pt as StorybookError } from "./chunk-C2p5r3Vt.js";
+
+//#region .dts-emit/code/core/src/manager-errors.d.ts
+/**
+ * If you can't find a suitable category for your error, create one based on the package name/file
+ * path of which the error is thrown. For instance: If it's from `@aussieljk/forkbook/internal/client-logger`,
+ * then MANAGER_CLIENT-LOGGER
+ *
+ * Categories are prefixed by a logical grouping, e.g. MANAGER_ to prevent manager and preview
+ * errors from having the same category and error code.
+ */
+declare enum Category {
+  MANAGER_UNCAUGHT = "MANAGER_UNCAUGHT",
+  MANAGER_UI = "MANAGER_UI",
+  MANAGER_API = "MANAGER_API",
+  MANAGER_CLIENT_LOGGER = "MANAGER_CLIENT-LOGGER",
+  MANAGER_CHANNELS = "MANAGER_CHANNELS",
+  MANAGER_CORE_EVENTS = "MANAGER_CORE-EVENTS",
+  MANAGER_ROUTER = "MANAGER_ROUTER",
+  MANAGER_THEMING = "MANAGER_THEMING",
+  MANAGER_UNIVERSAL_STORE = "MANAGER_UNIVERSAL-STORE",
+  MANAGER_OPEN_SERVICE = "MANAGER_OPEN-SERVICE"
+}
+declare class ProviderDoesNotExtendBaseProviderError extends StorybookError {
+  constructor();
+}
+declare class UncaughtManagerError extends StorybookError {
+  data: {
+    error: Error;
+  };
+  constructor(data: {
+    error: Error;
+  });
+}
+declare class StatusTypeIdMismatchError extends StorybookError {
+  data: {
+    status: Status;
+    typeId: StatusTypeId;
+  };
+  constructor(data: {
+    status: Status;
+    typeId: StatusTypeId;
+  });
+}
+declare class UniversalStoreFollowerTimeoutError extends StorybookError {
+  constructor(followerId: string);
+}
+declare class OpenServiceStaticSnapshotLoadError extends StorybookError {
+  data: {
+    serviceId: string;
+    queryName: string;
+    input: unknown;
+    logicalPath: string;
+    url: string;
+    cause: unknown;
+    status?: number;
+    statusText?: string;
+  };
+  constructor(data: {
+    serviceId: string;
+    queryName: string;
+    input: unknown;
+    logicalPath: string;
+    url: string;
+    cause: unknown;
+    status?: number;
+    statusText?: string;
+  });
+}
+declare class OpenServiceStaticSnapshotInvalidError extends StorybookError {
+  data: {
+    serviceId: string;
+    queryName: string;
+    input: unknown;
+    logicalPath: string;
+    url: string;
+    received: unknown;
+  };
+  constructor(data: {
+    serviceId: string;
+    queryName: string;
+    input: unknown;
+    logicalPath: string;
+    url: string;
+    received: unknown;
+  });
+}
+//#endregion
+export { Category, OpenServiceStaticSnapshotInvalidError, OpenServiceStaticSnapshotLoadError, ProviderDoesNotExtendBaseProviderError, StatusTypeIdMismatchError, UncaughtManagerError, UniversalStoreFollowerTimeoutError };

package/dist/manager-errors.js

@@ -0,0 +1,20 @@
+import {
+  Category,
+  OpenServiceStaticSnapshotInvalidError,
+  OpenServiceStaticSnapshotLoadError,
+  ProviderDoesNotExtendBaseProviderError,
+  StatusTypeIdMismatchError,
+  UncaughtManagerError,
+  UniversalStoreFollowerTimeoutError
+} from "./_browser-chunks/chunk-RSPAQWVJ.js";
+import "./_browser-chunks/chunk-V5M7Q4HT.js";
+import "./_browser-chunks/chunk-IMSF75WX.js";
+export {
+  Category,
+  OpenServiceStaticSnapshotInvalidError,
+  OpenServiceStaticSnapshotLoadError,
+  ProviderDoesNotExtendBaseProviderError,
+  StatusTypeIdMismatchError,
+  UncaughtManagerError,
+  UniversalStoreFollowerTimeoutError
+};

package/dist/mcp/index.d.ts

@@ -0,0 +1,270 @@
+import { GenericSchema } from "valibot";
+import { AllManifests, COMPONENT_MANIFEST_PATH, ComponentManifest, ComponentManifest as ComponentManifest$1, ComponentManifestMap, ComponentManifestMap as ComponentManifestMap$1, DOCS_MANIFEST_PATH, DOCS_TOOLSET_INSTRUCTIONS as FORKBOOK_MCP_INSTRUCTIONS, Doc, Doc as Doc$1, DocsManifestMap, DocsManifestMap as DocsManifestMap$1, ManifestProvider, RequiresOwnMcpError, Source as Source$1, Story, Story as Story$1, adaptCoreComponent, adaptCoreDoc, adaptCoreStories, resolveComponentEntry, resolveComponentStories, resolveDocEntry as resolveDoc } from "@aussieljk/forkbook/internal/toolsets-docs";
+import { McpServer } from "tmcp";
+
+//#region .dts-emit/code/core/src/mcp/types.d.ts
+/**
+ * Represents a single Forkbook source (local or remote).
+ */
+type Source = {
+  /** Unique identifier for this source (e.g., 'local', 'tetra') */id: string; /** Human-readable title (e.g., 'Local', 'Tetra Design System') */
+  title: string; /** Remote URL, undefined for local source */
+  url?: string;
+};
+type RequiresOwnMcpNotice = {
+  kind: 'requires-own-mcp';
+  endpoint: string;
+};
+/**
+ * All manifests for a single source.
+ */
+type SourceManifests = {
+  source: Source;
+  componentManifest: ComponentManifestMap$1;
+  docsManifest?: DocsManifestMap$1; /** Error message if fetching this source failed */
+  error?: string; /** Non-error guidance for sources that must be accessed through their own MCP endpoint */
+  notice?: RequiresOwnMcpNotice;
+};
+/**
+ * Custom context passed to MCP server and tools.
+ * Contains the request object and optional manifest provider.
+ */
+type StorybookContext = {
+  /**
+   * The incoming HTTP request being processed.
+   */
+  request?: Request;
+  /**
+   * Optional function to provide custom manifest retrieval logic.
+   * If provided, this function will be called instead of the default fetch-based provider.
+   * The function receives the request object, a path to the manifest file, and optionally
+   * a source (in multi-source mode).
+   * The default provider requires a request object and constructs the manifest URL from the request origin,
+   * using the top-level manifest path such as /manifests/components.json.
+   * Custom providers can use the request parameter to determine the manifest source, or ignore it entirely.
+   */
+  manifestProvider?: (request: Request | undefined, path: string, source?: Source) => Promise<string>;
+  /**
+   * Sources configuration for multi-source mode.
+   * When provided, tools will fetch and display manifests grouped by source.
+   */
+  sources?: Source[];
+  /**
+   * Optional handler called when the docs-list tool is invoked.
+   * Receives the context and the component manifest.
+   */
+  onListAllDocumentation?: (params: {
+    context: StorybookContext;
+    manifests: AllManifests;
+    resultText: string; /** Present in multi-source mode — all source manifests including errors */
+    sources?: SourceManifests[];
+  }) => void | Promise<void>;
+  /**
+   * Optional handler called when the docs-show tool is invoked.
+   * Receives the context, input parameters, and the found component (if any).
+   */
+  onGetDocumentation?: (params: {
+    context: StorybookContext;
+    input: {
+      id: string;
+      storybookId?: string;
+    };
+  } & ({
+    foundDocumentation: ComponentManifest$1 | Doc$1;
+    resultText: string;
+  } | {
+    foundDocumentation?: never;
+    resultText?: never;
+  })) => void | Promise<void>;
+  /**
+   * Optional in-process resolver for a single component or docs entry, used in
+   * Forkbook's dev server when `docgenServer` is enabled. When set,
+   * single-entry tools (`docs-show`, `docs-show-story`) call
+   * this instead of fetching the (potentially all-component) manifest index, so a
+   * single lookup never triggers docgen extraction for every component.
+   *
+   * Returns the fully-resolved component or doc in `@aussieljk/forkbook/mcp`'s internal
+   * shape (already adapted from the open-service payloads), or `undefined` when the
+   * id is unknown.
+   */
+  resolveEntry?: (id: string, source?: Source) => Promise<ResolvedEntry | undefined>;
+};
+/**
+ * Result of resolving a single id via {@link StorybookContext.resolveEntry}: either a
+ * fully-resolved component manifest or a standalone docs entry.
+ */
+type ResolvedEntry = {
+  kind: 'component';
+  component: ComponentManifest$1;
+} | {
+  kind: 'doc';
+  doc: Doc$1;
+};
+/**
+ * Open-service payload contracts (the "core format") that Forkbook's
+ * `docgenServer` mode produces. `@aussieljk/forkbook/mcp` adapts these into its
+ * internal {@link ComponentManifest}/{@link Doc} shapes in one place
+ * (`adaptCoreComponent`/`adaptCoreDoc`). Defined structurally (not as schemas) so
+ * the addon can build them in-process without importing Forkbook core.
+ */
+/** One story snippet from the `core/story-docs` service. */
+type CoreStoryDoc = {
+  id: string;
+  name: string;
+  snippet?: string;
+  description?: string;
+  summary?: string;
+  error?: {
+    name: string;
+    message: string;
+  };
+};
+/** One MDX doc from the `addon-docs/mdx` service. */
+type CoreMdxDoc = {
+  id: string;
+  name: string;
+  path?: string;
+  title?: string;
+  content?: string;
+  summary?: string;
+  error?: {
+    name: string;
+    message: string;
+  };
+};
+/**
+ * Payload returned by the `addon-docs/mdx` service for a component or standalone
+ * docs entry.
+ */
+type CoreMdxPayload = {
+  id: string;
+  name: string;
+  docs: Record<string, CoreMdxDoc>;
+};
+/** Payload returned by the `core/story-docs` service for one component. */
+type CoreStoryDocsPayload = {
+  id: string;
+  name: string;
+  path: string;
+  import?: string;
+  stories: Record<string, CoreStoryDoc>;
+  error?: {
+    name: string;
+    message: string;
+  };
+};
+/**
+ * Payload returned by the `core/docgen` service for one component. `argTypes` (a
+ * UI-normalized view) is intentionally ignored by the adapter; prop types come
+ * from the `reactComponentMeta` field.
+ */
+type CoreDocgenPayload = {
+  id: string;
+  name: string;
+  path?: string;
+  description?: string;
+  summary?: string;
+  jsDocTags?: Record<string, string[]>;
+  import?: string;
+  reactComponentMeta?: unknown;
+  subcomponents?: Record<string, unknown>;
+  error?: {
+    name: string;
+    message: string;
+  };
+  [key: string]: unknown;
+};
+/**
+ * A component assembled from the `core/docgen` payload plus the `core/story-docs`
+ * stories and resolved attached MDX docs.
+ */
+type CoreDocgenComponent = CoreDocgenPayload & {
+  import?: string; /** Story snippets, either as a story-docs record or an already-resolved array. */
+  stories?: Record<string, CoreStoryDoc> | Story$1[]; /** Attached docs keyed by doc id (resolved MDX payloads). */
+  docs?: Record<string, CoreMdxDoc>;
+};
+//#endregion
+//#region .dts-emit/code/core/src/mcp/tools/register.d.ts
+declare const LIST_TOOL_NAME: string;
+declare const GET_TOOL_NAME: string;
+declare const GET_STORY_TOOL_NAME: string;
+type Server = McpServer<any, StorybookContext>;
+type ToolEnabled = Parameters<Server['tool']>[0]['enabled'];
+/**
+ * What an embedder needs to register one of these tools on its own server.
+ *
+ * The type is written out rather than inferred: the schemas come from the bundled core toolset, so
+ * an inferred signature would name valibot types this package's `.d.ts` cannot reference.
+ */
+type DocsToolMetadata = {
+  name: string;
+  title: string;
+  description: string;
+  schema: GenericSchema;
+  outputSchema?: GenericSchema;
+};
+declare function getListAllDocumentationToolMetadata(options?: {
+  multiSource?: boolean;
+}): DocsToolMetadata;
+declare function getDocumentationToolMetadata(options?: {
+  multiSource?: boolean;
+}): DocsToolMetadata;
+declare function getStoryDocumentationToolMetadata(options?: {
+  multiSource?: boolean;
+}): DocsToolMetadata;
+declare function addListAllDocumentationTool(server: Server, enabled?: ToolEnabled, options?: {
+  multiSource?: boolean;
+}): Promise<void>;
+declare function addGetDocumentationTool(server: Server, enabled?: ToolEnabled, options?: {
+  multiSource?: boolean;
+}): Promise<void>;
+declare function addGetStoryDocumentationTool(server: Server, enabled?: ToolEnabled, options?: {
+  multiSource?: boolean;
+}): Promise<void>;
+//#endregion
+//#region .dts-emit/code/core/src/mcp/utils/multi-source-manifests.d.ts
+/**
+ * Fetches every source's manifests, capturing a failure as that source's own outcome rather than
+ * losing the whole listing. Throws only when no source produced anything usable.
+ */
+declare function getMultiSourceManifests(sources: Source$1[], request?: Request, manifestProvider?: ManifestProvider): Promise<SourceManifests[]>;
+//#endregion
+//#region .dts-emit/code/core/src/mcp/index.d.ts
+type InitializeRequestParams = {
+  protocolVersion: string;
+  capabilities: {
+    experimental?: {} | undefined;
+    sampling?: {} | undefined;
+    elicitation?: {} | undefined;
+    roots?: {
+      listChanged?: boolean | undefined;
+    } | undefined;
+  };
+  clientInfo: {
+    icons?: {
+      src: string;
+      mimeType?: string | undefined;
+      sizes?: string[] | undefined;
+    }[] | undefined;
+    version: string;
+    websiteUrl?: string | undefined;
+    name: string;
+    title?: string | undefined;
+  };
+};
+/**
+ * Options for creating a Forkbook MCP handler.
+ * Extends StorybookContext with server-level configuration.
+ */
+interface StorybookMcpHandlerOptions extends StorybookContext {
+  /**
+   * Optional handler called when an MCP session is initialized.
+   * This is only valid at the handler creation level, not per-request.
+   * Receives the initialize request parameters from the MCP protocol.
+   */
+  onSessionInitialize?: (initializeRequestParams: InitializeRequestParams) => void | Promise<void>;
+}
+type Handler = (req: Request, context?: StorybookContext) => Promise<Response>;
+declare const createStorybookMcpHandler: (options?: StorybookMcpHandlerOptions) => Promise<Handler>;
+//#endregion
+export { COMPONENT_MANIFEST_PATH, type ComponentManifest, type ComponentManifestMap, type CoreDocgenComponent, type CoreDocgenPayload, type CoreMdxDoc, type CoreMdxPayload, type CoreStoryDoc, type CoreStoryDocsPayload, DOCS_MANIFEST_PATH, type Doc, type DocsManifestMap, FORKBOOK_MCP_INSTRUCTIONS, GET_STORY_TOOL_NAME, GET_TOOL_NAME, LIST_TOOL_NAME, RequiresOwnMcpError, type RequiresOwnMcpNotice, type ResolvedEntry, type Source, type SourceManifests, type Story, type StorybookContext, StorybookMcpHandlerOptions, adaptCoreComponent, adaptCoreDoc, adaptCoreStories, addGetDocumentationTool, addGetStoryDocumentationTool, addListAllDocumentationTool, createStorybookMcpHandler, getDocumentationToolMetadata, getListAllDocumentationToolMetadata, getMultiSourceManifests, getStoryDocumentationToolMetadata, resolveComponentEntry, resolveComponentStories, resolveDoc };

package/dist/mcp/index.js

@@ -0,0 +1,305 @@
+import CJS_COMPAT_NODE_URL_ro17f80mg6k from 'node:url';
+import CJS_COMPAT_NODE_PATH_ro17f80mg6k from 'node:path';
+import CJS_COMPAT_NODE_MODULE_ro17f80mg6k from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_ro17f80mg6k.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_ro17f80mg6k.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_ro17f80mg6k.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Forkbook's esbuild configuration
+// ------------------------------------------------------------
+import {
+  package_default
+} from "../_node-chunks/chunk-TFEWM4E3.js";
+import "../_node-chunks/chunk-CXRU72ET.js";
+
+// src/mcp/index.ts
+import { McpServer } from "tmcp";
+import { ValibotJsonSchemaAdapter } from "@tmcp/adapter-valibot";
+import { HttpTransport } from "@tmcp/transport-http";
+
+// src/mcp/tools/register.ts
+import {
+  createCompositionDocsSources as createCompositionDocsSources2,
+  createDocsToolset,
+  createProviderDocsAccess,
+  emptyManifests,
+  selectReportedManifests,
+  ManifestGetError as ManifestGetError2,
+  RequiresOwnMcpError as RequiresOwnMcpError2,
+  resolveToolsetDescription,
+  toMcpToolName
+} from "@aussieljk/forkbook/internal/toolsets-docs";
+
+// src/mcp/utils/error-to-mcp-content.ts
+import {
+  formatRequiresOwnMcpNotice,
+  ManifestGetError,
+  RequiresOwnMcpError
+} from "@aussieljk/forkbook/internal/toolsets-docs";
+var errorToMCPContent = (error) => {
+  if (error instanceof RequiresOwnMcpError)
+    return {
+      content: [{ type: "text", text: formatRequiresOwnMcpNotice(error.source, error.endpoint) }]
+    };
+  let errorPrefix = error instanceof ManifestGetError ? "Error getting manifest" : "Unexpected error", errorMessage = error instanceof Error ? error.message : String(error), fullMessage = `${errorPrefix}: ${errorMessage}`;
+  if (error instanceof ManifestGetError && error.cause) {
+    let causeMessage = error.cause instanceof Error ? error.cause.message : String(error.cause);
+    fullMessage += `
+Caused by: ${causeMessage}`;
+  }
+  return {
+    content: [{ type: "text", text: fullMessage }],
+    isError: !0
+  };
+};
+
+// src/mcp/utils/multi-source-manifests.ts
+import {
+  createCompositionDocsSources,
+  listSources
+} from "@aussieljk/forkbook/internal/toolsets-docs";
+function toSourceManifests(listing) {
+  let { source, manifests, error, notice } = listing;
+  return {
+    source,
+    componentManifest: manifests?.componentManifest ?? { v: 1, components: {} },
+    ...manifests?.docsManifest ? { docsManifest: manifests.docsManifest } : {},
+    ...error ? { error } : {},
+    ...notice ? { notice } : {}
+  };
+}
+async function getMultiSourceManifests(sources, request, manifestProvider) {
+  return (await listSources(
+    createCompositionDocsSources({ sources, manifestProvider, getRequest: () => request }),
+    { withStoryIds: !1 }
+  )).map(toSourceManifests);
+}
+
+// src/mcp/tools/register.ts
+var LIST_TOOL_NAME = toMcpToolName("docs.list"), GET_TOOL_NAME = toMcpToolName("docs.show"), GET_STORY_TOOL_NAME = toMcpToolName("docs.showStory"), ctx = {
+  transport: "mcp",
+  getService: () => {
+    throw new Error("Open services are not available in a hosted Forkbook.");
+  }
+};
+function getSources(context) {
+  let sources = context?.sources;
+  if (sources?.some((source) => source.url))
+    return createCompositionDocsSources2({
+      sources,
+      manifestProvider: context?.manifestProvider,
+      getRequest: () => context?.request,
+      resolveEntry: context?.resolveEntry
+    });
+}
+function toolsetFor(context) {
+  let sources = getSources(context);
+  return sources ? createDocsToolset({ sources }) : createDocsToolset({
+    docsAccess: createProviderDocsAccess({
+      manifestProvider: context?.manifestProvider,
+      getRequest: () => context?.request,
+      resolveEntry: context?.resolveEntry
+    })
+  });
+}
+function metadataToolset(multiSource) {
+  let unavailable = { list: async () => emptyManifests(), resolve: async () => {
+  } };
+  return multiSource ? createDocsToolset({
+    sources: [{ source: { id: "local", title: "Local" }, access: unavailable }]
+  }) : createDocsToolset({ docsAccess: unavailable });
+}
+function toolMetadata(method, multiSource) {
+  let [, methodName] = method.split("."), definition = metadataToolset(multiSource).methods[methodName], outputSchema = outputSchemaOf(definition);
+  return {
+    name: toMcpToolName(method),
+    title: definition.title,
+    description: resolveToolsetDescription(definition.description, ctx),
+    schema: definition.input,
+    ...outputSchema ? { outputSchema } : {}
+  };
+}
+function getListAllDocumentationToolMetadata(options) {
+  return toolMetadata("docs.list", !!options?.multiSource);
+}
+function getDocumentationToolMetadata(options) {
+  return toolMetadata("docs.show", !!options?.multiSource);
+}
+function getStoryDocumentationToolMetadata(options) {
+  return toolMetadata("docs.showStory", !!options?.multiSource);
+}
+function registerTool(server, metadata, handler) {
+  server.tool(metadata, handler);
+}
+function outputSchemaOf(definition) {
+  return definition.output;
+}
+function isAgentFacingError(error) {
+  return error instanceof Error && error.agentFacing === !0;
+}
+async function toStructuredContent(outputSchema, data) {
+  if (!outputSchema || data === void 0)
+    return;
+  let result = await outputSchema["~standard"].validate(data);
+  if (result.issues) {
+    let serialized;
+    try {
+      serialized = JSON.stringify(result.issues)?.slice(0, 2e3) ?? String(result.issues);
+    } catch {
+      serialized = `${result.issues.length} issue(s) that could not be serialized`;
+    }
+    throw new Error(`Toolset output did not match its published output schema: ${serialized}`);
+  }
+  return result.value;
+}
+async function call(server, method, input) {
+  let context = server.ctx.custom;
+  try {
+    let definition = toolsetFor(context).methods[method], outcome = await definition.handler(input, ctx), structuredContent = await toStructuredContent(outputSchemaOf(definition), outcome.data), blocks = Array.isArray(outcome.markdown) ? outcome.markdown : [outcome.markdown];
+    return {
+      data: outcome.data,
+      result: {
+        content: blocks.map((text) => ({ type: "text", text })),
+        ...structuredContent !== void 0 ? { structuredContent } : {},
+        ...outcome.ok ? {} : { isError: !0 }
+      }
+    };
+  } catch (error) {
+    return isAgentFacingError(error) ? {
+      data: void 0,
+      result: {
+        content: [{ type: "text", text: error.message }],
+        isError: !0
+      }
+    } : (!(error instanceof RequiresOwnMcpError2) && !(error instanceof ManifestGetError2) && console.error(error), { data: void 0, result: errorToMCPContent(error) });
+  }
+}
+async function addListAllDocumentationTool(server, enabled, options) {
+  registerTool(
+    server,
+    { ...getListAllDocumentationToolMetadata(options), enabled },
+    async (input) => {
+      let context = server.ctx.custom, { data, result } = await call(server, "list", input), listing = data, manifests = listing && selectReportedManifests(listing);
+      return manifests && await context?.onListAllDocumentation?.({
+        context,
+        manifests,
+        resultText: result.content[0].text,
+        ...listing?.sources ? { sources: listing.sources.map(toSourceManifests) } : {}
+      }), result;
+    }
+  );
+}
+async function addGetDocumentationTool(server, enabled, options) {
+  registerTool(
+    server,
+    { ...getDocumentationToolMetadata(options), enabled },
+    async (input) => {
+      let context = server.ctx.custom, { data, result } = await call(server, "show", input);
+      if (data) {
+        let { entry } = data, found = entry ? entry.kind === "component" ? entry.component : entry.doc : void 0;
+        await context?.onGetDocumentation?.(
+          found ? {
+            context,
+            input,
+            foundDocumentation: found,
+            resultText: result.content[0].text
+          } : { context, input }
+        );
+      }
+      return result;
+    }
+  );
+}
+async function addGetStoryDocumentationTool(server, enabled, options) {
+  registerTool(
+    server,
+    { ...getStoryDocumentationToolMetadata(options), enabled },
+    async (input) => (await call(server, "showStory", input)).result
+  );
+}
+
+// src/mcp/index.ts
+import { DOCS_TOOLSET_INSTRUCTIONS as serverInstructions } from "@aussieljk/forkbook/internal/toolsets-docs";
+import {
+  adaptCoreComponent,
+  adaptCoreDoc,
+  adaptCoreStories,
+  COMPONENT_MANIFEST_PATH,
+  DOCS_MANIFEST_PATH,
+  RequiresOwnMcpError as RequiresOwnMcpError3,
+  resolveComponentEntry,
+  resolveComponentStories,
+  resolveDocEntry
+} from "@aussieljk/forkbook/internal/toolsets-docs";
+
+// src/mcp/types.ts
+import * as v from "valibot";
+import {
+  ComponentManifestMap,
+  ComponentManifestMapV0,
+  ComponentManifestMapV1,
+  DocsManifestMap,
+  DocsManifestMapV0,
+  DocsManifestMapV1,
+  JsonRef
+} from "@aussieljk/forkbook/internal/toolsets-docs";
+var StorybookIdField = {
+  storybookId: v.pipe(
+    v.string(),
+    v.description(
+      'The Forkbook source ID (e.g., "local", "tetra"). Required when multiple Storybooks are composed. See docs-list for available sources.'
+    )
+  )
+};
+
+// src/mcp/index.ts
+var createStorybookMcpHandler = async (options = {}) => {
+  let { onSessionInitialize, ...defaultContext } = options, adapter = new ValibotJsonSchemaAdapter(), server = new McpServer(
+    {
+      name: `${package_default.name}/mcp`,
+      version: package_default.version,
+      description: "MCP server that serves knowledge about your components based on your stories and documentation"
+    },
+    {
+      adapter,
+      instructions: serverInstructions,
+      capabilities: {
+        tools: { listChanged: !0 }
+      }
+    }
+  ).withContext();
+  onSessionInitialize && server.on("initialize", onSessionInitialize), await addListAllDocumentationTool(server), await addGetStoryDocumentationTool(server), await addGetDocumentationTool(server);
+  let transport = new HttpTransport(server, { path: null });
+  return (async (req, context) => await transport.respond(req, {
+    ...defaultContext,
+    ...context,
+    request: req
+  }));
+};
+export {
+  COMPONENT_MANIFEST_PATH,
+  ComponentManifestMap,
+  DOCS_MANIFEST_PATH,
+  DocsManifestMap,
+  serverInstructions as FORKBOOK_MCP_INSTRUCTIONS,
+  GET_STORY_TOOL_NAME,
+  GET_TOOL_NAME,
+  LIST_TOOL_NAME,
+  RequiresOwnMcpError3 as RequiresOwnMcpError,
+  adaptCoreComponent,
+  adaptCoreDoc,
+  adaptCoreStories,
+  addGetDocumentationTool,
+  addGetStoryDocumentationTool,
+  addListAllDocumentationTool,
+  createStorybookMcpHandler,
+  getDocumentationToolMetadata,
+  getListAllDocumentationToolMetadata,
+  getMultiSourceManifests,
+  getStoryDocumentationToolMetadata,
+  resolveComponentEntry,
+  resolveComponentStories,
+  resolveDocEntry as resolveDoc
+};