@yadsh/dsh-qa-surface 0.4.0 → 0.6.0

package/lib/types/documents/providers/registry.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Backend registry and selection (§22, §23, §14.3, §45).
+ *
+ * Tools never import a concrete provider: they ask the registry for the
+ * renderer, extractor or converter that fits the request, and the registry
+ * decides — from configuration and from what is actually available — which
+ * implementation that is. Swapping Docling for another extractor, or Typst for
+ * another PDF engine, is a change here and nowhere else.
+ */
+import type { ResolvedQaDocumentsConfig } from "../config.js";
+import type { BackendStatus, DocumentConverter, DocumentExtractor, DocumentFormat, ExtractedDocument, ExtractInput, DocxRenderer, PdfMode, PdfRenderer, ExtractionMode } from "../types.js";
+export interface ProviderSeams {
+    /** Substituted for the global `fetch` when talking to docling-serve. */
+    readonly fetchImpl?: typeof fetch;
+    readonly pandoc?: {
+        readonly programPrefixArgs?: readonly string[];
+        readonly versionProbe?: () => Promise<string | undefined>;
+    };
+    readonly libreoffice?: {
+        readonly programPrefixArgs?: readonly string[];
+        readonly versionProbe?: () => Promise<string | undefined>;
+    };
+    readonly markitdown?: {
+        readonly programPrefixArgs?: readonly string[];
+        readonly versionProbe?: () => Promise<string | undefined>;
+    };
+}
+export interface ProviderSet {
+    readonly docx: DocxRenderer;
+    readonly typstPdf: PdfRenderer | undefined;
+    readonly converter: DocumentConverter;
+    readonly docling: DocumentExtractor | undefined;
+    readonly doclingHealth: (() => Promise<BackendStatus>) | undefined;
+    readonly markitdown: DocumentExtractor | undefined;
+    readonly markitdownHealth: (() => Promise<BackendStatus>) | undefined;
+}
+export declare function createProviders(config: ResolvedQaDocumentsConfig, seams?: ProviderSeams): ProviderSet;
+/**
+ * The PDF route (§14.3):
+ *
+ * ```text
+ * DOCX + PDF requested          → office
+ * PDF only, template has Typst  → typst
+ * otherwise                     → office
+ * ```
+ *
+ * A deployment that asked for `typst` without enabling the engine is answered
+ * with `BACKEND_UNAVAILABLE` instead of silently rendering an office PDF in
+ * the wrong layout.
+ */
+export declare function selectPdfMode(options: {
+    readonly requested: PdfMode;
+    readonly formats: readonly ("docx" | "pdf")[];
+    readonly templateHasTypst: boolean;
+    readonly typstEnabled: boolean;
+}): "office" | "typst";
+export interface ExtractorSelection {
+    readonly extractor: DocumentExtractor;
+    /** Extractors to try, in order, when the first one is unreachable. */
+    readonly fallbacks: readonly DocumentExtractor[];
+}
+export declare function selectExtractor(providers: ProviderSet, config: ResolvedQaDocumentsConfig, mode: ExtractionMode, format: DocumentFormat): ExtractorSelection;
+/** Run the selected extractor, falling back only when it is unreachable. */
+export declare function extractWithFallback(selection: ExtractorSelection, input: ExtractInput): Promise<{
+    document: ExtractedDocument;
+    fellBackFrom?: string;
+}>;
+//# sourceMappingURL=registry.d.ts.map

