@atlascompiler/mcp 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,595 @@
+import { ReadResourceResult, ResourceTemplate, McpServer } from '@modelcontextprotocol/server';
+export { WebStandardStreamableHTTPServerTransport, createMcpHandler, validateHostHeader } from '@modelcontextprotocol/server';
+import { z } from 'zod';
+
+/**
+ * Atlas Model Context Protocol (MCP) Shared Types
+ */
+interface AtlasClientContext {
+    apiKey?: string;
+    workspaceId?: string;
+    userId?: string;
+    baseUrl?: string;
+    fetch?: typeof fetch;
+}
+interface AtlasScrapeArgs {
+    url: string;
+    formats?: ('markdown' | 'links' | 'text')[];
+    max_output_chars?: number;
+    timeout_ms?: number;
+}
+interface AtlasScrapeResult {
+    url: string;
+    title: string;
+    markdown?: string;
+    text?: string;
+    links?: Array<{
+        url: string;
+        text: string;
+    }>;
+    stats: {
+        character_count: number;
+        word_count: number;
+        read_time_seconds: number;
+    };
+    truncated: boolean;
+    resource_uri?: string;
+}
+interface AtlasCompileArgs {
+    url: string;
+    format?: 'markdown' | 'semantic' | 'markdown+links';
+    max_output_chars?: number;
+    force_fresh?: boolean;
+}
+interface AtlasHeading {
+    level: number;
+    text: string;
+    id?: string;
+    resource_uri?: string;
+}
+interface AtlasCompileResult {
+    url: string;
+    compilation_id: string;
+    title: string;
+    markdown?: string;
+    ast?: Record<string, unknown>;
+    headings?: AtlasHeading[];
+    resources: {
+        compiled_artifact_uri: string;
+        ast_uri?: string;
+    };
+    stats: {
+        character_count: number;
+        tokens_saved_pct?: number;
+        compilation_time_ms: number;
+    };
+    truncated: boolean;
+}
+interface AtlasMapArgs {
+    url: string;
+    limit?: number;
+    include_subdomains?: boolean;
+    sitemap?: 'include' | 'skip' | 'only';
+}
+interface AtlasMapResult {
+    root_url: string;
+    urls: string[];
+    count: number;
+    sitemaps_found: string[];
+    duration_ms: number;
+}
+interface AtlasBatchCompileArgs {
+    urls: string[];
+    format?: 'markdown' | 'semantic' | 'markdown+links';
+    max_output_chars_per_page?: number;
+}
+interface AtlasBatchItemResult {
+    url: string;
+    status: 'success' | 'failed';
+    compilation_id?: string;
+    title?: string;
+    markdown?: string;
+    resource_uri?: string;
+    character_count?: number;
+    error?: string;
+}
+interface AtlasBatchCompileResult {
+    total_requested: number;
+    successful: number;
+    failed: number;
+    results: AtlasBatchItemResult[];
+}
+interface AtlasCrawlArgs {
+    url: string;
+    max_pages?: number;
+    max_depth?: number;
+    include_paths?: string[];
+    exclude_paths?: string[];
+}
+interface AtlasCrawlPageResult {
+    url: string;
+    title: string;
+    depth: number;
+    compilation_id?: string;
+    resource_uri: string;
+    character_count?: number;
+}
+interface AtlasCrawlResult {
+    crawl_id: string;
+    root_url: string;
+    pages_crawled: number;
+    pages_failed: number;
+    summary_markdown: string;
+    pages: AtlasCrawlPageResult[];
+    duration_ms: number;
+}
+
+/**
+ * Atlas MCP Error Codes and Standardized Error Formatting
+ */
+type AtlasMcpErrorCode = 'ATLAS_INVALID_URL' | 'ATLAS_SSRF_BLOCKED' | 'ATLAS_FETCH_TIMEOUT' | 'ATLAS_FETCH_HTTP_ERROR' | 'ATLAS_RATE_LIMITED' | 'ATLAS_UNAUTHORIZED' | 'ATLAS_QUOTA_EXCEEDED' | 'ATLAS_JOB_FAILED' | 'ATLAS_RESOURCE_NOT_FOUND' | 'ATLAS_INTERNAL_ERROR';
+interface AtlasMcpErrorPayload {
+    code: AtlasMcpErrorCode;
+    message: string;
+    retryable: boolean;
+    retryAfterSeconds?: number;
+    details?: unknown;
+}
+declare class AtlasMcpError extends Error {
+    readonly code: AtlasMcpErrorCode;
+    readonly retryable: boolean;
+    readonly retryAfterSeconds?: number;
+    readonly details?: unknown;
+    constructor(payload: AtlasMcpErrorPayload);
+    toToolErrorResult(): {
+        isError: boolean;
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            error: {
+                code: AtlasMcpErrorCode;
+                message: string;
+                retryable: boolean;
+                retry_after_seconds: number | undefined;
+                details: unknown;
+            };
+        };
+    };
+}
+declare function wrapFetchError(err: unknown): AtlasMcpError;
+declare function assertOkResponse(response: Response): Promise<void>;
+declare function formatErrorToToolResult(err: unknown): {
+    isError: boolean;
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredContent: {
+        error: {
+            code: AtlasMcpErrorCode;
+            message: string;
+            retryable: boolean;
+            retry_after_seconds: number | undefined;
+            details: unknown;
+        };
+    };
+} | {
+    isError: boolean;
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredContent: {
+        error: {
+            code: string;
+            message: string;
+            retryable: boolean;
+        };
+    };
+};
+
+declare const compilationResourceTemplate: ResourceTemplate;
+declare const sectionResourceTemplate: ResourceTemplate;
+declare const crawlResourceTemplate: ResourceTemplate;
+declare const astResourceTemplate: ResourceTemplate;
+type ResourceContentItem = {
+    uri: string;
+    text: string;
+    mimeType?: string;
+} | {
+    uri: string;
+    blob: string;
+    mimeType?: string;
+};
+type ResourceReadResult = ReadResourceResult;
+type ResourceReader = (uri: string, variables: Record<string, string>) => Promise<ResourceReadResult>;
+declare function createRemoteResourceReader(context: AtlasClientContext): ResourceReader;
+
+declare const batchInputSchema: {
+    urls: z.ZodArray<z.ZodString>;
+    format: z.ZodDefault<z.ZodEnum<{
+        markdown: "markdown";
+        semantic: "semantic";
+        "markdown+links": "markdown+links";
+    }>>;
+    max_output_chars_per_page: z.ZodDefault<z.ZodNumber>;
+};
+declare const batchOutputSchema: {
+    total_requested: z.ZodNumber;
+    successful: z.ZodNumber;
+    failed: z.ZodNumber;
+    results: z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        status: z.ZodEnum<{
+            success: "success";
+            failed: "failed";
+        }>;
+        compilation_id: z.ZodOptional<z.ZodString>;
+        title: z.ZodOptional<z.ZodString>;
+        markdown: z.ZodOptional<z.ZodString>;
+        resource_uri: z.ZodOptional<z.ZodString>;
+        character_count: z.ZodOptional<z.ZodNumber>;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+};
+declare const batchToolDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        urls: z.ZodArray<z.ZodString>;
+        format: z.ZodDefault<z.ZodEnum<{
+            markdown: "markdown";
+            semantic: "semantic";
+            "markdown+links": "markdown+links";
+        }>>;
+        max_output_chars_per_page: z.ZodDefault<z.ZodNumber>;
+    };
+    outputSchema: {
+        total_requested: z.ZodNumber;
+        successful: z.ZodNumber;
+        failed: z.ZodNumber;
+        results: z.ZodArray<z.ZodObject<{
+            url: z.ZodString;
+            status: z.ZodEnum<{
+                success: "success";
+                failed: "failed";
+            }>;
+            compilation_id: z.ZodOptional<z.ZodString>;
+            title: z.ZodOptional<z.ZodString>;
+            markdown: z.ZodOptional<z.ZodString>;
+            resource_uri: z.ZodOptional<z.ZodString>;
+            character_count: z.ZodOptional<z.ZodNumber>;
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    };
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        openWorldHint: boolean;
+        idempotentHint: boolean;
+    };
+    cacheHint: {
+        ttlMs: number;
+        cacheScope: "private";
+    };
+};
+type BatchExecutor = (args: AtlasBatchCompileArgs) => Promise<AtlasBatchCompileResult>;
+declare function createRemoteBatchExecutor(context: AtlasClientContext): BatchExecutor;
+declare function formatBatchResult(res: AtlasBatchCompileResult): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredContent: AtlasBatchCompileResult;
+};
+
+declare const compileInputSchema: {
+    url: z.ZodString;
+    format: z.ZodDefault<z.ZodEnum<{
+        markdown: "markdown";
+        semantic: "semantic";
+        "markdown+links": "markdown+links";
+    }>>;
+    max_output_chars: z.ZodDefault<z.ZodNumber>;
+    force_fresh: z.ZodDefault<z.ZodBoolean>;
+};
+declare const compileOutputSchema: {
+    url: z.ZodString;
+    compilation_id: z.ZodString;
+    title: z.ZodString;
+    markdown: z.ZodOptional<z.ZodString>;
+    ast: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    headings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        level: z.ZodNumber;
+        text: z.ZodString;
+        id: z.ZodOptional<z.ZodString>;
+        resource_uri: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    resources: z.ZodObject<{
+        compiled_artifact_uri: z.ZodString;
+        ast_uri: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    stats: z.ZodObject<{
+        character_count: z.ZodNumber;
+        tokens_saved_pct: z.ZodOptional<z.ZodNumber>;
+        compilation_time_ms: z.ZodNumber;
+    }, z.core.$strip>;
+    truncated: z.ZodBoolean;
+};
+declare const compileToolDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        url: z.ZodString;
+        format: z.ZodDefault<z.ZodEnum<{
+            markdown: "markdown";
+            semantic: "semantic";
+            "markdown+links": "markdown+links";
+        }>>;
+        max_output_chars: z.ZodDefault<z.ZodNumber>;
+        force_fresh: z.ZodDefault<z.ZodBoolean>;
+    };
+    outputSchema: {
+        url: z.ZodString;
+        compilation_id: z.ZodString;
+        title: z.ZodString;
+        markdown: z.ZodOptional<z.ZodString>;
+        ast: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        headings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            level: z.ZodNumber;
+            text: z.ZodString;
+            id: z.ZodOptional<z.ZodString>;
+            resource_uri: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        resources: z.ZodObject<{
+            compiled_artifact_uri: z.ZodString;
+            ast_uri: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        stats: z.ZodObject<{
+            character_count: z.ZodNumber;
+            tokens_saved_pct: z.ZodOptional<z.ZodNumber>;
+            compilation_time_ms: z.ZodNumber;
+        }, z.core.$strip>;
+        truncated: z.ZodBoolean;
+    };
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        openWorldHint: boolean;
+        idempotentHint: boolean;
+    };
+    cacheHint: {
+        ttlMs: number;
+        cacheScope: "private";
+    };
+};
+type CompileExecutor = (args: AtlasCompileArgs) => Promise<AtlasCompileResult>;
+declare function createRemoteCompileExecutor(context: AtlasClientContext): CompileExecutor;
+declare function formatCompileResult(res: AtlasCompileResult): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredContent: AtlasCompileResult;
+};
+
+declare const crawlInputSchema: {
+    url: z.ZodString;
+    max_pages: z.ZodDefault<z.ZodNumber>;
+    max_depth: z.ZodDefault<z.ZodNumber>;
+    include_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exclude_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+};
+declare const crawlOutputSchema: {
+    crawl_id: z.ZodString;
+    root_url: z.ZodString;
+    pages_crawled: z.ZodNumber;
+    pages_failed: z.ZodNumber;
+    summary_markdown: z.ZodString;
+    pages: z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        title: z.ZodString;
+        depth: z.ZodNumber;
+        compilation_id: z.ZodOptional<z.ZodString>;
+        resource_uri: z.ZodString;
+        character_count: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    duration_ms: z.ZodNumber;
+};
+declare const crawlToolDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        url: z.ZodString;
+        max_pages: z.ZodDefault<z.ZodNumber>;
+        max_depth: z.ZodDefault<z.ZodNumber>;
+        include_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        exclude_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    };
+    outputSchema: {
+        crawl_id: z.ZodString;
+        root_url: z.ZodString;
+        pages_crawled: z.ZodNumber;
+        pages_failed: z.ZodNumber;
+        summary_markdown: z.ZodString;
+        pages: z.ZodArray<z.ZodObject<{
+            url: z.ZodString;
+            title: z.ZodString;
+            depth: z.ZodNumber;
+            compilation_id: z.ZodOptional<z.ZodString>;
+            resource_uri: z.ZodString;
+            character_count: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        duration_ms: z.ZodNumber;
+    };
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        openWorldHint: boolean;
+        idempotentHint: boolean;
+    };
+    cacheHint: {
+        ttlMs: number;
+        cacheScope: "private";
+    };
+};
+type CrawlExecutor = (args: AtlasCrawlArgs) => Promise<AtlasCrawlResult>;
+declare function createRemoteCrawlExecutor(context: AtlasClientContext): CrawlExecutor;
+declare function formatCrawlResult(res: AtlasCrawlResult): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredContent: AtlasCrawlResult;
+};
+
+declare const mapInputSchema: {
+    url: z.ZodString;
+    limit: z.ZodDefault<z.ZodNumber>;
+    include_subdomains: z.ZodDefault<z.ZodBoolean>;
+    sitemap: z.ZodDefault<z.ZodEnum<{
+        skip: "skip";
+        include: "include";
+        only: "only";
+    }>>;
+};
+declare const mapOutputSchema: {
+    root_url: z.ZodString;
+    urls: z.ZodArray<z.ZodString>;
+    count: z.ZodNumber;
+    sitemaps_found: z.ZodArray<z.ZodString>;
+    duration_ms: z.ZodNumber;
+};
+declare const mapToolDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        url: z.ZodString;
+        limit: z.ZodDefault<z.ZodNumber>;
+        include_subdomains: z.ZodDefault<z.ZodBoolean>;
+        sitemap: z.ZodDefault<z.ZodEnum<{
+            skip: "skip";
+            include: "include";
+            only: "only";
+        }>>;
+    };
+    outputSchema: {
+        root_url: z.ZodString;
+        urls: z.ZodArray<z.ZodString>;
+        count: z.ZodNumber;
+        sitemaps_found: z.ZodArray<z.ZodString>;
+        duration_ms: z.ZodNumber;
+    };
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        openWorldHint: boolean;
+        idempotentHint: boolean;
+    };
+    cacheHint: {
+        ttlMs: number;
+        cacheScope: "private";
+    };
+};
+type MapExecutor = (args: AtlasMapArgs) => Promise<AtlasMapResult>;
+declare function createRemoteMapExecutor(context: AtlasClientContext): MapExecutor;
+declare function formatMapResult(res: AtlasMapResult): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredContent: AtlasMapResult;
+};
+
+declare const scrapeInputSchema: {
+    url: z.ZodString;
+    formats: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        text: "text";
+        markdown: "markdown";
+        links: "links";
+    }>>>;
+    max_output_chars: z.ZodDefault<z.ZodNumber>;
+    timeout_ms: z.ZodDefault<z.ZodNumber>;
+};
+declare const scrapeOutputSchema: {
+    url: z.ZodString;
+    title: z.ZodString;
+    markdown: z.ZodOptional<z.ZodString>;
+    text: z.ZodOptional<z.ZodString>;
+    links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strip>>>;
+    stats: z.ZodObject<{
+        character_count: z.ZodNumber;
+        word_count: z.ZodNumber;
+        read_time_seconds: z.ZodNumber;
+    }, z.core.$strip>;
+    truncated: z.ZodBoolean;
+    resource_uri: z.ZodOptional<z.ZodString>;
+};
+declare const scrapeToolDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        url: z.ZodString;
+        formats: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            text: "text";
+            markdown: "markdown";
+            links: "links";
+        }>>>;
+        max_output_chars: z.ZodDefault<z.ZodNumber>;
+        timeout_ms: z.ZodDefault<z.ZodNumber>;
+    };
+    outputSchema: {
+        url: z.ZodString;
+        title: z.ZodString;
+        markdown: z.ZodOptional<z.ZodString>;
+        text: z.ZodOptional<z.ZodString>;
+        links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            url: z.ZodString;
+            text: z.ZodString;
+        }, z.core.$strip>>>;
+        stats: z.ZodObject<{
+            character_count: z.ZodNumber;
+            word_count: z.ZodNumber;
+            read_time_seconds: z.ZodNumber;
+        }, z.core.$strip>;
+        truncated: z.ZodBoolean;
+        resource_uri: z.ZodOptional<z.ZodString>;
+    };
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        openWorldHint: boolean;
+        idempotentHint: boolean;
+    };
+    cacheHint: {
+        ttlMs: number;
+        cacheScope: "private";
+    };
+};
+type ScrapeExecutor = (args: AtlasScrapeArgs) => Promise<AtlasScrapeResult>;
+declare function createRemoteScrapeExecutor(context: AtlasClientContext): ScrapeExecutor;
+declare function formatScrapeResult(res: AtlasScrapeResult): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredContent: AtlasScrapeResult;
+};
+
+interface CreateAtlasMcpServerOptions {
+    context?: AtlasClientContext;
+    scrapeExecutor?: ScrapeExecutor;
+    compileExecutor?: CompileExecutor;
+    mapExecutor?: MapExecutor;
+    batchExecutor?: BatchExecutor;
+    crawlExecutor?: CrawlExecutor;
+    resourceReader?: ResourceReader;
+}
+declare function createAtlasMcpServer(options?: CreateAtlasMcpServerOptions): McpServer;
+
+export { type AtlasBatchCompileArgs, type AtlasBatchCompileResult, type AtlasBatchItemResult, type AtlasClientContext, type AtlasCompileArgs, type AtlasCompileResult, type AtlasCrawlArgs, type AtlasCrawlPageResult, type AtlasCrawlResult, type AtlasHeading, type AtlasMapArgs, type AtlasMapResult, AtlasMcpError, type AtlasMcpErrorCode, type AtlasMcpErrorPayload, type AtlasScrapeArgs, type AtlasScrapeResult, type BatchExecutor, type CompileExecutor, type CrawlExecutor, type CreateAtlasMcpServerOptions, type MapExecutor, type ResourceContentItem, type ResourceReadResult, type ResourceReader, type ScrapeExecutor, assertOkResponse, astResourceTemplate, batchInputSchema, batchOutputSchema, batchToolDefinition, compilationResourceTemplate, compileInputSchema, compileOutputSchema, compileToolDefinition, crawlInputSchema, crawlOutputSchema, crawlResourceTemplate, crawlToolDefinition, createAtlasMcpServer, createRemoteBatchExecutor, createRemoteCompileExecutor, createRemoteCrawlExecutor, createRemoteMapExecutor, createRemoteResourceReader, createRemoteScrapeExecutor, formatBatchResult, formatCompileResult, formatCrawlResult, formatErrorToToolResult, formatMapResult, formatScrapeResult, mapInputSchema, mapOutputSchema, mapToolDefinition, scrapeInputSchema, scrapeOutputSchema, scrapeToolDefinition, sectionResourceTemplate, wrapFetchError };

