@stll/folio-cli 0.0.1-placeholder.0 → 0.1.0

package/dist/package-parts.js

@@ -0,0 +1,172 @@
+import { FOLIO_CLI_ERROR_CODES, cliError } from "./errors.js";
+import { Result } from "better-result";
+import path from "node:path";
+import { FolioDocxReviewer } from "@stll/folio-core/server";
+import { XMLParser, XMLValidator } from "fast-xml-parser";
+import JSZip from "jszip";
+//#region src/package-parts.ts
+/**
+* Package-level facts a transaction reports and checks: which parts a save
+* changed, the first revision id free for new revisions, and whether the
+* parts it changed are well formed with every relationship reference
+* resolved.
+*/
+const WORDPROCESSINGML_NAMESPACES = ["http://schemas.openxmlformats.org/wordprocessingml/2006/main", "http://purl.oclc.org/ooxml/wordprocessingml/main"];
+const RELATIONSHIP_NAMESPACES = ["http://schemas.openxmlformats.org/officeDocument/2006/relationships", "http://purl.oclc.org/ooxml/officeDocument/relationships"];
+const loadZip = (bytes) => Result.tryPromise({
+	try: () => JSZip.loadAsync(bytes),
+	catch: (error) => cliError({
+		code: FOLIO_CLI_ERROR_CODES.integrityFailed,
+		message: `The package is not a readable ZIP archive: ${error instanceof Error ? error.message : String(error)}`
+	})
+});
+const partEntries = (zip) => new Map(Object.entries(zip.files).filter(([, entry]) => !entry.dir));
+const sameBytes = (left, right) => Buffer.compare(left, right) === 0;
+/** Parts added, removed, or whose uncompressed content differs, sorted by name. */
+const diffPackages = async (before, after) => {
+	const beforeZip = await loadZip(before);
+	if (beforeZip.isErr()) return Result.err(beforeZip.error);
+	const afterZip = await loadZip(after);
+	if (afterZip.isErr()) return Result.err(afterZip.error);
+	const beforeParts = partEntries(beforeZip.value);
+	const afterParts = partEntries(afterZip.value);
+	const changes = [];
+	for (const [part, entry] of afterParts) {
+		const previous = beforeParts.get(part);
+		if (previous === void 0) {
+			changes.push({
+				part,
+				change: "added"
+			});
+			continue;
+		}
+		const [left, right] = await Promise.all([previous.async("uint8array"), entry.async("uint8array")]);
+		if (!sameBytes(left, right)) changes.push({
+			part,
+			change: "modified"
+		});
+	}
+	for (const part of beforeParts.keys()) if (!afterParts.has(part)) changes.push({
+		part,
+		change: "removed"
+	});
+	return Result.ok(changes.toSorted((left, right) => left.part.localeCompare(right.part)));
+};
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+/** Prefixes a part's namespace declarations bind to any of `namespaces`. */
+const prefixesBoundTo = (xml, namespaces) => {
+	const prefixes = /* @__PURE__ */ new Set();
+	for (const match of xml.matchAll(/\sxmlns:([A-Za-z_][\w.-]*)\s*=\s*"([^"]*)"/gu)) {
+		const [, prefix, uri] = match;
+		if (prefix !== void 0 && uri !== void 0 && namespaces.includes(uri)) prefixes.add(prefix);
+	}
+	return prefixes;
+};
+/**
+* The first revision id above every WordprocessingML `id` attribute in the
+* package, so new revisions never collide with an existing one.
+*/
+const nextRevisionIdSeed = async (bytes) => {
+	const zip = await loadZip(bytes);
+	if (zip.isErr()) return Result.err(zip.error);
+	let highest = 0;
+	for (const [part, entry] of partEntries(zip.value)) {
+		if (!part.endsWith(".xml")) continue;
+		const xml = await entry.async("string");
+		for (const prefix of prefixesBoundTo(xml, WORDPROCESSINGML_NAMESPACES)) {
+			const pattern = new RegExp(`\\s${escapeRegExp(prefix)}:id\\s*=\\s*"(\\d+)"`, "gu");
+			for (const [, id] of xml.matchAll(pattern)) highest = Math.max(highest, Number(id));
+		}
+	}
+	return Result.ok(highest + 1);
+};
+const relationshipParser = new XMLParser({
+	ignoreAttributes: false,
+	attributeNamePrefix: "",
+	removeNSPrefix: true,
+	isArray: (name) => name === "Relationship"
+});
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const parseRelationships = (xml) => {
+	const parsed = relationshipParser.parse(xml);
+	const root = isRecord(parsed) ? parsed["Relationships"] : void 0;
+	const entries = isRecord(root) ? root["Relationship"] : void 0;
+	if (!Array.isArray(entries)) return [];
+	return entries.filter(isRecord).map((entry) => ({
+		id: typeof entry["Id"] === "string" ? entry["Id"] : "",
+		target: typeof entry["Target"] === "string" ? entry["Target"] : "",
+		external: entry["TargetMode"] === "External"
+	}));
+};
+/** `word/document.xml` -> `word/_rels/document.xml.rels`; `_rels/.rels` belongs to the package. */
+const relationshipsPartFor = (part) => {
+	const directory = path.posix.dirname(part);
+	const base = path.posix.basename(part);
+	return directory === "." ? `_rels/${base}.rels` : `${directory}/_rels/${base}.rels`;
+};
+/** The part a `.rels` part describes (`""` for the package-level `_rels/.rels`). */
+const sourcePartFor = (relsPart) => {
+	const directory = path.posix.dirname(path.posix.dirname(relsPart));
+	const base = path.posix.basename(relsPart, ".rels");
+	return directory === "." ? base : `${directory}/${base}`;
+};
+const resolveTarget = (relsPart, target) => {
+	if (target.startsWith("/")) return target.slice(1);
+	const sourceDirectory = path.posix.dirname(sourcePartFor(relsPart));
+	return path.posix.normalize(path.posix.join(sourceDirectory === "." ? "" : sourceDirectory, target));
+};
+const integrityError = (message) => cliError({
+	code: FOLIO_CLI_ERROR_CODES.integrityFailed,
+	message
+});
+const checkChangedPart = async ({ zip, parts, part }) => {
+	const entry = parts.get(part);
+	if (entry === void 0 || !(part.endsWith(".xml") || part.endsWith(".rels"))) return null;
+	const xml = await entry.async("string");
+	if (XMLValidator.validate(xml) !== true) return `${part} is not well-formed XML.`;
+	if (part.endsWith(".rels")) {
+		const lowerCaseParts = new Set([...parts.keys()].map((name) => name.toLowerCase()));
+		for (const { id, target, external } of parseRelationships(xml)) {
+			if (external) continue;
+			const resolved = resolveTarget(part, target);
+			if (!lowerCaseParts.has(resolved.toLowerCase())) return `${part} relationship ${id} targets ${resolved}, which the package does not contain.`;
+		}
+		return null;
+	}
+	const prefixes = prefixesBoundTo(xml, RELATIONSHIP_NAMESPACES);
+	if (prefixes.size === 0) return null;
+	const relsXml = await zip.file(relationshipsPartFor(part))?.async("string");
+	const ids = new Set(parseRelationships(relsXml ?? "").map(({ id }) => id));
+	for (const prefix of prefixes) {
+		const pattern = new RegExp(`\\s${escapeRegExp(prefix)}:[A-Za-z]+\\s*=\\s*"([^"]*)"`, "gu");
+		for (const [, id] of xml.matchAll(pattern)) if (id !== void 0 && !ids.has(id)) return `${part} references relationship ${id}, which ${relationshipsPartFor(part)} does not define.`;
+	}
+	return null;
+};
+/**
+* Check what a save wrote before it replaces anything: the package opens,
+* every changed XML part is well formed, every relationship id a changed
+* part references resolves, every internal target a changed `.rels` part
+* names exists, and the package parses as a document again.
+*/
+const checkPackageIntegrity = async (bytes, changedParts) => {
+	const zip = await loadZip(bytes);
+	if (zip.isErr()) return Result.err(zip.error);
+	const parts = partEntries(zip.value);
+	for (const { part, change } of changedParts) {
+		if (change === "removed") continue;
+		const problem = await checkChangedPart({
+			zip: zip.value,
+			parts,
+			part
+		});
+		if (problem !== null) return Result.err(integrityError(`The saved package failed validation: ${problem}`));
+	}
+	const reopened = await Result.tryPromise({
+		try: () => FolioDocxReviewer.fromBuffer(bytes.slice().buffer),
+		catch: (error) => integrityError(`The saved package does not reopen: ${error instanceof Error ? error.message : String(error)}`)
+	});
+	return reopened.isErr() ? Result.err(reopened.error) : Result.ok();
+};
+//#endregion
+export { checkPackageIntegrity, diffPackages, nextRevisionIdSeed };