package/lib/types/documents/providers/shared.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Shared plumbing of the document providers.
+ *
+ * Providers report what they wrote through {@link verifyOutput}: a backend
+ * that exits 0 but leaves no file behind is a failure, and one that leaves an
+ * empty file is a failure too — the caller must never be handed a path that
+ * looks like an artifact and is not.
+ */
+import type { BackendInfo, DocumentWarning } from "../types.js";
+export type ProviderFailureCode = "RENDER_FAILED" | "CONVERSION_FAILED" | "EXTRACTION_FAILED";
+export interface VerifiedOutput {
+    readonly path: string;
+    readonly size: number;
+}
+export declare function verifyOutput(outputPath: string, backend: string, code: ProviderFailureCode): Promise<VerifiedOutput>;
+/** `--metadata=key=value` pairs, sanitized of control characters. */
+export declare function metadataArguments(metadata: Readonly<Record<string, string>> | undefined): string[];
+/** First line of a `--version` run, reduced to the version token. */
+export declare function parseVersionOutput(stdout: string, program: string): string | undefined;
+export declare function backendInfo(provider: string, version?: string): BackendInfo;
+/** Read a text output produced by a backend, with a bounded size. */
+export declare function readTextOutput(filePath: string, backend: string, maxBytes: number): Promise<{
+    text: string;
+    truncated: boolean;
+}>;
+export declare function truncationWarning(backend: string, contentType: string): DocumentWarning;
+//# sourceMappingURL=shared.d.ts.map

package/lib/types/documents/runtime.d.ts

@@ -0,0 +1,59 @@
+/**
+ * The runtime facade the tools talk to.
+ *
+ * One instance lives in the plugin and survives across calls, so the backend
+ * registry, the concurrency semaphores and the version caches are shared
+ * instead of rebuilt per request. The four operations are the whole surface:
+ * everything else in this subsystem is an implementation detail behind them.
+ */
+import { type QaDocumentsConfig, type ResolvedQaDocumentsConfig } from "./config.js";
+import { type ProviderSeams, type ProviderSet } from "./providers/registry.js";
+import { type DocumentLogger } from "./orchestrator/runtime-deps.js";
+import { resolveDocumentScope, type DocumentScope } from "./orchestrator/scope.js";
+import type { DocumentCapabilities, DocumentConvertInput, DocumentConvertResult, DocumentCreateInput, DocumentCreateResult, DocumentHealth, DocumentInspectInput, DocumentInspectResult, DocumentToMarkdownInput, DocumentToMarkdownResult } from "./types.js";
+export interface DocumentRuntimeOptions {
+    readonly config: ResolvedQaDocumentsConfig;
+    readonly logger?: DocumentLogger;
+    readonly seams?: ProviderSeams;
+    /** Pre-built registry; tests substitute stub backends here. */
+    readonly providers?: ProviderSet;
+    readonly now?: () => Date;
+}
+export declare class DocumentRuntime {
+    readonly config: ResolvedQaDocumentsConfig;
+    readonly providers: ProviderSet;
+    private readonly deps;
+    private readonly seams;
+    constructor(options: DocumentRuntimeOptions);
+    create(input: DocumentCreateInput, scope: DocumentScope): Promise<DocumentCreateResult>;
+    toMarkdown(input: DocumentToMarkdownInput, scope: DocumentScope): Promise<DocumentToMarkdownResult>;
+    convert(input: DocumentConvertInput, scope: DocumentScope): Promise<DocumentConvertResult>;
+    inspect(input: DocumentInspectInput, scope: DocumentScope): Promise<DocumentInspectResult>;
+    health(options?: {
+        readonly probeProcessBackends?: boolean;
+    }): Promise<DocumentHealth>;
+    capabilities(scope?: DocumentScope): Promise<DocumentCapabilities>;
+    /** Routes this runtime advertises, in documentation order. */
+    routes(): readonly (readonly [string, string])[];
+    /**
+     * Retention sweep (§41). Meaningful only for a pinned storage root: with the
+     * default per-workspace layout the plugin cannot enumerate workspaces, and a
+     * sweep that guessed would delete other projects' artifacts.
+     */
+    cleanup(options?: {
+        readonly now?: Date;
+    }): Promise<{
+        removed: string[];
+    } | undefined>;
+}
+/** Build a runtime from raw (schema-parsed) configuration. */
+export declare function createDocumentRuntime(options: {
+    readonly config: QaDocumentsConfig;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly logger?: DocumentLogger;
+    readonly seams?: ProviderSeams;
+    readonly providers?: ProviderSet;
+    readonly now?: () => Date;
+}): DocumentRuntime;
+export { resolveDocumentScope };
+//# sourceMappingURL=runtime.d.ts.map

package/lib/types/documents/security/file-types.d.ts

