deepspace 0.10.0 → 0.10.2

package/dist/documentation-server-core.d.ts

@@ -0,0 +1,11 @@
+import { D as DocumentationRuntimeData, a as DocumentationPageComponent, b as DocumentationSiteComponent } from './public-BGRX_Cjd.js';
+export { A as Accordion, c as AccordionGroup, C as Card, d as CodeGroup, e as DefaultDocumentation, f as DocumentationApp, g as DocumentationAppProps, h as DocumentationContent, i as DocumentationSiteProps, I as Info, N as Note, S as Step, j as Steps, T as Tab, k as Tabs, l as Tip, W as Warning } from './public-BGRX_Cjd.js';
+import 'react';
+
+declare function renderDocumentation({ data, Page, Site, }: {
+    data: DocumentationRuntimeData;
+    Page?: DocumentationPageComponent;
+    Site?: DocumentationSiteComponent;
+}): string;
+
+export { DocumentationPageComponent, DocumentationSiteComponent, renderDocumentation };

package/dist/{docs-server-core.js → documentation-server-core.js}

@@ -3,9 +3,9 @@ import {
   AccordionGroup,
   Card,
   CodeGroup,
-  DefaultDocs,
-  DocsApp,
-  DocsContent,
+  DefaultDocumentation,
+  DocumentationApp,
+  DocumentationContent,
   Info,
   Note,
   Step,
@@ -14,17 +14,17 @@ import {
   Tabs,
   Tip,
   Warning
-} from "./chunk-DQ4G6VL6.js";
+} from "./chunk-T7V4GUIN.js";
 
-// src/docs/runtime/server.tsx
+// src/documentation/runtime/server.tsx
 import { createElement } from "react";
 import { renderToString } from "react-dom/server";
