document-mcp 4.1.4 → 4.1.5

package/README.md

@@ -214,7 +214,7 @@ Every tool that takes or produces document bytes goes through the same two hybri
 | `pdf_inspect`               | Parses a PDF and reports a summary (page count, per-page size and item-kind histogram, metadata, embedded image formats), or with `full: true` the entire parsed `LayoutDocument` as plain JSON — no `$schema` stamp, since that family moved to `pdf-codec` at `document-schema.js` 4.0.0 and lost its schema-stamped envelope.                                                                                                                                                                                                                                                 |
 | `odm_to_pdf`                | Converts a `.odm` (ODF master document) to PDF. A `.odm` never carries its chapters' content inline, so each chapter resolves via a caller-supplied `chapters` href-to-document map and/or a `chaptersDir` searched by basename.                                                                                                                                                                                                                                                                                                                                                 |
 | `from_package`              | Rebuilds real document bytes in a target format from a `DocumentTree` previously serialised to JSON (e.g. by a conversion tool's own `onDocument`/package-dump step). Only a package genuinely written by a current dump round-trips: the `$schema` URI it carries pins the `document-schema.js` release that wrote it, and a pre-4.0.0 dump (the flat `{ formatVersion, content, pages }` envelope) is rejected with an error naming the pinned release, the flat-to-tree change, and the remedy — a layout-document dump gets its own pointer, naming the move to `pdf-codec`. |
-| `outline_document`          | Projects a document's own table of contents as structured JSON: groups (`{ text, level, children }`) for headings, list items, slides, sheets, and draw pages, leaves (`{ kind, text }`) for the content between them. The outline is over the source's own content — read through `documents.js`'s `DocumentConverter` port and built by `document-outline.js`'s `buildOutline`.                                                                                                                                                                                                |
+| `outline_document`          | Projects a document's own table of contents as structured JSON: groups (`{ text, level, children }`) for headings, list items, slides, sheets, and draw pages, leaves (`{ kind, text }`) for the content between them. The outline is over the source's own native content — read directly via `documents.js`'s `readNativeDocumentTree` (no bridging conversion, no discarded output bytes) and built by `document-outline.js`'s `buildOutline`.                                                                                                                                |
 | `odb_tables`                | 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, Firebird gbak backups).                                                                                                                                                                                                                                                                                                                                                                               |
 | `odb_forms`                 | Lists every form an `.odb` database declares, with each form's own data source and field-bound controls.                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
 | `odb_reports`               | Lists every report an `.odb` database declares, with each report's own data-source command, band/group structure, and `rpt:` formula expressions.                                                                                                                                                                                                                                                                                                                                                                                                                                |

package/dist/bin.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import { serveStdio } from "@modelcontextprotocol/server/stdio";
 import { McpServer } from "@modelcontextprotocol/server";
-import { DocumentFormatSchema, OdbReportNotSpecifiedError, OdmUnresolvedSectionError, UnrecognizedDocumentSchemaError, base64ToBytes, buildDocumentBytes, bytesToBase64, createLocalDocumentConverter, decodeOdbPackage, decodePackage, describeFontFace, documentFromJson, documentSchemaKindOf, evaluateSelect, extractSourceFontsForFormat, odbReportToDocx, odbReportToOdt, odbReportToPdf, odbToCsv, odbToXlsx, odmToPdf, parseSelect, readDocumentMetadata, readDocxExtras, readOdbForms, readOdbInventory, readOdbReportContent, readOdbReports, readOdbTables, readPdf, setDocumentMetadata } from "documents.js";
+import { DocumentFormatSchema, OdbReportNotSpecifiedError, OdmUnresolvedSectionError, UnrecognizedDocumentSchemaError, base64ToBytes, buildDocumentBytes, bytesToBase64, createLocalDocumentConverter, decodeOdbPackage, decodePackage, describeFontFace, documentFromJson, documentSchemaKindOf, evaluateSelect, extractSourceFontsForFormat, odbReportToDocx, odbReportToOdt, odbReportToPdf, odbToCsv, odbToXlsx, odmToPdf, parseSelect, readDocumentMetadata, readDocxExtras, readNativeDocumentTree, readOdbForms, readOdbInventory, readOdbReportContent, readOdbReports, readOdbTables, readPdf, setDocumentMetadata } from "documents.js";
 import { z } from "zod";
 import { readFile, writeFile } from "node:fs/promises";
 import { existsSync, readFileSync } from "node:fs";
 import { basename, join } from "node:path";
 import { buildOutline, isOutlineNode, outlineLeafText } from "document-outline.js";
 //#region package.json