@@ -0,0 +1,39 @@
+/**
+ * File-type identification and asset MIME policy (§26.3, §26.6, §17.1).
+ *
+ * The extension is a hint, never the authority: PDF is recognized by its
+ * header (after a bounded scan, because a PDF may carry leading junk), OOXML
+ * by its ZIP container plus the parts it holds, and macro-enabled documents by
+ * the presence of a VBA project. Legacy OLE documents (`.doc`, `.xls`, `.ppt`)
+ * are recognized only to be refused with a precise message.
+ */
+import type { DetectedFormat, DocumentFormat } from "../types.js";
+export declare const DOCUMENT_MEDIA_TYPES: Readonly<Record<DocumentFormat, string>>;
+export declare function mediaTypeFor(format: DocumentFormat): string;
+export declare function extensionFor(format: DocumentFormat): string;
+export interface SniffedDocument {
+    readonly format: DetectedFormat;
+    readonly mediaType: string;
+    /** The file is a ZIP container holding a Word processing document. */
+    readonly wordprocessing?: boolean;
+    /** `word/vbaProject.bin` or a macro-enabled content type is present. */
+    readonly macroEnabled?: boolean;
+    /** Container recognized as OOXML but not a supported document flavour. */
+    readonly unsupportedOffice?: boolean;
+}
+export declare function detectFormatByExtension(filename: string): DocumentFormat | undefined;
+/**
+ * Identify a document from its bytes, falling back to the extension only where
+ * bytes are inconclusive (plain text and Markdown are both just text).
+ */
+export declare function sniffDocument(buffer: Buffer, filename?: string): SniffedDocument;
+/** The supported source format behind a sniff result, or `undefined`. */
+export declare function supportedFormatOf(sniffed: SniffedDocument): DocumentFormat | undefined;
+/** Human-facing explanation of a sniff result the pipeline refuses. */
+export declare function describeUnsupported(sniffed: SniffedDocument, filename: string): string;
+export { DEFAULT_ASSET_MIME_TYPES, isAllowedAssetMimeType, mimeTypeForFilename, } from "./mime.js";
+/** Magic-byte MIME detection for the asset types the pipeline accepts. */
+export declare function mimeTypeOfBytes(buffer: Buffer): string | undefined;
+/** A short, sanitized description of the first bytes, for error messages. */
+export declare function describeBytes(buffer: Buffer): string;
+//# sourceMappingURL=file-types.d.ts.map

package/lib/types/documents/security/limits.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Resource limits and concurrency control (§26.4, §27).
+ *
+ * Every expensive stage (render, extraction, OCR) runs behind a semaphore so a
+ * burst of documents cannot exhaust the host, and every size/count budget is
+ * checked before the work starts rather than after a backend has already spent
+ * minutes on it.
+ */
+export declare function assertBytesWithinBudget(bytes: number, maxBytes: number, label: string): void;
+export declare function assertCharsWithinBudget(chars: number, maxChars: number, label: string): void;
+export declare function assertCountWithinBudget(count: number, maxCount: number, label: string): void;
+export interface Semaphore {
+    /** Resolve with the release function once a slot is free. */
+    acquire(signal?: AbortSignal): Promise<() => void>;
+    readonly limit: number;
+    /** Slots in use right now (tests and health output). */
+    readonly inUse: number;
+}
+/**
+ * Counting semaphore with FIFO fairness. An aborted waiter leaves the queue
+ * without consuming a slot, so a stopped turn never leaks capacity.
+ */
+export declare function createSemaphore(limit: number): Semaphore;
+//# sourceMappingURL=limits.d.ts.map

package/lib/types/documents/security/mime.d.ts

@@ -0,0 +1,13 @@
+/**
+ * MIME policy for document assets (§17.1).
+ *
+ * Kept free of Node builtins on purpose: the QA settings schema reaches this
+ * module from the browser bundle, so anything imported here also has to run in
+ * a page. The byte sniffing stays with the pipeline's file-type module, which
+ * may import whatever it needs.
+ */
+/** Asset MIME types accepted by default. */
+export declare const DEFAULT_ASSET_MIME_TYPES: readonly string[];
+export declare function mimeTypeForFilename(filename: string): string | undefined;
+export declare function isAllowedAssetMimeType(mimeType: string, allowed: readonly string[]): boolean;
+//# sourceMappingURL=mime.d.ts.map

