@stll/folio-cli 0.5.2 → 0.5.4

package/dist/main-document-part.d.ts

@@ -2,7 +2,7 @@ import { FolioCliError } from "./errors.js";
 import { Result } from "better-result";
 //#region src/main-document-part.d.ts
 /** Why a file is not a readable WordprocessingML package. */
-declare const INVALID_PACKAGE_REASONS: {
+export declare const INVALID_PACKAGE_REASONS: {
   readonly notZip: "notZip";
   readonly duplicatePartName: "duplicatePartName";
   readonly contentTypesMissing: "contentTypesMissing";
@@ -16,11 +16,10 @@ declare const INVALID_PACKAGE_REASONS: {
   readonly mainPartRoot: "mainPartRoot";
   readonly mainPartLocation: "mainPartLocation";
 };
-type InvalidPackageReason = (typeof INVALID_PACKAGE_REASONS)[keyof typeof INVALID_PACKAGE_REASONS];
+export type InvalidPackageReason = (typeof INVALID_PACKAGE_REASONS)[keyof typeof INVALID_PACKAGE_REASONS];
 /**
  * Refuse, as `invalid_document`, a file that is not a WordprocessingML
  * package with a main document part folio reads.
  */
-declare const checkWordprocessingPackage: (filePath: string, bytes: Uint8Array) => Promise<Result<void, FolioCliError>>;
-//#endregion
-export { INVALID_PACKAGE_REASONS, InvalidPackageReason, checkWordprocessingPackage };
+export declare const checkWordprocessingPackage: (filePath: string, bytes: Uint8Array) => Promise<Result<void, FolioCliError>>;
+//#endregion

package/dist/main-document-part.js

@@ -39,9 +39,9 @@ const MAIN_DOCUMENT_CONTENT_TYPES = /* @__PURE__ */ new Set([
 	"application/vnd.ms-word.template.macroEnabledTemplate.main+xml"
 ]);
 /** `[Content_Types].xml` and `_rels/.rels` are indexes; this bounds their inflation. */
-const MAX_PACKAGE_INDEX_BYTES = 1024 * 1024;
+const MAX_PACKAGE_INDEX_BYTES = 1048576;
 /** How much of the main part is inflated to find its root element. */
-const MAX_ROOT_SCAN_BYTES = 64 * 1024;
+const MAX_ROOT_SCAN_BYTES = 65536;
 /** Why a file is not a readable WordprocessingML package. */
 const INVALID_PACKAGE_REASONS = {
 	notZip: "notZip",

package/dist/mcp-kit/envelope.d.ts

@@ -1,13 +1,13 @@
 import { ToolCallResult, ToolError, ToolInputIssue, ToolOutcome } from "./types.js";
 //#region src/mcp-kit/envelope.d.ts
 /** Error codes the surface itself answers with; a tool adds its own. */
-declare const KIT_ERROR_CODES: {
+export declare const KIT_ERROR_CODES: {
   readonly validation: "validation_error";
   readonly unknownTool: "unknown_tool";
   readonly notFound: "not_found";
   readonly internal: "internal_error";
 };
-declare const toolError: (error: {
+export declare const toolError: (error: {
   code: string;
   message: string;
   hint?: string | undefined;
@@ -15,13 +15,12 @@ declare const toolError: (error: {
   issues?: readonly ToolInputIssue[] | undefined;
   details?: unknown;
 }) => ToolError;
-declare const failure: (error: Parameters<typeof toolError>[0]) => ToolOutcome;
-declare const success: (value: unknown) => ToolOutcome;
-declare const validationError: (message: string, issues: readonly ToolInputIssue[], hint?: string) => ToolOutcome;
+export declare const failure: (error: Parameters<typeof toolError>[0]) => ToolOutcome;
+export declare const success: (value: unknown) => ToolOutcome;
+export declare const validationError: (message: string, issues: readonly ToolInputIssue[], hint?: string) => ToolOutcome;
 /** Encode an outcome as a `tools/call` result, with the input notes after a success. */
-declare const toCallResult: (outcome: ToolOutcome, notes?: readonly string[]) => ToolCallResult;
+export declare const toCallResult: (outcome: ToolOutcome, notes?: readonly string[]) => ToolCallResult;
 /** Up to three known names close to `name`, closest first. */
-declare const closestNames: (name: string, known: readonly string[]) => string[];
-declare const didYouMean: (suggestions: readonly string[]) => string;
-//#endregion
-export { KIT_ERROR_CODES, closestNames, didYouMean, failure, success, toCallResult, toolError, validationError };
+export declare const closestNames: (name: string, known: readonly string[]) => string[];
+export declare const didYouMean: (suggestions: readonly string[]) => string;
+//#endregion

package/dist/mcp-kit/envelope.js

@@ -1,4 +1,11 @@
+import { distance } from "@stll/fuzzy-search";
 //#region src/mcp-kit/envelope.ts
+/**
+* How answers go on the wire: a success is its JSON payload, a failure is
+* `{ "error": { code, message, hint, retryable } }` with `isError` set, and
+* any "read X as Y" notes from lenient input reading ride after the payload
+* as their own text block, so the payload stays the tool's contract.
+*/
 /** Error codes the surface itself answers with; a tool adds its own. */
 const KIT_ERROR_CODES = {
 	validation: "validation_error",
@@ -52,26 +59,14 @@ const toCallResult = (outcome, notes = []) => {
 		isError: false
 	};
 };
-const editDistance = (a, b) => {
-	let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
-	for (let i = 1; i <= a.length; i += 1) {
-		const current = [i];
-		for (let j = 1; j <= b.length; j += 1) {
-			const substitution = (previous[j - 1] ?? 0) + (a[i - 1] === b[j - 1] ? 0 : 1);
-			current[j] = Math.min((previous[j] ?? 0) + 1, (current[j - 1] ?? 0) + 1, substitution);
-		}
-		previous = current;
-	}
-	return previous[b.length] ?? 0;
-};
 /** Up to three known names close to `name`, closest first. */
 const closestNames = (name, known) => {
-	const lowered = name.toLowerCase();
+	const lowered = name.toWellFormed().toLowerCase();
 	return known.map((candidate) => {
-		const lower = candidate.toLowerCase();
+		const lower = candidate.toWellFormed().toLowerCase();
 		return {
 			candidate,
-			distance: lower.includes(lowered) || lowered.includes(lower) ? 0 : editDistance(lowered, lower)
+			distance: lower.includes(lowered) || lowered.includes(lower) ? 0 : distance(lowered, lower, "levenshtein")
 		};
 	}).filter(({ distance }) => distance <= Math.max(2, Math.floor(name.length / 3))).toSorted((a, b) => a.distance - b.distance || a.candidate.localeCompare(b.candidate)).slice(0, 3).map(({ candidate }) => candidate);
 };

package/dist/mcp-kit/input.d.ts

@@ -1,6 +1,6 @@
 import { JsonSchema, ToolAccess, ToolInputIssue } from "./types.js";
 //#region src/mcp-kit/input.d.ts
-type ReadInput = {
+export type ReadInput = {
   ok: true;
   value: Record<string, unknown>;
   notes: readonly string[];
@@ -18,6 +18,6 @@ type ReadInputOptions = {
   exactProperties?: readonly string[] | undefined;
 };
 /** Check and leniently read one call's arguments against the tool's schema. */
-declare const readToolInput: ({ schema, value, access, exactProperties }: ReadInputOptions) => ReadInput;
+export declare const readToolInput: ({ schema, value, access, exactProperties }: ReadInputOptions) => ReadInput;
 //#endregion
-export { ReadInput, readToolInput };
+export {};

package/dist/mcp-kit/schema.d.ts

@@ -1,20 +1,19 @@
 import { JsonSchema, ListedTool } from "./types.js";
 //#region src/mcp-kit/schema.d.ts
-type CompactSchemaOptions = {
+export type CompactSchemaOptions = {
   /** Keep descriptions this many property levels deep; 0 (the default) keeps none. */
   describedDepth?: number;
 };
 /** The schema without annotation keywords, descriptions kept only as deep as asked. */
-declare const compactSchema: (schema: JsonSchema, { describedDepth }?: CompactSchemaOptions) => JsonSchema;
+export declare const compactSchema: (schema: JsonSchema, { describedDepth }?: CompactSchemaOptions) => JsonSchema;
 /**
  * Hoist every object subschema that occurs more than once and serializes to
  * at least `minBytes` into `$defs`, referenced by `$ref`: a schema that
  * repeats one shape for several properties states it once.
  */
-declare const hoistRepeatedSchemas: (schema: JsonSchema, { minBytes }?: {
+export declare const hoistRepeatedSchemas: (schema: JsonSchema, { minBytes }?: {
   minBytes?: number;
 }) => JsonSchema;
 /** The UTF-8 size of what `tools/list` sends for these tools. */
-declare const advertisedBytes: (tools: readonly ListedTool[]) => number;
-//#endregion
-export { CompactSchemaOptions, advertisedBytes, compactSchema, hoistRepeatedSchemas };
+export declare const advertisedBytes: (tools: readonly ListedTool[]) => number;
+//#endregion

package/dist/mcp-kit/surface.d.ts

@@ -1,19 +1,18 @@
 import { ListedTool, ToolCallResult, ToolDefinition } from "./types.js";
 //#region src/mcp-kit/surface.d.ts
-declare const CAPABILITY_TOOL_NAMES: {
+export declare const CAPABILITY_TOOL_NAMES: {
   readonly list: "list_capabilities";
   readonly describe: "describe_capability";
   readonly invoke: "invoke_capability";
 };
-type ToolSurfaceOptions<Context> = {
+export type ToolSurfaceOptions<Context> = {
   readonly tools: readonly ToolDefinition<Context>[];
 };
-type ToolSurface<Context> = {
+export type ToolSurface<Context> = {
   /** What `tools/list` returns: the direct tools, then the capability tools. */
   readonly listTools: () => ListedTool[];
   readonly callTool: (name: string, args: unknown, context: Context) => Promise<ToolCallResult>;
 };
 /** Build a surface over `tools`. Names must be unique and not a capability tool's. */
-declare const createToolSurface: <Context>({ tools }: ToolSurfaceOptions<Context>) => ToolSurface<Context>;
-//#endregion
-export { CAPABILITY_TOOL_NAMES, ToolSurface, ToolSurfaceOptions, createToolSurface };
+export declare const createToolSurface: <Context>({ tools }: ToolSurfaceOptions<Context>) => ToolSurface<Context>;
+//#endregion

package/dist/mcp-kit/types.d.ts

@@ -6,13 +6,13 @@
  * JSON payload or one error shape.
  */
 /** A JSON Schema object, as plain JSON. */
-type JsonSchema = {
+export type JsonSchema = {
   readonly [keyword: string]: unknown;
 };
 /** Whether a call only reads or may change state. */
-type ToolAccess = "read" | "write";
+export type ToolAccess = "read" | "write";
 /** One problem with one input value. */
-type ToolInputIssue = {
+export type ToolInputIssue = {
   readonly path: string;
   readonly message: string;
 };
@@ -21,7 +21,7 @@ type ToolInputIssue = {
  * `hint` says what to do next, and `retryable` says whether the same call
  * can succeed once the caller has done it (re-read, waited).
  */
-type ToolError = {
+export type ToolError = {
   readonly code: string;
   readonly message: string;
   readonly hint?: string;
@@ -29,14 +29,14 @@ type ToolError = {
   readonly issues?: readonly ToolInputIssue[];
   readonly details?: unknown;
 };
-type ToolOutcome = {
+export type ToolOutcome = {
   readonly ok: true;
   readonly value: unknown;
 } | {
   readonly ok: false;
   readonly error: ToolError;
 };
-type ToolDefinition<Context> = {
+export type ToolDefinition<Context> = {
   readonly name: string;
   /** One short sentence. A direct tool sends it on every turn, so every word costs. */
   readonly summary: string;
@@ -73,7 +73,7 @@ type ToolDefinition<Context> = {
   readonly run: (args: Record<string, unknown>, context: Context) => Promise<ToolOutcome>;
 };
 /** A tool as `tools/list` advertises it. */
-type ListedTool = {
+export type ListedTool = {
   name: string;
   description: string;
   inputSchema: {
@@ -87,12 +87,11 @@ type ListedTool = {
   };
 };
 /** A `tools/call` answer: a JSON payload or `{ error }`, as text. */
-type ToolCallResult = {
+export type ToolCallResult = {
   content: {
     type: "text";
     text: string;
   }[];
   isError: boolean;
 };
-//#endregion
-export { JsonSchema, ListedTool, ToolAccess, ToolCallResult, ToolDefinition, ToolError, ToolInputIssue, ToolOutcome };
+//#endregion

package/dist/mcp.d.ts

@@ -5,8 +5,8 @@ import { Readable, Writable } from "node:stream";
 import { Server, Tool } from "@modelcontextprotocol/server";
 //#region src/mcp.d.ts
 /** Limits on what one MCP tool call returns. */
-declare const MCP_READ_BOUNDS: FolioReadBounds;
-type FolioMcpServerOptions = {
+export declare const MCP_READ_BOUNDS: FolioReadBounds;
+export type FolioMcpServerOptions = {
   roots: AllowedRoots;
   /** Author for every change; `undefined` refuses writes with `author_required`. */
   author: string | undefined;
@@ -14,21 +14,21 @@ type FolioMcpServerOptions = {
   now?: () => Date;
 };
 /** The tool's full MCP input schema: its own arguments plus the file envelope. */
-declare const mcpInputSchema: (tool: FolioFileToolSpec) => JsonObjectSchema;
+export declare const mcpInputSchema: (tool: FolioFileToolSpec) => JsonObjectSchema;
 /**
  * Blocks as lines, a table row on one line: `| [id] cell | [id] cell |`,
  * a cell's paragraphs side by side. Empty cells hold no block and show none.
  */
-declare const blockLines: (blocks: readonly unknown[]) => string;
+export declare const blockLines: (blocks: readonly unknown[]) => string;
 /** What `tools/list` returns. */
-declare const listMcpTools: () => Tool[];
+export declare const listMcpTools: () => Tool[];
 /** A low-level MCP server exposing the file tools; connect it to a transport. */
-declare const createFolioMcpServer: (options: FolioMcpServerOptions) => Server;
+export declare const createFolioMcpServer: (options: FolioMcpServerOptions) => Server;
 type ServeOptions = FolioMcpServerOptions & {
   input: Readable;
   output: Writable;
 };
 /** Serve the file tools over stdio until the client disconnects. */
-declare const serveFolioMcp: ({ input, output, ...options }: ServeOptions) => Promise<void>;
+export declare const serveFolioMcp: ({ input, output, ...options }: ServeOptions) => Promise<void>;
 //#endregion
-export { FolioMcpServerOptions, MCP_READ_BOUNDS, blockLines, createFolioMcpServer, listMcpTools, mcpInputSchema, serveFolioMcp };
+export {};

package/dist/mcp.js

@@ -10,9 +10,9 @@ import { checkWithinRoots } from "./roots.js";
 import { Result, panic } from "better-result";
 import { SUGGEST_CHANGES_OPERATION_TYPES, describeSuggestChangesCapabilities } from "@stll/folio-agents/tools";
 import { FOLIO_DOCUMENT_OPERATION_KEYS_BY_TYPE } from "@stll/folio-core/server";
-import { FOLIO_DOCUMENT_OPERATION_BATCH_JSON_SCHEMA } from "@stll/folio-agents/operation-schema";
 import { ProtocolError, ProtocolErrorCode, Server } from "@modelcontextprotocol/server";
 import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
+import { FOLIO_DOCUMENT_OPERATION_BATCH_JSON_SCHEMA } from "@stll/folio-agents/operation-schema";
 //#region src/mcp.ts
 /**
 * `folio mcp`: the file tool registry as a Model Context Protocol server over
@@ -32,7 +32,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
 const MCP_READ_BOUNDS = {
 	defaultMaxBlocks: 200,
 	maxMatches: 100,
-	maxResponseBytes: 256 * 1024
+	maxResponseBytes: 262144
 };
 const ABOUT_URI = "folio://about";
 const OPERATIONS_SCHEMA_URI = "folio://schema/operations";
@@ -521,7 +521,8 @@ const toOutcome = (options, result) => {
 		});
 	}
 	const data = recordOf(result.value);
-	return success("txId" in data ? compactWrite(options, data) : compactRead(options, data));
+	const wrote = "txId" in data;
+	return success(wrote ? compactWrite(options, data) : compactRead(options, data));
 };
 /** Fill in a main-story range's `type` and `story`, which find_text leaves out. */
 const withFullRanges = (operations) => Array.isArray(operations) ? operations.map((operation) => {

package/dist/output-file.d.ts

@@ -10,6 +10,6 @@ type WriteOutputOptions = {
   /** The document rendered, which the output must not replace. */
   input: FileIdentity;
 };
-declare const writeOutputFile: ({ target, bytes, overwrite, input }: WriteOutputOptions) => Promise<Result<string, FolioCliError>>;
+export declare const writeOutputFile: ({ target, bytes, overwrite, input }: WriteOutputOptions) => Promise<Result<string, FolioCliError>>;
 //#endregion
-export { writeOutputFile };
+export {};

package/dist/output.d.ts

@@ -1,24 +1,24 @@
 import { FolioCliError, FolioCliErrorCode, PublicErrorDetails } from "./errors.js";
 //#region src/output.d.ts
-declare const OUTPUT_FORMATS: readonly ["json", "text"];
-type OutputFormat = (typeof OUTPUT_FORMATS)[number];
-declare const isOutputFormat: (value: unknown) => value is OutputFormat;
-type FailureBody = {
+export declare const OUTPUT_FORMATS: readonly ["json", "text"];
+export type OutputFormat = (typeof OUTPUT_FORMATS)[number];
+export declare const isOutputFormat: (value: unknown) => value is OutputFormat;
+export type FailureBody = {
   code: FolioCliErrorCode;
   message: string;
   hint?: string;
   details?: PublicErrorDetails;
 };
-type Envelope = {
+export type Envelope = {
   ok: true;
   data: unknown;
 } | {
   ok: false;
   error: FailureBody;
 };
-declare const successEnvelope: (data: unknown) => Envelope;
-declare const failureEnvelope: ({ code, message, hint, details }: FolioCliError) => Envelope;
-type RenderedOutput = {
+export declare const successEnvelope: (data: unknown) => Envelope;
+export declare const failureEnvelope: ({ code, message, hint, details }: FolioCliError) => Envelope;
+export type RenderedOutput = {
   stdout: string;
   stderr: string;
 };
@@ -28,6 +28,6 @@ type RenderEnvelopeOptions = {
   /** The tool that produced the data, for its text rendering. */
   tool: string;
 };
-declare const renderEnvelope: ({ envelope, format, tool }: RenderEnvelopeOptions) => RenderedOutput;
+export declare const renderEnvelope: ({ envelope, format, tool }: RenderEnvelopeOptions) => RenderedOutput;
 //#endregion
-export { Envelope, FailureBody, OUTPUT_FORMATS, OutputFormat, RenderedOutput, failureEnvelope, isOutputFormat, renderEnvelope, successEnvelope };
+export {};

package/dist/package-parts.d.ts

@@ -1,18 +1,18 @@
 import { FolioCliError } from "./errors.js";
 import { Result } from "better-result";
 //#region src/package-parts.d.ts
-type PartChange = "added" | "modified" | "removed";
-type ChangedPart = {
+export type PartChange = "added" | "modified" | "removed";
+export type ChangedPart = {
   part: string;
   change: PartChange;
 };
 /** Parts added, removed, or whose uncompressed content differs, sorted by name. */
-declare const diffPackages: (before: Uint8Array, after: Uint8Array) => Promise<Result<ChangedPart[], FolioCliError>>;
+export declare const diffPackages: (before: Uint8Array, after: Uint8Array) => Promise<Result<ChangedPart[], FolioCliError>>;
 /**
  * The first revision id above every WordprocessingML `id` attribute in the
  * package, so new revisions never collide with an existing one.
  */
-declare const nextRevisionIdSeed: (bytes: Uint8Array) => Promise<Result<number, FolioCliError>>;
+export declare const nextRevisionIdSeed: (bytes: Uint8Array) => Promise<Result<number, FolioCliError>>;
 /**
  * Check what a save wrote before it replaces anything: the package opens,
  * every changed XML part is well formed, every relationship id a changed
@@ -20,6 +20,5 @@ declare const nextRevisionIdSeed: (bytes: Uint8Array) => Promise<Result<number,
  * names exists, the package still has the main document part folio reads,
  * and it parses as a document again.
  */
-declare const checkPackageIntegrity: (bytes: Uint8Array<ArrayBuffer>, changedParts: readonly ChangedPart[]) => Promise<Result<void, FolioCliError>>;
-//#endregion
-export { ChangedPart, PartChange, checkPackageIntegrity, diffPackages, nextRevisionIdSeed };
+export declare const checkPackageIntegrity: (bytes: Uint8Array<ArrayBuffer>, changedParts: readonly ChangedPart[]) => Promise<Result<void, FolioCliError>>;
+//#endregion

package/dist/package.js

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

package/dist/preview-commands.d.ts

@@ -1,8 +1,7 @@
 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 };
+export declare const RENDER_HELP: string;
+export declare const runRender: (rest: readonly string[], io: FolioCliIo) => Promise<number>;
+export declare const SERVE_HELP: string;
+export declare const runServe: (rest: readonly string[], io: FolioCliIo) => Promise<number>;
+//#endregion

package/dist/preview-commands.js

@@ -20,8 +20,9 @@ const usageError = (message, hint) => cliError({
 	hint
 });
 const emit = (io, format, result) => {
+	const envelope = result.isOk() ? successEnvelope(result.value) : failureEnvelope(result.error);
 	const rendered = renderEnvelope({
-		envelope: result.isOk() ? successEnvelope(result.value) : failureEnvelope(result.error),
+		envelope,
 		format,
 		tool: "render"
 	});

package/dist/provenance.d.ts

@@ -1,7 +1,7 @@
 import { FolioCliError } from "./errors.js";
 import { Result } from "better-result";
 //#region src/provenance.d.ts
-declare const AUTHOR_ENV = "FOLIO_AUTHOR";
+export declare const AUTHOR_ENV = "FOLIO_AUTHOR";
 type ResolveAuthorOptions = {
   /** `--author`, or the MCP server's configured author. */
   explicit: string | undefined;
@@ -10,8 +10,8 @@ type ResolveAuthorOptions = {
   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>;
+export 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>;
+export declare const resolveTransactionDate: (explicit: string | undefined, now?: () => Date) => Result<string, FolioCliError>;
 //#endregion
-export { AUTHOR_ENV, resolveAuthor, resolveTransactionDate };
+export {};

package/dist/registry.d.ts

@@ -1,18 +1,18 @@
 import { FolioAgentToolName } from "@stll/folio-agents/types";
 //#region src/registry.d.ts
-type JsonObjectSchema = {
+export 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 = {
+export type FolioPositionalSpec = {
   readonly name: string;
   readonly property: string;
 };
 /** One `folio <name>` command. */
-type FolioCommandSpec = {
+export type FolioCommandSpec = {
   readonly name: string;
   readonly summary: string;
   /** Arguments the command implies (`accept` sets `action: "accept"`). */
@@ -37,7 +37,7 @@ type FolioToolSpecBase = {
  * accepts or rejects tracked changes; `compare` diffs two files and, given a
  * destination, writes a redline.
  */
-type FolioFileToolSpec = (FolioToolSpecBase & {
+export type FolioFileToolSpec = (FolioToolSpecBase & {
   readonly type: "agentRead";
   readonly agentTool: FolioAgentToolName;
 }) | (FolioToolSpecBase & {
@@ -51,19 +51,19 @@ type FolioFileToolSpec = (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;
+export type FolioToolAccess = "read" | "write" | "readOrWrite";
+export 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 = {
+export declare const MAX_READ_BLOCKS = 1000;
+export declare const RESOLVE_CHANGE_ACTIONS: readonly ["accept", "reject"];
+export type ResolveChangeAction = (typeof RESOLVE_CHANGE_ACTIONS)[number];
+export declare const FOLIO_FILE_TOOLS: readonly FolioFileToolSpec[];
+export declare const findFileTool: (name: string) => FolioFileToolSpec | undefined;
+export type FolioResolvedCommand = {
   tool: FolioFileToolSpec;
   command: FolioCommandSpec;
 };
-declare const findCommand: (name: string) => FolioResolvedCommand | undefined;
-declare const listCommands: () => readonly FolioResolvedCommand[];
+export declare const findCommand: (name: string) => FolioResolvedCommand | undefined;
+export 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 };
+export {};

package/dist/render.d.ts

@@ -4,32 +4,32 @@ import { Result } from "better-result";
 import { DisplayList } from "@stll/folio-core/display-list/types";
 import { FontsourceFaces } from "@stll/folio-core/fonts/fontsourceFaces";
 //#region src/render.d.ts
-declare const RENDER_FORMATS: readonly ["pdf", "png", "html"];
-type RenderFormat = (typeof RENDER_FORMATS)[number];
+export declare const RENDER_FORMATS: readonly ["pdf", "png", "html"];
+export type RenderFormat = (typeof RENDER_FORMATS)[number];
 /** The CLI's `@fontsource` faces, shared by every render in the process. */
-declare const cliFontFaces: () => FontsourceFaces;
+export declare const cliFontFaces: () => FontsourceFaces;
 /** The document's display list, measured with the CLI's faces. */
-declare const buildDisplayList: (file: LoadedFile) => Promise<Result<DisplayList, FolioCliError>>;
+export declare const buildDisplayList: (file: LoadedFile) => Promise<Result<DisplayList, FolioCliError>>;
 /** Refuse page numbers the document does not have; `undefined` keeps every page. */
-declare const checkPages: (list: DisplayList, pages: readonly number[] | undefined) => Result<DisplayList, FolioCliError>;
+export declare const checkPages: (list: DisplayList, pages: readonly number[] | undefined) => Result<DisplayList, FolioCliError>;
 /** Standalone HTML for the list, with its faces inlined. */
-declare const displayListHtml: (list: DisplayList, title: string) => string;
+export declare const displayListHtml: (list: DisplayList, title: string) => string;
 type RenderPdfOptions = {
   file: LoadedFile;
   pages: readonly number[] | undefined;
   timestamp: string;
 };
-type RenderedOutput = {
+export type RenderedOutput = {
   bytes: Uint8Array;
   pageCount: number;
 };
-declare const renderPdf: ({ file, pages, timestamp }: RenderPdfOptions) => Promise<Result<RenderedOutput, FolioCliError>>;
+export declare const renderPdf: ({ file, pages, timestamp }: RenderPdfOptions) => Promise<Result<RenderedOutput, FolioCliError>>;
 type RenderPngOptions = {
   file: LoadedFile;
   page: number;
   scale: number;
 };
 /** One page as a PNG: the DOM backend's page, screenshotted in headless Chromium. */
-declare const renderPng: ({ file, page, scale }: RenderPngOptions) => Promise<Result<RenderedOutput, FolioCliError>>;
+export declare const renderPng: ({ file, page, scale }: RenderPngOptions) => Promise<Result<RenderedOutput, FolioCliError>>;
 //#endregion
-export { RENDER_FORMATS, RenderFormat, RenderedOutput, buildDisplayList, checkPages, cliFontFaces, displayListHtml, renderPdf, renderPng };
+export {};

package/dist/render.js

@@ -3,8 +3,8 @@ import { createRequire } from "node:module";
 import { Result } from "better-result";
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
-import { selectDisplayPages } from "@stll/folio-core/display-list/selectDisplayPages";
 import { renderDisplayListToHtml } from "@stll/folio-core/display-list/html/renderDisplayListToHtml";
+import { selectDisplayPages } from "@stll/folio-core/display-list/selectDisplayPages";
 import { buildDocxDisplayList, writeDisplayListPdf } from "@stll/folio-core/export-pdf";
 import { createFontsourceFaces } from "@stll/folio-core/fonts/fontsourceFaces";
 //#region src/render.ts

package/dist/roots.d.ts

@@ -2,9 +2,9 @@ import { FolioCliError } from "./errors.js";
 import { Result } from "better-result";
 //#region src/roots.d.ts
 /** Real paths of the allowed root directories. */
-type AllowedRoots = readonly string[];
+export type AllowedRoots = readonly string[];
 /** Resolve each root to its real path; every root must be an existing directory. */
-declare const resolveRoots: (roots: readonly string[]) => Promise<Result<AllowedRoots, FolioCliError>>;
+export declare const resolveRoots: (roots: readonly string[]) => Promise<Result<AllowedRoots, FolioCliError>>;
 type CheckWithinRootsOptions = {
   roots: AllowedRoots;
   /** As the caller passed it; a relative path resolves against the first root. */
@@ -16,6 +16,6 @@ type CheckWithinRootsOptions = {
  * Refuse a path outside every allowed root, returning the resolved path the
  * call should use.
  */
-declare const checkWithinRoots: ({ roots, target, argument }: CheckWithinRootsOptions) => Promise<Result<string, FolioCliError>>;
+export declare const checkWithinRoots: ({ roots, target, argument }: CheckWithinRootsOptions) => Promise<Result<string, FolioCliError>>;
 //#endregion
-export { AllowedRoots, checkWithinRoots, resolveRoots };
+export {};

package/dist/save.d.ts

@@ -5,9 +5,9 @@ import "./execute-write.js";
 import { Result } from "better-result";
 //#region src/save.d.ts
 /** How the editor produced the bytes, as it reports it. */
-declare const EDITOR_SAVE_STRATEGIES: readonly ["selective", "full-repack", "unspecified"];
-type EditorSaveStrategy = (typeof EDITOR_SAVE_STRATEGIES)[number];
-type SaveDocumentOptions = {
+export declare const EDITOR_SAVE_STRATEGIES: readonly ["selective", "full-repack", "unspecified"];
+export type EditorSaveStrategy = (typeof EDITOR_SAVE_STRATEGIES)[number];
+export type SaveDocumentOptions = {
   /** The document the editor opened. */
   path: string;
   /** The whole package the editor serialized. */
@@ -39,10 +39,9 @@ type SaveDocumentOptions = {
  * `expectedVersion`, a lease another live holder keeps, bytes that do not
  * open as a document, and anything over 64 MiB, writing nothing.
  */
-declare const saveDocumentBytes: (options: SaveDocumentOptions) => Promise<Result<Readonly<Record<string, unknown>>, FolioCliError>>;
-declare const SAVE_HELP: string;
+export declare const saveDocumentBytes: (options: SaveDocumentOptions) => Promise<Result<Readonly<Record<string, unknown>>, FolioCliError>>;
+export declare const SAVE_HELP: string;
 /** `--flush-wait <ms>`: a whole number of milliseconds from 0. */
-declare const parseFlushWait: (value: string | undefined) => Result<number | undefined, FolioCliError>;
-declare const runSave: (rest: readonly string[], io: FolioCliIo) => Promise<number>;
-//#endregion
-export { EDITOR_SAVE_STRATEGIES, EditorSaveStrategy, SAVE_HELP, SaveDocumentOptions, parseFlushWait, runSave, saveDocumentBytes };
+export declare const parseFlushWait: (value: string | undefined) => Result<number | undefined, FolioCliError>;
+export declare const runSave: (rest: readonly string[], io: FolioCliIo) => Promise<number>;
+//#endregion