document-mcp 0.0.0 → 1.1.0

package/dist/bin.js

@@ -0,0 +1,831 @@
+#!/usr/bin/env node
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
+import { McpServer } from "@modelcontextprotocol/server";
+import { DocumentFormatSchema, OdbReportNotSpecifiedError, OdmUnresolvedSectionError, UnrecognizedDocumentSchemaError, base64ToBytes, buildDocumentBytes, bytesToBase64, createLocalDocumentConverter, decodePackage, documentFromJson, evaluateSelect, extractSourceFontsForFormat, layoutDocumentWithSchema, odbReportToDocx, odbReportToOdt, odbReportToPdf, odbToCsv, odbToXlsx, odmToPdf, parseSelect, readDocumentMetadata, readDocxExtras, readOdbForms, readOdbInventory, readOdbReportContent, readOdbReports, readOdbTables, readPdf, setDocumentMetadata } from "documents.js";
+import { z } from "zod";
+import { readFile, writeFile } from "node:fs/promises";
+import { readFontFace } from "pdf-codec";
+import { decodePackage as decodePackage$1 } from "odf.js";
+import { existsSync, readFileSync } from "node:fs";
+import { basename, join } from "node:path";
+//#region package.json
+var version = "1.1.0";
+//#endregion
+//#region src/io/document-input.ts
+const EXTENSION_TO_FORMAT = {
+	docx: "docx",
+	pptx: "pptx",
+	xlsx: "xlsx",
+	odt: "odt",
+	odp: "odp",
+	ods: "ods",
+	odg: "odg",
+	odf: "odf",
+	markdown: "markdown",
+	md: "markdown",
+	pdf: "pdf"
+};
+function inferFormatFromExtension(path) {
+	const lastSegment = path.split(/[/\\]/).pop() ?? path;
+	const dotIndex = lastSegment.lastIndexOf(".");
+	if (dotIndex <= 0) return;
+	const extension = lastSegment.slice(dotIndex + 1).toLowerCase();
+	return EXTENSION_TO_FORMAT[extension];
+}
+/**
+* The hybrid input shape every MCP tool that accepts a document accepts: either a filesystem path (format inferred from its extension) or inline base64-encoded bytes (format required, since there is no filename to infer it from).
+*/
+const DocumentInputSchema = z.union([z.object({ path: z.string().describe("Filesystem path to the document to read. The document format is inferred from the file extension.") }), z.object({
+	bytesBase64: z.string().describe("Base64-encoded document bytes."),
+	format: DocumentFormatSchema.describe("The document format of bytesBase64 -- required, since inline bytes carry no filename to infer it from.")
+})]);
+/**
+* Resolves the hybrid DocumentInput union to concrete bytes and a format: for the path shape, reads the file from disk and infers its format from the extension (throwing if the extension is unrecognised); for the bytesBase64 shape, decodes the inline payload and uses the caller-supplied format directly.
+*/
+async function resolveDocumentInput(input, options) {
+	if ("path" in input) {
+		const format = inferFormatFromExtension(input.path);
+		if (format === void 0) throw new Error(`Could not infer a document format from the file extension of "${input.path}". Recognised extensions: ${Object.keys(EXTENSION_TO_FORMAT).join(", ")}. Pass an explicit format via the bytesBase64 input shape instead.`);
+		const buffer = await readFile(input.path, { signal: options?.signal });
+		return {
+			bytes: new Uint8Array(buffer),
+			format
+		};
+	}
+	return {
+		bytes: base64ToBytes(input.bytesBase64),
+		format: input.format
+	};
+}
+//#endregion
+//#region src/io/document-output.ts
+/**
+* The hybrid output shape every MCP tool that produces a document accepts: an optional filesystem path to write the result to. Omitting it returns the bytes inline, base64-encoded, instead.
+*/
+const DocumentOutputSchema = z.object({ outputPath: z.string().optional().describe("Filesystem path to write the resulting document to. Omit to receive the document bytes inline, base64-encoded, in the tool result instead.") });
+/**
+* Resolves output bytes against the hybrid DocumentOutput shape: writes to `outputPath` and reports the path plus byte length when one is given, otherwise returns the bytes inline as base64 (flagged `large: true` above `LARGE_RESULT_THRESHOLD_BYTES`, never truncated or refused).
+*/
+async function resolveDocumentOutput(bytes, output) {
+	if (output.outputPath !== void 0) {
+		await writeFile(output.outputPath, bytes);
+		return {
+			path: output.outputPath,
+			byteLength: bytes.byteLength
+		};
+	}
+	const bytesBase64 = bytesToBase64(bytes);
+	if (bytes.byteLength > 5242880) return {
+		bytesBase64,
+		byteLength: bytes.byteLength,
+		large: true
+	};
+	return {
+		bytesBase64,
+		byteLength: bytes.byteLength
+	};
+}
+//#endregion
+//#region src/tools/convert.ts
+const DiagnosticSchema = z.object({
+	severity: z.enum(["info", "warning"]),
+	code: z.string(),
+	message: z.string(),
+	pageIndex: z.number().optional()
+});
+const FontSubstitutionSchema$1 = z.object({
+	requestedFamily: z.string(),
+	requestedBold: z.boolean(),
+	requestedItalic: z.boolean(),
+	reason: z.enum(["missing-face", "vendored-substitute"]),
+	resolvedFamily: z.string()
+});
+const ResolvedDocumentOutputSchema = z.union([z.object({
+	path: z.string(),
+	byteLength: z.number()
+}), z.object({
+	bytesBase64: z.string(),
+	byteLength: z.number(),
+	large: z.literal(true).optional()
+})]);
+const FontInputSchema$1 = z.object({
+	family: z.string().describe("The font family name this face provides."),
+	bold: z.boolean().describe("Whether this face is the bold weight."),
+	italic: z.boolean().describe("Whether this face is the italic slope."),
+	bytesBase64: z.string().describe("Base64-encoded font program bytes (TrueType/OpenType/CFF) for this family/weight/style combination.")
+});
+const ConvertDocumentInputSchema = z.object({
+	source: DocumentInputSchema.describe("The document to convert."),
+	targetFormat: DocumentFormatSchema.describe("The format to convert the document to. Not every (source, targetFormat) pair is supported directly -- call list_document_conversions first to confirm this one is."),
+	output: DocumentOutputSchema.optional().describe("Where to write the converted document. Omit entirely to receive the bytes inline, base64-encoded, instead."),
+	fonts: z.array(FontInputSchema$1).optional().describe("Extra font faces to make available to the conversion, for a family the source document does not already embed. Only consulted by a conversion that runs a layout engine (a <format>-to-pdf conversion); every other conversion ignores this option entirely."),
+	onSubstitutionDiagnostics: z.boolean().optional().describe("When true, additionally report each individual font-substitution event as structured fontSubstitutions (which family/weight/style was requested, what it resolved to instead, and why). Every substitution is always reported as a plain diagnostic in `diagnostics` regardless of this flag -- this only controls whether the fuller, structured event is also collected.")
+});
+const ConvertDocumentOutputSchema = z.object({
+	targetFormat: DocumentFormatSchema,
+	output: ResolvedDocumentOutputSchema,
+	diagnostics: z.array(DiagnosticSchema),
+	fontSubstitutions: z.array(FontSubstitutionSchema$1).optional()
+});
+const ListDocumentConversionsOutputSchema = z.object({ conversions: z.array(z.object({
+	source: DocumentFormatSchema,
+	target: DocumentFormatSchema
+})) });
+function registerConvertTools(server) {
+	const converter = createLocalDocumentConverter();
+	server.registerTool("convert_document", {
+		title: "Convert document",
+		description: "Converts a document from one supported format to another via documents.js's DocumentConverter port -- docx, pptx, xlsx, odt, odp, ods, odg, odf, markdown, and pdf. Not every (source, targetFormat) pair is supported directly (odf, for instance, only ever converts to pdf); call list_document_conversions first to see which pairs actually are.",
+		inputSchema: ConvertDocumentInputSchema,
+		outputSchema: ConvertDocumentOutputSchema
+	}, async ({ source, targetFormat, output, fonts, onSubstitutionDiagnostics }, ctx) => {
+		const { signal } = ctx.mcpReq;
+		const { bytes, format } = await resolveDocumentInput(source, { signal });
+		const fontSubstitutions = [];
+		const result = await converter.convert({
+			source: {
+				format,
+				bytes
+			},
+			targetFormat
+		}, {
+			signal,
+			fonts: fonts?.map((font) => ({
+				family: font.family,
+				bold: font.bold,
+				italic: font.italic,
+				bytes: base64ToBytes(font.bytesBase64)
+			})),
+			onFontSubstitution: onSubstitutionDiagnostics === true ? (substitution) => fontSubstitutions.push(substitution) : void 0
+		});
+		const resolvedOutput = await resolveDocumentOutput(result.document.bytes, output ?? {});
+		const structuredContent = {
+			targetFormat: result.document.format,
+			output: resolvedOutput,
+			diagnostics: [...result.diagnostics],
+			...onSubstitutionDiagnostics === true ? { fontSubstitutions: [...fontSubstitutions] } : {}
+		};
+		return {
+			content: [{
+				type: "text",
+				text: JSON.stringify(structuredContent)
+			}],
+			structuredContent
+		};
+	});
+	server.registerTool("list_document_conversions", {
+		title: "List document conversions",
+		description: "Lists every (source, target) format pair convert_document actually supports, straight from documents.js's own DocumentConverter port -- the definitive source of truth for what convert_document will and will not accept as a (source, targetFormat) combination.",
+		outputSchema: ListDocumentConversionsOutputSchema
+	}, () => {
+		const structuredContent = { conversions: converter.conversions.map((conversion) => ({
+			source: conversion.source,
+			target: conversion.target
+		})) };
+		return {
+			content: [{
+				type: "text",
+				text: JSON.stringify(structuredContent)
+			}],
+			structuredContent
+		};
+	});
+}
+//#endregion
+//#region src/tools/docx-extras.ts
+function registerDocxExtrasTools(server) {
+	server.registerTool("docx_extras", {
+		title: "Docx extras",
+		description: "Reads a docx's own comments, footnotes, headers, footers, and numbering definitions -- data documents.js's ContentDocument pivot cannot carry, so ordinary document-reading tools never see it. Returns the real DocxExtras object (comments/footnotes/headers/footers/numbering) as structured data.",
+		inputSchema: z.object({ source: DocumentInputSchema.describe("The docx document to read.") })
+	}, async ({ source }) => {
+		const { bytes } = await resolveDocumentInput(source);
+		const pkg = decodePackage(bytes);
+		const extras = readDocxExtras(pkg);
+		return {
+			content: [{
+				type: "text",
+				text: JSON.stringify(extras)
+			}],
+			structuredContent: extras
+		};
+	});
+}
+//#endregion
+//#region src/tools/fonts.ts
+const FontFileInputSchema = z.union([z.object({ path: z.string().describe("Filesystem path to the font file (.ttf/.otf) to read.") }), z.object({ bytesBase64: z.string().describe("Base64-encoded font file bytes.") })]);
+async function resolveFontFileInput(input) {
+	if ("path" in input) {
+		const buffer = await readFile(input.path);
+		return {
+			bytes: new Uint8Array(buffer),
+			source: input.path
+		};
+	}
+	return {
+		bytes: base64ToBytes(input.bytesBase64),
+		source: "inline font bytes"
+	};
+}
+/** A tool result reporting a problem: `isError: true` with the message as the sole content block, never a thrown exception -- a thrown error from a tool callback surfaces as a JSON-RPC protocol error rather than a result the caller can inspect and recover from. Matches odb.ts's own errorResult/toErrorResult/jsonResult convention. */
+function errorResult$1(message) {
+	return {
+		content: [{
+			type: "text",
+			text: message
+		}],
+		isError: true
+	};
+}
+/** errorResult's counterpart for a caught exception: UnsupportedFontSourceFormatError (extractSourceFontsForFormat rejecting a format with no source-embedded-font concept -- xlsx/pdf/markdown/odf) and FontFaceParseError (readFontFace rejecting bytes that are not a recognised sfnt font, or a .ttc collection) both carry a self-contained, already-actionable message, so there is nothing to add beyond surfacing it verbatim. */
+function toErrorResult$1(error) {
+	return errorResult$1(error instanceof Error ? error.message : String(error));
+}
+/** A successful tool result: the value serialised as the text content block, and returned verbatim as structuredContent for a caller that wants the parsed value directly rather than re-parsing the text block. */
+function jsonResult(value) {
+	return {
+		content: [{
+			type: "text",
+			text: JSON.stringify(value)
+		}],
+		structuredContent: value
+	};
+}
+function registerFontTools(server) {
+	server.registerTool("fonts", {
+		title: "List document fonts",
+		description: "Lists every source-embedded font face a docx/pptx/odt/odp/ods/odg document carries (family, weight/style, byte length).",
+		inputSchema: z.object({ source: DocumentInputSchema.describe("The docx/pptx/odt/odp/ods/odg document to extract source-embedded font faces from.") })
+	}, async ({ source }) => {
+		try {
+			const { bytes, format } = await resolveDocumentInput(source);
+			return jsonResult({ faces: extractSourceFontsForFormat(format, bytes).map((face) => ({
+				family: face.family,
+				bold: face.bold,
+				italic: face.italic,
+				byteLength: face.bytes.length
+			})) });
+		} catch (error) {
+			return toErrorResult$1(error);
+		}
+	});
+	server.registerTool("describe_font_file", {
+		title: "Describe font file",
+		description: "Reads a standalone TrueType/OpenType font file (.ttf/.otf) and reports the family/bold/italic triple it declares about itself.",
+		inputSchema: z.object({ source: FontFileInputSchema.describe("The standalone .ttf/.otf font file to inspect -- not a document.") })
+	}, async ({ source }) => {
+		try {
+			const { bytes, source: label } = await resolveFontFileInput(source);
+			const face = readFontFace(bytes, label);
+			return jsonResult({
+				family: face.family,
+				bold: face.bold,
+				italic: face.italic
+			});
+		} catch (error) {
+			return toErrorResult$1(error);
+		}
+	});
+}
+//#endregion
+//#region src/tools/from-package.ts
+async function readSourceBytes(source) {
+	if ("path" in source) {
+		const buffer = await readFile(source.path);
+		return new Uint8Array(buffer);
+	}
+	return base64ToBytes(source.bytesBase64);
+}
+function errorResult(message) {
+	return {
+		content: [{
+			type: "text",
+			text: message
+		}],
+		isError: true
+	};
+}
+function registerFromPackageTools(server) {
+	server.registerTool("from_package", {
+		title: "Build document from package",
+		description: "Rebuilds real document bytes in a target format from a DocumentPackage previously serialised to JSON (e.g. by a caller's own --dump-package-equivalent step) -- the read side of the DocumentPackage round trip a conversion's onDocument callback produces.",
+		inputSchema: z.object({
+			source: DocumentInputSchema.describe("The DocumentPackage JSON to read. 'path' points at a JSON file on disk -- its extension is never used to infer a document format, since the file holds a DocumentPackage, not a document. 'bytesBase64' carries the JSON inline; its 'format' field is required by the shared hybrid input shape but unused by this tool."),
+			targetFormat: DocumentFormatSchema.describe("The document format to build from the DocumentPackage."),
+			output: DocumentOutputSchema.optional().describe("Where to write the resulting document. Omit entirely (or omit outputPath within it) to receive the bytes inline instead.")
+		})
+	}, async ({ source, targetFormat, output }) => {
+		try {
+			const bytes = await readSourceBytes(source);
+			const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+			let parsed;
+			try {
+				parsed = JSON.parse(text);
+			} catch (error) {
+				return errorResult(`'source' is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+			}
+			const result = documentFromJson(parsed);
+			if (result.kind !== "DocumentPackage") return errorResult(`'source' is a ${result.kind}, not a DocumentPackage -- only a file carrying a real DocumentPackage (e.g. written by a caller's own --dump-package-equivalent step) can be read back by this tool`);
+			const resolvedOutput = await resolveDocumentOutput(buildDocumentBytes(result.value, targetFormat), output ?? {});
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(resolvedOutput)
+				}],
+				structuredContent: resolvedOutput
+			};
+		} catch (error) {
+			if (error instanceof UnrecognizedDocumentSchemaError) return errorResult("'source' has no recognised $schema -- only a file carrying a real DocumentPackage (e.g. written by a caller's own --dump-package-equivalent step) can be read back by this tool");
+			return errorResult(error instanceof Error ? error.message : String(error));
+		}
+	});
+}
+//#endregion
+//#region src/tools/metadata.ts
+function toErrorResult(error) {
+	return {
+		content: [{
+			type: "text",
+			text: error instanceof Error ? error.message : String(error)
+		}],
+		isError: true
+	};
+}
+function registerMetadataTools(server) {
+	server.registerTool("metadata_read", {
+		title: "Read document metadata",
+		description: "Reads a document's own title/author/subject/keywords/creator/producer/created-and-modified-timestamp metadata. Works across every supported format, including xlsx (read via a throwaway xlsx-to-pdf preview, since documents.js has no dedicated xlsx metadata reader of its own) and odf (a standalone formula document).",
+		inputSchema: z.object({ source: DocumentInputSchema.describe("The document to read metadata from.") })
+	}, async ({ source }) => {
+		try {
+			const { bytes, format } = await resolveDocumentInput(source);
+			const metadata = readDocumentMetadata(format, bytes);
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(metadata)
+				}],
+				structuredContent: metadata
+			};
+		} catch (error) {
+			return toErrorResult(error);
+		}
+	});
+	server.registerTool("metadata_write", {
+		title: "Write document metadata",
+		description: "Patches a document's own title/author/subject/keywords, leaving every other field and every other flag as-is. Does not convert format -- the source document's own format and targetFormat must match (or both be 'pdf'); xlsx and odf are rejected outright as either a source or a target, in both directions. Convert the document to a different format first (e.g. with a documents.js conversion tool) if metadata needs to be set on the result of a format change.",
+		inputSchema: z.object({
+			source: DocumentInputSchema.describe("The document to patch metadata on."),
+			targetFormat: DocumentFormatSchema.describe("The format to write the patched document back out as -- must match the source document's own format (or both be 'pdf'). metadata_write never converts format."),
+			output: DocumentOutputSchema.optional().describe("Where to write the patched document. Omit entirely to receive the bytes inline, base64-encoded."),
+			setTitle: z.string().optional().describe("Set the title field. Omit to leave it exactly as the source document already has it."),
+			setAuthor: z.string().optional().describe("Set the author field. Omit to leave it exactly as the source document already has it."),
+			setSubject: z.string().optional().describe("Set the subject field. Omit to leave it exactly as the source document already has it."),
+			setKeywords: z.array(z.string()).optional().describe("Set the keywords field. Omit to leave it exactly as the source document already has it.")
+		})
+	}, async ({ source, targetFormat, output, setTitle, setAuthor, setSubject, setKeywords }) => {
+		try {
+			const { bytes, format } = await resolveDocumentInput(source);
+			const resolvedOutput = await resolveDocumentOutput(setDocumentMetadata(format, targetFormat, bytes, {
+				title: setTitle,
+				author: setAuthor,
+				subject: setSubject,
+				keywords: setKeywords
+			}), output ?? {});
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(resolvedOutput)
+				}],
+				structuredContent: resolvedOutput
+			};
+		} catch (error) {
+			return toErrorResult(error);
+		}
+	});
+}
+//#endregion
+//#region src/tools/odb.ts
+const ODB_SOURCE_DESCRIPTION = ".odb database to read. 'path' points at the .odb file on disk -- its extension is never used to infer a document format, since documents.js deliberately excludes 'odb' from DocumentFormat (an embedded database front end has no single natural target format -- tables, saved queries, and reports are three unrelated output shapes -- see that package's own README). 'bytesBase64' carries the .odb bytes inline; its 'format' field is required by the shared hybrid input shape but unused by every odb tool.";
+async function resolveOdbBytes$1(source) {
+	if ("path" in source) {
+		const buffer = await readFile(source.path);
+		return new Uint8Array(buffer);
+	}
+	return base64ToBytes(source.bytesBase64);
+}
+/** Resolves an .odb DocumentInput straight through to a decoded odf.js Package -- the shape every read (as opposed to export) odb tool needs. */
+async function resolveOdbPackage(source) {
+	return decodePackage$1(await resolveOdbBytes$1(source));
+}
+/** Resolves a saved query's own SQL text by name against the .odb's own db:queries (read via readOdbInventory) -- odb_query's own equivalent of document-cli's resolveQuerySql, for the case where the caller named a saved query rather than supplying SQL directly. Throws, naming every available query, when the name doesn't resolve -- see this module's own top-of-file note on why a thrown Error is the right shape here. */
+function resolveSavedQuerySql(pkg, name) {
+	const inventory = readOdbInventory(pkg);
+	const saved = inventory.queries.find((candidate) => candidate.name === name);
+	if (saved === void 0) {
+		const available = inventory.queries.map((candidate) => candidate.name);
+		throw new Error(`This .odb declares no saved query named "${name}".${available.length === 0 ? "" : ` Available: ${available.join(", ")}.`}`);
+	}
+	return saved.command;
+}
+/** Classifies odb_query's own sql/query pair before any package is read: exactly one of the two must be given. Throws for either "both given" or "neither given". Kept as a pure, synchronous check (no Package involved) so both variables narrow cleanly through ordinary control flow, rather than needing a cross-variable inference TypeScript can't derive from two separate `!== undefined` checks. */
+function classifyQueryInput(sql, query) {
+	if (sql !== void 0 && query !== void 0) throw new Error("Provide \"sql\" or \"query\", not both.");
+	if (sql !== void 0) return {
+		kind: "literal",
+		sql
+	};
+	if (query !== void 0) return {
+		kind: "saved",
+		name: query
+	};
+	throw new Error("Provide either \"sql\" (a literal SELECT statement) or \"query\" (the name of one of this .odb's own saved queries).");
+}
+function registerOdbTools(server) {
+	server.registerTool("odb_tables", {
+		title: "List .odb tables",
+		description: "Lists every table an embedded .odb database declares -- column names, types, and row data -- across every storage tier documents.js supports (HSQLDB TEXT/CACHED/BINARY script formats, Firebird gbak backups).",
+		inputSchema: z.object({ source: DocumentInputSchema.describe(ODB_SOURCE_DESCRIPTION) })
+	}, async ({ source }) => {
+		const pkg = await resolveOdbPackage(source);
+		const tables = readOdbTables(pkg);
+		return {
+			content: [{
+				type: "text",
+				text: JSON.stringify(tables)
+			}],
+			structuredContent: tables
+		};
+	});
+	server.registerTool("odb_forms", {
+		title: "List .odb forms",
+		description: "Lists every form an .odb database declares, with each form's own data source and field-bound controls.",
+		inputSchema: z.object({ source: DocumentInputSchema.describe(ODB_SOURCE_DESCRIPTION) })
+	}, async ({ source }) => {
+		const pkg = await resolveOdbPackage(source);
+		const forms = readOdbForms(pkg);
+		return {
+			content: [{
+				type: "text",
+				text: JSON.stringify(forms)
+			}],
+			structuredContent: forms
+		};
+	});
+	server.registerTool("odb_reports", {
+		title: "List .odb reports",
+		description: "Lists every report an .odb database declares, with each report's own data-source command, band/group structure, and rpt: formula expressions.",
+		inputSchema: z.object({ source: DocumentInputSchema.describe(ODB_SOURCE_DESCRIPTION) })
+	}, async ({ source }) => {
+		const pkg = await resolveOdbPackage(source);
+		const reports = readOdbReports(pkg);
+		return {
+			content: [{
+				type: "text",
+				text: JSON.stringify(reports)
+			}],
+			structuredContent: reports
+		};
+	});
+	server.registerTool("odb_query", {
+		title: "Query an .odb database",
+		description: "Runs a bounded single-table SELECT over an embedded .odb database's own extracted tables, given directly as SQL or by naming one of the database's saved queries. No database engine is involved -- the query runs in memory over the same tables odb_tables would return, against a closed grammar (SELECT/WHERE/GROUP BY/ORDER BY, no joins or subqueries); an unsupported construct is reported as a tool error naming it, never silently ignored.",
+		inputSchema: z.object({
+			source: DocumentInputSchema.describe(ODB_SOURCE_DESCRIPTION),
+			sql: z.string().describe("A literal SELECT statement to run. Mutually exclusive with \"query\".").optional(),
+			query: z.string().describe("The name of one of the .odb's own saved queries to run. Mutually exclusive with \"sql\".").optional()
+		})
+	}, async ({ source, sql, query }) => {
+		const spec = classifyQueryInput(sql, query);
+		const pkg = await resolveOdbPackage(source);
+		const resolvedSql = spec.kind === "literal" ? spec.sql : resolveSavedQuerySql(pkg, spec.name);
+		const result = evaluateSelect(parseSelect(resolvedSql), readOdbTables(pkg));
+		return {
+			content: [{
+				type: "text",
+				text: JSON.stringify(result)
+			}],
+			structuredContent: result
+		};
+	});
+	server.registerTool("odb_to_csv", {
+		title: "Export one .odb table to CSV",
+		description: "Extracts exactly one named table from an embedded .odb database as CSV bytes. The table name is required whenever the database declares more than one table.",
+		inputSchema: z.object({
+			source: DocumentInputSchema.describe(ODB_SOURCE_DESCRIPTION),
+			table: z.string().describe("The table to export -- required when the .odb declares more than one table.").optional(),
+			output: DocumentOutputSchema.optional().describe("Where to write the resulting CSV. Omit entirely (or omit outputPath within it) to receive the bytes inline instead.")
+		})
+	}, async ({ source, table, output }, ctx) => {
+		const bytes = await resolveOdbBytes$1(source);
+		const resolvedOutput = await resolveDocumentOutput(odbToCsv(bytes, {
+			signal: ctx.mcpReq.signal,
+			table
+		}), output ?? {});
+		return {
+			content: [{
+				type: "text",
+				text: JSON.stringify(resolvedOutput)
+			}],
+			structuredContent: resolvedOutput
+		};
+	});
+	server.registerTool("odb_to_xlsx", {
+		title: "Export .odb tables to xlsx",
+		description: "Extracts every table an embedded .odb database declares into one xlsx workbook, one sheet per table.",
+		inputSchema: z.object({
+			source: DocumentInputSchema.describe(ODB_SOURCE_DESCRIPTION),
+			output: DocumentOutputSchema.optional().describe("Where to write the resulting xlsx workbook. Omit entirely (or omit outputPath within it) to receive the bytes inline instead.")
+		})
+	}, async ({ source, output }, ctx) => {
+		const bytes = await resolveOdbBytes$1(source);
+		const resolvedOutput = await resolveDocumentOutput(odbToXlsx(bytes, { signal: ctx.mcpReq.signal }), output ?? {});
+		return {
+			content: [{
+				type: "text",
+				text: JSON.stringify(resolvedOutput)
+			}],
+			structuredContent: resolvedOutput
+		};
+	});
+}
+//#endregion
+//#region src/tools/odb-render-report.ts
+async function resolveOdbBytes(source) {
+	if ("path" in source) {
+		const buffer = await readFile(source.path);
+		return new Uint8Array(buffer);
+	}
+	return base64ToBytes(source.bytesBase64);
+}
+const FontInputSchema = z.object({
+	family: z.string().describe("The font family name this face provides."),
+	bold: z.boolean().describe("Whether this face is the bold weight."),
+	italic: z.boolean().describe("Whether this face is the italic slope."),
+	bytesBase64: z.string().describe("Base64-encoded font program bytes (TrueType/OpenType/CFF) for this family/weight/style combination.")
+});
+const OdbRenderReportTargetFormatSchema = z.enum([
+	"docx",
+	"odt",
+	"pdf"
+]);
+const OdbRenderReportInputSchema = z.object({
+	source: DocumentInputSchema.describe(".odb database to render a report from. 'path' points at the .odb file on disk -- its extension is never used to infer a document format, since documents.js deliberately excludes 'odb' from DocumentFormat (an embedded database front end has no single natural target format -- tables, saved queries, and reports are three unrelated output shapes -- see that package's own README). 'bytesBase64' carries the .odb bytes inline; its 'format' field is required by the shared hybrid input shape but unused by this tool."),
+	report: z.string().optional().describe("The name of the report to render. Required only when the .odb declares more than one report -- omitting it when exactly one is declared renders that one automatically."),
+	targetFormat: OdbRenderReportTargetFormatSchema.describe("The format to render the report into."),
+	output: DocumentOutputSchema.optional().describe("Where to write the rendered report. Omit entirely (or omit outputPath within it) to receive the bytes inline instead."),
+	fonts: z.array(FontInputSchema).optional().describe("Extra font faces to make available, for a family the rendered report's own text otherwise falls back on. Only consulted when targetFormat is 'pdf' -- docx and odt output is genuine editable text with no font-embedding step of its own, so fonts is ignored for those two targets.")
+});
+const MathDiagnosticSchema = z.object({
+	kind: z.enum(["unsupported-element", "approximated-element"]),
+	detail: z.string(),
+	sourcePath: z.string().optional()
+});
+const FontSubstitutionSchema = z.object({
+	requestedFamily: z.string(),
+	requestedBold: z.boolean(),
+	requestedItalic: z.boolean(),
+	reason: z.enum(["missing-face", "vendored-substitute"]),
+	resolvedFamily: z.string()
+});
+const CharSubstitutionSchema = z.object({
+	from: z.string(),
+	to: z.string(),
+	pageIndex: z.number()
+});
+const diagnosticsShape = {
+	mathDiagnostics: z.array(MathDiagnosticSchema),
+	fontSubstitutions: z.array(FontSubstitutionSchema),
+	charSubstitutions: z.array(CharSubstitutionSchema)
+};
+const OdbRenderReportOutputSchema = z.union([z.object({
+	path: z.string(),
+	byteLength: z.number(),
+	...diagnosticsShape
+}), z.object({
+	bytesBase64: z.string(),
+	byteLength: z.number(),
+	large: z.literal(true).optional(),
+	...diagnosticsShape
+})]);
+function odbReportNotSpecifiedResult(error) {
+	return {
+		isError: true,
+		content: [{
+			type: "text",
+			text: error.message
+		}],
+		structuredContent: { availableReports: error.availableReports }
+	};
+}
+function registerOdbRenderReportTools(server) {
+	server.registerTool("odb_render_report", {
+		title: "Render .odb report",
+		description: "Resolves one of an .odb database's own reports -- its data-bound command run through the bounded SQL engine, its rpt: formulas evaluated, its bands laid out -- and renders the result to docx, odt, or pdf.",
+		inputSchema: OdbRenderReportInputSchema,
+		outputSchema: OdbRenderReportOutputSchema
+	}, async ({ source, report, targetFormat, output, fonts }, ctx) => {
+		const { signal } = ctx.mcpReq;
+		const inputBytes = await resolveOdbBytes(source);
+		const pkg = decodePackage$1(inputBytes);
+		let content;
+		try {
+			content = readOdbReportContent(pkg, { report });
+		} catch (error) {
+			if (error instanceof OdbReportNotSpecifiedError) return odbReportNotSpecifiedResult(error);
+			throw error;
+		}
+		const mathDiagnostics = [];
+		const recordMathDiagnostic = (diagnostic, diagnosticContext) => {
+			mathDiagnostics.push({
+				kind: diagnostic.kind,
+				detail: diagnostic.detail,
+				sourcePath: diagnosticContext.sourcePath
+			});
+		};
+		const fontSubstitutions = [];
+		const charSubstitutions = [];
+		let bytes;
+		if (targetFormat === "docx") bytes = odbReportToDocx(content, {
+			signal,
+			onMathDiagnostic: recordMathDiagnostic
+		});
+		else if (targetFormat === "odt") bytes = odbReportToOdt(content, { signal });
+		else bytes = odbReportToPdf(content, {
+			signal,
+			fonts: fonts?.map((font) => ({
+				family: font.family,
+				bold: font.bold,
+				italic: font.italic,
+				bytes: base64ToBytes(font.bytesBase64)
+			})),
+			onFontSubstitution: (substitution) => fontSubstitutions.push(substitution),
+			onSubstitution: (substitution, substitutionContext) => {
+				charSubstitutions.push({
+					from: substitution.from,
+					to: substitution.to,
+					pageIndex: substitutionContext.pageIndex
+				});
+			},
+			onMathDiagnostic: recordMathDiagnostic
+		});
+		const structuredContent = {
+			...await resolveDocumentOutput(bytes, output ?? {}),
+			mathDiagnostics,
+			fontSubstitutions,
+			charSubstitutions
+		};
+		return {
+			content: [{
+				type: "text",
+				text: JSON.stringify(structuredContent)
+			}],
+			structuredContent
+		};
+	});
+}
+//#endregion
+//#region src/tools/odm.ts
+const OdmMasterSourceSchema = z.union([z.object({ path: z.string().describe("Filesystem path to the .odm master document to convert.") }), z.object({ bytesBase64: z.string().describe("Base64-encoded .odm master document bytes.") })]);
+async function resolveOdmMasterBytes(source) {
+	if ("path" in source) return new Uint8Array(await readFile(source.path));
+	return base64ToBytes(source.bytesBase64);
+}
+const OdmChapterInputSchema = z.object({
+	href: z.string().describe("The chapter's own text:section-source href as declared inside the .odm master document (e.g. '../chapter1.odt')."),
+	source: DocumentInputSchema.describe("The chapter document's own bytes -- always read as odt, regardless of the format this hybrid input declares.")
+});
+const OdmToPdfInputSchema = z.object({
+	source: OdmMasterSourceSchema.describe("The .odm master document to convert."),
+	chapters: z.array(OdmChapterInputSchema).default([]).describe("Explicit href -> chapter document overrides. Checked before chaptersDir for a given href."),
+	chaptersDir: z.string().optional().describe("Directory to search for each unresolved chapter href, matched by the href's own basename. Checked after chapters."),
+	output: DocumentOutputSchema.default({}).describe("Where to write the resulting PDF. Omit to receive the bytes inline, base64-encoded.")
+});
+const OdmToPdfOutputSchema = z.union([z.object({
+	path: z.string(),
+	byteLength: z.number()
+}), z.object({
+	bytesBase64: z.string(),
+	byteLength: z.number(),
+	large: z.literal(true).optional()
+})]);
+function registerOdmTools(server) {
+	server.registerTool("odm_to_pdf", {
+		title: "Convert ODM master document to PDF",
+		description: "Converts a .odm (ODF master document) to PDF. A .odm never carries its own chapters' content inline -- every text:section is a bare external reference to a standalone .odt file -- so each chapter the master document declares must resolve through `chapters` (an explicit href -> document override) and/or `chaptersDir` (a directory searched by the href's own basename), checked in that order. A chapter left unresolved by both fails the whole conversion, naming every unresolved href.",
+		inputSchema: OdmToPdfInputSchema,
+		outputSchema: OdmToPdfOutputSchema
+	}, async ({ source, chapters, chaptersDir, output }) => {
+		const masterBytes = await resolveOdmMasterBytes(source);
+		const overrides = /* @__PURE__ */ new Map();
+		for (const chapter of chapters) {
+			const { bytes: chapterBytes } = await resolveDocumentInput(chapter.source);
+			overrides.set(chapter.href, chapterBytes);
+		}
+		const resolveSubDocument = (href) => {
+			const overrideBytes = overrides.get(href);
+			if (overrideBytes !== void 0) return overrideBytes;
+			if (chaptersDir === void 0) return;
+			const candidate = join(chaptersDir, basename(href));
+			if (!existsSync(candidate)) return;
+			return new Uint8Array(readFileSync(candidate));
+		};
+		try {
+			const result = await resolveDocumentOutput(odmToPdf(masterBytes, { resolveSubDocument }), output);
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(result)
+				}],
+				structuredContent: result
+			};
+		} catch (error) {
+			if (error instanceof OdmUnresolvedSectionError) return {
+				isError: true,
+				content: [{
+					type: "text",
+					text: `${error.message}\nPass chaptersDir <dir> containing these files, or an explicit chapters override, for each href.`
+				}],
+				structuredContent: { hrefs: error.hrefs }
+			};
+			throw error;
+		}
+	});
+}
+//#endregion
+//#region src/tools/pdf-inspect.ts
+function buildItemKindHistogram(items) {
+	const histogram = /* @__PURE__ */ new Map();
+	for (const item of items) histogram.set(item.kind, (histogram.get(item.kind) ?? 0) + 1);
+	return histogram;
+}
+function countImagesByFormat(images) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const asset of Object.values(images)) counts.set(asset.format, (counts.get(asset.format) ?? 0) + 1);
+	return counts;
+}
+function registerPdfInspectTools(server) {
+	server.registerTool("pdf_inspect", {
+		title: "Inspect PDF",
+		description: "Parses a PDF (documents.js's readPdf) and reports a summary: page count, each page's own size and item-kind histogram, document metadata, and embedded image formats. Pass full: true to return the entire parsed LayoutDocument (tagged with its own $schema) instead of a summary.",
+		inputSchema: z.object({
+			source: DocumentInputSchema.describe("The PDF document to inspect."),
+			full: z.boolean().optional().describe("When true, return the entire parsed LayoutDocument instead of a summary. Defaults to false.")
+		})
+	}, async ({ source, full }, ctx) => {
+		const { signal } = ctx.mcpReq;
+		const { bytes, format } = await resolveDocumentInput(source, { signal });
+		if (format !== "pdf") throw new Error(`pdf_inspect requires a PDF document, received a "${format}" document instead.`);
+		const layout = readPdf(bytes, { signal });
+		if (full === true) {
+			const tagged = layoutDocumentWithSchema(layout);
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(tagged)
+				}],
+				structuredContent: tagged
+			};
+		}
+		const summary = {
+			pageCount: layout.pages.length,
+			pages: layout.pages.map((page) => ({
+				widthPt: page.widthPt,
+				heightPt: page.heightPt,
+				itemKinds: Object.fromEntries(buildItemKindHistogram(page.items))
+			})),
+			metadata: layout.metadata,
+			imagesByFormat: Object.fromEntries(countImagesByFormat(layout.images))
+		};
+		return {
+			content: [{
+				type: "text",
+				text: JSON.stringify(summary)
+			}],
+			structuredContent: summary
+		};
+	});
+}
+//#endregion
+//#region src/server.ts
+function createServer() {
+	const server = new McpServer({
+		name: "document-mcp",
+		version
+	});
+	registerConvertTools(server);
+	registerDocxExtrasTools(server);
+	registerFontTools(server);
+	registerFromPackageTools(server);
+	registerMetadataTools(server);
+	registerOdbTools(server);
+	registerOdbRenderReportTools(server);
+	registerOdmTools(server);
+	registerPdfInspectTools(server);
+	return server;
+}
+//#endregion
+//#region src/bin.ts
+serveStdio(createServer);
+//#endregion
+export {};