package/dist/package.js

@@ -0,0 +1,4 @@
+//#region package.json
+var version = "0.1.0";
+//#endregion
+export { version };

package/dist/preview-commands.d.ts

@@ -0,0 +1,8 @@
+import { FolioCliIo } from "./cli.js";
+//#region src/preview-commands.d.ts
+declare const RENDER_HELP: string;
+declare const runRender: (rest: readonly string[], io: FolioCliIo) => Promise<number>;
+declare const SERVE_HELP: string;
+declare const runServe: (rest: readonly string[], io: FolioCliIo) => Promise<number>;
+//#endregion
+export { RENDER_HELP, SERVE_HELP, runRender, runServe };

package/dist/preview-commands.js

@@ -0,0 +1,226 @@
+import { checkExpectedVersion, readDocumentFile } from "./document.js";
+import { EXIT_CODES, FOLIO_CLI_ERROR_CODES, cliError, exitCodeForError } from "./errors.js";
+import { writeOutputFile } from "./output-file.js";
+import { OUTPUT_FORMATS, failureEnvelope, isOutputFormat, renderEnvelope, successEnvelope } from "./output.js";
+import { resolveTransactionDate } from "./provenance.js";
+import { buildDisplayList, checkPages, displayListHtml, renderPdf, renderPng } from "./render.js";
+import { startPreviewServer } from "./serve.js";
+import { Result } from "better-result";
+import { parseArgs } from "node:util";
+import path from "node:path";
+//#region src/preview-commands.ts
+/**
+* `folio render` and `folio serve`: the document as its pages, from folio's
+* own layout and painters. Neither changes the document.
+*/
+const usageError = (message, hint) => cliError({
+	code: FOLIO_CLI_ERROR_CODES.usage,
+	message,
+	hint
+});
+const emit = (io, format, result) => {
+	const rendered = renderEnvelope({
+		envelope: result.isOk() ? successEnvelope(result.value) : failureEnvelope(result.error),
+		format,
+		tool: "render"
+	});
+	if (rendered.stdout !== "") io.stdout(rendered.stdout);
+	if (rendered.stderr !== "") io.stderr(rendered.stderr);
+	return result.isOk() ? EXIT_CODES.ok : exitCodeForError(result.error.code);
+};
+const formatFrom = (value, io) => {
+	if (value === void 0) return Result.ok(io.isTTY ? "text" : "json");
+	return isOutputFormat(value) ? Result.ok(value) : Result.err(usageError(`--output must be ${OUTPUT_FORMATS.join(" or ")}.`));
+};
+/** The output format an extension names, or `null` for any other. */
+const renderFormatOf = (target) => {
+	switch (path.extname(target).toLowerCase()) {
+		case ".pdf": return "pdf";
+		case ".png": return "png";
+		case ".html": return "html";
+		default: return null;
+	}
+};
+const positiveInteger = (value, flag) => {
+	if (value === void 0) return Result.ok(void 0);
+	const parsed = Number(value);
+	return Number.isInteger(parsed) && parsed >= 1 ? Result.ok(parsed) : Result.err(usageError(`${flag} expects a whole number from 1.`));
+};
+const RENDER_HELP = [
+	"Usage: folio render <file> -o <out.pdf|out.png|out.html> [--page <n>]",
+	"",
+	"Render the document with folio's layout: a PDF of every page (or --page n), an HTML",
+	"document of its pages, or one page as a PNG (page 1 unless --page). PNG needs Chromium",
+	"through playwright-core. The document is never changed.",
+	"",
+	"Flags:",
+	"  -o, --out <path>          Output file; its extension picks the format",
+	"  --page <n>                Only this page (1-based)",
+	"  --scale <n>               PNG pixels per CSS pixel (default 2)",
+	"  --overwrite               Replace an existing output file",
+	"  --expect-version <sha>    Refuse unless the document has this fileVersion",
+	"  --date <iso>              PDF creation date (default: now)",
+	"  --output <json|text>      Envelope format",
+	""
+].join("\n");
+const renderOptions = {
+	out: {
+		type: "string",
+		short: "o"
+	},
+	page: { type: "string" },
+	scale: { type: "string" },
+	overwrite: { type: "boolean" },
+	"expect-version": { type: "string" },
+	date: { type: "string" },
+	output: { type: "string" },
+	help: {
+		type: "boolean",
+		short: "h"
+	}
+};
+const runRender = async (rest, io) => {
+	const parsed = Result.try({
+		try: () => parseArgs({
+			args: [...rest],
+			options: renderOptions,
+			allowPositionals: true,
+			strict: true
+		}),
+		catch: (error) => usageError(error instanceof Error ? error.message : String(error), "Run folio render --help.")
+	});
+	if (parsed.isErr()) return emit(io, io.isTTY ? "text" : "json", parsed);
+	const { values, positionals } = parsed.value;
+	if (values.help === true) {
+		io.stdout(RENDER_HELP);
+		return EXIT_CODES.ok;
+	}
+	const format = formatFrom(values.output, io);
+	if (format.isErr()) return emit(io, io.isTTY ? "text" : "json", format);
+	const result = await render({
+		values,
+		positionals
+	});
+	return emit(io, format.value, result);
+};
+const render = async ({ values, positionals }) => {
+	const [input, ...extra] = positionals;
+	if (input === void 0 || extra.length > 0) return Result.err(usageError("Usage: folio render <file> -o <out.pdf|out.png|out.html>."));
+	if (values.out === void 0) return Result.err(usageError("folio render needs -o <out.pdf|out.png|out.html>."));
+	const kind = renderFormatOf(values.out);
+	if (kind === null) return Result.err(usageError("-o must end in .pdf, .png, or .html."));
+	const page = positiveInteger(values.page, "--page");
+	if (page.isErr()) return Result.err(page.error);
+	const scale = positiveInteger(values.scale, "--scale");
+	if (scale.isErr()) return Result.err(scale.error);
+	const date = resolveTransactionDate(values.date);
+	if (date.isErr()) return Result.err(date.error);
+	const file = await readDocumentFile(input);
+	if (file.isErr()) return Result.err(file.error);
+	const version = checkExpectedVersion(file.value, values["expect-version"]);
+	if (version.isErr()) return Result.err(version.error);
+	const pages = page.value === void 0 ? void 0 : [page.value];
+	let output;
+	switch (kind) {
+		case "pdf":
+			output = await renderPdf({
+				file: file.value,
+				pages,
+				timestamp: date.value
+			});
+			break;
+		case "png":
+			output = await renderPng({
+				file: file.value,
+				page: page.value ?? 1,
+				scale: scale.value ?? 2
+			});
+			break;
+		case "html": {
+			const list = await buildDisplayList(file.value);
+			const selected = list.isOk() ? checkPages(list.value, pages) : list;
+			output = selected.isOk() ? Result.ok({
+				bytes: new TextEncoder().encode(displayListHtml(selected.value, path.basename(file.value.path))),
+				pageCount: selected.value.pages.length
+			}) : Result.err(selected.error);
+			break;
+		}
+		default: return kind;
+	}
+	if (output.isErr()) return Result.err(output.error);
+	const written = await writeOutputFile({
+		target: values.out,
+		bytes: output.value.bytes,
+		overwrite: values.overwrite === true,
+		input: file.value.identity
+	});
+	if (written.isErr()) return Result.err(written.error);
+	return Result.ok({
+		path: file.value.path,
+		fileVersion: file.value.fileVersion,
+		output: written.value,
+		format: kind,
+		pageCount: output.value.pageCount,
+		bytes: output.value.bytes.byteLength
+	});
+};
+const SERVE_HELP = [
+	"Usage: folio serve <file> [--port <n>]",
+	"",
+	"Serve a read-only live preview of the document on 127.0.0.1. The page follows the file:",
+	"when its version changes (a folio write, or any other program), the preview re-renders.",
+	"The URL carries a random token; the server never writes. Stop it with Ctrl-C.",
+	"",
+	"Flags:",
+	"  --port <n>              Port on 127.0.0.1 (default: a free one)",
+	"  --output <json|text>    Envelope format for the startup line",
+	""
+].join("\n");
+const runServe = async (rest, io) => {
+	const parsed = Result.try({
+		try: () => parseArgs({
+			args: [...rest],
+			options: {
+				port: { type: "string" },
+				output: { type: "string" },
+				help: {
+					type: "boolean",
+					short: "h"
+				}
+			},
+			allowPositionals: true,
+			strict: true
+		}),
+		catch: (error) => usageError(error instanceof Error ? error.message : String(error), "Run folio serve --help.")
+	});
+	if (parsed.isErr()) return emit(io, io.isTTY ? "text" : "json", parsed);
+	const { values, positionals } = parsed.value;
+	if (values.help === true) {
+		io.stdout(SERVE_HELP);
+		return EXIT_CODES.ok;
+	}
+	const format = formatFrom(values.output, io);
+	if (format.isErr()) return emit(io, io.isTTY ? "text" : "json", format);
+	const [input, ...extra] = positionals;
+	if (input === void 0 || extra.length > 0) return emit(io, format.value, Result.err(usageError("Usage: folio serve <file> [--port <n>].")));
+	const port = values.port === void 0 ? 0 : Number(values.port);
+	if (!Number.isInteger(port) || port < 0 || port > 65535) return emit(io, format.value, Result.err(usageError("--port expects a port number.")));
+	if (io.untilInterrupted === void 0) return emit(io, format.value, Result.err(usageError("folio serve needs to run until interrupted.")));
+	const started = await startPreviewServer({
+		documentPath: input,
+		port
+	});
+	if (started.isErr()) return emit(io, format.value, Result.err(cliError({
+		code: FOLIO_CLI_ERROR_CODES.invalidInput,
+		message: started.error.message
+	})));
+	const exit = emit(io, format.value, Result.ok({
+		url: started.value.url,
+		path: path.resolve(input)
+	}));
+	await io.untilInterrupted();
+	await started.value.close();
+	return exit;
+};
+//#endregion
+export { RENDER_HELP, SERVE_HELP, runRender, runServe };