package/lib/types/documents/security/paths.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Path containment and filename hygiene (§26.2, §32).
+ *
+ * Two rules hold everywhere in the pipeline:
+ *
+ * - every path the pipeline touches is resolved against an allowed root and
+ *   the resolution must stay inside it — traversal, absolute escapes and
+ *   `file://` references are refused before anything is opened;
+ * - a caller-supplied filename is a label, never a path: directories are
+ *   dropped, separators and reserved characters collapse to `-`, and the
+ *   extension is the one the operation itself chose.
+ */
+/** Whether `target` is `root` or a descendant of it (no symlink resolution). */
+export declare function isInsideRoot(root: string, target: string): boolean;
+export declare function assertInsideRoot(root: string, target: string, label: string): string;
+/**
+ * Canonicalize a path for containment checks: the existing prefix is resolved
+ * through symlinks, the non-existent remainder is appended unresolved. A
+ * symlink pointing outside the root therefore canonicalizes outside it.
+ */
+export declare function canonicalizeForContainment(input: string): Promise<string>;
+/** Resolve a caller-supplied path against `root`, refusing any escape. */
+export declare function resolveInsideRoot(root: string, requested: string, label: string): Promise<string>;
+/**
+ * Turn a caller-supplied filename into a safe file name (§32).
+ * `../../foo report?.docx` becomes `foo-report.docx`.
+ */
+export declare function sanitizeFilename(requested: string | undefined, fallbackStem: string, extension: string): string;
+/** `file:///...` form required by `-env:UserInstallation` and friends. */
+export declare function toFileUri(target: string): string;
+/**
+ * Assert an asset reference inside Markdown targets the assets directory and
+ * nothing else: no absolute paths, no URLs, no traversal (§17.1).
+ */
+export declare function assertRelativeAssetReference(reference: string): string;
+/** Recursively-size snapshot helper used by the limits guard. */
+export declare function assertNotBlank(value: string, label: string): string;
+//# sourceMappingURL=paths.d.ts.map

package/lib/types/documents/templates/registry.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Template registry (§12.2).
+ *
+ * A deployment describes its templates in a `manifest.yml` beside the
+ * template files:
+ *
+ * ```yaml
+ * templates:
+ *   default:
+ *     docx: ./docx/default.docx
+ *   qa-report:
+ *     docx: ./docx/qa-report.docx
+ *     typst: ./typst/qa-report
+ * ```
+ *
+ * Every declared path is resolved against the template root and must stay
+ * inside it: a registry file is operator input, but it is read from the
+ * workspace, so it gets the same containment treatment as everything else
+ * (§26.2).
+ */
+import type { DocumentWarning } from "../types.js";
+export declare const TEMPLATE_MANIFEST_FILE = "manifest.yml";
+export interface DocumentTemplate {
+    readonly name: string;
+    /** Absolute path of the reference DOCX, when the template declares one. */
+    readonly docx?: string;
+    /** Absolute path of the Typst template directory, when it declares one. */
+    readonly typst?: string;
+}
+export interface TemplateRegistry {
+    /** Absolute template root, when the workspace provides one. */
+    readonly root?: string;
+    readonly templates: ReadonlyMap<string, DocumentTemplate>;
+    readonly warnings: readonly DocumentWarning[];
+}
+/** The template name that always resolves, with or without a registry. */
+export declare const BUILTIN_TEMPLATE_NAME = "default";
+/** Located registry file inside a candidate root. */
+export declare function findTemplateManifest(root: string): Promise<string | undefined>;
+/**
+ * Load a registry from a template root. A missing root, a missing manifest or
+ * an unreadable document all leave the builtin default in place and report a
+ * warning — a broken template directory must not stop the agent from writing a
+ * plain document, but it must not be silent either.
+ */
+export declare function loadTemplateRegistry(root: string | undefined): Promise<TemplateRegistry>;
+export declare function templateNames(registry: TemplateRegistry): string[];
+/** Load a registry from a candidate root, defaulting to a file-system probe. */
+export declare function loadTemplateRegistryFrom(roots: readonly (string | undefined)[], probe: (candidate: string) => Promise<boolean>): Promise<TemplateRegistry>;
+//# sourceMappingURL=registry.d.ts.map