package/dist/index.js

@@ -0,0 +1,84 @@
+import {
+  AtlasMcpError,
+  assertOkResponse,
+  astResourceTemplate,
+  batchInputSchema,
+  batchOutputSchema,
+  batchToolDefinition,
+  compilationResourceTemplate,
+  compileInputSchema,
+  compileOutputSchema,
+  compileToolDefinition,
+  crawlInputSchema,
+  crawlOutputSchema,
+  crawlResourceTemplate,
+  crawlToolDefinition,
+  createAtlasMcpServer,
+  createRemoteBatchExecutor,
+  createRemoteCompileExecutor,
+  createRemoteCrawlExecutor,
+  createRemoteMapExecutor,
+  createRemoteResourceReader,
+  createRemoteScrapeExecutor,
+  formatBatchResult,
+  formatCompileResult,
+  formatCrawlResult,
+  formatErrorToToolResult,
+  formatMapResult,
+  formatScrapeResult,
+  mapInputSchema,
+  mapOutputSchema,
+  mapToolDefinition,
+  scrapeInputSchema,
+  scrapeOutputSchema,
+  scrapeToolDefinition,
+  sectionResourceTemplate,
+  wrapFetchError
+} from "./chunk-QNNAZCBS.js";
+
+// src/index.ts
+import {
+  createMcpHandler,
+  validateHostHeader,
+  WebStandardStreamableHTTPServerTransport
+} from "@modelcontextprotocol/server";
+export {
+  AtlasMcpError,
+  WebStandardStreamableHTTPServerTransport,
+  assertOkResponse,
+  astResourceTemplate,
+  batchInputSchema,
+  batchOutputSchema,
+  batchToolDefinition,
+  compilationResourceTemplate,
+  compileInputSchema,
+  compileOutputSchema,
+  compileToolDefinition,
+  crawlInputSchema,
+  crawlOutputSchema,
+  crawlResourceTemplate,
+  crawlToolDefinition,
+  createAtlasMcpServer,
+  createMcpHandler,
+  createRemoteBatchExecutor,
+  createRemoteCompileExecutor,
+  createRemoteCrawlExecutor,
+  createRemoteMapExecutor,
+  createRemoteResourceReader,
+  createRemoteScrapeExecutor,
+  formatBatchResult,
+  formatCompileResult,
+  formatCrawlResult,
+  formatErrorToToolResult,
+  formatMapResult,
+  formatScrapeResult,
+  mapInputSchema,
+  mapOutputSchema,
+  mapToolDefinition,
+  scrapeInputSchema,
+  scrapeOutputSchema,
+  scrapeToolDefinition,
+  sectionResourceTemplate,
+  validateHostHeader,
+  wrapFetchError
+};