@sparkelf/dsh-plugin-document-attachments 0.1.0-rc.10

package/lib/mineru.js

@@ -0,0 +1,213 @@
+import { r as DocumentParserError } from "./types-gD1pbaLm.js";
+import z from "@deepseek-ai/schemastery";
+import { unzipSync } from "fflate";
+//#region lib/types/provider.js
+/** Synchronous MinerU `/file_parse` document parser provider. */
+/** Stable parser-provider id recorded with durable parse provenance. */
+const MINERU_PROVIDER_ID = "mineru";
+function logProviderError(operation, error) {
+	console.error(`document-parser-mineru: ${operation}`, error);
+}
+/** MinerU external parser implementation. */
+var MinerUDocumentParserProvider = class {
+	id = MINERU_PROVIDER_ID;
+	endpoint;
+	timeoutMs;
+	maxResponseBytes;
+	constructor(options) {
+		const endpoint = parseEndpoint(options.endpoint);
+		if (!Number.isSafeInteger(options.timeoutMs) || options.timeoutMs <= 0) throw new Error("document-parser-mineru: timeoutMs must be a positive safe integer");
+		if (!Number.isSafeInteger(options.maxResponseBytes) || options.maxResponseBytes <= 0) throw new Error("document-parser-mineru: maxResponseBytes must be a positive safe integer");
+		this.endpoint = endpoint;
+		this.timeoutMs = options.timeoutMs;
+		this.maxResponseBytes = options.maxResponseBytes;
+	}
+	async parse(request, signal) {
+		const timeout = AbortSignal.timeout(this.timeoutMs);
+		const combined = signal === void 0 ? timeout : AbortSignal.any([signal, timeout]);
+		const form = new FormData();
+		const fileBytes = new Uint8Array(request.data.byteLength);
+		fileBytes.set(request.data);
+		form.append("files", new Blob([fileBytes.buffer], { type: request.attachment.mediaType }), request.attachment.name);
+		form.append("return_md", "true");
+		form.append("return_middle_json", "false");
+		form.append("return_model_output", "false");
+		form.append("return_content_list", "true");
+		form.append("return_images", "true");
+		form.append("response_format_zip", "true");
+		form.append("return_original_file", "false");
+		let response;
+		try {
+			response = await fetch(this.endpoint, {
+				method: "POST",
+				redirect: "error",
+				body: form,
+				signal: combined
+			});
+		} catch (error) {
+			logProviderError("request failed", error);
+			if (signal?.aborted === true) throw new DocumentParserError("Document parsing was cancelled.", "DOCUMENT_PARSE_ABORTED", { cause: error });
+			if (timeout.aborted) throw new DocumentParserError(`Document parsing exceeded the configured ${this.timeoutMs} ms timeout.`, "DOCUMENT_PARSE_TIMEOUT", { cause: error });
+			throw new DocumentParserError("Unable to reach the configured document parser.", "DOCUMENT_PARSE_FAILED", { cause: error });
+		}
+		if (!response.ok) throw new DocumentParserError(`Document parser returned HTTP ${response.status}.`, "DOCUMENT_PARSE_FAILED");
+		const declaredLength = response.headers.get("content-length");
+		if (declaredLength !== null) {
+			const bytes = Number(declaredLength);
+			if (Number.isFinite(bytes) && bytes > this.maxResponseBytes) throw new DocumentParserError("Document parser response exceeds the configured byte limit.", "DOCUMENT_PARSE_RESPONSE_TOO_LARGE");
+		}
+		let archive;
+		try {
+			archive = await readBoundedBody(response, this.maxResponseBytes);
+		} catch (error) {
+			logProviderError("response read failed", error);
+			if (error instanceof DocumentParserError) throw error;
+			if (signal?.aborted === true) throw new DocumentParserError("Document parsing was cancelled.", "DOCUMENT_PARSE_ABORTED", { cause: error });
+			if (timeout.aborted) throw new DocumentParserError(`Document parsing exceeded the configured ${this.timeoutMs} ms timeout.`, "DOCUMENT_PARSE_TIMEOUT", { cause: error });
+			throw new DocumentParserError("Unable to read the document parser response.", "DOCUMENT_PARSE_FAILED", { cause: error });
+		}
+		return parseArchive(unzipBounded(archive, this.maxResponseBytes));
+	}
+};
+/** Read a response body and reject as soon as accumulated compressed bytes exceed the configured bound. */
+async function readBoundedBody(response, maxBytes) {
+	if (response.body === null) return new Uint8Array();
+	const reader = response.body.getReader();
+	const chunks = [];
+	let totalBytes = 0;
+	try {
+		while (true) {
+			const part = await reader.read();
+			if (part.done) break;
+			const value = part.value;
+			totalBytes += value.byteLength;
+			if (totalBytes > maxBytes) {
+				try {
+					await reader.cancel();
+				} catch (error) {
+					logProviderError("oversized response cancellation failed", error);
+				}
+				throw new DocumentParserError("Document parser response exceeds the configured byte limit.", "DOCUMENT_PARSE_RESPONSE_TOO_LARGE");
+			}
+			chunks.push(value);
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	const body = new Uint8Array(totalBytes);
+	let offset = 0;
+	for (const chunk of chunks) {
+		body.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return body;
+}
+/** Reject archives whose declared aggregate uncompressed size exceeds the bound before fflate allocates the entries. */
+function unzipBounded(archive, maxBytes) {
+	let declaredBytes = 0;
+	let entries;
+	try {
+		entries = unzipSync(archive, { filter(file) {
+			if (declaredBytes > maxBytes) return false;
+			declaredBytes += file.originalSize;
+			return declaredBytes <= maxBytes;
+		} });
+	} catch (error) {
+		logProviderError("ZIP extraction failed", error);
+		throw new DocumentParserError("Document parser returned an invalid ZIP archive.", "DOCUMENT_PARSE_INVALID_OUTPUT", { cause: error });
+	}
+	if (declaredBytes > maxBytes) throw new DocumentParserError("Document parser extracted output exceeds the configured byte limit.", "DOCUMENT_PARSE_RESPONSE_TOO_LARGE");
+	return entries;
+}
+/** Validate a configured HTTP(S) parser endpoint without silently rewriting it. */
+function parseEndpoint(value) {
+	let url;
+	try {
+		url = new URL(value);
+	} catch (error) {
+		logProviderError("endpoint parsing failed", error);
+		throw new Error("document-parser-mineru: endpoint must be an absolute URL", { cause: error });
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error("document-parser-mineru: endpoint must use http or https");
+	return url.toString();
+}
+/**
+* Select exactly one v1 Markdown and content-list output plus every extracted raster image.
+* @param entries - bounded in-memory ZIP entries from one synchronous MinerU response.
+* @returns validated complete transient parser output bytes.
+*/
+function parseArchive(entries) {
+	const files = Object.entries(entries).filter(([name]) => !name.endsWith("/"));
+	const markdown = files.filter(([name]) => name.toLowerCase().endsWith(".md"));
+	const contentLists = files.filter(([name]) => {
+		const lower = name.toLowerCase();
+		return lower.endsWith("_content_list.json") && !lower.endsWith("_content_list_v2.json");
+	});
+	const markdownEntry = markdown[0];
+	const contentListEntry = contentLists[0];
+	if (markdown.length !== 1 || contentLists.length !== 1 || markdownEntry === void 0 || contentListEntry === void 0) throw new DocumentParserError("Document parser ZIP must contain exactly one Markdown file and one content-list JSON file.", "DOCUMENT_PARSE_INVALID_OUTPUT");
+	const markdownBytes = markdownEntry[1];
+	const contentListBytes = contentListEntry[1];
+	validateUtf8(markdownBytes, "Markdown");
+	const contentListText = validateUtf8(contentListBytes, "content-list JSON");
+	try {
+		const parsed = JSON.parse(contentListText);
+		if (!Array.isArray(parsed)) throw new Error("content list is not an array");
+	} catch (error) {
+		logProviderError("content-list validation failed", error);
+		throw new DocumentParserError("Document parser content-list output is not a JSON array.", "DOCUMENT_PARSE_INVALID_OUTPUT", { cause: error });
+	}
+	const images = [];
+	for (const [path, data] of files) {
+		if (!path.split("/").includes("images")) continue;
+		const name = path.slice(path.lastIndexOf("/") + 1);
+		const mediaType = imageMediaType(name);
+		if (mediaType === void 0) throw new DocumentParserError(`Document parser returned unsupported extracted image type for "${name}".`, "DOCUMENT_PARSE_INVALID_OUTPUT");
+		images.push({
+			name,
+			mediaType,
+			data
+		});
+	}
+	return {
+		markdown: markdownBytes,
+		contentList: contentListBytes,
+		images
+	};
+}
+/** Strict UTF-8 decoder used before parser output is accepted for durable persistence. */
+function validateUtf8(data, label) {
+	try {
+		return new TextDecoder("utf-8", { fatal: true }).decode(data);
+	} catch (error) {
+		logProviderError(`${label} UTF-8 decoding failed`, error);
+		throw new DocumentParserError(`Document parser ${label} is not valid UTF-8.`, "DOCUMENT_PARSE_INVALID_OUTPUT", { cause: error });
+	}
+}
+/** MIME owned by the existing raster attachment admission path. */
+function imageMediaType(name) {
+	const lower = name.toLowerCase();
+	if (lower.endsWith(".png")) return "image/png";
+	if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) return "image/jpeg";
+	if (lower.endsWith(".webp")) return "image/webp";
+	if (lower.endsWith(".gif")) return "image/gif";
+}
+//#endregion
+//#region lib/types/mineru.js
+/** MinerU implementation of the external document-parser seam. @module @sparkelf/dsh-plugin-document-attachments/mineru */
+/** Cordis plugin name used by loader diagnostics. */
+const name = "document-parser-mineru";
+/** Provider registers into the provider-neutral parser seam. */
+const inject = ["documentParser"];
+/** MinerU provider configuration has no implicit endpoint, timeout, or size policy. */
+const Config = z.object({
+	endpoint: z.string().required(),
+	timeoutMs: z.number().step(1).min(1).required(),
+	maxResponseBytes: z.number().step(1).min(1).required()
+});
+/** Register the MinerU provider into `ctx.documentParser`. */
+function apply(ctx, config) {
+	ctx.documentParser.registerProvider(new MinerUDocumentParserProvider(config));
+}
+//#endregion
+export { Config, MINERU_PROVIDER_ID, MinerUDocumentParserProvider, apply, inject, name };

package/lib/types/client/DraftDocuments.d.ts

@@ -0,0 +1,10 @@
+import type { PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+type Props = PropsRuntime<'conversation.input.attachments.documents'> & PropsLocale<'documentAttachments'>;
+/**
+ * Render browser-owned Document drafts with remove controls.
+ * @param props - nested composer slot owner data and locale translator.
+ * @returns the draft rail, or null when empty.
+ */
+export declare function DraftDocuments({ documents, onRemoveDocument, t }: Props): import("react").JSX.Element | null;
+export {};
+//# sourceMappingURL=DraftDocuments.d.ts.map

package/lib/types/client/MessageDocuments.d.ts

@@ -0,0 +1,17 @@
+import type { PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+type Props = PropsRuntime<'conversation.message.images.documents'> & PropsLocale<'documentAttachments'>;
+type TrajectoryProps = PropsRuntime<'conversation.trajectory.images.documents'> & PropsLocale<'documentAttachments'>;
+/**
+ * Render durable Document cards in Chat history.
+ * @param props - nested Chat attachment owner data and locale translator.
+ * @returns the history card row, or null when empty.
+ */
+export declare function MessageDocuments({ documents, t }: Props): import("react").JSX.Element;
+/**
+ * Render durable Document cards in Trajectory history.
+ * @param props - nested Trajectory attachment owner data and locale translator.
+ * @returns the history card row, or null when empty.
+ */
+export declare function TrajectoryDocuments({ documents, t }: TrajectoryProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=MessageDocuments.d.ts.map

package/lib/types/client/index.d.ts

@@ -0,0 +1,62 @@
+/** Browser Document prompt transport, localized intake validation, and nested card registrations. */
+import type { Context } from '@deepseek-ai/cordis';
+import type { SessionRequestId } from '@deepseek-ai/dsh-api-session-controller/types';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import type { DocumentDraft, DocumentLimits } from './types.ts';
+export declare const name = "document-attachments-client";
+export declare const inject: string[];
+interface DocumentPromptRequest {
+    readonly sessionId: SessionId;
+    readonly requestId: SessionRequestId;
+    readonly mode: 'queue' | 'steer';
+    readonly content: readonly unknown[];
+    readonly signal?: AbortSignal;
+}
+type DocumentPromptResponse = {
+    readonly ok: true;
+    readonly value: {
+        readonly accepted: true;
+    };
+} | {
+    readonly ok: false;
+    readonly error: {
+        readonly code: string;
+        readonly message: string;
+        readonly details: Record<string, unknown>;
+    };
+};
+/** Localized Document intake and authenticated prompt transport consumed by Conversation. */
+export interface DocumentPromptClient {
+    /** @returns localized rejection text for slash-command submissions. */
+    commandUnsupported(): string;
+    /**
+     * @param limits - actual Host Document limits.
+     * @returns localized mixed file drop invitation.
+     */
+    dropLabels(limits: DocumentLimits): {
+        readonly title: string;
+        readonly desc: string;
+    };
+    /**
+     * @param files - newly selected browser Documents.
+     * @param existing - live Document drafts already registered.
+     * @param limits - actual Host attachment-provider limits.
+     * @returns localized rejection text, or null when intake may proceed.
+     */
+    validateIntake(files: readonly File[], existing: readonly DocumentDraft[], limits: DocumentLimits): string | null;
+    /**
+     * @param request - prepared mixed browser prompt.
+     * @returns Session-compatible prompt admission result.
+     */
+    submit(request: DocumentPromptRequest): Promise<DocumentPromptResponse>;
+}
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        /** Browser Document intake and prompt transport. */
+        documentPrompt: DocumentPromptClient;
+    }
+}
+/** Install browser transport, localized validation, and Document card contributions. */
+export declare function apply(ctx: Context): void;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/lib/types/client/locales.d.ts

@@ -0,0 +1,47 @@
+export declare const en: {
+    readonly 'intake.count': "Attach up to {count} documents per message.";
+    readonly 'intake.type': "Choose a PDF, DOCX, PPTX, or XLSX file whose extension matches its type.";
+    readonly 'intake.fileSize': "Each document must be {size} or smaller.";
+    readonly 'intake.totalSize': "Documents in one message must total {size} or less.";
+    readonly 'submit.failed': "Unable to submit the document prompt.";
+    readonly 'command.unsupported': "Slash commands do not accept document attachments.";
+    readonly 'drop.title': "Drop images or documents here";
+    readonly 'drop.desc': "PDF, DOCX, PPTX, or XLSX; up to {count} documents, {size} each.";
+    readonly 'draft.group': "Draft documents";
+    readonly 'draft.remove': "Remove {name}";
+    readonly 'history.group': "Attached documents";
+    readonly 'format.pdf': "PDF";
+    readonly 'format.docx': "DOCX";
+    readonly 'format.pptx': "PPTX";
+    readonly 'format.xlsx': "XLSX";
+    readonly 'format.mib': "{value} MiB";
+    readonly 'format.kib': "{value} KiB";
+};
+export declare const zh: {
+    readonly 'intake.count': "每条消息最多可附加 {count} 个文档。";
+    readonly 'intake.type': "请选择扩展名与类型一致的 PDF、DOCX、PPTX 或 XLSX 文件。";
+    readonly 'intake.fileSize': "每个文档不得超过 {size}。";
+    readonly 'intake.totalSize': "单条消息中的文档总大小不得超过 {size}。";
+    readonly 'submit.failed': "无法提交文档消息。";
+    readonly 'command.unsupported': "斜杠命令不接受文档附件。";
+    readonly 'drop.title': "将图片或文档拖放到此处";
+    readonly 'drop.desc': "支持 PDF、DOCX、PPTX 或 XLSX；最多 {count} 个文档，每个不超过 {size}。";
+    readonly 'draft.group': "待发送文档";
+    readonly 'draft.remove': "移除 {name}";
+    readonly 'history.group': "已附加文档";
+    readonly 'format.pdf': "PDF";
+    readonly 'format.docx': "DOCX";
+    readonly 'format.pptx': "PPTX";
+    readonly 'format.xlsx': "XLSX";
+    readonly 'format.mib': "{value} MiB";
+    readonly 'format.kib': "{value} KiB";
+};
+type DocumentLocaleKey = keyof typeof en;
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** Product copy for document intake and durable document cards. */
+        documentAttachments: DocumentLocaleKey;
+    }
+}
+export {};
+//# sourceMappingURL=locales.d.ts.map

package/lib/types/client/types.d.ts

@@ -0,0 +1,49 @@
+/** Browser-only Document draft, limits, and presentation owner data. */
+import type { DraftAttachmentId } from '@deepseek-ai/dsh-client-ui-conversation/client';
+/** Browser-owned Document draft before Host admission. */
+export interface DocumentDraft {
+    readonly kind: 'document';
+    readonly id: DraftAttachmentId;
+    readonly file: File;
+}
+/** Host-projected Document admission limits consumed by browser intake. */
+export interface DocumentLimits {
+    readonly maxDocumentBytes: number;
+    readonly maxDocumentsPerMessage: number;
+    readonly maxMessageDocumentBytes: number;
+    readonly mediaTypes: readonly string[];
+}
+/** Plain durable Document metadata rendered by history cards. */
+interface DocumentCardData {
+    readonly name: string;
+    readonly mediaType: string;
+    readonly bytes: number;
+}
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface SlotMap {
+        'conversation.input.attachments.documents': {
+            kind: 'single';
+            scope: 'session-maybe';
+            owner: {
+                documents: readonly DocumentDraft[];
+                onRemoveDocument: (id: DraftAttachmentId) => void;
+            };
+        };
+        'conversation.message.images.documents': {
+            kind: 'single';
+            scope: 'session';
+            owner: {
+                documents: readonly DocumentCardData[];
+            };
+        };
+        'conversation.trajectory.images.documents': {
+            kind: 'single';
+            scope: 'session';
+            owner: {
+                documents: readonly DocumentCardData[];
+            };
+        };
+    }
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/lib/types/error.d.ts

@@ -0,0 +1,14 @@
+/** Document parser failures crossing provider and Host admission. @module @deepseek-ai/dsh-document-parser/error */
+import type { DocumentParserErrorCode } from './types.ts';
+/** Failure crossing the document-parser capability seam. */
+export declare class DocumentParserError extends Error {
+    /** Stable machine-routing failure code. */
+    readonly code: DocumentParserErrorCode;
+    /**
+     * @param message - user-safe failure description without original bytes or parser temporary paths.
+     * @param code - stable parser failure code.
+     * @param options - optional chained cause.
+     */
+    constructor(message: string, code: DocumentParserErrorCode, options?: ErrorOptions);
+}
+//# sourceMappingURL=error.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,56 @@
+/** Optional external document-parser capability (`ctx.documentParser`). @module @sparkelf/dsh-plugin-document-attachments */
+import { Context, Service } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import type { DocumentParseRequest, DocumentParseResult, DocumentParserProvider } from './types.ts';
+export { DocumentParserError } from './error.ts';
+export type { DocumentAttachmentRef, DocumentMediaType, DocumentParseRequest, DocumentParseResult, DocumentParserErrorCode, DocumentParserProvider, ParsedDocumentImage, } from './types.ts';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        documentParser: DocumentParserRuntime;
+    }
+}
+/** Deployment choices owned by the provider-neutral parser seam. */
+export interface Config {
+    /** Explicit parser provider id; omission auto-selects exactly one registered provider. */
+    provider?: string;
+    /** Maximum aggregate rendered-document bytes, including delimiters and metadata, accepted for direct-context version one. */
+    maxDirectMarkdownBytes: number;
+    /** Maximum encoded JSON bytes accepted by the authenticated mixed prompt route. */
+    maxRequestBytes: number;
+}
+/** Parser seam configuration; the direct-context budget is intentionally required. */
+export declare const Config: z<Config>;
+/** Provider-neutral parser registry and direct-context policy owner. */
+export declare class DocumentParserRuntime extends Service {
+    static inject: string[];
+    private providers;
+    private readonly providerId;
+    /** Maximum aggregate rendered-document bytes Host admission may attach in one submitted message. */
+    readonly maxDirectMarkdownBytes: number;
+    constructor(ctx: Context, config: Config);
+    /**
+     * Register one parser provider until the owning Cordis fiber disposes.
+     * @param provider - provider implementation keyed by its non-empty id.
+     * @returns disposer that withdraws exactly this registration.
+     */
+    registerProvider(provider: DocumentParserProvider): () => void;
+    /**
+     * Report whether current registry state resolves the configured provider selection.
+     * This does not probe provider health or external endpoint availability.
+     * @returns true only when a parse call can select exactly one registered provider.
+     */
+    isSelectionResolvable(): boolean;
+    /**
+     * Parse one already-persisted document through the deployment-selected provider.
+     * @param request - verified original bytes and their durable metadata.
+     * @param signal - optional cancellation forwarded to the provider.
+     * @returns provider id together with the complete transient parse bundle.
+     */
+    parse(request: DocumentParseRequest, signal?: AbortSignal): Promise<{
+        parser: string;
+        result: DocumentParseResult;
+    }>;
+    private resolveProvider;
+}
+export default DocumentParserRuntime;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/input.d.ts