package/lib/types/documents/templates/resolver.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Template resolution (§12.3).
+ *
+ * ```text
+ * requested template
+ *   ↓ (absent)
+ * project default
+ *   ↓ (absent)
+ * builtin default
+ * ```
+ *
+ * A requested template that does not exist is an error, never a silent
+ * fallback: a report rendered in the wrong corporate layout is worse than a
+ * failed call the operator can read. The builtin `default` name resolves
+ * without a registry entry — it means "the document backend's own defaults".
+ */
+import type { DocumentWarning } from "../types.js";
+import { type DocumentTemplate, type TemplateRegistry } from "./registry.js";
+export interface ResolvedTemplate {
+    readonly name: string;
+    readonly template?: DocumentTemplate;
+    /** How the effective name was chosen. */
+    readonly source: "requested" | "project-default" | "builtin";
+}
+export interface TemplateResolution {
+    readonly resolved: ResolvedTemplate;
+    readonly warnings: readonly DocumentWarning[];
+}
+export declare function resolveTemplate(registry: TemplateRegistry, requested: string | undefined, projectDefault: string): TemplateResolution;
+//# sourceMappingURL=resolver.d.ts.map

package/lib/types/documents/tools/convert.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `document_convert` — one supported format to another (§10, §34).
+ */
+import type { DocumentRuntime } from "../runtime.js";
+export declare const DOCUMENT_CONVERT_TOOL = "document_convert";
+export declare function createDocumentConvertTool(options: {
+    readonly runtime: DocumentRuntime;
+}): import("@deepseek-ai/dsh-tools").ToolDefinition;
+//# sourceMappingURL=convert.d.ts.map

package/lib/types/documents/tools/create.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `document_create` — Markdown to DOCX and/or PDF (§8, §34).
+ *
+ * This is the tool the agent reaches for instead of driving pandoc and
+ * LibreOffice itself, which is the whole point of the pipeline: the intent is
+ * "give me this report as a Word file and a PDF", and the service decides how
+ * that happens.
+ */
+import type { DocumentRuntime } from "../runtime.js";
+export declare const DOCUMENT_CREATE_TOOL = "document_create";
+export declare function createDocumentCreateTool(options: {
+    readonly runtime: DocumentRuntime;
+}): import("@deepseek-ai/dsh-tools").ToolDefinition;
+//# sourceMappingURL=create.d.ts.map

package/lib/types/documents/tools/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The four agent-facing document tools (§8–§11, §34) and their registration.
+ *
+ * Registration is explicit and returns its disposers: the host may register
+ * them globally (the default) or an agent scope may register the same
+ * definitions later, which is what a deployment that wants progressive
+ * disclosure needs. Nothing here decides *whether* document tools are visible;
+ * that is the deployment's allow-list.
+ */
+import type { ToolDefinition } from "@deepseek-ai/dsh-tools";
+import type { DocumentRuntime } from "../runtime.js";
+import { DOCUMENT_CONVERT_TOOL } from "./convert.js";
+import { DOCUMENT_CREATE_TOOL } from "./create.js";
+import { DOCUMENT_INSPECT_TOOL } from "./inspect.js";
+import { DOCUMENT_TO_MARKDOWN_TOOL } from "./to-markdown.js";
+/** Exact names of the tools this subsystem registers (allow-list contract). */
+export declare const DOCUMENT_TOOL_NAMES: readonly string[];
+export { DOCUMENT_CONVERT_TOOL, DOCUMENT_CREATE_TOOL, DOCUMENT_INSPECT_TOOL, DOCUMENT_TO_MARKDOWN_TOOL, };
+export declare function createDocumentTools(options: {
+    readonly runtime: DocumentRuntime;
+}): ToolDefinition[];
+/** Anything that can accept a tool definition; the host's registry facade. */
+export interface DocumentToolRegistry {
+    register(definition: ToolDefinition): () => void;
+}
+/**
+ * Register every document tool and return one disposer. `enabled: false` is
+ * handled by the caller: the surface is then absent rather than inert.
+ */
+export declare function registerDocumentTools(registry: DocumentToolRegistry, options: {
+    readonly runtime: DocumentRuntime;
+}): () => void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/documents/tools/inspect.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `document_inspect` — what a document is, without converting it (§11, §34).
+ */
+import type { DocumentRuntime } from "../runtime.js";
+export declare const DOCUMENT_INSPECT_TOOL = "document_inspect";
+export declare function createDocumentInspectTool(options: {
+    readonly runtime: DocumentRuntime;
+}): import("@deepseek-ai/dsh-tools").ToolDefinition;
+//# sourceMappingURL=inspect.d.ts.map