-var version = "4.1.4";
+var version = "4.1.5";
 //#endregion
 //#region src/io/document-input.ts
 const EXTENSION_TO_FORMAT = {
@@ -776,20 +776,6 @@ function registerOdmTools(server) {
 }
 //#endregion
 //#region src/tools/outline.ts
-const OUTLINE_PROBE_TARGETS = {
-	csv: "ods",
-	docx: "odt",
-	odf: "pdf",
-	odg: "pdf",
-	odt: "docx",
-	odp: "pptx",
-	ods: "xlsx",
-	markdown: "docx",
-	pdf: "docx",
-	pptx: "odp",
-	svg: "odg",
-	xlsx: "ods"
-};
 function leafKind(leaf) {
 	if ("kind" in leaf) return leaf.kind;
 	if ("mathml" in leaf) return "formula";
@@ -806,27 +792,18 @@ function toOutlineJson(children) {
 	});
 }
 function registerOutlineTools(server) {
-	const converter = createLocalDocumentConverter();
 	server.registerTool("outline_document", {
 		title: "Outline document",
-		description: "Projects a document's table of contents as a structured outline: reads the source through documents.js's DocumentConverter port, takes the tree-form DocumentTree the conversion reports, and runs document-outline.js's buildOutline over it. Groups carry { text, level, children } (a heading's, list item's, slide's, sheet's, or page's own label plus nested children); leaves carry { kind, text }. The outline is over the source's own content -- the internal conversion target preserves it and is pdf only for odf (the one format that only converts to pdf) and odg (whose alternative, svg, cannot represent more than one page).",
+		description: "Projects a document's table of contents as a structured outline: reads the source's own native DocumentTree directly (documents.js's readNativeDocumentTree -- no bridging conversion, no discarded output bytes) and runs document-outline.js's buildOutline over it. Groups carry { text, level, children } (a heading's, list item's, slide's, sheet's, or page's own label plus nested children); leaves carry { kind, text }.",
 		inputSchema: z.object({ source: DocumentInputSchema.describe("The document to outline.") })
 	}, async ({ source }, ctx) => {
 		const { signal } = ctx.mcpReq;
 		const { bytes, format } = await resolveDocumentInput(source, { signal });
-		const targetFormat = OUTLINE_PROBE_TARGETS[format];
-		const pkg = (await converter.convert({
-			source: {
-				format,
-				bytes
-			},
-			targetFormat
-		}, { signal })).package;
-		if (pkg === void 0) throw new Error(`the ${format}-to-${targetFormat} conversion reported no DocumentTree, so there is no tree to outline`);
+		const tree = readNativeDocumentTree(format, bytes, { signal });
 		const structuredContent = {
 			sourceFormat: format,
-			kind: pkg.kind,
-			outline: toOutlineJson(buildOutline(pkg))
+			kind: tree.kind,
+			outline: toOutlineJson(buildOutline(tree))
 		};
 		return {
 			content: [{

package/dist/index.cjs

@@ -7,7 +7,7 @@ let node_fs = require("node:fs");
 let node_path = require("node:path");
 let document_outline_js = require("document-outline.js");
 //#region package.json
-var version = "4.1.4";
+var version = "4.1.5";
 //#endregion
 //#region src/io/document-input.ts
 const EXTENSION_TO_FORMAT = {
@@ -775,20 +775,6 @@ function registerOdmTools(server) {
 }
 //#endregion
 //#region src/tools/outline.ts
-const OUTLINE_PROBE_TARGETS = {
-	csv: "ods",
-	docx: "odt",
-	odf: "pdf",
-	odg: "pdf",
-	odt: "docx",
-	odp: "pptx",
-	ods: "xlsx",
-	markdown: "docx",
-	pdf: "docx",
-	pptx: "odp",
-	svg: "odg",
-	xlsx: "ods"
-};
 function leafKind(leaf) {
 	if ("kind" in leaf) return leaf.kind;
 	if ("mathml" in leaf) return "formula";
@@ -805,27 +791,18 @@ function toOutlineJson(children) {
 	});
 }
 function registerOutlineTools(server) {
-	const converter = (0, documents_js.createLocalDocumentConverter)();
 	server.registerTool("outline_document", {
 		title: "Outline document",
-		description: "Projects a document's table of contents as a structured outline: reads the source through documents.js's DocumentConverter port, takes the tree-form DocumentTree the conversion reports, and runs document-outline.js's buildOutline over it. Groups carry { text, level, children } (a heading's, list item's, slide's, sheet's, or page's own label plus nested children); leaves carry { kind, text }. The outline is over the source's own content -- the internal conversion target preserves it and is pdf only for odf (the one format that only converts to pdf) and odg (whose alternative, svg, cannot represent more than one page).",
+		description: "Projects a document's table of contents as a structured outline: reads the source's own native DocumentTree directly (documents.js's readNativeDocumentTree -- no bridging conversion, no discarded output bytes) and runs document-outline.js's buildOutline over it. Groups carry { text, level, children } (a heading's, list item's, slide's, sheet's, or page's own label plus nested children); leaves carry { kind, text }.",
 		inputSchema: zod.z.object({ source: DocumentInputSchema.describe("The document to outline.") })
 	}, async ({ source }, ctx) => {
 		const { signal } = ctx.mcpReq;
 		const { bytes, format } = await resolveDocumentInput(source, { signal });
-		const targetFormat = OUTLINE_PROBE_TARGETS[format];
-		const pkg = (await converter.convert({
-			source: {
-				format,
-				bytes
-			},
-			targetFormat
-		}, { signal })).package;
-		if (pkg === void 0) throw new Error(`the ${format}-to-${targetFormat} conversion reported no DocumentTree, so there is no tree to outline`);
+		const tree = (0, documents_js.readNativeDocumentTree)(format, bytes, { signal });
 		const structuredContent = {
 			sourceFormat: format,
-			kind: pkg.kind,
-			outline: toOutlineJson((0, document_outline_js.buildOutline)(pkg))
+			kind: tree.kind,
+			outline: toOutlineJson((0, document_outline_js.buildOutline)(tree))
 		};
 		return {
 			content: [{

package/dist/index.js

@@ -1,12 +1,12 @@
 import { McpServer } from "@modelcontextprotocol/server";
-import { DocumentFormatSchema, OdbReportNotSpecifiedError, OdmUnresolvedSectionError, UnrecognizedDocumentSchemaError, base64ToBytes, buildDocumentBytes, bytesToBase64, createLocalDocumentConverter, decodeOdbPackage, decodePackage, describeFontFace, documentFromJson, documentSchemaKindOf, evaluateSelect, extractSourceFontsForFormat, odbReportToDocx, odbReportToOdt, odbReportToPdf, odbToCsv, odbToXlsx, odmToPdf, parseSelect, readDocumentMetadata, readDocxExtras, readOdbForms, readOdbInventory, readOdbReportContent, readOdbReports, readOdbTables, readPdf, setDocumentMetadata } from "documents.js";
+import { DocumentFormatSchema, OdbReportNotSpecifiedError, OdmUnresolvedSectionError, UnrecognizedDocumentSchemaError, base64ToBytes, buildDocumentBytes, bytesToBase64, createLocalDocumentConverter, decodeOdbPackage, decodePackage, describeFontFace, documentFromJson, documentSchemaKindOf, evaluateSelect, extractSourceFontsForFormat, odbReportToDocx, odbReportToOdt, odbReportToPdf, odbToCsv, odbToXlsx, odmToPdf, parseSelect, readDocumentMetadata, readDocxExtras, readNativeDocumentTree, readOdbForms, readOdbInventory, readOdbReportContent, readOdbReports, readOdbTables, readPdf, setDocumentMetadata } from "documents.js";
 import { z } from "zod";
 import { readFile, writeFile } from "node:fs/promises";
 import { existsSync, readFileSync } from "node:fs";
 import { basename, join } from "node:path";
 import { buildOutline, isOutlineNode, outlineLeafText } from "document-outline.js";
 //#region package.json
-var version = "4.1.4";
+var version = "4.1.5";
 //#endregion
 //#region src/io/document-input.ts
 const EXTENSION_TO_FORMAT = {
@@ -774,20 +774,6 @@ function registerOdmTools(server) {
 }
 //#endregion
 //#region src/tools/outline.ts
-const OUTLINE_PROBE_TARGETS = {
-	csv: "ods",
-	docx: "odt",
-	odf: "pdf",
-	odg: "pdf",
-	odt: "docx",
-	odp: "pptx",
-	ods: "xlsx",
-	markdown: "docx",
-	pdf: "docx",
-	pptx: "odp",
-	svg: "odg",
-	xlsx: "ods"
-};
 function leafKind(leaf) {
 	if ("kind" in leaf) return leaf.kind;
 	if ("mathml" in leaf) return "formula";
@@ -804,27 +790,18 @@ function toOutlineJson(children) {
 	});
 }
 function registerOutlineTools(server) {
-	const converter = createLocalDocumentConverter();
 	server.registerTool("outline_document", {
 		title: "Outline document",
-		description: "Projects a document's table of contents as a structured outline: reads the source through documents.js's DocumentConverter port, takes the tree-form DocumentTree the conversion reports, and runs document-outline.js's buildOutline over it. Groups carry { text, level, children } (a heading's, list item's, slide's, sheet's, or page's own label plus nested children); leaves carry { kind, text }. The outline is over the source's own content -- the internal conversion target preserves it and is pdf only for odf (the one format that only converts to pdf) and odg (whose alternative, svg, cannot represent more than one page).",
+		description: "Projects a document's table of contents as a structured outline: reads the source's own native DocumentTree directly (documents.js's readNativeDocumentTree -- no bridging conversion, no discarded output bytes) and runs document-outline.js's buildOutline over it. Groups carry { text, level, children } (a heading's, list item's, slide's, sheet's, or page's own label plus nested children); leaves carry { kind, text }.",
 		inputSchema: z.object({ source: DocumentInputSchema.describe("The document to outline.") })
 	}, async ({ source }, ctx) => {
 		const { signal } = ctx.mcpReq;
 		const { bytes, format } = await resolveDocumentInput(source, { signal });
-		const targetFormat = OUTLINE_PROBE_TARGETS[format];
-		const pkg = (await converter.convert({
-			source: {
-				format,
-				bytes
-			},
-			targetFormat
-		}, { signal })).package;
-		if (pkg === void 0) throw new Error(`the ${format}-to-${targetFormat} conversion reported no DocumentTree, so there is no tree to outline`);
+		const tree = readNativeDocumentTree(format, bytes, { signal });
 		const structuredContent = {
 			sourceFormat: format,
-			kind: pkg.kind,
-			outline: toOutlineJson(buildOutline(pkg))
+			kind: tree.kind,
+			outline: toOutlineJson(buildOutline(tree))
 		};
 		return {
 			content: [{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "document-mcp",
-  "version": "4.1.4",
+  "version": "4.1.5",
   "description": "MCP (Model Context Protocol) server exposing documents.js's document-conversion, .odb, metadata, and font tooling as MCP tools.",
   "type": "module",
   "repository": {
@@ -87,8 +87,8 @@
   "packageManager": "pnpm@11.6.0",
   "dependencies": {
     "@modelcontextprotocol/server": "^2.0.0",
-    "document-outline.js": "^3.1.1",
-    "documents.js": "^6.1.4",
+    "document-outline.js": "^3.2.0",
+    "documents.js": "^6.2.0",
     "zod": "^4.2.0"
   },
   "devDependencies": {
@@ -99,7 +99,7 @@
     "@vitest/coverage-v8": "^4.1.10",
     "eslint": "^10.8.0",
     "husky": "^9.1.7",
-    "odf.js": "^6.1.1",
+    "odf.js": "^6.1.2",
     "publint": "^0.3.22",
     "semantic-release": "^25.0.8",
     "tsdown": "^0.22.14",