document-rest 0.0.0 → 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Joseph Mearman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,78 @@
+# document-rest
+
+[![GitHub](https://img.shields.io/badge/GitHub-181717?logo=github&logoColor=white)](https://github.com/ExaDev/documents.js/tree/main/packages/document-rest) [![npm](https://img.shields.io/badge/npm-CB3837?logo=npm&logoColor=white)](https://www.npmjs.com/package/document-rest) [![npm version](https://img.shields.io/npm/v/document-rest)](https://www.npmjs.com/package/document-rest) [![CI](https://img.shields.io/github/actions/workflow/status/ExaDev/documents.js/ci.yml?branch=main)](https://github.com/ExaDev/documents.js/actions)
+
+> A plain REST API server exposing [`document-operations`](../document-operations/README.md)'s document-conversion, `.odb`, metadata, and font tooling as JSON-over-HTTP `POST` routes, for a caller with no MCP client and no Node runtime of its own — a Kotlin/JVM app, a Python script, or any other language with an HTTP client.
+
+`document-rest` adds no conversion or editing logic of its own — like [`document-mcp`](../document-mcp/README.md), it is a dispatch layer over [`document-operations`](../document-operations/README.md), the only difference being the transport: one `POST` route per operation instead of one MCP tool. `document-mcp`'s existing `--transport http` mode is not a substitute for this: it speaks MCP's own JSON-RPC protocol over a single `/mcp` path, which still needs an MCP client library to call — this package is for a caller that wants ordinary request/response JSON with no protocol of its own layered on top.
+
+## Getting started
+
+Run the server directly — no install step needed:
+
+```sh
+npx document-rest --port 3100
+```
+
+This binds a plain `node:http` listener to `127.0.0.1` (loopback only) on the given `--port` (default `3100`; `--port 0` asks the OS for a free port, reported on stderr once bound).
+
+> **Security note:** this listener has no authentication and no Host/Origin allowlisting of its own — anyone who can reach it can call every operation, including ones that read and write arbitrary filesystem paths. It is safe by default only because it binds to loopback; whatever fronts it for remote access (a tunnel, a reverse proxy) is responsible for authenticating callers before traffic ever reaches this process. Matches [`document-mcp`'s own `--transport http` listener](../document-mcp/README.md#remote-transport-http), which carries the identical note for the identical reason.
+
+### Standalone binary
+
+Every release also attaches a Node [single-executable application](https://nodejs.org/api/single-executable-applications.html) build for Linux, macOS, and Windows to that release's own GitHub Release assets — the entire server and its dependencies embedded in one file, needing no Node.js install or `npx` at all. For the "a caller with no Node runtime of its own" case this package exists for in the first place, this removes the last Node dependency too: download the asset matching your platform from the package's tag on the [Releases page](https://github.com/ExaDev/documents.js/releases), run it directly (`chmod +x` on Linux/macOS first), and it takes the identical `--port` flag.
+
+## API
+
+**`GET /`** lists every available operation:
+
+```sh
+curl http://127.0.0.1:3100/
+```
+
+```json
+{ "operations": [{ "name": "convert_document", "title": "Convert document", "description": "..." }, ...] }
+```
+
+**`POST /<operationName>`** runs one operation: the request body is JSON, validated against that operation's own input schema, and the response is `{ "result": ... }` on success. Every operation `document-operations` defines is reachable this way — see [that package's own README](../document-operations/README.md#operations) for the full list of operation names and what each one does; the request/response shapes are identical to the equivalent MCP tool's own `structuredContent`, since both dispatch to the exact same `run()` function.
+
+```sh
+curl -X POST http://127.0.0.1:3100/convert_document \
+  -H 'content-type: application/json' \
+  -d '{"source":{"path":"/tmp/report.docx"},"targetFormat":"markdown"}'
+```
+
+### Errors
+
+| Status | When                                                                                                                                                                                                   |
+| ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `400`  | The request body is not valid JSON, fails the operation's own input schema (`{ error, issues }`, from Zod's `treeifyError`), or the operation itself threw (`{ error }`, the thrown message verbatim). |
+| `404`  | No operation exists with that name.                                                                                                                                                                    |
+| `405`  | A method other than `POST` was used against a known operation route (`GET /` is the only exception).                                                                                                   |
+
+Two operations enrich their `400` body beyond a bare `{ error }`, mirroring `document-mcp`'s own `registerOperation` `mapError` hooks for the identical two typed errors: `odb_render_report`'s `OdbReportNotSpecifiedError` adds `availableReports` (every report name the `.odb` actually declares), and `odm_to_pdf`'s `OdmUnresolvedSectionError` adds `hrefs` (every chapter reference that failed to resolve).
+
+## Getting started (development)
+
+Requires Node.js `>=20` and pnpm `11.6.0` (pinned via `packageManager` in `package.json`).
+
+```sh
+pnpm install
+pnpm build      # turbo -> tsdown -> dist/ (ESM + CJS + .d.ts)
+pnpm typecheck  # turbo -> tsc --noEmit, plus attw --pack
+pnpm lint       # turbo -> eslint . --fix --cache --max-warnings 0
+pnpm test       # turbo -> vitest run, driving a real ephemeral-port HTTP server through fetch()
+```
+
+## Gotchas
+
+- **No streaming, no chunked upload.** `readJsonBody` buffers the entire request body into memory before parsing it as JSON, matching every operation's own hybrid `bytesBase64`-or-`path` input convention (a large document is better supplied by filesystem `path`, read once by the operation itself, than base64-inflated over HTTP).
+- **Abort on client disconnect.** Each request gets its own `AbortSignal`, wired to the underlying `IncomingMessage`'s `close` event (node:http carries no `AbortSignal` of its own) — a client that disconnects mid-conversion causes the operation's own signal-aware work (e.g. `convert_document`'s page-boundary cancellation) to stop at the next checkpoint rather than running to completion for a caller no longer listening.
+
+## Contributing
+
+Release, CI, and commit-message conventions are all workspace-wide, not package-local — see the [monorepo root README](../../README.md#releases) for the release mechanism and [CONTRIBUTING.md](../../CONTRIBUTING.md) for the shared git hooks and history conventions. Work inside `packages/document-rest/`.
+
+## License
+
+MIT

package/dist/bin.js

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+import { createServer } from "node:http";
+import { DOCUMENT_OPERATIONS } from "document-operations";
+import { OdbReportNotSpecifiedError, OdmUnresolvedSectionError } from "documents.js";
+import { z } from "zod";
+//#region src/server.ts
+const OPERATIONS_BY_NAME = new Map(DOCUMENT_OPERATIONS.map((operation) => [operation.name, operation]));
+const ERROR_MAPPERS = /* @__PURE__ */ new Map([["odb_render_report", (error) => {
+	if (!(error instanceof OdbReportNotSpecifiedError)) return void 0;
+	return {
+		status: 400,
+		body: {
+			error: error.message,
+			availableReports: error.availableReports
+		}
+	};
+}], ["odm_to_pdf", (error) => {
+	if (!(error instanceof OdmUnresolvedSectionError)) return void 0;
+	return {
+		status: 400,
+		body: {
+			error: `${error.message} Pass chaptersDir containing these files, or an explicit chapters override, for each href.`,
+			hrefs: error.hrefs
+		}
+	};
+}]]);
+async function readJsonBody(req) {
+	const chunks = [];
+	for await (const chunk of req) chunks.push(chunk);
+	const text = Buffer.concat(chunks).toString("utf-8");
+	if (text.length === 0) return {};
+	return JSON.parse(text);
+}
+function sendJson(res, status, body) {
+	const text = JSON.stringify(body);
+	res.writeHead(status, { "content-type": "application/json" });
+	res.end(text);
+}
+function abortSignalFor(req) {
+	const controller = new AbortController();
+	req.once("close", () => {
+		controller.abort();
+	});
+	return controller.signal;
+}
+async function handleOperationRequest(req, res, operation) {
+	let rawBody;
+	try {
+		rawBody = await readJsonBody(req);
+	} catch (error) {
+		sendJson(res, 400, { error: `Request body is not valid JSON: ${error instanceof Error ? error.message : String(error)}` });
+		return;
+	}
+	const parsed = operation.inputSchema.safeParse(rawBody);
+	if (!parsed.success) {
+		sendJson(res, 400, {
+			error: "Request body failed validation.",
+			issues: z.treeifyError(parsed.error)
+		});
+		return;
+	}
+	try {
+		sendJson(res, 200, { result: await operation.run(parsed.data, { signal: abortSignalFor(req) }) });
+	} catch (error) {
+		const mapped = ERROR_MAPPERS.get(operation.name)?.(error);
+		if (mapped !== void 0) {
+			sendJson(res, mapped.status, mapped.body);
+			return;
+		}
+		sendJson(res, 400, { error: error instanceof Error ? error.message : String(error) });
+	}
+}
+function listOperations() {
+	return { operations: DOCUMENT_OPERATIONS.map((operation) => ({
+		name: operation.name,
+		title: operation.title,
+		description: operation.description
+	})) };
+}
+/**
+* Builds a REST API server exposing every document-operations DocumentOperation as `POST /<name>`: the JSON request body is validated against the operation's own inputSchema, `run()` is called with the parsed input, and the result is returned as `{ result }`. `GET /` lists every available operation (name/title/description) for discovery. Never started -- `src/bin.ts` binds it to a port; a test binds it to an ephemeral one.
+*/
+function createRestServer() {
+	return createServer((req, res) => {
+		(async () => {
+			if (req.url === void 0 || req.method === void 0) {
+				sendJson(res, 400, { error: "Malformed request: no url or method." });
+				return;
+			}
+			const url = new URL(req.url, "http://localhost");
+			if (url.pathname === "/" && req.method === "GET") {
+				sendJson(res, 200, listOperations());
+				return;
+			}
+			const name = url.pathname.replace(/^\//, "");
+			const operation = OPERATIONS_BY_NAME.get(name);
+			if (operation === void 0) {
+				sendJson(res, 404, { error: `No operation named "${name}". GET / lists every available operation.` });
+				return;
+			}
+			if (req.method !== "POST") {
+				sendJson(res, 405, { error: `${name} only accepts POST, received ${req.method}.` });
+				return;
+			}
+			await handleOperationRequest(req, res, operation);
+		})();
+	});
+}
+//#endregion
+//#region src/cli.ts
+const DEFAULT_PORT = 3100;
+function readFlag(args, name) {
+	const prefix = `--${name}=`;
+	for (const [index, arg] of args.entries()) {
+		if (arg.startsWith(prefix)) return arg.slice(prefix.length);
+		if (arg === `--${name}`) {
+			const value = args[index + 1];
+			if (value === void 0) throw new Error(`--${name} requires a value`);
+			return value;
+		}
+	}
+}
+function parsePort(raw) {
+	const port = Number.parseInt(raw, 10);
+	if (!Number.isInteger(port) || String(port) !== raw.trim() || port < 0 || port > 65535) throw new Error(`--port must be an integer between 0 and 65535, got "${raw}"`);
+	return port;
+}
+/**
+* The real CLI entry logic, shared by both distribution shapes this package ships: `src/bin.ts` (the published npm `bin`, run under a real Node.js install) and `src/sea-entry.ts` (bundled into a Node single-executable application, which embeds its own Node runtime). Node's SEA feature runs only a CommonJS entry with no top-level await (see that file's own comment), so this function itself contains no top-level await of its own -- only `bin.ts` awaits calling it, at its own top level, which SEA never sees.
+*
+* Returns the listening `Server` rather than resolving `void` so a caller with a reason to stop it again (a test binding an ephemeral port for the duration of one assertion) can -- neither real distribution shape needs to, so both simply discard it.
+*/
+async function main() {
+	const portArg = readFlag(process.argv.slice(2), "port");
+	const port = portArg === void 0 ? DEFAULT_PORT : parsePort(portArg);
+	const server = createRestServer();
+	await new Promise((resolve) => {
+		server.listen(port, "127.0.0.1", resolve);
+	});
+	const address = server.address();
+	if (address === null || typeof address === "string") throw new Error("Expected the HTTP server to bind a TCP address, not a pipe or Unix socket");
+	console.error(`document-rest listening on http://127.0.0.1:${String(address.port)}`);
+	return server;
+}
+//#endregion
+//#region src/bin.ts
+await main();
+//#endregion
+export {};

package/dist/index.cjs

@@ -0,0 +1,110 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let node_http = require("node:http");
+let document_operations = require("document-operations");
+let documents_js = require("documents.js");
+let zod = require("zod");
+//#region src/server.ts
+const OPERATIONS_BY_NAME = new Map(document_operations.DOCUMENT_OPERATIONS.map((operation) => [operation.name, operation]));
+const ERROR_MAPPERS = /* @__PURE__ */ new Map([["odb_render_report", (error) => {
+	if (!(error instanceof documents_js.OdbReportNotSpecifiedError)) return void 0;
+	return {
+		status: 400,
+		body: {
+			error: error.message,
+			availableReports: error.availableReports
+		}
+	};
+}], ["odm_to_pdf", (error) => {
+	if (!(error instanceof documents_js.OdmUnresolvedSectionError)) return void 0;
+	return {
+		status: 400,
+		body: {
+			error: `${error.message} Pass chaptersDir containing these files, or an explicit chapters override, for each href.`,
+			hrefs: error.hrefs
+		}
+	};
+}]]);
+async function readJsonBody(req) {
+	const chunks = [];
+	for await (const chunk of req) chunks.push(chunk);
+	const text = Buffer.concat(chunks).toString("utf-8");
+	if (text.length === 0) return {};
+	return JSON.parse(text);
+}
+function sendJson(res, status, body) {
+	const text = JSON.stringify(body);
+	res.writeHead(status, { "content-type": "application/json" });
+	res.end(text);
+}
+function abortSignalFor(req) {
+	const controller = new AbortController();
+	req.once("close", () => {
+		controller.abort();
+	});
+	return controller.signal;
+}
+async function handleOperationRequest(req, res, operation) {
+	let rawBody;
+	try {
+		rawBody = await readJsonBody(req);
+	} catch (error) {
+		sendJson(res, 400, { error: `Request body is not valid JSON: ${error instanceof Error ? error.message : String(error)}` });
+		return;
+	}
+	const parsed = operation.inputSchema.safeParse(rawBody);
+	if (!parsed.success) {
+		sendJson(res, 400, {
+			error: "Request body failed validation.",
+			issues: zod.z.treeifyError(parsed.error)
+		});
+		return;
+	}
+	try {
+		sendJson(res, 200, { result: await operation.run(parsed.data, { signal: abortSignalFor(req) }) });
+	} catch (error) {
+		const mapped = ERROR_MAPPERS.get(operation.name)?.(error);
+		if (mapped !== void 0) {
+			sendJson(res, mapped.status, mapped.body);
+			return;
+		}
+		sendJson(res, 400, { error: error instanceof Error ? error.message : String(error) });
+	}
+}
+function listOperations() {
+	return { operations: document_operations.DOCUMENT_OPERATIONS.map((operation) => ({
+		name: operation.name,
+		title: operation.title,
+		description: operation.description
+	})) };
+}
+/**
+* Builds a REST API server exposing every document-operations DocumentOperation as `POST /<name>`: the JSON request body is validated against the operation's own inputSchema, `run()` is called with the parsed input, and the result is returned as `{ result }`. `GET /` lists every available operation (name/title/description) for discovery. Never started -- `src/bin.ts` binds it to a port; a test binds it to an ephemeral one.
+*/
+function createRestServer() {
+	return (0, node_http.createServer)((req, res) => {
+		(async () => {
+			if (req.url === void 0 || req.method === void 0) {
+				sendJson(res, 400, { error: "Malformed request: no url or method." });
+				return;
+			}
+			const url = new URL(req.url, "http://localhost");
+			if (url.pathname === "/" && req.method === "GET") {
+				sendJson(res, 200, listOperations());
+				return;
+			}
+			const name = url.pathname.replace(/^\//, "");
+			const operation = OPERATIONS_BY_NAME.get(name);
+			if (operation === void 0) {
+				sendJson(res, 404, { error: `No operation named "${name}". GET / lists every available operation.` });
+				return;
+			}
+			if (req.method !== "POST") {
+				sendJson(res, 405, { error: `${name} only accepts POST, received ${req.method}.` });
+				return;
+			}
+			await handleOperationRequest(req, res, operation);
+		})();
+	});
+}
+//#endregion
+exports.createRestServer = createRestServer;

package/dist/index.d.cts

@@ -0,0 +1,8 @@
+import { Server } from "node:http";
+//#region src/server.d.ts
+/**
+ * Builds a REST API server exposing every document-operations DocumentOperation as `POST /<name>`: the JSON request body is validated against the operation's own inputSchema, `run()` is called with the parsed input, and the result is returned as `{ result }`. `GET /` lists every available operation (name/title/description) for discovery. Never started -- `src/bin.ts` binds it to a port; a test binds it to an ephemeral one.
+ */
+declare function createRestServer(): Server;
+//#endregion
+export { createRestServer };

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import { Server } from "node:http";
+//#region src/server.d.ts
+/**
+ * Builds a REST API server exposing every document-operations DocumentOperation as `POST /<name>`: the JSON request body is validated against the operation's own inputSchema, `run()` is called with the parsed input, and the result is returned as `{ result }`. `GET /` lists every available operation (name/title/description) for discovery. Never started -- `src/bin.ts` binds it to a port; a test binds it to an ephemeral one.
+ */
+declare function createRestServer(): Server;
+//#endregion
+export { createRestServer };

package/dist/index.js

@@ -0,0 +1,109 @@
+import { createServer } from "node:http";
+import { DOCUMENT_OPERATIONS } from "document-operations";
+import { OdbReportNotSpecifiedError, OdmUnresolvedSectionError } from "documents.js";
+import { z } from "zod";
+//#region src/server.ts
+const OPERATIONS_BY_NAME = new Map(DOCUMENT_OPERATIONS.map((operation) => [operation.name, operation]));
+const ERROR_MAPPERS = /* @__PURE__ */ new Map([["odb_render_report", (error) => {
+	if (!(error instanceof OdbReportNotSpecifiedError)) return void 0;
+	return {
+		status: 400,
+		body: {
+			error: error.message,
+			availableReports: error.availableReports
+		}
+	};
+}], ["odm_to_pdf", (error) => {
+	if (!(error instanceof OdmUnresolvedSectionError)) return void 0;
+	return {
+		status: 400,
+		body: {
+			error: `${error.message} Pass chaptersDir containing these files, or an explicit chapters override, for each href.`,
+			hrefs: error.hrefs
+		}
+	};
+}]]);
+async function readJsonBody(req) {
+	const chunks = [];
+	for await (const chunk of req) chunks.push(chunk);
+	const text = Buffer.concat(chunks).toString("utf-8");
+	if (text.length === 0) return {};
+	return JSON.parse(text);
+}
+function sendJson(res, status, body) {
+	const text = JSON.stringify(body);
+	res.writeHead(status, { "content-type": "application/json" });
+	res.end(text);
+}
+function abortSignalFor(req) {
+	const controller = new AbortController();
+	req.once("close", () => {
+		controller.abort();
+	});
+	return controller.signal;
+}
+async function handleOperationRequest(req, res, operation) {
+	let rawBody;
+	try {
+		rawBody = await readJsonBody(req);
+	} catch (error) {
+		sendJson(res, 400, { error: `Request body is not valid JSON: ${error instanceof Error ? error.message : String(error)}` });
+		return;
+	}
+	const parsed = operation.inputSchema.safeParse(rawBody);
+	if (!parsed.success) {
+		sendJson(res, 400, {
+			error: "Request body failed validation.",
+			issues: z.treeifyError(parsed.error)
+		});
+		return;
+	}
+	try {
+		sendJson(res, 200, { result: await operation.run(parsed.data, { signal: abortSignalFor(req) }) });
+	} catch (error) {
+		const mapped = ERROR_MAPPERS.get(operation.name)?.(error);
+		if (mapped !== void 0) {
+			sendJson(res, mapped.status, mapped.body);
+			return;
+		}
+		sendJson(res, 400, { error: error instanceof Error ? error.message : String(error) });
+	}
+}
+function listOperations() {
+	return { operations: DOCUMENT_OPERATIONS.map((operation) => ({
+		name: operation.name,
+		title: operation.title,
+		description: operation.description
+	})) };
+}
+/**
+* Builds a REST API server exposing every document-operations DocumentOperation as `POST /<name>`: the JSON request body is validated against the operation's own inputSchema, `run()` is called with the parsed input, and the result is returned as `{ result }`. `GET /` lists every available operation (name/title/description) for discovery. Never started -- `src/bin.ts` binds it to a port; a test binds it to an ephemeral one.
+*/
+function createRestServer() {
+	return createServer((req, res) => {
+		(async () => {
+			if (req.url === void 0 || req.method === void 0) {
+				sendJson(res, 400, { error: "Malformed request: no url or method." });
+				return;
+			}
+			const url = new URL(req.url, "http://localhost");
+			if (url.pathname === "/" && req.method === "GET") {
+				sendJson(res, 200, listOperations());
+				return;
+			}
+			const name = url.pathname.replace(/^\//, "");
+			const operation = OPERATIONS_BY_NAME.get(name);
+			if (operation === void 0) {
+				sendJson(res, 404, { error: `No operation named "${name}". GET / lists every available operation.` });
+				return;
+			}
+			if (req.method !== "POST") {
+				sendJson(res, 405, { error: `${name} only accepts POST, received ${req.method}.` });
+				return;
+			}
+			await handleOperationRequest(req, res, operation);
+		})();
+	});
+}
+//#endregion
+export { createRestServer };

package/package.json

@@ -1,5 +1,108 @@
 {
   "name": "document-rest",
-  "version": "0.0.0",
-  "private": false
+  "version": "1.1.0",
+  "description": "A plain REST API server exposing document-operations' conversion, editing, inspection, and .odb operations as JSON-over-HTTP endpoints -- one POST route per operation, for a caller with no MCP client and no Node runtime of their own.",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ExaDev/documents.js.git",
+    "directory": "packages/document-rest"
+  },
+  "homepage": "https://github.com/ExaDev/documents.js/tree/main/packages/document-rest",
+  "bugs": {
+    "url": "https://github.com/ExaDev/documents.js/issues"
+  },
+  "bin": {
+    "document-rest": "./dist/bin.js"
+  },
+  "exports": {
+    ".": {
+      "types": {
+        "import": "./dist/index.d.ts",
+        "require": "./dist/index.d.cts"
+      },
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./*": {
+      "types": {
+        "import": "./dist/*.d.ts",
+        "require": "./dist/*.d.cts"
+      },
+      "import": "./dist/*.js",
+      "require": "./dist/*.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true,
+    "registry": "https://registry.npmjs.org/"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "turbo run _build",
+    "_build": "tsdown",
+    "prepublishOnly": "pnpm run lint && pnpm run typecheck && tsdown && publint && attw --pack",
+    "lint": "turbo run _lint",
+    "_lint": "eslint . --fix --cache --max-warnings 0",
+    "typecheck": "turbo run _typecheck _typecheck:attw",
+    "_typecheck": "tsc --noEmit",
+    "_typecheck:attw": "attw --pack",
+    "test": "turbo run _test",
+    "_test": "vitest run --project unit",
+    "test:watch": "vitest",
+    "test:coverage": "turbo run _test:coverage",
+    "_test:coverage": "vitest run --project unit --coverage",
+    "test:mutation": "turbo run _test:mutation",
+    "_test:mutation": "stryker run stryker.config.ts",
+    "test:smoke": "turbo run _test:smoke",
+    "_test:smoke": "vitest run --project smoke",
+    "prepare": "husky",
+    "release": "semantic-release"
+  },
+  "keywords": [
+    "rest",
+    "http",
+    "api",
+    "docx",
+    "pptx",
+    "pdf",
+    "odt",
+    "odp",
+    "ods",
+    "odg",
+    "odf",
+    "odb",
+    "document-conversion"
+  ],
+  "license": "MIT",
+  "packageManager": "pnpm@11.6.0",
+  "dependencies": {
+    "document-operations": "1.1.0",
+    "documents.js": "7.20.1",
+    "zod": "4.4.3"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "0.18.5",
+    "@types/node": "26.2.0",
+    "@vitest/coverage-v8": "4.1.11",
+    "eslint": "10.8.1",
+    "husky": "9.1.7",
+    "odf.js": "7.25.1",
+    "publint": "0.3.22",
+    "semantic-release": "25.0.9",
+    "tsdown": "0.22.14",
+    "turbo": "2.10.8",
+    "typescript": "6.0.3",
+    "vitest": "4.1.11"
+  }
 }