@@ -0,0 +1,12 @@
+/** Authenticated mixed prompt admission for parsed document attachments. */
+import type { Context } from '@deepseek-ai/cordis';
+import type { DocumentParserRuntime } from './index.ts';
+/**
+ * Register the authenticated mixed prompt route for this capability.
+ * @param ctx - Host context carrying WebServer, Connection, Attachment, and Session Controller services.
+ * @param parser - provider-neutral parser runtime.
+ * @param maxRequestBytes - exact encoded HTTP body limit.
+ * @returns route disposer owned by the Document parser Service fiber.
+ */
+export declare function registerDocumentPromptRoute(ctx: Context, parser: DocumentParserRuntime, maxRequestBytes: number): () => void;
+//# sourceMappingURL=input.d.ts.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Package-owned invariant companion for `@sparkelf/dsh-plugin-document-attachments`.
+ * @module @sparkelf/dsh-plugin-document-attachments/invariant
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "document-parser-mineru-invariant";
+/** Service required before the companion can reserve package ownership. */
+export declare const inject: string[];
+/** Register this package's invariant companion. */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

package/lib/types/mineru.d.ts

@@ -0,0 +1,23 @@
+/** MinerU implementation of the external document-parser seam. @module @sparkelf/dsh-plugin-document-attachments/mineru */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+export { MINERU_PROVIDER_ID, MinerUDocumentParserProvider, } from './provider.ts';
+export type { MinerUProviderOptions } from './provider.ts';
+/** Cordis plugin name used by loader diagnostics. */
+export declare const name = "document-parser-mineru";
+/** Provider registers into the provider-neutral parser seam. */
+export declare const inject: string[];
+/** External MinerU endpoint and bounded synchronous parse policy. */
+export interface Config {
+    /** Absolute MinerU synchronous `/file_parse` endpoint. */
+    endpoint: string;
+    /** Maximum wall-clock milliseconds for one parse. */
+    timeoutMs: number;
+    /** Maximum compressed response and aggregate extracted output bytes. */
+    maxResponseBytes: number;
+}
+/** MinerU provider configuration has no implicit endpoint, timeout, or size policy. */
+export declare const Config: z<Config>;
+/** Register the MinerU provider into `ctx.documentParser`. */
+export declare function apply(ctx: Context, config: Config): void;
+//# sourceMappingURL=mineru.d.ts.map