package/dist/provenance.d.ts

@@ -0,0 +1,17 @@
+import { FolioCliError } from "./errors.js";
+import { Result } from "better-result";
+//#region src/provenance.d.ts
+declare const AUTHOR_ENV = "FOLIO_AUTHOR";
+type ResolveAuthorOptions = {
+  /** `--author`, or the MCP server's configured author. */
+  explicit: string | undefined;
+  env: Readonly<Record<string, string | undefined>>;
+  /** Directory whose git configuration supplies the fallback. */
+  cwd: string;
+};
+/** `--author`, then `FOLIO_AUTHOR`, then git `user.name`; refuses when none is set. */
+declare const resolveAuthor: ({ explicit, env, cwd }: ResolveAuthorOptions) => Result<string, FolioCliError>;
+/** The transaction timestamp: `--date` when given (for reproducible output), else now. */
+declare const resolveTransactionDate: (explicit: string | undefined, now?: () => Date) => Result<string, FolioCliError>;
+//#endregion
+export { AUTHOR_ENV, resolveAuthor, resolveTransactionDate };

package/dist/provenance.js

@@ -0,0 +1,53 @@
+import { FOLIO_CLI_ERROR_CODES, cliError } from "./errors.js";
+import { Result } from "better-result";
+import { spawnSync } from "node:child_process";
+//#region src/provenance.ts
+/**
+* Who and when a transaction records. Every revision, comment, and reply a
+* transaction authors carries one author and one UTC timestamp; neither is
+* ever invented.
+*/
+const AUTHOR_ENV = "FOLIO_AUTHOR";
+const nonEmpty = (value) => {
+	const trimmed = value?.trim();
+	return trimmed === void 0 || trimmed === "" ? void 0 : trimmed;
+};
+const gitUserName = (cwd, env) => {
+	const childEnv = {};
+	for (const [key, value] of Object.entries(env)) if (value !== void 0) childEnv[key] = value;
+	const run = spawnSync("git", ["config", "user.name"], {
+		cwd,
+		env: childEnv,
+		encoding: "utf8",
+		timeout: 2e3,
+		stdio: [
+			"ignore",
+			"pipe",
+			"ignore"
+		]
+	});
+	return run.status === 0 ? nonEmpty(run.stdout) : void 0;
+};
+/** `--author`, then `FOLIO_AUTHOR`, then git `user.name`; refuses when none is set. */
+const resolveAuthor = ({ explicit, env, cwd }) => {
+	const author = nonEmpty(explicit) ?? nonEmpty(env["FOLIO_AUTHOR"]) ?? gitUserName(cwd, env);
+	return author === void 0 ? Result.err(cliError({
+		code: FOLIO_CLI_ERROR_CODES.authorRequired,
+		message: "No author is configured for this change.",
+		hint: `Pass --author, set ${AUTHOR_ENV}, or configure git user.name.`
+	})) : Result.ok(author);
+};
+/** An ISO-8601 UTC timestamp at second precision, as revision dates are written. */
+const toRevisionDate = (date) => date.toISOString().replace(/\.\d{3}Z$/u, "Z");
+/** The transaction timestamp: `--date` when given (for reproducible output), else now. */
+const resolveTransactionDate = (explicit, now = () => /* @__PURE__ */ new Date()) => {
+	if (explicit === void 0) return Result.ok(toRevisionDate(now()));
+	const parsed = new Date(explicit);
+	return Number.isNaN(parsed.getTime()) ? Result.err(cliError({
+		code: FOLIO_CLI_ERROR_CODES.usage,
+		message: `--date ${JSON.stringify(explicit)} is not an ISO-8601 date.`,
+		hint: "Use a form like 2026-01-31T09:00:00Z."
+	})) : Result.ok(toRevisionDate(parsed));
+};
+//#endregion
+export { AUTHOR_ENV, resolveAuthor, resolveTransactionDate };