package/lib/types/documents/tools/shared.d.ts

@@ -0,0 +1,77 @@
+/**
+ * What the four document tools share: the calling session's scope, the output
+ * shapes they render, and the warning formatter.
+ *
+ * A tool is a thin adapter. It reads the session's working directory (the
+ * artifact root and the allowed input roots both derive from it), hands intent
+ * to the runtime, and renders the structured result for the model. No tool
+ * knows a backend name beyond the one the result reports.
+ */
+import type { ParameterSchemaSpec } from "@deepseek-ai/dsh-tools";
+import type { DocumentScope } from "../orchestrator/scope.js";
+import type { DocumentFileResult, DocumentWarning } from "../types.js";
+/**
+ * Model-facing shape of a warning. The tool results carry code, message and
+ * backend; the diagnostic `details` stay in the manifest, where they are read
+ * by an operator rather than by the model.
+ */
+export interface ToolWarning {
+    readonly code: string;
+    readonly message: string;
+    readonly backend?: string;
+}
+export declare function toolWarnings(warnings: readonly DocumentWarning[]): ToolWarning[];
+/** Shared output-schema fragment for the `warnings` array of every tool. */
+export declare const warningsSchema: {
+    type: "array";
+    items: {
+        type: "object";
+        additionalProperties: false;
+        properties: {
+            code: {
+                type: "string";
+                required: true;
+            };
+            message: {
+                type: "string";
+                required: true;
+            };
+            backend: {
+                type: "string";
+            };
+        };
+    };
+};
+/** Mutable projection of a produced file for the tool result. */
+export declare function toolFiles(files: readonly DocumentFileResult[]): {
+    format: string;
+    path: string;
+    mediaType: string;
+    size: number;
+    sha256: string;
+    status: string;
+    error?: string;
+}[];
+/** Structural view of the execution context a tool body needs. */
+export interface DocumentToolExec {
+    readonly signal?: AbortSignal;
+    readonly agent?: {
+        readonly session: {
+            readonly header: {
+                readonly cwd?: string;
+                readonly id?: unknown;
+            };
+        };
+    };
+}
+/**
+ * Resolve the session scope, failing closed: a session without a working
+ * directory gets no document access rather than the host process's cwd.
+ */ export declare function requireDocumentScope(exec: DocumentToolExec): DocumentScope;
+export declare function fileParameter(): ParameterSchemaSpec[string];
+export declare function formatBytes(bytes: number): string;
+export declare function renderWarning(warning: ToolWarning): string;
+/** One line per produced file, plus failed formats explicitly named. */
+export declare function renderFiles(files: readonly DocumentFileResult[]): string[];
+export declare const ARTIFACT_NOTE = "The artifact directory keeps the source, the assets and manifest.json beside the outputs.";
+//# sourceMappingURL=shared.d.ts.map

package/lib/types/documents/tools/to-markdown.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `document_to_markdown` — DOCX/PDF to Markdown (§9, §34).
+ *
+ * The model gets the extracted text and a path to the full copy; the artifact
+ * bundle keeps the input, the extracted Markdown and any extracted images.
+ */
+import type { DocumentRuntime } from "../runtime.js";
+export declare const DOCUMENT_TO_MARKDOWN_TOOL = "document_to_markdown";
+export declare function createDocumentToMarkdownTool(options: {
+    readonly runtime: DocumentRuntime;
+}): import("@deepseek-ai/dsh-tools").ToolDefinition;
+//# sourceMappingURL=to-markdown.d.ts.map