package/lib/types/provider.d.ts

@@ -0,0 +1,23 @@
+/** Synchronous MinerU `/file_parse` document parser provider. */
+import { type DocumentParseRequest, type DocumentParseResult, type DocumentParserProvider } from './index.ts';
+/** Stable parser-provider id recorded with durable parse provenance. */
+export declare const MINERU_PROVIDER_ID = "mineru";
+/** Fully resolved MinerU HTTP policy. Every value is deployment-owned. */
+export interface MinerUProviderOptions {
+    /** Absolute synchronous `POST /file_parse` endpoint. */
+    endpoint: string;
+    /** Maximum wall-clock time for one parse request. */
+    timeoutMs: number;
+    /** Maximum compressed HTTP body and aggregate extracted output bytes. */
+    maxResponseBytes: number;
+}
+/** MinerU external parser implementation. */
+export declare class MinerUDocumentParserProvider implements DocumentParserProvider {
+    readonly id = "mineru";
+    private readonly endpoint;
+    private readonly timeoutMs;
+    private readonly maxResponseBytes;
+    constructor(options: MinerUProviderOptions);
+    parse(request: DocumentParseRequest, signal?: AbortSignal): Promise<DocumentParseResult>;
+}
+//# sourceMappingURL=provider.d.ts.map