-function renderDocs({
+function renderDocumentation({
   data,
   Page,
-  Site = DefaultDocs
+  Site = DefaultDocumentation
 }) {
-  const content = createElement(DocsContent, { data, Page });
+  const content = createElement(DocumentationContent, { data, Page });
   return renderToString(createElement(Site, { children: content, data }));
 }
 export {
@@ -32,9 +32,9 @@ export {
   AccordionGroup,
   Card,
   CodeGroup,
-  DefaultDocs,
-  DocsApp,
-  DocsContent,
+  DefaultDocumentation,
+  DocumentationApp,
+  DocumentationContent,
   Info,
   Note,
   Step,
@@ -43,6 +43,6 @@ export {
   Tabs,
   Tip,
   Warning,
-  renderDocs
+  renderDocumentation
 };
-//# sourceMappingURL=docs-server-core.js.map
+//# sourceMappingURL=documentation-server-core.js.map

package/dist/documentation-server-core.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/documentation/runtime/server.tsx"],"sourcesContent":["import { createElement, type ReactElement } from 'react'\nimport { renderToString } from 'react-dom/server'\nimport type { DocumentationRuntimeData } from '../types'\nimport {\n  DefaultDocumentation,\n  DocumentationContent,\n  type DocumentationPageComponent,\n  type DocumentationSiteComponent,\n} from './public'\nexport * from './public'\n\nexport function renderDocumentation({\n  data,\n  Page,\n  Site = DefaultDocumentation as DocumentationSiteComponent,\n}: {\n  data: DocumentationRuntimeData\n  Page?: DocumentationPageComponent\n  Site?: DocumentationSiteComponent\n}): string {\n  const content: ReactElement = createElement(DocumentationContent, { data, Page })\n  return renderToString(createElement(Site, { children: content, data }))\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA,SAAS,qBAAwC;AACjD,SAAS,sBAAsB;AAUxB,SAAS,oBAAoB;AAAA,EAClC;AAAA,EACA;AAAA,EACA,OAAO;AACT,GAIW;AACT,QAAM,UAAwB,cAAc,sBAAsB,EAAE,MAAM,KAAK,CAAC;AAChF,SAAO,eAAe,cAAc,MAAM,EAAE,UAAU,SAAS,KAAK,CAAC,CAAC;AACxE;","names":[]}

package/dist/documentation.d.ts

@@ -0,0 +1,366 @@
+declare const DOCUMENTATION_CONFIG_FILE = "documentation.json";
+declare const DOCUMENTATION_MANIFEST_VERSION = 2;
+type DocumentationAssistantAccess = 'disabled' | 'public' | 'authenticated';
+type DocumentationMcpAccess = 'disabled' | 'public';
+declare const DOCUMENTATION_CONTEXTUAL_ACTIONS: readonly ["copy", "view", "assistant", "chatgpt", "claude", "mcp", "add-mcp", "cursor", "vscode"];
+type DocumentationContextualAction = (typeof DOCUMENTATION_CONTEXTUAL_ACTIONS)[number];
+declare const DEFAULT_DOCUMENTATION_CONTEXTUAL_ACTIONS: readonly DocumentationContextualAction[];
+interface DocumentationFontConfig {
+    family: string;
+    weight?: number | string;
+    source?: string;
+    format?: string;
+}
+interface DocumentationThemeConfig {
+    preset?: string;
+    accent?: string;
+    background?: string;
+    backgroundDark?: string;
+    backgroundDecoration?: 'none' | 'gradient' | 'grid';
+    bodyFont?: DocumentationFontConfig;
+    headingFont?: DocumentationFontConfig;
+    monoFont?: DocumentationFontConfig;
+    codeBlockMode?: 'dark' | 'system';
+    eyebrowStyle?: 'section' | 'breadcrumbs' | 'none';
+    logo?: string;
+    logoDark?: string;
+    logoHref?: string;
+    favicon?: string;
+    defaultMode?: 'light' | 'dark' | 'system';
+    strictMode?: boolean;
+}
+interface DocumentationLinkConfig {
+    label: string;
+    href: string;
+}
+interface DocumentationNavGroup {
+    group: string;
+    pages: DocumentationNavigationItem[];
+}
+type DocumentationNavigationItem = string | DocumentationLinkConfig | DocumentationNavGroup;
+declare const DOCUMENTATION_OPENAPI_SAMPLE_LANGUAGES: readonly ["curl", "javascript", "python", "go"];
+type DocumentationOpenApiSampleLanguage = (typeof DOCUMENTATION_OPENAPI_SAMPLE_LANGUAGES)[number];
+type DocumentationOpenApiSampleDefaults = 'required' | 'all';
+interface DocumentationOpenApiExamplesConfig {
+    languages: DocumentationOpenApiSampleLanguage[];
+    defaults: DocumentationOpenApiSampleDefaults;
+    autogenerate: boolean;
+}
+declare const DEFAULT_DOCUMENTATION_OPENAPI_EXAMPLES: {
+    readonly languages: readonly ["curl", "python", "javascript", "go"];
+    readonly defaults: "all";
+    readonly autogenerate: true;
+};
+interface DocumentationOpenApiConfig {
+    source: string;
+    route?: string;
+    label?: string;
+    playground?: boolean;
+    baseUrl?: string;
+    examples?: DocumentationOpenApiExamplesConfig;
+}
+interface DocumentationAssistantConfig {
+    access: DocumentationAssistantAccess;
+    model?: string;
+    suggestions?: string[];
+}
+interface DocumentationMcpConfig {
+    access: DocumentationMcpAccess;
+}
+interface DocumentationContextualConfig {
+    actions: DocumentationContextualAction[];
+}
+interface DocumentationSeoConfig {
+    noindex?: boolean;
+    ogImage?: string;
+    metaTags?: Record<string, string>;
+}
+interface DocumentationConfig {
+    $schema?: string;
+    name: string;
+    description?: string;
+    source: string;
+    output: string;
+    url?: string;
+    /** Explicit custom hostnames that mount this documentation at `/`. */
+    domains: string[];
+    theme: DocumentationThemeConfig;
+    navigation?: DocumentationNavigationItem[];
+    links: DocumentationLinkConfig[];
+    footer: DocumentationLinkConfig[];
+    redirects: Record<string, string>;
+    openapi: DocumentationOpenApiConfig[];
+    assistant: DocumentationAssistantConfig;
+    mcp: DocumentationMcpConfig;
+    contextual: DocumentationContextualConfig;
+    seo: DocumentationSeoConfig;
+}
+interface DocumentationFrontmatter {
+    title?: string;
+    description?: string;
+    slug?: string;
+    hidden?: boolean;
+    noindex?: boolean;
+}
+interface DocumentationHeading {
+    depth: number;
+    id: string;
+    text: string;
+}
+interface DocumentationPage {
+    sourcePath: string;
+    relativePath: string;
+    route: string;
+    title: string;
+    description?: string;
+    hidden: boolean;
+    noindex: boolean;
+    markdown: string;
+    html: string;
+    text: string;
+    headings: DocumentationHeading[];
+    sourceFormat: 'markdown' | 'mdx' | 'generated';
+    kind: 'page' | 'openapi';
+    openapi?: DocumentationOpenApiOperation;
+}
+interface DocumentationNavigationPage {
+    kind: 'page';
+    route: string;
+    label: string;
+}
+interface DocumentationNavigationLink {
+    kind: 'link';
+    href: string;
+    label: string;
+}
+interface DocumentationNavigationGroup {
+    kind: 'group';
+    label: string;
+    items: DocumentationNavigationNode[];
+}
+type DocumentationNavigationNode = DocumentationNavigationPage | DocumentationNavigationLink | DocumentationNavigationGroup;
+interface DocumentationOpenApiParameter {
+    name: string;
+    in: string;
+    required: boolean;
+    description?: string;
+    schema?: unknown;
+    example?: unknown;
+}
+interface DocumentationOpenApiResponse {
+    status: string;
+    description: string;
+    schema?: unknown;
+}
+interface DocumentationOpenApiCodeSample {
+    language: string;
+    label: string;
+    syntax: string;
+    code: string;
+    generated: boolean;
+}
+interface DocumentationOpenApiOperation {
+    method: string;
+    path: string;
+    operationId: string;
+    summary: string;
+    description?: string;
+    tags: string[];
+    parameters: DocumentationOpenApiParameter[];
+    requestBody?: unknown;
+    responses: DocumentationOpenApiResponse[];
+    security?: unknown;
+    baseUrl?: string;
+    playground: boolean;
+    codeSamples: DocumentationOpenApiCodeSample[];
+}
+interface DocumentationSearchEntry {
+    route: string;
+    title: string;
+    description?: string;
+    headings: string[];
+    text: string;
+}
+interface DocumentationAssistantChunk {
+    id: string;
+    route: string;
+    title: string;
+    heading?: string;
+    text: string;
+}
+interface DocumentationGraph {
+    config: DocumentationConfig;
+    pages: DocumentationPage[];
+    navigation: DocumentationNavigationNode[];
+    sourceHash: string;
+}
+interface DocumentationBuildManifest {
+    version: typeof DOCUMENTATION_MANIFEST_VERSION;
+    sourceHash: string;
+    outputHash: string;
+    name: string;
+    pageCount: number;
+    /** Authored pages plus configured redirect entry points. */
+    routes: string[];
+    /** Exact non-HTML artifacts that may be served from the public mount. */
+    resources: string[];
+    assistant: DocumentationAssistantConfig;
+    mcp: DocumentationMcpConfig;
+    domains: string[];
+    /** Default public mount on the ordinary app hostname. */
+    basePath: string;
+}
+interface DocumentationDiagnostic {
+    code: string;
+    message: string;
+    file?: string;
+    line?: number;
+}
+interface DocumentationValidationResult {
+    appDir: string;
+    configPath: string;
+    sourceDir: string;
+    outputDir: string;
+    graph: DocumentationGraph;
+    warnings: DocumentationDiagnostic[];
+}
+interface DocumentationBuildResult extends DocumentationValidationResult {
+    manifest: DocumentationBuildManifest;
+    files: string[];
+}
+interface DocumentationRuntimePageLink {
+    route: string;
+    title: string;
+}
+interface DocumentationRuntimePage {
+    route: string;
+    title: string;
+    description?: string;
+    html: string;
+    headings: DocumentationHeading[];
+    kind: DocumentationPage['kind'];
+    markdownUrl: string;
+    openapi?: DocumentationOpenApiOperation;
+}
+interface DocumentationRuntimeData {
+    /** Public mount (`/docs` on an app host, empty on an explicit documentation domain). */
+    basePath: string;
+    config: Pick<DocumentationConfig, 'name' | 'description' | 'theme' | 'links' | 'footer' | 'assistant' | 'mcp' | 'contextual'>;
+    page: DocumentationRuntimePage;
+    navigation: DocumentationNavigationNode[];
+    breadcrumbs: string[];
+    previous?: DocumentationRuntimePageLink;
+    next?: DocumentationRuntimePageLink;
+}
+type DocumentationRuntimeRouteData = Omit<DocumentationRuntimeData, 'config' | 'navigation'>;
+/** Small per-route payload used by the hydrated documentation router. */
+interface DocumentationRuntimeRouteDocument {
+    canonical: string | null;
+    data: DocumentationRuntimeRouteData;
+    description: string | null;
+    openGraph: Record<'og:title' | 'og:description' | 'og:url', string | null>;
+    robots: string | null;
+    title: string;
+}
+declare class DocumentationError extends Error {
+    readonly code: string;
+    readonly diagnostics: DocumentationDiagnostic[];
+    constructor(message: string, code: string, diagnostics?: DocumentationDiagnostic[]);
+}
+
+interface BuildDocumentationOptions {
+    appDir: string;
+    outputDir?: string;
+    baseUrl?: string;
+    /** Public mount on the ordinary app host. Defaults to `/docs`. */
+    basePath?: string;
+}
+declare function buildDocumentation(options: BuildDocumentationOptions): DocumentationBuildResult;
+
+interface LoadedDocumentationConfig {
+    config: DocumentationConfig;
+    configPath: string;
+    sourceDir: string;
+    outputDir: string;
+    raw: string;
+    warnings: DocumentationDiagnostic[];
+}
+declare function loadDocumentationConfig(appDir: string): LoadedDocumentationConfig;
+
+declare function validateDocumentation(appDir: string): DocumentationValidationResult;
+
+/** Normalize and validate every public documentation route in one place. */
+declare function normalizeRoute(value: string): string;
+declare function routeFromRelativePath(relativePath: string): string;
+
+declare function slugify(value: string): string;
+
+interface ParsedMarkdown {
+    frontmatter: DocumentationFrontmatter;
+    markdown: string;
+    html: string;
+    text: string;
+    headings: DocumentationHeading[];
+}
+declare function parseMarkdown(source: string, file: string): ParsedMarkdown;
+declare function parseFrontmatter(source: string, file: string): {
+    frontmatter: DocumentationFrontmatter;
+    body: string;
+};
+
+declare function htmlToText(html: string): string;
+
+declare const AGENT_SKILLS_SCHEMA = "https://schemas.agentskills.io/discovery/0.2.0/schema.json";
+interface DocumentationSkillArtifacts {
+    name: string;
+    description: string;
+    markdown: string;
+    legacyIndex: Record<string, unknown>;
+    discoveryIndex: Record<string, unknown>;
+}
+/** Build one deterministic, installable skill from the same graph as the site. */
+declare function createDocumentationSkillArtifacts(graph: DocumentationGraph, baseUrl?: string, basePath?: string): DocumentationSkillArtifacts;
+declare function documentationSkillName(value: string): string;
+
+interface DocumentationViteServer {
+    restart(): Promise<void>;
+    watcher: {
+        add(paths: string[]): void;
+        on(event: 'all', handler: (event: string, path: string) => void): void;
+        on(event: 'ready', handler: () => void): void;
+    };
+    config: {
+        logger: {
+            info(message: string): void;
+            error(message: string): void;
+        };
+    };
+}
+/**
+ * Vite bridge for the app Worker's ASSETS binding.
+ *
+ * Both development and production write Vite's reserved public namespace so
+ * the Cloudflare ASSETS binding has one identical source in both environments.
+ * Documentation's feature metadata sets `run_worker_first = true`, leaving the
+ * app Worker as the single router while binding reads bypass it as assets.
+ */
+declare function deepSpaceDocumentation(): {
+    name: string;
+    config(config: {
+        root?: string;
+    }, _environment: {
+        command: 'build' | 'serve';
+    }): {
+        server: {
+            watch: {
+                ignored: string[];
+            };
+        };
+    };
+    configResolved(config: {
+        root: string;
+    }): void;
+    configureServer(server: DocumentationViteServer): void;
+};
+
+export { AGENT_SKILLS_SCHEMA, type BuildDocumentationOptions, DEFAULT_DOCUMENTATION_CONTEXTUAL_ACTIONS, DEFAULT_DOCUMENTATION_OPENAPI_EXAMPLES, DOCUMENTATION_CONFIG_FILE, DOCUMENTATION_CONTEXTUAL_ACTIONS, DOCUMENTATION_MANIFEST_VERSION, DOCUMENTATION_OPENAPI_SAMPLE_LANGUAGES, type DocumentationAssistantAccess, type DocumentationAssistantChunk, type DocumentationAssistantConfig, type DocumentationBuildManifest, type DocumentationBuildResult, type DocumentationConfig, type DocumentationContextualAction, type DocumentationContextualConfig, type DocumentationDiagnostic, DocumentationError, type DocumentationFontConfig, type DocumentationFrontmatter, type DocumentationGraph, type DocumentationHeading, type DocumentationLinkConfig, type DocumentationMcpAccess, type DocumentationMcpConfig, type DocumentationNavGroup, type DocumentationNavigationGroup, type DocumentationNavigationItem, type DocumentationNavigationLink, type DocumentationNavigationNode, type DocumentationNavigationPage, type DocumentationOpenApiCodeSample, type DocumentationOpenApiConfig, type DocumentationOpenApiExamplesConfig, type DocumentationOpenApiOperation, type DocumentationOpenApiParameter, type DocumentationOpenApiResponse, type DocumentationOpenApiSampleDefaults, type DocumentationOpenApiSampleLanguage, type DocumentationPage, type DocumentationRuntimeData, type DocumentationRuntimePage, type DocumentationRuntimePageLink, type DocumentationRuntimeRouteData, type DocumentationRuntimeRouteDocument, type DocumentationSearchEntry, type DocumentationSeoConfig, type DocumentationSkillArtifacts, type DocumentationThemeConfig, type DocumentationValidationResult, type LoadedDocumentationConfig, buildDocumentation, createDocumentationSkillArtifacts, deepSpaceDocumentation, documentationSkillName, htmlToText, loadDocumentationConfig, normalizeRoute, parseFrontmatter, parseMarkdown, routeFromRelativePath, slugify, validateDocumentation };