package/dist/registry.d.ts

@@ -0,0 +1,69 @@
+import { FolioAgentToolName } from "@stll/folio-agents/types";
+//#region src/registry.d.ts
+type JsonObjectSchema = {
+  readonly type: "object";
+  readonly properties: Readonly<Record<string, unknown>>;
+  readonly required: readonly string[];
+  readonly additionalProperties: false;
+};
+/** A positional argument after `<file>` that sets one tool argument. */
+type FolioPositionalSpec = {
+  readonly name: string;
+  readonly property: string;
+};
+/** One `folio <name>` command. */
+type FolioCommandSpec = {
+  readonly name: string;
+  readonly summary: string;
+  /** Arguments the command implies (`accept` sets `action: "accept"`). */
+  readonly preset?: Readonly<Record<string, unknown>>;
+  /** Positionals after `<file>`, in order. */
+  readonly positionals?: readonly FolioPositionalSpec[];
+  /** Flag spellings that differ from the kebab-cased property (`ids` as `--id`). */
+  readonly flagNames?: Readonly<Record<string, string>>;
+  /** A bare JSON array passed to `--input` fills this property. */
+  readonly inputArrayProperty?: string;
+};
+type FolioToolSpecBase = {
+  readonly name: string;
+  readonly description: string;
+  /** The tool's own arguments, without the file envelope. */
+  readonly argsSchema: JsonObjectSchema;
+  readonly commands: readonly FolioCommandSpec[];
+};
+/**
+ * How a tool runs. `agentRead` and `agentWrite` run a `@stll/folio-agents`
+ * tool against one file (a write commits a transaction); `resolveChanges`
+ * accepts or rejects tracked changes; `compare` diffs two files and, given a
+ * destination, writes a redline.
+ */
+type FolioFileToolSpec = (FolioToolSpecBase & {
+  readonly type: "agentRead";
+  readonly agentTool: FolioAgentToolName;
+}) | (FolioToolSpecBase & {
+  readonly type: "agentWrite";
+  readonly agentTool: FolioAgentToolName;
+  /** Whether the caller may choose direct edits over tracked changes. */
+  readonly editMode: "tracked-or-direct" | "fixed";
+}) | (FolioToolSpecBase & {
+  readonly type: "resolveChanges";
+}) | (FolioToolSpecBase & {
+  readonly type: "compare";
+});
+/** Whether a tool call may write, which decides its envelope and flags. */
+type FolioToolAccess = "read" | "write" | "readOrWrite";
+declare const toolAccess: (tool: FolioFileToolSpec) => FolioToolAccess;
+/** Largest page `read_document` returns on any surface. */
+declare const MAX_READ_BLOCKS = 1000;
+declare const RESOLVE_CHANGE_ACTIONS: readonly ["accept", "reject"];
+type ResolveChangeAction = (typeof RESOLVE_CHANGE_ACTIONS)[number];
+declare const FOLIO_FILE_TOOLS: readonly FolioFileToolSpec[];
+declare const findFileTool: (name: string) => FolioFileToolSpec | undefined;
+type FolioResolvedCommand = {
+  tool: FolioFileToolSpec;
+  command: FolioCommandSpec;
+};
+declare const findCommand: (name: string) => FolioResolvedCommand | undefined;
+declare const listCommands: () => readonly FolioResolvedCommand[];
+//#endregion
+export { FOLIO_FILE_TOOLS, FolioCommandSpec, FolioFileToolSpec, FolioPositionalSpec, FolioResolvedCommand, FolioToolAccess, JsonObjectSchema, MAX_READ_BLOCKS, RESOLVE_CHANGE_ACTIONS, ResolveChangeAction, findCommand, findFileTool, listCommands, toolAccess };