package/lib/types/types.d.ts

@@ -0,0 +1,66 @@
+/** Provider-neutral document parsing vocabulary. @module @sparkelf/dsh-plugin-document-attachments/types */
+import type { AttachmentId, ImageAttachmentRef, ImageMediaType } from '@deepseek-ai/dsh-attachment';
+/** Document formats admitted by the Plus generic source integration. */
+export type DocumentMediaType = 'application/pdf' | 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' | 'application/vnd.openxmlformats-officedocument.presentationml.presentation' | 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
+/** Durable original-document reference shared structurally with the patched attachment service. */
+export interface DocumentAttachmentRef {
+    attachmentId: AttachmentId;
+    mediaType: DocumentMediaType;
+    bytes: number;
+    name: string;
+}
+/** Generic durable file metadata shared structurally with the patched AttachmentStore. */
+export interface FileAttachmentRef {
+    attachmentId: AttachmentId;
+    mediaType: string;
+    bytes: number;
+    name?: string;
+}
+/** Durable parser outputs stored before a Document block enters a Session. */
+export interface ParsedDocumentRef {
+    parser: string;
+    markdown: FileAttachmentRef;
+    modelText: FileAttachmentRef;
+    contentList: FileAttachmentRef;
+    images: ImageAttachmentRef[];
+}
+/** Stable parser failure codes used by Host admission and provider diagnostics. */
+export type DocumentParserErrorCode = 'DOCUMENT_PARSER_DUPLICATE_PROVIDER' | 'DOCUMENT_PARSER_CONFIGURED_MISSING' | 'DOCUMENT_PARSER_UNAVAILABLE' | 'DOCUMENT_PARSER_AMBIGUOUS' | 'DOCUMENT_PARSE_FAILED' | 'DOCUMENT_PARSE_INVALID_OUTPUT' | 'DOCUMENT_PARSE_RESPONSE_TOO_LARGE' | 'DOCUMENT_PARSE_TIMEOUT' | 'DOCUMENT_PARSE_ABORTED' | 'DOCUMENT_PARSE_CONTEXT_TOO_LARGE';
+/** One already-persisted original document supplied to a parser provider. */
+export interface DocumentParseRequest {
+    /** Durable original-document metadata. */
+    attachment: DocumentAttachmentRef;
+    /** Exact original bytes resolved from the durable attachment store. */
+    data: Uint8Array;
+}
+/** One extracted raster image returned by a parser before durable persistence. */
+export interface ParsedDocumentImage {
+    /** Parser-relative display name only; never a host storage path. */
+    name: string;
+    /** Declared raster media type validated again by the attachment store on persistence. */
+    mediaType: ImageMediaType;
+    /** Exact extracted image bytes. */
+    data: Uint8Array;
+}
+/** Complete parser output required by the version-one durable document path. */
+export interface DocumentParseResult {
+    /** Complete UTF-8 Markdown bytes used for direct model projection. */
+    markdown: Uint8Array;
+    /** Complete UTF-8 JSON bytes for the parser's reading-order content list. */
+    contentList: Uint8Array;
+    /** Extracted raster images in parser output order. */
+    images: readonly ParsedDocumentImage[];
+}
+/** External parser implementation registered into {@link DocumentParserRuntime}. */
+export interface DocumentParserProvider {
+    /** Stable provider id used by explicit deployment selection and durable parse provenance. */
+    readonly id: string;
+    /**
+     * Parse one original document into the complete version-one output bundle.
+     * @param request - original durable metadata and verified bytes.
+     * @param signal - optional caller cancellation.
+     * @returns complete Markdown, content-list JSON, and extracted images.
+     */
+    parse(request: DocumentParseRequest, signal?: AbortSignal): Promise<DocumentParseResult>;
+}
+//# sourceMappingURL=types.d.ts.map